text:
'use strict';

const msRest = require('ms-rest');
const WebResource = msRest.WebResource;

/**
 * @summary The Web Search API lets you send a search query to Bing and get
 * back search results that include links to webpages, images, and more.
 *
 * @param {string} query The user's search query term. The term may not be
 * empty. The term may contain Bing Advanced Operators. For example, to limit
 * results to a specific domain, use the site: operator.
 *
 * @param {object} [options] Optional Parameters.
 *
 * @param {string} [options.acceptLanguage] A comma-delimited list of one or
 * more languages to use for user interface strings. The list is in decreasing
 * order of preference. For additional information, including expected format,
 * see [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
 * header and the setLang query parameter are mutually exclusive; do not
 * specify both. If you set this header, you must also specify the cc query
 * parameter. Bing will use the first supported language it finds from the
 * list, and combine that language with the cc parameter value to determine the
 * market to return results for. If the list does not include a supported
 * language, Bing will find the closest language and market that supports the
 * request, and may use an aggregated or default market for the results instead
 * of a specified one. You should use this header and the cc query parameter
 * only if you specify multiple languages; otherwise, you should use the mkt
 * and setLang query parameters. A user interface string is a string that's
 * used as a label in a user interface. There are very few user interface
 * strings in the JSON response objects. Any links in the response objects to
 * Bing.com properties will apply the specified language.
 *
 * @param {string} [options.pragma] By default, Bing returns cached content, if
 * available. To prevent Bing from returning cached content, set the Pragma
 * header to no-cache (for example, Pragma: no-cache).
 *
 * @param {string} [options.userAgent] The user agent originating the request.
 * Bing uses the user agent to provide mobile users with an optimized
 * experience. Although optional, you are strongly encouraged to always specify
 * this header. The user-agent should be the same string that any commonly used
 * browser would send. For information about user agents, see [RFC
 * 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
 *
 * @param {string} [options.clientId] Bing uses this header to provide users
 * with consistent behavior across Bing API calls. Bing often flights new
 * features and improvements, and it uses the client ID as a key for assigning
 * traffic on different flights. If you do not use the same client ID for a
 * user across multiple requests, then Bing may assign the user to multiple
 * conflicting flights. Being assigned to multiple conflicting flights can lead
 * to an inconsistent user experience. For example, if the second request has a
 * different flight assignment than the first, the experience may be
 * unexpected. Also, Bing can use the client ID to tailor web results to that
 * client ID's search history, providing a richer experience for the user. Bing
 * also uses this header to help improve result rankings by analyzing the
 * activity generated by a client ID. The relevance improvements help with
 * better quality of results delivered by Bing APIs and in turn enables higher
 * click-through rates for the API consumer. IMPORTANT: Although optional, you
 * should consider this header required. Persisting the client ID across
 * multiple requests for the same end user and device combination enables 1)
 * the API consumer to receive a consistent user experience, and 2) higher
 * click-through rates via better quality of results from the Bing APIs. Each
 * user that uses your application on the device must have a unique, Bing
 * generated client ID. If you do not include this header in the request, Bing
 * generates an ID and returns it in the X-MSEdge-ClientID response header. The
 * only time that you should NOT include this header in a request is the first
 * time the user uses your app on that device. Use the client ID for each Bing
 * API request that your app makes for this user on the device. Persist the
 * client ID. To persist the ID in a browser app, use a persistent HTTP cookie
 * to ensure the ID is used across all sessions. Do not use a session cookie.
 * For other apps such as mobile apps, use the device's persistent storage to
 * persist the ID. The next time the user uses your app on that device, get the
 * client ID that you persisted. Bing responses may or may not include this
 * header. If the response includes this header, capture the client ID and use
 * it for all subsequent Bing requests for the user on that device. If you
 * include the X-MSEdge-ClientID, you must not include cookies in the request.
 *
 * @param {string} [options.clientIp] The IPv4 or IPv6 address of the client
 * device. The IP address is used to discover the user's location. Bing uses
 * the location information to determine safe search behavior. Although
 * optional, you are encouraged to always specify this header and the
 * X-Search-Location header. Do not obfuscate the address (for example, by
 * changing the last octet to 0). Obfuscating the address results in the
 * location not being anywhere near the device's actual location, which may
 * result in Bing serving erroneous results.
 *
 * @param {string} [options.location] A semicolon-delimited list of key/value
 * pairs that describe the client's geographical location. Bing uses the
 * location information to determine safe search behavior and to return
 * relevant local content. Specify the key/value pair as <key>:<value>. The
 * following are the keys that you use to specify the user's location. lat
 * (required): The latitude of the client's location, in degrees. The latitude
 * must be greater than or equal to -90.0 and less than or equal to +90.0.
 * Negative values indicate southern latitudes and positive values indicate
 * northern latitudes. long (required): The longitude of the client's location,
 * in degrees. The longitude must be greater than or equal to -180.0 and less
 * than or equal to +180.0. Negative values indicate western longitudes and
 * positive values indicate eastern longitudes. re (required): The radius, in
 * meters, which specifies the horizontal accuracy of the coordinates. Pass the
 * value returned by the device's location service. Typical values might be 22m
 * for GPS/Wi-Fi, 380m for cell tower triangulation, and 18,000m for reverse IP
 * lookup. ts (optional): The UTC UNIX timestamp of when the client was at the
 * location. (The UNIX timestamp is the number of seconds since January 1,
 * 1970.) head (optional): The client's relative heading or direction of
 * travel. Specify the direction of travel as degrees from 0 through 360,
 * counting clockwise relative to true north. Specify this key only if the sp
 * key is nonzero. sp (optional): The horizontal velocity (speed), in meters
 * per second, that the client device is traveling. alt (optional): The
 * altitude of the client device, in meters. are (optional): The radius, in
 * meters, that specifies the vertical accuracy of the coordinates. Specify
 * this key only if you specify the alt key. Although many of the keys are
 * optional, the more information that you provide, the more accurate the
 * location results are. Although optional, you are encouraged to always
 * specify the user's geographical location. Providing the location is
 * especially important if the client's IP address does not accurately reflect
 * the user's physical location (for example, if the client uses VPN). For
 * optimal results, you should include this header and the X-MSEdge-ClientIP
 * header, but at a minimum, you should include this header.
 *
 * @param {number} [options.answerCount] The number of answers that you want
 * the response to include. The answers that Bing returns are based on ranking.
 * For example, if Bing returns webpages, images, videos, and relatedSearches
 * for a request and you set this parameter to two (2), the response includes
 * webpages and images.If you included the responseFilter query parameter in
 * the same request and set it to webpages and news, the response would include
 * only webpages.
 *
 * @param {string} [options.countryCode] A 2-character country code of the
 * country where the results come from. This API supports only the United
 * States market. If you specify this query parameter, it must be set to us. If
 * you set this parameter, you must also specify the Accept-Language header.
 * Bing uses the first supported language it finds from the languages list, and
 * combine that language with the country code that you specify to determine
 * the market to return results for. If the languages list does not include a
 * supported language, Bing finds the closest language and market that supports
 * the request, or it may use an aggregated or default market for the results
 * instead of a specified one. You should use this query parameter and the
 * Accept-Language query parameter only if you specify multiple languages;
 * otherwise, you should use the mkt and setLang query parameters. This
 * parameter and the mkt query parameter are mutually exclusive—do not specify
 * both.
 *
 * @param {number} [options.count] The number of search results to return in
 * the response. The default is 10 and the maximum value is 50. The actual
 * number delivered may be less than requested.Use this parameter along with
 * the offset parameter to page results.For example, if your user interface
 * displays 10 search results per page, set count to 10 and offset to 0 to get
 * the first page of results. For each subsequent page, increment offset by 10
 * (for example, 0, 10, 20). It is possible for multiple pages to include some
 * overlap in results.
 *
 * @param {string} [options.freshness] Filter search results by the following
 * age values: Day—Return webpages that Bing discovered within the last 24
 * hours. Week—Return webpages that Bing discovered within the last 7 days.
 * Month—Return webpages that discovered within the last 30 days. This filter
 * applies only to webpage results and not to the other results such as news
 * and images. Possible values include: 'Day', 'Week', 'Month'
 *
 * @param {string} [options.market] The market where the results come from.
 * Typically, mkt is the country where the user is making the request from.
 * However, it could be a different country if the user is not located in a
 * country where Bing delivers results. The market must be in the form
 * <language code>-<country code>. For example, en-US. The string is case
 * insensitive. If known, you are encouraged to always specify the market.
 * Specifying the market helps Bing route the request and return an appropriate
 * and optimal response. If you specify a market that is not listed in Market
 * Codes, Bing uses a best fit market code based on an internal mapping that is
 * subject to change. This parameter and the cc query parameter are mutually
 * exclusive—do not specify both.
 *
 * @param {number} [options.offset] The zero-based offset that indicates the
 * number of search results to skip before returning results. The default is 0.
 * The offset should be less than (totalEstimatedMatches - count). Use this
 * parameter along with the count parameter to page results. For example, if
 * your user interface displays 10 search results per page, set count to 10 and
 * offset to 0 to get the first page of results. For each subsequent page,
 * increment offset by 10 (for example, 0, 10, 20). it is possible for multiple
 * pages to include some overlap in results.
 *
 * @param {array} [options.promote] A comma-delimited list of answers that you
 * want the response to include regardless of their ranking. For example, if
 * you set answerCount) to two (2) so Bing returns the top two ranked answers,
 * but you also want the response to include news, you'd set promote to news.
 * If the top ranked answers are webpages, images, videos, and relatedSearches,
 * the response includes webpages and images because news is not a ranked
 * answer. But if you set promote to video, Bing would promote the video answer
 * into the response and return webpages, images, and videos. The answers that
 * you want to promote do not count against the answerCount limit. For example,
 * if the ranked answers are news, images, and videos, and you set answerCount
 * to 1 and promote to news, the response contains news and images. Or, if the
 * ranked answers are videos, images, and news, the response contains videos
 * and news. Possible values are Computation, Images, News, RelatedSearches,
 * SpellSuggestions, TimeZone, Videos, Webpages. Use only if you specify
 * answerCount.
 *
 * @param {array} [options.responseFilter] A comma-delimited list of answers to
 * include in the response. If you do not specify this parameter, the response
 * includes all search answers for which there's relevant data. Possible filter
 * values are Computation, Images, News, RelatedSearches, SpellSuggestions,
 * TimeZone, Videos, Webpages. Although you may use this filter to get a single
 * answer, you should instead use the answer-specific endpoint in order to get
 * richer results. For example, to receive only images, send the request to one
 * of the Image Search API endpoints. The RelatedSearches and SpellSuggestions
 * answers do not support a separate endpoint like the Image Search API does
 * (only the Web Search API returns them). To include answers that would
 * otherwise be excluded because of ranking, see the promote query parameter.
 *
 * @param {string} [options.safeSearch] A filter used to filter adult content.
 * Off: Return webpages with adult text, images, or videos. Moderate: Return
 * webpages with adult text, but not adult images or videos. Strict: Do not
 * return webpages with adult text, images, or videos. The default is Moderate.
 * If the request comes from a market that Bing's adult policy requires that
 * safeSearch is set to Strict, Bing ignores the safeSearch value and uses
 * Strict. If you use the site: query operator, there is the chance that the
 * response may contain adult content regardless of what the safeSearch query
 * parameter is set to. Use site: only if you are aware of the content on the
 * site and your scenario supports the possibility of adult content. Possible
 * values include: 'Off', 'Moderate', 'Strict'
 *
 * @param {string} [options.setLang] The language to use for user interface
 * strings. Specify the language using the ISO 639-1 2-letter language code.
 * For example, the language code for English is EN. The default is EN
 * (English). Although optional, you should always specify the language.
 * Typically, you set setLang to the same language specified by mkt unless the
 * user wants the user interface strings displayed in a different language.
 * This parameter and the Accept-Language header are mutually exclusive; do not
 * specify both. A user interface string is a string that's used as a label in
 * a user interface. There are few user interface strings in the JSON response
 * objects. Also, any links to Bing.com properties in the response objects
 * apply the specified language.
 *
 * @param {boolean} [options.textDecorations] A Boolean value that determines
 * whether display strings should contain decoration markers such as hit
 * highlighting characters. If true, the strings may include markers. The
 * default is false. To specify whether to use Unicode characters or HTML tags
 * as the markers, see the textFormat query parameter.
 *
 * @param {string} [options.textFormat] The type of markers to use for text
 * decorations (see the textDecorations query parameter). Possible values are
 * Raw—Use Unicode characters to mark content that needs special formatting.
 * The Unicode characters are in the range E000 through E019. For example, Bing
 * uses E000 and E001 to mark the beginning and end of query terms for hit
 * highlighting. HTML—Use HTML tags to mark content that needs special
 * formatting. For example, use <b> tags to highlight query terms in display
 * strings. The default is Raw. For display strings that contain escapable HTML
 * characters such as <, >, and &, if textFormat is set to HTML, Bing escapes
 * the characters as appropriate (for example, < is escaped to <). Possible
 * values include: 'Raw', 'Html'
 *
 * @param {object} [options.customHeaders] Headers that will be added to the
 * request
 *
 * @param {function} callback - The callback.
 *
 * @returns {function} callback(err, result, request, response)
 *
 *                      {Error}  err        - The Error object if an error occurred, null otherwise.
 *
 *                      {object} [result]   - The deserialized result object if an error did not occur.
 *                      See {@link SearchResponse} for more information.
 *
 *                      {object} [request]  - The HTTP Request object if an error did not occur.
 *
 *                      {stream} [response] - The HTTP Response stream if an error did not occur.
 */
