Get the key/value(s) from the raw output
 rubocop:disable PerceivedComplexity
170656
def return_value(nil_values = false, transformation = nil, return_hash = false)
      @value = decode_values
      return @value if @value.first.is_a? String

      if @value.count == 1 && !return_hash
        @value = @value.first['Value']
        @value = transformation.call(@value) if transformation && !@value.nil?
        return @value
      else
        @value = @value.map do |el|
          el['Value'] = transformation.call(el['Value']) if transformation && !el['Value'].nil?
          { key: el['Key'], value: el['Value'] } if el['Value'] || nil_values
        end.compact
      end
    end
708794
def extract_metadata
      @metadata = {}

      convert do |current|
        current.each_line.drop_while do |line|
          next false if line !~ /^#\+([a-z_]+): (.*)/

          key, value = $1, $2
          @metadata[key.to_sym] = value
        end.join('')
      end
    end
492547
function getHostKeyPublicModulus($raw_output = false)
    {
        return $raw_output ? $this->host_key_public_modulus->toBytes() : $this->host_key_public_modulus->toString();
    }
1367235
def get(key, options = {})
    options[:min] ||= 0.0
    options[:max] ||= options[:min] + 1.0
    (get_unit(key) * (options[:max] - options[:min])) + options[:min]
  end
695065
def parse!
      unless raw.has_key?(:sales_orders)
        raw[:sales_orders] = {}
      end

      # force orders to be an array
      orders = raw[:sales_orders].fetch(:sales_order_summary, {})
      unless orders.kind_of?(Array)
        raw[:sales_orders][:sales_order_summary] = [orders]
      end

      # typecast :count_more_sales_orders_available to integer
      if raw.has_key?(:count_more_sales_orders_available)
        convert_to_integer!(:count_more_sales_orders_available, raw)
      end

      # typecast :count_sales_orders_returned to integer
      if raw.has_key?(:count_sales_orders_returned)
        convert_to_integer!(:count_sales_orders_returned, raw)
      end

      raw[:sales_orders][:sales_order_summary].each do |summary|

        # typecast :shipment_key to integer
        if summary.fetch(:shipments, {}).fetch(:shipment_summary, {}).has_key?(:shipment_key)
          convert_to_integer!(:shipment_key, summary[:shipments][:shipment_summary])
        end

        # typecast :zip1 to integer
        if summary.fetch(:shipments, {}).fetch(:shipment_summary, {}).fetch(:ship_to, {}).has_key?(:zip1)
          convert_to_integer!(:zip1, summary[:shipments][:shipment_summary][:ship_to])
        end
      end
    end
848075
def decode
      self.raw_splits.each do |split|
        self.modules.each do |m|
          m.decode_split(split)
        end
      end
    end
665849
def get_value(key, &block)
      key   = key.to_sym
      value = @table[key]

      if block_given?
        block.arity == 0 ? value.instance_eval(&block) : block.call(value)
      end

      value
    end
944550
def get_output_dict(stack):
    
    outputs = {}
    if 'Outputs' not in stack:
        return outputs

    for output in stack['Outputs']:
        logger.debug("    %s %s: %s", stack['StackName'], output['OutputKey'],
                     output['OutputValue'])
        outputs[output['OutputKey']] = output['OutputValue']
    return outputs
1259841
def read_raw(self, key):
        
        data = None
        if key is not None:
            data = self.db.read(key.strip())
        else:
            self.tcex.log.warning(u'The key field was None.')
        return data
198357
def raw_get(self, *raw_args, **raw_kwargs):
        

        args = self.prepare_args(*raw_args)
        kwargs = self.prepare_kwargs(**raw_kwargs)

        key = self.key(*args, **kwargs)

        return self.cache.get(key)
705484
def _get_val(record, keys):
    '''
    
    '''
    data = record
    for key in keys:
        if key in data:
            data = data[key]
        else:
            return None
    return data
685242
def get_keys(custom_headers:nil)
      response = get_keys_async(custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
152539
def get_keys(self, key=None):
        
        if key:
            value = _lxc.Container.get_keys(self, key)
        else:
            value = _lxc.Container.get_keys(self)

        if value is False:
            return False
        elif value.endswith("\n"):
            return value.rstrip("\n").split("\n")
        else:
            return value
328991
def extract_options(args)
      options = args.last
      options.respond_to?(:to_hash) ? options.to_hash.dup : {}
    end
763437
def print_subkey_and_value(key, value)
      print_label key
      value.each do |subkey, val|
        if val.is_a? Hash
          print_inner_subkey subkey
          inspect_inner_hash val
        elsif val.is_a? Array
          print_inner_subkey subkey
          extract_hashes_and_print val
        elsif val.is_a? String
          print_hash subkey, val
        end
      end
    end
828401
def [](key)
      key = CF::String.from_string(key) if key.is_a?(::String)
      self.class.check_cftype(key)
      raw = CF.CFDictionaryGetValue(self, key)
      raw.null? ? nil : self.class.typecast(raw).retain.release_on_gc
    end
260281
def key_values(self):
        
        key_values = {}
        for key in self.keys:
            if key in self.payload:
                key_values[key] = self.payload[key]
        return key_values