private void mergeTables(
final CyTable source, final CyTable target, final Class<? extends CyIdentifiable> type) {
CyColumn sourceKey = source.getPrimaryKey();
CyColumn targetKey = target.getPrimaryKey();
String keyName = sourceKey.getName();
// Make sure keys match
if (keyName.equals(targetKey.getName())) {
// Merge columns first, because even if the source table has no rows to merge,
// the columns have to be restored
mergeColumns(keyName, source, target);
for (CyRow sourceRow : source.getAllRows()) {
if (cancelled) return;
Long key = sourceRow.get(keyName, Long.class);
CyIdentifiable entry = cache.getObjectById(key, type);
Long mappedKey = entry != null ? entry.getSUID() : null;
if (mappedKey == null) mappedKey = key;
CyRow targetRow = target.getRow(mappedKey);
mergeRow(keyName, sourceRow, targetRow);
}
}
}
private String convertToName(final String id) {
final Collection<CyRow> rows =
ontologyDAG.getDefaultNodeTable().getMatchingRows(CyNetwork.NAME, id);
if (!rows.isEmpty()) {
final CyRow row = rows.iterator().next();
final String termName = row.get(OBOReader.TERM_NAME, String.class);
if (termName != null) return termName;
else return id;
} else return id;
}
public void mapNodeColumn(final String[] entries, final CyRow sourceRow, final CyRow targetRow) {
this.isSelfEdge = false;
// Primary ID sets
final Map<String, String> accsSource = createNames(entries[0]);
processNames(sourceRow, accsSource);
// ALT and Aliases
final Map<String, List<String>> otherSource = createOtherNames(entries[2], entries[4]);
processOtherNames(sourceRow, otherSource);
if (currentGeneName != null) sourceRow.set(PREDICTED_GENE_NAME, currentGeneName);
else {
guessHumanReadableName(sourceRow);
}
setSpecies(entries[9], sourceRow);
if (!isSelfEdge) {
final Map<String, String> accsTarget = createNames(entries[1]);
processNames(targetRow, accsTarget);
final Map<String, List<String>> otherTarget = createOtherNames(entries[3], entries[5]);
processOtherNames(targetRow, otherTarget);
if (currentGeneName != null) targetRow.set(PREDICTED_GENE_NAME, currentGeneName);
else {
guessHumanReadableName(targetRow);
}
setSpecies(entries[10], targetRow);
}
// For 2.7 data
if (entries.length > 15) {
// addListColumn(sourceRow, entries[16], "Biological Role", String.class);
// addListColumn(targetRow, entries[17], "Biological Role", String.class);
//
// addListColumn(sourceRow, entries[18], "Experimental Role", String.class);
// addListColumn(targetRow, entries[19], "Experimental Role", String.class);
addListColumn(sourceRow, entries[20], INTERACTOR_TYPE, String.class);
addListColumn(targetRow, entries[21], INTERACTOR_TYPE, String.class);
addListColumn(sourceRow, entries[22], "Xref", String.class);
addListColumn(targetRow, entries[23], "Xref", String.class);
addSimpleListColumn(sourceRow, entries[25], "Annotations");
addSimpleListColumn(targetRow, entries[26], "Annotations");
addSimpleListColumn(sourceRow, entries[36], "Features");
addSimpleListColumn(targetRow, entries[38], "Features");
// addListColumn(sourceRow, entries[40], "Participant Detection Method", String.class);
// addListColumn(targetRow, entries[41], "Participant Detection Method", String.class);
}
}
private final void setSpecies(final String speciesText, CyRow row) {
// Pick first entry only.
final String[] entries = SPLITTER.split(speciesText);
final String[] values = parseValues(entries[0]);
if (values[1] != null) {
row.set(TAXNOMY, values[1]);
}
if (values[2] != null) {
row.set(TAXNOMY_NAME, values[2]);
}
}
private boolean findHumanReadableName(
final CyRow row, final List<String> attrList, Pattern pattern, boolean exist) {
String candidateString = null;
for (final String geneID : attrList) {
if (pattern.matcher(geneID).find() == exist) {
candidateString = geneID;
break;
}
}
if (candidateString != null) {
if (candidateString.contains("_")) {
final String firstPart = candidateString.split("_")[0];
for (String candidate : attrList) {
if (candidate.equalsIgnoreCase(firstPart)) {
candidateString = firstPart;
break;
}
}
}
row.set(PREDICTED_GENE_NAME, candidateString);
return true;
}
return false;
}
/**
* Add a single entry
*
* @param row
* @param val
* @param columnName
*/
private final void addSingleColumn(
final CyRow row, final String val, final String columnName, final Class<?> dataType) {
// Ignore invalid entry.
if (val == null || val.equals("-")) {
return;
}
// Create column if necessary
if (row.getTable().getColumn(columnName) == null) {
row.getTable().createColumn(columnName, dataType, false);
}
Object newValue = val;
if (dataType == Boolean.class) newValue = Boolean.parseBoolean(val);
row.set(columnName, newValue);
}
private void processOtherNames(CyRow row, final Map<String, List<String>> accs) {
for (String originalDBName : accs.keySet()) {
final String dbName = validateNamespace(originalDBName);
if (row.getTable().getColumn(dbName) == null)
row.getTable().createListColumn(dbName, String.class, false);
List<String> currentList = row.getList(dbName, String.class);
if (currentList == null) currentList = new ArrayList<String>();
final Set<String> nameSet = new HashSet<String>(currentList);
final List<String> names = accs.get(originalDBName);
nameSet.addAll(names);
row.set(dbName, new ArrayList<String>(nameSet));
}
}
@Override
public boolean handleIt(
final CyIdentifiable to,
final CyColumn toColumn,
final Map<CyIdentifiable, CyColumn> mapFromGOFromAttr) {
if (to == null || toColumn == null || mapFromGOFromAttr == null) {
throw new java.lang.NullPointerException("All parameters should not be null.");
}
final CyTable table = toColumn.getTable();
final CyRow row = table.getRow(to.getSUID());
final ColumnType type = ColumnType.getType(toColumn);
if (type == ColumnType.STRING) {
final String toValue = row.get(toColumn.getName(), String.class);
final Set<String> values = new TreeSet<String>();
values.add(toValue);
for (Map.Entry<CyIdentifiable, CyColumn> entry : mapFromGOFromAttr.entrySet()) {
final CyIdentifiable from = entry.getKey();
final CyColumn fromColumn = entry.getValue();
final CyRow fromRow = fromColumn.getTable().getRow(from.getSUID());
// TODO figure out which network to be using
String fromValue = fromRow.get(fromColumn.getName(), String.class);
if (fromValue != null) {
values.add(fromValue.toString());
}
}
StringBuilder str = new StringBuilder();
for (String v : values) {
str.append(v + ";");
}
str.deleteCharAt(str.length() - 1);
row.set(toColumn.getName(), str.toString());
return true;
}
// FIXME: how about Integer, Double, Boolean?
return false;
}
private void processSpecies(CyRow row, CrossReference ref) {
if (ref != null) {
final String name = ref.getText();
final String speciesID = ref.getIdentifier();
row.set(TAXNOMY, speciesID);
row.set(TAXNOMY_NAME, name);
}
}
private void guessHumanReadableName(final CyRow row) {
boolean found = false;
// Special handler for STRING. This is a hack...
if (row.getTable().getColumn(STRING_ATTR_NAME) != null) {
final List<String> stringList = row.getList(STRING_ATTR_NAME, String.class);
if (stringList != null) found = findHumanReadableName(row, stringList, ncbiPattern, true);
}
if (found) return;
// try NCBI
if (row.getTable().getColumn(ENTREZ_GENE_ATTR_NAME) != null) {
final List<String> ncbiList = row.getList(ENTREZ_GENE_ATTR_NAME, String.class);
if (ncbiList != null) found = findHumanReadableName(row, ncbiList, ncbiPattern, true);
}
if (found) return;
// Try Uniprot
List<String> uniprotList = null;
if (row.getTable().getColumn(UNIPROT_ATTR_NAME) != null) {
uniprotList = row.getList(UNIPROT_ATTR_NAME, String.class);
if (uniprotList != null) found = findHumanReadableName(row, uniprotList, exact1Pattern, true);
}
if (found) return;
if (uniprotList != null) found = findHumanReadableName(row, uniprotList, uniprotPattern, false);
if (found) return;
// Unknown
if (row.getTable().getColumn("unknown") != null) {
final List<String> unknownList = row.getList("unknown", String.class);
if (unknownList != null)
found = findHumanReadableName(row, unknownList, uniprotPattern, false);
}
if (found) return;
if (found == false) {
// Give up. Use primary key
row.set(PREDICTED_GENE_NAME, row.get(CyNetwork.NAME, String.class));
}
}
private void mergeRow(String keyName, CyRow sourceRow, CyRow targetRow) {
for (CyColumn column : sourceRow.getTable().getColumns()) {
if (cancelled) return;
String columnName = column.getName();
if (columnName.equals(keyName)) continue;
Class<?> type = column.getType();
if (type.equals(List.class)) {
Class<?> elementType = column.getListElementType();
List<?> list = sourceRow.getList(columnName, elementType);
targetRow.set(columnName, list);
} else {
Object value = sourceRow.get(columnName, type);
targetRow.set(columnName, value);
}
}
}
public void mapEdgeColumn(final EncoreInteraction interaction, final CyRow row) {
final Set<String> exp = interaction.getExperimentToPubmed().keySet();
row.set(DETECTION_METHOD_ID, new ArrayList<String>(exp));
final List<CrossReference> pubIDs = interaction.getPublicationIds();
final List<String> pubIdList = new ArrayList<String>();
final List<String> pubDBList = new ArrayList<String>();
for (CrossReference pub : pubIDs) {
pubIdList.add(pub.getIdentifier());
pubDBList.add(pub.getDatabase());
}
if (pubIdList.isEmpty() == false) row.set(PUB_ID, pubIdList);
if (pubDBList.isEmpty() == false) row.set(PUB_DB, pubDBList);
// Interaction (use UniqueID)
row.set(CyEdge.INTERACTION, interaction.getMappingIdDbNames());
final List<Confidence> scores = interaction.getConfidenceValues();
for (Confidence c : scores) {
String type = c.getType();
String value = c.getValue();
if (row.getTable().getColumn(type) == null)
row.getTable().createColumn(type, Double.class, true);
try {
double doubleVal = Double.parseDouble(value);
row.set(type, doubleVal);
} catch (NumberFormatException e) {
// logger.warn("Invalid number string: " + value);
// Ignore invalid number
}
}
}
@Test
public void gaReaderTest() throws Exception {
File file = new File("./src/test/resources/" + GA_YEAST);
GeneAssociationReader reader =
new GeneAssociationReader(
"dummy dag", file.toURI().toURL().openStream(), "yeast GA", serviceRegistrar);
System.out.print("Start read: ");
reader.run(tm);
final CyTable[] tables = reader.getTables();
assertNotNull(tables);
assertEquals(1, tables.length);
assertNotNull(tables[0]);
// All 22 Columns + NAME primary key + synonyms
assertEquals(24, tables[0].getColumns().size());
// For yeast test file.
assertEquals(6359, tables[0].getRowCount());
// Check table contents
final CyTable table = tables[0];
final CyRow row1 = table.getRow("S000003319");
assertNotNull(row1);
final List<String> bpList1 = row1.getList("biological process", String.class);
assertNotNull(bpList1);
assertFalse(bpList1.contains("GO:0000287"));
assertTrue(bpList1.contains("GO:0006067"));
assertFalse(bpList1.contains("fake value"));
final String taxName = row1.get(GeneAssociationTag.TAXON.toString(), String.class);
assertNotNull(taxName);
assertEquals("Saccharomyces cerevisiae", taxName);
final List<String> referenceList1 =
row1.getList("biological process DB Reference", String.class);
// assertNotNull(referenceList1);
// assertEquals(2, referenceList1.size());
}
/**
* Split the entry by the delimiter and simply creates list column from the values.
*
* @param row
* @param val
* @param columnName
*/
private final void addSimpleListColumn(
final CyRow row, final String val, final String columnName) {
// Ignore invalid entry.
if (val == null || val.equals("-")) {
return;
}
// Create column if necessary
if (row.getTable().getColumn(columnName) == null) {
row.getTable().createListColumn(columnName, String.class, false);
}
final String[] entries = SPLITTER.split(val);
final List<String> ids = new ArrayList<String>();
for (final String entry : entries) {
if (entry != null) {
final String newEntry = entry.replaceAll("\"", "");
ids.add(newEntry);
}
}
if (!ids.isEmpty()) row.set(columnName, ids);
}
public void handleEvent(RowsSetEvent e) {
final CyTable local = e.getSource();
synchronized (lock) {
final List<CyTable> sharedList = tables.get(local);
for (CyTable shared : sharedList) {
for (RowSetRecord record : e.getColumnRecords(columnName)) {
// assume payload collection is for same column
final CyRow r = shared.getRow(record.getRow().get(CyIdentifiable.SUID, Long.class));
if (r != null) {
final Object name = record.getValue();
String sharedName = r.get(sharedColumnName, String.class);
if (sharedName == null) {
r.set(sharedColumnName, name);
}
}
}
}
}
}
/** {@inheritDoc} */
@Override
public Evidence[] mapFromTable(CyEdge edge, CyTable table) {
if (edge == null) throw new NullPointerException("edge cannot be null");
if (table == null) throw new NullPointerException("table cannot be null");
Set<String> nonAnnotationColumns =
new HashSet<String>(
asList(
CyNetwork.SUID,
NETWORK_SUID,
NETWORK_NAME,
EDGE_SUID,
BEL_STATEMENT,
SUMMARY_TEXT,
CITATION_ID,
CITATION_NAME,
CITATION_TYPE,
SPECIES));
Collection<CyRow> evidenceRows = table.getMatchingRows(EDGE_SUID, edge.getSUID());
List<Evidence> evidences = new ArrayList<Evidence>(evidenceRows.size());
if (!evidenceRows.isEmpty()) {
for (CyRow evRow : evidenceRows) {
Evidence e = new Evidence();
e.belStatement = evRow.get(BEL_STATEMENT, String.class);
e.summaryText = evRow.get(SUMMARY_TEXT, String.class);
e.citation = new Citation();
e.citation.id = evRow.get(CITATION_ID, String.class);
e.citation.name = evRow.get(CITATION_NAME, String.class);
e.citation.type = evRow.get(CITATION_TYPE, String.class);
e.biologicalContext = new BiologicalContext();
e.biologicalContext.speciesCommonName = evRow.get(SPECIES, String.class);
e.biologicalContext.variedAnnotations = new HashMap<String, Object>();
for (Entry<String, Object> columnValue : evRow.getAllValues().entrySet()) {
if (nonAnnotationColumns.contains(columnValue.getKey())) continue;
e.biologicalContext.variedAnnotations.put(columnValue.getKey(), columnValue.getValue());
}
evidences.add(e);
}
}
return evidences.toArray(new Evidence[evidences.size()]);
}
private final void addListColumn(
final CyRow row, final String val, final String columnName, final Class<?> listType) {
if (val == null || val.equals("-")) {
return;
}
String newColName = null;
// Create column if necessary
if (columnName != null) {
if (row.getTable().getColumn(columnName) == null) {
row.getTable().createListColumn(columnName, listType, false);
row.getTable().createListColumn(columnName + " ID", String.class, false);
}
newColName = columnName;
}
final String[] entries = SPLITTER.split(val);
final List<String> ids = new ArrayList<String>();
final List<String> descriptions = new ArrayList<String>();
for (final String entry : entries) {
final String[] contents = parseValues(entry);
if (newColName == null) {
if (row.getTable().getColumn(contents[0]) == null) {
row.getTable().createListColumn(contents[0], listType, false);
row.getTable().createListColumn(contents[0] + " ID", String.class, false);
}
newColName = contents[0];
}
if (contents[1] != null) ids.add(contents[1]);
if (contents[2] != null) descriptions.add(contents[2]);
}
if (!ids.isEmpty()) row.set(newColName + " ID", ids);
if (!descriptions.isEmpty()) row.set(newColName, descriptions);
}
@Override
public void run(TaskMonitor taskMonitor) throws Exception {
CaseList caseList = (CaseList) caseSetComboBox.getSelectedItem();
Object[] profiles = profileList.getSelectedValues();
String geneSymbolField = (String) geneSymbolComboBox.getSelectedItem();
// update the configuration to store this field
MondrianApp app = MondrianApp.getInstance();
CyNetwork currentNetwork = app.getAppManager().getCurrentNetwork();
// call the next two lines in the right order!
app.getMondrianConfiguration()
.setNetworkGeneSymbolAttr(currentNetwork.getSUID(), geneSymbolField);
Map<String, Long> geneSymbolMap =
app.getMondrianConfiguration().getGeneNodeMap(currentNetwork.getSUID());
List<String> genes = new ArrayList<String>(geneSymbolMap.keySet());
// Extract data from web service
int p = 1;
List<GeneticProfile> profileList = new ArrayList<GeneticProfile>();
List<MondrianCyTable> importedTables = new ArrayList<MondrianCyTable>();
CyNetwork network = app.getAppManager().getCurrentNetwork();
CancerStudy study = (CancerStudy) cancerStudyComboBox.getSelectedItem();
for (Object obj : profiles) {
GeneticProfile profile = (GeneticProfile) obj;
profileList.add(profile);
taskMonitor.setStatusMessage("Loading genetic profile: " + profile.getName());
taskMonitor.setProgress(p++ / (double) profiles.length);
CyTable table =
MondrianApp.getInstance()
.getTableFactory()
.createTable(profile.getName(), CyIdentifiable.SUID, Long.class, true, true);
DataTypeMatrix matrix = portalClient.getProfileData(caseList, profile, genes);
List<String> dataColNames = matrix.getDataColNames();
for (String colName : dataColNames) {
if (profile.getType() == GENETIC_PROFILE_TYPE.MUTATION_EXTENDED) {
table.createColumn(colName, String.class, false);
} else {
table.createColumn(colName, Double.class, false);
}
}
// Add rows
for (String rowName : matrix.getRowNames()) {
long suid = geneSymbolMap.get(rowName);
CyRow row = table.getRow(suid);
// row.set("selected", currentNetwork.getDefaultNodeTable().getRow(suid).get("selected",
// Boolean.class));
// row.set(geneSymbolField, rowName);
int i = 0;
for (String colName : dataColNames) {
row.set(colName, matrix.getDataRow(rowName).get(i++));
}
}
log.debug(
"Loading genetic profile: "
+ profile.getName()
+ "; Insert Table: "
+ matrix.getNumRows()
+ ", "
+ matrix.getDataColNames().size());
MondrianCyTable mondrianCyTable = new MondrianCyTable(study, profile, caseList, table);
importedTables.add(mondrianCyTable);
//
}
app.getMondrianConfiguration().registerMondrianTables(network, importedTables);
// app.getMondrianConfiguration().cbioDataImport(currentNetwork.getSUID(), profileList,
// caseList);
}
public void mapEdgeColumn(
final String[] entries,
final CyRow row,
final CyEdge edge,
final String sourceName,
final String targetName) {
// Column 7: Detection method
final String[] detectionMethods = SPLITTER.split(entries[6]);
final List<String> methods = new ArrayList<String>();
final List<String> methodID = new ArrayList<String>();
for (final String entry : detectionMethods) {
final String[] methodContents = parseValues(entry);
if (methodContents[1] != null) methodID.add(methodContents[1]);
if (methodContents[2] != null) methods.add(methodContents[2]);
}
if (!methods.isEmpty()) row.set(DETECTION_METHOD_NAME, methods);
if (!methodID.isEmpty()) row.set(DETECTION_METHOD_ID, methodID);
// Column 8: Authors
final String[] authorsParts = SPLITTER.split(entries[7]);
final List<String> authors = new ArrayList<String>();
for (final String entry : authorsParts) {
String updatedAuthor = entry.replaceAll("\"", "");
authors.add(updatedAuthor);
}
if (!authors.isEmpty()) row.set(AUTHOR, authors);
final List<String> pubIdList = new ArrayList<String>();
final List<String> pubDBList = new ArrayList<String>();
final String[] pubID = SPLITTER.split(entries[8]);
for (final String entry : pubID) {
String id = parseValues(entry)[1];
String db = parseValues(entry)[0];
if (id != null && db != null) {
pubDBList.add(db);
pubIdList.add(id);
}
}
if (!pubIdList.isEmpty()) row.set(PUB_ID, pubIdList);
if (!pubDBList.isEmpty()) row.set(PUB_DB, pubDBList);
final String[] dbNames = SPLITTER.split(entries[12]);
row.set(SOURCE_DB, parseValues(dbNames[0])[0]);
// Interaction Types - Use first one as primary type.
final String[] typeParts = SPLITTER.split(entries[11]);
final List<String> types = new ArrayList<String>();
for (final String entry : typeParts) {
final String type = parseValues(entry)[2];
if (type != null) types.add(type);
}
if (!types.isEmpty()) {
row.set(INTERACTION_TYPE, types);
row.set(PRIMARY_INTERACTION_TYPE, types.get(0));
}
// Set interaction: this is an ID.
final String[] interactionID = SPLITTER.split(entries[13]);
final String interaction = parseValues(interactionID[0])[1];
row.set(CyEdge.INTERACTION, interaction);
// Create name
row.set(CyNetwork.NAME, sourceName + " (" + interaction + ") " + targetName);
final String[] scores = SPLITTER.split(entries[14]);
for (String score : scores) {
final String[] scoreArray = parseValues(score);
String scoreType = "Confidence-Score-" + scoreArray[0];
String value = scoreArray[1];
if (value == null) {
continue;
}
if (row.getTable().getColumn(scoreType) == null)
row.getTable().createColumn(scoreType, Double.class, true);
try {
double doubleVal = Double.parseDouble(value);
row.set(scoreType, doubleVal);
} catch (NumberFormatException e) {
// logger.warn("Invalid number string: " + value);
// Ignore invalid number
}
}
// For MITAB 2.7
if (entries.length > 15) {
addListColumn(row, entries[16], "Source Biological Role", String.class);
addListColumn(row, entries[17], "Target Biological Role", String.class);
addListColumn(row, entries[18], "Source Experimental Role", String.class);
addListColumn(row, entries[19], "Target Experimental Role", String.class);
addListColumn(row, entries[40], "Source Participant Detection Method", String.class);
addListColumn(row, entries[41], "Target Participant Detection Method", String.class);
addListColumn(row, entries[15], "Complex Expansion", String.class);
addListColumn(row, entries[24], "Xref", String.class);
addSimpleListColumn(row, entries[27], "Annotation");
addListColumn(row, entries[28], "Host Organism Taxonomy", String.class);
addSimpleListColumn(row, entries[29], "Parameters");
addSingleColumn(row, entries[30], "Creation Date", String.class);
addSingleColumn(row, entries[31], "Update Date", String.class);
addSingleColumn(row, entries[35], "Negative", Boolean.class);
}
}
/** {@inheritDoc} */
@Override
public void mapToTable(Graph graph, Edge edge, Evidence evidence, CyTable table) {
if (graph == null) throw new NullPointerException("graph cannot be null");
if (edge == null) throw new NullPointerException("edge cannot be null");
if (evidence == null) throw new NullPointerException("evidence cannot be null");
if (table == null) throw new NullPointerException("table cannot be null");
if (graph.cyNetwork == null)
throw new IllegalArgumentException("graph's cyNetwork cannot be null");
if (edge.cyEdge == null) throw new IllegalArgumentException("edge's cyEdge cannot be null");
CyNetwork cyN = graph.cyNetwork;
CyEdge cyE = edge.cyEdge;
CyRow networkRow = cyN.getRow(cyN);
String networkName = networkRow.get(CyNetwork.NAME, String.class);
CyRow row = table.getRow(SUIDFactory.getNextSUID());
row.set(NETWORK_SUID, cyN.getSUID());
row.set(NETWORK_NAME, networkName);
row.set(EDGE_SUID, cyE.getSUID());
row.set(BEL_STATEMENT, evidence.belStatement);
row.set(SUMMARY_TEXT, evidence.summaryText);
if (evidence.citation != null) {
row.set(CITATION_TYPE, evidence.citation.type);
row.set(CITATION_ID, evidence.citation.id);
row.set(CITATION_NAME, evidence.citation.name);
}
if (evidence.biologicalContext != null) {
// create any annotation columns that do not already exist
BiologicalContext bc = evidence.biologicalContext;
for (String varyingKey : bc.variedAnnotations.keySet()) {
getOrCreateColumn(varyingKey, String.class, false, table);
}
// set annotation values
row.set(SPECIES, bc.speciesCommonName);
Map<String, Object> varying = bc.variedAnnotations;
for (Entry<String, Object> entry : varying.entrySet()) {
row.set(entry.getKey(), getOrEmptyString(entry.getKey(), varying));
}
}
}
private void mapEntry(final String[] entries) {
// Set primary key for the table, which is DB Object ID
final String primaryKeyValue = entries[DB_OBJ_ID];
final CyRow row = table.getRow(primaryKeyValue);
row.set(CyNetwork.NAME, primaryKeyValue);
// Check namespace
final String namespace = NAMESPACE_MAP.get(entries[ASPECT]);
for (int i = 0; i < EXPECTED_COL_COUNT; i++) {
final GeneAssociationTag tag = GeneAssociationTag.values()[i];
switch (tag) {
// Evidence code and GO ID should be organized by namespace.
case GO_ID:
String goidString = entries[i];
if (this.termIDList != null) goidString = convertToName(goidString);
List<String> currentList = row.getList(namespace, String.class);
if (currentList == null) currentList = new ArrayList<String>();
if (currentList.contains(goidString) == false) currentList.add(goidString);
row.set(namespace, currentList);
break;
case EVIDENCE:
case DB_REFERENCE:
final String value = entries[i];
String columnName = namespace;
if (tag == GeneAssociationTag.EVIDENCE) columnName = columnName + EVIDENCE_SUFFIX;
else columnName = columnName + REFERENCE_SUFFIX;
List<String> valueList = row.getList(columnName, String.class);
if (valueList == null) valueList = new ArrayList<String>();
if (valueList.contains(value) == false) valueList.add(value);
row.set(columnName, valueList);
break;
case TAXON:
final String taxID = entries[i].split(":")[1];
final String taxName = speciesMap.get(taxID);
if (taxName != null) row.set(tag.toString(), taxName);
else if (taxID != null) row.set(tag.toString(), taxID);
break;
case ASPECT:
// Ignore these lines
break;
case DB_OBJECT_ID:
case DB_OBJECT_SYMBOL:
case DB_OBJECT_SYNONYM:
// Create consolidated id list attribute.
List<String> synList = row.getList(SYNONYM_COL_NAME, String.class);
if (synList == null) synList = new ArrayList<String>();
if (tag == GeneAssociationTag.DB_OBJECT_SYNONYM) {
final String[] vals = entries[i].split(LIST_DELIMITER);
for (String val : vals) {
if (synList.contains(val) == false) synList.add(val);
}
} else {
if (synList.contains(entries[i]) == false) synList.add(entries[i]);
}
row.set(SYNONYM_COL_NAME, synList);
break;
default:
if (LIST_INDEX.contains(i + 1)) {
final String[] vals = entries[i].split(LIST_DELIMITER);
List<String> listVals = row.getList(tag.toString(), String.class);
if (listVals == null) listVals = new ArrayList<String>();
for (String val : vals) {
if (listVals.contains(val) == false) listVals.add(val);
}
row.set(tag.toString(), listVals);
} else row.set(tag.toString(), entries[i]);
break;
}
}
}
