Read value(s) and value name(s) form given key

@param hk the HKEY
@param key the key
@return the value name(s) plus the value(s)
@throws RegistryException when something is not right
977857
public Map<String, String> readStringValues(HKey hk, String key) throws RegistryException {
		return readStringValues(hk, key, null);
	}
680736
public T get(final int key) {
		int index = ((key & 0x7FFFFFFF) % elementKeys.length);

		long m = elementKeys[index];
		if (key == m) {
			return elementValues[index];
		}

		return null;
	}
989990
@Override
    public V get(Object key) {
        if (key == null) {
            throw new NullPointerException();
        }
        
        CachedValue<K, V> entry = map.get(key);
        if (entry == null) {
            return null;
        }
        if (isValueExpired(entry)) {
            if (map.remove(key, entry)) {
                onValueRemove(entry);
                return null;
            }
            return get(key);
        }
        return readValue(entry);
    }
1161704
@Override
    public V get(K key) {
        if(key == null) {
            return null;
        }
        
        byte[] bytes = _store.get(_keySerializer.serialize(key));
        return bytes == null ? null : _valSerializer.deserialize(bytes);
    }
415822
public static void removeValue(String registryName, String key) {
		Sysprop registryObject = readRegistryObject(registryName);
		if (registryObject == null || StringUtils.isBlank(key)) {
			return;
		}
		if (registryObject.hasProperty(key)) {
			registryObject.removeProperty(key);
			CoreUtils.getInstance().getDao().update(REGISTRY_APP_ID, registryObject);
		}
	}
1196894
@Override
  public List<V> get(Object key)
  {
    if (key == null) {
      return null;
    }

    K[] keys = _keys;
    int size = _size;
    
    for (int i = size - 1; i >= 0; i--) {
      if (key.equals(keys[i])) {
        return _values[i];
      }
    }
    return null;
  }
1354605
def Match(self, registry_key):
    
    value_names = frozenset([
        registry_value.name for registry_value in registry_key.GetValues()])

    return self._value_names.issubset(value_names)
152881
public String getValue(String key) {
		for (Iterator iter = components.values().iterator(); iter.hasNext();) {
			LdapRdnComponent component = (LdapRdnComponent) iter.next();
			if (ObjectUtils.nullSafeEquals(component.getKey(), key)) {
				return component.getValue();
			}
		}

		throw new IllegalArgumentException("No RdnComponent with the key " + key);
	}
25556
public MessageBuilder varWithClass(final String key, final Class<?> clazz) {
        
        final String className;
        if(clazz.isArray()) {
            // 配列の場合
            Class<?> elementType = clazz.getComponentType();
            className = elementType.getName() + "[]";
            
        } else {
            className = clazz.getName();
            
        }
        
        return var(key, className);
    }
403069
public static Map<String, Object> getRegistry(String registryName) {
		if (StringUtils.isBlank(registryName)) {
			return null;
		}
		Sysprop registryObject = readRegistryObject(registryName);
		return registryObject == null ? null : registryObject.getProperties();
	}
1052319
public <H,R> Map<String,AttributeValue> convertKey(final T key) {
        final DynamoDBMapperFieldModel<T,H> hk = this.<H>hashKey();
        final DynamoDBMapperFieldModel<T,R> rk = this.<R>rangeKeyIfExists();
        return this.<H,R>convertKey(hk.get(key), (rk == null ? (R)null : rk.get(key)));
    }
787632
public static Map<String, String> readValues(String keyName) throws RegistryException {
        try (Key key = Key.open(keyName, KEY_READ)) {
            int[] info = invoke(Methods.REG_QUERY_INFO_KEY.get(), key.id);
            checkError(info[InfoIndex.INFO_ERROR_CODE.get()]);
            int count = info[InfoIndex.INFO_COUNT_VALUES.get()];
            int maxLength = info[InfoIndex.INFO_MAX_VALUE_LENGTH.get()] + 1;
            Map<String, String> values = new HashMap<>();
            for (int i = 0; i < count; i++) {
                String valueName = fromByteArray(invoke(Methods.REG_ENUM_VALUE.get(), key.id, i, maxLength));
                values.put(valueName, readValue(keyName, valueName));
            }
            return values;
        }
    }
21326
public static void createKey(String keyName) throws RegistryException {
        int[] info = invoke(Methods.REG_CREATE_KEY_EX.get(), keyParts(keyName));
        checkError(info[InfoIndex.INFO_ERROR_CODE.get()]);
        invoke(Methods.REG_CLOSE_KEY.get(), info[InfoIndex.INFO_HANDLE.get()]);
    }
729498
public byte[] getGZIP(Key key) {
        Value payload = getValue(key, shouldUseReadOnlyResponseCache);
        if (payload == null) {
            return null;
        }
        return payload.getGzipped();
    }
946576
public S getSchemaByKey(K key) throws SchemaRegistryException {
    try {
      return cachedSchemasByKeys.get(key);
    } catch (ExecutionException e) {
      throw new SchemaRegistryException(String.format("Schema with key %s cannot be retrieved", key), e);
    }
  }
1272910
public String getValue(String key) {
        KeyValue kv = getKV(key);
        return kv == null ? null : kv.getValue();
    }
952596
public Object get(Object key)
    {
        purge();
        Entry entry = getEntry(key);
        if (entry == null) return null;
        return entry.getValue();
    }