text:
// NOTE: This file was generated by the ServiceGenerator.

// ----------------------------------------------------------------------------
// API:
//   Google Spectrum Database API (spectrum/v1explorer)
// Description:
//   API for spectrum-management functions.
// Documentation:
//   http://developers.google.com/spectrum

#if GTLR_BUILT_AS_FRAMEWORK
  #import "GTLR/GTLRObject.h"
#else
  #import "GTLRObject.h"
#endif

#if GTLR_RUNTIME_VERSION != 3000
#error This file was generated by a different version of ServiceGenerator which is incompatible with this GTLR library source.
#endif

@class GTLRSpectrum_AntennaCharacteristics;
@class GTLRSpectrum_DatabaseSpec;
@class GTLRSpectrum_DbUpdateSpec;
@class GTLRSpectrum_DeviceCapabilities;
@class GTLRSpectrum_DeviceDescriptor;
@class GTLRSpectrum_DeviceOwner;
@class GTLRSpectrum_DeviceValidity;
@class GTLRSpectrum_EventTime;
@class GTLRSpectrum_FrequencyRange;
@class GTLRSpectrum_GeoLocation;
@class GTLRSpectrum_GeoLocationEllipse;
@class GTLRSpectrum_GeoLocationPoint;
@class GTLRSpectrum_GeoLocationPolygon;
@class GTLRSpectrum_GeoSpectrumSchedule;
@class GTLRSpectrum_Message;
@class GTLRSpectrum_RulesetInfo;
@class GTLRSpectrum_Schedule;
@class GTLRSpectrum_Vcard;
@class GTLRSpectrum_VcardAddress;
@class GTLRSpectrum_VcardTelephone;
@class GTLRSpectrum_VcardTypedText;

NS_ASSUME_NONNULL_BEGIN

/**
 *  Antenna characteristics provide additional information, such as the antenna
 *  height, antenna type, etc. Whether antenna characteristics must be provided
 *  in a request depends on the device type and regulatory domain.
 */
@interface GTLRSpectrum_AntennaCharacteristics : GTLRObject

/**
 *  The antenna height in meters. Whether the antenna height is required depends
 *  on the device type and the regulatory domain. Note that the height may be
 *  negative.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *height;

/**
 *  If the height is required, then the height type (AGL for above ground level
 *  or AMSL for above mean sea level) is also required. The default is AGL.
 */
@property(copy, nullable) NSString *heightType;

/**
 *  The height uncertainty in meters. Whether this is required depends on the
 *  regulatory domain.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *heightUncertainty;

@end

/**
 *  This message contains the name and URI of a database.
 */
@interface GTLRSpectrum_DatabaseSpec : GTLRObject

/** The display name for a database. */
@property(copy, nullable) NSString *name;

/** The corresponding URI of the database. */
@property(copy, nullable) NSString *uri;

@end

/**
 *  This message is provided by the database to notify devices of an upcoming
 *  change to the database URI.
 */
@interface GTLRSpectrum_DbUpdateSpec : GTLRObject

/**
 *  A required list of one or more databases. A device should update its
 *  preconfigured list of databases to replace (only) the database that provided
 *  the response with the specified entries.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_DatabaseSpec *> *databases;

@end

/**
 *  Device capabilities provide additional information that may be used by a
 *  device to provide additional information to the database that may help it to
 *  determine available spectrum. If the database does not support device
 *  capabilities it will ignore the parameter altogether.
 */
@interface GTLRSpectrum_DeviceCapabilities : GTLRObject

/**
 *  An optional list of frequency ranges supported by the device. Each element
 *  must contain start and stop frequencies in which the device can operate.
 *  Channel identifiers are optional. When specified, the database should not
 *  return available spectrum that falls outside these ranges or channel IDs.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_FrequencyRange *> *frequencyRanges;

@end

/**
 *  The device descriptor contains parameters that identify the specific device,
 *  such as its manufacturer serial number, regulatory-specific identifier
 *  (e.g., FCC ID), and any other device characteristics required by regulatory
 *  domains.
 */
@interface GTLRSpectrum_DeviceDescriptor : GTLRObject

/**
 *  Specifies the ETSI white space device category. Valid values are the strings
 *  master and slave. This field is case-insensitive. Consult the ETSI
 *  documentation for details about the device types.
 */
@property(copy, nullable) NSString *etsiEnDeviceCategory;

/**
 *  Specifies the ETSI white space device emissions class. The values are
 *  represented by numeric strings, such as 1, 2, etc. Consult the ETSI
 *  documentation for details about the device types.
 */
@property(copy, nullable) NSString *etsiEnDeviceEmissionsClass;

/**
 *  Specifies the ETSI white space device type. Valid values are single-letter
 *  strings, such as A, B, etc. Consult the ETSI documentation for details about
 *  the device types.
 */
@property(copy, nullable) NSString *etsiEnDeviceType;

/**
 *  Specifies the ETSI white space device technology identifier. The string
 *  value must not exceed 64 characters in length. Consult the ETSI
 *  documentation for details about the device types.
 */
@property(copy, nullable) NSString *etsiEnTechnologyId;

/**
 *  Specifies the device's FCC certification identifier. The value is an
 *  identifier string whose length should not exceed 32 characters. Note that,
 *  in practice, a valid FCC ID may be limited to 19 characters.
 */
@property(copy, nullable) NSString *fccId;

/**
 *  Specifies the TV Band White Space device type, as defined by the FCC. Valid
 *  values are FIXED, MODE_1, MODE_2.
 */
@property(copy, nullable) NSString *fccTvbdDeviceType;

/**
 *  The manufacturer's ID may be required by the regulatory domain. This should
 *  represent the name of the device manufacturer, should be consistent across
 *  all devices from the same manufacturer, and should be distinct from that of
 *  other manufacturers. The string value must not exceed 64 characters in
 *  length.
 */
@property(copy, nullable) NSString *manufacturerId;

/**
 *  The device's model ID may be required by the regulatory domain. The string
 *  value must not exceed 64 characters in length.
 */
@property(copy, nullable) NSString *modelId;

/**
 *  The list of identifiers for rulesets supported by the device. A database may
 *  require that the device provide this list before servicing the device
 *  requests. If the database does not support any of the rulesets specified in
 *  the list, the database may refuse to service the device requests. If
 *  present, the list must contain at least one entry.
 *  For information about the valid requests, see section 9.2 of the PAWS
 *  specification. Currently, FccTvBandWhiteSpace-2010 is the only supported
 *  ruleset.
 */
@property(strong, nullable) NSArray<NSString *> *rulesetIds;

/**
 *  The manufacturer's device serial number; required by the applicable
 *  regulatory domain. The length of the value must not exceed 64 characters.
 */
@property(copy, nullable) NSString *serialNumber;

@end

/**
 *  This parameter contains device-owner information required as part of device
 *  registration. The regulatory domains may require additional parameters.
 *  All contact information must be expressed using the structure defined by the
 *  vCard format specification. Only the contact fields of vCard are supported:
 *  - fn: Full name of an individual
 *  - org: Name of the organization
 *  - adr: Address fields
 *  - tel: Telephone numbers
 *  - email: Email addresses
 *  Note that the vCard specification defines maximum lengths for each field.
 */
@interface GTLRSpectrum_DeviceOwner : GTLRObject

/**
 *  The vCard contact information for the device operator is optional, but may
 *  be required by specific regulatory domains.
 *
 *  Remapped to 'operatorProperty' to avoid language reserved word 'operator'.
 */
@property(strong, nullable) GTLRSpectrum_Vcard *operatorProperty;

/**
 *  The vCard contact information for the individual or business that owns the
 *  device is required.
 */
@property(strong, nullable) GTLRSpectrum_Vcard *owner;

@end

/**
 *  The device validity element describes whether a particular device is valid
 *  to operate in the regulatory domain.
 */
@interface GTLRSpectrum_DeviceValidity : GTLRObject

/**
 *  The descriptor of the device for which the validity check was requested. It
 *  will always be present.
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/**
 *  The validity status: true if the device is valid for operation, false
 *  otherwise. It will always be present.
 *
 *  Uses NSNumber of boolValue.
 */
@property(strong, nullable) NSNumber *isValid;

/**
 *  If the device identifier is not valid, the database may include a reason.
 *  The reason may be in any language. The length of the value should not exceed
 *  128 characters.
 */
@property(copy, nullable) NSString *reason;

@end

/**
 *  The start and stop times of an event. This is used to indicate the time
 *  period for which a spectrum profile is valid.
 *  Both times are expressed using the format, YYYY-MM-DDThh:mm:ssZ, as defined
 *  in RFC3339. The times must be expressed using UTC.
 */
@interface GTLRSpectrum_EventTime : GTLRObject

/** The inclusive start of the event. It will be present. */
@property(copy, nullable) NSString *startTime;

/** The exclusive end of the event. It will be present. */
@property(copy, nullable) NSString *stopTime;

@end

/**
 *  A specific range of frequencies together with the associated maximum power
 *  level and channel identifier.
 */
@interface GTLRSpectrum_FrequencyRange : GTLRObject

/**
 *  The database may include a channel identifier, when applicable. When it is
 *  included, the device should treat it as informative. The length of the
 *  identifier should not exceed 16 characters.
 */
@property(copy, nullable) NSString *channelId;

/**
 *  The maximum total power level (EIRP)—computed over the corresponding
 *  operating bandwidth—that is permitted within the frequency range. Depending
 *  on the context in which the frequency-range element appears, this value may
 *  be required. For example, it is required in the available-spectrum response,
 *  available-spectrum-batch response, and spectrum-use notification message,
 *  but it should not be present (it is not applicable) when the frequency range
 *  appears inside a device-capabilities message.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *maxPowerDBm;

/**
 *  The required inclusive start of the frequency range (in Hertz).
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *startHz;

/**
 *  The required exclusive end of the frequency range (in Hertz).
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *stopHz;

@end

/**
 *  This parameter is used to specify the geolocation of the device.
 */
@interface GTLRSpectrum_GeoLocation : GTLRObject

/**
 *  The location confidence level, as an integer percentage, may be required,
 *  depending on the regulatory domain. When the parameter is optional and not
 *  provided, its value is assumed to be 95. Valid values range from 0 to 99,
 *  since, in practice, 100-percent confidence is not achievable. The confidence
 *  value is meaningful only when geolocation refers to a point with
 *  uncertainty.
 *
 *  Uses NSNumber of intValue.
 */
@property(strong, nullable) NSNumber *confidence;

/**
 *  If present, indicates that the geolocation represents a point.
 *  Paradoxically, a point is parameterized using an ellipse, where the center
 *  represents the location of the point and the distances along the major and
 *  minor axes represent the uncertainty. The uncertainty values may be
 *  required, depending on the regulatory domain.
 */
