documentation inherited from interface KeyTranslator
515784
public Iterator<String> enumerateReleaseCommands ()
    {
        ArrayList<String> commands = Lists.newArrayList();
        for (KeyRecord rec : _keys.values()) {
            commands.add(rec.releaseCommand);
        }

        return commands.iterator();
    }
76152
def as_translation_key(self):
        
        return TranslationKey(**{
            name: getattr(self, name)
            for name in TranslationKey._fields})
33433
function translateObject(language, key, destObj, keysArray, valuesArray) {
	return new Promise(function (resolve, reject) {
		var valuesStr = valuesArray.join(hashSimple);

		translateService.translate(valuesStr, {to: language}, function (err, res) {
			if (err || res.code !== 200) {
				reject(err || res);
			} else {
        // yandex return an array string and so we need split back to the normal vlues
				var result = res.text[0].split(hashSimple);
				for (var i = 0; i < keysArray.length; i++) {
					destObj[key][keysArray[i]] = result[i];
				}

				resolve(destObj);
			}
		});
	});
}
184720
function parseObjectPropertyKey() {
  var token;

  index = lookahead.start;
  token = lex();

  // Note: This function is called only from parseObjectProperty(), where
  // EOF and Punctuator tokens are already filtered out.

  if (token.type === TokenStringLiteral || token.type === TokenNumericLiteral) {
    if (token.octal) {
      throwError(token, MessageStrictOctalLiteral);
    }
    return finishLiteral(token);
  }

  return finishIdentifier(token.value);
}
781849
private final static String key(Class from, Class to) {
        return from.getName() + "->" + to.getName();
    }
117316
function _translateKeyboardEvent(event) {
        var hasMacCtrl = (brackets.platform === "mac") ? (event.ctrlKey) : false,
            hasCtrl = (brackets.platform !== "mac") ? (event.ctrlKey) : (event.metaKey),
            hasAlt = (event.altKey),
            hasShift = (event.shiftKey),
            key = String.fromCharCode(event.keyCode);

        //From the W3C, if we can get the KeyboardEvent.keyIdentifier then look here
        //As that will let us use keys like then function keys "F5" for commands. The
        //full set of values we can use is here
        //http://www.w3.org/TR/2007/WD-DOM-Level-3-Events-20071221/keyset.html#KeySet-Set
        var ident = event.keyIdentifier;
        if (ident) {
            if (ident.charAt(0) === "U" && ident.charAt(1) === "+") {
                //This is a unicode code point like "U+002A", get the 002A and use that
                key = String.fromCharCode(parseInt(ident.substring(2), 16));
            } else {
                //This is some non-character key, just use the raw identifier
                key = ident;
            }
        }

        // Translate some keys to their common names
        if (key === "\t") {
            key = "Tab";
        } else if (key === " ") {
            key = "Space";
        } else if (key === "\b") {
            key = "Backspace";
        } else if (key === "Help") {
            key = "Insert";
        } else if (event.keyCode === KeyEvent.DOM_VK_DELETE) {
            key = "Delete";
        } else {
            key = _mapKeycodeToKey(event.keyCode, key);
        }

        return _buildKeyDescriptor(hasMacCtrl, hasCtrl, hasAlt, hasShift, key);
    }
278320
function getKey(key) {
  if(this.conf.transform) {
    if(typeof(this.conf.transform.key) == 'function') {
      return this.conf.transform.key.call(this, key);
    }
  }
  key = delimited(key, this.conf.delimiter);
  key = key.replace(/- /, this.conf.delimiter);
  key = key.replace(/[^a-zA-Z0-9_]/, '');
  if(this.conf.prefix) {
    return this.conf.prefix + this.conf.delimiter + key.toLowerCase()
  }
  return key.toLowerCase();
}
314443
private synchronized boolean markIsTransaction(String channelId, String uuid, boolean isTransaction) {
        if (this.isTransaction == null) {
            return false;
        }

        String key = getTxKey(channelId, uuid);
        this.isTransaction.put(key, isTransaction);
        return true;
    }
616449
function translatedGetter(key, argsGetter, lang = getCurrentLanguage()) {
            const data = [key].concat(argsGetter(lang))
            let old = getCurrentLanguage()
            setLanguage(lang)
            const rlt = rStrip(
              pureI18n.apply(null, data),
              (s, a, b, c, count) => {
                const data = JSON.parse(s)
                return toWrappedString(translatedGetter(data[0], () => data.slice(1), lang), void 0, count)
              },
              level - 1
            )
            setLanguage(old)
            return rlt
          }
