PUT request

@param -> url [partially qualified]
@param -> join boolean
430422
public function put($url, $data)
    {       
      $url = $this->join($url);
      return $this->request(API::API_METHOD_PUT, $url, $data);
    }
474882
def put(url, doc = nil, options = {})
      connection(url, options) do |uri, conn|
        conn.put(uri.request_uri, doc, options)
      end
    end
829003
public <T> Optional<T> PUT(String partialUrl, Object payload, GenericType<T> returnType)
    {    
        URI uri = buildUri(partialUrl);   
        return executePutRequest(uri, payload, null, null, returnType);
    }
846595
def put(self, endpoint, json=None, params=None, **kwargs):
        
        json = kwargs['data'] if 'data' in kwargs else json
        return self._make_request('put', endpoint, data=json, params=params)
331952
def put url, body=nil, options={}
      response = filtered_response(self.class.put(url, { :body => body, :query => options, headers: { 'content-type' => ''} }))
    end
1140396
def put(self, url, params=None, headers=None, content=None, form_content=None):
        # type: (str, Optional[Dict[str, str]], Optional[Dict[str, str]], Any, Optional[Dict[str, Any]]) -> ClientRequest
        
        request = self._request('PUT', url, params, headers, content, form_content)
        return request
780258
public RequestBuilder put(final String url) {

    checkNotNull(url, "url may not be null");
    final AsyncHttpClient.BoundRequestBuilder ningRequestBuilder = asyncHttpClient.preparePut(url);
    return createNewRequestBuilder(url, ningRequestBuilder);
  }
366932
public function put($url, $body = [], $headers = [], $options = [])
    {
        return $this->request('PUT', $url, $body, $headers, $options);
    }
926379
public function put($url, $params = null) {
    $this->params = $params;
    $this->method = 'PUT';
    $this->url = $url;

    return $this->request();
  }
1080632
public Response put(String restPath, Object payload, Map<String, String> queryParams) {
		LOG.debug("PUT: {}", restPath);
		return call(HttpMethod.PUT, restPath, Response.class, payload, queryParams);
	}
1189899
def rest_put_stream(self, url, stream, headers=None, session=None, verify=True, cert=None):
        
        res = session.put(url, headers=headers, data=stream, verify=verify, cert=cert)
        return res.text, res.status_code
121301
def put(path, data = {}, header = {})
      _send(json_request(Net::HTTP::Patch, path, data, header))
    end
497990
def put(path, params)
      headers = {}

      request('PUT', path, params.to_json, headers) do |resp|
        yield(resp) if block_given?
      end
    end
522028
public static String put(String url, String body) {
        return request(HttpRequest.put(replaceLocalHost(url)), body).body();
    }
481833
def put(path, stream, length)
      path = @uri.merge(path).path
      res = @handler.request_sending_stream(:put, path, stream, length, @headers)
      res.body
    end
592805
function put(argv, callback) {
  if (!argv[2]) {
    console.error("url is required");
    console.error("Usage : put <url> <data>");
    process.exit(-1);
  }
  if (!argv[3]) {
    console.error("data is required");
    console.error("Usage : put <url> <data>");
    process.exit(-1);
  }
  util.put(argv[2], argv[3], function(err, val, uri) {
    if (!err) {
      console.log('PUT to : ' + argv[2]);
    }
  });
}
591265
def put(path, data, options = {})
      uri = build_uri(path, options)

      request = Net::HTTP::Put.new(uri.request_uri)
      set_authorisation_header(request)
      request.set_form_data(data)

      response = https_client(uri).request(request)
    end