@property(strong, nullable) GTLRSpectrum_GeoLocationEllipse *point;

/**
 *  If present, indicates that the geolocation represents a region. Database
 *  support for regions is optional.
 */
@property(strong, nullable) GTLRSpectrum_GeoLocationPolygon *region;

@end

/**
 *  A "point" with uncertainty is represented using the Ellipse shape.
 */
@interface GTLRSpectrum_GeoLocationEllipse : GTLRObject

/** A required geo-spatial point representing the center of the ellipse. */
@property(strong, nullable) GTLRSpectrum_GeoLocationPoint *center;

/**
 *  A floating-point number that expresses the orientation of the ellipse,
 *  representing the rotation, in degrees, of the semi-major axis from North
 *  towards the East. For example, when the uncertainty is greatest along the
 *  North-South direction, orientation is 0 degrees; conversely, if the
 *  uncertainty is greatest along the East-West direction, orientation is 90
 *  degrees. When orientation is not present, the orientation is assumed to be
 *  0.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *orientation;

/**
 *  A floating-point number that expresses the location uncertainty along the
 *  major axis of the ellipse. May be required by the regulatory domain. When
 *  the uncertainty is optional, the default value is 0.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *semiMajorAxis;

/**
 *  A floating-point number that expresses the location uncertainty along the
 *  minor axis of the ellipse. May be required by the regulatory domain. When
 *  the uncertainty is optional, the default value is 0.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *semiMinorAxis;

@end

/**
 *  A single geolocation on the globe.
 */
@interface GTLRSpectrum_GeoLocationPoint : GTLRObject

/**
 *  A required floating-point number that expresses the latitude in degrees
 *  using the WGS84 datum. For details on this encoding, see the National
 *  Imagery and Mapping Agency's Technical Report TR8350.2.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *latitude;

/**
 *  A required floating-point number that expresses the longitude in degrees
 *  using the WGS84 datum. For details on this encoding, see the National
 *  Imagery and Mapping Agency's Technical Report TR8350.2.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *longitude;

@end

/**
 *  A region is represented using the polygonal shape.
 */
@interface GTLRSpectrum_GeoLocationPolygon : GTLRObject

/**
 *  When the geolocation describes a region, the exterior field refers to a list
 *  of latitude/longitude points that represent the vertices of a polygon. The
 *  first and last points must be the same. Thus, a minimum of four points is
 *  required. The following polygon restrictions from RFC5491 apply:
 *  - A connecting line shall not cross another connecting line of the same
 *  polygon.
 *  - The vertices must be defined in a counterclockwise order.
 *  - The edges of a polygon are defined by the shortest path between two points
 *  in space (not a geodesic curve). Consequently, the length between two
 *  adjacent vertices should be restricted to a maximum of 130 km.
 *  - All vertices are assumed to be at the same altitude.
 *  - Polygon shapes should be restricted to a maximum of 15 vertices (16 points
 *  that include the repeated vertex).
 */
@property(strong, nullable) NSArray<GTLRSpectrum_GeoLocationPoint *> *exterior;

@end

/**
 *  The schedule of spectrum profiles available at a particular geolocation.
 */
@interface GTLRSpectrum_GeoSpectrumSchedule : GTLRObject

/**
 *  The geolocation identifies the location at which the spectrum schedule
 *  applies. It will always be present.
 */
@property(strong, nullable) GTLRSpectrum_GeoLocation *location;

/**
 *  A list of available spectrum profiles and associated times. It will always
 *  be present, and at least one schedule must be included (though it may be
 *  empty if there is no available spectrum). More than one schedule may be
 *  included to represent future changes to the available spectrum.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_Schedule *> *spectrumSchedules;

@end

/**
 *  Available spectrum can be logically characterized by a list of frequency
 *  ranges and permissible power levels for each range.
 */
@interface GTLRSpectrum_Message : GTLRObject

/**
 *  The bandwidth (in Hertz) for which permissible power levels are specified.
 *  For example, FCC regulation would require only one spectrum specification at
 *  6MHz bandwidth, but Ofcom regulation would require two specifications, at
 *  0.1MHz and 8MHz. This parameter may be empty if there is no available
 *  spectrum. It will be present otherwise.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *bandwidth;

/**
 *  The list of frequency ranges and permissible power levels. The list may be
 *  empty if there is no available spectrum, otherwise it will be present.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_FrequencyRange *> *frequencyRanges;

@end

/**
 *  The request message for a batch available spectrum query protocol.
 */
@interface GTLRSpectrum_PawsGetSpectrumBatchRequest : GTLRObject

/**
 *  Depending on device type and regulatory domain, antenna characteristics may
 *  be required.
 */
@property(strong, nullable) GTLRSpectrum_AntennaCharacteristics *antenna;

/**
 *  The master device may include its device capabilities to limit the
 *  available-spectrum batch response to the spectrum that is compatible with
 *  its capabilities. The database should not return spectrum that is
 *  incompatible with the specified capabilities.
 */
@property(strong, nullable) GTLRSpectrum_DeviceCapabilities *capabilities;

/**
 *  When the available spectrum request is made on behalf of a specific device
 *  (a master or slave device), device descriptor information for the device on
 *  whose behalf the request is made is required (in such cases, the requestType
 *  parameter must be empty). When a requestType value is specified, device
 *  descriptor information may be optional or required according to the rules of
 *  the applicable regulatory domain.
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/**
 *  A geolocation list is required. This allows a device to specify its current
 *  location plus additional anticipated locations when allowed by the
 *  regulatory domain. At least one location must be included. Geolocation must
 *  be given as the location of the radiation center of the device's antenna. If
 *  a location specifies a region, rather than a point, the database may return
 *  an UNIMPLEMENTED error if it does not support query by region.
 *  There is no upper limit on the number of locations included in a available
 *  spectrum batch request, but the database may restrict the number of
 *  locations it supports by returning a response with fewer locations than
 *  specified in the batch request. Note that geolocations must be those of the
 *  master device (a device with geolocation capability that makes an available
 *  spectrum batch request), whether the master device is making the request on
 *  its own behalf or on behalf of a slave device (one without geolocation
 *  capability).
 */
@property(strong, nullable) NSArray<GTLRSpectrum_GeoLocation *> *locations;

/**
 *  When an available spectrum batch request is made by the master device (a
 *  device with geolocation capability) on behalf of a slave device (a device
 *  without geolocation capability), the rules of the applicable regulatory
 *  domain may require the master device to provide its own device descriptor
 *  information (in addition to device descriptor information for the slave
 *  device in a separate parameter).
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *masterDeviceDesc;

/**
 *  Depending on device type and regulatory domain, device owner information may
 *  be included in an available spectrum batch request. This allows the device
 *  to register and get spectrum-availability information in a single request.
 */
@property(strong, nullable) GTLRSpectrum_DeviceOwner *owner;

/**
 *  The request type parameter is an optional parameter that can be used to
 *  modify an available spectrum batch request, but its use depends on
 *  applicable regulatory rules. For example, It may be used to request generic
 *  slave device parameters without having to specify the device descriptor for
 *  a specific device. When the requestType parameter is missing, the request is
 *  for a specific device (master or slave), and the device descriptor parameter
 *  for the device on whose behalf the batch request is made is required.
 */
@property(copy, nullable) NSString *requestType;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The response message for the batch available spectrum query contains a
 *  schedule of available spectrum for the device at multiple locations.
 */
@interface GTLRSpectrum_PawsGetSpectrumBatchResponse : GTLRObject

/**
 *  A database may include the databaseChange parameter to notify a device of a
 *  change to its database URI, providing one or more alternate database URIs.
 *  The device should use this information to update its list of pre-configured
 *  databases by (only) replacing its entry for the responding database with the
 *  list of alternate URIs.
 */
@property(strong, nullable) GTLRSpectrum_DbUpdateSpec *databaseChange;

/**
 *  The database must return in its available spectrum response the device
 *  descriptor information it received in the master device's available spectrum
 *  batch request.
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/**
 *  The available spectrum batch response must contain a geo-spectrum schedule
 *  list, The list may be empty if spectrum is not available. The database may
 *  return more than one geo-spectrum schedule to represent future changes to
 *  the available spectrum. How far in advance a schedule may be provided
 *  depends upon the applicable regulatory domain. The database may return
 *  available spectrum for fewer geolocations than requested. The device must
 *  not make assumptions about the order of the entries in the list, and must
 *  use the geolocation value in each geo-spectrum schedule entry to match
 *  available spectrum to a location.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_GeoSpectrumSchedule *> *geoSpectrumSchedules;

/**
 *  Identifies what kind of resource this is. Value: the fixed string
 *  "spectrum#pawsGetSpectrumBatchResponse".
 */
@property(copy, nullable) NSString *kind;

/**
 *  The database may return a constraint on the allowed maximum contiguous
 *  bandwidth (in Hertz). A regulatory domain may require the database to return
 *  this parameter. When this parameter is present in the response, the device
 *  must apply this constraint to its spectrum-selection logic to ensure that no
 *  single block of spectrum has bandwidth that exceeds this value.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *maxContiguousBwHz;

/**
 *  The database may return a constraint on the allowed maximum total bandwidth
 *  (in Hertz), which does not need to be contiguous. A regulatory domain may
 *  require the database to return this parameter. When this parameter is
 *  present in the available spectrum batch response, the device must apply this
 *  constraint to its spectrum-selection logic to ensure that total bandwidth
 *  does not exceed this value.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *maxTotalBwHz;

/**
 *  For regulatory domains that require a spectrum-usage report from devices,
 *  the database must return true for this parameter if the geo-spectrum
 *  schedules list is not empty; otherwise, the database should either return
 *  false or omit this parameter. If this parameter is present and its value is
 *  true, the device must send a spectrum use notify message to the database;
 *  otherwise, the device should not send the notification.
 *
 *  Uses NSNumber of boolValue.
 */
@property(strong, nullable) NSNumber *needsSpectrumReport;

/**
 *  The database should return ruleset information, which identifies the
 *  applicable regulatory authority and ruleset for the available spectrum batch
 *  response. If included, the device must use the corresponding ruleset to
 *  interpret the response. Values provided in the returned ruleset information,
 *  such as maxLocationChange, take precedence over any conflicting values
 *  provided in the ruleset information returned in a prior initialization
 *  response sent by the database to the device.
 */
@property(strong, nullable) GTLRSpectrum_RulesetInfo *rulesetInfo;

/**
 *  The database includes a timestamp of the form, YYYY-MM-DDThh:mm:ssZ
 *  (Internet timestamp format per RFC3339), in its available spectrum batch
 *  response. The timestamp should be used by the device as a reference for the
 *  start and stop times specified in the response spectrum schedules.
 */
