The Uniprot mappings to other database identifiers for this sequence
@return
350176
@Override
	public LinkedHashMap<String, ArrayList<DBReferenceInfo>> getDatabaseReferences()  {
		LinkedHashMap<String, ArrayList<DBReferenceInfo>> databaseReferencesHashMap = new LinkedHashMap<String, ArrayList<DBReferenceInfo>>();
		if (uniprotDoc == null) {
			return databaseReferencesHashMap;
		}

		try {
			Element uniprotElement = uniprotDoc.getDocumentElement();
			Element entryElement = XMLHelper.selectSingleElement(uniprotElement, "entry");
			ArrayList<Element> dbreferenceElementList = XMLHelper.selectElements(entryElement, "dbReference");
			for (Element element : dbreferenceElementList) {
				String type = element.getAttribute("type");
				String id = element.getAttribute("id");
				ArrayList<DBReferenceInfo> idlist = databaseReferencesHashMap.get(type);
				if (idlist == null) {
					idlist = new ArrayList<DBReferenceInfo>();
					databaseReferencesHashMap.put(type, idlist);
				}
				DBReferenceInfo dbreferenceInfo = new DBReferenceInfo(type, id);
				ArrayList<Element> propertyElementList = XMLHelper.selectElements(element, "property");
				for (Element propertyElement : propertyElementList) {
					String propertyType = propertyElement.getAttribute("type");
					String propertyValue = propertyElement.getAttribute("value");
					dbreferenceInfo.addProperty(propertyType, propertyValue);
				}

				idlist.add(dbreferenceInfo);
			}
		} catch (XPathExpressionException e) {
			logger.error("Problems while parsing db references in UniProt XML: {}. No db references will be available.",e.getMessage());
			return new LinkedHashMap<String, ArrayList<DBReferenceInfo>>();
		}

		return databaseReferencesHashMap;
	}
415357
public List<SqlResultSetMapping<OrmDescriptor>> getAllSqlResultSetMapping()
   {
      List<SqlResultSetMapping<OrmDescriptor>> list = new ArrayList<SqlResultSetMapping<OrmDescriptor>>();
      List<Node> nodeList = model.get("sql-result-set-mapping");
      for(Node node: nodeList)
      {
         SqlResultSetMapping<OrmDescriptor>  type = new SqlResultSetMappingImpl<OrmDescriptor>(this, "sql-result-set-mapping", model, node);
         list.add(type);
      }
      return list;
   }
