Changeset 6091

Timestamp:

Aug 24, 2012, 2:23:25 PM (11 years ago)

Author:

Nicklas Nordborg

Message:

References #1707: Make it possible for a derived bioassay to have multiple physical bioassays as parents

Fixes problems with finding the correct parent items when inheriting annotations from parents. This should now consider all extracts encountered when moving upstreams from raw bioassay and derived bioassays.

Location:

trunk

Files:

• src/core/net/sf/basedb/core/PhysicalBioAssay.java (modified) (5 diffs)
• src/core/net/sf/basedb/util/AnnotationUtil.java (modified) (10 diffs)
• src/core/net/sf/basedb/util/overview/OverviewUtil.java (modified) (4 diffs)
• src/core/net/sf/basedb/util/overview/loader/ExtractLoader.java (modified) (5 diffs)
• src/core/net/sf/basedb/util/query (added)
• src/core/net/sf/basedb/util/query/MultiQueryIterator.java (added)
• www/common/annotations/inherit.jsp (modified) (6 diffs)
• www/views/derivedbioassays/edit_bioassay.jsp (modified) (2 diffs)

trunk/src/core/net/sf/basedb/core/PhysicalBioAssay.java

@@ -27 +27 @@
 import net.sf.basedb.core.query.Restrictions;
 import net.sf.basedb.core.query.Hql;
-
+import net.sf.basedb.util.collections.BasicItemToIdTransformer;
+
+import java.util.Collection;
+import java.util.Collections;
 import java.util.Date;
 import java.util.Set;
@@ -157 +160 @@
     throws BaseException
   {
-    return getAnnotatableParents(0, null);
-  }
+    return getAnnotatableParents(0, (Collection<Extract>)null);
+  }
+  
   /**
     Get the protocol from the creation event.
@@ -273 +277 @@
     @since 3.0
   */
+  public Set<Annotatable> getAnnotatableParents(int position, Extract extract)
+    throws BaseException
+  {
+    return getAnnotatableParents(position, extract == null ? null : Collections.singleton(extract));
+  }
+
+  /**
+    Get the extracts, possible on a specific assay position or only a specific
+    extract, and the array slide.
+    @param position If > 0 only include the extracts on that
+      position in the bioassay (see {@link BioMaterialEventSource#getPosition()}.
+      If <= 0 include all extracts.
+    @param extract If not null, only include that extract (if present on the
+      bioassay)
+    @since 3.2
+  */
   @SuppressWarnings("unchecked")
-  public Set<Annotatable> getAnnotatableParents(int position, Extract extract)
+  public Set<Annotatable> getAnnotatableParents(int position, Collection<Extract> extracts)
     throws BaseException
   {
@@ -292 +312 @@
         );
       }
-      if (extract != null)
+      if (extracts != null && extracts.size() > 0)
       {
-        query.restrict(Restrictions.eq(Hql.property("id"), Expressions.integer(extract.getId())));
+        query.restrict(Restrictions.in(Hql.property("id"), Expressions.parameter("extracts")));
+        Set<Integer> extractIds = new HashSet<Integer>();
+        new BasicItemToIdTransformer().transform(extracts, extractIds);
+        query.setParameter("extracts", extractIds, Type.INT);
       }
       annotatable.addAll(query.list(getDbControl()));
@@ -304 +327 @@
   }
 
