This method has been made "static"ally available so that
non-JAXB code does not have to (unnecesarily) instantiate
an instance fo this class.

@param key A {@link CorrelationKey}
@return A {@link String} equivalent of the key
8593
public static String marshalCorrelationKey( CorrelationKey key ) {
        if( key == null ) {
            return "";
        }
        StringBuffer result = new StringBuffer();
        if( ! key.getProperties().isEmpty() ) {
            Iterator<CorrelationProperty<?>> iter = key.getProperties().iterator();
            CorrelationProperty<?> prop = iter.next();
            if( prop != null ) {
                result.append(prop.getValue().toString());
            }
            while( iter.hasNext() ) {
                prop = iter.next();
                if( prop != null ) {
                    result.append(":").append(prop.getValue().toString());
                }
            }
        }
        return result.toString();
    }
1190601
private String getJsonKey(String key) {
		String jsonKey = key;
		if (addQuoteToKey) {
			jsonKey = JavascriptStringUtil.quote(key);
		}
		return jsonKey;
	}
642971
public static boolean isConstantKey(Key<?> key) {
    Type type = key.getTypeLiteral().getType();

    if (!(type instanceof Class)) {
      return false;
    }

    Class clazz = (Class) type;
    return clazz == String.class || clazz == Class.class || clazz.isPrimitive()
        || Number.class.isAssignableFrom(clazz) || Character.class.isAssignableFrom(clazz)
        || Boolean.class.isAssignableFrom(clazz) || clazz.isEnum();
  }
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)));
    }
279359
public static <T> T get(String key, Class<T> clz) {
        return (T)m().get(key);
    }
690754
public T get(K key) {
        T item = cache.get(key);
        if (item == null) {
            item = buildAndCache(key, crestConfig);
        }
        return item;
    }
1317138
public <G extends Serializable> Metric<G> getMetric(CxxMetricsFactory.Key metricKey) {
    Metric<G> metric = (Metric<G>) this.langSpecificMetrics.get(metricKey);
    if (metric == null) {
      throw new IllegalStateException("Requested metric " + metricKey + " couldn't be found");
    }
    return metric;
  }
925780
private Class<?> getKey(Class<?> key)
	{
		Class<?> newKey = lookupMap.get(key);
		if (newKey != null)
			return newKey;

		for (Class<?> c : internalMap.keySet())
		{
			if (c.isAssignableFrom(key))
			{
				lookupMap.put(key, c);
				return c;
			}
		}
		return null;
	}
505361
public T getValueByString(String key) {
        for (T value : values) {
            if (keyFactory.generateKey(value).equals(key)) {
                return value;
            }
        }
        return null;
    }
347497
public String getKeyValue(String key){
        String keyName = keysMap.get(key);
        if (keyName != null){
            return keyName;
        }
        return ""; //key wasn't defined in keys properties file
    }
741846
@NotNull
    public static Key<String> stringKey(@NotNull String name) {
        return create(name, String.class);
    }
1285827
public int addKey(String key) {
        JdkUtils.requireNonNull(key);
        int nextIndex = keys.size();
        final Integer mapIndex = JdkUtils.putIfAbsent(keys, key, nextIndex);
        return mapIndex == null ? nextIndex : mapIndex;
    }
547357
private String getKey(Object key) {
        if (key == null) {
            throw new IllegalArgumentException("Cache key not be null");
        }

        return ObjectUtils.toString(key);
    }
534365
@Nullable
  public CloseableReference<V> get(final K key) {
    Preconditions.checkNotNull(key);
    Entry<K, V> oldExclusive;
    CloseableReference<V> clientRef = null;
    synchronized (this) {
      oldExclusive = mExclusiveEntries.remove(key);
      Entry<K, V> entry = mCachedEntries.get(key);
      if (entry != null) {
        clientRef = newClientReference(entry);
      }
    }
    maybeNotifyExclusiveEntryRemoval(oldExclusive);
    maybeUpdateCacheParams();
    maybeEvictEntries();
    return clientRef;
  }
972746
public final String key() {
    key = (key == null) ? UUID.randomUUID().toString() : key;
    return key;
  }
684779
public JsonWriter keyLiteral(CharSequence key) {
        startKey();

        if (key == null) {
            throw new IllegalArgumentException("Expected map key, but got null.");
        }

        writer.write(key.toString());
        writer.write(':');
        return this;
    }
284317
public static Maybe<Set<String>> keys(CacheConfigBean cacheConfigBean, String key) {
        return SingleRxXian
                .call(CacheService.CACHE_SERVICE, "cacheMapKeys", new JSONObject() {{
                    put("cacheConfig", cacheConfigBean);
                    put("key", key);
                }})
                .flatMapMaybe(unitResponse -> {
                    unitResponse.throwExceptionIfNotSuccess();
                    if (unitResponse.getData() == null)
                        return Maybe.empty();
                    else
                        return Maybe.just(Reflection.toTypedSet(unitResponse.getData(), String.class));
                });
    }