|
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.common;
|
|
11
|
|
|
12
|
|
|
13
|
import java.beans.PropertyChangeEvent;
|
|
14
|
import java.beans.PropertyChangeListener;
|
|
15
|
import java.util.ArrayList;
|
|
16
|
import java.util.HashSet;
|
|
17
|
import java.util.List;
|
|
18
|
import java.util.Set;
|
|
19
|
import java.util.UUID;
|
|
20
|
|
|
21
|
import javax.persistence.Column;
|
|
22
|
import javax.persistence.Embedded;
|
|
23
|
import javax.persistence.FetchType;
|
|
24
|
import javax.persistence.MappedSuperclass;
|
|
25
|
import javax.persistence.OneToMany;
|
|
26
|
import javax.persistence.Transient;
|
|
27
|
import javax.validation.constraints.NotNull;
|
|
28
|
import javax.validation.constraints.Size;
|
|
29
|
import javax.xml.bind.annotation.XmlAccessType;
|
|
30
|
import javax.xml.bind.annotation.XmlAccessorType;
|
|
31
|
import javax.xml.bind.annotation.XmlElement;
|
|
32
|
import javax.xml.bind.annotation.XmlElementWrapper;
|
|
33
|
import javax.xml.bind.annotation.XmlTransient;
|
|
34
|
import javax.xml.bind.annotation.XmlType;
|
|
35
|
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
|
|
36
|
|
|
37
|
import org.apache.log4j.Logger;
|
|
38
|
import org.hibernate.annotations.Cascade;
|
|
39
|
import org.hibernate.annotations.CascadeType;
|
|
40
|
import org.hibernate.annotations.IndexColumn;
|
|
41
|
import org.hibernate.envers.Audited;
|
|
42
|
import org.hibernate.search.annotations.Analyze;
|
|
43
|
import org.hibernate.search.annotations.Field;
|
|
44
|
import org.hibernate.search.annotations.FieldBridge;
|
|
45
|
import org.hibernate.search.annotations.Fields;
|
|
46
|
import org.hibernate.search.annotations.Store;
|
|
47
|
import org.hibernate.validator.constraints.NotEmpty;
|
|
48
|
|
|
49
|
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
|
|
50
|
import eu.etaxonomy.cdm.hibernate.search.StripHtmlBridge;
|
|
51
|
import eu.etaxonomy.cdm.jaxb.FormattedTextAdapter;
|
|
52
|
import eu.etaxonomy.cdm.jaxb.LSIDAdapter;
|
|
53
|
import eu.etaxonomy.cdm.model.media.Rights;
|
|
54
|
import eu.etaxonomy.cdm.model.name.NonViralName;
|
|
55
|
import eu.etaxonomy.cdm.model.name.TaxonNameBase;
|
|
56
|
import eu.etaxonomy.cdm.model.reference.Reference;
|
|
57
|
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
|
|
58
|
import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
|
|
59
|
import eu.etaxonomy.cdm.strategy.match.Match;
|
|
60
|
import eu.etaxonomy.cdm.strategy.match.Match.ReplaceMode;
|
|
61
|
import eu.etaxonomy.cdm.strategy.match.MatchMode;
|
|
62
|
import eu.etaxonomy.cdm.strategy.merge.Merge;
|
|
63
|
import eu.etaxonomy.cdm.strategy.merge.MergeMode;
|
|
64
|
import eu.etaxonomy.cdm.validation.Level2;
|
|
65
|
|
|
66
|
/**
|
|
67
|
* Superclass for the primary CDM classes that can be referenced from outside via LSIDs and contain a simple generated title string as a label for human reading.
|
|
68
|
* All subclasses inherit the ability to store additional properties that are stored as {@link Extension Extensions}, basically a string value with a type term.
|
|
69
|
* Any number of right statements can be attached as well as multiple {@link OriginalSourceBase} objects.
|
|
70
|
* Original sources carry a reference to the source, an ID within that source and the original title/label of this object as it was used in that source (originalNameString).
|
|
71
|
* A Taxon for example that was taken from 2 sources like FaunaEuropaea and IPNI would have two originalSource objects.
|
|
72
|
* The originalSource representing that taxon as it was found in IPNI would contain IPNI as the reference, the IPNI id of the taxon and the name of the taxon exactly as it was used in IPNI.
|
|
73
|
*
|
|
74
|
* @author m.doering
|
|
75
|
* @version 1.0
|
|
76
|
* @created 08-Nov-2007 13:06:27
|
|
77
|
*/
|
|
78
|
@XmlAccessorType(XmlAccessType.FIELD)
|
|
79
|
@XmlType(name = "IdentifiableEntity", propOrder = {
|
|
80
|
"lsid",
|
|
81
|
"titleCache",
|
|
82
|
"protectedTitleCache",
|
|
83
|
"rights",
|
|
84
|
"extensions",
|
|
85
|
"credits",
|
|
86
|
"sources"
|
|
87
|
})
|
|
88
|
@Audited
|
|
89
|
@MappedSuperclass
|
|
90
|
public abstract class IdentifiableEntity<S extends IIdentifiableEntityCacheStrategy> extends AnnotatableEntity
|
|
91
|
implements IIdentifiableEntity /*, ISourceable<IdentifiableSource> */ {
|
|
92
|
private static final long serialVersionUID = -5610995424730659058L;
|
|
93
|
private static final Logger logger = Logger.getLogger(IdentifiableEntity.class);
|
|
94
|
|
|
95
|
@XmlTransient
|
|
96
|
public static final boolean PROTECTED = true;
|
|
97
|
@XmlTransient
|
|
98
|
public static final boolean NOT_PROTECTED = false;
|
|
99
|
|
|
100
|
@XmlElement(name = "LSID", type = String.class)
|
|
101
|
@XmlJavaTypeAdapter(LSIDAdapter.class)
|
|
102
|
@Embedded
|
|
103
|
private LSID lsid;
|
|
104
|
|
|
105
|
@XmlElement(name = "TitleCache", required = true)
|
|
106
|
@XmlJavaTypeAdapter(FormattedTextAdapter.class)
|
|
107
|
@Column(length=255, name="titleCache")
|
|
108
|
@Match(value=MatchMode.CACHE, cacheReplaceMode=ReplaceMode.ALL)
|
|
109
|
@NotEmpty(groups = Level2.class) // implictly NotNull
|
|
110
|
@Size(max = 800) //see #1592
|
|
111
|
@Fields({
|
|
112
|
@Field(store=Store.YES),
|
|
113
|
@Field(name = "titleCache__sort", analyze = Analyze.NO, store=Store.YES)
|
|
114
|
})
|
|
115
|
@FieldBridge(impl=StripHtmlBridge.class)
|
|
116
|
protected String titleCache;
|
|
117
|
|
|
118
|
//if true titleCache will not be automatically generated/updated
|
|
119
|
@XmlElement(name = "ProtectedTitleCache")
|
|
120
|
protected boolean protectedTitleCache;
|
|
121
|
|
|
122
|
@XmlElementWrapper(name = "Rights", nillable = true)
|
|
123
|
@XmlElement(name = "Rights")
|
|
124
|
@OneToMany(fetch = FetchType.LAZY, orphanRemoval=true)
|
|
125
|
@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})
|
|
126
|
//TODO
|
|
127
|
@Merge(MergeMode.ADD_CLONE)
|
|
128
|
@NotNull
|
|
129
|
private Set<Rights> rights = new HashSet<Rights>();
|
|
130
|
|
|
131
|
@XmlElementWrapper(name = "Credits", nillable = true)
|
|
132
|
@XmlElement(name = "Credit")
|
|
133
|
@IndexColumn(name="sortIndex", base = 0)
|
|
134
|
@OneToMany(fetch = FetchType.LAZY, orphanRemoval=true)
|
|
135
|
@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})
|
|
136
|
//TODO
|
|
137
|
@Merge(MergeMode.ADD_CLONE)
|
|
138
|
@NotNull
|
|
139
|
private List<Credit> credits = new ArrayList<Credit>();
|
|
140
|
|
|
141
|
@XmlElementWrapper(name = "Extensions", nillable = true)
|
|
142
|
@XmlElement(name = "Extension")
|
|
143
|
@OneToMany(fetch = FetchType.LAZY, orphanRemoval=true)
|
|
144
|
@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})
|
|
145
|
@Merge(MergeMode.ADD_CLONE)
|
|
146
|
@NotNull
|
|
147
|
private Set<Extension> extensions = new HashSet<Extension>();
|
|
148
|
|
|
149
|
@XmlElementWrapper(name = "Sources", nillable = true)
|
|
150
|
@XmlElement(name = "IdentifiableSource")
|
|
151
|
@OneToMany(fetch = FetchType.LAZY, orphanRemoval=true)
|
|
152
|
@Cascade({CascadeType.SAVE_UPDATE, CascadeType.MERGE, CascadeType.DELETE})
|
|
153
|
@Merge(MergeMode.ADD_CLONE)
|
|
154
|
@NotNull
|
|
155
|
private Set<IdentifiableSource> sources = new HashSet<IdentifiableSource>();
|
|
156
|
|
|
157
|
@XmlTransient
|
|
158
|
@Transient
|
|
159
|
protected S cacheStrategy;
|
|
160
|
|
|
161
|
protected IdentifiableEntity(){
|
|
162
|
initListener();
|
|
163
|
}
|
|
164
|
|
|
165
|
protected void initListener(){
|
|
166
|
PropertyChangeListener listener = new PropertyChangeListener() {
|
|
167
|
@Override
|
|
168
|
public void propertyChange(PropertyChangeEvent e) {
|
|
169
|
if (!e.getPropertyName().equals("titleCache") && !e.getPropertyName().equals("cacheStrategy") && ! isProtectedTitleCache()){
|
|
170
|
titleCache = null;
|
|
171
|
}
|
|
172
|
}
|
|
173
|
};
|
|
174
|
addPropertyChangeListener(listener);
|
|
175
|
}
|
|
176
|
|
|
177
|
/**
|
|
178
|
* By default, we expect most cdm objects to be abstract things
|
|
179
|
* i.e. unable to return a data representation.
|
|
180
|
*
|
|
181
|
* Specific subclasses (e.g. Sequence) can override if necessary.
|
|
182
|
*/
|
|
183
|
@Override
|
|
184
|
public byte[] getData() {
|
|
185
|
return null;
|
|
186
|
}
|
|
187
|
|
|
188
|
//******************************** CACHE *****************************************************/
|
|
189
|
|
|
190
|
|
|
191
|
/* (non-Javadoc)
|
|
192
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getTitleCache()
|
|
193
|
*/
|
|
194
|
// @Transient - must not be transient, since this property needs to to be included in all serializations produced by the remote layer
|
|
195
|
@Override
|
|
196
|
public String getTitleCache(){
|
|
197
|
if (protectedTitleCache){
|
|
198
|
return this.titleCache;
|
|
199
|
}
|
|
200
|
// is title dirty, i.e. equal NULL?
|
|
201
|
if (titleCache == null){
|
|
202
|
this.titleCache = generateTitle();
|
|
203
|
this.titleCache = getTruncatedCache(this.titleCache) ;
|
|
204
|
}
|
|
205
|
return titleCache;
|
|
206
|
}
|
|
207
|
|
|
208
|
/**
|
|
209
|
* The titleCache will be regenerated from scratch if not protected
|
|
210
|
* @return <code>true</code> if title cache was regenerated, <code>false</code> otherwise
|
|
211
|
*/
|
|
212
|
protected boolean regenerateTitleCache() {
|
|
213
|
if (!protectedTitleCache) {
|
|
214
|
this.titleCache = null;
|
|
215
|
getTitleCache();
|
|
216
|
}
|
|
217
|
return protectedTitleCache;
|
|
218
|
}
|
|
219
|
/* (non-Javadoc)
|
|
220
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#setTitleCache(java.lang.String)
|
|
221
|
*/
|
|
222
|
@Override
|
|
223
|
public void setTitleCache(String titleCache){
|
|
224
|
this.titleCache = titleCache;
|
|
225
|
}
|
|
226
|
|
|
227
|
/* (non-Javadoc)
|
|
228
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#setTitleCache(java.lang.String, boolean)
|
|
229
|
*/
|
|
230
|
@Override
|
|
231
|
public void setTitleCache(String titleCache, boolean protectCache){
|
|
232
|
titleCache = getTruncatedCache(titleCache);
|
|
233
|
this.titleCache = titleCache;
|
|
234
|
this.protectedTitleCache = protectCache;
|
|
235
|
}
|
|
236
|
|
|
237
|
|
|
238
|
/**
|
|
239
|
* @param cache
|
|
240
|
* @return
|
|
241
|
*/
|
|
242
|
@Transient
|
|
243
|
protected String getTruncatedCache(String cache) {
|
|
244
|
if (cache != null && cache.length() > 1023){
|
|
245
|
logger.warn("Truncation of cache: " + this.toString() + "/" + cache);
|
|
246
|
cache = cache.substring(0, 1020) + "...";
|
|
247
|
}
|
|
248
|
return cache;
|
|
249
|
}
|
|
250
|
|
|
251
|
//**************************************************************************************
|
|
252
|
|
|
253
|
/* (non-Javadoc)
|
|
254
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getLsid()
|
|
255
|
*/
|
|
256
|
@Override
|
|
257
|
public LSID getLsid(){
|
|
258
|
return this.lsid;
|
|
259
|
}
|
|
260
|
/* (non-Javadoc)
|
|
261
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#setLsid(java.lang.String)
|
|
262
|
*/
|
|
263
|
@Override
|
|
264
|
public void setLsid(LSID lsid){
|
|
265
|
this.lsid = lsid;
|
|
266
|
}
|
|
267
|
/* (non-Javadoc)
|
|
268
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getRights()
|
|
269
|
*/
|
|
270
|
@Override
|
|
271
|
public Set<Rights> getRights() {
|
|
272
|
if(rights == null) {
|
|
273
|
this.rights = new HashSet<Rights>();
|
|
274
|
}
|
|
275
|
return this.rights;
|
|
276
|
}
|
|
277
|
|
|
278
|
/* (non-Javadoc)
|
|
279
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#addRights(eu.etaxonomy.cdm.model.media.Rights)
|
|
280
|
*/
|
|
281
|
@Override
|
|
282
|
public void addRights(Rights right){
|
|
283
|
getRights().add(right);
|
|
284
|
}
|
|
285
|
/* (non-Javadoc)
|
|
286
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#removeRights(eu.etaxonomy.cdm.model.media.Rights)
|
|
287
|
*/
|
|
288
|
@Override
|
|
289
|
public void removeRights(Rights right){
|
|
290
|
getRights().remove(right);
|
|
291
|
}
|
|
292
|
|
|
293
|
|
|
294
|
@Override
|
|
295
|
public List<Credit> getCredits() {
|
|
296
|
if(credits == null) {
|
|
297
|
this.credits = new ArrayList<Credit>();
|
|
298
|
}
|
|
299
|
return this.credits;
|
|
300
|
}
|
|
301
|
|
|
302
|
/* (non-Javadoc)
|
|
303
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getCredits(int)
|
|
304
|
*/
|
|
305
|
@Override
|
|
306
|
public Credit getCredits(Integer index){
|
|
307
|
return getCredits().get(index);
|
|
308
|
}
|
|
309
|
|
|
310
|
/* (non-Javadoc)
|
|
311
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#addCredit(eu.etaxonomy.cdm.model.common.Credit)
|
|
312
|
*/
|
|
313
|
@Override
|
|
314
|
public void addCredit(Credit credit){
|
|
315
|
getCredits().add(credit);
|
|
316
|
}
|
|
317
|
|
|
318
|
|
|
319
|
/* (non-Javadoc)
|
|
320
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#addCredit(eu.etaxonomy.cdm.model.common.Credit, int)
|
|
321
|
*/
|
|
322
|
@Override
|
|
323
|
public void addCredit(Credit credit, int index){
|
|
324
|
getCredits().add(index, credit);
|
|
325
|
}
|
|
326
|
|
|
327
|
/* (non-Javadoc)
|
|
328
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#removeCredit(eu.etaxonomy.cdm.model.common.Credit)
|
|
329
|
*/
|
|
330
|
@Override
|
|
331
|
public void removeCredit(Credit credit){
|
|
332
|
getCredits().remove(credit);
|
|
333
|
}
|
|
334
|
|
|
335
|
/* (non-Javadoc)
|
|
336
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#removeCredit(int)
|
|
337
|
*/
|
|
338
|
@Override
|
|
339
|
public void removeCredit(int index){
|
|
340
|
getCredits().remove(index);
|
|
341
|
}
|
|
342
|
|
|
343
|
|
|
344
|
/* (non-Javadoc)
|
|
345
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#getExtensions()
|
|
346
|
*/
|
|
347
|
@Override
|
|
348
|
public Set<Extension> getExtensions(){
|
|
349
|
if(extensions == null) {
|
|
350
|
this.extensions = new HashSet<Extension>();
|
|
351
|
}
|
|
352
|
return this.extensions;
|
|
353
|
}
|
|
354
|
/**
|
|
355
|
* @param type
|
|
356
|
* @return a Set of extension value strings
|
|
357
|
*/
|
|
358
|
public Set<String> getExtensions(ExtensionType type){
|
|
359
|
return getExtensions(type.getUuid());
|
|
360
|
}
|
|
361
|
/**
|
|
362
|
* @param extensionTypeUuid
|
|
363
|
* @return a Set of extension value strings
|
|
364
|
*/
|
|
365
|
public Set<String> getExtensions(UUID extensionTypeUuid){
|
|
366
|
Set<String> result = new HashSet<String>();
|
|
367
|
for (Extension extension : getExtensions()){
|
|
368
|
if (extension.getType().getUuid().equals(extensionTypeUuid)){
|
|
369
|
result.add(extension.getValue());
|
|
370
|
}
|
|
371
|
}
|
|
372
|
return result;
|
|
373
|
}
|
|
374
|
|
|
375
|
public void addExtension(String value, ExtensionType extensionType){
|
|
376
|
Extension.NewInstance(this, value, extensionType);
|
|
377
|
}
|
|
378
|
|
|
379
|
/* (non-Javadoc)
|
|
380
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#addExtension(eu.etaxonomy.cdm.model.common.Extension)
|
|
381
|
*/
|
|
382
|
@Override
|
|
383
|
public void addExtension(Extension extension){
|
|
384
|
if (extension != null){
|
|
385
|
extension.setExtendedObj(this);
|
|
386
|
getExtensions().add(extension);
|
|
387
|
}
|
|
388
|
}
|
|
389
|
/* (non-Javadoc)
|
|
390
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#removeExtension(eu.etaxonomy.cdm.model.common.Extension)
|
|
391
|
*/
|
|
392
|
@Override
|
|
393
|
public void removeExtension(Extension extension){
|
|
394
|
if (extension != null){
|
|
395
|
extension.setExtendedObj(null);
|
|
396
|
getExtensions().remove(extension);
|
|
397
|
}
|
|
398
|
}
|
|
399
|
|
|
400
|
|
|
401
|
/* (non-Javadoc)
|
|
402
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#isProtectedTitleCache()
|
|
403
|
*/
|
|
404
|
@Override
|
|
405
|
public boolean isProtectedTitleCache() {
|
|
406
|
return protectedTitleCache;
|
|
407
|
}
|
|
408
|
|
|
409
|
/* (non-Javadoc)
|
|
410
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#setProtectedTitleCache(boolean)
|
|
411
|
*/
|
|
412
|
@Override
|
|
413
|
public void setProtectedTitleCache(boolean protectedTitleCache) {
|
|
414
|
this.protectedTitleCache = protectedTitleCache;
|
|
415
|
}
|
|
416
|
|
|
417
|
/* (non-Javadoc)
|
|
418
|
* @see eu.etaxonomy.cdm.model.common.ISourceable#getSources()
|
|
419
|
*/
|
|
420
|
@Override
|
|
421
|
public Set<IdentifiableSource> getSources() {
|
|
422
|
if(sources == null) {
|
|
423
|
this.sources = new HashSet<IdentifiableSource>();
|
|
424
|
}
|
|
425
|
return this.sources;
|
|
426
|
}
|
|
427
|
|
|
428
|
/* (non-Javadoc)
|
|
429
|
* @see eu.etaxonomy.cdm.model.common.ISourceable#addSource(eu.etaxonomy.cdm.model.common.OriginalSourceBase)
|
|
430
|
*/
|
|
431
|
@Override
|
|
432
|
public void addSource(IdentifiableSource source) {
|
|
433
|
if (source != null){
|
|
434
|
IdentifiableEntity oldSourcedObj = source.getSourcedObj();
|
|
435
|
if (oldSourcedObj != null && oldSourcedObj != this){
|
|
436
|
oldSourcedObj.getSources().remove(source);
|
|
437
|
}
|
|
438
|
getSources().add(source);
|
|
439
|
source.setSourcedObj(this);
|
|
440
|
}
|
|
441
|
}
|
|
442
|
|
|
443
|
/* (non-Javadoc)
|
|
444
|
* @see eu.etaxonomy.cdm.model.common.ISourceable#addSource(java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)
|
|
445
|
*/
|
|
446
|
@Override
|
|
447
|
public IdentifiableSource addSource(OriginalSourceType type, String id, String idNamespace, Reference citation, String microCitation) {
|
|
448
|
if (id == null && idNamespace == null && citation == null && microCitation == null){
|
|
449
|
return null;
|
|
450
|
}
|
|
451
|
IdentifiableSource source = IdentifiableSource.NewInstance(type, id, idNamespace, citation, microCitation);
|
|
452
|
addSource(source);
|
|
453
|
return source;
|
|
454
|
}
|
|
455
|
|
|
456
|
|
|
457
|
/* (non-Javadoc)
|
|
458
|
* @see eu.etaxonomy.cdm.model.common.ISourceable#addImportSource(java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)
|
|
459
|
*/
|
|
460
|
@Override
|
|
461
|
public IdentifiableSource addImportSource(String id, String idNamespace, Reference<?> citation, String microCitation) {
|
|
462
|
if (id == null && idNamespace == null && citation == null && microCitation == null){
|
|
463
|
return null;
|
|
464
|
}
|
|
465
|
IdentifiableSource source = IdentifiableSource.NewInstance(OriginalSourceType.Import, id, idNamespace, citation, microCitation);
|
|
466
|
addSource(source);
|
|
467
|
return source;
|
|
468
|
}
|
|
469
|
|
|
470
|
/* (non-Javadoc)
|
|
471
|
* @see eu.etaxonomy.cdm.model.common.ISourceable#removeSource(eu.etaxonomy.cdm.model.common.IOriginalSource)
|
|
472
|
*/
|
|
473
|
@Override
|
|
474
|
public void removeSource(IdentifiableSource source) {
|
|
475
|
getSources().remove(source);
|
|
476
|
}
|
|
477
|
|
|
478
|
//******************************** TO STRING *****************************************************/
|
|
479
|
|
|
480
|
/* (non-Javadoc)
|
|
481
|
* @see eu.etaxonomy.cdm.model.common.IIdentifiableEntity#toString()
|
|
482
|
*/
|
|
483
|
@Override
|
|
484
|
public String toString() {
|
|
485
|
String result;
|
|
486
|
if (titleCache == null){
|
|
487
|
result = super.toString();
|
|
488
|
}else{
|
|
489
|
result = this.titleCache;
|
|
490
|
}
|
|
491
|
return result;
|
|
492
|
}
|
|
493
|
|
|
494
|
|
|
495
|
public int compareTo(IdentifiableEntity identifiableEntity) {
|
|
496
|
|
|
497
|
int result = 0;
|
|
498
|
|
|
499
|
if (identifiableEntity == null) {
|
|
500
|
throw new NullPointerException("Cannot compare to null.");
|
|
501
|
}
|
|
502
|
|
|
503
|
// First, compare the name cache.
|
|
504
|
// TODO: Avoid using instanceof operator
|
|
505
|
// Use Class.getDeclaredMethod() instead to find out whether class has getNameCache() method?
|
|
506
|
|
|
507
|
String specifiedNameCache = "";
|
|
508
|
String thisNameCache = "";
|
|
509
|
String specifiedTitleCache = "";
|
|
510
|
String thisTitleCache = "";
|
|
511
|
String specifiedReferenceTitleCache = "";
|
|
512
|
String thisReferenceTitleCache = "";
|
|
513
|
String thisGenusString = "";
|
|
514
|
String specifiedGenusString = "";
|
|
515
|
int thisrank_order = 0;
|
|
516
|
|
|
517
|
if(identifiableEntity instanceof NonViralName) {
|
|
518
|
specifiedNameCache = HibernateProxyHelper.deproxy(identifiableEntity, NonViralName.class).getNameCache();
|
|
519
|
specifiedTitleCache = identifiableEntity.getTitleCache();
|
|
520
|
|
|
521
|
} else if(identifiableEntity instanceof TaxonBase) {
|
|
522
|
TaxonBase taxonBase = HibernateProxyHelper.deproxy(identifiableEntity, TaxonBase.class);
|
|
523
|
|
|
524
|
TaxonNameBase<?,?> taxonNameBase = taxonBase.getName();
|
|
525
|
|
|
526
|
|
|
527
|
NonViralName nonViralName = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class);
|
|
528
|
specifiedNameCache = nonViralName.getNameCache();
|
|
529
|
specifiedTitleCache = taxonNameBase.getTitleCache();
|
|
530
|
|
|
531
|
specifiedReferenceTitleCache = ((TaxonBase)identifiableEntity).getSec().getTitleCache();
|
|
532
|
Reference reference = taxonBase.getSec();
|
|
533
|
if (reference != null) {
|
|
534
|
reference = HibernateProxyHelper.deproxy(reference, Reference.class);
|
|
535
|
specifiedReferenceTitleCache = reference.getTitleCache();
|
|
536
|
}
|
|
537
|
}
|
|
538
|
|
|
539
|
if(this instanceof NonViralName) {
|
|
540
|
thisNameCache = HibernateProxyHelper.deproxy(this, NonViralName.class).getNameCache();
|
|
541
|
thisTitleCache = getTitleCache();
|
|
542
|
} else if(this instanceof TaxonBase) {
|
|
543
|
TaxonNameBase<?,?> taxonNameBase= HibernateProxyHelper.deproxy(this, TaxonBase.class).getName();
|
|
544
|
NonViralName nonViralName = HibernateProxyHelper.deproxy(taxonNameBase, NonViralName.class);
|
|
545
|
thisNameCache = nonViralName.getNameCache();
|
|
546
|
thisTitleCache = taxonNameBase.getTitleCache();
|
|
547
|
thisReferenceTitleCache = getTitleCache();
|
|
548
|
thisGenusString = nonViralName.getGenusOrUninomial();
|
|
549
|
}
|
|
550
|
|
|
551
|
// Compare name cache of taxon names
|
|
552
|
|
|
553
|
if (!specifiedNameCache.equals("") && !thisNameCache.equals("")) {
|
|
554
|
result = thisNameCache.compareTo(specifiedNameCache);
|
|
555
|
}
|
|
556
|
|
|
557
|
// Compare title cache of taxon names
|
|
558
|
|
|
559
|
if ((result == 0) && (!specifiedTitleCache.equals("") || !thisTitleCache.equals(""))) {
|
|
560
|
result = thisTitleCache.compareTo(specifiedTitleCache);
|
|
561
|
}
|
|
562
|
|
|
563
|
// Compare title cache of taxon references
|
|
564
|
|
|
565
|
if ((result == 0) && (!specifiedReferenceTitleCache.equals("") || !thisReferenceTitleCache.equals(""))) {
|
|
566
|
result = thisReferenceTitleCache.compareTo(specifiedReferenceTitleCache);
|
|
567
|
}
|
|
568
|
|
|
569
|
return result;
|
|
570
|
}
|
|
571
|
|
|
572
|
/**
|
|
573
|
* Returns the {@link eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy cache strategy} used to generate
|
|
574
|
* several strings corresponding to <i>this</i> identifiable entity
|
|
575
|
* (in particular taxon name caches and author strings).
|
|
576
|
*
|
|
577
|
* @return the cache strategy used for <i>this</i> identifiable entity
|
|
578
|
* @see eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy
|
|
579
|
*/
|
|
580
|
public S getCacheStrategy() {
|
|
581
|
return this.cacheStrategy;
|
|
582
|
}
|
|
583
|
/**
|
|
584
|
* @see #getCacheStrategy()
|
|
585
|
*/
|
|
586
|
|
|
587
|
public void setCacheStrategy(S cacheStrategy) {
|
|
588
|
this.cacheStrategy = cacheStrategy;
|
|
589
|
}
|
|
590
|
|
|
591
|
@Override
|
|
592
|
public String generateTitle() {
|
|
593
|
if (cacheStrategy == null){
|
|
594
|
//logger.warn("No CacheStrategy defined for "+ this.getClass() + ": " + this.getUuid());
|
|
595
|
return this.getClass() + ": " + this.getUuid();
|
|
596
|
}else{
|
|
597
|
return cacheStrategy.getTitleCache(this);
|
|
598
|
}
|
|
599
|
}
|
|
600
|
|
|
601
|
//****************** CLONE ************************************************/
|
|
602
|
|
|
603
|
/* (non-Javadoc)
|
|
604
|
* @see eu.etaxonomy.cdm.model.common.AnnotatableEntity#clone()
|
|
605
|
*/
|
|
606
|
@Override
|
|
607
|
public Object clone() throws CloneNotSupportedException{
|
|
608
|
IdentifiableEntity result = (IdentifiableEntity)super.clone();
|
|
609
|
|
|
610
|
//Extensions
|
|
611
|
result.extensions = new HashSet<Extension>();
|
|
612
|
for (Extension extension : getExtensions() ){
|
|
613
|
Extension newExtension = (Extension)extension.clone();
|
|
614
|
result.addExtension(newExtension);
|
|
615
|
}
|
|
616
|
|
|
617
|
//OriginalSources
|
|
618
|
result.sources = new HashSet<IdentifiableSource>();
|
|
619
|
for (IdentifiableSource source : getSources()){
|
|
620
|
IdentifiableSource newSource = (IdentifiableSource)source.clone();
|
|
621
|
result.addSource(newSource);
|
|
622
|
}
|
|
623
|
|
|
624
|
//Rights
|
|
625
|
result.rights = new HashSet<Rights>();
|
|
626
|
for(Rights rights : getRights()) {
|
|
627
|
result.addRights(rights);
|
|
628
|
}
|
|
629
|
|
|
630
|
|
|
631
|
//Credits
|
|
632
|
result.credits = new ArrayList<Credit>();
|
|
633
|
for(Credit credit : getCredits()) {
|
|
634
|
result.addCredit(credit);
|
|
635
|
}
|
|
636
|
|
|
637
|
//no changes to: lsid, titleCache, protectedTitleCache
|
|
638
|
|
|
639
|
//empty titleCache
|
|
640
|
if (! protectedTitleCache){
|
|
641
|
result.titleCache = null;
|
|
642
|
}
|
|
643
|
|
|
644
|
result.initListener();
|
|
645
|
return result;
|
|
646
|
}
|
|
647
|
|
|
648
|
|
|
649
|
}
|