Source code

001/*
002 * BioJava development code
003 *
004 * This code may be freely distributed and modified under the
005 * terms of the GNU Lesser General Public Licence. This should
006 * be distributed with the code. If you do not have a copy,
007 * see:
008 *
009 * http://www.gnu.org/copyleft/lesser.html
010 *
011 * Copyright for this code is held jointly by the individual
012 * authors. These should be listed in @author doc comments.
013 *
014 * For more information on the BioJava project and its aims,
015 * or to join the biojava-l mailing list, visit the home page
016 * at:
017 *
018 * http://www.biojava.org/
019 *
020 */
021
022package org.biojavax.ontology;
023
024import java.util.Arrays;
025import java.util.Set;
026import java.util.TreeSet;
027
028import org.biojava.bio.Annotation;
029import org.biojava.ontology.Ontology;
030import org.biojava.ontology.Term;
031import org.biojava.utils.AbstractChangeable;
032import org.biojava.utils.ChangeEvent;
033import org.biojava.utils.ChangeSupport;
034import org.biojava.utils.ChangeVetoException;
035import org.biojavax.RankedCrossRef;
036import org.biojavax.RichAnnotation;
037
038/**
039 * A Term object that can be compared and thus sorted.
040 * @author Richard Holland
041 * @since 1.5
042 */
043public class SimpleComparableTerm extends AbstractChangeable implements ComparableTerm {
044 
045 private String name;
046 private String description;
047 private ComparableOntology ontology;
048 private String identifier;
049 private Boolean obsolete;
050 private Set synonyms = new TreeSet();
051 private Set rankedcrossrefs = new TreeSet();
052 
053 /**
054 * Creates a new instance of SimpleComparableTerm with synonyms.
055 * @param ontology The ontology to put the term in. Must not be null.
056 * @param name the name of the term. Must not be null.
057 * @param synonyms a set of synonyms for the term. Can be null.
058 */
059 SimpleComparableTerm(ComparableOntology ontology, String name, Object[] synonyms) {
060 if (name == null || name.equals("")) throw new IllegalArgumentException("Name must not be null or empty");
061 if (ontology == null) throw new IllegalArgumentException("Ontology must not be null"); 
062 this.name = name;
063 this.description = null;
064 this.ontology = ontology;
065 this.identifier = null;
066 this.obsolete = Boolean.FALSE;
067 if (synonyms!=null 
068 && synonyms.length != 0) this.synonyms.addAll(Arrays.asList(synonyms));
069 }
070 
071 // Hibernate requirement - not for public use.
072 protected SimpleComparableTerm() {}
073 
074 /**
075 * {@inheritDoc}
076 */
077 public int hashCode() {
078 int value = 17;
079 // Hibernate comparison - we haven't been populated yet
080 if (this.ontology==null) return value;
081 // Normal comparison
082 value = 37*value + this.name.hashCode();
083 value = 37*value + this.ontology.hashCode();
084 return value;
085 }
086 
087 /**
088 * {@inheritDoc}
089 * Two terms are equal if they are in the same ontology and
090 * share the same name.
091 */
092 public boolean equals(Object obj) {
093 if (obj == this) return true;
094 if (!(obj instanceof Term)) return false;
095 // Hibernate comparison - we haven't been populated yet
096 if (this.ontology==null) return false;
097 // Normal comparison
098 Term that = (Term) obj;
099 return this.ontology.equals(that.getOntology()) &&
100 this.name.equals(that.getName());
101 }
102 
103 /**
104 * {@inheritDoc}
105 * Terms are sorted by ontology first, then name.
106 */
107 public int compareTo(Object o) {
108 if (o==this) return 0;
109 // Hibernate comparison - we haven't been populated yet
110 if (this.ontology==null) return -1;
111 // Normal comparison
112 Term them = (Term)o;
113 if (!this.ontology.equals(them.getOntology())) return this.ontology.compareTo(them.getOntology());
114 return this.name.compareTo(them.getName());
115 }
116 
117 /**
118 * {@inheritDoc}
119 * Synonyms are stored in the database as the results of a toString() operation
120 * on each synonym object. This doesn't happen until it reaches the database
121 * though, so if you are not using a database, don't worry about it.
122 */
123 public void addSynonym(Object synonym) { this.synonyms.add(synonym); }
124 
125 /**
126 * {@inheritDoc}
127 */
128 public void removeSynonym(Object synonym) { this.synonyms.remove(synonym); }
129 
130 /**
131 * {@inheritDoc}
132 */
133 public Object[] getSynonyms() { return this.synonyms.toArray(); }
134 
135 // Hibernate requirement - not for public use.
136 Set getSynonymSet() { return this.synonyms; }
137 
138 // Hibernate requirement - not for public use.
139 void setSynonymSet(Set synonyms) { this.synonyms = synonyms; }
140 
141 /**
142 * {@inheritDoc}
143 * <b>Warning</b> this method gives access to the original 
144 * Collection not a copy. This is required by Hibernate. If you
145 * modify the object directly the behaviour may be unpredictable.
146 */
147 public Set getRankedCrossRefs() { return this.rankedcrossrefs; } // original for Hibernate
148 
149 /**
150 * {@inheritDoc}
151 * <b>Warning</b> this method gives access to the original 
152 * Collection not a copy. This is required by Hibernate. If you
153 * modify the object directly the behaviour may be unpredictable.
154 */
155 public void setRankedCrossRefs(Set rankedcrossrefs) throws ChangeVetoException {
156 this.rankedcrossrefs = rankedcrossrefs; // original for Hibernate
157 }
158 
159 /**
160 * {@inheritDoc}
161 */
162 public void addRankedCrossRef(RankedCrossRef crossref) throws ChangeVetoException {
163 if (crossref==null) throw new IllegalArgumentException("Crossref cannot be null");
164 if(!this.hasListeners(ComparableTerm.RANKEDCROSSREF)) {
165 this.rankedcrossrefs.add(crossref);
166 } else {
167 ChangeEvent ce = new ChangeEvent(
168 this,
169 ComparableTerm.RANKEDCROSSREF,
170 crossref,
171 null
172 );
173 ChangeSupport cs = this.getChangeSupport(ComparableTerm.RANKEDCROSSREF);
174 synchronized(cs) {
175 cs.firePreChangeEvent(ce);
176 this.rankedcrossrefs.add(crossref);
177 cs.firePostChangeEvent(ce);
178 }
179 }
180 }
181 
182 /**
183 * {@inheritDoc}
184 */
185 public void removeRankedCrossRef(RankedCrossRef crossref) throws ChangeVetoException {
186 if (crossref==null) throw new IllegalArgumentException("Crossref cannot be null");
187 if(!this.hasListeners(ComparableTerm.RANKEDCROSSREF)) {
188 this.rankedcrossrefs.remove(crossref);
189 } else {
190 ChangeEvent ce = new ChangeEvent(
191 this,
192 ComparableTerm.RANKEDCROSSREF,
193 null,
194 crossref
195 );
196 ChangeSupport cs = this.getChangeSupport(ComparableTerm.RANKEDCROSSREF);
197 synchronized(cs) {
198 cs.firePreChangeEvent(ce);
199 this.rankedcrossrefs.remove(crossref);
200 cs.firePostChangeEvent(ce);
201 }
202 }
203 }
204 
205 /**
206 * {@inheritDoc}
207 */
208 public String getName() { return this.name; }
209 
210 // Hibernate requirement - not for public use.
211 void setName(String name) { this.name = name; }
212 
213 /**
214 * {@inheritDoc}
215 */
216 public String getDescription() { return this.description; }
217 
218 /**
219 * {@inheritDoc}
220 */
221 public void setDescription(String description) throws ChangeVetoException {
222 if(!this.hasListeners(ComparableTerm.DESCRIPTION)) {
223 this.description = description;
224 } else {
225 ChangeEvent ce = new ChangeEvent(
226 this,
227 ComparableTerm.DESCRIPTION,
228 description,
229 this.description
230 );
231 ChangeSupport cs = this.getChangeSupport(ComparableTerm.DESCRIPTION);
232 synchronized(cs) {
233 cs.firePreChangeEvent(ce);
234 this.description = description;
235 cs.firePostChangeEvent(ce);
236 }
237 }
238 }
239 
240 /**
241 * {@inheritDoc}
242 */
243 public Ontology getOntology() { return this.ontology; }
244 
245 // Hibernate requirement - not for public use.
246 void setOntology(ComparableOntology ontology) { this.ontology = ontology; }
247 
248 /**
249 * {@inheritDoc}
250 * Form: "ontology:name [obsolete]" where [obsolete] is optional
251 */
252 public String toString() { 
253 boolean isobs = (this.obsolete!=null && this.obsolete.booleanValue());
254 return this.ontology+":"+this.name+(isobs?" [obsolete]":""); 
255 }
256 
257 /**
258 * {@inheritDoc}
259 * ALWAYS RETURNS AN EMPTY ANNOTATION OBJECT
260 */
261 public Annotation getAnnotation() { return RichAnnotation.EMPTY_ANNOTATION; }
262 
263 /**
264 * {@inheritDoc}
265 */
266 public String getIdentifier() { return this.identifier; }
267 
268 /**
269 * {@inheritDoc}
270 */
271 public void setIdentifier(String identifier) throws ChangeVetoException {
272 if(!this.hasListeners(ComparableTerm.IDENTIFIER)) {
273 this.identifier = identifier;
274 } else {
275 ChangeEvent ce = new ChangeEvent(
276 this,
277 ComparableTerm.IDENTIFIER,
278 identifier,
279 this.identifier
280 );
281 ChangeSupport cs = this.getChangeSupport(ComparableTerm.IDENTIFIER);
282 synchronized(cs) {
283 cs.firePreChangeEvent(ce);
284 this.identifier = identifier;
285 cs.firePostChangeEvent(ce);
286 }
287 }
288 }
289
290 // Hibernate requirement - not for public use.
291 String getObsoleteChar() {
292 return (this.getObsolete()!=null && this.getObsolete().equals(Boolean.TRUE))?"X":null;
293 }
294
295 // Hibernate requirement - not for public use.
296 void setObsoleteChar(String obsolete) throws ChangeVetoException {
297 this.setObsolete(Boolean.valueOf(obsolete!=null && obsolete.equals("X")));
298 }
299 
300 /**
301 * {@inheritDoc}
302 */
303 public Boolean getObsolete() { return this.obsolete; }
304 
305 /**
306 * {@inheritDoc}
307 */
308 public void setObsolete(Boolean obsolete) throws ChangeVetoException {
309 if(!this.hasListeners(ComparableTerm.OBSOLETE)) {
310 this.obsolete = obsolete;
311 } else {
312 ChangeEvent ce = new ChangeEvent(
313 this,
314 ComparableTerm.OBSOLETE,
315 obsolete,
316 this.obsolete
317 );
318 ChangeSupport cs = this.getChangeSupport(ComparableTerm.OBSOLETE);
319 synchronized(cs) {
320 cs.firePreChangeEvent(ce);
321 this.obsolete = obsolete;
322 cs.firePostChangeEvent(ce);
323 }
324 }
325 }
326 
327 // Hibernate requirement - not for public use.
328 private Integer id;
329 
330 /**
331 * Gets the Hibernate ID. Should be used with caution.
332 * @return the Hibernate ID, if using Hibernate.
333 */
334 public Integer getId() { return this.id; }
335 
336 /**
337 * Sets the Hibernate ID. Should be used with caution.
338 * @param id the Hibernate ID, if using Hibernate.
339 */
340 public void setId(Integer id) { this.id = id;}
341}