Resolve a key accessor reference.
431784
function getKey(_, ctx) {
  var k = 'k:' + _.$key + '_' + (!!_.$flat);
  return ctx.fn[k] || (ctx.fn[k] = key(_.$key, _.$flat));
}
871363
def get_key(cls, key):
        ""
        return cls.get().get(key, cls.DEFAULT_CONFIG.get(key,None))
287576
private String resolveKeyWithFallback(String keyName) {

        String result = resolveKey(keyName);
        if ((result == null) && (m_keyFallbackHandler != null)) {
            Optional<String> fallback = m_keyFallbackHandler.getFallbackKey(keyName);
            if (fallback.isPresent()) {
                result = resolveKey(fallback.get());
            }
        }
        return result;
    }
712083
def has_key(self, key):
        """"""
        k = self._lowerOrReturn(key)
        return k in self.data
747975
def _invalidate_entry(self, key):
        ""
        old_entry = self.access_lookup.get(key)
        if old_entry:
            old_entry.is_valid = False

        return old_entry
747113
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return ProtectionAuthority(key)
        if key not in ProtectionAuthority._member_map_:
            extend_enum(ProtectionAuthority, key, default)
        return ProtectionAuthority[key]
283018
def ensureKeysAreSetup(self):
        
        if not areKeysSetup(self.name, self.keys_dir):
            raise REx(REx.reason.format(self.name) + self.keygenScript)
1211975
def resolve(self, key):
        
        registration = self._registrations.get(key)

        if registration is None:
            raise KeyError("Unknown key: '{0}'".format(key))

        return registration.resolve(self, key)
905428
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return ReturnCode(key)
        if key not in ReturnCode._member_map_:
            extend_enum(ReturnCode, key, default)
        return ReturnCode[key]
1044678
private static <K, V> boolean keyOrValueIsAbsent(Entry<String, KeyValue<K, V>> entry) {
		KeyValue<K, V> kv = entry.getValue();
		return kv.key == null || kv.value == null;
	}
1111187
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return TOS_REL(key)
        if key not in TOS_REL._member_map_:
            extend_enum(TOS_REL, key, default)
        return TOS_REL[key]
897240
def _get_ordered_access_keys(self):
        ""
        self.access_log_lock.acquire()
        r = [e.key for e in self.access_log if e.is_valid]
        self.access_log_lock.release()

        return r
1055243
def get(key, default=-1):
        """"""
        if isinstance(key, int):
            return Registration(key)
        if key not in Registration._member_map_:
            extend_enum(Registration, key, default)
        return Registration[key]
640186
def _resolve(self):
        """"""
        self.__is_resolved = True
        if self.is_complex:
            type = self.nested if self.nested else self
            type.__reference = self.module.lookup(type.name)
757028
public static String componentAccessToken(String key) {
		if (isKeyParam(key)) {
			return apiHandler.componentAccessToken(key);
		}
		return key;
	}
720386
def get_locked_variable(self, key, access_key):
        
        return self.get_variable(key, per_reference=False, access_key=access_key)
352030
def resolve(self, *pargs, **kwargs):
        """"""
        self._cached = (pargs, kwargs)
        self._try_then()