How to use

getXrefs

method

in

uk.ac.ebi.intact.model.AnnotatedObject

public static <X extends Xref> Collection<X> getIdentityXrefs(AnnotatedObject<X,?> annotatedObject) {
  Collection<X> xrefs = new ArrayList<X>();
  for (X xref : annotatedObject.getXrefs()) {
    CvXrefQualifier qualifier = xref.getCvXrefQualifier();
    if (qualifier != null &&
      CvObjectUtils.getPsiMiIdentityXref(qualifier).getPrimaryId().equals(CvXrefQualifier.IDENTITY_MI_REF)) {
      xrefs.add(xref);
    }
  }
  return xrefs;
}

private boolean hasPsiXref( AnnotatedObject annotatedObject, String psiId ) {
  boolean hasIt = false;
  if ( psiId == null ) {
    return false;
  }
  for ( Iterator iterator = annotatedObject.getXrefs().iterator(); iterator.hasNext() && false == hasIt; ) {
    Xref xref = (Xref) iterator.next();
    if ( xref.getCvDatabase().getShortLabel().equals( CvDatabase.PSI_MI ) ) {
      if ( psiId.equals( xref.getPrimaryId() ) ) {
        hasIt = true;
      }
    }
  }
  return hasIt;
}

private boolean hasPsiXref( AnnotatedObject annotatedObject, String psiId ) {
  boolean hasIt = false;
  if ( psiId == null ) {
    return false;
  }
  for ( Iterator iterator = annotatedObject.getXrefs().iterator(); iterator.hasNext() && false == hasIt; ) {
    Xref xref = (Xref) iterator.next();
    if ( xref.getCvDatabase().getShortLabel().equals( CvDatabase.PSI_MI ) ) {
      if ( psiId.equals( xref.getPrimaryId() ) ) {
        hasIt = true;
      }
    }
  }
  return hasIt;
}

private boolean hasPsiXref( AnnotatedObject annotatedObject, String psiId ) {
  boolean hasIt = false;
  if ( psiId == null ) {
    return false;
  }
  for ( Iterator iterator = annotatedObject.getXrefs().iterator(); iterator.hasNext() && false == hasIt; ) {
    Xref xref = (Xref) iterator.next();
    if ( xref.getCvDatabase().getShortLabel().equals( CvDatabase.PSI_MI ) ) {
      if ( psiId.equals( xref.getPrimaryId() ) ) {
        hasIt = true;
      }
    }
  }
  return hasIt;
}

public static <X extends Xref> boolean hasIdentity(AnnotatedObject<X, ?> annotatedObject, String psiMi) {
  if (annotatedObject == null) {
    throw new NullPointerException("annotatedObject should not be null");
  }
  if (psiMi == null) {
    throw new NullPointerException("psiMi should not be null");
  }
  Collection<X> annotatedObjectXrefs = annotatedObject.getXrefs();
  for (X xref : annotatedObjectXrefs) {
    if (psiMi.equals(xref.getPrimaryId())) {
      if (CvXrefQualifier.IDENTITY_MI_REF.equals(psiMi)) {
        return true;
      }
      if (xref.getCvXrefQualifier() != null && hasIdentity(xref.getCvXrefQualifier(), CvXrefQualifier.IDENTITY_MI_REF)) {
        return true;
      }
    }
  }
  return false;
}

public static <X extends Xref> X getIdentityXref(AnnotatedObject<X, ?> annotatedObject, String databaseMi) {
  for (X xref : annotatedObject.getXrefs()) {
    CvXrefQualifier qualifier = xref.getCvXrefQualifier();
    CvDatabase database = xref.getCvDatabase();
    String qualMi;
    String dbMi;
    if (qualifier != null && database != null &&
        (qualMi = qualifier.getIdentifier()) != null &&
        (dbMi = database.getIdentifier()) != null &&
        qualMi.equals(CvXrefQualifier.IDENTITY_MI_REF) &&
        dbMi.equals(databaseMi)) {
      return xref;
    }
  }
  return null;
}