function _search(query, options, callback) {
   /* jshint validthis: true */
  let client = this.client;
  if(!callback && typeof options === 'function') {
    callback = options;
    options = null;
  }
  if (!callback) {
    throw new Error('callback cannot be null.');
  }
  let acceptLanguage = (options && options.acceptLanguage !== undefined) ? options.acceptLanguage : undefined;
  let pragma = (options && options.pragma !== undefined) ? options.pragma : undefined;
  let userAgent = (options && options.userAgent !== undefined) ? options.userAgent : undefined;
  let clientId = (options && options.clientId !== undefined) ? options.clientId : undefined;
  let clientIp = (options && options.clientIp !== undefined) ? options.clientIp : undefined;
  let location = (options && options.location !== undefined) ? options.location : undefined;
  let answerCount = (options && options.answerCount !== undefined) ? options.answerCount : undefined;
  let countryCode = (options && options.countryCode !== undefined) ? options.countryCode : undefined;
  let count = (options && options.count !== undefined) ? options.count : undefined;
  let freshness = (options && options.freshness !== undefined) ? options.freshness : undefined;
  let market = (options && options.market !== undefined) ? options.market : 'en-us';
  let offset = (options && options.offset !== undefined) ? options.offset : undefined;
  let promote = (options && options.promote !== undefined) ? options.promote : undefined;
  let responseFilter = (options && options.responseFilter !== undefined) ? options.responseFilter : undefined;
  let safeSearch = (options && options.safeSearch !== undefined) ? options.safeSearch : undefined;
  let setLang = (options && options.setLang !== undefined) ? options.setLang : undefined;
  let textDecorations = (options && options.textDecorations !== undefined) ? options.textDecorations : undefined;
  let textFormat = (options && options.textFormat !== undefined) ? options.textFormat : undefined;
  let xBingApisSDK = 'true';
  // Validate
  try {
    if (this.client.endpoint === null || this.client.endpoint === undefined || typeof this.client.endpoint.valueOf() !== 'string') {
      throw new Error('this.client.endpoint cannot be null or undefined and it must be of type string.');
    }
    if (acceptLanguage !== null && acceptLanguage !== undefined && typeof acceptLanguage.valueOf() !== 'string') {
      throw new Error('acceptLanguage must be of type string.');
    }
    if (pragma !== null && pragma !== undefined && typeof pragma.valueOf() !== 'string') {
      throw new Error('pragma must be of type string.');
    }
    if (userAgent !== null && userAgent !== undefined && typeof userAgent.valueOf() !== 'string') {
      throw new Error('userAgent must be of type string.');
    }
    if (clientId !== null && clientId !== undefined && typeof clientId.valueOf() !== 'string') {
      throw new Error('clientId must be of type string.');
    }
    if (clientIp !== null && clientIp !== undefined && typeof clientIp.valueOf() !== 'string') {
      throw new Error('clientIp must be of type string.');
    }
    if (location !== null && location !== undefined && typeof location.valueOf() !== 'string') {
      throw new Error('location must be of type string.');
    }
    if (answerCount !== null && answerCount !== undefined && typeof answerCount !== 'number') {
      throw new Error('answerCount must be of type number.');
    }
    if (countryCode !== null && countryCode !== undefined && typeof countryCode.valueOf() !== 'string') {
      throw new Error('countryCode must be of type string.');
    }
    if (count !== null && count !== undefined && typeof count !== 'number') {
      throw new Error('count must be of type number.');
    }
    if (freshness !== null && freshness !== undefined && typeof freshness.valueOf() !== 'string') {
      throw new Error('freshness must be of type string.');
    }
    if (market !== null && market !== undefined && typeof market.valueOf() !== 'string') {
      throw new Error('market must be of type string.');
    }
    if (offset !== null && offset !== undefined && typeof offset !== 'number') {
      throw new Error('offset must be of type number.');
    }
    if (Array.isArray(promote)) {
      for (let i = 0; i < promote.length; i++) {
        if (promote[i] !== null && promote[i] !== undefined && typeof promote[i].valueOf() !== 'string') {
          throw new Error('promote[i] must be of type string.');
        }
      }
    }
    if (query === null || query === undefined || typeof query.valueOf() !== 'string') {
      throw new Error('query cannot be null or undefined and it must be of type string.');
    }
    if (Array.isArray(responseFilter)) {
      for (let i1 = 0; i1 < responseFilter.length; i1++) {
        if (responseFilter[i1] !== null && responseFilter[i1] !== undefined && typeof responseFilter[i1].valueOf() !== 'string') {
          throw new Error('responseFilter[i1] must be of type string.');
        }
      }
    }
    if (safeSearch !== null && safeSearch !== undefined && typeof safeSearch.valueOf() !== 'string') {
      throw new Error('safeSearch must be of type string.');
    }
    if (setLang !== null && setLang !== undefined && typeof setLang.valueOf() !== 'string') {
      throw new Error('setLang must be of type string.');
    }
    if (textDecorations !== null && textDecorations !== undefined && typeof textDecorations !== 'boolean') {
      throw new Error('textDecorations must be of type boolean.');
    }
    if (textFormat !== null && textFormat !== undefined && typeof textFormat.valueOf() !== 'string') {
      throw new Error('textFormat must be of type string.');
    }
  } catch (error) {
    return callback(error);
  }

  // Construct URL
  let baseUrl = this.client.baseUri;
  let requestUrl = baseUrl + (baseUrl.endsWith('/') ? '' : '/') + 'search';
  requestUrl = requestUrl.replace('{Endpoint}', this.client.endpoint);
  let queryParameters = [];
  if (answerCount !== null && answerCount !== undefined) {
    queryParameters.push('answerCount=' + encodeURIComponent(answerCount.toString()));
  }
  if (countryCode !== null && countryCode !== undefined) {
    queryParameters.push('cc=' + encodeURIComponent(countryCode));
  }
  if (count !== null && count !== undefined) {
    queryParameters.push('count=' + encodeURIComponent(count.toString()));
  }
  if (freshness !== null && freshness !== undefined) {
    queryParameters.push('freshness=' + encodeURIComponent(freshness));
  }
  if (market !== null && market !== undefined) {
    queryParameters.push('mkt=' + encodeURIComponent(market));
  }
  if (offset !== null && offset !== undefined) {
    queryParameters.push('offset=' + encodeURIComponent(offset.toString()));
  }
  if (promote !== null && promote !== undefined) {
    queryParameters.push('promote=' + encodeURIComponent(promote.join(',')));
  }
  queryParameters.push('q=' + encodeURIComponent(query));
  if (responseFilter !== null && responseFilter !== undefined) {
    queryParameters.push('responseFilter=' + encodeURIComponent(responseFilter.join(',')));
  }
  if (safeSearch !== null && safeSearch !== undefined) {
    queryParameters.push('safeSearch=' + encodeURIComponent(safeSearch));
  }
  if (setLang !== null && setLang !== undefined) {
    queryParameters.push('setLang=' + encodeURIComponent(setLang));
  }
  if (textDecorations !== null && textDecorations !== undefined) {
    queryParameters.push('textDecorations=' + encodeURIComponent(textDecorations.toString()));
  }
  if (textFormat !== null && textFormat !== undefined) {
    queryParameters.push('textFormat=' + encodeURIComponent(textFormat));
  }
  if (queryParameters.length > 0) {
    requestUrl += '?' + queryParameters.join('&');
  }

  // Create HTTP transport objects
  let httpRequest = new WebResource();
  httpRequest.method = 'GET';
  httpRequest.url = requestUrl;
  httpRequest.headers = {};
  // Set Headers
  httpRequest.headers['Content-Type'] = 'application/json; charset=utf-8';
  if (xBingApisSDK !== undefined && xBingApisSDK !== null) {
    httpRequest.headers['X-BingApis-SDK'] = xBingApisSDK;
  }
  if (acceptLanguage !== undefined && acceptLanguage !== null) {
    httpRequest.headers['Accept-Language'] = acceptLanguage;
  }
  if (pragma !== undefined && pragma !== null) {
    httpRequest.headers['Pragma'] = pragma;
  }
  if (userAgent !== undefined && userAgent !== null) {
    httpRequest.headers['User-Agent'] = userAgent;
  }
  if (clientId !== undefined && clientId !== null) {
    httpRequest.headers['X-MSEdge-ClientID'] = clientId;
  }
  if (clientIp !== undefined && clientIp !== null) {
    httpRequest.headers['X-MSEdge-ClientIP'] = clientIp;
  }
  if (location !== undefined && location !== null) {
    httpRequest.headers['X-Search-Location'] = location;
  }
  if(options) {
    for(let headerName in options['customHeaders']) {
      if (options['customHeaders'].hasOwnProperty(headerName)) {
        httpRequest.headers[headerName] = options['customHeaders'][headerName];
      }
    }
  }
  httpRequest.body = null;
  // Send Request
  return client.pipeline(httpRequest, (err, response, responseBody) => {
    if (err) {
      return callback(err);
    }
    let statusCode = response.statusCode;
    if (statusCode !== 200) {
      let error = new Error(responseBody);
      error.statusCode = response.statusCode;
      error.request = msRest.stripRequest(httpRequest);
      error.response = msRest.stripResponse(response);
      if (responseBody === '') responseBody = null;
      let parsedErrorResponse;
      try {
        parsedErrorResponse = JSON.parse(responseBody);
        if (parsedErrorResponse) {
          let internalError = null;
          if (parsedErrorResponse.error) internalError = parsedErrorResponse.error;
          error.code = internalError ? internalError.code : parsedErrorResponse.code;
          error.message = internalError ? internalError.message : parsedErrorResponse.message;
        }
        if (parsedErrorResponse !== null && parsedErrorResponse !== undefined) {
          let resultMapper = new client.models['ErrorResponse']().mapper();
          error.body = client.deserialize(resultMapper, parsedErrorResponse, 'error.body');
        }
      } catch (defaultError) {
        error.message = `Error "${defaultError.message}" occurred in deserializing the responseBody ` +
                         `- "${responseBody}" for the default response.`;
        return callback(error);
      }
      return callback(error);
    }
    // Create Result
    let result = null;
    if (responseBody === '') responseBody = null;
    // Deserialize Response
    if (statusCode === 200) {
      let parsedResponse = null;
      try {
        parsedResponse = JSON.parse(responseBody);
        result = JSON.parse(responseBody);
        if (parsedResponse !== null && parsedResponse !== undefined) {
          let resultMapper = new client.models['SearchResponse']().mapper();
          result = client.deserialize(resultMapper, parsedResponse, 'result');
        }
      } catch (error) {
        let deserializationError = new Error(`Error ${error} occurred in deserializing the responseBody - ${responseBody}`);
        deserializationError.request = msRest.stripRequest(httpRequest);
        deserializationError.response = msRest.stripResponse(response);
        return callback(deserializationError);
      }
    }

    return callback(null, result, httpRequest, response);
  });
}