419372
function parseStartKey(key, restOfLine) {
        // When a new key is encountered, the rest of the line is immediately added as
        // its value, by calling `flushBuffer`.
        flushBuffer();

        incrementArrayElement(key);

        if (stackScope && stackScope.flags.indexOf('+') > -1) key = 'value';

        bufferKey = key;
        bufferString = restOfLine;

        flushBufferInto(key, { replace: true });
      }
135537
static BindTransform getPrimitiveTransform(TypeName type) {

		if (Integer.TYPE.toString().equals(type.toString())) {
			return new IntegerBindTransform(false);
		}
		if (Boolean.TYPE.toString().equals(type.toString())) {
			return new BooleanBindTransform(false);
		}
		if (Long.TYPE.toString().equals(type.toString())) {
			return new LongBindTransform(false);
		}
		if (Double.TYPE.toString().equals(type.toString())) {
			return new DoubleBindTransform(false);
		}
		if (Float.TYPE.toString().equals(type.toString())) {
			return new FloatBindTransform(false);
		}
		if (Short.TYPE.toString().equals(type.toString())) {
			return new ShortBindTransform(false);
		}
		if (Byte.TYPE.toString().equals(type.toString())) {
			return new ByteBindTransform(false);
		}
		if (Character.TYPE.toString().equals(type.toString())) {
			return new CharacterBindTransform(false);
		}
		return null;
	}
1115603
private Object getKeyForActionMap(JComponent component, KeyStroke keyStroke) {
		for (int i = 0; i < 3; i++) {
			InputMap inputMap = component.getInputMap(i);
			if (inputMap != null) {
				Object key = inputMap.get(keyStroke);
				if (key != null) {
					return key;
				}
			}
		}
		return null;
	}
1281113
def translate_key(jsonkey):
  ""
  nombre,pkey,field=ujson.loads(jsonkey)
  return FieldKey(nombre,tuple(pkey),field)
1175307
private static String getKeyValuePair(final String key, final String value, 
        final boolean formEncoding)
        {
        final StringBuilder sb = new StringBuilder ();
        
        final String firstEncoded;
        final String secondEncoded;
        if (formEncoding)
            {
            firstEncoded = urlFormEncode (key);
            secondEncoded = urlFormEncode (value);
            }
        else
            {
            firstEncoded = urlNonFormEncode (key);
            secondEncoded = urlNonFormEncode (value);
            }
        sb.append (firstEncoded);
        sb.append ('=');
        sb.append (secondEncoded);
        
        return sb.toString ();
        }
1125380
static PrefsTransform getLanguageTransform(TypeName type) {
		String typeName = type.toString();

		if (Integer.class.getCanonicalName().equals(typeName)) {
			return new IntegerPrefsTransform(true);
		}
		if (Boolean.class.getCanonicalName().equals(typeName)) {
			return new BooleanPrefsTransform(true);
		}
		if (Long.class.getCanonicalName().equals(typeName)) {
			return new LongPrefsTransform(true);
		}
		if (Double.class.getCanonicalName().equals(typeName)) {
			return new DoublePrefsTransform(true);
		}
		if (Float.class.getCanonicalName().equals(typeName)) {
			return new FloatPrefsTransform(true);
		}
		if (Short.class.getCanonicalName().equals(typeName)) {
			return new ShortPrefsTransform(true);
		}
		if (Byte.class.getCanonicalName().equals(typeName)) {
			return new BytePrefsTransform(true);
		}
		if (Character.class.getCanonicalName().equals(typeName)) {
			return new CharacterPrefsTransform(true);
		}
		if (String.class.getCanonicalName().equals(typeName)) {
			return new StringPrefsTransform();
		}
		return null;
	}
255138
public KeyDeclaration getKey(int i) throws ArrayIndexOutOfBoundsException
  {

    if (null == m_keyDeclarations)
      throw new ArrayIndexOutOfBoundsException();

    return (KeyDeclaration) m_keyDeclarations.elementAt(i);
  }
1036817
function withKeys(obj, keyList) {
    var retObject = {};
    var index, ptr;

    if (typeof obj != "object") {
        return retObject;
    }

    if (typeof keyList != "object"
        || !keyList.hasOwnProperty("length")
        || keyList.length <= 0) {
        return obj;
    }

    for (index in obj) {
        if (obj.hasOwnProperty(index)) {
            ptr = keyList.indexOf(index);
            if (ptr >= 0) {
                retObject[index] = obj[index];
            }
        }
    }

    return retObject;
}