public static <X extends Xref> X getIdentityXref(AnnotatedObject<X, ?> annotatedObject, String databaseMi) {
  for (X xref : annotatedObject.getXrefs()) {
    CvXrefQualifier qualifier = xref.getCvXrefQualifier();
    CvDatabase database = xref.getCvDatabase();
    String qualMi;
    String dbMi;
    if (qualifier != null && database != null &&
        (qualMi = qualifier.getIdentifier()) != null &&
        (dbMi = database.getIdentifier()) != null &&
        qualMi.equals(CvXrefQualifier.IDENTITY_MI_REF) &&
        dbMi.equals(databaseMi)) {
      return xref;
    }
  }
  return null;
}

/**
 * Retrieves the xrefs from an AnnotatedObject, initializing them if necessary.
 *
 * @param ao The annotated object instance with possibly non-initialized xrefs
 * @return The returned xrefs are ensured to be initialized
 * @since 2.4.0
 */
public static Collection<? extends Xref> ensureInitializedXrefs(AnnotatedObject<?, ?> ao) {
  Collection<? extends Xref> xrefs;
  if (IntactCore.isInitialized(ao.getXrefs())) {
    xrefs = ao.getXrefs();
  } else {
    xrefs = IntactContext.getCurrentInstance().getDaoFactory().getXrefDao(AnnotatedObjectUtils.getXrefClassType(ao.getClass()))
        .getByParentAc(ao.getAc());
  }
  return xrefs;
}

public <X extends Xref> void populateWithPsiMi(AnnotatedObject annotatedObject, String psiMi) {
  this.institution = annotatedObject.getOwner();
  Class<? extends Xref> xrefClass = AnnotatedObjectUtils.getXrefClassType(annotatedObject.getClass());
  X xref = (X) createPsiMiXref(xrefClass, psiMi);
  xref.setParent(annotatedObject);
  if (xref instanceof CvObjectXref) {
    if (((CvObject)annotatedObject).getIdentifier() == null) {
      ((CvObjectXref)xref).prepareParentMi();
    }
  }
  annotatedObject.getXrefs().add(xref);
}

/**
 * Retrieves the xrefs from an AnnotatedObject, initializing them if necessary.
 *
 * @param ao The annotated object instance with possibly non-initialized xrefs
 * @return The returned xrefs are ensured to be initialized
 * @since 2.4.0
 */
public static Collection<? extends Xref> ensureInitializedXrefs(AnnotatedObject<?, ?> ao) {
  Collection<? extends Xref> xrefs;
  if (IntactCore.isInitialized(ao.getXrefs())) {
    xrefs = ao.getXrefs();
  } else {
    xrefs = IntactContext.getCurrentInstance().getDaoFactory().getXrefDao(AnnotatedObjectUtils.getXrefClassType(ao.getClass()))
        .getByParentAc(ao.getAc());
  }
  return xrefs;
}

public static <X extends Xref> X getIdentityXref(AnnotatedObject<X,?> annotatedObject, CvDatabase cvDatabase) {
  String dbMi = CvObjectUtils.getPsiMiIdentityXref(cvDatabase).getPrimaryId();
  for (X xref : annotatedObject.getXrefs()) {
    CvXrefQualifier qualifier = xref.getCvXrefQualifier();
    if (qualifier != null &&
      CvObjectUtils.getPsiMiIdentityXref(qualifier).getPrimaryId().equals(CvXrefQualifier.IDENTITY_MI_REF) &&
      CvObjectUtils.getPsiMiIdentityXref(qualifier).getPrimaryId().equals(dbMi)) {
      return xref;
    }
  }
  return null;
}

public Collection<GeneralMessage> check(AnnotatedObject<?,?> intactObject) throws SanityRuleException {
  Collection<GeneralMessage> messages = new ArrayList<GeneralMessage>();
  for (Xref xref : intactObject.getXrefs()) {
    String primaryId = xref.getPrimaryId();
    String idValidationRegexp = getIdValidationRegexp(xref.getCvDatabase());
    if (idValidationRegexp != null && !primaryId.matches(idValidationRegexp)) {
      XrefMessage xrefMessage = new XrefMessage( MessageDefinition.XREF_INVALID_PRIMARYID, intactObject, xref);
      Field regexField = new Field();
      regexField.setName("Regexp");
      regexField.setValue(idValidationRegexp);
      xrefMessage.getInsaneObject().getFields().add(regexField);
      messages.add(xrefMessage);
    }
  }
  return messages;
}