+  
   /**
     Get the event that represents the creation of this hybridization.

trunk/src/core/net/sf/basedb/util/AnnotationUtil.java

@@ -22 +22 @@
 package net.sf.basedb.util;
 
+import java.util.Collection;
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
+import java.util.Map;
 import java.util.Queue;
 import java.util.Set;
@@ -46 +50 @@
 public class AnnotationUtil
 {
+  /**
+    Create a new cache object that can be used with
+    {@link #getAllAnnotatableParentItems(DbControl, Annotatable, Filter, Cache)}
+    @since 3.2
+  */
+  public static Cache createCache()
+  {
+    return new Cache();
+  }
   
   /**
@@ -60 +73 @@
       which parents to include
     @return A set containing the parent items
+    @see #getAllAnnotatableParentItems(DbControl, Annotatable, Filter, Cache)
   */
   public static Set<Annotatable> getAllAnnotatableParentItems(DbControl dc, 
     Annotatable item, Filter<Annotatable> filter)
   {
-    Set<AnnotatableWrapper> processed = new HashSet<AnnotatableWrapper>();
+    return getAllAnnotatableParentItems(dc, item, filter, null);
+  }
+
+  /**
+    Get all annotatable parent items for a given item. A {@link Filter}
+    may be used to filter the returned collection. If a filter
+    is specified only parent items for which the {@link Filter#evaluate(Object)}
+    method returns true are included in the returned collection. Note
+    that all parent items are loaded before the filter is evaluated
+    and that the evaluation order is undefined. A cache may be used
+    to improve performance if this method is called multiple times
+    with different items that have overlapping parent trees.
+    
+    @param dc The DbControl to use for database access
+    @param item The item to find the parents for
+    @param filter An optional filter that can be used to filter 
+      which parents to include
+    @param cache An optional cache object
+    @return A set containing the parent items
+    @see #createCache()
+    @since 3.2
+  */
+  public static Set<Annotatable> getAllAnnotatableParentItems(DbControl dc, 
+    Annotatable item, Filter<Annotatable> filter, Cache cache)
+  {
+    Set<AnnotatableWrapper> processed = new LinkedHashSet<AnnotatableWrapper>();
     Queue<AnnotatableWrapper> unprocessed = new LinkedList<AnnotatableWrapper>();
-    unprocessed.add(new AnnotatableWrapper(item, null));
-
+    unprocessed.add(new AnnotatableWrapper(item, cache));
+  
     // As long as we have unprocessed entries...
     while (!unprocessed.isEmpty())
@@ -81 +120 @@
     
     // All parents are now loaded...
-    Set<Annotatable> allParents = new HashSet<Annotatable>(processed.size());
+    Set<Annotatable> allParents = new LinkedHashSet<Annotatable>(processed.size());
     for (AnnotatableWrapper wrapper : processed)
     {
@@ -96 +135 @@
   /**
     This wrapper class is needed because we need to keep
-    track of the {@link RawBioAssay#getParentExtract()} property 
+    track of extracts linked with raw bioassays and derived bioassays
     until we have loaded the Extracts of a Physical Bioassay.
     <p>
-    When we reach a {@link RawBioAssay} item, we remember the parent extract on
-    that as we move up to DerivedBioAssaySet and PhysicalBioAssay.
-    When the PhysicalBioAssay is reached we use the extract to call
-    {@link PhysicalBioAssay#getAnnotatableParents(int, Extract)} so that we only
-    get extracts that are linked with the correct raw bioassay.
+    When we reach a {@link RawBioAssay} item or {@link DerivedBioAssay} item, we 
+    remember the extract on that as we move up towards PhysicalBioAssay.
+    When the PhysicalBioAssay is reached we use the extracts to call
+    {@link PhysicalBioAssay#getAnnotatableParents(int, Collection)}.
   */
   static class AnnotatableWrapper
@@ -112 +150 @@
       <ul>
       <li>If the item is a raw bioassay, {@link RawBioAssay#getParentExtract()}
-      <li>If the item is a derived bioassay, extract if it is not null,
-        otherwise {@link DerivedBioAssay#getExtract()}
-      <li>If the item is a physical bioassay, the extract parameter
+      <li>If the item is a derived bioassay, {@link DerivedBioAssay#getExtract()}
       <li>null in all other cases.
-    */
-    private static Extract getExtract(Annotatable item, Extract extract)
+      </ul>
+    */
+    private static Extract getExtract(Annotatable item)
     {
       Extract result = null;
@@ -126 +163 @@
       else if (item instanceof DerivedBioAssay)
       {
-        if (extract != null)
+        result = ((DerivedBioAssay)item).getExtract();
+      }
+      return result;
+    }
+    
+    private final Annotatable item;
+    private final AnnotatableWrapper chain;
+    private final Cache cache;
+    private boolean hasLoadedExtract;
+    private Extract extract;
+
+    AnnotatableWrapper(Annotatable item, Cache cache)
+    {
+      this.item = item;
+      this.chain = null;
+      this.cache = cache;
+    }
+    
+    AnnotatableWrapper(Annotatable item, AnnotatableWrapper chain)
+    {
+      this.item = item;
+      this.chain = chain;
+      this.cache = chain.cache;
+    }
+    
+    
+    /**
+      The annotatable that we are wrapping.
+    */
+    Annotatable getAnnotatable()
+    {
+      return item;
+    }
+    
+    Collection<Extract> loadExtracts(Collection<Extract> extractsInChain)
+    {
+      if (chain != null) chain.loadExtracts(extractsInChain);
+      if (!hasLoadedExtract)
+      {
+        extract = getExtract(item);
+        hasLoadedExtract = true;
+      }
+      if (extract != null) extractsInChain.add(extract);
+      return extractsInChain;
+    }
+    
+    /**
+      Get all annotatable parents wrapped inside AnnotatableWrapper:s
+    */
+    Set<AnnotatableWrapper> getAnnotatableParentWrappers() 
+      throws BaseException
+    {
+      Set<Annotatable> parents = null;
+      Set<AnnotatableWrapper> wrappedParents = Collections.emptySet();
+      
+      if (cache != null && cache.contains(item))
+      {
+        wrappedParents = cache.get(item);
+      }
+      else
+      {
+        boolean useCache = true;
+        if (item instanceof PhysicalBioAssay)
         {
-          result = extract;
+          Collection<Extract> extractsInChain = loadExtracts(new HashSet<Extract>());
+          parents = ((PhysicalBioAssay)item).getAnnotatableParents(0, extractsInChain);
+          useCache = false;
         }
         else
         {
-          result = ((DerivedBioAssay)item).getExtract();
+          parents = item.getAnnotatableParents();
         }
-      }
-      else if (item instanceof PhysicalBioAssay)
-      {
-        result = extract;
-      }
-      return result;
-    }
-    
-    private final Annotatable item;
-    private final Extract extract;
-
-    AnnotatableWrapper(Annotatable item, Extract extract)
-    {
-      this.item = item;
-      this.extract = getExtract(item, extract);
-    }
-    
-    /**
-      The annotatable that we are wrapping.
-    */
-    Annotatable getAnnotatable()
-    {
-      return item;
-    }
-    
-    /**
-      Get all annotatable parents wrapped inside AnnotatableWrapper:s
-    */
-    Set<AnnotatableWrapper> getAnnotatableParentWrappers() 
-      throws BaseException
-    {
-      Set<Annotatable> parents = null;
-      Set<AnnotatableWrapper> wrappedParents = Collections.emptySet();
-      if (item instanceof PhysicalBioAssay)
-      {
-        parents = ((PhysicalBioAssay)item).getAnnotatableParents(0, extract);
-      }
-      else
-      {
-        parents = item.getAnnotatableParents();
-      }
-      if (parents != null)
-      {
-        wrappedParents = new HashSet<AnnotatableWrapper>(parents.size());
-        for (Annotatable parent : parents)
+        if (parents != null)
         {
-          wrappedParents.add(new AnnotatableWrapper(parent, extract));
+          wrappedParents = new HashSet<AnnotatableWrapper>(parents.size());
+          for (Annotatable parent : parents)
+          {
+            wrappedParents.add(new AnnotatableWrapper(parent, this));
+          }
         }
+        if (cache != null && useCache) cache.put(item, wrappedParents);
       }
       return wrappedParents;
@@ -188 +250 @@
     /**
       A wrapper is equal to another if they references the same item
-      and extract.
+      and chain of wrappers.
     */
     @Override
@@ -196 +258 @@
       if (o == null || o.getClass() != this.getClass()) return false;
       AnnotatableWrapper other = (AnnotatableWrapper)o;
-      return this.item.equals(other.item) && EqualsHelper.equals(this.extract, other.extract);
+      return this.item.equals(other.item) && EqualsHelper.equals(this.chain, other.chain);
     }
 
@@ -202 +264 @@
     public int hashCode()
     {
-      return item.hashCode() + EqualsHelper.hashCode(extract);
-    }
+      return item.hashCode() + EqualsHelper.hashCode(chain);
+    }
+  }
+  
+  public static class Cache
+  {
+    private final Map<Annotatable, Set<AnnotatableWrapper>> cmap;
+    
+    Cache()
+    {
+      this.cmap = new HashMap<Annotatable, Set<AnnotatableWrapper>>();
+    }
+    
+    boolean contains(Annotatable item)
+    {
+      return cmap.containsKey(item);
+    }
+    
+    Set<AnnotatableWrapper> get(Annotatable item)
+    {
+      return cmap.get(item);
+    }
+    
+    void put(Annotatable item, Set<AnnotatableWrapper> parents)
+    {
+      cmap.put(item, parents);
+    }
+    
   }
 }

trunk/src/core/net/sf/basedb/util/overview/OverviewUtil.java

@@ -38 +38 @@
 import net.sf.basedb.core.BasicItem;
 import net.sf.basedb.core.DbControl;
-import net.sf.basedb.core.DerivedBioAssay;
-import net.sf.basedb.core.Extract;
 import net.sf.basedb.core.ItemSubtype;
-import net.sf.basedb.core.PermissionDeniedException;
 import net.sf.basedb.core.Presets;
-import net.sf.basedb.core.PhysicalBioAssay;
 import net.sf.basedb.core.Item;
 import net.sf.basedb.core.ItemQuery;
@@ -49 +45 @@
 import net.sf.basedb.core.Project;
 import net.sf.basedb.core.SessionControl;
-import net.sf.basedb.core.RawBioAssay;
 import net.sf.basedb.core.Subtypable;
 import net.sf.basedb.core.Type;
@@ -55 +50 @@
 import net.sf.basedb.core.query.Hql;
 import net.sf.basedb.core.query.Restrictions;
+import net.sf.basedb.util.AnnotationUtil;
+import net.sf.basedb.util.AnnotationUtil.Cache;
 import net.sf.basedb.util.extensions.ClientContext;
 import net.sf.basedb.util.extensions.ExtensionsInvoker;
@@ -409 +406 @@
   public static Set<Annotatable> getAnnotatableParents(DbControl dc, OverviewContext context, Annotatable item)
   {
-    return getAnnotatableParents(dc, context, item, item);
-  }
-  
-  /**
-    The internal implementation needs to keep track of the special case when we
-    start with raw bioassay or derived bioassay as the root item. This is because when 
-    we reach the associated physical bioassay we should only load the extract
-    that is associated with the raw/derived bioassay
-  */
-  @SuppressWarnings("unchecked")
-  private static Set<Annotatable> getAnnotatableParents(DbControl dc, OverviewContext context, Annotatable item, Annotatable root)
-  {
-    String cacheKey = "annotatable.parent." + item.getType().name() + "." + item.getId();
-
-    // Special case when starting with a raw/derived bioassay with an extract 
-    // since the extract is the 
-    Extract extract = null;
-    PhysicalBioAssay bioAssay = null;
-    try
-    {
-      if (root instanceof RawBioAssay)
-      {
-        RawBioAssay rba = (RawBioAssay)root;
-        extract = rba.getParentExtract();
-      }
-      else if (root instanceof DerivedBioAssay)
-      {
-        DerivedBioAssay dba = (DerivedBioAssay)root;
-        extract = dba.getExtract();
-      }
-    }
-    catch (PermissionDeniedException ex)
-    {}
-    
-    if (extract != null)
-    {
-      if (item instanceof DerivedBioAssay)
-      {
-        cacheKey += "#" + extract.getId();
-      }
-      else if (item instanceof PhysicalBioAssay)
-      {
-        bioAssay = (PhysicalBioAssay)item;
-        cacheKey += "#" + extract.getId();
-      }
-    }
-  
-    Set<Annotatable> parents = (Set<Annotatable>)context.getCachedObject(cacheKey);
-    if (parents == null)
-    {
-      parents = new HashSet<Annotatable>();
-      context.setCachedObject(cacheKey, parents);
-      Set<? extends Annotatable> temp = bioAssay != null ?
-          bioAssay.getAnnotatableParents(0, extract) : item.getAnnotatableParents();
-      if (temp != null)
-      {
-        for (Annotatable a : temp)
-        {
-          parents.add(a);
-          parents.addAll(getAnnotatableParents(dc, context, a, root));
-        }
-      }
-    }
-    return parents;
-  }
+    Cache cache = (Cache)context.getCachedObject("annotatable.parent.cache");
+    if (cache == null)
+    {
+      cache = AnnotationUtil.createCache();
+      context.setCachedObject("annotatable.parent.cache", cache);
+    }
+    return AnnotationUtil.getAllAnnotatableParentItems(dc, item, null, cache);
+  }
+
   
 }