/** Class representing a Web. */
class Web {
  /**
   * Create a Web.
   * @param {WebSearchClient} client Reference to the service client.
   */
  constructor(client) {
    this.client = client;
    this._search = _search;
  }

  /**
   * @summary The Web Search API lets you send a search query to Bing and get
   * back search results that include links to webpages, images, and more.
   *
   * @param {string} query The user's search query term. The term may not be
   * empty. The term may contain Bing Advanced Operators. For example, to limit
   * results to a specific domain, use the site: operator.
   *
   * @param {object} [options] Optional Parameters.
   *
   * @param {string} [options.acceptLanguage] A comma-delimited list of one or
   * more languages to use for user interface strings. The list is in decreasing
   * order of preference. For additional information, including expected format,
   * see [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
   * header and the setLang query parameter are mutually exclusive; do not
   * specify both. If you set this header, you must also specify the cc query
   * parameter. Bing will use the first supported language it finds from the
   * list, and combine that language with the cc parameter value to determine the
   * market to return results for. If the list does not include a supported
   * language, Bing will find the closest language and market that supports the
   * request, and may use an aggregated or default market for the results instead
   * of a specified one. You should use this header and the cc query parameter
   * only if you specify multiple languages; otherwise, you should use the mkt
   * and setLang query parameters. A user interface string is a string that's
   * used as a label in a user interface. There are very few user interface
   * strings in the JSON response objects. Any links in the response objects to
   * Bing.com properties will apply the specified language.
   *
   * @param {string} [options.pragma] By default, Bing returns cached content, if
   * available. To prevent Bing from returning cached content, set the Pragma
   * header to no-cache (for example, Pragma: no-cache).
   *
   * @param {string} [options.userAgent] The user agent originating the request.
   * Bing uses the user agent to provide mobile users with an optimized
   * experience. Although optional, you are strongly encouraged to always specify
   * this header. The user-agent should be the same string that any commonly used
   * browser would send. For information about user agents, see [RFC
   * 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
   *
   * @param {string} [options.clientId] Bing uses this header to provide users
   * with consistent behavior across Bing API calls. Bing often flights new
   * features and improvements, and it uses the client ID as a key for assigning
   * traffic on different flights. If you do not use the same client ID for a
   * user across multiple requests, then Bing may assign the user to multiple
   * conflicting flights. Being assigned to multiple conflicting flights can lead
   * to an inconsistent user experience. For example, if the second request has a
   * different flight assignment than the first, the experience may be
   * unexpected. Also, Bing can use the client ID to tailor web results to that
   * client ID's search history, providing a richer experience for the user. Bing
   * also uses this header to help improve result rankings by analyzing the
   * activity generated by a client ID. The relevance improvements help with
   * better quality of results delivered by Bing APIs and in turn enables higher
   * click-through rates for the API consumer. IMPORTANT: Although optional, you
   * should consider this header required. Persisting the client ID across
   * multiple requests for the same end user and device combination enables 1)
   * the API consumer to receive a consistent user experience, and 2) higher
   * click-through rates via better quality of results from the Bing APIs. Each
   * user that uses your application on the device must have a unique, Bing
   * generated client ID. If you do not include this header in the request, Bing
   * generates an ID and returns it in the X-MSEdge-ClientID response header. The
   * only time that you should NOT include this header in a request is the first
   * time the user uses your app on that device. Use the client ID for each Bing
   * API request that your app makes for this user on the device. Persist the
   * client ID. To persist the ID in a browser app, use a persistent HTTP cookie
   * to ensure the ID is used across all sessions. Do not use a session cookie.
   * For other apps such as mobile apps, use the device's persistent storage to
   * persist the ID. The next time the user uses your app on that device, get the
   * client ID that you persisted. Bing responses may or may not include this
   * header. If the response includes this header, capture the client ID and use
   * it for all subsequent Bing requests for the user on that device. If you
   * include the X-MSEdge-ClientID, you must not include cookies in the request.
   *
   * @param {string} [options.clientIp] The IPv4 or IPv6 address of the client
   * device. The IP address is used to discover the user's location. Bing uses
   * the location information to determine safe search behavior. Although
   * optional, you are encouraged to always specify this header and the
   * X-Search-Location header. Do not obfuscate the address (for example, by
   * changing the last octet to 0). Obfuscating the address results in the
   * location not being anywhere near the device's actual location, which may
   * result in Bing serving erroneous results.
   *
   * @param {string} [options.location] A semicolon-delimited list of key/value
   * pairs that describe the client's geographical location. Bing uses the
   * location information to determine safe search behavior and to return
   * relevant local content. Specify the key/value pair as <key>:<value>. The
   * following are the keys that you use to specify the user's location. lat
   * (required): The latitude of the client's location, in degrees. The latitude
   * must be greater than or equal to -90.0 and less than or equal to +90.0.
   * Negative values indicate southern latitudes and positive values indicate
   * northern latitudes. long (required): The longitude of the client's location,
   * in degrees. The longitude must be greater than or equal to -180.0 and less
   * than or equal to +180.0. Negative values indicate western longitudes and
   * positive values indicate eastern longitudes. re (required): The radius, in
   * meters, which specifies the horizontal accuracy of the coordinates. Pass the
   * value returned by the device's location service. Typical values might be 22m
   * for GPS/Wi-Fi, 380m for cell tower triangulation, and 18,000m for reverse IP
   * lookup. ts (optional): The UTC UNIX timestamp of when the client was at the
   * location. (The UNIX timestamp is the number of seconds since January 1,
   * 1970.) head (optional): The client's relative heading or direction of
   * travel. Specify the direction of travel as degrees from 0 through 360,
   * counting clockwise relative to true north. Specify this key only if the sp
   * key is nonzero. sp (optional): The horizontal velocity (speed), in meters
   * per second, that the client device is traveling. alt (optional): The
   * altitude of the client device, in meters. are (optional): The radius, in
   * meters, that specifies the vertical accuracy of the coordinates. Specify
   * this key only if you specify the alt key. Although many of the keys are
   * optional, the more information that you provide, the more accurate the
   * location results are. Although optional, you are encouraged to always
   * specify the user's geographical location. Providing the location is
   * especially important if the client's IP address does not accurately reflect
   * the user's physical location (for example, if the client uses VPN). For
   * optimal results, you should include this header and the X-MSEdge-ClientIP
   * header, but at a minimum, you should include this header.
   *
   * @param {number} [options.answerCount] The number of answers that you want
   * the response to include. The answers that Bing returns are based on ranking.
   * For example, if Bing returns webpages, images, videos, and relatedSearches
   * for a request and you set this parameter to two (2), the response includes
   * webpages and images.If you included the responseFilter query parameter in
   * the same request and set it to webpages and news, the response would include
   * only webpages.
   *
   * @param {string} [options.countryCode] A 2-character country code of the
   * country where the results come from. This API supports only the United
   * States market. If you specify this query parameter, it must be set to us. If
   * you set this parameter, you must also specify the Accept-Language header.
   * Bing uses the first supported language it finds from the languages list, and
   * combine that language with the country code that you specify to determine
   * the market to return results for. If the languages list does not include a
   * supported language, Bing finds the closest language and market that supports
   * the request, or it may use an aggregated or default market for the results
   * instead of a specified one. You should use this query parameter and the
   * Accept-Language query parameter only if you specify multiple languages;
   * otherwise, you should use the mkt and setLang query parameters. This
   * parameter and the mkt query parameter are mutually exclusive—do not specify
   * both.
   *
   * @param {number} [options.count] The number of search results to return in
   * the response. The default is 10 and the maximum value is 50. The actual
   * number delivered may be less than requested.Use this parameter along with
   * the offset parameter to page results.For example, if your user interface
   * displays 10 search results per page, set count to 10 and offset to 0 to get
   * the first page of results. For each subsequent page, increment offset by 10
   * (for example, 0, 10, 20). It is possible for multiple pages to include some
   * overlap in results.
   *
   * @param {string} [options.freshness] Filter search results by the following
   * age values: Day—Return webpages that Bing discovered within the last 24
   * hours. Week—Return webpages that Bing discovered within the last 7 days.
   * Month—Return webpages that discovered within the last 30 days. This filter
   * applies only to webpage results and not to the other results such as news
   * and images. Possible values include: 'Day', 'Week', 'Month'
   *
   * @param {string} [options.market] The market where the results come from.
   * Typically, mkt is the country where the user is making the request from.
   * However, it could be a different country if the user is not located in a
   * country where Bing delivers results. The market must be in the form
   * <language code>-<country code>. For example, en-US. The string is case
   * insensitive. If known, you are encouraged to always specify the market.
   * Specifying the market helps Bing route the request and return an appropriate
   * and optimal response. If you specify a market that is not listed in Market
   * Codes, Bing uses a best fit market code based on an internal mapping that is
   * subject to change. This parameter and the cc query parameter are mutually
   * exclusive—do not specify both.
   *
   * @param {number} [options.offset] The zero-based offset that indicates the
   * number of search results to skip before returning results. The default is 0.
   * The offset should be less than (totalEstimatedMatches - count). Use this
   * parameter along with the count parameter to page results. For example, if
   * your user interface displays 10 search results per page, set count to 10 and
   * offset to 0 to get the first page of results. For each subsequent page,
   * increment offset by 10 (for example, 0, 10, 20). it is possible for multiple
   * pages to include some overlap in results.
   *
   * @param {array} [options.promote] A comma-delimited list of answers that you
   * want the response to include regardless of their ranking. For example, if
   * you set answerCount) to two (2) so Bing returns the top two ranked answers,
   * but you also want the response to include news, you'd set promote to news.
   * If the top ranked answers are webpages, images, videos, and relatedSearches,
   * the response includes webpages and images because news is not a ranked
   * answer. But if you set promote to video, Bing would promote the video answer
   * into the response and return webpages, images, and videos. The answers that
   * you want to promote do not count against the answerCount limit. For example,
   * if the ranked answers are news, images, and videos, and you set answerCount
   * to 1 and promote to news, the response contains news and images. Or, if the
   * ranked answers are videos, images, and news, the response contains videos
   * and news. Possible values are Computation, Images, News, RelatedSearches,
   * SpellSuggestions, TimeZone, Videos, Webpages. Use only if you specify
   * answerCount.
   *
   * @param {array} [options.responseFilter] A comma-delimited list of answers to
   * include in the response. If you do not specify this parameter, the response
   * includes all search answers for which there's relevant data. Possible filter
   * values are Computation, Images, News, RelatedSearches, SpellSuggestions,
   * TimeZone, Videos, Webpages. Although you may use this filter to get a single
   * answer, you should instead use the answer-specific endpoint in order to get
   * richer results. For example, to receive only images, send the request to one
   * of the Image Search API endpoints. The RelatedSearches and SpellSuggestions
   * answers do not support a separate endpoint like the Image Search API does
   * (only the Web Search API returns them). To include answers that would
   * otherwise be excluded because of ranking, see the promote query parameter.
   *
   * @param {string} [options.safeSearch] A filter used to filter adult content.
   * Off: Return webpages with adult text, images, or videos. Moderate: Return
   * webpages with adult text, but not adult images or videos. Strict: Do not
   * return webpages with adult text, images, or videos. The default is Moderate.
   * If the request comes from a market that Bing's adult policy requires that
   * safeSearch is set to Strict, Bing ignores the safeSearch value and uses
   * Strict. If you use the site: query operator, there is the chance that the
   * response may contain adult content regardless of what the safeSearch query
   * parameter is set to. Use site: only if you are aware of the content on the
   * site and your scenario supports the possibility of adult content. Possible
   * values include: 'Off', 'Moderate', 'Strict'
   *
   * @param {string} [options.setLang] The language to use for user interface
   * strings. Specify the language using the ISO 639-1 2-letter language code.
   * For example, the language code for English is EN. The default is EN
   * (English). Although optional, you should always specify the language.
   * Typically, you set setLang to the same language specified by mkt unless the
   * user wants the user interface strings displayed in a different language.
   * This parameter and the Accept-Language header are mutually exclusive; do not
   * specify both. A user interface string is a string that's used as a label in
   * a user interface. There are few user interface strings in the JSON response
   * objects. Also, any links to Bing.com properties in the response objects
   * apply the specified language.
   *
   * @param {boolean} [options.textDecorations] A Boolean value that determines
   * whether display strings should contain decoration markers such as hit
   * highlighting characters. If true, the strings may include markers. The
   * default is false. To specify whether to use Unicode characters or HTML tags
   * as the markers, see the textFormat query parameter.
   *
   * @param {string} [options.textFormat] The type of markers to use for text
   * decorations (see the textDecorations query parameter). Possible values are
   * Raw—Use Unicode characters to mark content that needs special formatting.
   * The Unicode characters are in the range E000 through E019. For example, Bing
   * uses E000 and E001 to mark the beginning and end of query terms for hit
   * highlighting. HTML—Use HTML tags to mark content that needs special
   * formatting. For example, use <b> tags to highlight query terms in display
   * strings. The default is Raw. For display strings that contain escapable HTML
   * characters such as <, >, and &, if textFormat is set to HTML, Bing escapes
   * the characters as appropriate (for example, < is escaped to <). Possible
   * values include: 'Raw', 'Html'
   *
   * @param {object} [options.customHeaders] Headers that will be added to the
   * request
   *
   * @returns {Promise} A promise is returned
   *
   * @resolve {HttpOperationResponse<SearchResponse>} - The deserialized result object.
   *
   * @reject {Error} - The error object.
   */
  searchWithHttpOperationResponse(query, options) {
    let client = this.client;
    let self = this;
    return new Promise((resolve, reject) => {
      self._search(query, options, (err, result, request, response) => {
        let httpOperationResponse = new msRest.HttpOperationResponse(request, response);
        httpOperationResponse.body = result;
        if (err) { reject(err); }
        else { resolve(httpOperationResponse); }
        return;
      });
    });
  }

