001package org.biopax.paxtools.query.wrapperL3undirected; 002 003import org.apache.commons.logging.Log; 004import org.apache.commons.logging.LogFactory; 005import org.biopax.paxtools.model.BioPAXElement; 006import org.biopax.paxtools.model.BioPAXLevel; 007import org.biopax.paxtools.model.Model; 008import org.biopax.paxtools.model.level3.*; 009import org.biopax.paxtools.query.model.AbstractGraph; 010import org.biopax.paxtools.query.model.GraphObject; 011import org.biopax.paxtools.query.model.Node; 012import org.biopax.paxtools.query.wrapperL3.Filter; 013 014import java.util.*; 015 016/** 017 * Wrapper for L3 Graphs. 018 * 019 * @author Ozgun Babur 020 */ 021public class GraphL3Undirected extends AbstractGraph 022{ 023 /** 024 * The model to be wrapped. 025 */ 026 protected Model model; 027 028 protected List<Filter> filters; 029 030 /** 031 * Log for logging. 032 */ 033 protected final Log log = LogFactory.getLog(GraphL3Undirected.class); 034 035 /** 036 * Constructor with the model and the IDs of the ubiquitous molecules. IDs can be null, meaning 037 * no labeling is desired. 038 * @param model Model to wrap 039 * @param filters for filtering graph elements 040 */ 041 public GraphL3Undirected(Model model, Filter... filters) 042 { 043 assert model.getLevel() == BioPAXLevel.L3; 044 this.model = model; 045 046 if (filters.length > 0) 047 { 048 this.filters = Arrays.asList(filters); 049 } 050 } 051 052 /** 053 * There must be no filter opposing to traverse this object to traverse it. 054 * @param ele element to check 055 * @return true if ok to traverse 056 */ 057 private boolean passesFilters(Level3Element ele) 058 { 059 if (filters == null) return true; 060 061 for (Filter filter : filters) 062 { 063 if (!filter.okToTraverse(ele)) return false; 064 } 065 return true; 066 } 067 068 /** 069 * This method creates a wrapper for every wrappable L3 element. 070 * @param obj Object to wrap 071 * @return The wrapper 072 */ 073 @Override 074 public Node wrap(Object obj) 075 { 076 // Check if the object is level3 077 if (!(obj instanceof Level3Element)) throw new IllegalArgumentException( 078 "An object other than a Level3Element is trying to be wrapped: " + obj); 079 080 // Check if the object passes the filter 081 if (!passesFilters((Level3Element) obj)) return null; 082 083 // Wrap if traversible 084 085 if (obj instanceof PhysicalEntity) 086 { 087 return new PhysicalEntityWrapper((PhysicalEntity) obj, this); 088 } 089 else if (obj instanceof Control) 090 { 091 return new ControlWrapper((Control) obj, this); 092 } 093 else if (obj instanceof Interaction) 094 { 095 return new InteractionWrapper((Interaction) obj, this); 096 } 097 else 098 { 099 if (log.isWarnEnabled()) 100 { 101 log.warn("Invalid BioPAX object to wrap as node. Ignoring: " + obj); 102 } 103 return null; 104 } 105 } 106 107 /** 108 * RDF IDs of elements is used as key in the object map. 109 * @param wrapped Object to wrap 110 * @return Key 111 */ 112 @Override 113 public String getKey(Object wrapped) 114 { 115 if (wrapped instanceof BioPAXElement) 116 { 117 return ((BioPAXElement) wrapped).getRDFId(); 118 } 119 120 throw new IllegalArgumentException("Object cannot be wrapped: " + wrapped); 121 } 122 123 /** 124 * Gets wrappers of given elements 125 * @param objects Wrapped objects 126 * @return wrappers 127 */ 128 public Set<Node> getWrapperSet(Set<?> objects) 129 { 130 Set<Node> wrapped = new HashSet<Node>(); 131 132 for (Object object : objects) 133 { 134 Node node = (Node) getGraphObject(object); 135 if (node != null) 136 { 137 wrapped.add(node); 138 } 139 } 140 return wrapped; 141 } 142 143 /** 144 * Gets an element-to-wrapper map for the given elements. 145 * @param objects Wrapped objects 146 * @return object-to-wrapper map 147 */ 148 public Map<Object, Node> getWrapperMap(Set<?> objects) 149 { 150 Map<Object, Node> map = new HashMap<Object, Node>(); 151 152 for (Object object : objects) 153 { 154 Node node = (Node) getGraphObject(object); 155 if (node != null) 156 { 157 map.put(object, node); 158 } 159 } 160 return map; 161 } 162 163 /** 164 * Gets the wrapped objects of the given wrappers. 165 * @param wrappers Wrappers 166 * @return Wrapped objects 167 */ 168 public Set<Object> getWrappedSet(Set<? extends GraphObject> wrappers) 169 { 170 Set<Object> objects = new HashSet<Object>(); 171 172 for (GraphObject wrapper : wrappers) 173 { 174 if (wrapper instanceof PhysicalEntityWrapper) 175 { 176 objects.add(((PhysicalEntityWrapper) wrapper).getPhysicalEntity()); 177 } 178 else if (wrapper instanceof ControlWrapper) 179 { 180 objects.add(((ControlWrapper) wrapper).getControl()); 181 } 182 else if (wrapper instanceof InteractionWrapper) 183 { 184 objects.add(((InteractionWrapper) wrapper).getInteraction()); 185 } 186 } 187 return objects; 188 } 189 190 /** 191 * @return Wrapped model 192 */ 193 public Model getModel() 194 { 195 return model; 196 } 197}