@property(copy, nullable) NSString *timestamp;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The request message for the available spectrum query protocol which must
 *  include the device's geolocation.
 */
@interface GTLRSpectrum_PawsGetSpectrumRequest : GTLRObject

/**
 *  Depending on device type and regulatory domain, the characteristics of the
 *  antenna may be required.
 */
@property(strong, nullable) GTLRSpectrum_AntennaCharacteristics *antenna;

/**
 *  The master device may include its device capabilities to limit the
 *  available-spectrum response to the spectrum that is compatible with its
 *  capabilities. The database should not return spectrum that is incompatible
 *  with the specified capabilities.
 */
@property(strong, nullable) GTLRSpectrum_DeviceCapabilities *capabilities;

/**
 *  When the available spectrum request is made on behalf of a specific device
 *  (a master or slave device), device descriptor information for that device is
 *  required (in such cases, the requestType parameter must be empty). When a
 *  requestType value is specified, device descriptor information may be
 *  optional or required according to the rules of the applicable regulatory
 *  domain.
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/**
 *  The geolocation of the master device (a device with geolocation capability
 *  that makes an available spectrum request) is required whether the master
 *  device is making the request on its own behalf or on behalf of a slave
 *  device (one without geolocation capability). The location must be the
 *  location of the radiation center of the master device's antenna. To support
 *  mobile devices, a regulatory domain may allow the anticipated position of
 *  the master device to be given instead. If the location specifies a region,
 *  rather than a point, the database may return an UNIMPLEMENTED error code if
 *  it does not support query by region.
 */
@property(strong, nullable) GTLRSpectrum_GeoLocation *location;

/**
 *  When an available spectrum request is made by the master device (a device
 *  with geolocation capability) on behalf of a slave device (a device without
 *  geolocation capability), the rules of the applicable regulatory domain may
 *  require the master device to provide its own device descriptor information
 *  (in addition to device descriptor information for the slave device, which is
 *  provided in a separate parameter).
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *masterDeviceDesc;

/**
 *  Depending on device type and regulatory domain, device owner information may
 *  be included in an available spectrum request. This allows the device to
 *  register and get spectrum-availability information in a single request.
 */
@property(strong, nullable) GTLRSpectrum_DeviceOwner *owner;

/**
 *  The request type parameter is an optional parameter that can be used to
 *  modify an available spectrum request, but its use depends on applicable
 *  regulatory rules. It may be used, for example, to request generic slave
 *  device parameters without having to specify the device descriptor for a
 *  specific device. When the requestType parameter is missing, the request is
 *  for a specific device (master or slave), and the deviceDesc parameter for
 *  the device on whose behalf the request is made is required.
 */
@property(copy, nullable) NSString *requestType;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The response message for the available spectrum query which contains a
 *  schedule of available spectrum for the device.
 */
@interface GTLRSpectrum_PawsGetSpectrumResponse : GTLRObject

/**
 *  A database may include the databaseChange parameter to notify a device of a
 *  change to its database URI, providing one or more alternate database URIs.
 *  The device should use this information to update its list of pre-configured
 *  databases by (only) replacing its entry for the responding database with the
 *  list of alternate URIs.
 */
@property(strong, nullable) GTLRSpectrum_DbUpdateSpec *databaseChange;

/**
 *  The database must return, in its available spectrum response, the device
 *  descriptor information it received in the master device's available spectrum
 *  request.
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/**
 *  Identifies what kind of resource this is. Value: the fixed string
 *  "spectrum#pawsGetSpectrumResponse".
 */
@property(copy, nullable) NSString *kind;

/**
 *  The database may return a constraint on the allowed maximum contiguous
 *  bandwidth (in Hertz). A regulatory domain may require the database to return
 *  this parameter. When this parameter is present in the response, the device
 *  must apply this constraint to its spectrum-selection logic to ensure that no
 *  single block of spectrum has bandwidth that exceeds this value.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *maxContiguousBwHz;

/**
 *  The database may return a constraint on the allowed maximum total bandwidth
 *  (in Hertz), which need not be contiguous. A regulatory domain may require
 *  the database to return this parameter. When this parameter is present in the
 *  available spectrum response, the device must apply this constraint to its
 *  spectrum-selection logic to ensure that total bandwidth does not exceed this
 *  value.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *maxTotalBwHz;

/**
 *  For regulatory domains that require a spectrum-usage report from devices,
 *  the database must return true for this parameter if the spectrum schedule
 *  list is not empty; otherwise, the database will either return false or omit
 *  this parameter. If this parameter is present and its value is true, the
 *  device must send a spectrum use notify message to the database; otherwise,
 *  the device must not send the notification.
 *
 *  Uses NSNumber of boolValue.
 */
@property(strong, nullable) NSNumber *needsSpectrumReport;

/**
 *  The database should return ruleset information, which identifies the
 *  applicable regulatory authority and ruleset for the available spectrum
 *  response. If included, the device must use the corresponding ruleset to
 *  interpret the response. Values provided in the returned ruleset information,
 *  such as maxLocationChange, take precedence over any conflicting values
 *  provided in the ruleset information returned in a prior initialization
 *  response sent by the database to the device.
 */
@property(strong, nullable) GTLRSpectrum_RulesetInfo *rulesetInfo;

/**
 *  The available spectrum response must contain a spectrum schedule list. The
 *  list may be empty if spectrum is not available. The database may return more
 *  than one spectrum schedule to represent future changes to the available
 *  spectrum. How far in advance a schedule may be provided depends on the
 *  applicable regulatory domain.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_Schedule *> *spectrumSchedules;

/**
 *  The database includes a timestamp of the form YYYY-MM-DDThh:mm:ssZ (Internet
 *  timestamp format per RFC3339) in its available spectrum response. The
 *  timestamp should be used by the device as a reference for the start and stop
 *  times specified in the response spectrum schedules.
 */
@property(copy, nullable) NSString *timestamp;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The initialization request message allows the master device to initiate
 *  exchange of capabilities with the database.
 */
@interface GTLRSpectrum_PawsInitRequest : GTLRObject

/**
 *  The DeviceDescriptor parameter is required. If the database does not support
 *  the device or any of the rulesets specified in the device descriptor, it
 *  must return an UNSUPPORTED error code in the error response.
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/** A device's geolocation is required. */
@property(strong, nullable) GTLRSpectrum_GeoLocation *location;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The initialization response message communicates database parameters to the
 *  requesting device.
 */
@interface GTLRSpectrum_PawsInitResponse : GTLRObject

/**
 *  A database may include the databaseChange parameter to notify a device of a
 *  change to its database URI, providing one or more alternate database URIs.
 *  The device should use this information to update its list of pre-configured
 *  databases by (only) replacing its entry for the responding database with the
 *  list of alternate URIs.
 */
@property(strong, nullable) GTLRSpectrum_DbUpdateSpec *databaseChange;

/**
 *  Identifies what kind of resource this is. Value: the fixed string
 *  "spectrum#pawsInitResponse".
 */
@property(copy, nullable) NSString *kind;

/**
 *  The rulesetInfo parameter must be included in the response. This parameter
 *  specifies the regulatory domain and parameters applicable to that domain.
 *  The database must include the authority field, which defines the regulatory
 *  domain for the location specified in the INIT_REQ message.
 */
@property(strong, nullable) GTLRSpectrum_RulesetInfo *rulesetInfo;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The spectrum-use notification message which must contain the geolocation of
 *  the Device and parameters required by the regulatory domain.
 */
@interface GTLRSpectrum_PawsNotifySpectrumUseRequest : GTLRObject

/**
 *  Device descriptor information is required in the spectrum-use notification
 *  message.
 */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/**
 *  The geolocation of the master device (the device that is sending the
 *  spectrum-use notification) to the database is required in the spectrum-use
 *  notification message.
 */
@property(strong, nullable) GTLRSpectrum_GeoLocation *location;

/**
 *  A spectrum list is required in the spectrum-use notification. The list
 *  specifies the spectrum that the device expects to use, which includes
 *  frequency ranges and maximum power levels. The list may be empty if the
 *  device decides not to use any of spectrum. For consistency, the
 *  psdBandwidthHz value should match that from one of the spectrum elements in
 *  the corresponding available spectrum response previously sent to the device
 *  by the database. Note that maximum power levels in the spectrum element must
 *  be expressed as power spectral density over the specified psdBandwidthHz
 *  value. The actual bandwidth to be used (as computed from the start and stop
 *  frequencies) may be different from the psdBandwidthHz value. As an example,
 *  when regulatory rules express maximum power spectral density in terms of
 *  maximum power over any 100 kHz band, then the psdBandwidthHz value should be
 *  set to 100 kHz, even though the actual bandwidth used can be 20 kHz.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_Message *> *spectra;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  An empty response to the notification.
 */
@interface GTLRSpectrum_PawsNotifySpectrumUseResponse : GTLRObject

/**
 *  Identifies what kind of resource this is. Value: the fixed string
 *  "spectrum#pawsNotifySpectrumUseResponse".
 */
@property(copy, nullable) NSString *kind;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The registration request message contains the required registration
 *  parameters.
 */
@interface GTLRSpectrum_PawsRegisterRequest : GTLRObject

/** Antenna characteristics, including its height and height type. */
@property(strong, nullable) GTLRSpectrum_AntennaCharacteristics *antenna;

/** A DeviceDescriptor is required. */
@property(strong, nullable) GTLRSpectrum_DeviceDescriptor *deviceDesc;

/** Device owner information is required. */
@property(strong, nullable) GTLRSpectrum_DeviceOwner *deviceOwner;

/** A device's geolocation is required. */
@property(strong, nullable) GTLRSpectrum_GeoLocation *location;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The registration response message simply acknowledges receipt of the request
 *  and is otherwise empty.
 */
@interface GTLRSpectrum_PawsRegisterResponse : GTLRObject

/**
 *  A database may include the databaseChange parameter to notify a device of a
 *  change to its database URI, providing one or more alternate database URIs.
 *  The device should use this information to update its list of pre-configured
 *  databases by (only) replacing its entry for the responding database with the
 *  list of alternate URIs.
 */
@property(strong, nullable) GTLRSpectrum_DbUpdateSpec *databaseChange;

/**
 *  Identifies what kind of resource this is. Value: the fixed string
 *  "spectrum#pawsRegisterResponse".
 */
@property(copy, nullable) NSString *kind;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The device validation request message.
 */
@interface GTLRSpectrum_PawsVerifyDeviceRequest : GTLRObject