  /**
   * @summary The Web Search API lets you send a search query to Bing and get
   * back search results that include links to webpages, images, and more.
   *
   * @param {string} query The user's search query term. The term may not be
   * empty. The term may contain Bing Advanced Operators. For example, to limit
   * results to a specific domain, use the site: operator.
   *
   * @param {object} [options] Optional Parameters.
   *
   * @param {string} [options.acceptLanguage] A comma-delimited list of one or
   * more languages to use for user interface strings. The list is in decreasing
   * order of preference. For additional information, including expected format,
   * see [RFC2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html). This
   * header and the setLang query parameter are mutually exclusive; do not
   * specify both. If you set this header, you must also specify the cc query
   * parameter. Bing will use the first supported language it finds from the
   * list, and combine that language with the cc parameter value to determine the
   * market to return results for. If the list does not include a supported
   * language, Bing will find the closest language and market that supports the
   * request, and may use an aggregated or default market for the results instead
   * of a specified one. You should use this header and the cc query parameter
   * only if you specify multiple languages; otherwise, you should use the mkt
   * and setLang query parameters. A user interface string is a string that's
   * used as a label in a user interface. There are very few user interface
   * strings in the JSON response objects. Any links in the response objects to
   * Bing.com properties will apply the specified language.
   *
   * @param {string} [options.pragma] By default, Bing returns cached content, if
   * available. To prevent Bing from returning cached content, set the Pragma
   * header to no-cache (for example, Pragma: no-cache).
   *
   * @param {string} [options.userAgent] The user agent originating the request.
   * Bing uses the user agent to provide mobile users with an optimized
   * experience. Although optional, you are strongly encouraged to always specify
   * this header. The user-agent should be the same string that any commonly used
   * browser would send. For information about user agents, see [RFC
   * 2616](http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html).
   *
   * @param {string} [options.clientId] Bing uses this header to provide users
   * with consistent behavior across Bing API calls. Bing often flights new
   * features and improvements, and it uses the client ID as a key for assigning
   * traffic on different flights. If you do not use the same client ID for a
   * user across multiple requests, then Bing may assign the user to multiple
   * conflicting flights. Being assigned to multiple conflicting flights can lead
   * to an inconsistent user experience. For example, if the second request has a
   * different flight assignment than the first, the experience may be
   * unexpected. Also, Bing can use the client ID to tailor web results to that
   * client ID's search history, providing a richer experience for the user. Bing
   * also uses this header to help improve result rankings by analyzing the
   * activity generated by a client ID. The relevance improvements help with
   * better quality of results delivered by Bing APIs and in turn enables higher
   * click-through rates for the API consumer. IMPORTANT: Although optional, you
   * should consider this header required. Persisting the client ID across
   * multiple requests for the same end user and device combination enables 1)
   * the API consumer to receive a consistent user experience, and 2) higher
   * click-through rates via better quality of results from the Bing APIs. Each
   * user that uses your application on the device must have a unique, Bing
   * generated client ID. If you do not include this header in the request, Bing
   * generates an ID and returns it in the X-MSEdge-ClientID response header. The
   * only time that you should NOT include this header in a request is the first
   * time the user uses your app on that device. Use the client ID for each Bing
   * API request that your app makes for this user on the device. Persist the
   * client ID. To persist the ID in a browser app, use a persistent HTTP cookie
   * to ensure the ID is used across all sessions. Do not use a session cookie.
   * For other apps such as mobile apps, use the device's persistent storage to
   * persist the ID. The next time the user uses your app on that device, get the
   * client ID that you persisted. Bing responses may or may not include this
   * header. If the response includes this header, capture the client ID and use
   * it for all subsequent Bing requests for the user on that device. If you
   * include the X-MSEdge-ClientID, you must not include cookies in the request.
   *
   * @param {string} [options.clientIp] The IPv4 or IPv6 address of the client
   * device. The IP address is used to discover the user's location. Bing uses
   * the location information to determine safe search behavior. Although
   * optional, you are encouraged to always specify this header and the
   * X-Search-Location header. Do not obfuscate the address (for example, by
   * changing the last octet to 0). Obfuscating the address results in the
   * location not being anywhere near the device's actual location, which may
   * result in Bing serving erroneous results.
   *
   * @param {string} [options.location] A semicolon-delimited list of key/value
   * pairs that describe the client's geographical location. Bing uses the
   * location information to determine safe search behavior and to return
   * relevant local content. Specify the key/value pair as <key>:<value>. The
   * following are the keys that you use to specify the user's location. lat
   * (required): The latitude of the client's location, in degrees. The latitude
   * must be greater than or equal to -90.0 and less than or equal to +90.0.
   * Negative values indicate southern latitudes and positive values indicate
   * northern latitudes. long (required): The longitude of the client's location,
   * in degrees. The longitude must be greater than or equal to -180.0 and less
   * than or equal to +180.0. Negative values indicate western longitudes and
   * positive values indicate eastern longitudes. re (required): The radius, in
   * meters, which specifies the horizontal accuracy of the coordinates. Pass the
   * value returned by the device's location service. Typical values might be 22m
   * for GPS/Wi-Fi, 380m for cell tower triangulation, and 18,000m for reverse IP
   * lookup. ts (optional): The UTC UNIX timestamp of when the client was at the
   * location. (The UNIX timestamp is the number of seconds since January 1,
   * 1970.) head (optional): The client's relative heading or direction of
   * travel. Specify the direction of travel as degrees from 0 through 360,
   * counting clockwise relative to true north. Specify this key only if the sp
   * key is nonzero. sp (optional): The horizontal velocity (speed), in meters
   * per second, that the client device is traveling. alt (optional): The
   * altitude of the client device, in meters. are (optional): The radius, in
   * meters, that specifies the vertical accuracy of the coordinates. Specify
   * this key only if you specify the alt key. Although many of the keys are
   * optional, the more information that you provide, the more accurate the
   * location results are. Although optional, you are encouraged to always
   * specify the user's geographical location. Providing the location is
   * especially important if the client's IP address does not accurately reflect
   * the user's physical location (for example, if the client uses VPN). For
   * optimal results, you should include this header and the X-MSEdge-ClientIP
   * header, but at a minimum, you should include this header.
   *
   * @param {number} [options.answerCount] The number of answers that you want
   * the response to include. The answers that Bing returns are based on ranking.
   * For example, if Bing returns webpages, images, videos, and relatedSearches
   * for a request and you set this parameter to two (2), the response includes
   * webpages and images.If you included the responseFilter query parameter in
   * the same request and set it to webpages and news, the response would include
   * only webpages.
   *
   * @param {string} [options.countryCode] A 2-character country code of the
   * country where the results come from. This API supports only the United
   * States market. If you specify this query parameter, it must be set to us. If
   * you set this parameter, you must also specify the Accept-Language header.
   * Bing uses the first supported language it finds from the languages list, and
   * combine that language with the country code that you specify to determine
   * the market to return results for. If the languages list does not include a
   * supported language, Bing finds the closest language and market that supports
   * the request, or it may use an aggregated or default market for the results
   * instead of a specified one. You should use this query parameter and the
   * Accept-Language query parameter only if you specify multiple languages;
   * otherwise, you should use the mkt and setLang query parameters. This
   * parameter and the mkt query parameter are mutually exclusive—do not specify
   * both.
   *
   * @param {number} [options.count] The number of search results to return in
   * the response. The default is 10 and the maximum value is 50. The actual
   * number delivered may be less than requested.Use this parameter along with
   * the offset parameter to page results.For example, if your user interface
   * displays 10 search results per page, set count to 10 and offset to 0 to get
   * the first page of results. For each subsequent page, increment offset by 10
   * (for example, 0, 10, 20). It is possible for multiple pages to include some
   * overlap in results.
   *
   * @param {string} [options.freshness] Filter search results by the following
   * age values: Day—Return webpages that Bing discovered within the last 24
   * hours. Week—Return webpages that Bing discovered within the last 7 days.
   * Month—Return webpages that discovered within the last 30 days. This filter
   * applies only to webpage results and not to the other results such as news
   * and images. Possible values include: 'Day', 'Week', 'Month'
   *
   * @param {string} [options.market] The market where the results come from.
   * Typically, mkt is the country where the user is making the request from.
   * However, it could be a different country if the user is not located in a
   * country where Bing delivers results. The market must be in the form
   * <language code>-<country code>. For example, en-US. The string is case
   * insensitive. If known, you are encouraged to always specify the market.
   * Specifying the market helps Bing route the request and return an appropriate
   * and optimal response. If you specify a market that is not listed in Market
   * Codes, Bing uses a best fit market code based on an internal mapping that is
   * subject to change. This parameter and the cc query parameter are mutually
   * exclusive—do not specify both.
   *
   * @param {number} [options.offset] The zero-based offset that indicates the
   * number of search results to skip before returning results. The default is 0.
   * The offset should be less than (totalEstimatedMatches - count). Use this
   * parameter along with the count parameter to page results. For example, if
   * your user interface displays 10 search results per page, set count to 10 and
   * offset to 0 to get the first page of results. For each subsequent page,
   * increment offset by 10 (for example, 0, 10, 20). it is possible for multiple
   * pages to include some overlap in results.
   *
   * @param {array} [options.promote] A comma-delimited list of answers that you
   * want the response to include regardless of their ranking. For example, if
   * you set answerCount) to two (2) so Bing returns the top two ranked answers,
   * but you also want the response to include news, you'd set promote to news.
   * If the top ranked answers are webpages, images, videos, and relatedSearches,
   * the response includes webpages and images because news is not a ranked
   * answer. But if you set promote to video, Bing would promote the video answer
   * into the response and return webpages, images, and videos. The answers that
   * you want to promote do not count against the answerCount limit. For example,
   * if the ranked answers are news, images, and videos, and you set answerCount
   * to 1 and promote to news, the response contains news and images. Or, if the
   * ranked answers are videos, images, and news, the response contains videos
   * and news. Possible values are Computation, Images, News, RelatedSearches,
   * SpellSuggestions, TimeZone, Videos, Webpages. Use only if you specify
   * answerCount.
   *
   * @param {array} [options.responseFilter] A comma-delimited list of answers to
   * include in the response. If you do not specify this parameter, the response
   * includes all search answers for which there's relevant data. Possible filter
   * values are Computation, Images, News, RelatedSearches, SpellSuggestions,
   * TimeZone, Videos, Webpages. Although you may use this filter to get a single
   * answer, you should instead use the answer-specific endpoint in order to get
   * richer results. For example, to receive only images, send the request to one
   * of the Image Search API endpoints. The RelatedSearches and SpellSuggestions
   * answers do not support a separate endpoint like the Image Search API does
   * (only the Web Search API returns them). To include answers that would
   * otherwise be excluded because of ranking, see the promote query parameter.
   *
   * @param {string} [options.safeSearch] A filter used to filter adult content.
   * Off: Return webpages with adult text, images, or videos. Moderate: Return
   * webpages with adult text, but not adult images or videos. Strict: Do not
   * return webpages with adult text, images, or videos. The default is Moderate.
   * If the request comes from a market that Bing's adult policy requires that
   * safeSearch is set to Strict, Bing ignores the safeSearch value and uses
   * Strict. If you use the site: query operator, there is the chance that the
   * response may contain adult content regardless of what the safeSearch query
   * parameter is set to. Use site: only if you are aware of the content on the
   * site and your scenario supports the possibility of adult content. Possible
   * values include: 'Off', 'Moderate', 'Strict'
   *
   * @param {string} [options.setLang] The language to use for user interface
   * strings. Specify the language using the ISO 639-1 2-letter language code.
   * For example, the language code for English is EN. The default is EN
   * (English). Although optional, you should always specify the language.
   * Typically, you set setLang to the same language specified by mkt unless the
   * user wants the user interface strings displayed in a different language.
   * This parameter and the Accept-Language header are mutually exclusive; do not
   * specify both. A user interface string is a string that's used as a label in
   * a user interface. There are few user interface strings in the JSON response
   * objects. Also, any links to Bing.com properties in the response objects
   * apply the specified language.
   *
   * @param {boolean} [options.textDecorations] A Boolean value that determines
   * whether display strings should contain decoration markers such as hit
   * highlighting characters. If true, the strings may include markers. The
   * default is false. To specify whether to use Unicode characters or HTML tags
   * as the markers, see the textFormat query parameter.
   *
   * @param {string} [options.textFormat] The type of markers to use for text
   * decorations (see the textDecorations query parameter). Possible values are
   * Raw—Use Unicode characters to mark content that needs special formatting.
   * The Unicode characters are in the range E000 through E019. For example, Bing
   * uses E000 and E001 to mark the beginning and end of query terms for hit
   * highlighting. HTML—Use HTML tags to mark content that needs special
   * formatting. For example, use <b> tags to highlight query terms in display
   * strings. The default is Raw. For display strings that contain escapable HTML
   * characters such as <, >, and &, if textFormat is set to HTML, Bing escapes
   * the characters as appropriate (for example, < is escaped to <). Possible
   * values include: 'Raw', 'Html'
   *
   * @param {object} [options.customHeaders] Headers that will be added to the
   * request
   *
   * @param {function} [optionalCallback] - The optional callback.
   *
   * @returns {function|Promise} If a callback was passed as the last parameter
   * then it returns the callback else returns a Promise.
   *
   * {Promise} A promise is returned
   *
   *                      @resolve {SearchResponse} - The deserialized result object.
   *
   *                      @reject {Error} - The error object.
   *
   * {function} optionalCallback(err, result, request, response)
   *
   *                      {Error}  err        - The Error object if an error occurred, null otherwise.
   *
   *                      {object} [result]   - The deserialized result object if an error did not occur.
   *                      See {@link SearchResponse} for more information.
   *
   *                      {object} [request]  - The HTTP Request object if an error did not occur.
   *
   *                      {stream} [response] - The HTTP Response stream if an error did not occur.
   */
  search(query, options, optionalCallback) {
    let client = this.client;
    let self = this;
    if (!optionalCallback && typeof options === 'function') {
      optionalCallback = options;
      options = null;
    }
    if (!optionalCallback) {
      return new Promise((resolve, reject) => {
        self._search(query, options, (err, result, request, response) => {
          if (err) { reject(err); }
          else { resolve(result); }
          return;
        });
      });
    } else {
      return self._search(query, options, optionalCallback);
    }
  }

}

