Updates this object using the data that exists on OneView
 @note Will overwrite any data that differs from OneView
 @param [Hash] header The header options for the request (key-value pairs)
 @return [Resource] self
555176
def refresh(header = self.class::DEFAULT_REQUEST_HEADER)
      ensure_client && ensure_uri
      response = @client.rest_get(@data['uri'], header, @api_version)
      body = @client.response_handler(response)
      set_all(body)
      self
    end
240890
def update(self, data):
        
        result = None
        if data:
            _dumps = self._dumps
            data = {
                key: _dumps(value)
                for key, value in data.items()}
            result = self._client.hmset(self.key_prefix, data)
        return result
975624
def set_header(self, name: str, value: _HeaderTypes) -> None:
        
        self._headers[name] = self._convert_header_value(value)
1300346
def list_available_request_headers(custom_headers:nil)
      response = list_available_request_headers_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
884799
def _update_response_location_header(self, resource):
        
        location = resource_to_url(resource, request=self.request)
        loc_hdr = ('Location', location)
        hdr_names = [hdr[0].upper() for hdr in self.request.response.headerlist]
        try:
            idx = hdr_names.index('LOCATION')
        except ValueError:
            self.request.response.headerlist.append(loc_hdr)
        else:
            # Replace existing location header.
            # FIXME: It is not clear under which conditions this happens, so
            #        we do not have a test for it yet.
            self.request.response.headerlist[idx] = loc_hdr
174288
def with_headers(self, headers):
        
        return self.replace(headers=_merge_maps(self.headers, headers))
608861
def update(self, byts):
        '''
        
        '''
        self.size += len(byts)
        [h[1].update(byts) for h in self.hashes]
44247
def delete(header = self.class::DEFAULT_REQUEST_HEADER)
      ensure_client && ensure_uri
      response = @client.rest_delete(@data['uri'], header, @api_version)
      @client.response_handler(response)
      true
    end
1079664
def update(hash)
      shash = {}
      hash.each do |key, value|
        shash[@serializer.key_for(key)] = value
      end
      @journal << shash
      @table.update(shash)
      self
    end
1107261
def update(other_hash)
      other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
      self
    end
1134816
def update(attributes)
      load_attributes(
          Core::RestApi.instance.put(path, attributes, if_match_header))
    end
1168827
def put(self, url, data, headers=None):
        
        return self._request('PUT', url, data, headers=headers)
970283
def update(self):
        '''
        
        '''
        conditionalRequestHeader = dict()
        if self.etag is not None:
            conditionalRequestHeader[Consts.REQ_IF_NONE_MATCH] = self.etag
        if self.last_modified is not None:
            conditionalRequestHeader[Consts.REQ_IF_MODIFIED_SINCE] = self.last_modified

        status, responseHeaders, output = self._requester.requestJson(
            "GET",
            self._url.value,
            headers=conditionalRequestHeader
        )
        if status == 304:
            return False
        else:
            headers, data = self._requester._Requester__check(status, responseHeaders, output)
            self._storeAndUseAttributes(headers, data)
            self.__completed = True
            return True
382623
def list_available_response_headers(custom_headers:nil)
      response = list_available_response_headers_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
756425
def update(key, ctx)
      resp = _request_endpoint(ctx)
      if resp && resp.endpoints
        resp.endpoints.each { |e| self[key] = e }
      end
    end
300004
def oauth_header
      uri = uri_base + @options[:path].to_s

      # The hash SimpleOAuth accepts is slightly different from that of
      # ROAuth.  To preserve backward compatability, fix the cache here
      # so that the arguments passed in don't need to change.
      oauth = {
        :consumer_key => @options[:oauth][:consumer_key],
        :consumer_secret => @options[:oauth][:consumer_secret],
        :token => @options[:oauth][:access_key],
        :token_secret => @options[:oauth][:access_secret]
      }

      data = ['POST', 'PUT'].include?(@options[:method]) ? params : {}

      SimpleOAuth::Header.new(@options[:method], uri, data, oauth)
    end
425539
function (header) {
    this.httpHeader = parseHTTPHeader(header);

    if (this.httpHeader[ 'content-length' ]) this.size = this.httpHeader[ 'content-length' ];

    if (this.httpHeader[ 'content-type' ]) this.mime = this.httpHeader[ 'content-type' ];

    if (this.httpHeader[ 'last-modified' ]) this.lastModified = new Date(this.httpHeader[ 'last-modified' ]);
  }