/**
 *  A list of device descriptors, which specifies the slave devices to be
 *  validated, is required.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_DeviceDescriptor *> *deviceDescs;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  The device validation response message.
 */
@interface GTLRSpectrum_PawsVerifyDeviceResponse : GTLRObject

/**
 *  A database may include the databaseChange parameter to notify a device of a
 *  change to its database URI, providing one or more alternate database URIs.
 *  The device should use this information to update its list of pre-configured
 *  databases by (only) replacing its entry for the responding database with the
 *  list of alternate URIs.
 */
@property(strong, nullable) GTLRSpectrum_DbUpdateSpec *databaseChange;

/**
 *  A device validities list is required in the device validation response to
 *  report whether each slave device listed in a previous device validation
 *  request is valid. The number of entries must match the number of device
 *  descriptors listed in the previous device validation request.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_DeviceValidity *> *deviceValidities;

/**
 *  Identifies what kind of resource this is. Value: the fixed string
 *  "spectrum#pawsVerifyDeviceResponse".
 */
@property(copy, nullable) NSString *kind;

/**
 *  The message type (e.g., INIT_REQ, AVAIL_SPECTRUM_REQ, ...).
 *  Required field.
 */
@property(copy, nullable) NSString *type;

/**
 *  The PAWS version. Must be exactly 1.0.
 *  Required field.
 */
@property(copy, nullable) NSString *version;

@end

/**
 *  This contains parameters for the ruleset of a regulatory domain that is
 *  communicated using the initialization and available-spectrum processes.
 */
@interface GTLRSpectrum_RulesetInfo : GTLRObject

/**
 *  The regulatory domain to which the ruleset belongs is required. It must be a
 *  2-letter country code. The device should use this to determine additional
 *  device behavior required by the associated regulatory domain.
 */
@property(copy, nullable) NSString *authority;

/**
 *  The maximum location change in meters is required in the initialization
 *  response, but optional otherwise. When the device changes location by more
 *  than this specified distance, it must contact the database to get the
 *  available spectrum for the new location. If the device is using spectrum
 *  that is no longer available, it must immediately cease use of the spectrum
 *  under rules for database-managed spectrum. If this value is provided within
 *  the context of an available-spectrum response, it takes precedence over the
 *  value within the initialization response.
 *
 *  Uses NSNumber of doubleValue.
 */
@property(strong, nullable) NSNumber *maxLocationChange;

/**
 *  The maximum duration, in seconds, between requests for available spectrum.
 *  It is required in the initialization response, but optional otherwise. The
 *  device must contact the database to get available spectrum no less
 *  frequently than this duration. If the new spectrum information indicates
 *  that the device is using spectrum that is no longer available, it must
 *  immediately cease use of those frequencies under rules for database-managed
 *  spectrum. If this value is provided within the context of an
 *  available-spectrum response, it takes precedence over the value within the
 *  initialization response.
 *
 *  Uses NSNumber of intValue.
 */
@property(strong, nullable) NSNumber *maxPollingSecs;

/**
 *  The identifiers of the rulesets supported for the device's location. The
 *  database should include at least one applicable ruleset in the
 *  initialization response. The device may use the ruleset identifiers to
 *  determine parameters to include in subsequent requests. Within the context
 *  of the available-spectrum responses, the database should include the
 *  identifier of the ruleset that it used to determine the available-spectrum
 *  response. If included, the device must use the specified ruleset to
 *  interpret the response. If the device does not support the indicated
 *  ruleset, it must not operate in the spectrum governed by the ruleset.
 */
@property(strong, nullable) NSArray<NSString *> *rulesetIds;

@end

/**
 *  The spectrum schedule element combines an event time with spectrum profile
 *  to define a time period in which the profile is valid.
 */
@interface GTLRSpectrum_Schedule : GTLRObject

/**
 *  The event time expresses when the spectrum profile is valid. It will always
 *  be present.
 */
@property(strong, nullable) GTLRSpectrum_EventTime *eventTime;

/**
 *  A list of spectrum messages representing the usable profile. It will always
 *  be present, but may be empty when there is no available spectrum.
 */
@property(strong, nullable) NSArray<GTLRSpectrum_Message *> *spectra;

@end

/**
 *  A vCard-in-JSON message that contains only the fields needed for PAWS:
 *  - fn: Full name of an individual
 *  - org: Name of the organization
 *  - adr: Address fields
 *  - tel: Telephone numbers
 *  - email: Email addresses
 */
@interface GTLRSpectrum_Vcard : GTLRObject

/** The street address of the entity. */
@property(strong, nullable) GTLRSpectrum_VcardAddress *adr;

/** An email address that can be used to reach the contact. */
@property(strong, nullable) GTLRSpectrum_VcardTypedText *email;

/** The full name of the contact person. For example: John A. Smith. */
@property(copy, nullable) NSString *fn;

/** The organization associated with the registering entity. */
@property(strong, nullable) GTLRSpectrum_VcardTypedText *org;

/** A telephone number that can be used to call the contact. */
@property(strong, nullable) GTLRSpectrum_VcardTelephone *tel;

@end

/**
 *  The structure used to represent a street address.
 */
@interface GTLRSpectrum_VcardAddress : GTLRObject

/** The postal code associated with the address. For example: 94423. */
@property(copy, nullable) NSString *code;

/** The country name. For example: US. */
@property(copy, nullable) NSString *country;

/**
 *  The city or local equivalent portion of the address. For example: San Jose.
 */
@property(copy, nullable) NSString *locality;

/** An optional post office box number. */
@property(copy, nullable) NSString *pobox;

/** The state or local equivalent portion of the address. For example: CA. */
@property(copy, nullable) NSString *region;

/** The street number and name. For example: 123 Any St. */
@property(copy, nullable) NSString *street;

@end

/**
 *  The structure used to represent a telephone number.
 */
@interface GTLRSpectrum_VcardTelephone : GTLRObject

/** A nested telephone URI of the form: tel:+1-123-456-7890. */
@property(copy, nullable) NSString *uri;

@end

/**
 *  The structure used to represent an organization and an email address.
 */
@interface GTLRSpectrum_VcardTypedText : GTLRObject

/**
 *  The text string associated with this item. For example, for an org field:
 *  ACME, inc. For an email field: smith\@example.com.
 */
@property(copy, nullable) NSString *text;

@end

NS_ASSUME_NONNULL_END


text:
package fr.pht.improv.db;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;

public class ImprovDbHelper extends SQLiteOpenHelper {

    private static final String DB_NAME = "improv.db";
    private static final int DB_VERSION = 1;

    public ImprovDbHelper(Context context) {
        // CursorFactory set to null ... ?
        super(context, DB_NAME, null, DB_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        ImprovDbTable.onCreate(db);
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        ImprovDbTable.onUpgrade(db, oldVersion, newVersion);
    }

}

redpajama_set_name: RedPajamaGithub


text:
void
cblas_ssyr2k (const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
              const enum CBLAS_TRANSPOSE Trans, const int N, const int K,
              const float alpha, const float *A, const int lda,
              const float *B, const int ldb, const float beta, float *C,
              const int ldc)
{
#define BASE float
#include "source_syr2k_r.h"
#undef BASE
}


text:
import os
from PyQt4 import *
from PyQt4.QtOpenGL import *
from PyQt4.QtGui import QMatrix4x4

def shaderDir():
    return os.path.dirname(os.path.abspath(__file__))

def shaderFile(shader_name):
    return os.path.join(shaderDir(), shader_name)

class ShaderProgram(object):
    def __init__(self, vertex_shader, fragment_shader):
        self._program = QGLShaderProgram()
        self.linkShaders(vertex_shader, fragment_shader)

    def bind(self):
        if not self.isLinked():
            return

        self._program.bind()

    def release(self):
        self._program.release()

    def isLinked(self):
        return self._program.isLinked()

    def linkShaders(self, vertex_shader, fragment_shader):
        vertex_shader_file = shaderFile(vertex_shader)
        fragment_shader_file = shaderFile(fragment_shader)

        self._program.removeAllShaders()
        self._program.addShaderFromSourceFile(QGLShader.Vertex, vertex_shader_file)
        self._program.addShaderFromSourceFile(QGLShader.Fragment, fragment_shader_file)
        self._program.link()
        self._program.bind()
        self._initAttr()

    def setUniformValue(self, attr, val):
        attr_location = self._program.uniformLocation(attr)
        self._program.setUniformValue(attr_location, val)

    def _initAttr(self):
        matrixLocation = self._program.uniformLocation("matrix")
        self._program.setUniformValue(matrixLocation, QMatrix4x4())


text:
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package com.venky.swf.db;

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Date;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;
import java.text.DecimalFormat;
import java.util.*;

import com.venky.cache.Cache;
import com.venky.core.date.DateUtils;
import com.venky.core.io.ByteArrayInputStream;
import com.venky.core.io.StringReader;
import com.venky.core.log.SWFLogger;
import com.venky.core.log.TimerStatistics.Timer;
import com.venky.core.math.DoubleUtils;
import com.venky.core.string.StringUtil;
import com.venky.core.util.Bucket;
import com.venky.core.util.ExceptionUtil;
import com.venky.core.util.ObjectUtil;
import com.venky.swf.db.annotations.column.COLUMN_DEF;
import com.venky.swf.db.annotations.column.defaulting.StandardDefault;
import com.venky.swf.db.annotations.column.defaulting.StandardDefaulter;
import com.venky.swf.db.model.Model;
import com.venky.swf.db.table.Table;
import com.venky.swf.routing.Config;

/**
 *
 * @author venky
 */
public abstract class JdbcTypeHelper {
	public boolean supportsLimitSyntax(){
		return true;
	}
	public boolean isSavepointManagedByJdbc(){
    	return true;
    }

	public boolean isAutoCommitOnDDL(){
		return false;
	}

	public String getEstablishSavepointStatement(String name){
		return null;
	}

	public String getReleaseSavepointStatement(String name){
		return null;
	}

	public String getRollbackToSavepointStatement(String name){
		return null;
	}

	public boolean requiresSeparatePrimaryKeyClause(){
		return true;
	}

	public boolean isColumnNameAutoLowerCasedInDB(){
		return false;
	}

	private static Class<?> getClass(String name){
		try {
			return Class.forName(name);
		}catch (Exception ex){
			return null;
		}
	}
	private static Class<?> sqlTransactionRollbackException(){
		return getClass("java.sql.SQLTransactionRollbackException");
	}

	private Class<?> queryTimeoutException(){
		return getClass("java.sql.SQLTimeoutException");
	}
	public boolean hasTransactionRolledBack(Throwable ex){
		Class<?> sqlTransactionRollBackException = sqlTransactionRollbackException();
		if (sqlTransactionRollBackException == null){
			return false;
		}
		return getEmbeddedException(ex,sqlTransactionRollBackException) != null  ;
	}

