/*!
\class Identifier
\brief Unique and immutable identifier composed of digit, sources, counters
\param d the digit (position in dense space)
\param s the list of sources
\param c the list of counters
187210
function Identifier(d, s, c){
    this._d = d;
    this._s = s;
    this._c = c;
}
488194
def identifier(key)
      key &&= key.to_sym
      return unless Rudy::ID_MAP.has_key?(key)
      Rudy::ID_MAP[key]
    end
240463
def id(cls):
        
        if cls.__uuid_primary_key__:
            return immutable(Column(UUIDType(binary=False), default=uuid_.uuid4, primary_key=True, nullable=False))
        else:
            return immutable(Column(Integer, primary_key=True, nullable=False))
43921
def parametrize(self, operator, params):
        
        return (CaselessKeyword(operator, identChars=alphanums) +
                self.parameter(params))
189270
function() {
        var ch = exprICode(index),
          start = index,
          identifier;

        if (isIdentifierStart(ch)) {
          index++;
        } else {
          throwError("Unexpected " + exprI(index), index);
        }

        while (index < length) {
          ch = exprICode(index);
          if (isIdentifierPart(ch)) {
            index++;
          } else {
            break;
          }
        }
        identifier = expr.slice(start, index);

        if (literals.hasOwnProperty(identifier)) {
          return {
            type: code.LITERAL,
            value: literals[identifier],
            raw: identifier
          };
        } else if (identifier === this_str) {
          return { type: code.THIS_EXP };
        } else {
          return {
            type: code.IDENTIFIER,
            name: identifier
          };
        }
      }
200844
def identifiers
      if @typecode < Composite
        GCCType.new( @typecode.element_type ).identifiers * @typecode.num_elements
      else
        [ GCCType.new( @typecode ).identifier ]
      end
    end
161671
public static byte []
toDNS(DSAParams params, byte [] sig)
throws SignatureException
{
	int rLength, sLength;
	int rOffset, sOffset;
	if ((sig[0] != ASN1_SEQ) || (sig[2] != ASN1_INT))
		throw new SignatureException("Expected SEQ, INT");
	rLength = sig[3];
	rOffset = 4;
	if (sig[rOffset] == 0) {
		rLength--;
		rOffset++;
	}
	if (sig[rOffset+rLength] != ASN1_INT)
		throw new SignatureException("Expected INT");
	sLength = sig[rOffset + rLength + 1];
	sOffset = rOffset + rLength + 2;
	if (sig[sOffset] == 0) {
		sLength--;
		sOffset++;
	}

	if ((rLength > 20) || (sLength > 20))
		throw new SignatureException("DSA R/S too long");

	byte[] newSig = new byte[41];
	Arrays.fill(newSig, (byte) 0);
	newSig[0] = (byte) ((params.getP().bitLength() - 512)/64);
	System.arraycopy(sig, rOffset, newSig, 1 + (20 - rLength), rLength);
	System.arraycopy(sig, sOffset, newSig, 21 + (20 - sLength), sLength);
	return newSig;
}
780806
function passId (trace, i, j) {
	let id = (trace.id != null ? trace.id : trace)
	let n = i
	let m = j
	let key = id << 16 | (n & 0xff) << 8 | m & 0xff

	return key
}
237341
function uniqueId() {
  var prefix = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'id_';
  var id = prefix + strRand();
  if (!store.uniqueId) store.uniqueId = {};
  var generatedIds = store.uniqueId;

  if (document.getElementById(id) || generatedIds[id]) {
    return uniqueId(prefix);
  } else {
    generatedIds[id] = true;
    return id;
  }
}
1043898
function(identifier, parent) {
        var parts = identifier.split('.');
        var i = 0;
        parent = parent || window;
        while (i < parts.length) {
            parent[parts[i]] = parent[parts[i]] || {};
            parent = parent[parts[i]];
            i++;
        }
        return parent;
    }
919914
function getIdlParameterList(parameters) {
    var result = []

    if (parameters.length == 0) return "";

    result.push("<table>")
    parameters.forEach(function(parameter, index, list){
        var comma = (index == list.length-1) ? "" : ","
        result.push("<tr>")
        result.push("<td>" + Indent2 + (parameter.out ? "out" : "in"))
        result.push("<td>" + getIdlType(parameter.type))
        result.push("<td>" + "<span class='parameterName tdIndent'>" + parameter.name + comma + "</span>")
    })

    result.push("</table>")
    return result.join("\n") + Indent
}
763731
def t_IDENTIFIER(t):
  "
  if t.value in keywords:
    t.type = t.value
  return t
932090
function marshallCustomIdentifiers(request, shape) {
  var identifiers = {};
  marshallCustomIdentifiersHelper(identifiers, request.params, shape);
  return identifiers;
}
1238395
def p_identifier_name_string(self, p):
        
        p[0] = asttypes.PropIdentifier(p[1].value)
        # manually clone the position attributes.
        for k in ('_token_map', 'lexpos', 'lineno', 'colno'):
            setattr(p[0], k, getattr(p[1], k))
893088
private Key[] longListToNativeKeys(Class<?> entityClass, List<Long> identifiers) {
    if (identifiers == null || identifiers.isEmpty()) {
      return new Key[0];
    }
    EntityMetadata entityMetadata = EntityIntrospector.introspect(entityClass);
    Key[] nativeKeys = new Key[identifiers.size()];
    KeyFactory keyFactory = entityManager.newNativeKeyFactory();
    keyFactory.setKind(entityMetadata.getKind());
    for (int i = 0; i < identifiers.size(); i++) {
      long id = identifiers.get(i);
      nativeKeys[i] = keyFactory.newKey(id);
    }
    return nativeKeys;
  }
260126
function _generate_identifier()
    {
        $identifier = 'SSH-2.0-phpseclib_2.0';

        $ext = array();
        if (function_exists('\\Sodium\\library_version_major')) {
            $ext[] = 'libsodium';
        }

        if (extension_loaded('openssl')) {
            $ext[] = 'openssl';
        } elseif (extension_loaded('mcrypt')) {
            $ext[] = 'mcrypt';
        }

        if (extension_loaded('gmp')) {
            $ext[] = 'gmp';
        } elseif (extension_loaded('bcmath')) {
            $ext[] = 'bcmath';
        }

        if (!empty($ext)) {
            $identifier .= ' (' . implode(', ', $ext) . ')';
        }

        return $identifier;
    }
636342
def by_type(self, identifier_class):
        
        myidentifiers = set()
        for identifier in self.source_identifiers.values():
            if (isinstance(identifier, identifier_class)):
                myidentifiers.update([identifier])
        return set(myidentifiers)