Retrieves all non metadata keys of a JSON object
@param {Object} container reference to the data holder object
@return {Array} an array containing all non metadata keys of the object
@see aria.utils.Object.keys
518913
function (container) {
                var raw = ariaUtilsObject.keys(container);
                return ariaUtilsArray.filter(raw, function (key) {
                    return !aria.utils.Json.isMetadata(key);
                });
            }
1735
function (container, keyName) {
            for (var element in container) {
                if (container.hasOwnProperty(element)) {
                    container[element][keyName] = element;
                }
            }
        }
920360
function getObjectWithKeyAsCjs(key, object) {
	const jsContents = Object.keys(object).reduce((jsLines, name) => {
		jsLines.push(`\t\t'${escapeForJS(name)}': '${escapeForJS(object[name])}'`);

		return jsLines;
	}, []).join(',\n');
	const cjs = `\n\t${key}: {\n${jsContents}\n\t}`;

	return cjs;
}
307955
function getAllKeys (objArray) {
  let keys = []
  _.forEach(objArray, function (row) {
    if (!row || typeof row === 'string') return
    keys = keys.concat(Object.keys(row))
  })
  return _.union(keys)
}
636740
function _sortPropertyContainers(obj, key) {
        if (_smellsLikeAPropertyContainer(obj)) {
            return _.mapValues(obj, _sortElements);
        }
        else {
            return obj;
        }
    }
144777
JsonObject toDockerPortBindingsJson() {
        Map<String, Integer> portMap = getContainerPortToHostPortMap();
        if (!portMap.isEmpty()) {
            JsonObject portBindings = new JsonObject();
            Map<String, String> bindToMap = getBindToHostMap();

            for (Map.Entry<String, Integer> entry : portMap.entrySet()) {
                String containerPortSpec = entry.getKey();
                Integer hostPort = entry.getValue();

                JsonObject o = new JsonObject();
                o.addProperty("HostPort", hostPort != null ? hostPort.toString() : "");

                if (bindToMap.containsKey(containerPortSpec)) {
                    o.addProperty("HostIp", bindToMap.get(containerPortSpec));
                }

                JsonArray array = new JsonArray();
                array.add(o);

                portBindings.add(containerPortSpec, array);
            }
            return portBindings;
        } else {
            return null;
        }
    }
1291886
def keys(source, ext=COMPLETE):
    
    _MMD_LIB.extract_metadata_keys.restype = ctypes.c_char_p
    _MMD_LIB.extract_metadata_keys.argtypes = [ctypes.c_char_p, ctypes.c_ulong]
    src = source.encode('utf-8')
    all_keys = _MMD_LIB.extract_metadata_keys(src, ext)
    all_keys = all_keys.decode('utf-8') if all_keys else ''
    key_list = [ii for ii in all_keys.split('\n') if ii]
    return key_list
61327
function keyInArray(keys) {
  var keySet = Immutable.Set(keys);
  return function (v, k) {

    return keySet.has(k);
  }
}
1101237
public function keys()
    {
        $this->init();

        try {
            if ($this->multiContainerMode) {
                $containersList = $this->blobProxy->listContainers();
                return call_user_func_array('array_merge', array_map(
                    function(Container $container) {
                        $containerName = $container->getName();
                        return $this->fetchBlobs($containerName, $containerName);
                    },
                    $containersList->getContainers()
                ));
            }

            return $this->fetchBlobs($this->containerName);
        } catch (ServiceException $e) {
            $this->failIfContainerNotFound($e, 'retrieve keys', $this->containerName);
            $errorCode = $this->getErrorCodeFromServiceException($e);

            throw new \RuntimeException(sprintf(
                'Failed to list keys for the container "%s": %s (%s).',
                $this->containerName,
                $e->getErrorText(),
                $errorCode
            ), $e->getCode());
        }
    }
1299189
function(container) {
		var top = container.el.offsetTop;
		var bottom = top+container.el.offsetHeight;
	
		var left = container.el.offsetLeft;
		var right = left+container.el.offsetWidth;
	
		return [
	    	{x : left, y: top},
	    	{x : left, y: bottom},
	    	{x : right, y: top},
	    	{x : right, y: bottom}
		];
   }
558423
private void getResPathKeys(String[] keys, int depth) {
        ICUResourceBundle b = this;
        while (depth > 0) {
            keys[--depth] = b.key;
            b = b.container;
            assert (depth == 0) == (b.container == null);
        }
    }
347439
@SuppressWarnings("unchecked")
    public <K> K[] getKeys(Map<K, ?> map) {
        K[] result = null;
        Set<K> keySet = map.keySet();
        if (keySet.size() > 0) {
            result = (K[]) keySet.toArray(new Object[keySet.size()]);
        }
        
        return result;
    }
279713
function hkeys(key, req) {
  var val = this.getKey(key, req);
  if(!val) return [];
  return val.getKeys();
}
885135
private Set<String> getNotNullExtraKeys(Node actual, Set<String> extraKeys) {
        Set<String> notNullExtraKeys = new TreeSet<>();
        for (String extraKey : extraKeys) {
            if (!actual.get(extraKey).isNull()) {
                notNullExtraKeys.add(extraKey);
            }
        }
        return notNullExtraKeys;
    }
1364883
function (obj) {
        var keys = []
        for (var key in obj) {
            if (obj.hasOwnProperty(key)) {
                keys.push(key)
            }
        }
        return keys
    }
951433
protected function parseContainer(Container $container)
    {
        $map = array();

        foreach ($container->keys() as $name) {
            if (strpos($name, self::DIC_PREFIX) === 0) {
                continue;
            }

            if ($item = $this->parseItem($container, $name)) {
                $map[] = $item;
            }
        }

        return $map;
    }
262540
function getObjectWithStringifiedKeys(object) {
	return Object.keys(object).reduce((objectJSON, key) => {
		objectJSON[key] = String(object[key]);

		return objectJSON;
	}, {});
}