Protected get -------------- Makes a GET request and executes a callback if it was success and tries to repeat request otherwise
509918
function getProtected(url, callback) {
    get(url, callback, () => {
        setTimeout(
            getProtected.bind(null, url, callback),
            1500
        );
    });
}
1282278
def _get(self, *args, **kwargs):
        
        return self._request(requests.get, *args, **kwargs)
156653
def do_GET(self):
        """"""
        logging.debug("New GET request.")

        query = parse_qs(urlparse(self.path).query)
        command = query['command'][0].split(' ')
        async = bool(int(query.get('async', [False])[0]))
        output = run_command(command, asynchronous=async)

        self.respond(output)
38419
function get(cb) {
    getRaw(function (err, num, muted) {
      timeouts.push(setTimeout(function () {
        cb(err, num, muted);
      }), 0);
    });
  }
593441
@Override
	public void execute(HttpGet httpGet, FutureCallback<HttpResponse> futureCallback) {

		try {
			if (httpGet == null) {
				throw new RuntimeException("Cannot issue GET request with HttpGet object");
			}
			log.info("Executing GET request to " + httpGet.getURI().toString());
			thread = new GetThread(client, httpGet, futureCallback);
			thread.start();
		} catch (Exception e) {
			log.error(e.getMessage());
			futureCallback.failed(e);
		}
	}
1296710
def get(self, timeout=None):
        
        if timeout is None:
            self._lock.acquire()
        else:
            self._wait(timeout)
        
        res = self.result
        if res[0]:
            return res[1]
        else:
            raise res[1]
880554
protected void executeGetAsync(HttpCallback callback, String url, Object tag, StrParam... strParams) {
        Request.Builder builder = mBuilder.builderGet(url, strParams);
        async(builder, tag, callback);
    }
627371
public RequestBuilder get(final String url) {

    checkNotNull(url, "url may not be null");
    final AsyncHttpClient.BoundRequestBuilder ningRequestBuilder = asyncHttpClient.prepareGet(url);
    return createNewRequestBuilder(url, ningRequestBuilder);
  }
10781
function get(url, bubbleError) {

        /* use url as key for the cache */
        var value = cache.fetch(url)
        var defer = $.Deferred()

        if (value) {
            return defer.resolve(value) /* return a resolved promise with the cached value */
        } else {
            try {
                $.get(url)
                    .done(function(value) {
                        defer.resolve(cache.save(url, decode(value)))
                    }).fail(function(err) {
                        log(err.error)
                    })
            } catch (err) {
                if (bubbleError) {
                    throw new Error(err)
                } else {
                    log(err.error)
                }
            }
        }
        return defer
    }
144396
public T get() throws IllegalStateException {
    switch (this.state) {
      case INCOMPLETE:
        // Do not block browser so just throw ex
        throw new IllegalStateException("The server response did not yet recieved.");
      case FAILED:
        throw new IllegalStateException(this.error);
      case SUCCEEDED:
        return this.value;
      default:
        throw new IllegalStateException("Something very unclear");
    }
  }
123205
function(params, headers, callback) {
        var url;
        url = this.client.url(false);
        return this.client.get(url, params, headers, callback);
      }
1292137
@SuppressWarnings("unchecked")
    @Override
    public <T> T get(EntityGetOperation<T> getter) throws ServiceException {
        getter.setProxyData(createProxyData());
        Object rawResponse = getResource(getter).get(getter.getResponseClass());
        Object processedResponse = getter.processResponse(rawResponse);
        return (T) processedResponse;
    }
278576
@Override
    public T get() throws InterruptedException {
        while (true) {
            synchronized (this) {
                if (completed) {
                    return results == null || results.isEmpty()
                        ? null
                        : results.get(0);
                }
                wait();
            }
        }
    }
256443
def get(url, parameters = {}, skip_status_check = false)
      response = connection.get("#{api_endpoint}#{url}", parameters)
      on_complete(response) unless skip_status_check
      response
    end
1233550
@SuppressWarnings("unchecked")
  public T get() {
    try {
      isLoaded();
      return (T) this;
    } catch (Error e) {
      load();
    }

    isLoaded();

    return (T) this;
  }
168340
def get(self):
        ''''''

        key = self.get_key_from_request()
        result = self.get_storage().get(key)

        return result if result else None
435154
function get( opts, clbk ) {
	request( opts, done );
	/**
	* FUNCTION: done( error, data )
	*	Callback invoked upon completing a request.
	*
	* @private
	* @param {Error|Null} error - error object
	* @param {String} data - response data
	* @returns {Void}
	*/
	function done( error, data ) {
		if ( error ) {
			return clbk( error );
		}
		data = transform( data );
		clbk( null, data );
	} // end FUNCTION done()
}