search the all namespace for key
 @param [String] key key for search
 @return [Array] values
552255
def search_param(key)
      code, message, value = @server.call("searchParam", @caller_id, key)
      case code
      when 1
        return value
      when -1
        raise message
      else
        return false
      end
    end
1122181
def filtered_keys
      values.keys.reject { |k| k == :title || !attr_def[k] || (attr_def[k][:behaviour] == :namevar && @namevars.size == 1) }
    end
479570
function checkKeyNamespace(key) {
            try {
        	    var regDot = /\./;
        	    if (regDot.test(key)) {
            		var fullname = '';
            		var names = key.split(/\./);
            		for (var i = 0; i < names.length; i++) {
            		    if (i > 0) {
            			    fullname += '.';
            		    }
            		    fullname += names[i];

                        if (typeof fullname === "undefined") {
                            fullname = {};
                        }

            		    /*if (eval('typeof ' + fullname + ' == "undefined"')) {
            			    eval(fullname + '={};');
            		    }*/
        		    }
    	        }
            } catch(e) {
                logger.error("AUGMENTED: MessageBundle " + e);
            }
    	}
994127
def get(namespace = false, key = false, defaultValue = '')
      if namespace && key
        value = @config[namespace][key]
        if value
          return value
        else
          return defaultValue
        end
      end

      return @config if !@config.empty?

      get_config
    end
383441
def lookup(outputs, key)
      out = outputs.find { |o| o.output_key == key }
      out&.output_value
    end
726983
def[](*keys)
      values = json.is_a?(Array) ? json : [json]
      keys.each { |key| values = values.map{ |value| value.is_a?(Hash) ? value[key] : nil} }
      json.is_a?(Array) ? values : values.first
    end
345980
public Map<String, CFMetaData> getKeyspaceMetaData(String keyspaceName)
    {
        assert keyspaceName != null;
        KSMetaData ksm = keyspaces.get(keyspaceName);
        assert ksm != null;
        return ksm.cfMetaData();
    }
1080256
def get(key)
      node = self

      while node do
        # Find index of the entry that best fits the key.
        i = node.search_key_index(key)
        if node.is_leaf
          # This is a leaf node. Check if there is an exact match for the
          # given key and return the corresponding value or nil.
          return node.keys[i] == key ? node.values[i] : nil
        end

        # Descend into the right child node to continue the search.
        node = node.children[i]
      end

      PEROBS.log.fatal "Could not find proper node to get from while " +
        "looking for key #{key}"
    end
996772
def tags(key = nil)
      if custom?
        tags = @data[:data][:sdk][:custom][:tags]
      else
        tags = @data[:data][key]
      end
      key ? tags[key] : tags
    end
1193520
def [](key)
      if ! @fields.has_key?(key) && ! @fseq.empty?
        while true
          @fseq = @fseq.skip_whitespace
          if @fseq.first == 125 # '}'.ord
            @fseq = @fseq.skip_byte(125).skip_whitespace # '}'.ord
            break
          end
          new_key, new_value = read_field_and_consume
          @fields[new_key] = new_value
          break if new_key == key
        end
      end
      @fields[key]
    end
450098
function(config, keyToFind) {

  // Recursive function.
  var rec = function(o, prefix) {

    // Loop through each of the objects properties to find value.
    return _.find(o, function(val, key) {

      // Build namespaced name.
      var name = _.filter([prefix, key]).join('.');

      if (typeof val === 'string') {

        // If name of string value matches, return it.
        return (':' + name + ':') === keyToFind;

      } else if (typeof val === 'object') {

        // Recursively check object.
        return rec(val, name);

      } else {

        // Not a string or an object so just return false.
        return false;

      }

    });

  };

  // Init recursive function and return.
  return rec(config);

}
93420
def get(self, key, namespace=None):
        """"""
        # Short-circuit to reduce overhead.
        if not _CONFIG_OVERRIDE:
            return NO_VALUE
        full_key = generate_uppercase_key(key, namespace)
        logger.debug('Searching %s for %s', self, full_key)
        return get_key_from_envs(reversed(_CONFIG_OVERRIDE), full_key)
861613
def _lookup_namespace(self, symbol, namespace):
        
        for namespace_part in symbol.parts:
            namespace = namespace.get(namespace_part)
            if namespace is None:
                break
            if not isinstance(namespace, dict):
                return namespace
        raise Error('%s not found' % symbol.name)
679211
function data(key, value) {
    if (string(key)) {
      // Set `key`.
      if (arguments.length === 2) {
        assertUnfrozen('data', frozen)

        namespace[key] = value

        return processor
      }

      // Get `key`.
      return (own.call(namespace, key) && namespace[key]) || null
    }

    // Set space.
    if (key) {
      assertUnfrozen('data', frozen)
      namespace = key
      return processor
    }

    // Get space.
    return namespace
  }
1094098
private boolean containsKey(K key, int keyGroupIndex, N namespace) {

		checkKeyNamespacePreconditions(key, namespace);

		Map<N, Map<K, S>> namespaceMap = getMapForKeyGroup(keyGroupIndex);

		if (namespaceMap == null) {
			return false;
		}

		Map<K, S> keyedMap = namespaceMap.get(namespace);

		return keyedMap != null && keyedMap.containsKey(key);
	}
1276946
def key_exists(self, namespace, key):
        

        return namespace in self.__data and key in self.__data[namespace]
447700
def [](key)
      entity = new_entity
      key_property = entity.get_property(entity.primary_key)
      key_property.value = key

      result = service.execute("#{name}(#{key_property.url_value})")
      entities = service.find_entities(result)
      single_entity_from_xml(entities)
    end