	public boolean isQueryTimeoutSupported(){
		return true;
	}

	public boolean isNoWaitSupported(){
		return false;
	}
	public String getNoWaitLiteral(){
		return "";
	}

	public String getForUpdateLiteral(){
		return " FOR UPDATE ";
	}

	public boolean isQueryTimeoutException(SQLException ex){
		Class<?> queryTimeOutException = queryTimeoutException();
		if (queryTimeOutException != null && queryTimeOutException.isInstance(ex)){
			return true;
		}
		return false;
	}
    public static class TypeRef<M> {

        int jdbcType;
        String sqlType;
        int size;
        int scale;
        TypeConverter<M> typeConverter;
        Class<?> javaClass;
        boolean quotedWhenUnbounded;
        boolean columnDefaultQuoted;
        public TypeRef(int jdbcType, String sqlType, int size, int scale, boolean quotedWhenUnbounded, boolean columnDefaultQuoted,
                TypeConverter<M> typeConverter) {
            this.jdbcType = jdbcType;
            this.sqlType = sqlType;
            this.size = size;
            this.scale = scale;
            this.quotedWhenUnbounded = quotedWhenUnbounded;
            this.columnDefaultQuoted = columnDefaultQuoted;
            this.typeConverter = typeConverter;
        }
        public boolean isColumnDefaultQuoted() {
			return columnDefaultQuoted;
		}
        public boolean isQuotedWhenUnbounded() {
			return quotedWhenUnbounded;
		}

		public int getJdbcType() {
            return jdbcType;
        }

        public int getSize() {
            return size;
        }

        public String getSqlType() {
            return sqlType;
        }

        public int getScale() {
            return scale;
        }

        public boolean isLOB(){
        	return JdbcTypeHelper.isLOB(jdbcType);
        }

        public boolean isCLOB(){
        	return JdbcTypeHelper.isCLOB(jdbcType);
        }

        public boolean isBLOB(){
        	return JdbcTypeHelper.isBLOB(jdbcType);
        }

        public boolean isNumeric(){
        	return JdbcTypeHelper.isNumeric(javaClass);
        }
        public boolean isDate(){
            return JdbcTypeHelper.isDate(jdbcType);
        }
        public boolean isTimestamp(){
            return JdbcTypeHelper.isTimestamp(jdbcType);
        }

        public Class<?> getJavaClass(){
        	return javaClass;
        }

        public void setJavaClass(Class<?> javaClass){
        	this.javaClass = javaClass;
        }
        public TypeConverter<M> getTypeConverter() {
            return typeConverter;
        }
    }

    private static int[] CLOBTYPES = new int[] {Types.CLOB,Types.LONGVARCHAR} ;
    static {
    	Arrays.sort(CLOBTYPES);
    }

    private static int[] BLOBTYPES = new int[] {Types.BLOB , Types.LONGVARBINARY , Types.BINARY, Types.VARBINARY} ;
    static {
    	Arrays.sort(BLOBTYPES);
    }

    private static Class<?>[] NUMERICTYPES = new Class[] { int.class, short.class, long.class, float.class, double.class, Number.class };
    public static boolean isNumeric(Class<?> clazz){
    	if (clazz == null){
    		throw new NullPointerException("Trying to find if null class is numeric!");
    	}
    	for (int i = 0 ; i < NUMERICTYPES.length ; i ++ ){
    		if (NUMERICTYPES[i].isAssignableFrom(clazz)){
    			return true;
    		}
    	}
    	return false;
    }
    private static int[] DATETYPES = new int[] { Types.DATE };
    private static int[] TIMESTAMP_TYPES = new int[]  { Types.TIMESTAMP };

    public static boolean isDate(int jdbcType) {
        return Arrays.binarySearch(DATETYPES,jdbcType)>= 0;
    }
    public static boolean isTimestamp(int jdbcType) {
        return Arrays.binarySearch(TIMESTAMP_TYPES,jdbcType)>= 0;
    }

    public static boolean isCLOB(int jdbcType) {
    	return Arrays.binarySearch(CLOBTYPES,jdbcType)>= 0;
	}
	public static boolean isBLOB(int jdbcType) {
    	return Arrays.binarySearch(BLOBTYPES,jdbcType)>= 0;
	}
	public static boolean isLOB(int jdbcType){
    	return isCLOB(jdbcType) || isBLOB(jdbcType);
    }

    public abstract class TypeConverter<M> {

        public abstract M valueOf(Object o);

        public String toString(Object m) {
        	return StringUtil.valueOf(m);
        }
        public String toStringISO(Object m) { return toString(m) ; }

        public abstract String getDisplayClassName();
    }

    public class BooleanConverter extends TypeConverter<Boolean> {

    	public Boolean valueOf(Object s) {
            if (ObjectUtil.isVoid(s)) {
                return false;
            }
            return Boolean.valueOf(StringUtil.valueOf(s).equalsIgnoreCase("true") || StringUtil.valueOf(s).equalsIgnoreCase("1") || StringUtil.valueOf(s).equalsIgnoreCase("Y") || StringUtil.valueOf(s).equalsIgnoreCase("YES"));
        }

    	public String toString(Object m) {
    		if (m != null){
    			Boolean v = valueOf(m);
    			if (v){
    				return "Y";
    			}else {
    				return "N";
    			}
    		}
        	return StringUtil.valueOf(m);
        }

		@Override
		public String getDisplayClassName() {
			return "boolean";
		}
    }

    public class CharacterConverter extends TypeConverter<Character> {

        public Character valueOf(Object object) {
            if (ObjectUtil.isVoid(object)) {
                return (char) 0;
            }
            char[] c = StringUtil.valueOf(object).toCharArray();
            if (c.length == 1) {
                return c[0];
            }
            throw new RuntimeException("Cannot convert String "
                    + String.valueOf(object) + " to character");
        }

		@Override
		public String getDisplayClassName() {
			return "char";
		}
    }

    public class ByteConverter extends TypeConverter<Byte> {