module.exports = Web;


text:
<?php

class Google_Service_ToolResults_SuggestionProto extends Google_Model
{
  public $helpUrl;
  protected $longMessageType = 'Google_Service_ToolResults_SafeHtmlProto';
  protected $longMessageDataType = '';
  public $priority;
  public $pseudoResourceId;
  protected $regionType = 'Google_Service_ToolResults_RegionProto';
  protected $regionDataType = '';
  public $resourceName;
  public $screenId;
  public $secondaryPriority;
  protected $shortMessageType = 'Google_Service_ToolResults_SafeHtmlProto';
  protected $shortMessageDataType = '';
  public $title;

  public function setHelpUrl($helpUrl)
  {
    $this->helpUrl = $helpUrl;
  }
  public function getHelpUrl()
  {
    return $this->helpUrl;
  }
  /**
   * @param Google_Service_ToolResults_SafeHtmlProto
   */
  public function setLongMessage(Google_Service_ToolResults_SafeHtmlProto $longMessage)
  {
    $this->longMessage = $longMessage;
  }
  /**
   * @return Google_Service_ToolResults_SafeHtmlProto
   */
  public function getLongMessage()
  {
    return $this->longMessage;
  }
  public function setPriority($priority)
  {
    $this->priority = $priority;
  }
  public function getPriority()
  {
    return $this->priority;
  }
  public function setPseudoResourceId($pseudoResourceId)
  {
    $this->pseudoResourceId = $pseudoResourceId;
  }
  public function getPseudoResourceId()
  {
    return $this->pseudoResourceId;
  }
  /**
   * @param Google_Service_ToolResults_RegionProto
   */
  public function setRegion(Google_Service_ToolResults_RegionProto $region)
  {
    $this->region = $region;
  }
  /**
   * @return Google_Service_ToolResults_RegionProto
   */
  public function getRegion()
  {
    return $this->region;
  }
  public function setResourceName($resourceName)
  {
    $this->resourceName = $resourceName;
  }
  public function getResourceName()
  {
    return $this->resourceName;
  }
  public function setScreenId($screenId)
  {
    $this->screenId = $screenId;
  }
  public function getScreenId()
  {
    return $this->screenId;
  }
  public function setSecondaryPriority($secondaryPriority)
  {
    $this->secondaryPriority = $secondaryPriority;
  }
  public function getSecondaryPriority()
  {
    return $this->secondaryPriority;
  }
  /**
   * @param Google_Service_ToolResults_SafeHtmlProto
   */
  public function setShortMessage(Google_Service_ToolResults_SafeHtmlProto $shortMessage)
  {
    $this->shortMessage = $shortMessage;
  }
  /**
   * @return Google_Service_ToolResults_SafeHtmlProto
   */
  public function getShortMessage()
  {
    return $this->shortMessage;
  }
  public function setTitle($title)
  {
    $this->title = $title;
  }
  public function getTitle()
  {
    return $this->title;
  }
}

