Acccess to the status of response
 @param value [Ineger, nil] integer value for new status
 @return [Integer] current status
 @example Set status value
   status 200
516569
def status(value = nil)
			response.status ||= 200
			response.headers['X-Cascade'] = 'pass' if value == 404
			value ? response.status = value : response.status
		end
913417
def validate_status!(response)
      return unless status
      # Validate status code if defined in the spec
      if response.status != status
        raise Exceptions::Validation.new(
          "Invalid response code detected. Response %s dictates status of %s but this response is returning %s." %
          [name, status.inspect, response.status.inspect]
        )
      end
    end
888834
def status
      {
        :extended   => get_if_handleable(raw[:extended_status_message]),
        :code       => raw[:status_code].to_i,
        :message    => get_if_handleable(raw[:status_message]),
        :updated_at => get_if_handleable(raw[:status_update_date])
      }.reject { |k, v| v.nil? }
    end
53156
def []=(key, value)
      @lock.synchronize do
        if !@replace && @store.include?(key)
          # XXX don't expose the receiver as this class is an internal
          # implementation detail
          raise Wireless::KeyError.new(
            "#{@type} already exists: #{key}",
            key: key
          )
        end

        @store[key] = value
      end
    end
1286411
def current
      response = request(:get_all_current)
      handles = response.values.flatten.collect { |handle| Entity::Handle.build(handle) }
      initialize_items
      get_data_for_handles(handles)

      self
    end
616310
def _handle_status(self, key, value):
        
        if key in ("USERID_HINT", "NEED_PASSPHRASE",
                   "GET_HIDDEN", "SIGEXPIRED", "KEYEXPIRED",
                   "GOOD_PASSPHRASE", "GOT_IT", "GET_LINE"):
            pass
        elif key in ("BAD_PASSPHRASE", "MISSING_PASSPHRASE"):
            self.status = key.replace("_", " ").lower()
        else:
            self.status = 'failed'
            raise ValueError("Unknown status message: %r" % key)
1237942
def set_initial_status(self, response):
        
        self._raise_if_bad_http_status_and_method(response)

        if self._is_empty(response):
            self.resource = None
        else:
            try:
                self.resource = self._deserialize(response)
            except DeserializationError:
                self.resource = None

        self.set_async_url_if_present(response)

        if response.status_code in {200, 201, 202, 204}:
            if self.async_url or self.location_url or response.status_code == 202:
                self.status = 'InProgress'
            elif response.status_code == 201:
                status = self._get_provisioning_state(response)
                self.status = status or 'InProgress'
            elif response.status_code == 200:
                status = self._get_provisioning_state(response)
                self.status = status or 'Succeeded'
            elif response.status_code == 204:
                self.status = 'Succeeded'
                self.resource = None
            else:
                raise OperationFailed("Invalid status found")
            return
        raise OperationFailed("Operation failed or cancelled")
16153
def []=(key, value)
      @lock.synchronize do
        @indexes = {}
        if value.id_changed?
          hash.delete value.to_id(true)
        end
        saved = hash[key] = value.to_hash.freeze
        adapter.save_database if @options[:sync]
        saved
      end
    end
1014385
def raise_status(response):
    
    if response.status_code != 200:
        if response.status_code == 401:
            raise StrawPollException('Unauthorized', response)
        elif response.status_code == 403:
            raise StrawPollException('Forbidden', response)
        elif response.status_code == 404:
            raise StrawPollException('Not Found', response)
        else:
            response.raise_for_status()
350789
def _handle_status(self, key, value):
        
        if key in (
                "USERID_HINT",
                "NEED_PASSPHRASE",
                "BAD_PASSPHRASE",
                "GOOD_PASSPHRASE",
                "MISSING_PASSPHRASE",
                "PINENTRY_LAUNCHED",
                "BEGIN_SIGNING",
                "CARDCTRL",
                "INV_SGNR",
                "SIGEXPIRED",
                "KEY_CONSIDERED",
            ):
            self.status = key.replace("_", " ").lower()
        elif key == "SIG_CREATED":
            (self.sig_type, self.sig_algo, self.sig_hash_algo,
             self.what, self.timestamp, self.fingerprint) = value.split()
        elif key == "KEYEXPIRED":
            self.status = "skipped signing key, key expired"
            if (value is not None) and (len(value) > 0):
                 self.status += " on {}".format(str(value))
        elif key == "KEYREVOKED":
            self.status = "skipped signing key, key revoked"
            if (value is not None) and (len(value) > 0):
                 self.status += " on {}".format(str(value))
        elif key == "NODATA":
            self.status = nodata(value)
        elif key == "PROGRESS":
            self.status = progress(value.split(' ', 1)[0])
        else:
            raise ValueError("Unknown status message: %r" % key)
235080
def convert_value(value)
      case value
      when true  then "true"
      when false then "false"
      when Hash  then convert_value(value.values)
      when Array then value.map(&:to_s)
      else value.to_s
      end
    end
263786
def status(task_id)
      uri = 'api/status'
      params = {
        appkey: @appkey,
        timestamp: Time.now.to_i,
        task_id: task_id
      }
      request(uri, params)
    end
142411
def set(value)
    if value.nil?
      @is_nil = true
      @data = nil
      _set(nil)
    else
      @is_nil = false
      _set(screen_data(value))
    end
  end
981067
def offset(value = nil, &block)
      chain { criteria.update_request_options from: block || Integer(value) }
    end
363490
def value=(val)
      case val
      when ::String     then @value = val.to_s
      when ::Hash       then @value = val
      when ::Array      then @value = val
      when ::OpenStruct then @value = val
      when ::DateTime   then @value = val.strftime XS_DATETIME_FORMAT
      when ::Time       then @value = val.strftime XS_DATETIME_FORMAT
      when ::Date       then @value = val.strftime XS_DATETIME_FORMAT
      else
        if val.respond_to?(:to_datetime)
          @value = val.to_datetime
        elsif val.respond_to?(:call)
          @value = val.call
        elsif val.nil?
          @value = nil
        else
          @value = val.to_s
        end
      end
    rescue => e
      @value = val.to_s
    end
914336
def status(self, timeout=None):
        
        assembler = commons.StatusRequestAssembler(self._url)

        obj = yield self._post(assembler.url, assembler.data, timeout)

        status = Status._parse(obj)

        returnValue(status)
767389
def halt(status=nil, body=nil)
      unless status.nil? || Integer === status
        body = status
        status = nil
      end
      response.status = status if status
      response.body = body if body
      throw :halt
    end