Returns an ObjectId for the given name.  Names are in the format
 <ModuleName>::<NodeName>.<Index> with ModuleName and Index being
 optional.
509254
def oid(name)
      module_parts = name.to_str.split("::")
      if module_parts.length == 1
        parse_oid(@by_name, name.to_str)
      elsif module_parts.length == 2
        module_name = module_parts[0]
        oid = module_parts[1]
        module_hash = @by_module_by_name[module_name]
        if module_hash
          parse_oid(module_hash, oid)
        else
          raise ModuleNotLoadedError, "module '#{module_name}' not loaded"
        end
      else
        raise ArgumentError, "invalid format: #{name.to_str}"
      end
    end
209681
public static String getName(ObjectIdentifier oid) {
        OIDInfo info = oidMap.get(oid);
        return (info == null) ? null : info.name;
    }
1105650
public int getIndex(String name) {
    Integer index = nameIndex.get(name);
    if (index == null) {
      throw new IllegalArgumentException("Field with name '" + name + "' was not found");
    }
    return index;
  }
153082
public String getObjectId() {
    if (TextObject_Type.featOkTst && ((TextObject_Type)jcasType).casFeat_objectId == null)
      jcasType.jcas.throwFeatMissing("objectId", "de.julielab.jules.types.TextObject");
    return jcasType.ll_cas.ll_getStringValue(addr, ((TextObject_Type)jcasType).casFeatCode_objectId);}
1063148
def get_index_by_name(self, name):
        """"""
        for i in range(self.n_blocks):
            if self.get_block_name(i) == name:
                return i
        raise KeyError('Block name ({}) not found'.format(name))
700205
def get_node(self, node_name):
        """"""
        for node in self.nodes:
            if node.__name__ == node_name:
                return node
1132558
def get_node_by_name(graph, name):
    """"""
    for id, attrs in graph.nodes(data=True):
        if attrs['n'] == name:
            return id
23563
def ids(data)

      # Just return if nothing to do
      return data if data and data.empty?

      # Support passing id as string
      data = {'_id' => data} if !data or data.is_a?(String)

      # Turn all keys to string
      data = data.stringify_keys

      # Convert id to _id for mongo
      data['_id'] = data.delete('id') if data['id']

      # Convert ids to BSON ObjectId
      data.each do |k, v|
        if v.is_a?(String) and v =~ /^[0-9a-fA-F]{24}$/
          data[k] = oid(v)
        end
      end

      # Return data
      data
    end
722837
def _get_oid(data, position, dummy0, dummy1, dummy2):
    """"""
    end = position + 12
    return ObjectId(data[position:end]), end
827515
def get(self, node_id):
        
        return \
            self._nodes[_node.Root.ID].get(node_id) or \
            self._nodes[_node.Root.ID].get(self._sid_map.get(node_id))
1300047
def getNamedItem(self, name: str) -> Optional[Attr]:
        
        return self._dict.get(name, None)
1222766
public static String objectId(Object object) {
        if (object == null) {
            return "?";
        }
        if (object instanceof IdInfoProvider) {
            return getId(((IdInfoProvider) object).idScope(),
                ((IdInfoProvider) object).idObject());
        } else {
            return getId(object.getClass(), object);
        }
    }
620366
function objectId_jsonSchema(name) {

  var result = simpleType_jsonSchema.call(this, name);

  result.type = 'string';
  result.pattern = '^[0-9a-fA-F]{24}$';

  return result;
}
787684
def name(self, id):
        
        data = self.bytes(id, 'N')
        if not data:
            print("%x has no name" % id)
            return
        if data[:1] == b'\x00':
            nameid, = struct.unpack_from(">" + self.fmt, data, 1)
            nameblob = self.blob(self.nodebase, 'S', nameid * 256, nameid * 256 + 32)
            return nameblob.rstrip(b"\x00").decode('utf-8')
        return data.rstrip(b"\x00").decode('utf-8')
780266
public static ObjectId valueOf( String uuid ) {
        int p = uuid.indexOf("/");
        if (p < 0) {
            return new ObjectId(Type.OBJECT, uuid);
        }
        
        int p1 = p;
        while (p > 0) {
            p1 = p;
            p = uuid.indexOf("/", p + 1);
        }
        
        p = p1;
        String ident = uuid.substring(0, p);
        String type = uuid.substring(p + 1);

        return new ObjectId(Type.valueOf(type.toUpperCase()), ident);
    }
107492
def get_node_by_name(self, nodename):
        
        for kind, nodes in self.nodes.items():
            for node in nodes:
                if node.name == nodename:
                    return node
        else:
            raise NodeNotFound(
                "Node `{0}` not found in cluster `{1}`"
                .format(nodename, self.name))
1220121
def get_synonym(objectID, request_options = {})
      client.get(Protocol.synonym_uri(name, objectID), :read, request_options)
    end