public UpdatedCrossReference(Xref ref, UpdateStatus status){ super(); if (ref != null){ this.database = ref.getCvDatabase() != null ? ref.getCvDatabase().getAc() : null; this.identifier = ref.getPrimaryId(); this.qualifier = ref.getCvXrefQualifier() != null ? ref.getCvXrefQualifier().getAc() : null; } else { this.database = null; this.identifier = null; this.qualifier = null; } this.status = status != null ? status : UpdateStatus.none; this.parent = null; }
public static boolean sameXref( Xref x1, Xref x2 ) { if (x1.getAc() != null && x2.getAc() != null) { return x1.getAc().equals(x2.getAc()); } if ( !same( x1.getPrimaryId(), x2.getPrimaryId() ) ) { return false; } if ( !CvObjectUtils.areEqual( x1.getCvDatabase(), x2.getCvDatabase() ) ) { return false; } if ( !CvObjectUtils.areEqual( x1.getCvXrefQualifier(), x2.getCvXrefQualifier() ) ) { return false; } if ( !same( x1.getSecondaryId(), x2.getSecondaryId() ) ) { return false; } if ( !same( x1.getDbRelease(), x2.getDbRelease() ) ) { return false; } return true; }
/** * Note: this does not clone the parent. * * @param xref * @return * @throws uk.ac.ebi.intact.model.clone.IntactClonerException * */ protected Xref cloneXref(Xref xref) throws IntactClonerException { if (xref == null) return null; Class clazz = CgLibUtil.removeCglibEnhanced(xref.getClass()); Xref clone = null; try { final Constructor constructor = clazz.getConstructor(); clone = (Xref) constructor.newInstance(); clonerManager.addClone(xref, clone); clone.setPrimaryId(xref.getPrimaryId()); clone.setSecondaryId(xref.getSecondaryId()); clone.setDbRelease(xref.getDbRelease()); clone.setCvDatabase(clone(xref.getCvDatabase())); clone.setCvXrefQualifier(clone(xref.getCvXrefQualifier())); } catch (Exception e) { throw new IntactClonerException("An error occured upon building a " + clazz.getSimpleName(), e); } clone.setParent(clone(xref.getParent())); return clone; }
private static <X extends Xref> X newXrefInstance(Class<X> xrefClass, CvDatabase db, String primaryId, String secondaryId, String dbRelease, CvXrefQualifier cvXrefQual) { X xref = null; try { xref = xrefClass.newInstance(); xref.setCvDatabase(db); xref.setPrimaryId(primaryId); xref.setSecondaryId(secondaryId); xref.setDbRelease(dbRelease); xref.setCvXrefQualifier(cvXrefQual); } catch (Exception e) { throw new PsiConversionException(e); } return xref; }
public <X extends Xref> X createXref(AnnotatedObject<X,?> parent, String primaryId, CvXrefQualifier cvXrefQualifer, CvDatabase cvDatabase) { X xref = (X) XrefUtils.newXrefInstanceFor(parent.getClass()); xref.setOwner(parent.getOwner()); xref.setParent(parent); xref.setPrimaryId(primaryId); xref.setCvXrefQualifier(cvXrefQualifer); xref.setCvDatabase(cvDatabase); return xref; }
public static String getPsiReference( CvObject cv ) { if ( cv == null ) { throw new IllegalArgumentException( "the given CvObject must not be null." ); } for ( Iterator iterator = cv.getXrefs().iterator(); iterator.hasNext(); ) { Xref xref = (Xref) iterator.next(); if ( CvDatabase.PSI_MI.equals( xref.getCvDatabase().getShortLabel() ) ) { return xref.getPrimaryId(); } } 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; }
private Xref synchronizeXref( Xref xref, AnnotatedObject parent ) { if (xref.getAc() != null) { return IntactContext.getCurrentInstance().getDataContext().getDaoFactory() .getXrefDao().getByAc(xref.getAc()); } xref.setCvDatabase( synchronize( xref.getCvDatabase() ) ); xref.setCvXrefQualifier( synchronize( xref.getCvXrefQualifier() ) ); xref.setParent(parent); if (xref.getAc() == null && xref.getAc() != null) { annotatedObjectsToPersist.put(keyBuilder.keyForXref(xref), xref); } return xref; }
protected void traverseXref(Xref xref, IntactVisitor... visitors) { if (xref == null) return; for (IntactVisitor visitor : visitors) { visitor.visitXref(xref); } // check if this element has been traversed already, to avoid cyclic recursion if (recursionChecker.isAlreadyTraversed(xref)) { return; } traverse(xref.getCvXrefQualifier(), visitors); traverse(xref.getCvDatabase(), visitors); traverse(xref.getOwner(), visitors); }
CvDatabase cvDb = (CvDatabase) cvPersister.syncIfTransient(xref.getCvDatabase()); xref.setCvDatabase(cvDb); if (xref.getCvXrefQualifier() != null) { CvXrefQualifier cvXrefQual = (CvXrefQualifier) cvPersister.syncIfTransient(xref.getCvXrefQualifier()); xref.setCvXrefQualifier(cvXrefQual); xref.setParent(intactObject); xref.setOwner(institutionPersister.syncIfTransient(xref.getOwner()));
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; }
@Override public void visitXref( Xref xref ) { final CvDatabase db = xref.getCvDatabase(); String mi = db.getIdentifier(); if ( mi != null ) { String key = createCvKey( db.getClass(), mi ); final CvDatabase oboTerm = ( CvDatabase ) mi2cv.get( key ); if ( oboTerm == null ) { log.warn( "Could not find xref " + db.getClass().getSimpleName() + "( " + db.getShortLabel() + " ) by MI: " + mi ); } else { xref.setCvDatabase( oboTerm ); } } final CvXrefQualifier qualifier = xref.getCvXrefQualifier(); if( qualifier != null ) { mi = qualifier.getIdentifier(); if ( mi != null ) { final String key = createCvKey( qualifier.getClass(), mi ); final CvXrefQualifier oboQualifier = ( CvXrefQualifier ) mi2cv.get( key ); if ( oboQualifier == null ) { log.warn( "Could not find qualifier " + qualifier.getClass().getSimpleName() + "( " + qualifier.getShortLabel() + " ) by MI: " + mi ); } else { xref.setCvXrefQualifier( oboQualifier ); } } } }
protected void fixPubmedReferenceAsIdentityToPrimaryRef(Xref xref) { if (CvDatabase.PUBMED_MI_REF.equals(xref.getCvDatabase().getIdentifier()) && CvXrefQualifier.IDENTITY_MI_REF.equals(xref.getCvXrefQualifier().getIdentifier())) { CvXrefQualifier primaryRef = CvObjectUtils.createCvObject(xref.getOwner(), CvXrefQualifier.class, CvXrefQualifier.PRIMARY_REFERENCE_MI_REF, CvXrefQualifier.PRIMARY_REFERENCE); xref.setCvXrefQualifier(primaryRef); final ConverterMessage converterMessage = new ConverterMessage(MessageLevel.WARN, "Incorrect cross refernece to Pubmed that had qualifier 'identity'. Changed to 'primary-reference", ConverterContext.getInstance().getLocation().getCurrentLocation()); converterMessage.setAutoFixed(true); ConverterContext.getInstance().getReport().getMessages().add(converterMessage); } }
public int compare(X o1, X o2) { return o1.getPrimaryId().compareTo(o2.getPrimaryId()); } };
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 void insertSearchItemForXref( Xref xref ) { if ( log.isDebugEnabled() ) { log.debug( "Inserting SearchItems for Xref: " + xref.getPrimaryId() + " (" + xref.getAc() + "); Parent AC: " + xref.getParentAc() ); } SearchItem searchItem = searchItemForXref( xref ); if ( log.isDebugEnabled() ) { log.debug( "\t" + searchItem ); } IntactContext.getCurrentInstance().getDataContext().getDaoFactory() .getSearchItemDao().persist( searchItem ); }
private static SearchItem searchItemForXref( Xref xref ) { return new SearchItem( xref.getParentAc(), xref.getPrimaryId(), xref.getParent().getClass().getName(), "xref" ); }
public Key keyForXref(Xref xref) { return new Key(keyFor(xref.getParent()).getUniqueString() + "::" + xref.getPrimaryId()); }
private static <X extends Xref> void addXref(DbReference dbReference, AnnotatedObject<X, ?> annotatedObject, XrefConverter<X> xrefConverter) { X xref = xrefConverter.psiToIntact(dbReference); annotatedObject.addXref(xref); if (annotatedObject instanceof Institution) { xref.setOwner((Institution)annotatedObject); } else if (xref instanceof CvObjectXref && xref.getCvXrefQualifier() != null) { ((CvObjectXref)xref).prepareParentMi(); } }
/** * Search for all Xrefs having Xref with the given CvDatabase. * * @param ao the non null AnnotatedObject to search on. * @param db the non null CvDatabase filter. * * @return a non null Collection of Xref, may be empty. */ public static Collection<Xref> searchXrefs( AnnotatedObject ao, CvDatabase db ) { if ( ao == null ) { throw new NullPointerException( "AnnotatedObject must not be null." ); } if ( db == null ) { throw new NullPointerException( "CvDatabase must not be null." ); } Collection<Xref> xrefs = new ArrayList<Xref>( ao.getXrefs().size() ); for ( Iterator<Xref> iterator = ao.getXrefs().iterator(); iterator.hasNext(); ) { Xref xref = iterator.next(); if ( db.equals( xref.getCvDatabase() ) ) { xrefs.add( xref ); } } return xrefs; }