Gets the path to the key
Can return group path, key path, or group path + key path
486114
private function getKeyPath(Memento\Key $key = null)
    {
        $pathParts = array();

        // determine group key path
        if (!is_null($this->groupKey)) {
            $keyFileName = base64_encode($this->groupKey->getKey());
            // key filenames should be stored encoded for security
            $keyPartition = abs(crc32($keyFileName)) % Memento\Engine\File::DIR_PARTITION_COUNT;
            $pathParts[] = $keyPartition . DIRECTORY_SEPARATOR . $keyFileName;
        }

        // determine single key path
        if (!is_null($key)) {
            $keyFileName = base64_encode($key->getKey());
            // key filenames should be stored encoded for security
            $keyPartition = abs(crc32($keyFileName)) % Memento\Engine\File::DIR_PARTITION_COUNT;
            $pathParts[] = $keyPartition . DIRECTORY_SEPARATOR . $keyFileName;
        }

        $keyPath = $this->storagePath . DIRECTORY_SEPARATOR . implode(DIRECTORY_SEPARATOR, $pathParts);

        if (!is_dir($keyPath)) {
            @mkdir($keyPath, 0777, true);
        }

        return $keyPath;
    }
132275
protected String getKey(String hostName, String contextPath) {
        return String.format("%s/%s", (hostName == null ? EMPTY : hostName), (contextPath == null ? EMPTY : contextPath));
    }
779557
def GetKeyByPath(self, key_path):
    
    key_path_upper = key_path.upper()
    if key_path_upper.startswith(self._key_path_prefix_upper):
      relative_key_path = key_path[self._key_path_prefix_length:]
    elif key_path.startswith(definitions.KEY_PATH_SEPARATOR):
      relative_key_path = key_path
      key_path = ''.join([self._key_path_prefix, key_path])
    else:
      return None

    try:
      regf_key = self._regf_file.get_key_by_path(relative_key_path)
    except IOError:
      regf_key = None
    if not regf_key:
      return None

    return REGFWinRegistryKey(regf_key, key_path=key_path)
1195084
def GetSubkeyByPath(self, key_path):
    
    subkey = self
    for path_segment in key_paths.SplitKeyPath(key_path):
      subkey = subkey.GetSubkeyByName(path_segment)
      if not subkey:
        break

    return subkey
165193
function getPath (obj, ks) {
      ks = typeof ks == "string" ? keysFromPath(ks) : ks;

      var i = -1, length = ks.length;

      // If the obj is null or undefined we have to break as
      // a TypeError will result trying to access any property
      // Otherwise keep incrementally access the next property in
      // ks until complete
      while (++i < length && obj != null) {
        obj = obj[ks[i]];
      }
      return i === length ? obj : void 0;
    }
706474
protected function getPath($key)
    {
        $parsed = $this->parseKey($key);

        array_shift($parsed);

        list ($dir, $file) = $parsed;
        return sprintf('%s/%s/%s', $this->path, $dir, $file);
    }
913499
private static String getPathForKey(Key k) {
    final int off = k._kb[0]==Key.DVEC ? Vec.KEY_PREFIX_LEN : 0;
    return new String(k._kb,off,k._kb.length-off);
  }
446609
def getKey(self, key):
		
		data = self.getDictionary()
		if key in data:
			return data[key]
		else:
			return None
1170448
def GetKeyByPath(self, key_path):
    
    key_path_upper = key_path.upper()
    if key_path_upper.startswith(self._key_path_prefix_upper):
      relative_key_path = key_path[self._key_path_prefix_length:]
    elif key_path.startswith(definitions.KEY_PATH_SEPARATOR):
      relative_key_path = key_path
      key_path = ''.join([self._key_path_prefix, key_path])
    else:
      return None

    path_segments = key_paths.SplitKeyPath(relative_key_path)
    registry_key = self._root_key
    if not registry_key:
      return None

    for path_segment in path_segments:
      registry_key = registry_key.GetSubkeyByName(path_segment)
      if not registry_key:
        return None

    return registry_key
698822
public static List<String> getStringsWithGroup(String groupName,String...keys){
        try {
        	if(JedisProviderFactory.isCluster(groupName)){
        		return JedisProviderFactory.getMultiKeyJedisClusterCommands(groupName).mget(keys);
        	}else{
        		return JedisProviderFactory.getMultiKeyCommands(groupName).mget(keys);
        	}
		} finally {
			JedisProviderFactory.getJedisProvider(groupName).release();
		}
	}
801449
def GetRootKey(self):
    
    root_registry_key = virtual.VirtualWinRegistryKey('')

    for mapped_key in self._MAPPED_KEYS:
      key_path_segments = key_paths.SplitKeyPath(mapped_key)
      if not key_path_segments:
        continue

      registry_key = root_registry_key
      for name in key_path_segments[:-1]:
        sub_registry_key = registry_key.GetSubkeyByName(name)
        if not sub_registry_key:
          sub_registry_key = virtual.VirtualWinRegistryKey(name)
          registry_key.AddSubkey(sub_registry_key)

        registry_key = sub_registry_key

      sub_registry_key = registry_key.GetSubkeyByName(key_path_segments[-1])
      if (not sub_registry_key and
          isinstance(registry_key, virtual.VirtualWinRegistryKey)):
        sub_registry_key = virtual.VirtualWinRegistryKey(
            key_path_segments[-1], registry=self)

        registry_key.AddSubkey(sub_registry_key)

    return root_registry_key
134767
public static String getPathForKey(Key k) {
    final int off = k._kb[0]==Key.CHK   || k._kb[0]==Key.VEC ? Vec.KEY_PREFIX_LEN : 0;
    String p = new String(k._kb,off,k._kb.length-off);

    if(p.startsWith("nfs:/"))
      p = p.substring("nfs:/".length());
    else if (p.startsWith("nfs:\\"))
      p = p.substring("nfs:\\".length());

    return p;
  }
874966
def GetSubkeyByPath(self, key_path):
    
    if not self._registry_key and self._registry:
      self._GetKeyFromRegistry()

    subkey = self
    for path_segment in key_paths.SplitKeyPath(key_path):
      subkey = subkey.GetSubkeyByName(path_segment)
      if not subkey:
        break

    return subkey
137501
@Override
	public String get(Object key) {
		return this.groupedMap.get(DEFAULT_GROUP, Convert.toStr(key));
	}
1240659
def _get_metadata_path(self, key):
        
        return "{group}/meta/{key}/meta".format(group=self.group._v_pathname,
                                                key=key)
333501
def Get(self,key):
		

		for disk in self.disks:
			if disk.id == key:  return(disk)
			elif key in disk.partition_paths:  return(disk)
582979
def _get_path(dict_, path):
    '''
    
    '''
    cur = dict_
    for part in path.split('/'):
        cur = cur[part]
    return cur