protected <X extends Xref, A extends Alias> void copyAnotatedObjectCommons( AnnotatedObject<X, A> source,
                                      AnnotatedObject<X, A> target ) {
  // if the source does not have an AC, we should not update the target shortLabel, fullName and owner
  // as it does not make much sense
  //if (source.getAc() != null) {
    copyProperty(source, "shortLabel", target);
    copyProperty(source, "fullName", target);
    copyProperty(source, "owner", target);
  //}
  copyXrefCollection( source.getXrefs(), target.getXrefs() );
  copyAliasCollection( source.getAliases(), target.getAliases(), source, target );
  copyAnnotationCollection( source.getAnnotations(), target.getAnnotations() );
}

/**
 * Initializes the AnnotatedObject collections (xrefs, aliases, annotations).
 *
 * @param ao The annotatedObject
 */
public static void initializeAnnotatedObject(AnnotatedObject ao) {
  initialize(ao.getXrefs());
  initialize(ao.getAliases());
  initialize(ao.getAnnotations());
}

private <T extends AnnotatedObject> void initializeCommonsIfNecessary(T ao, T managedObject) {
  if (IntactCore.isInitialized(ao.getXrefs()))
    IntactCore.initialize(managedObject.getXrefs());
  if (IntactCore.isInitialized(ao.getAnnotations()))
    IntactCore.initialize(managedObject.getAnnotations());
  if (IntactCore.isInitialized(ao.getAliases())) {
    IntactCore.initialize(managedObject.getAliases());
  }
}

private <T extends AnnotatedObject> void initializeCommonsIfNecessary(T ao, T managedObject) {
  if (IntactCore.isInitialized(ao.getXrefs()))
    IntactCore.initialize(managedObject.getXrefs());
  if (IntactCore.isInitialized(ao.getAnnotations()))
    IntactCore.initialize(managedObject.getAnnotations());
  if (IntactCore.isInitialized(ao.getAliases())) {
    IntactCore.initialize(managedObject.getAliases());
  }
}

/**
 * Initializes the AnnotatedObject collections (xrefs, aliases, annotations).
 *
 * @param ao The annotatedObject
 */
public static void initializeAnnotatedObject(AnnotatedObject ao) {
  initialize(ao.getXrefs());
  initialize(ao.getAliases());
  initialize(ao.getAnnotations());
}

protected <X extends Xref, A extends Alias> void copyAnotatedObjectCommons( AnnotatedObject<X, A> source,
                                      AnnotatedObject<X, A> target ) {
  // if the source does not have an AC, we should not update the target shortLabel, fullName and owner
  // as it does not make much sense
  //if (source.getAc() != null) {
    copyProperty(source, "shortLabel", target);
    copyProperty(source, "fullName", target);
    copyProperty(source, "owner", target);
  //}
  copyXrefCollection( source.getXrefs(), target.getXrefs() );
  copyAliasCollection( source.getAliases(), target.getAliases(), source, target );
  copyAnnotationCollection( source.getAnnotations(), target.getAnnotations() );
}

protected void traverseAnnotatedObjectCommon(AnnotatedObject ao, IntactVisitor ... visitors) {
  traverse(ao.getAnnotations(), visitors);
  traverse(ao.getAliases(), visitors);
  traverse(ao.getXrefs(), visitors);
  // check if this element has been traversed already, to avoid cyclic recursion
  if (recursionChecker.isAlreadyTraversed(ao)) {
    return;
  }
  traverse(ao.getOwner(), visitors);
}

protected void traverseAnnotatedObjectCommon(AnnotatedObject ao, IntactVisitor ... visitors) {
  traverse(ao.getAnnotations(), visitors);
  traverse(ao.getAliases(), visitors);
  traverse(ao.getXrefs(), visitors);
  // check if this element has been traversed already, to avoid cyclic recursion
  if (recursionChecker.isAlreadyTraversed(ao)) {
    return;
  }
  traverse(ao.getOwner(), visitors);
}