283830
public java.util.List<String> getNatGatewayIds() {
        if (natGatewayIds == null) {
            natGatewayIds = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return natGatewayIds;
    }
704692
public java.util.List<DBSecurityGroup> getDBSecurityGroups() {
        if (dBSecurityGroups == null) {
            dBSecurityGroups = new com.amazonaws.internal.SdkInternalList<DBSecurityGroup>();
        }
        return dBSecurityGroups;
    }
507541
public java.util.List<DBSubnetGroup> getDBSubnetGroups() {
        if (dBSubnetGroups == null) {
            dBSubnetGroups = new com.amazonaws.internal.SdkInternalList<DBSubnetGroup>();
        }
        return dBSubnetGroups;
    }
484679
public Set<Integer> getOutlinkIDs()
	{
		Set<Integer> tmpSet = new HashSet<Integer>();

		Session session = wiki.__getHibernateSession();
		session.beginTransaction();
		session.buildLockRequest(LockOptions.NONE).lock(hibernatePage);

		tmpSet.addAll(hibernatePage.getOutLinks());

		session.getTransaction().commit();
		return tmpSet;
	}
666074
public Set<String> loadUuidsOfComponentsWithOpenIssues() {
    try (DbSession dbSession = dbClient.openSession(false)) {
      return dbClient.issueDao().selectComponentUuidsOfOpenIssuesForProjectUuid(dbSession, treeRootHolder.getRoot().getUuid());
    }
  }
78281
private static ProteinSequence getUniprot(String uniProtID) throws Exception {

		AminoAcidCompoundSet set = AminoAcidCompoundSet.getAminoAcidCompoundSet();
		UniprotProxySequenceReader<AminoAcidCompound> uniprotSequence = new UniprotProxySequenceReader<AminoAcidCompound>(uniProtID,set);

		ProteinSequence seq = new ProteinSequence(uniprotSequence);

		return seq;
	}
941996
public String determineDatabaseName() {
		if (this.generateUniqueName) {
			if (this.uniqueName == null) {
				this.uniqueName = UUID.randomUUID().toString();
			}
			return this.uniqueName;
		}
		if (StringUtils.hasLength(this.name)) {
			return this.name;
		}
		if (this.embeddedDatabaseConnection != EmbeddedDatabaseConnection.NONE) {
			return "testdb";
		}
		return null;
	}
1172543
public DataStore<? extends DBIDs> getNeighs() {
    final DBIDs ids = points.getDBIDs();
    // init lists
    WritableDataStore<ModifiableDBIDs> neighs = DataStoreUtil.makeStorage(ids, DataStoreFactory.HINT_HOT, ModifiableDBIDs.class);
    for(DBIDIter it = ids.iter(); it.valid(); it.advance()) {
      neighs.put(it, DBIDUtil.newHashSet());
    }

    FiniteProgress splitp = LOG.isVerbose() ? new FiniteProgress("Processing splits for neighborhoods", splitsets.size(), LOG) : null;
    // go through all sets
    Iterator<ArrayDBIDs> it1 = splitsets.iterator();
    DBIDVar v = DBIDUtil.newVar();
    while(it1.hasNext()) {
      ArrayDBIDs pinSet = it1.next();

      final int indoff = pinSet.size() >> 1; // middle point of projection
      pinSet.assignVar(indoff, v);
      // add all points as neighbors to middle point
      neighs.get(v).addDBIDs(pinSet);

      // and the the middle point to all other points in set
      for(DBIDIter it = pinSet.iter(); it.valid(); it.advance()) {
        neighs.get(it).add(v);
      }
      LOG.incrementProcessed(splitp);
    }
    LOG.ensureCompleted(splitp);
    return neighs;
  }
1348482
public List<EntityResult<SqlResultSetMapping<T>>> getAllEntityResult()
   {
      List<EntityResult<SqlResultSetMapping<T>>> list = new ArrayList<EntityResult<SqlResultSetMapping<T>>>();
      List<Node> nodeList = childNode.get("entity-result");
      for(Node node: nodeList)
      {
         EntityResult<SqlResultSetMapping<T>>  type = new EntityResultImpl<SqlResultSetMapping<T>>(this, "entity-result", childNode, node);
         list.add(type);
      }
      return list;
   }
1074327
public Map<String, Set<ServiceDefinition>> getNamespaceServiceDefinitionMap() {
        Map<String, Set<ServiceDefinition>> namespaceServiceDefinitionMap = new HashMap<String, Set<ServiceDefinition>>();

        for (String namespace : serviceImplementationMap.keySet()) {
            Set<ServiceDefinition> serviceDefinitions = new HashSet<ServiceDefinition>();
            namespaceServiceDefinitionMap.put(namespace, serviceDefinitions);
            for (ServiceDefinition sd : serviceImplementationMap.get(namespace).keySet()) {
                serviceDefinitions.add(sd);
            }
        }
        return Collections.unmodifiableMap(namespaceServiceDefinitionMap);
    }
1238089
public ResultSet getGeneratedKeys(Protocol protocol) {
    if (insertId == 0) {
      return SelectResultSet.createEmptyResultSet();
    }

    if (updateCount > 1) {
      long[] insertIds = new long[(int) updateCount];
      for (int i = 0; i < updateCount; i++) {
        insertIds[i] = insertId + i * autoIncrement;
      }
      return SelectResultSet.createGeneratedData(insertIds, protocol, true);
    }

    return SelectResultSet.createGeneratedData(new long[]{insertId}, protocol, true);
  }
435858
protected Set<String> getAttributeNames() {
        if(columnMetadata == null || columnMetadata.isEmpty()) throw new InitException("Failed to find table: " + getTableName());
        return Collections.unmodifiableSet(columnMetadata.keySet());
    }
1102378
public java.util.List<IdentityPoolUsage> getIdentityPoolUsages() {
        if (identityPoolUsages == null) {
            identityPoolUsages = new com.amazonaws.internal.SdkInternalList<IdentityPoolUsage>();
        }
        return identityPoolUsages;
    }
1015666
public List<Identifier> getIdentifiers() {
        if (mIdentifiers.getClass().isInstance(UNMODIFIABLE_LIST_OF_IDENTIFIER)) {
            return mIdentifiers;
        }
        else {
            return Collections.unmodifiableList(mIdentifiers);
        }
    }
675859
public Set<String> queryFeatureNames() {
        Set<String> result = null;
        try {
            //if you change the 'null' arg, don't forget to implement the exception handler block!
            ServiceReference<?>[] refs = this.systemBundleCtx.getAllServiceReferences(ServerFeatures.class.getName(), null);
            if (refs != null && refs.length > 0) {
                result = new HashSet<String>();
                //if we somehow had more than one eligible service, we will use them all.
                //result will then be the aggregate of all data.
                for (ServiceReference<?> sr : refs) {
                    ServerFeatures sf = (ServerFeatures) this.systemBundleCtx.getService(sr);
                    String infos[] = sf.getServerFeatureNames();
                    for (String info : infos) {
                        result.add(info);
                    }
                }
            }
        } catch (InvalidSyntaxException e) {
            //tough for the filter 'null' to be invalid..
        }

        //sort the list alpha.. just makes it neater to debug missing files..
        ArrayList<String> sorted = new ArrayList<String>();
        if (result != null)
            sorted.addAll(result);
        Collections.sort(sorted);
        result = new LinkedHashSet<String>(); //linked set will preserve order

        //maybe addAll will work here, it's not clear, the intent is to preserve the sorted order.
        for (String s : sorted) {
            result.add(s);
        }
        return result;
    }