|
1
|
/**
|
|
2
|
* Copyright (C) 2007 EDIT
|
|
3
|
* European Distributed Institute of Taxonomy
|
|
4
|
* http://www.e-taxonomy.eu
|
|
5
|
*
|
|
6
|
* The contents of this file are subject to the Mozilla Public License Version 1.1
|
|
7
|
* See LICENSE.TXT at the top of this package for the full license terms.
|
|
8
|
*/
|
|
9
|
|
|
10
|
package eu.etaxonomy.cdm.model.taxon;
|
|
11
|
|
|
12
|
import java.util.HashMap;
|
|
13
|
import java.util.List;
|
|
14
|
import java.util.Map;
|
|
15
|
import java.util.UUID;
|
|
16
|
|
|
17
|
import javax.persistence.Entity;
|
|
18
|
import javax.xml.bind.annotation.XmlAccessType;
|
|
19
|
import javax.xml.bind.annotation.XmlAccessorType;
|
|
20
|
import javax.xml.bind.annotation.XmlRootElement;
|
|
21
|
import javax.xml.bind.annotation.XmlType;
|
|
22
|
|
|
23
|
import org.apache.log4j.Logger;
|
|
24
|
import org.hibernate.envers.Audited;
|
|
25
|
|
|
26
|
import eu.etaxonomy.cdm.model.common.DefinedTermBase;
|
|
27
|
import eu.etaxonomy.cdm.model.common.RelationshipTermBase;
|
|
28
|
import eu.etaxonomy.cdm.model.common.TermType;
|
|
29
|
import eu.etaxonomy.cdm.model.common.TermVocabulary;
|
|
30
|
|
|
31
|
|
|
32
|
/**
|
|
33
|
* The class representing categories of {@link TaxonRelationship taxon relationships}
|
|
34
|
* (like "is congruent to" or "is misapplied name for").
|
|
35
|
* <P>
|
|
36
|
* A standard (ordered) list of taxon relationship type instances will be
|
|
37
|
* automatically created as the project starts. But this class allows to extend
|
|
38
|
* this standard list by creating new instances of additional taxon
|
|
39
|
* relationship types if needed.
|
|
40
|
* <P>
|
|
41
|
* This class corresponds in part to: <ul>
|
|
42
|
* <li> TaxonRelationshipTerm according to the TDWG ontology
|
|
43
|
* <li> RelationshipType according to the TCS
|
|
44
|
* </ul>
|
|
45
|
*
|
|
46
|
* @author m.doering
|
|
47
|
* @created 08-Nov-2007 13:06:17
|
|
48
|
*/
|
|
49
|
@XmlAccessorType(XmlAccessType.FIELD)
|
|
50
|
@XmlType(name = "TaxonRelationshipType")
|
|
51
|
@XmlRootElement(name = "TaxonRelationshipType")
|
|
52
|
@Entity
|
|
53
|
//@Indexed disabled to reduce clutter in indexes, since this type is not used by any search
|
|
54
|
//@Indexed(index = "eu.etaxonomy.cdm.model.common.DefinedTermBase")
|
|
55
|
@Audited
|
|
56
|
public class TaxonRelationshipType extends RelationshipTermBase<TaxonRelationshipType> {
|
|
57
|
private static final long serialVersionUID = 6575652105931691670L;
|
|
58
|
@SuppressWarnings("unused")
|
|
59
|
private static final Logger logger = Logger.getLogger(TaxonRelationshipType.class);
|
|
60
|
|
|
61
|
protected static Map<UUID, TaxonRelationshipType> termMap = null;
|
|
62
|
|
|
63
|
@Deprecated //will be removed in future versions. Use Classification/TaxonNode instead
|
|
64
|
private static final UUID uuidTaxonomicallyIncludedIn = UUID.fromString("d13fecdf-eb44-4dd7-9244-26679c05df1c");
|
|
65
|
|
|
66
|
private static final UUID uuidMisappliedNameFor = UUID.fromString("1ed87175-59dd-437e-959e-0d71583d8417");
|
|
67
|
private static final UUID uuidInvalidDesignationFor = UUID.fromString("605b1d01-f2b1-4544-b2e0-6f08def3d6ed");
|
|
68
|
|
|
69
|
private static final UUID uuidContradiction = UUID.fromString("a8f03491-2ad6-4fae-a04c-2a4c117a2e9b");
|
|
70
|
private static final UUID uuidCongruentTo = UUID.fromString("60974c98-64ab-4574-bb5c-c110f6db634d");
|
|
71
|
private static final UUID uuidIncludes = UUID.fromString("0501c385-cab1-4fbe-b945-fc747419bb13");
|
|
72
|
private static final UUID uuidOverlaps = UUID.fromString("2046a0fd-4fd6-45a1-b707-2b91547f3ec7");
|
|
73
|
private static final UUID uuidExcludes = UUID.fromString("4535a63c-4a3f-4d69-9350-7bf02e2c23be");
|
|
74
|
private static final UUID uuidDoesNotExclude = UUID.fromString("0e5099bb-87c0-400e-abdc-bcfed5b5eece");
|
|
75
|
private static final UUID uuidDoesNotOverlap = UUID.fromString("ecd2382b-3d94-4169-9dd2-2c4ea1d24605");
|
|
76
|
private static final UUID uuidNotIncludedIn = UUID.fromString("89dffa4e-e004-4d42-b0d1-ae1827529e43");
|
|
77
|
private static final UUID uuidNotCongruentTo = UUID.fromString("6c16c33b-cfc5-4a00-92bd-a9f9e448f389");
|
|
78
|
|
|
79
|
|
|
80
|
private static final UUID uuidCongruentToOrIncludes = UUID.fromString("b55cb3a2-6e20-4ca3-95bc-12b59d3235b0");
|
|
81
|
private static final UUID uuidIncludedInOrIncludes = UUID.fromString("c3ed5089-6779-4051-bb24-f5ea0eca80d5");
|
|
82
|
private static final UUID uuidCongruentIncludedInOrIncludes = UUID.fromString("0170cd83-93ad-43c2-9ad1-7ac879300e2f");
|
|
83
|
private static final UUID uuidCongruentToOrOverlaps = UUID.fromString("78355cfa-5200-432f-8e00-82b97afad0ed");
|
|
84
|
private static final UUID uuidIncludesOrOverlaps = UUID.fromString("f1ec567b-3c73-436b-8625-b4fd53588abb");
|
|
85
|
|
|
86
|
private static final UUID uuidCongruentToOrIncludesOrOverlaps = UUID.fromString("2d923b1a-6c0f-414c-ac9b-bbc502e18078");
|
|
87
|
private static final UUID uuidIncludedInOrIncludesOrOverlaps = UUID.fromString("43466aa9-e431-4f37-8bca-febfd9f63716");
|
|
88
|
private static final UUID uuidCongruentToOrExcludes = UUID.fromString("758e6cf3-05a0-49ed-9496-d8c4a9fd02ae");
|
|
89
|
private static final UUID uuidIncludesOrExcludes = UUID.fromString("6ee440bc-fd3d-4da2-ad85-906d35a94731");
|
|
90
|
private static final UUID uuidCongruentToOrIncludesOrExcludes = UUID.fromString("d5c6953d-aa53-46f8-aafc-ebc6428ad5d0");
|
|
91
|
private static final UUID uuidIncludedInOrIncludesOrExcludes = UUID.fromString("43d8492c-8bd5-4f38-a633-f1ad910a34dd");
|
|
92
|
private static final UUID uuidOverlapsOrExcludes = UUID.fromString("623ecdeb-ff1f-471d-a8dc-0d75b2fe8d94");
|
|
93
|
private static final UUID uuidCongruentToOrOverlapsOrExcludes = UUID.fromString("6fabef72-5264-44f1-bfc0-8e2e141375f2");
|
|
94
|
private static final UUID uuidIncludesOrOverlapsOrExcludes = UUID.fromString("b7153c89-cc6c-4f8c-bf74-216f10feac46");
|
|
95
|
|
|
96
|
private static final UUID uuidAllRelationships = UUID.fromString("831fcd88-e5c9-49e0-b06e-bbb67d1c05c9");
|
|
97
|
|
|
98
|
public static TaxonRelationshipType NewInstance(String term, String label, String labelAbbrev, boolean symmetric, boolean transitive) {
|
|
99
|
return new TaxonRelationshipType(term, label, labelAbbrev, symmetric, transitive);
|
|
100
|
}
|
|
101
|
|
|
102
|
|
|
103
|
//********************************** CONSTRUCTOR *********************************/
|
|
104
|
|
|
105
|
//for hibernate use only
|
|
106
|
@Deprecated
|
|
107
|
protected TaxonRelationshipType() {
|
|
108
|
super(TermType.TaxonRelationshipType);
|
|
109
|
}
|
|
110
|
/**
|
|
111
|
* Class constructor: creates an additional taxon relationship type
|
|
112
|
* instance with a description (in the {@link eu.etaxonomy.cdm.model.common.Language#DEFAULT() default language}), a label,
|
|
113
|
* a label abbreviation and the flags indicating whether this new taxon
|
|
114
|
* relationship type is symmetric and/or transitive.
|
|
115
|
*
|
|
116
|
* @param term the string (in the default language) describing the
|
|
117
|
* new taxon relationship type to be created
|
|
118
|
* @param label the string identifying the new taxon relationship
|
|
119
|
* type to be created
|
|
120
|
* @param labelAbbrev the string identifying (in abbreviated form) the
|
|
121
|
* new taxon relationship type to be created
|
|
122
|
* @param symmetric the boolean indicating whether the new taxon
|
|
123
|
* relationship type to be created is symmetric
|
|
124
|
* @param transitive the boolean indicating whether the new taxon
|
|
125
|
* relationship type to be created is transitive
|
|
126
|
* @see #TaxonRelationshipType()
|
|
127
|
*/
|
|
128
|
private TaxonRelationshipType(String term, String label, String labelAbbrev, boolean symmetric, boolean transitive) {
|
|
129
|
super(TermType.TaxonRelationshipType, term, label, labelAbbrev, symmetric, transitive);
|
|
130
|
}
|
|
131
|
|
|
132
|
|
|
133
|
//************************** METHODS ********************************
|
|
134
|
|
|
135
|
/* (non-Javadoc)
|
|
136
|
* @see eu.etaxonomy.cdm.model.common.DefinedTermBase#resetTerms()
|
|
137
|
*/
|
|
138
|
@Override
|
|
139
|
public void resetTerms(){
|
|
140
|
termMap = null;
|
|
141
|
}
|
|
142
|
|
|
143
|
|
|
144
|
protected static TaxonRelationshipType getTermByUuid(UUID uuid){
|
|
145
|
if (termMap == null || termMap.isEmpty()){
|
|
146
|
return getTermByClassAndUUID(TaxonRelationshipType.class, uuid);
|
|
147
|
} else {
|
|
148
|
return termMap.get(uuid);
|
|
149
|
}
|
|
150
|
}
|
|
151
|
|
|
152
|
|
|
153
|
/**
|
|
154
|
* Returns true, if this relationship type is not a <i>misapplied name for<i>
|
|
155
|
* and also no <i>taxonomically included in</i> relationship.<BR>
|
|
156
|
* It assumes that all other relationships are concept relationships.
|
|
157
|
* @return
|
|
158
|
*/
|
|
159
|
public boolean isConceptRelationship(){
|
|
160
|
if (this.equals(MISAPPLIED_NAME_FOR())){
|
|
161
|
return false;
|
|
162
|
}else if (this.equals(TAXONOMICALLY_INCLUDED_IN())){
|
|
163
|
return false;
|
|
164
|
}
|
|
165
|
return true;
|
|
166
|
}
|
|
167
|
|
|
168
|
/**
|
|
169
|
* Returns the taxon relationship type "is taxonomically included in". This
|
|
170
|
* indicates that the {@link TaxonRelationship#getFromTaxon() source taxon}
|
|
171
|
* in such a {@link TaxonRelationship taxon relationship} has the target {@link Taxon taxon}
|
|
172
|
* as immediate next higher parent within the classification. Generally
|
|
173
|
* the {@link Taxon#getSec() concept reference} of both taxa are the same
|
|
174
|
* except if the concept reference follows the taxonomical opinion of
|
|
175
|
* another reference.<BR>
|
|
176
|
* This type is neither symmetric nor transitive.
|
|
177
|
* @deprecated will be removed in version 3.0
|
|
178
|
*/
|
|
179
|
@Deprecated
|
|
180
|
public static final TaxonRelationshipType TAXONOMICALLY_INCLUDED_IN(){
|
|
181
|
return getTermByUuid(uuidTaxonomicallyIncludedIn);
|
|
182
|
}
|
|
183
|
/**
|
|
184
|
* Returns the taxon relationship type "is misapplied name for". This
|
|
185
|
* indicates that the {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon name} of the {@link TaxonRelationship#getFromTaxon() source taxon}
|
|
186
|
* in such a {@link TaxonRelationship taxon relationship} has been erroneously used by
|
|
187
|
* the {@link TaxonBase#getSec() concept reference} to denominate the same real taxon
|
|
188
|
* as the one meant by the target {@link Taxon taxon}.<BR>
|
|
189
|
* This type is neither symmetric nor transitive.
|
|
190
|
*/
|
|
191
|
public static final TaxonRelationshipType MISAPPLIED_NAME_FOR(){
|
|
192
|
return getTermByUuid(uuidMisappliedNameFor);
|
|
193
|
}
|
|
194
|
/**
|
|
195
|
* Returns the taxon relationship type "is invalid designation for". This
|
|
196
|
* indicates that the {@link eu.etaxonomy.cdm.model.name.TaxonNameBase taxon name} of the {@link TaxonRelationship#getFromTaxon() source taxon}
|
|
197
|
* in such a {@link TaxonRelationship taxon relationship} has
|
|
198
|
* {@link eu.etaxonomy.cdm.model.name.NomenclaturalStatusType#isInvalidType() not been validly published} but was intended to denominate
|
|
199
|
* a real taxon which is the same as the one meant by the target {@link Taxon taxon}.<BR>
|
|
200
|
* According to the nomenclature codes a not validly published taxon name is
|
|
201
|
* not a taxon name at all.<BR>
|
|
202
|
* This type is neither symmetric nor transitive.
|
|
203
|
*/
|
|
204
|
public static final TaxonRelationshipType INVALID_DESIGNATION_FOR(){
|
|
205
|
return getTermByUuid(uuidInvalidDesignationFor);
|
|
206
|
}
|
|
207
|
/**
|
|
208
|
* Returns the (concept) taxon relationship type "is impossible"
|
|
209
|
* (contradiction). This is a concept relationship type which means that the
|
|
210
|
* circumscriptions (the set of organisms/specimens that belong to a {@link Taxon taxon}
|
|
211
|
* according to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
212
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
213
|
* beeing compared. In a concept relationship the concept references of the
|
|
214
|
* involved taxa must be distinct. <BR>
|
|
215
|
* The "is impossible" (contradiction) taxon relationship type arises
|
|
216
|
* logically if two or more incompatible (concept) taxon relationships
|
|
217
|
* between the two taxa already exist (for instance with the types
|
|
218
|
* "is congruent to" and "excludes").<BR>
|
|
219
|
* This type is symmetric but not transitive.
|
|
220
|
*/
|
|
221
|
public static final TaxonRelationshipType CONTRADICTION(){
|
|
222
|
return getTermByUuid(uuidContradiction);
|
|
223
|
}
|
|
224
|
/**
|
|
225
|
* Returns the (concept) taxon relationship type "is congruent to".
|
|
226
|
* This is a concept relationship type which means that the circumscriptions
|
|
227
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
228
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
229
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
230
|
* beeing compared. In a concept relationship the concept references of the
|
|
231
|
* involved taxa must be distinct. <BR>
|
|
232
|
* The "is congruent to" taxon relationship type indicates that the
|
|
233
|
* circumscriptions of both taxa involved in the taxon relationship are
|
|
234
|
* identical.<BR>
|
|
235
|
* This type is symmetric and transitive.
|
|
236
|
*/
|
|
237
|
public static final TaxonRelationshipType CONGRUENT_TO(){
|
|
238
|
return getTermByUuid(uuidCongruentTo);
|
|
239
|
}
|
|
240
|
/**
|
|
241
|
* Returns the (concept) taxon relationship type "includes".
|
|
242
|
* This is a concept relationship type which means that the circumscriptions
|
|
243
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
244
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
245
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
246
|
* beeing compared. In a concept relationship the concept references of the
|
|
247
|
* involved taxa must be distinct. <BR>
|
|
248
|
* The "includes" taxon relationship type indicates that each element
|
|
249
|
* belonging to the circumscription of the target taxon involved in the
|
|
250
|
* taxon relationship belongs to the circumscription of the source taxon,
|
|
251
|
* but that some elements belonging to the circumscription of the source
|
|
252
|
* taxon do not belong to the circumscription of the target taxon.<BR>
|
|
253
|
* This type is not symmetric but transitive.
|
|
254
|
*/
|
|
255
|
public static final TaxonRelationshipType INCLUDES(){
|
|
256
|
return getTermByUuid(uuidIncludes);
|
|
257
|
}
|
|
258
|
/**
|
|
259
|
* Returns the (concept) taxon relationship type "overlaps".
|
|
260
|
* This is a concept relationship type which means that the circumscriptions
|
|
261
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
262
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
263
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
264
|
* beeing compared. In a concept relationship the concept references of the
|
|
265
|
* involved taxa must be distinct. <BR>
|
|
266
|
* The "overlaps" taxon relationship type indicates that both
|
|
267
|
* circumscriptions have common elements but that some elements belonging
|
|
268
|
* to the circumscription of the source taxon do not belong to the
|
|
269
|
* circumscription of the target taxon and vice-versa.<BR>
|
|
270
|
* This type is symmetric but not transitive.
|
|
271
|
*/
|
|
272
|
public static final TaxonRelationshipType OVERLAPS(){
|
|
273
|
return getTermByUuid(uuidOverlaps);
|
|
274
|
}
|
|
275
|
/**
|
|
276
|
* Returns the (concept) taxon relationship type "excludes".
|
|
277
|
* This is a concept relationship type which means that the circumscriptions
|
|
278
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
279
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
280
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
281
|
* beeing compared. In a concept relationship the concept references of the
|
|
282
|
* involved taxa must be distinct. <BR>
|
|
283
|
* The "excludes" taxon relationship type indicates that both
|
|
284
|
* circumscriptions have no common elements.<BR>
|
|
285
|
* This type is symmetric but not transitive.
|
|
286
|
*/
|
|
287
|
public static final TaxonRelationshipType EXCLUDES(){
|
|
288
|
return getTermByUuid(uuidExcludes);
|
|
289
|
}
|
|
290
|
/**
|
|
291
|
* Returns the (concept) taxon relationship type "does not exclude".
|
|
292
|
* This is a concept relationship type which means that the circumscriptions
|
|
293
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
294
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
295
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
296
|
* beeing compared. In a concept relationship the concept references of the
|
|
297
|
* involved taxa must be distinct. <BR>
|
|
298
|
* The "does not exclude" taxon relationship type indicates that both
|
|
299
|
* circumscriptions have common elements. This type is a generalisation of
|
|
300
|
* {@link #CONGRUENT_TO() "is congruent to"}, {@link #INCLUDES() "includes"} and {@link #OVERLAPS() "overlaps"}.<BR>
|
|
301
|
* This type is symmetric but not transitive.
|
|
302
|
*
|
|
303
|
* @see #EXCLUDES()
|
|
304
|
*/
|
|
305
|
public static final TaxonRelationshipType DOES_NOT_EXCLUDE(){
|
|
306
|
return getTermByUuid(uuidDoesNotExclude);
|
|
307
|
}
|
|
308
|
/**
|
|
309
|
* Returns the (concept) taxon relationship type "does not overlap".
|
|
310
|
* This is a concept relationship type which means that the circumscriptions
|
|
311
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
312
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
313
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
314
|
* beeing compared. In a concept relationship the concept references of the
|
|
315
|
* involved taxa must be distinct. <BR>
|
|
316
|
* The "does not overlap" taxon relationship type is a generalisation of
|
|
317
|
* {@link #CONGRUENT_TO() "is congruent to"}, {@link #INCLUDES() "includes"} and {@link #EXCLUDES() "excludes"}.<BR>
|
|
318
|
* This type is symmetric but not transitive.
|
|
319
|
*
|
|
320
|
* @see #OVERLAPS()
|
|
321
|
*/
|
|
322
|
public static final TaxonRelationshipType DOES_NOT_OVERLAP(){
|
|
323
|
return getTermByUuid(uuidDoesNotOverlap);
|
|
324
|
}
|
|
325
|
/**
|
|
326
|
* Returns the (concept) taxon relationship type "is not included in".
|
|
327
|
* This is a concept relationship type which means that the circumscriptions
|
|
328
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
329
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
330
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
331
|
* beeing compared. In a concept relationship the concept references of the
|
|
332
|
* involved taxa must be distinct. <BR>
|
|
333
|
* The "is not included in" taxon relationship type indicates that at least
|
|
334
|
* one element belonging to the circumscription of the source taxon involved
|
|
335
|
* in the taxon relationship does not belong to the circumscription of the
|
|
336
|
* target taxon. <BR>
|
|
337
|
* This type is neither symmetric nor transitive.
|
|
338
|
*
|
|
339
|
* @see #INCLUDES()
|
|
340
|
*/
|
|
341
|
public static final TaxonRelationshipType NOT_INCLUDED_IN(){
|
|
342
|
return getTermByUuid(uuidNotIncludedIn);
|
|
343
|
}
|
|
344
|
/**
|
|
345
|
* Returns the (concept) taxon relationship type "is not congruent to".
|
|
346
|
* This is a concept relationship type which means that the circumscriptions
|
|
347
|
* (the set of organisms/specimens that belong to a {@link Taxon taxon} according
|
|
348
|
* to the -maybe implicit- opinion of the {@link TaxonBase#getSec() concept reference})
|
|
349
|
* of both taxa involved in such a {@link TaxonRelationship taxon relationship} are
|
|
350
|
* beeing compared. In a concept relationship the concept references of the
|
|
351
|
* involved taxa must be distinct. <BR>
|
|
352
|
* The "is not congruent to" taxon relationship type indicates that at least
|
|
353
|
* one element belonging to one of both circumscriptions does not belong to
|
|
354
|
* the other circumscription. This type is a generalisation of
|
|
355
|
* {@link #INCLUDES() "includes"}, {@link #OVERLAPS() "overlaps"} and {@link #EXCLUDES() "excludes"}.<BR>
|
|
356
|
* This type is symmetric but not transitive.
|
|
357
|
*
|
|
358
|
* @see #CONGRUENT_TO()
|
|
359
|
*/
|
|
360
|
public static final TaxonRelationshipType NOT_CONGRUENT_TO(){
|
|
361
|
return getTermByUuid(uuidNotCongruentTo);
|
|
362
|
}
|
|
363
|
|
|
364
|
public static final TaxonRelationshipType CONGRUENT_OR_INCLUDES(){
|
|
365
|
return getTermByUuid(uuidCongruentToOrIncludes);
|
|
366
|
}
|
|
367
|
public static final TaxonRelationshipType INCLUDED_OR_INCLUDES(){
|
|
368
|
return getTermByUuid(uuidIncludedInOrIncludes);
|
|
369
|
}
|
|
370
|
public static final TaxonRelationshipType CONGRUENT_OR_INCLUDED_OR_INCLUDES(){
|
|
371
|
return getTermByUuid(uuidCongruentIncludedInOrIncludes);
|
|
372
|
}
|
|
373
|
public static final TaxonRelationshipType CONGRUENT_OR_OVERLAPS(){
|
|
374
|
return getTermByUuid(uuidCongruentToOrOverlaps);
|
|
375
|
}
|
|
376
|
|
|
377
|
public static final TaxonRelationshipType INCLUDES_OR_OVERLAPS(){
|
|
378
|
return getTermByUuid(uuidIncludesOrOverlaps);
|
|
379
|
}
|
|
380
|
|
|
381
|
public static final TaxonRelationshipType CONGRUENT_OR_INCLUDES_OR_EXCLUDES(){
|
|
382
|
return getTermByUuid(uuidCongruentToOrIncludesOrExcludes);
|
|
383
|
}
|
|
384
|
|
|
385
|
public static final TaxonRelationshipType INCLUDES_OR_EXCLUDES(){
|
|
386
|
return getTermByUuid(uuidIncludesOrExcludes);
|
|
387
|
}
|
|
388
|
|
|
389
|
public static final TaxonRelationshipType CONGRUENT_OR_EXCLUDES(){
|
|
390
|
return getTermByUuid(uuidCongruentToOrExcludes);
|
|
391
|
}
|
|
392
|
|
|
393
|
public static final TaxonRelationshipType INCLUDED_OR_INCLUDES_OR_OVERLAPS(){
|
|
394
|
return getTermByUuid(uuidIncludedInOrIncludesOrOverlaps);
|
|
395
|
}
|
|
396
|
|
|
397
|
public static final TaxonRelationshipType CONGRUENT_OR_INCLUDES_OR_OVERLAPS(){
|
|
398
|
return getTermByUuid(uuidCongruentToOrIncludesOrOverlaps);
|
|
399
|
}
|
|
400
|
|
|
401
|
public static final TaxonRelationshipType INCLUDES_OR_OVERLAPS_OR_EXCLUDES(){
|
|
402
|
return getTermByUuid(uuidIncludesOrOverlapsOrExcludes);
|
|
403
|
}
|
|
404
|
|
|
405
|
public static final TaxonRelationshipType CONGRUENT_OR_OVERLAPS_OR_EXCLUDES(){
|
|
406
|
return getTermByUuid(uuidCongruentToOrOverlapsOrExcludes);
|
|
407
|
}
|
|
408
|
|
|
409
|
public static final TaxonRelationshipType OVERLAPS_OR_EXCLUDES(){
|
|
410
|
return getTermByUuid(uuidOverlapsOrExcludes);
|
|
411
|
}
|
|
412
|
|
|
413
|
public static final TaxonRelationshipType INCLUDED_OR_INCLUDES_OR_EXCLUDES(){
|
|
414
|
return getTermByUuid(uuidIncludedInOrIncludesOrExcludes);
|
|
415
|
}
|
|
416
|
|
|
417
|
@Override
|
|
418
|
protected void setDefaultTerms(TermVocabulary<TaxonRelationshipType> termVocabulary) {
|
|
419
|
termMap = new HashMap<UUID, TaxonRelationshipType>();
|
|
420
|
for (TaxonRelationshipType term : termVocabulary.getTerms()){
|
|
421
|
termMap.put(term.getUuid(), term);
|
|
422
|
}
|
|
423
|
}
|
|
424
|
|
|
425
|
//TODO ohter relationshipTypes
|
|
426
|
|
|
427
|
public static final TaxonRelationshipType ALL_RELATIONSHIPS(){
|
|
428
|
return getTermByUuid(uuidAllRelationships);
|
|
429
|
}
|
|
430
|
|
|
431
|
@Override
|
|
432
|
public TaxonRelationshipType readCsvLine(Class<TaxonRelationshipType> termClass, List<String> csvLine, Map<UUID,DefinedTermBase> terms, boolean abbrevAsId) {
|
|
433
|
TaxonRelationshipType newInstance = super.readCsvLine(termClass, csvLine, terms, abbrevAsId);
|
|
434
|
|
|
435
|
String inverseLabelAbbrev = csvLine.get(7).trim();
|
|
436
|
newInstance.setSymbol(newInstance.getIdInVocabulary());
|
|
437
|
newInstance.setInverseSymbol(inverseLabelAbbrev);
|
|
438
|
return newInstance;
|
|
439
|
}
|
|
440
|
}
|