trunk/src/core/net/sf/basedb/util/overview/loader/ExtractLoader.java

@@ -23 +23 @@
 
 import java.util.HashSet;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
@@ -52 +53 @@
 import net.sf.basedb.util.overview.Node;
 import net.sf.basedb.util.overview.node.NodeFactory;
+import net.sf.basedb.util.query.MultiQueryIterator;
 
 /**
@@ -308 +310 @@
     are the extracts that has been used on a bioassay.
   */
+  @SuppressWarnings("unchecked")
   private Node createReverseNode(PhysicalBioAssay bioAssay, DbControl dc, OverviewContext context, Node bioAssayNode)
   {
@@ -314 +317 @@
 
     ItemQuery<Extract> query = context.initQuery(bioAssay.getExtracts(0), "name");
+    ItemQuery<Extract> extraQuery = null;
 
     // If we have followed this path from derived bioassays that has specified an 
     // extract we should only load the same extracts when following the path upstreams
+    // We look for both 
     Set<Integer> extractIds = getExtractChain(bioAssayNode);
     if (extractIds.size() > 0) 
@@ -324 +329 @@
         );
       query.setParameter("extracts", extractIds, Type.INT);
-    }
-    ItemResultIterator<Extract> it = query.iterate(dc);
+
+      extraQuery = context.initQuery(bioAssay.getExtracts(0), "name");
+      extraQuery.join(Hql.leftJoin("creationEvent", "cevt"));
+      extraQuery.join(Hql.leftJoin("cevt", "sources", "sss", null, false));
+      
+      extraQuery.restrict(
+        Restrictions.in(Hql.property("sss", "bioMaterial"), Expressions.parameter("extracts"))
+        );
+      extraQuery.setParameter("extracts", extractIds, Type.INT);
+    }
+    Iterator<Extract> it = MultiQueryIterator.get(dc, query, extraQuery);
     while (it.hasNext())
     {

trunk/www/common/annotations/inherit.jsp

@@ -28 +28 @@
   @version 2.0
 --%>
-<%@page import="net.sf.basedb.core.Subtypable"%>
 <%@ page pageEncoding="UTF-8" session="false"
   import="net.sf.basedb.core.SessionControl"
@@ -50 +49 @@
   import="net.sf.basedb.core.AnnotationType"
   import="net.sf.basedb.core.PermissionDeniedException"
+  import="net.sf.basedb.util.AnnotationUtil"
+  import="net.sf.basedb.core.Subtypable"
   import="net.sf.basedb.core.query.Orders"
   import="net.sf.basedb.core.query.Hql"
@@ -67 +68 @@
 <%@ taglib prefix="base" uri="/WEB-INF/base.tld" %>
 <%!
-private void loadParents(Set<AnnotationSet> parentAnnotations, Set<Annotatable> parentItems, Annotatable current, Annotatable root)
+private void loadParents(DbControl dc, Set<AnnotationSet> parentAnnotations, Set<Annotatable> parentItems, Annotatable current)
 {
+  Set<Annotatable> parents = AnnotationUtil.getAllAnnotatableParentItems(dc, current, null);
+  for (Annotatable parent : parents)
+  {
+    if (parent != null && parentItems.add(parent))
+    {
+      if (parent.hasPermission(Permission.USE) && parent.isAnnotated())
+      {
+        parentAnnotations.add(parent.getAnnotationSet());
+      }
+    }
+  }
+  /*
   Set<Annotatable> parents = null;
   if (current instanceof PhysicalBioAssay)
@@ -105 +118 @@
     }
   }
+  */
 }
 
@@ -205 +219 @@
   {
     // Get all annotated parents and their annotation sets
-    loadParents(parentAnnotations, parentItems, item, item);
+    loadParents(dc, parentAnnotations, parentItems, item);
   }
   if (standalone)
@@ -237 +251 @@
               parentAnnotations.add(parentItem.getAnnotationSet());
             }
-            loadParents(parentAnnotations, parentItems, parentItem, item);
+            loadParents(dc, parentAnnotations, parentItems, parentItem);
           }
         }

trunk/www/views/derivedbioassays/edit_bioassay.jsp

@@ -341 +341 @@
       
       var parents = new Array();
-      if (frm.isRoot[0].checked)
+      if (frm.physicalBioassays && (!frm.isRoot || frm.isRoot[0].checked))
       {
         var ids = Link.getListIds(frm.physicalBioAssays, 'P');
@@ -349 +349 @@
         }
       }
-      else
+      else if (frm.parents && (!frm.isRoot || frm.isRoot[1].checked))
       {
         var ids = Link.getListIds(frm.parents, 'D');