(see Defaults#each_key)
967098
def each_key(&block)
      raise NotImplementedError, "each_key is not supported on this proxy" \
        unless supports? :each_key

      return enum_for(:each_key) unless block_given?
      adapter.each_key(&block)
      self
    end
1332440
def zscan_each(key, *args, &block)
      data_type_check(key, ZSet)
      return [] unless data[key]

      return to_enum(:zscan_each, key, options) unless block_given?
      cursor = 0
      loop do
        cursor, values = zscan(key, cursor, options)
        values.each(&block)
        break if cursor == '0'
      end
    end
39996
def symbolize_keys keys, hash
      new_hash = {}
      keys.each do |key|
        if hash[key].kind_of? Hash
          new_hash[key.to_sym] = symbolize_keys(hash[key].keys, hash[key])
        elsif hash[key].kind_of? Array
          new_hash[key.to_sym] = []
          hash[key].each do |item|
            if item.kind_of? Hash
              new_hash[key.to_sym] << symbolize_keys(item.keys, item)
            else
              new_hash[key.to_sym] << item
            end
          end
        else
          new_hash[key.to_sym] = hash[key]
        end
      end

      return new_hash
    end
629554
def each_key(key, &block)
      index = 0
      subkey = nil

      subkey_max_len, _ = reg_query_info_key_max_lengths(key)

      begin
        subkey, filetime = reg_enum_key(key, index, subkey_max_len)
        yield subkey, filetime if !subkey.nil?
        index += 1
      end while !subkey.nil?

      index
    end
358929
function (params) {

			return _.every(_.keys(params), function (key) { 
				return _.contains(put_params, key); 
			});
		}
996772
def tags(key = nil)
      if custom?
        tags = @data[:data][:sdk][:custom][:tags]
      else
        tags = @data[:data][key]
      end
      key ? tags[key] : tags
    end
1217177
def keys
      if :hash == self.type
        self.children.map { |child| child.children[0] }
      else
        raise Synvert::Core::MethodNotSupported.new "keys is not handled for #{self.debug_info}"
      end
    end
1119353
def each
      @data.each do |section, hash|
        hash.each do |key, value|
          yield [section, key, value]
        end
      end
    end
1279023
def each_pair(type, default = nil)
			real_hash.each_key() { |key|
				value = fetch(key, type, default)
				if (!value.nil?)
					yield(key, value)
				end
			}
		end
1265006
def keys_with_ttl(pattern = SCAN_PATTERN, count = DEFAULT_COUNT)
      hash = {}
      redis do |conn|
        conn.scan_each(match: prefix(pattern), count: count).each do |key|
          hash[key] = conn.ttl(key)
        end
      end
      hash
    end
1141698
def to_mutable
    each_with_object( {} ) { |(key, value), hash|
      hash[ Hamster.to_mutable key ] = Hamster.to_mutable value
    }
  end
450304
def keys(pattern = nil, secret_only = nil)
      keys = []
      each_key(pattern, secret_only) do |key|
        keys << key
      end
      keys
    end
655908
def write_keys(attrs)
      attrs.each { |key, value| proxy_writer(key, value) if writeable?(key) }
      self
    end
883447
def key
      if @key.nil?
        hash_key = @name.to_s
        @key = hash_key
        keys = @tags.keys
        keys.sort
        keys.each do |k|
          v = tags[k]
          hash_key += "|#{k}|#{v}"
        end
        @key = hash_key
      end
      @key
    end
1264308
def each_node(node, indent)
      # Process named variables for each structure
      variables = node[@value][1].clone

      # The each structure accept missing arguments as well, therefore we need to
      # substitute them with our defaults
      #
      # each in iterable
      # each value in iterable
      # each key, value in iterable

      # Value argument name provided only
      if variables.length == 1
        variables.unshift Settings::DEFAULT_EACH_KEY

      # Missing key and value arguments
      elsif variables.empty?
        variables[0] = Settings::DEFAULT_EACH_KEY
        variables[1] = Settings::DEFAULT_EACH_VALUE
      end

      # Choose whether to apply each with index (Arrays) or each (Hashes) methods
      #buffer_eval "_opulent_send_method = (#{node[@value][1]}.is_a?(Array) ? :each_with_index : :each)"
      case node[@value][0][0]
      when '[]'
        buffer_eval "#{node[@value][0][1]}.each_with_index do |#{variables.reverse.join ', '}|"
      else
        buffer_eval "#{node[@value][0][1]}.each do |#{variables.join ', '}|"
      end

      # Evaluate child nodes
      node[@children].each do |child|
        root child, indent
      end

      # End
      buffer_eval 'end'
    end
190685
def each(value = nil, &block)
      yield self, value
      if @children
        @children.each do |child|
          child.each value, &block
        end
      end
      value
    end
966524
def each_field
      self.class.all_fields.each do |field|
        value = __send__(field.getter)
        yield(field, value)
      end
    end