How to use

getConceptAccession

method

in

net.sourceforge.ondex.core.ONDEXConcept

@Override
public ConceptAccession getConceptAccession(String accession,
    DataSource elementOf) throws NullValueException,
    EmptyStringException {
  return parent.getConceptAccession(accession, elementOf);
}

boolean ambiguous = concept.getConceptAccession(oldAccession, accession_dataSource).isAmbiguous();
concept.deleteConceptAccession(oldAccession, accession_dataSource);
concept.createConceptAccession(replacements.get(oldAccession), accession_dataSource, ambiguous);

boolean ambiguous = concept.getConceptAccession(oldAccession, accession_dataSource).isAmbiguous();
concept.deleteConceptAccession(oldAccession, accession_dataSource);
concept.createConceptAccession(replacements.get(oldAccession), accession_dataSource, ambiguous);

if(acDomain.getConceptAccession(domId, interPro) == null) {
  if(domId.length() > 1 && !domId.equalsIgnoreCase("NULL")) {
    acDomain.createConceptAccession(domId, interPro,false);

concept.getConceptAccession((String) pair.getFirst(), dataSource).setAmbiguous(accessions.get(pair));

private void writeSynonym(String synonym, String conceptName,
    ONDEXConcept c) {
  String check = (String) ValidatorRegistry.validators.get("cvregex").validate(synonym);
  if (check != null) {
    DataSource dataSource = aog.getMetaData().getDataSource(check);
    if (dataSource == null) {
      if (!reportedMissingCVs.contains(check)) {
        ONDEXEventHandler.getEventHandlerForSID(aog.getSID()).fireEventOccurred(new DataSourceMissingEvent("DataSource missing => "
            + check, ""));
        reportedMissingCVs.add(check);
      }
    } else {
      if (c.getConceptAccession(synonym, dataSource) == null) {
        c.createConceptAccession(synonym.toUpperCase(), dataSource,
            false);
      }
    }
  } else {
    if (!synonym.equalsIgnoreCase(conceptName)) {
      c.createConceptName(synonym,false);
    }
  }
}

    String ob = obIt.next();
    if (ac.getConceptAccession(ob, elementOf) == null) 
      ac.createConceptAccession(ob, elementOf, true);
  while (merIt.hasNext()) {
    String mer = merIt.next();
    if ((obsoletes == null ||!obsoletes.contains(mer)) || ac.getConceptAccession(mer, elementOf) == null ) {
      ac.createConceptAccession(mer, elementOf, true);
if (ac.getConceptAccession(pid, elementOf) == null) 
  ac.createConceptAccession(pid, elementOf, false);
if (loc > -1) {
  String fakelocus = pid.substring(0, loc);
  if (ac.getConceptAccession(fakelocus, elementOf) == null) 
    ac.createConceptAccession(fakelocus, elementOf, true);

  while (obIt.hasNext()) {
    String ob = obIt.next();
    if (ac.getConceptAccession(ob, elementOf) == null) 
      ac.createConceptAccession(ob, elementOf, true);
  while (merIt.hasNext()) {
    String mer = merIt.next();
    if ((obsoletes == null || !obsoletes.contains(mer)) && ac.getConceptAccession(mer, elementOf) == null) {
      ac.createConceptAccession(mer, elementOf, true);
if ( ac.getConceptAccession(pid, elementOf) == null) 
  ac.createConceptAccession(pid, elementOf, false);
if ( ac.getConceptAccession(locus, elementOf) == null) 
  ac.createConceptAccession(locus, elementOf, true);

@Override
public Object getCellEditorValue() {
  // this is value returned by default editor
  String newAccession = super.getCellEditorValue().toString();
  if (acc == null) {
    // construct new CA with defaults
    if (newAccession.trim().length() > 0)
      acc = concept.createConceptAccession(newAccession, unknown, true);
  } else {
    // existing CA check accession update
    if (!newAccession.equals(acc.getAccession())) {
      // delete old one
      ConceptAccession old = concept.getConceptAccession(acc.getAccession(), acc.getElementOf());
      concept.deleteConceptAccession(acc.getAccession(), acc.getElementOf());
      // keep additional settings and create non empty accession
      if (newAccession.trim().length() > 0)
        acc = concept.createConceptAccession(newAccession, old.getElementOf(), old.isAmbiguous());
      else
        // clear existing concept accession from table
        acc = null;
    }
  }
  // return concept accession instead of string
  return acc;
}

/**
 * A unification reference is a non-ambiguous accession.
 * 
 * @param c
 *            ONDEXConcept with unification reference
 * @param uni
 *            unificationXref used
 */
private void addUnificationXref(ONDEXConcept c, unificationXref uni)
    throws Exception {
  // sanity checks
  if (uni.getID() == null || uni.getID().isEmpty()) {
    System.err.println(uni.getRDFId() + " is empty unificationXref.");
    return;
  }
  // get current data source
  DataSource elementOf = findDataSource(uni.getDB());
  
  if(elementOf.getId().equalsIgnoreCase("unknown")){
    System.err.println("DataSource is UNKNOWN");
    
  }
  
  
  if ((DEBUG || c.getConceptAccession(uni.getID(), elementOf) == null) && !(elementOf.getId().equalsIgnoreCase("unknown"))){
      c.createConceptAccession(uni.getID(), elementOf, false);
  }    
}

/**
 * Any other relationships with entry of other data sources, marked as
 * ambiguous.
 * 
 * @param c
 *            ONDEXConcept with relationship reference
 * @param rel
 *            relationshipXref used
 */
private void addRelationshipXref(ONDEXConcept c, relationshipXref rel)
    throws Exception {
  // sanity checks
  if (rel.getID() == null || rel.getID().isEmpty()) {
    System.err.println(rel.getRDFId() + " is empty relationshipXref.");
    return;
  }
  DataSource elementOf = findDataSource(rel.getDB());
  if ((DEBUG || c.getConceptAccession(rel.getID(), elementOf) == null) && !(elementOf.getId().equalsIgnoreCase("unknown"))){
    c.createConceptAccession(rel.getID(), elementOf, false);
  }    
}
  // get current data source

  @Override
  public void actionPerformed(ActionEvent e) {
    this.setVisible(false);
    editor.acc.setAmbiguous(box.isSelected());

    // has the DataSource of accession changed?
    DataSource dataSource = (DataSource) selection.getSelectedItem();
    if (!editor.acc.getElementOf().equals(dataSource)) {
      // delete old one
      ConceptAccession old = editor.concept.getConceptAccession(editor.acc.getAccession(), editor.acc.getElementOf());
      editor.concept.deleteConceptAccession(editor.acc.getAccession(), editor.acc.getElementOf());
      // create one with new DataSource
      editor.acc = editor.concept.createConceptAccession(old.getAccession(), dataSource, old.isAmbiguous());
    }
  }
}

/**
 * Creates an accession on concept only if it does not already exists
 * 
 * @param target
 *            - relation
 * @param newAcc
 *            - attribute to create
 * @throws AccessDeniedException
 * @throws EmptyStringException
 * @throws NullValueException
 */
public static void addNewAccession(ONDEXConcept target,
    ConceptAccession newAcc) throws NullValueException,
    EmptyStringException, AccessDeniedException {
  if (target.getConceptAccession(newAcc.getAccession(),
      newAcc.getElementOf()) == null)
    target.createConceptAccession(newAcc.getAccession(),
        newAcc.getElementOf(), true);
}

  && c.getConceptAccession(name, ds) == null) {
c.createConceptAccession(name, ds, false);