        public Byte valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return (byte) 0;
            }
            return Byte.valueOf(StringUtil.valueOf(o));
        }
        @Override
		public String getDisplayClassName() {
			return "byte";
		}
    }

    public abstract class NumberConverter<N extends Number> extends TypeConverter<N> {
		@Override
		public String getDisplayClassName() {
			return "number text-right";
		}
    }

	@SuppressWarnings("unchecked")
	public abstract class NumericConverter<N extends Number> extends NumberConverter<N> {
		public DecimalFormat getDisplayFormat(){
			return new DecimalFormat("##############.0000");
		}

		public String toString(Object o){
			if (o == null){
				return "";
			}
			N n = (N)o;
			double fract = n.doubleValue() - Math.floor(n.doubleValue());
			DecimalFormat fmt = getDisplayFormat();
			if (DoubleUtils.compareTo(fract ,Math.round(fract*100.0)/100.0)== 0){
				fmt = new DecimalFormat("##############.00");
			}
			return fmt.format(n.doubleValue());
		}
    }
    public class ShortConverter extends NumberConverter<Short> {
        public Short valueOf(Object o) {
            return getTypeRef(Long.class).getTypeConverter().valueOf(o).shortValue();
        }

    }

    public class IntegerConverter extends NumberConverter<Integer> {
        public Integer valueOf(Object o) {
        	return getTypeRef(Long.class).getTypeConverter().valueOf(o).intValue();
        }
    }

    public class LongConverter extends NumberConverter<Long> {
        public Long valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return Long.valueOf(0L);
            }else if (o instanceof Date){
                return ((Date)o).getTime();
            }else if (o instanceof Boolean){
                BooleanConverter bc = (BooleanConverter) getTypeRef(Boolean.class).getTypeConverter();
                return Long.valueOf(bc.valueOf("1").equals(o)? 1L : 0L);
            }else if (o instanceof Long) {
                return (Long)o;
            }else {
                String v = StringUtil.valueOf(o);
                int indexOfDot = v.indexOf(".");
                if ( indexOfDot >= 0){
                    v = v.substring(0,indexOfDot);
                }
                return Long.valueOf(v);
            }
        }
    }

    public class FloatConverter extends NumericConverter<Float> {
        public Float valueOf(Object o) {
        	DoubleConverter dc = (DoubleConverter) getTypeRef(Double.class).getTypeConverter();
        	return dc.valueOf(o).floatValue();
        }
    }

    public class DoubleConverter extends NumericConverter<Double> {

        public Double valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return 0.0;
            }else if (o instanceof Date){
            	return (double) ((Date) o).getTime();
            }else if (o instanceof Boolean){
            	BooleanConverter bc = (BooleanConverter) getTypeRef(Boolean.class).getTypeConverter();
             	return (double) (bc.valueOf("1").equals(o) ? 1 : 0);
            }else {
                try {
                    return Double.valueOf(StringUtil.valueOf(o));
                }catch(Exception ex){
                    throw new RuntimeException(String.format("Only Numeric Value is Allowed (%s)",o));
                }
            }
        }
    }
    public class BucketConverter extends NumericConverter<Bucket> {

        public Bucket valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return new Bucket(0.0);
            }else if (o instanceof Date){
            	return new Bucket(((Date)o).getTime());
            }else if (o instanceof Boolean){
            	BooleanConverter bc = (BooleanConverter) getTypeRef(Boolean.class).getTypeConverter();
             	return new Bucket( bc.valueOf("1").equals(o)? 1 : 0);
            }else {
                try {
                    return new Bucket(Double.valueOf(StringUtil.valueOf(o)));
                }catch(Exception ex){
                    throw new RuntimeException(String.format("Only Numeric Value is Allowed (%s)",o));
                }
            }
        }
    }
    public class BigDecimalConverter extends NumericConverter<BigDecimal> {
    	public DecimalFormat getDisplayFormat(){
			return new DecimalFormat("###############.0000000000");
		}

        public BigDecimal valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return new BigDecimal(0.0);
            }
            return new BigDecimal(StringUtil.valueOf(o));
        }
    }

    public class StringConverter extends TypeConverter<String> {

        public String valueOf(Object o) {
            return StringUtil.valueOf(o);
        }

        public String toString(Object o) {
            return StringUtil.valueOf(o);
        }
        @Override
		public String getDisplayClassName() {
			return "string";
		}
    }

    public class DateConverter extends TypeConverter<Date> {
    	private String format = null;
    	private TimeZone tz = null;
    	public DateConverter(){
    		this(DateUtils.APP_DATE_FORMAT_STR,TimeZone.getDefault());
    	}
    	public DateConverter(String format,TimeZone tz){
    		this.format = format;
    		this.tz = tz;
    	}

        public Date valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return null;
            }

            if (o instanceof java.util.Date) {
                return new Date(((java.util.Date) o).getTime());
            }

            return new Date(DateUtils.getDate(StringUtil.valueOf(o)).getTime());
        }

        public String toString(Object date) {
            return date == null ? "" : (date instanceof String ? (String)date : DateUtils.getTimestampStr(valueOf(date),tz,format));
        }
        public String toStringISO(Object date) {
            return date == null ? "" : (date instanceof String ? (String)date : DateUtils.getTimestampStr(valueOf(date),tz,DateUtils.ISO_DATE_FORMAT_STR));
        }
        @Override
		public String getDisplayClassName() {
			return "date";
		}

    }

    public class TimeConverter extends TypeConverter<Time> {
    	String format = null ;
    	TimeZone tz  = null;
    	public TimeConverter(){
    		this(DateUtils.APP_TIME_FORMAT_STR,TimeZone.getDefault());
    	}
    	public TimeConverter(String format,TimeZone tz){
    		this.format = format;
    		this.tz = tz;
    	}
        public Time valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return null;
            }
            if (o instanceof Time){
            	return new Time(((Time)o).getTime());
            }
            return new Time(DateUtils.getTime(StringUtil.valueOf(o)).getTime());
        }

        public String toString(Object time) {
            return time == null ? "" : (time instanceof String ? (String)time : DateUtils.getTimestampStr(valueOf(time),tz, format));
        }
        public String toStringISO(Object time) {
            return time == null ? "" : (time instanceof String ? (String)time : DateUtils.getTimestampStr(valueOf(time),tz,DateUtils.ISO_DATE_TIME_FORMAT_STR));
        }
        @Override
		public String getDisplayClassName() {
			return "time";
		}

    }

    public class TimestampConverter extends TypeConverter<Timestamp> {
    	public TimestampConverter(){
    		this(DateUtils.APP_DATE_TIME_FORMAT_STR,TimeZone.getDefault());
    	}
    	private String format;
    	private TimeZone tz;
    	public TimestampConverter(String format,TimeZone tz){
    		this.format = format;
    		this.tz = tz;
    	}
        public Timestamp valueOf(Object o) {
            if (ObjectUtil.isVoid(o)) {
                return null;
            }
            if (o instanceof Timestamp){
            	return new Timestamp(((Timestamp)o).getTime());
            }
            return new Timestamp(DateUtils.getDate(StringUtil.valueOf(o)).getTime());
        }

        public String toString(Object ts) {
            return ts == null ? "" : (ts instanceof String ? (String)ts : DateUtils.getTimestampStr(valueOf(ts),tz,format));
        }

        public String toStringISO(Object ts) {
            return ts == null ? "" : (ts instanceof String ? (String)ts : DateUtils.getTimestampStr(valueOf(ts),tz,DateUtils.ISO_DATE_TIME_FORMAT_STR));
        }
        @Override
		public String getDisplayClassName() {
			return "timestamp";
		}

    }
    public class StringArrayConverter extends TypeConverter<String[]> {

        @Override
        public String[] valueOf(Object o) {
            if (o ==  null){
                return new String[0];
            }
            if (o instanceof String[]){
                return (String[])o;
            }

            if (o instanceof String){
                StringTokenizer tok = new StringTokenizer((String)o,",\"[]");
                List<String> arr = new ArrayList<>();
                while (tok.hasMoreTokens()){
                    arr.add(tok.nextToken().trim());
                }
                return arr.toArray(new String[]{});
            }
            TypeConverter<String> stringTypeConverter = getTypeRef(String.class).getTypeConverter();
            Object possiblyArray = o;
            if (List.class.isAssignableFrom(o.getClass())) {
                possiblyArray = ((List)possiblyArray).toArray();
            }
            if (possiblyArray.getClass().isArray()){
                int len = Array.getLength(possiblyArray);
                String[] out = new String[len];
                for (int i = 0 ; i < len ;i ++){
                    out[i] = stringTypeConverter.valueOf(Array.get(possiblyArray,i));
                }
                return out;
            }else{
                return new String[]{stringTypeConverter.toString(possiblyArray)};
            }

        }

        @Override
        public String toString(Object m) {
            if (m == null){
                return "[]";
            }
            List<String> array = new ArrayList<>();
            if (m instanceof List){
                ((List)m).forEach(o->{
                    array.add(StringUtil.valueOf(o));
                });
            }else if (m.getClass().isArray()){
                for (int i = 0 ; i < Array.getLength(m) ; i ++){
                    array.add(StringUtil.valueOf(Array.get(m,i)));
                }
            }else if (m instanceof String){
                StringTokenizer tok = new StringTokenizer((String)m,",\"[]");
                while (tok.hasMoreTokens()){
                    array.add(tok.nextToken().trim());
                }
            }
            return array.toString();

        }

        @Override
        public String getDisplayClassName() {
            return "array";
        }
    }
    public class InputStreamConverter extends TypeConverter<InputStream> {

        public InputStream valueOf(Object o) {
            if (o == null) {
                return null;
            }
            if (o instanceof Blob) {
                Blob b = (Blob) o;
                try {
                    return new ByteArrayInputStream(StringUtil.readBytes(b.getBinaryStream()));
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            }
            if (o instanceof InputStream) {
            	if (o instanceof ByteArrayInputStream){
            		ByteArrayInputStream is = (ByteArrayInputStream)o;
            		is.reset();
            		return is;
            	}else {
            		return new ByteArrayInputStream(StringUtil.readBytes((InputStream)o));
            	}
            }
            if (o instanceof byte[]){
            	return new ByteArrayInputStream((byte[])o);

            }
            return new ByteArrayInputStream(StringUtil.valueOf(o).getBytes());
        }

        public String toString(Object in) {
            return in == null ? "" : (in instanceof String ? (String)in : StringUtil.read(valueOf(in)));
        }
        public String toStringISO(Object in) {
            return in == null ? "" : (in instanceof String ? (String)in : Base64.getEncoder().encodeToString(StringUtil.readBytes(valueOf(in))));
        }
        @Override
		public String getDisplayClassName() {
			return "string";
		}

    }

    public class ReaderConverter extends TypeConverter<Reader> {

        public Reader valueOf(Object o) {
            if (o == null) {
                return null;
            }
            if (o instanceof Clob) {
                Clob b = (Clob) o;
                try {
                    return new StringReader(StringUtil.read(b.getCharacterStream()));
                } catch (SQLException e) {
                    throw new RuntimeException(e);
                }
            }
            if (o instanceof Reader) {
            	if (o instanceof StringReader){
            		try {
						((StringReader)o).reset();
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
            		return (Reader) o;
            	}else {
            		return new StringReader(StringUtil.read((Reader)o));
            	}
            }
            return new StringReader(StringUtil.valueOf(o));
        }

        public String toString(Object reader) {
            return reader == null ? "" : (reader instanceof String ? (String)reader : StringUtil.read(valueOf(reader)));
        }
        @Override
		public String getDisplayClassName() {
			return "string";
		}

    }
    private static Cache<Class<?>,JdbcTypeHelper> _instance = new Cache<Class<?>, JdbcTypeHelper>(0,0) {

		/**
		 *
		 */
		private static final long serialVersionUID = -3456286258113436179L;

		@Override
		protected JdbcTypeHelper getValue(Class<?> driverClass) {
            if (driverClass.getName().startsWith("org.apache.derby.")){
            	return new DerbyHelper();
            }else if (driverClass.getName().startsWith("com.mysql")) {
                return new MySqlHelper();
            }else if (driverClass.getName().startsWith("org.postgresql")) {
            	return new PostgresqlHelper();
            }else if (driverClass.getName().startsWith("org.sqlite")){
            	return new SQLiteHelper();
            }else if (driverClass.getName().startsWith("org.sqldroid")) {
            	return new SQLDroidHelper();
            }else if (driverClass.getName().startsWith("org.h2")) {
            	return new H2Helper();
            }else if (driverClass.getName().equals("com.venky.swf.db.drivers.CockroachDBDummyDriver")) {
                return new CockroachDBHelper();
            }

            return null;
		}
	};
    public static JdbcTypeHelper instance(Class<?> driverClass){
        return _instance.get(driverClass);
    }

    private final Map<Class<?>, TypeRef<?>> javaTypeRefMap = new HashMap<Class<?>, TypeRef<?>>();
    private final Map<Integer, List<TypeRef<?>>> jdbcTypeRefMap = new HashMap<Integer, List<TypeRef<?>>>();
    protected <T> void registerjdbcSQLType(Class<T> clazz, TypeRef<T> ref) {
    	ref.setJavaClass(clazz);
        javaTypeRefMap.put(clazz, ref);
        List<TypeRef<?>> colTypeRefs = jdbcTypeRefMap.get(ref.jdbcType);
        if (colTypeRefs == null){
        	colTypeRefs = new ArrayList<TypeRef<?>>();
        	jdbcTypeRefMap.put(ref.jdbcType, colTypeRefs);
        }
        colTypeRefs.add(ref);
    }

    public <T> TypeRef<T> getTypeRef(Class<T> javaClass) {
        TypeRef<?> ref = javaTypeRefMap.get(javaClass);
        if (ref != null) {
            return (TypeRef<T>) ref;
        }
        Timer loop = cat.startTimer("loop:" + javaClass.getName(), Config.instance().isTimerAdditive());
    	try {
	        for (Class<?> key : javaTypeRefMap.keySet()) {
	            if (key.isAssignableFrom(javaClass)) {
	            	TypeRef<?> value = javaTypeRefMap.get(key);
	            	javaTypeRefMap.put(key, value);
	                return (TypeRef<T>) value;
	            }
	        }
	        return null;
    	}finally{
    		loop.stop();
    	}
    }

    public List<TypeRef<?>> getTypeRefs(int jdbcType) {
    	List<TypeRef<?>> refs = jdbcTypeRefMap.get(jdbcType);
    	if (refs == null){
    		Config.instance().getLogger(getClass().getName()).warning("Cannot find ref for jdbcType:" + jdbcType);
    	}
    	return refs;
    }
    public TypeRef<?> getTypeRef(int jdbcType) {
    	List<TypeRef<?>> refs = getTypeRefs(jdbcType);
    	if (refs == null || refs.isEmpty()){
    		Config.instance().getLogger(getClass().getName()).warning("Cannot find ref for jdbcType:" + jdbcType);
    		return null;
    	}else{
    		return refs.get(0);
    	}
    }

    public String getAutoIncrementInstruction() {
        return " BIGINT NOT NULL ";
    }

    public long getPrimaryKeyOffset(){
        return getPrimaryKeyOffset(Config.instance().getLongProperty("swf.node.id",0L));
    }
    public long getPrimaryKeyOffset(long nodeId){
        return ((nodeId << 44) | 1);
    }

    public abstract String getCurrentTimeStampKW();
    public abstract String getCurrentDateKW();
    public String toDefaultKW(TypeRef<?> ref, COLUMN_DEF def){
    	Timer timer = cat.startTimer(null,Config.instance().isTimerAdditive());
    	try {
	    	if (def.value() == StandardDefault.CURRENT_TIMESTAMP){
	    		return getCurrentTimeStampKW();
	    	}else if (def.value() == StandardDefault.CURRENT_DATE){
	    		return getCurrentDateKW();
	    	}else {
	    		return getDefaultKW(ref,StandardDefaulter.getDefaultValue(def));
	    	}
    	}finally{
    		timer.stop();
    	}
    }
    public String getDefaultKW(TypeRef<?> ref, Object value){
    	if ( ref.isColumnDefaultQuoted() && !StringUtil.valueOf(value).startsWith("'")){
			return "'" + value + "'";
    	}else {
    		return StringUtil.valueOf(value);
    	}
    }

  	public static Throwable getEmbeddedException(Throwable in, Class<?> instanceOfThisClass){
  		return ExceptionUtil.getEmbeddedException(in, instanceOfThisClass);
  	}

  	public boolean isVoid (Object o){
  		return o == null || ObjectUtil.equals(getTypeRef(o.getClass()).getTypeConverter().valueOf(null),o);
  	}

  	protected <M extends Model> void updateSequence(Table<M> table){
  		Config.instance().getLogger(getClass().getName()).warning("updateSequence not implemented in " + getClass().getName() );
  	}

	public String getLowerCaseFunction() {
		return "LOWER";
	}

	public void setBinaryStream(PreparedStatement st, int i, ByteArrayInputStream in) throws SQLException {
		st.setBinaryStream(i, in, in.available());
	}

	private final SWFLogger cat = new SWFLogger(Config.instance().getLogger(getClass().getName()));
}


text:
(function(){
    'use strict';
    angular.module('gantt.tree').directive('ganttRowTreeLabel', ['GanttDirectiveBuilder', function(Builder) {
        var builder = new Builder('ganttRowTreeLabel');
        builder.restrict = 'A';
        builder.templateUrl = undefined;
        return builder.build();
    }]);
}());


text:
while true; do
    sleep 10
    flask deploy
    if [[ "$?" == "0" ]]; then
        echo Deploy success
        break
    fi
    echo Deploy command failed, retrying in 10 secs...
done

# nohup flask build index > /dev/null 2>&1 &
flask build index

# nohup flask build similarity > /dev/null 2>&1 &
flask build similarity

exec gunicorn -b :5000 --access-logfile - --error-logfile - manage:app


text:
The AMP HTML project strongly encourages technical [contributions](https://www.ampproject.org/contribute/)!

We hope you'll become an ongoing participant in our open source community but we also welcome one-off contributions for the issues you're particularly passionate about.

> :grey_question: If you have questions about using AMP or are encountering problems using AMP on your site please visit our [support page](SUPPORT.md) for help.

#### Contents

- [Reporting issues with AMP](#reporting-issues-with-amp)
  * [Bugs](#bugs)
  * [Suggestions and feature requests](#suggestions-and-feature-requests)
- [Contributing code](#contributing-code)
  * [Tips for new open source contributors](#tips-for-new-open-source-contributors)
  * [Contributing extended components](#contributing-extended-components)
  * [How to contribute code](#how-to-contribute-code)
    + [Contributing a new feature (concept & design phase)](#phase-concept-design)
    + [Contributing code for a feature (coding phase)](#phase-coding)
- [Contributor License Agreement](#contributor-license-agreement)
- [Ongoing participation](#ongoing-participation)
  * [Discussion channels](#discussion-channels)
  * [Status updates](#status-updates)
  * [Weekly design reviews](#weekly-design-reviews)
  * [Working groups](#working-groups)
  * [See Also](#see-also)
## Reporting issues with AMP

### Bugs

If you find a bug in AMP, please [file a GitHub issue](https://github.com/ampproject/amphtml/issues/new).  Members of the community are regularly monitoring issues and will try to fix open bugs quickly according to our [prioritization guidelines](./contributing/issue-priorities.md).

The best bug reports provide a detailed description of the issue (including screenshots if possible), step-by-step instructions for predictably reproducing the issue, and possibly even a working example that demonstrates the issue.

### Suggestions and feature requests

The AMP Project is meant to evolve with feedback.  The project and its users appreciate your thoughts on ways to improve the design or features.

To make a suggestion or feature request [file a GitHub issue](https://github.com/ampproject/amphtml/issues/new) describing your idea.

If you are suggesting a feature that you are intending to implement, please see the [Contributing a new feature](#phase-concept-design) section below for next steps.

## Contributing code

The AMP Project accepts and greatly appreciates code contributions!

### Tips for new open source contributors

If you are new to contributing to an open source project, Git/GitHub, etc. welcome!  We are glad you're interested in contributing to the AMP Project and we want to help make your open source experience a success.

The [Getting Started End-to-End Guide](./contributing/getting-started-e2e.md) provides step-by-step instructions for everything from creating a GitHub account to getting your code reviewed and merged.  Even if you've never contributed to an open source project before you'll soon be building AMP, making improvements and seeing your code live across the web.

The community has created a list of [Good First Issues](https://github.com/ampproject/amphtml/labels/good%20first%20issue) specifically for new contributors to the project.  Feel free to find one of the [unclaimed Good First Issues](https://github.com/ampproject/amphtml/issues?utf8=%E2%9C%93&q=is%3Aopen%20label%3A%22good%20first%20issue%22%20-label%3A%22GFI%20Claimed!%22) that interests you, claim it by adding a comment to it and jump in!

If you're interested in helping out but can't find a Good First Issue that matches your skills/interests, [sign up for our Slack](https://docs.google.com/forms/d/e/1FAIpQLSd83J2IZA6cdR6jPwABGsJE8YL4pkypAbKMGgUZZriU7Qu6Tg/viewform?fbzx=4406980310789882877) and then reach out in the [#welcome-contributors channel](https://amphtml.slack.com/messages/welcome-contributors/) or send a Direct Message to [mrjoro](https://amphtml.slack.com/team/mrjoro/).

If you run into any problems we have plenty of people who are willing to help; see the [How to get help](./contributing/getting-started-e2e.md#how-to-get-help) section of the Getting Started guide.

> :bookmark: You might have noticed that we use GitHub emojis in our pull requests. To learn what these emojis mean and which ones to use, see  :sparkles:[our list of emojis](./.github/PULL_REQUEST_TEMPLATE.md#emojis-for-categorizing-pull-requests) :sparkles:.

### Contributing extended components

A key feature of the AMP HTML project is its extensibility - it is meant to support "Extended Components" that provide first-class support for additional rich features.

Because Extended Components may have significant impact on AMP HTML performance, security, and usage, Extended Component contributions will be very carefully analyzed and scrutinized.

In particular, we strive to design the overall component set, so that a large number of use cases can be composed from them. Instead of creating a new component it may thus be a better solution to combine existing components to a similar effect.

We have a few additional resources that provide an introduction to contributing extended components:
* ["Building an AMP Extension"](./contributing/building-an-amp-extension.md) has a detailed description of how to build an AMP component.
* ["Creating your first AMP Component" codelab](https://codelabs.developers.google.com/codelabs/creating-your-first-amp-component/#0) provides a quick overview of the steps you need to go through to create a component with examples you can modify for your component.
* The ["Building a new AMP component" talk at AMP Conf 2017](https://youtu.be/FJEhQFNKeaQ?list=PLXTOW_XMsIDTDXYO-NAi2OpEH0zyguvqX) provides an introduction to contributing AMP components.

For further detail on integrating third-party services (e.g., fonts, embeds, etc.), see our [3p contribution guidelines](https://github.com/ampproject/amphtml/tree/master/3p).

### How to contribute code

Contributing to AMP involves two phases:

1.  [Concept & Design](#phase-concept-design)
2.  [Coding & Implementation](#phase-coding)

#### Contributing a new feature (concept & design phase)

1. Familiarize yourself with our [Design Principles](./contributing/DESIGN_PRINCIPLES.md).
1. [Create an  Intent to Implement (I2I) GH issue](https://github.com/ampproject/amphtml/issues/new) to discuss your new feature. In your I2I, include the following:
   -  A high-level description of the feature.
   -  A description of the API you plan to create.
   -  If you are integrating a third-party service, provide a link to the third-party's site and product.
   -  Details on any data collection or tracking that the feature might perform.
   -  A prototype or mockup (for example, an image, a GIF, or a link to a demo).
3. Before starting on the code, get approval for your feature from an [OWNER](https://github.com/ampproject/amphtml/search?utf8=%E2%9C%93&q=filename%3AOWNERS.yaml&type=Code) of your feature's area and a [core committer](GOVERNANCE.md#core-committers).  In most cases the people who can give this approval and are most familiar with your feature's area will get involved proactively or someone else in the community will add them. As part of the design review, you might be required to discuss your design in the [weekly design review](#weekly-design-reviews) meeting.
5.  [Start coding](#phase-coding).

#### Contributing code for a feature (coding & implementation phase)

1. If you haven't already, consider [joining the AMP Project](https://goo.gl/forms/T65peVtfQfEoDWeD3). This is entirely *optional* but by joining the project you become part of the AMP contributor community, and it allows for the ability to assign issues to you in GitHub.
1.  [Perform the one-time setup](./contributing/getting-started-quick.md#one-time-setup): Set up your GitHub account, install Node, Yarn, Gulp CLI, fork repo, track repo, etc.
1. [Create a working branch](./contributing/getting-started-e2e.md#create-a-git-branch).
1. [Build AMP](./contributing/getting-started-e2e.md#building-amp-and-starting-a-local-server).
1. Write code and consult these resources for guidance and guidelines:
   - **Design**: [AMP Design Principles](./contributing/DESIGN_PRINCIPLES.md)
   - **JavaScript**: [Google JavaScript Code Style Guide](https://google.github.io/styleguide/jsguide.html)
   - **CSS**: [Writing CSS For AMP Runtime](./contributing/writing-css.md)
   - **Creating new components**:
     - [Instructions and Guidelines for building an AMP component](./contributing/building-an-amp-extension.md)
     - Learn to create your first component in this [codelab](https://codelabs.developers.google.com/codelabs/creating-your-first-amp-component/#0)
     - Watch this [YouTube video](https://youtu.be/FJEhQFNKeaQ?list=PLXTOW_XMsIDTDXYO-NAi2OpEH0zyguvqX) to learn about "Building a new AMP component"
   - **Integrating third-party software, embeds, services**: [Guidelines](./3p/README.md)
1. [Commit your files](./contributing/getting-started-e2e.md#edit-files-and-commit-them).
1. [Test your changes](./contributing/getting-started-e2e.md#testing-your-changes): A key feature of AMP is performance.  All changes will be analyzed for any performance impact; we particularly appreciate changes that make things even faster.  Please include any measured performance impact with substantial pull requests.
1. [Put your new component behind an experiment flag](./contributing/building-an-amp-extension.md#experiments).
1. [Pull the latest changes from the AMPHTML repo](./contributing/getting-started-e2e.md#pull-the-latest-changes-from-the-amphtml-repository) and resolve any conflicts.
1. [Sign the CLA](CONTRIBUTING.md#contributor-license-agreement): This is a one-time task.
1.  Run the **pre push** check, which is a tool that helps catch any issues before you submit your code. To enable the git pre-push hook, see [`enable-git-pre-push.sh`](./build-system/enable-git-pre-push.sh#L17-L20).
1. Prepare for your code review:
   - [ ] [Correct test coverage](./contributing/TESTING.md)
   - [ ] [Code follows style and design guidelines](./contributing/DEVELOPING.md#guidelines--style)
   - [ ] [Documentation for your feature](./contributing/building-an-amp-extension.md#documenting-your-element)
   - [ ] [Presubmit passes (no lint and type check errors, tests are passing)](./build-system/enable-git-pre-push.sh#L17-L20)
   - [ ] [Validation rules and validation tests provided](./contributing/building-an-amp-extension.md#allowing-proper-validations)
   - [ ] [Feature is behind an experiment flag](./contributing/building-an-amp-extension.md#experiments)
   - [ ] [Example provided](./contributing/building-an-amp-extension.md#example-of-using-your-extension)
1. [Push your changes](./contributing/getting-started-e2e.md#push-your-changes-to-your-github-fork)
1. [Send a Pull Request (PR) to review your code](./contributing/getting-started-e2e.md#send-a-pull-request-ie-request-a-code-review). Your PR needs to include:
    - A descriptive title
    - A link to your GitHub Intent To Implement # or Issue #
    - A visual demonstration of your change (e.g., a screenshot, GIF, or links to  a published demo (we can link to our Heroku setup which allows developers to publish work-in-progress code to the cloud)
    - @mention the core committer or someone who's already worked with you on the feature
1. Make sure your PR presubmit passes (no lint and type check errors, tests are passing).
1. [Respond to feedback](./contributing/getting-started-e2e.md#respond-to-pull-request-comments).
1. After your PR is approved, it's merged by a core committer. To check on your changes and find out when they get into production, read [See your changes in production](./contributing/getting-started-quick.md#see-your-changes-in-production).
1. [Clean up](./contributing/getting-started-quick.md#delete-your-branch-after-your-changes-are-merged-optional): After your changes are merged, you can delete your working branch.

## Contributor License Agreement

The AMP Project hosted at GitHub requires all contributors to either sign an individual Contributor License Agreement or be covered by a corporate Contributor License Agreement in order to protect contributors and users in issues of intellectual property.

We recommend you handle signing/being covered by a CLA *before* you send a pull request to avoid problems, though this is not absolutely necessary until your code is ready to be merged in.

**Make sure that the email you associate with your CLA is the same email address you associate with your commits (likely via the `user.email` Git config as described on GitHub's [Set up Git](https://help.github.com/articles/set-up-git/) page).**

* **If you are contributing code on your own behalf** you can sign the [individual CLA](https://developers.google.com/open-source/cla/individual) instantly online.
* **If you are planning on contributing code on behalf of your company:**
  * Your company will need to agree to a [corporate CLA](https://developers.google.com/open-source/cla/corporate) if it has not already done so.  Although this is a relatively straightforward process, it requires approval from an authorized signer at your company and a manual verification process that may take a couple of days.  To ensure you can get your code reviewed and merged quickly please start this process as soon as possible.  The signer of your corporate CLA will associate a Google Group to the corporate CLA, and any email address added to this Google Group will be considered to be covered by this corporate CLA.
  * To be covered by your company's corporate CLA the owner of the Google Group associated with the corporate CLA (someone at your company) will need to add your address to this Google Group.

## Ongoing participation

We actively encourage ongoing participation by community members.

### Discussion channels

Technical issues, designs, etc. are discussed using several different channels:

- [GitHub issues](https://github.com/ampproject/amphtml/issues) and [pull requests](https://github.com/ampproject/amphtml/pulls)
- [Slack](https://amphtml.slack.com) ([signup](https://docs.google.com/forms/d/1wAE8w3K5preZnBkRk-MD1QkX8FmlRDxd_vs4bFSeJlQ/viewform?fbzx=4406980310789882877))
  - the [#contributing](https://amphtml.slack.com/messages/C9HRJ1GPN/details/) channel is the main channel for you to discuss/ask questions about *contributing* to the open source project
  - if you're *new to contributing* to AMP stop by [#welcome-contributors](https://amphtml.slack.com/messages/C432AFMFE/details/) to say hi!
  - **NOTE: if you have a question about *using AMP on your site*, use [Stack Overflow](https://stackoverflow.com/questions/tagged/amp-html) rather than Slack** as Stack Overflow is more actively monitored for these types of questions
  - there are many other Slack channels for more specific topics; after you join our Slack click on the "Channels" header to find other channels you want to participate in
- the [amphtml-discuss Google Group](https://groups.google.com/forum/#!forum/amphtml-discuss)

### Status updates

Status updates from members of the community are tracked using approximately bi-weekly [Status Update GitHub issues](https://github.com/ampproject/amphtml/issues?q=label%3A%22Type%3A+Status+Update%22).

We encourage everyone who is actively contributing to AMP to add a comment to the relevant Status Update issue.

### Weekly design reviews

The community holds weekly engineering [design reviews](./contributing/design-reviews.md) via video conference.  We encourage everyone in the community to participate in these discussions and to bring their designs for new features and significant bug fixes to these reviews.

### Working groups

AMP Project [working groups](./contributing/working-groups.md) bring together parties with related interests to discuss ideas for how AMP can evolve and to receive updates on new features and changes in AMP that are relevant to the group.

## See also

* [Code of conduct](CODE_OF_CONDUCT.md)
* [3p contribution guidelines](https://github.com/ampproject/amphtml/tree/master/3p)
* The [GOVERNANCE](GOVERNANCE.md) model


text:
import os

from django.db import models
from tagging.models import Tag

from graphite.events.compat import ModelTaggedItemManager

if os.environ.get('READTHEDOCS'):
    TagField = lambda *args, **kwargs: None
else:
    from tagging.fields import TagField

class Event(models.Model):
    when = models.DateTimeField()
    what = models.CharField(max_length=255)
    data = models.TextField(blank=True)
    tags = TagField(default="")

    def get_tags(self):
        return Tag.objects.get_for_object(self)

    def __str__(self):
        return "%s: %s" % (self.when, self.what)

    @staticmethod
    def find_events(time_from=None, time_until=None, tags=None, set_operation=None):

        if tags is not None:
            if set_operation == 'union':
                query = Event.tagged.with_any(tags)
            elif set_operation == 'intersection':
                query = Event.tagged.with_intersection(tags)
            else:
                query = Event.tagged.with_all(tags)
        else:
            query = Event.objects.all()

        if time_from is not None:
            query = query.filter(when__gte=time_from)

        if time_until is not None:
            query = query.filter(when__lte=time_until)

        result = list(query.order_by("when"))
        return result

    def as_dict(self):
        return dict(
            when=self.when,
            what=self.what,
            data=self.data,
            tags=self.tags.split(),
            id=self.id,
        )

# We use this rather than tagging.register() so that tags can be exposed
# in the admin UI
ModelTaggedItemManager().contribute_to_class(Event, 'tagged')


text:
How-to-create-a-web-api-no-one-wants-to-use
===========================================

"How to create a web API" presentation from TechDays Sweden and NDC London. Based on https://github.com/hakimel/reveal.js/

View the presentation here: http://karolikl.github.io/How-to-create-a-web-api-no-one-wants-to-use/


text:
const
	fs = require('fs'),
	path = require('path'),
	windowslib = require('..');

describe('device', function () {
	it('namespace should be an object', function () {
		should(windowslib.device).be.an.Object;
	});

	(process.platform === 'win32' ? it : it.skip)('detect Windows Phone devices', function (done) {
		this.timeout(5000);
		this.slow(4000);

		windowslib.device.detect(function (err, results) {
			if (err) {
				return done(err);
			}

			should(results).be.an.Object;
			should(results).have.keys('devices', 'issues');

			should(results.devices).be.an.Array;
			results.devices.forEach(function (dev) {
				should(dev).be.an.Object;
				should(dev).have.properties('name', 'udid', 'index', 'wpsdk'); // may also have 'ip'

				should(dev.name).be.a.String;
				should(dev.name).not.equal('');

				should(dev.udid).be.a.Number;

				should(dev.index).be.a.Number;

				should(dev.wpsdk).not.be.ok;
			});

			should(results.issues).be.an.Array;
			results.issues.forEach(function (issue) {
				should(issue).be.an.Object;
				should(issue).have.keys('id', 'type', 'message');
				should(issue.id).be.a.String;
				should(issue.type).be.a.String;
				should(issue.type).match(/^info|warning|error$/);
				should(issue.message).be.a.String;
			});

			done();
		});
	});

	(process.platform === 'win32' ? it : it.skip)('connect to a device', function (done) {
		this.timeout(120000);
		this.slow(110000);

		windowslib.device.connect(0, done);
	});

	(process.platform === 'win32' ? it : it.skip)('install app on a device', function (done) {
		this.timeout(120000);
		this.slow(110000);

		windowslib.visualstudio.build({
			buildConfiguration: 'Debug',
			project: path.join(__dirname, 'TestApp', 'TestApp.csproj')
		}, function (err, result) {
			if (err) {
				return done(err);
			}

			var xapFile = path.join(__dirname, 'TestApp', 'Bin', 'Debug', 'TestApp_Debug_AnyCPU.xap');
			should(fs.existsSync(xapFile)).be.ok;

			windowslib.device.install(0, xapFile, function (err) {
				done(err);
			});
		});
	});
});


text:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <artifactId>ch3_list</artifactId>
    <version>1.0</version>
    <packaging>jar</packaging>

    <parent>
        <groupId>ru.job4j</groupId>
        <artifactId>p1_collections_pro</artifactId>
        <version>1.0</version>
    </parent>
</project>