redpajama_set_name: RedPajamaGithub


text:
[`blocks.observable.extend()`](../api.md#blocks-observable-extend) method could be used to extend a particular observable functionality.
Great example is value formatting. Let's build value formatter.

Before using `extend()` you will need to implement the formatting logic. After that the formatter could be used for any observable:

```javascript
// Creating an extender. It should be added as a property on the blocks.observable object
blocks.observable.formatter = function (formatCallback) {
    // The idea behind the formatter is to create an additional property called displayValue
    // which could be used in data-queries to show the formatter value and in the same time
    // use the original observable to work with the raw integer value
    // <span>{{goldPrice.displayValue}}</span>

    // creating a displayValue property on the observable because this points to the observable
    // creating a dependency observable so we could control value assignments
    this.displayValue = blocks.observable({

        // sets the value by calling the format callback and assigning its result
        set: function (value) {
            // this points to the displayValue observable
            this._value = formatCallback(value);
            alert('formatted');
        },

        // returns the value
        get: function () {
            // this points to the displayValue observable
            return this._value;
        }
    });

    this.on('change', function () {
        this.displayValue(this());
    });

    this.displayValue(this());

    // it is possible to return an observable here which will return the observable when calling this extender
    // this is not necessary here because by default if you do not return observable the extender will return itself
    // so writing return this; will have the same effect as leaving it without the return
};

// initializing a formatter, providing the format callback parameter
// the code alerts formatted because the value is formatted initially
// Note: every parameter after the first is passed to the extender function
var goldPrice = blocks.observable(3).extend('formatter', function (value) {
    // a simple example that parses the value and appends to zeros to the end
    return parseInt(value, 10) + '.00';
});

// alerts 3
alert(goldPrice());

// alerts 3.00
alert(goldPrice.displayValue());

// alerts formatted
goldPrice(41);

// alerts 41
alert(goldPrice());

// alerts 41.00
alert(goldPrice.displayValue());
```


text:
package org.codehaus.groovy.ast.expr;

import org.codehaus.groovy.ast.ClassNode;
import org.codehaus.groovy.ast.GroovyCodeVisitor;

/**
 * Represents access to a Java/Groovy class in an expression, such
 * as when invoking a static method or accessing a static type
 */
public class ClassExpression extends Expression {

    public ClassExpression(ClassNode type) {
        super.setType(type);
    }

    public void visit(GroovyCodeVisitor visitor) {
        visitor.visitClassExpression(this);
    }

    public Expression transformExpression(ExpressionTransformer transformer) {
        return this;
    }

    public String getText() {
        return getType().getName();
    }

    public String toString() {
       return super.toString() + "[type: " + getType().getName() + "]";
    }
}


text:
CREATE TABLE bed5FloatScore (
    bin smallint not null,      # Index field
    chrom varchar(255) not null,	# Chromosome
    chromStart int unsigned not null,	# Start position in chromosome
    chromEnd int unsigned not null,	# End position in chromosome
    name varchar(255) not null,	# Name of item
    score int not null,	# 0-1000 score for useScore shading
    floatScore float not null,	# Floating point score.
              #Indices
    INDEX(chrom(16),bin),
    INDEX(chrom(16),chromStart),
    INDEX(name(16))
);


text:
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent">

    <ImageView
        android:id="@+id/calendar_item_image"
        android:layout_width="match_parent"
        android:layout_height="200dp"
        android:layout_alignParentLeft="true"
        android:layout_alignParentRight="true"
        android:layout_alignParentStart="true"
        android:layout_alignParentEnd="true"
        android:layout_gravity="center_horizontal"
        android:contentDescription="@string/image_description"
        android:scaleType="centerCrop" />

    <TextView
        android:id="@+id/calendar_item_title"
        android:layout_width="match_parent"
        android:layout_height="40dp"
        android:layout_marginTop="130dp"
        android:background="@color/text_dim"
        android:textColor="#ffffff"
        android:paddingLeft="10dp"
        android:paddingTop="7dp"
        android:paddingRight="10dp"
        android:gravity="start|bottom" />

    <TextView
        android:id="@+id/calendar_item_date"
        android:layout_width="match_parent"
        android:layout_height="30dp"
        android:layout_centerHorizontal="true"
        android:background="@color/text_dim"
        android:textColor="#ffffff"
        android:paddingLeft="10dp"
        android:paddingRight="10dp"
        android:layout_below="@+id/calendar_item_title"
        android:gravity="start" />

    <TextView
        android:id="@+id/calendar_item_text"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:layout_below="@+id/calendar_item_image"
        android:paddingLeft="20dp"
        android:paddingTop="10dp"
        android:paddingRight="20dp"
        android:paddingBottom="10dp"
        android:textAppearance="@android:style/TextAppearance.Small" />

    <View
        android:layout_width="fill_parent"
        android:layout_height="2dp"
        android:layout_marginBottom="15dp"
        android:layout_marginLeft="20dp"
        android:layout_marginRight="20dp"
        android:background="@color/text_dim"
        android:layout_below="@+id/calendar_item_text"/>
</RelativeLayout>


text:
<?xml version="1.0"?>
<!--
  Copyright (c) 2010, The HSQL Development Group. All rights reserved.
  Released under the HSQL license, available at http://hsqldb.org
-->
<project name="hsqldb-antivy-setup">
  <target name="ivy-setup" depends="-ivy-setup"/>

  <target name="-ivy-setup" unless="-ivy.is.setup">
    <fail>An Ant target that you have invoked, directly or indirectly, has been changed
to reply upon Gradle.
Please rerun your Ant command as a Gradle command, using 'gradlew' in place of
'ant'.</fail>
  </target>
</project>


text:
package com.aspose.diagram.examples.TextBoxes;

import com.aspose.diagram.Diagram;
import com.aspose.diagram.SaveFileFormat;
import com.aspose.diagram.Shape;
import com.aspose.diagram.examples.Utils;

public class SetShapeTextPositionAtTop {

	public static void main(String[] args) throws Exception {
		// ExStart:SetShapeTextPositionAtTop
		// The path to the documents directory.
		String dataDir = Utils.getSharedDataDir(SetShapeTextPositionAtTop.class) + "TextBoxes/";
		// load source Visio diagram
		Diagram diagram = new Diagram(dataDir + "Drawing1.vsdx");
		// get shape
		long shapeid = 1;
		Shape shape = diagram.getPages().getPage("Page-1").getShapes().getShape(shapeid);

		// set text position at the top,
		// TxtLocPinY = "TxtHeight*0" and TxtPinY = "Height*1"
		shape.getTextXForm().getTxtLocPinY().setValue(0);
		shape.getTextXForm().getTxtPinY().setValue(shape.getXForm().getHeight().getValue());

		// set orientation angle
		double angleDeg = 0;
		double angleRad = (Math.PI / 180) * angleDeg;
		shape.getTextXForm().getTxtAngle().setValue(angleRad);

		// save Visio diagram in the local storage
		diagram.save(dataDir + "SetShapeTextPositionAtTop_Out.vsdx", SaveFileFormat.VSDX);
		// ExEnd:SetShapeTextPositionAtTop
	}

}


text:
#import <XCTest/XCTest.h>
#import "SPTDataLoaderTimeProviderImplementation.h"

@interface SPTDataLoaderTimeProviderImplementationTest: XCTestCase

@end

@implementation SPTDataLoaderTimeProviderImplementationTest

- (void)testCurrentTimeIsEqualToCFAbsoluteTimeGetCurrent
{
    // Given
    const CFAbsoluteTime expectedTime = CFAbsoluteTimeGetCurrent();
    SPTDataLoaderTimeProviderImplementation *timeProvider = [SPTDataLoaderTimeProviderImplementation new];

    // When
    const CFAbsoluteTime actualTime = timeProvider.currentTime;

    // Time
    XCTAssertEqualWithAccuracy(expectedTime, actualTime, 0.1, @"The currentTime is not equal to the system time given by CFAbsoluteTimeGetCurrent()");
}

@end


text:
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

//Automatically adjusts pitch od all audiosources in gameobject, and its children if specified
public class MicrogameAutoPitch : MonoBehaviour
{
	[SerializeField]
	private bool includeChildren;
	private AudioSource[] sources;

	void Awake()
	{
		sources = includeChildren ? GetComponentsInChildren<AudioSource>() : GetComponents<AudioSource>();
	}

	void Start()
	{
		updatePitch();
	}

	public void updatePitch()
	{
		for (int i = 0; i < sources.Length; i++)
		{
			sources[i].pitch = Time.timeScale;
		}
	}
}


text:
package com.psddev.dari.util;

/** Thrown when an object could not be converted into a date. */
@SuppressWarnings("serial")
public class DateFormatException extends IllegalArgumentException {

    /** Creates an instance with the given message. */
    public DateFormatException(String message) {
        super(message);
    }
}


text:
import { Code } from '@expo/html-elements';
import React, { PropsWithChildren } from 'react';
import { StyleSheet, View, ViewStyle, TextStyle } from 'react-native';

type Props = PropsWithChildren<{
  containerStyle?: ViewStyle;
  textStyle?: TextStyle;
}>;

const MonoText = ({ children, containerStyle, textStyle }: Props) => (
  <View style={[styles.container, containerStyle]}>
    {children}
  </View>
);

const styles = StyleSheet.create({
  container: {
    backgroundColor: '#fff',
    padding: 6,
    marginVertical: 8,
    borderWidth: 1,
    borderColor: '#666',
  },
  monoText: {
    fontSize: 10,
  },
});

export default MonoText;


text:
package org.jf.dexlib2.dexbacked.raw;

import org.jf.dexlib2.dexbacked.DexBackedDexFile;
import org.jf.dexlib2.dexbacked.raw.util.DexAnnotator;
import org.jf.dexlib2.util.AnnotatedBytes;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class FieldIdItem {
    public static final int ITEM_SIZE = 8;

    public static final int CLASS_OFFSET = 0;
    public static final int TYPE_OFFSET = 2;
    public static final int NAME_OFFSET = 4;

    @Nonnull
    public static SectionAnnotator makeAnnotator(@Nonnull DexAnnotator annotator, @Nonnull MapItem mapItem) {
        return new SectionAnnotator(annotator, mapItem) {
            @Nonnull @Override public String getItemName() {
                return "field_id_item";
            }

            @Override
            protected void annotateItem(@Nonnull AnnotatedBytes out, int itemIndex, @Nullable String itemIdentity) {
                int classIndex = dexFile.readUshort(out.getCursor());
                out.annotate(2, "class_idx = %s", TypeIdItem.getReferenceAnnotation(dexFile, classIndex));

                int typeIndex = dexFile.readUshort(out.getCursor());
                out.annotate(2, "return_type_idx = %s", TypeIdItem.getReferenceAnnotation(dexFile, typeIndex));

                int nameIndex = dexFile.readSmallUint(out.getCursor());
                out.annotate(4, "name_idx = %s", StringIdItem.getReferenceAnnotation(dexFile, nameIndex));
            }
        };
    }

    @Nonnull
    public static String asString(@Nonnull DexBackedDexFile dexFile, int fieldIndex) {
        int fieldOffset = dexFile.getFieldIdItemOffset(fieldIndex);
        int classIndex = dexFile.readUshort(fieldOffset + CLASS_OFFSET);
        String classType = dexFile.getType(classIndex);

        int typeIndex = dexFile.readUshort(fieldOffset + TYPE_OFFSET);
        String fieldType = dexFile.getType(typeIndex);

        int nameIndex = dexFile.readSmallUint(fieldOffset + NAME_OFFSET);
        String fieldName = dexFile.getString(nameIndex);

        return String.format("%s->%s:%s", classType, fieldName, fieldType);
    }

    @Nonnull
    public static String getReferenceAnnotation(@Nonnull DexBackedDexFile dexFile, int fieldIndex) {
        try {
            String fieldString = asString(dexFile, fieldIndex);
            return String.format("field_id_item[%d]: %s", fieldIndex, fieldString);
        } catch (Exception ex) {
            ex.printStackTrace(System.err);
        }
        return String.format("field_id_item[%d]", fieldIndex);
    }

    public static String[] getFields(@Nonnull RawDexFile dexFile) {
        MapItem mapItem = dexFile.getMapItemForSection(ItemType.FIELD_ID_ITEM);
        if (mapItem == null) {
            return new String[0];
        }

        int fieldCount = mapItem.getItemCount();
        String[] ret = new String[fieldCount];
        for (int i=0; i<fieldCount; i++) {
            ret[i] = asString(dexFile, i);
        }
        return ret;
    }
}


text:
#include "mongoc-tests.h"

#include "ha-test.h"

#include "mongoc-client-private.h"
#include "mongoc-cursor-private.h"
#include "mongoc-write-concern-private.h"
#include "TestSuite.h"

#undef G_LOG_DOMAIN
#define G_LOG_DOMAIN "test"

static ha_replica_set_t *replica_set;
static ha_node_t *r1;
static ha_node_t *r2;
static ha_node_t *r3;
static ha_node_t *a1;
static bool use_pool;

static void
insert_test_docs (mongoc_collection_t *collection)
{
   mongoc_write_concern_t *write_concern;
   bson_error_t error;
   bson_oid_t oid;
   bson_t b;
   int i;

   write_concern = mongoc_write_concern_new ();
   mongoc_write_concern_set_w (write_concern, 3);

   {
      const bson_t *wc;
      char *str;

      wc = _mongoc_write_concern_get_gle (write_concern);
      str = bson_as_extended_json (wc, NULL);
      fprintf (stderr, "Write Concern: %s\n", str);
      bson_free (str);
   }

   for (i = 0; i < 200; i++) {
      bson_init (&b);
      bson_oid_init (&oid, NULL);
      bson_append_oid (&b, "_id", 3, &oid);

      ASSERT_OR_PRINT (
         mongoc_collection_insert (
            collection, MONGOC_INSERT_NONE, &b, write_concern, &error),
         error);
      bson_destroy (&b);
   }

   mongoc_write_concern_destroy (write_concern);
}

static ha_node_t *
get_replica (mongoc_client_t *client, uint32_t id)
{
   mongoc_server_description_t *description;
   ha_node_t *iter;

   description = mongoc_topology_server_by_id (client->topology, id, NULL);
   BSON_ASSERT (description);

   for (iter = replica_set->nodes; iter; iter = iter->next) {
      if (iter->port == description->host.port) {
         mongoc_server_description_destroy (description);
         return iter;
      }
   }

   mongoc_server_description_destroy (description);
   BSON_ASSERT (false);
   return NULL;
}

/*
 *--------------------------------------------------------------------------
 *
 * test1 --
 *
 *       Tests the failover scenario of a node having a network partition
 *       between the time the client recieves the first OP_REPLY and the
 *       submission of a followup OP_GETMORE.
 *
 *       This function will abort() upon failure.
 *
 * Returns:
 *       None.
 *
 * Side effects:
 *       None.
 *
 *--------------------------------------------------------------------------
 */

static void
test1 (void)
{
   mongoc_server_description_t *description;
   mongoc_collection_t *collection;
   mongoc_read_prefs_t *read_prefs;
   mongoc_cursor_t *cursor;
   mongoc_client_t *client;
   mongoc_client_pool_t *pool = NULL;
   const bson_t *doc;
   bson_error_t error;
   bool r;
   ha_node_t *replica;
   bson_t q;
   int i;

   bson_init (&q);

   if (use_pool) {
      pool = ha_replica_set_create_client_pool (replica_set);
      client = mongoc_client_pool_pop (pool);
   } else {
      client = ha_replica_set_create_client (replica_set);
   }

   collection = mongoc_client_get_collection (client, "test1", "test1");

   MONGOC_DEBUG ("Inserting test documents.");
   insert_test_docs (collection);
   MONGOC_INFO ("Test documents inserted.");

   read_prefs = mongoc_read_prefs_new (MONGOC_READ_SECONDARY);

   MONGOC_DEBUG ("Sending query to a SECONDARY.");
   cursor = mongoc_collection_find (
      collection, MONGOC_QUERY_NONE, 0, 0, 100, &q, NULL, read_prefs);

   BSON_ASSERT (cursor);
   BSON_ASSERT (!cursor->server_id);

   /*
    * Send OP_QUERY to server and get first document back.
    */
   MONGOC_INFO ("Sending OP_QUERY.");
   r = mongoc_cursor_next (cursor, &doc);
   BSON_ASSERT (r);
   BSON_ASSERT (cursor->server_id);
   BSON_ASSERT (cursor->sent);
   BSON_ASSERT (!cursor->done);
   BSON_ASSERT (cursor->rpc.reply.n_returned == 100);
   BSON_ASSERT (!cursor->end_of_event);

   /*
    * Make sure we queried a secondary.
    */
   description = mongoc_topology_server_by_id (
      client->topology, cursor->server_id, &error);
   ASSERT_OR_PRINT (description, error);
   BSON_ASSERT (description->type != MONGOC_SERVER_RS_PRIMARY);
   mongoc_server_description_destroy (description);

   /*
    * Exhaust the items in our first OP_REPLY.
    */
   MONGOC_DEBUG ("Exhausting OP_REPLY.");
   for (i = 0; i < 98; i++) {
      r = mongoc_cursor_next (cursor, &doc);
      BSON_ASSERT (r);
      BSON_ASSERT (cursor->server_id);
      BSON_ASSERT (!cursor->done);
      BSON_ASSERT (!cursor->end_of_event);
   }

   /*
    * Finish off the last item in this OP_REPLY.
    */
   MONGOC_INFO ("Fetcing last doc from OP_REPLY.");
   r = mongoc_cursor_next (cursor, &doc);
   BSON_ASSERT (r);
   BSON_ASSERT (cursor->server_id);
   BSON_ASSERT (cursor->sent);
   BSON_ASSERT (!cursor->done);
   BSON_ASSERT (!cursor->end_of_event);

   /*
    * Determine which node we queried by using the server_id to
    * get the cluster information.
    */

   BSON_ASSERT (cursor->server_id);
   replica = get_replica (client, cursor->server_id);

   /*
    * Kill the node we are communicating with.
    */
   MONGOC_INFO ("Killing replicaSet node to synthesize failure.");
   ha_node_kill (replica);

   /*
    * Try to fetch the next result set, expect failure.
    */
   MONGOC_DEBUG ("Checking for expected failure.");
   r = mongoc_cursor_next (cursor, &doc);
   BSON_ASSERT (!r);

   r = mongoc_cursor_error (cursor, &error);
   BSON_ASSERT (r);
   MONGOC_WARNING ("%s", error.message);

   mongoc_cursor_destroy (cursor);
   mongoc_read_prefs_destroy (read_prefs);
   mongoc_collection_destroy (collection);

   if (use_pool) {
      mongoc_client_pool_push (pool, client);
      mongoc_client_pool_destroy (pool);
   } else {
      mongoc_client_destroy (client);
   }
   bson_destroy (&q);

   ha_node_restart (replica);
}

static void
test2 (void)
{
   mongoc_read_prefs_t *read_prefs;
   mongoc_collection_t *collection;
   mongoc_cursor_t *cursor;
   mongoc_client_t *client;
   mongoc_client_pool_t *pool = NULL;
   const bson_t *doc;
   bson_error_t error;
   bool r;
   bson_t q;

   bson_init (&q);

   /*
    * Start by killing 2 of the replica set nodes.
    */
   ha_node_kill (r1);
   ha_node_kill (r2);

   if (use_pool) {
      pool = ha_replica_set_create_client_pool (replica_set);
      client = mongoc_client_pool_pop (pool);
   } else {
      client = ha_replica_set_create_client (replica_set);
   }

   collection = mongoc_client_get_collection (client, "test2", "test2");

   /*
    * Perform a query and ensure it fails with no nodes available.
    */
   read_prefs = mongoc_read_prefs_new (MONGOC_READ_SECONDARY_PREFERRED);
   cursor = mongoc_collection_find (
      collection, MONGOC_QUERY_NONE, 0, 100, 0, &q, NULL, read_prefs);

   /*
    * Try to submit OP_QUERY. Since it is SECONDARY PREFERRED, it should
    * succeed if there is any node up (which r3 is up).
    */
   r = mongoc_cursor_next (cursor, &doc);
   BSON_ASSERT (!r); /* No docs */

   /* No error, slaveOk was set */
   ASSERT_OR_PRINT (!mongoc_cursor_error (cursor, &error), error);

   mongoc_read_prefs_destroy (read_prefs);
   mongoc_cursor_destroy (cursor);
   mongoc_collection_destroy (collection);

   if (use_pool) {
      mongoc_client_pool_push (pool, client);
      mongoc_client_pool_destroy (pool);
   } else {
      mongoc_client_destroy (client);
   }

   bson_destroy (&q);

   ha_node_restart (r1);
   ha_node_restart (r2);
}

/*
 *--------------------------------------------------------------------------
 *
 * main --
 *
 *       Test various replica-set failure scenarios.
 *
 * Returns:
 *       0 on success; otherwise context specific error code.
 *
 * Side effects:
 *       None.
 *
 *--------------------------------------------------------------------------
 */

int
main (int argc,     /* IN */
      char *argv[]) /* IN */
{
   mongoc_init ();

   replica_set = ha_replica_set_new ("repltest1");
   r1 = ha_replica_set_add_replica (replica_set, "replica1");
   r2 = ha_replica_set_add_replica (replica_set, "replica2");
   r3 = ha_replica_set_add_replica (replica_set, "replica3");
   a1 = ha_replica_set_add_arbiter (replica_set, "arbiter1");

   ha_replica_set_start (replica_set);

   ha_replica_set_wait_for_healthy (replica_set);
   use_pool = false;
   run_test ("/ReplicaSet/single/lose_node_during_cursor", test1);

   ha_replica_set_wait_for_healthy (replica_set);
   use_pool = true;
   run_test ("/ReplicaSet/pool/lose_node_during_cursor", test1);

   ha_replica_set_wait_for_healthy (replica_set);
   use_pool = false;
   run_test ("/ReplicaSet/single/cursor_with_2_of_3_replicas_down", test2);

   ha_replica_set_wait_for_healthy (replica_set);
   use_pool = true;
   run_test ("/ReplicaSet/pool/cursor_with_2_of_3_replicas_down", test2);

   ha_replica_set_wait_for_healthy (replica_set);

   ha_replica_set_shutdown (replica_set);
   ha_replica_set_destroy (replica_set);

   mongoc_cleanup ();

   return 0;
}


text:
package tr.edu.iyte.ceng389.dothese.activity;

import tr.edu.iyte.ceng389.dothese.fragment.NotificationPreferencesFragment;
import android.os.Bundle;
import android.support.v4.app.FragmentActivity;
import android.view.MenuItem;

/** Notification preference activity to choose the time for the notifications
 * that will be created before a task deadline
 *
 * @author ezgihacihalil - 180201058
 * @author mehmetakiftutuncu - 170201018 */
public class NotificationPreferencesActivity extends FragmentActivity
{
	@Override
    public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);

        getFragmentManager().beginTransaction().replace(android.R.id.content, new NotificationPreferencesFragment()).commit();

        // Show home button in the action bar which will go back to main activity
        getActionBar().setDisplayHomeAsUpEnabled(true);
        getActionBar().setHomeButtonEnabled(true);
    }

	@Override
	public boolean onOptionsItemSelected(MenuItem item)
	{
		switch(item.getItemId())
		{
			case android.R.id.home:
				finish();
				return true;

			default:
				return false;
		}
	}
}


text:
Pi
==

A GUI program that calculates the mathematical constant Pi using the 4/1-4/3+4/5 method