import eu.etaxonomy.cdm.io.common.mapping.out.IExportTransformer;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
*
TransactionStatus txStatus = startTransaction(true);
- FeatureTree featureTree = state.getConfig().getFeatureTree();
+ TermTree featureTree = state.getConfig().getFeatureTree();
featureTree = getFeatureTreeService().load(featureTree.getUuid());
TermTreeNode rootNode = featureTree.getRoot();
import eu.etaxonomy.cdm.database.ICdmDataSource;
import eu.etaxonomy.cdm.io.common.XmlExportConfiguratorBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(WordExportConfigurator.class);
- private FeatureTree featureTree;
+ private TermTree featureTree;
- private WordExportConfigurator(ICdmDataSource source, File destinationFolder, FeatureTree featureTree) {
+ private WordExportConfigurator(ICdmDataSource source, File destinationFolder, TermTree featureTree) {
super(destinationFolder, source, null);
this.featureTree = featureTree;
}
- public static WordExportConfigurator NewInstance(ICdmDataSource source, File destinationFolder, FeatureTree featureTree) {
+ public static WordExportConfigurator NewInstance(ICdmDataSource source, File destinationFolder, TermTree featureTree) {
return new WordExportConfigurator(source, destinationFolder, featureTree);
}
};
}
- public FeatureTree getFeatureTree() {
+ public TermTree getFeatureTree() {
return featureTree;
}
import eu.etaxonomy.cdm.model.reference.Reference;\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
public class CdmIDResolver extends IDResolver {\r
return resolveObject(uuid, targetType, vocabularyService);\r
} else if(DescriptionBase.class.isAssignableFrom(targetType)) {\r
return resolveObject(uuid, targetType, descriptionService);\r
- } else if(FeatureTree.class.isAssignableFrom(targetType)) {\r
+ } else if(TermTree.class.isAssignableFrom(targetType)) {\r
return resolveObject(uuid, targetType, featureTreeService);\r
} else if(Media.class.isAssignableFrom(targetType)) {\r
return resolveObject(uuid, targetType, mediaService);\r
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;\r
import eu.etaxonomy.cdm.model.term.DefinedTerm;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
\r
@XmlElementWrapper(name = "FeatureTrees")\r
@XmlElements({\r
- @XmlElement(name = "FeatureTree", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = FeatureTree.class)\r
+ @XmlElement(name = "FeatureTree", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TermTree.class)\r
})\r
- protected List<FeatureTree> featureTrees = new ArrayList<>();\r
+ protected List<TermTree> featureTrees = new ArrayList<>();\r
\r
@XmlElementWrapper(name = "PolytomousKeys")\r
@XmlElements({\r
this.references = value;\r
}\r
\r
- public List<FeatureTree> getFeatureTrees() {\r
+ public List<TermTree> getFeatureTrees() {\r
return featureTrees;\r
}\r
\r
return taxonNodes;\r
}\r
\r
- public void setFeatureTrees(List<FeatureTree> value) {\r
+ public void setFeatureTrees(List<TermTree> value) {\r
this.featureTrees = value;\r
}\r
\r
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
* @author a.babadshanjan
implements ICdmExport<JaxbExportConfigurator, JaxbExportState> {
private static final long serialVersionUID = -525533131708894145L;
-
private static final Logger logger = Logger.getLogger(JaxbExport.class);
private DataSet dataSet;
- /**
- *
- */
public JaxbExport() {
super();
}
}
commitTransaction(txStatus);
-
return;
-
}
public static void writeToFile(File file, DataSet dataSet) throws UnsupportedEncodingException, FileNotFoundException {
logger.info("# User");
List<User> users = getUserService().list(null, UserRows, 0, null, null);
-
for (User user: users){
dataSet.addUser(HibernateProxyHelper.deproxy(user));
}
-
}
if (jaxbExpConfig.isDoTermVocabularies() == true) {
if (termVocabularyRows == 0) { termVocabularyRows = MAX_ROWS; }
dataSet.setTermVocabularies((List)getVocabularyService().list(null,termVocabularyRows, 0, null, null));
}
-
-
// if (jaxbExpConfig.isDoLanguageData() == true) {
// if (languageDataRows == 0) { languageDataRows = MAX_ROWS; }
// logger.info("# Representation, Language String");
dataSet.setAgents(getAgentService().list(null,agentRows, 0,null,null));
}
-
-
if (jaxbExpConfig.getDoReferences() != IExportConfigurator.DO_REFERENCES.NONE) {
if (referenceBaseRows == 0) { referenceBaseRows = getReferenceService().count(Reference.class); }
logger.info("# Reference: " + referenceBaseRows);
dataSet.setTaxonomicNames(getNameService().list(null,taxonNameRows, 0,null,null));
}
-
-
if (jaxbExpConfig.isDoTaxa() == true) {
if (taxonBaseRows == 0) { taxonBaseRows = getTaxonService().count(TaxonBase.class); }
logger.info("# TaxonBase: " + taxonBaseRows);
dataSet.addTypeDesignations(getNameService().getAllTypeDesignations(MAX_ROWS, 0));
}
-
-
if (jaxbExpConfig.isDoMedia() == true) {
if (mediaRows == 0) { mediaRows = MAX_ROWS; }
logger.info("# Media");
if (jaxbExpConfig.isDoFeatureData() == true) {
if (featureDataRows == 0) { featureDataRows = MAX_ROWS; }
logger.info("# Feature Tree, Feature Node");
- List<FeatureTree> featureTrees = new ArrayList<FeatureTree>();
+ List<TermTree> featureTrees = new ArrayList<>();
featureTrees= getFeatureTreeService().list(null,featureDataRows, 0, null, null);
- List<FeatureTree> taxTreesdeproxy = new ArrayList<FeatureTree>();
- for (FeatureTree featureTree : featureTrees){
+ List<TermTree> taxTreesdeproxy = new ArrayList<>();
+ for (TermTree featureTree : featureTrees){
HibernateProxyHelper.deproxy(featureTree);
taxTreesdeproxy.add(featureTree);
}
-
dataSet.setFeatureTrees(getFeatureTreeService().list(null,null,null,null,null));
}
if (jaxbExpConfig.isDoClassificationData() == true) {
if (classificationDataRows == 0) { classificationDataRows = MAX_ROWS; }
logger.info("# Classification");
-
List<Classification> taxTrees = new ArrayList<Classification>();
taxTrees= getClassificationService().list(null,classificationDataRows, 0, null, null);
HibernateProxyHelper.deproxy(taxTree);
taxTreesdeproxy.add(taxTree);
}
- List<TaxonNode> taxNodes = new ArrayList<TaxonNode>();
+ List<TaxonNode> taxNodes = new ArrayList<>();
taxNodes= getClassificationService().getAllNodes();
- List<TaxonNode> taxNodesdeproxy = new ArrayList<TaxonNode>();
+ List<TaxonNode> taxNodesdeproxy = new ArrayList<>();
for (TaxonNode taxNode : taxNodes){
HibernateProxyHelper.deproxy(taxNode);
taxNodesdeproxy.add(taxNode);
dataSet.setLanguageStrings(null);
}
-
@Override
protected boolean doCheck(JaxbExportState state) {
boolean result = true;
return result;
}
-
@Override
protected boolean isIgnore(JaxbExportState state) {
return false;
}
-
-
-
}
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
/**\r
List<DescriptionBase> descriptions;\r
List<TypeDesignationBase<?>> typeDesignations;\r
List<SpecimenOrObservationBase> occurrences;\r
- List<FeatureTree> featureTrees;\r
+ List<TermTree> featureTrees;\r
List<TermTreeNode> featureNodes;\r
List<Media> media;\r
List<LanguageStringBase> languageData;\r
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.cdm.model.term.DefinedTerm;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
import eu.etaxonomy.cdm.model.term.Representation;\r
import eu.etaxonomy.cdm.model.term.TermBase;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
private Set<StatisticalMeasure> statisticalMeasures = new HashSet<>();\r
private Set<VersionableEntity> featureData = new HashSet<>();\r
- private Set<FeatureTree> featureTrees = new HashSet<>();\r
+ private Set<TermTree> featureTrees = new HashSet<>();\r
private Set<Classification> classifications = new HashSet<>();\r
\r
private final UUID uuidAnnotationTypeLocation = UUID.fromString("a3737e07-72e3-46d2-986d-fa4cf5de0b63");\r
getReferenceService().save(source);\r
}\r
\r
- for (FeatureTree featureTree : featureTrees) {\r
+ for (TermTree featureTree : featureTrees) {\r
getFeatureTreeService().save(featureTree);\r
}\r
getDescriptiveDataSetService().save(descriptiveDataSet);\r
String label = (String)ImportHelper.getXmlInputValue(elRepresentation,"Label",sddNamespace);\r
//Element elDesignedFor = elCharacterTree.getChild("DesignedFor",sddNamespace);//TODO ?\r
\r
- FeatureTree featureTree = FeatureTree.NewInstance();\r
+ TermTree featureTree = TermTree.NewInstance();\r
importRepresentation(elCharacterTree, sddNamespace, featureTree, "", cdmState);\r
TermTreeNode<Feature> root = featureTree.getRoot();\r
List<Element> listeOfNodes = elCharacterTree.getChildren("Nodes", sddNamespace);\r
import eu.etaxonomy.cdm.model.term.DefinedTerm;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.Representation;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
@XmlElementWrapper(name = "FeatureData")\r
@XmlElements({\r
@XmlElement(name = "FeatureNode", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TermTreeNode.class),\r
- @XmlElement(name = "FeatureTree", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = FeatureTree.class)\r
+ @XmlElement(name = "FeatureTree", namespace = "http://etaxonomy.eu/cdm/model/description/1.0", type = TermTree.class)\r
})\r
// protected List<VersionableEntity> featureData;\r
protected List<VersionableEntity> featureData;\r
import eu.etaxonomy.cdm.model.term.DefinedTerm;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.Representation;\r
import eu.etaxonomy.cdm.model.term.TermBase;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
for (int i = 0; i < cdmSource.getFeatureData().size(); i++) {\r
VersionableEntity featu = cdmSource.getFeatureData().get(i);\r
- if (featu instanceof FeatureTree) {\r
- FeatureTree ft = (FeatureTree) featu;\r
+ if (featu instanceof TermTree) {\r
+ TermTree ft = (TermTree) featu;\r
ElementImpl elChartree = new ElementImpl(document,\r
CHARACTER_TREE);\r
chartreeCount = buildReference(featu, featuretrees, ID,\r
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
private String treatmentMainName,originalTreatmentName;
- private final HashMap<String,Map<String,String>> namesMap = new HashMap<String, Map<String,String>>();
+ private final HashMap<String,Map<String,String>> namesMap = new HashMap<>();
private final Pattern keypattern = Pattern.compile("^(\\d+.*|-\\d+.*)");
@SuppressWarnings({ "rawtypes", "unused" })
protected void extractTreatment(Node treatmentnode, Reference refMods, URI sourceName) { logger.info("extractTreatment");
- List<TaxonName> namesToSave = new ArrayList<TaxonName>();
+ List<TaxonName> namesToSave = new ArrayList<>();
NodeList children = treatmentnode.getChildNodes();
Taxon acceptedTaxon =null;
boolean hasRefgroup=false;
*/
private void buildFeatureTree() {
logger.info("buildFeatureTree");
- FeatureTree proibiospheretree = importer.getFeatureTreeService().find(proIbioTreeUUID);
+ TermTree proibiospheretree = importer.getFeatureTreeService().find(proIbioTreeUUID);
if (proibiospheretree == null){
- List<FeatureTree> trees = importer.getFeatureTreeService().list(FeatureTree.class, null, null, null, null);
+ List<TermTree> trees = importer.getFeatureTreeService().list(TermTree.class, null, null, null, null);
if (trees.size()==1) {
- FeatureTree<Feature> ft = trees.get(0);
+ TermTree<Feature> ft = trees.get(0);
if (featuresMap==null) {
- featuresMap=new HashMap<String, Feature>();
+ featuresMap=new HashMap<>();
}
- for (Feature feature: ft.getDistinctFeatures()){
+ for (Feature feature: ft.getDistinctTerms()){
if(feature!=null) {
featuresMap.put(feature.getTitleCache(), feature);
}
}
}
- proibiospheretree = FeatureTree.NewInstance();
+ proibiospheretree = TermTree.NewInstance();
proibiospheretree.setUuid(proIbioTreeUUID);
}
logger.info("extractDistribution");
// logger.info("acceptedTaxon: "+acceptedTaxon);
NodeList children = distribution.getChildNodes();
- Map<Integer,List<MySpecimenOrObservation>> specimenOrObservations = new HashMap<Integer, List<MySpecimenOrObservation>>();
- Map<Integer,String> descriptionsFulltext = new HashMap<Integer,String>();
+ Map<Integer,List<MySpecimenOrObservation>> specimenOrObservations = new HashMap<>();
+ Map<Integer,String> descriptionsFulltext = new HashMap<>();
for (int i=0;i<children.getLength();i++){
if (children.item(i).getNodeName().equalsIgnoreCase("tax:p")){
* @param refMods: the current reference extracted from the MODS
* @param featureName: the feature name
*/
- @SuppressWarnings({ "unused", "rawtypes" })
+ @SuppressWarnings({ "unused"})
private String extractSpecificFeatureNotStructured(Node description, Taxon acceptedTaxon, Taxon defaultTaxon,
List<TaxonName> nameToSave, Reference refMods, String featureName ) {
logger.info("extractSpecificFeatureNotStructured " + featureName);
String fullName = "";
String newName="";
String identifier="";
- HashMap<String, String> atomisedMap = new HashMap<String, String>();
+ HashMap<String, String> atomisedMap = new HashMap<>();
List<String> atomisedName= new ArrayList<String>();
String rankStr = "";
String fullName = "";
String newName = "";
String identifier = "";
- HashMap<String, String> atomisedMap = new HashMap<String, String>();
- List<String> atomisedNameList= new ArrayList<String>();
+ HashMap<String, String> atomisedMap = new HashMap<>();
+ List<String> atomisedNameList= new ArrayList<>();
String status= extractStatus(children);
classification.addChildTaxon((Taxon)tmpTaxonBase, refMods, null);
}
} else{
- hierarchy = new HashMap<Rank, Taxon>();
+ hierarchy = new HashMap<>();
//System.out.println("LOOK FOR PARENT "+taxonname.toString()+", "+tmptaxonbase.toString());
if (!isSynonym){
lookForParentNode(taxonName,(Taxon)tmpTaxonBase, refMods,this);
return costs[s2.length()];
}
- Map<Rank, Taxon> hierarchy = new HashMap<Rank, Taxon>();
+ Map<Rank, Taxon> hierarchy = new HashMap<>();
/**
* @param taxonName
*/
\r
import eu.etaxonomy.cdm.model.description.Feature;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
\r
//@Ignore //does not work anymore since FeatureNode + Tree was moved to term package\r
public class FeatureTest {\r
URI uri = new URI(URIEncoder.encode(this.getClass().getResource(resource).toString()));\r
DataSet dataSet = cdmDocumentBuilder.unmarshal(DataSet.class, new InputStreamReader(this.getClass().getResourceAsStream(resource)),uri.toString());\r
\r
- FeatureTree<Feature> featureTree = dataSet.getFeatureTrees().get(0);\r
+ TermTree<Feature> featureTree = dataSet.getFeatureTrees().get(0);\r
Feature feature = (Feature)dataSet.getTerms().get(1);\r
\r
assertNotNull("FeatureTree must not be null", featureTree);\r
import eu.etaxonomy.cdm.io.descriptive.owl.out.StructureTreeOwlExportConfigurator;
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
}
public List<UUID> createFeatureTree() {
- FeatureTree tree = FeatureTree.NewInstance();
- TermVocabulary voc = TermVocabulary.NewInstance(TermType.Feature, "voc description", "vocabulary", "voc", URI.create("http://test.voc"));
+ TermTree<Feature> tree = TermTree.NewInstance();
+ TermVocabulary<Feature> voc = TermVocabulary.NewInstance(TermType.Feature, "voc description", "vocabulary", "voc", URI.create("http://test.voc"));
Feature featureA = Feature.NewInstance("A", "A", "A");
@MetaValue(value = "Synonym", targetEntity = Synonym.class),
@MetaValue(value = "Taxon", targetEntity = Taxon.class),
- @MetaValue(value = "FeatureTree", targetEntity = FeatureTree.class),
+ @MetaValue(value = "TermTree", targetEntity = TermTree.class),
@MetaValue(value = "PhylogeneticTree", targetEntity = PhylogeneticTree.class),
@MetaValue(value = "MediaSpecimen", targetEntity = MediaSpecimen.class),
@MetaValue(value = "TermVocabulary", targetEntity = TermVocabulary.class),
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.term.OrderedTerm;
import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;
import eu.etaxonomy.cdm.model.term.Representation;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.name.Rank;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.Representation;
import eu.etaxonomy.cdm.strategy.cache.description.DescriptiveDataSetDefaultCacheStrategy;
@XmlSchemaType(name = "IDREF")
@ManyToOne(fetch = FetchType.LAZY)
@Cascade({CascadeType.SAVE_UPDATE,CascadeType.MERGE})
- private FeatureTree<Character> descriptiveSystem;
+ private TermTree<Character> descriptiveSystem;
@XmlElementWrapper(name = "Descriptions")
@XmlElement(name = "Description")
}
}
- public FeatureTree<Character> getDescriptiveSystem() {
+ public TermTree<Character> getDescriptiveSystem() {
return descriptiveSystem;
}
- public void setDescriptiveSystem(FeatureTree<Character> descriptiveSystem) {
+ public void setDescriptiveSystem(TermTree<Character> descriptiveSystem) {
this.descriptiveSystem = descriptiveSystem;
}
import javax.xml.bind.annotation.XmlEnumValue;\r
\r
import eu.etaxonomy.cdm.model.common.Language;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
\r
/**\r
- * The role of the descriptive system of type {@link FeatureTree}.<BR>\r
+ * The role of the descriptive system of type {@link TermTree}.<BR>\r
* A descriptive systeme may play different roles within a working set. \r
* The roles may be \r
* <li>\r
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.Representation;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
* ("generalization of") features. "Kind of" / "generalization of" relations
* are bidirectional (a feature F1 is a "Kind of" a feature F2 if and only
* if the feature F2 is a "generalization of" the feature F1. This hierarchical
- * structure has nothing in common with {@link FeatureTree feature trees} used for determination.
+ * structure has nothing in common with {@link TermTree feature trees} used for determination.
* <P>
* A standard set of feature instances will be automatically
* created as the project starts. But this class allows to extend this standard
import org.hibernate.annotations.Type;
import org.hibernate.envers.Audited;
-import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.description.MediaKey;
-import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
/**
* The class to arrange {@link Feature features} (characters) in a tree structure.
* nothing in common with the possible hierarchical structure of features
* depending on their grade of precision.
*
- * @see MediaKey
- *
* @author m.doering
* @since 08-Nov-2007 13:06:16
*/
@XmlAccessorType(XmlAccessType.FIELD)
-@XmlType(name = "FeatureTree", propOrder = {
+@XmlType(name = "TermTree", propOrder = {
"root",
"termType",
"allowDuplicates",
"representations"
})
-@XmlRootElement(name = "FeatureTree")
+@XmlRootElement(name = "TermTree")
@Entity
//@Indexed disabled to reduce clutter in indexes, since this type is not used by any search
-//@Indexed(index = "eu.etaxonomy.cdm.model.term.FeatureTree")
+//@Indexed(index = "eu.etaxonomy.cdm.model.term.TermTree")
@Audited
-public class FeatureTree <T extends DefinedTermBase>
- extends IdentifiableEntity<IIdentifiableEntityCacheStrategy>
- implements IHasTermType, Cloneable{
+public class TermTree <T extends DefinedTermBase>
+ extends TermGraphBase<T, TermTreeNode> {
private static final long serialVersionUID = -6713834139003172735L;
- private static final Logger logger = Logger.getLogger(FeatureTree.class);
+ private static final Logger logger = Logger.getLogger(TermTree.class);
+
+
+ // TODO representations needed? FeatureTree was a TermBase until v3.3 but was removed from
+ //it as TermBase got the termType which does not apply to FeatureTree.
+ //We need to check how far representations and uri is still required
+ //or can be deleted. Current implementations seem all to use the title cache
+ //instead of representation. This may not be correct.
@XmlElement(name = "Root")
@OneToOne(fetch = FetchType.LAZY, targetEntity=TermTreeNode.class)
* with an empty {@link #getRoot() root node}.
* @param termType the {@link TermType term type}, must not be null
*/
- public static <T extends DefinedTermBase<T>> FeatureTree<T> NewInstance(@NotNull TermType termType){
- return new FeatureTree<>(termType);
+ public static <T extends DefinedTermBase<T>> TermTree<T> NewInstance(@NotNull TermType termType){
+ return new TermTree<>(termType);
}
/**
* @see #NewInstance(UUID)
* @see #NewInstance(List)
*/
- public static FeatureTree<Feature> NewInstance(){
- return new FeatureTree<>(TermType.Feature);
+ public static TermTree<Feature> NewInstance(){
+ return new TermTree<>(TermType.Feature);
}
/**
* @see #NewInstance()
* @see #NewInstance(List)
*/
- public static <T extends DefinedTermBase<T>> FeatureTree<T> NewInstance(UUID uuid){
- FeatureTree<T> result = new FeatureTree<>(TermType.Feature);
+ public static <T extends DefinedTermBase<T>> TermTree<T> NewInstance(UUID uuid){
+ TermTree<T> result = new TermTree<>(TermType.Feature);
result.setUuid(uuid);
return result;
}
* @see #NewInstance()
* @see #NewInstance(UUID)
*/
- public static FeatureTree<Feature> NewInstance(List<Feature> featureList){
- FeatureTree<Feature> result = new FeatureTree<>(TermType.Feature);
+ public static TermTree<Feature> NewInstance(List<Feature> featureList){
+ TermTree<Feature> result = new TermTree<>(TermType.Feature);
TermTreeNode<Feature> root = result.getRoot();
for (Feature feature : featureList){
//for JAXB only, TODO needed?
@Deprecated
- protected FeatureTree(){}
+ protected TermTree(){}
/**
* Class constructor: creates a new feature tree instance with an empty
* {@link #getRoot() root node}.
*/
- protected FeatureTree(TermType termType) {
+ protected TermTree(TermType termType) {
this.termType = termType;
checkTermType(this); //check not null
root = new TermTreeNode<>(termType);
}
/**
- * @deprecated this method is only for internal use when deleting a {@link FeatureTree}
+ * @deprecated this method is only for internal use when deleting a {@link TermTree}
* from a database. It should never be called for other reasons.
*/
@Deprecated
return result;
}
- public boolean isAllowDuplicates() {
- return allowDuplicates;
- }
- public void setAllowDuplicates(boolean allowDuplicates) {
- this.allowDuplicates = allowDuplicates;
- }
- /**
- * Throws {@link IllegalArgumentException} if the given
- * term has not the same term type as this term or if term type is null.
- * @param term
- */
- private void checkTermType(IHasTermType term) {
- IHasTermType.checkTermTypes(term, this);
- }
//******************** METHODS ***********************************************/
/**
- * Computes a set of distinct terms that are present in this feature tree
+ * Computes a set of distinct terms that are present in this term tree
*
* @return
*/
- @Transient
- public Set<T> getDistinctFeatures(){
+ @Override
+ @Transient
+ public Set<T> getDistinctTerms(){
Set<T> features = new HashSet<>();
- return root.getDistinctFeaturesRecursive(features);
+ return root.getDistinctTermsRecursive(features);
}
+ public List<T> asTermList() {
+ List<T> result = new ArrayList<>();
+ for (TermTreeNode<T> node : getRootChildren()){
+ result.add(node.getTerm());
+ result.addAll(node.asTermListRecursive(result));
+ }
+ return result;
+ }
+
//*********************** CLONE ********************************************************/
/**
- * Clones <i>this</i> {@link FeatureTree}. This is a shortcut that enables to create
+ * Clones <i>this</i> {@link TermTree}. This is a shortcut that enables to create
* a new instance that differs only slightly from <i>this</i> tree by
* modifying only some of the attributes.
* {@link TermTreeNode tree nodes} always belong only to one tree, so all
* {@link TermTreeNode tree nodes} are cloned to build
- * the new {@link FeatureTree}
+ * the new {@link TermTree}
*
*
* @see eu.etaxonomy.cdm.model.term.TermBase#clone()
*/
@Override
public Object clone() {
- FeatureTree<T> result;
+ TermTree<T> result;
try {
- result = (FeatureTree<T>)super.clone();
+ result = (TermTree<T>)super.clone();
}catch (CloneNotSupportedException e) {
logger.warn("Object does not implement cloneable");
e.printStackTrace();
import eu.etaxonomy.cdm.model.description.StatisticalMeasurementValue;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
* @author m.venin
private boolean merge=true; // if this boolean is set to true, branches of the tree will be merged if the corresponding states can be used together without decreasing their score
- private FeatureTree dependenciesTree; // the tree containing the dependencies between states and features (InapplicableIf and OnlyApplicableIf)
+ private TermTree dependenciesTree; // the tree containing the dependencies between states and features (InapplicableIf and OnlyApplicableIf)
private Map<State,Set<Feature>> iIdependencies = new HashMap<>(); // map of a set of Features (value) inapplicables if a State (key) is present
private Map<State,Set<Feature>> oAIdependencies = new HashMap<>(); // map of a set of Features (value) only applicables if a State (key) is present
private Map<Feature,Set<Feature>> featureDependencies = new HashMap<>(); // map of all the sets of features (values) which have dependencies with states of other features (keys)
*
* @param tree
*/
- public void setDependencies(FeatureTree tree){
+ public void setDependencies(TermTree tree){
this.dependenciesTree = tree;
}
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(FeatureTreeTest.class);
- private FeatureTree testTree;
- private TermTreeNode node1;
- private TermTreeNode node2;
- private TermTreeNode node3;
- private TermTreeNode node4;
+ private TermTree<Feature> testTree;
+ private TermTreeNode<Feature> node1;
+ private TermTreeNode<Feature> node2;
+ private TermTreeNode<Feature> node3;
+ private TermTreeNode<Feature> node4;
@BeforeClass
public static void setUpBeforeClass() {
*/
@Before
public void setUp() throws Exception {
- testTree = FeatureTree.NewInstance();
+ testTree = TermTree.NewInstance();
node1 = testTree.getRoot().addChild(Feature.ANATOMY());
node2 = node1.addChild(Feature.BIOLOGY_ECOLOGY());
public void testClone(){
TermTreeNode<Feature> node21 = node1.addChild(Feature.ADDITIONAL_PUBLICATION(), 1);
- FeatureTree clone = (FeatureTree) testTree.clone();
+ TermTree<Feature> clone = (TermTree<Feature>) testTree.clone();
+
assertEquals (clone.getRoot().getTerm(), testTree.getRoot().getTerm());
assertNotSame(clone.getRoot(), testTree.getRoot());
- List<TermTreeNode> children = clone.getRootChildren();
+ List<TermTreeNode<Feature>> children = clone.getRootChildren();
assertEquals(children.get(0).getTerm(), node1.getTerm());
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.term.Representation;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
import eu.etaxonomy.cdm.model.term.TermType;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
//Feature Tree
- FeatureTree<Feature> featureTree = FeatureTree.NewInstance();
+ TermTree<Feature> featureTree = TermTree.NewInstance();
// featureTree
TermTreeNode<Feature> descriptionFeatureNode = featureTree.getRoot().addChild(Feature.DESCRIPTION());
TermTreeNode<Feature> leaveLengthNode = descriptionFeatureNode.addChild(leaveLength);
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.OrderedTerm;
import eu.etaxonomy.cdm.model.term.OrderedTermBase;
import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;
DescriptionElementSource.class,
Distribution.class,
Feature.class,
- FeatureTree.class,
+ TermTree.class,
IndividualsAssociation.class,
MeasurementUnit.class,
MediaKey.class,
import java.util.UUID;\r
\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;\r
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
* @since 10.07.2008\r
* @version 1.0\r
*/\r
-public interface IFeatureTreeDao extends IIdentifiableDao<FeatureTree> {\r
- public List<FeatureTree> list();\r
+public interface IFeatureTreeDao extends IIdentifiableDao<TermTree> {\r
+ public List<TermTree> list();\r
\r
public UUID DefaultFeatureTreeUuid = UUID.fromString("ac8d4e58-926d-4f81-ac77-cebdd295df7c");\r
\r
*/\r
public void deepLoadNodes(List<TermTreeNode> nodes, List<String> nodePaths);\r
\r
- public <S extends FeatureTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
+ public <S extends TermTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
String pattern);\r
}\r
\r
import eu.etaxonomy.cdm.model.description.Feature;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
import eu.etaxonomy.cdm.model.term.VocabularyEnum;\r
* @version 1.0\r
*/\r
@Repository\r
-public class FeatureTreeDaoImpl extends IdentifiableDaoBase<FeatureTree> implements IFeatureTreeDao{\r
+public class FeatureTreeDaoImpl extends IdentifiableDaoBase<TermTree> implements IFeatureTreeDao{\r
@SuppressWarnings("unused")\r
private static final Logger logger = Logger.getLogger(FeatureTreeDaoImpl.class);\r
\r
private ITermVocabularyDao termVocabularyDao;\r
\r
public FeatureTreeDaoImpl() {\r
- super(FeatureTree.class);\r
+ super(TermTree.class);\r
indexedClasses = new Class[1];\r
- indexedClasses[0] = FeatureTree.class;\r
+ indexedClasses[0] = TermTree.class;\r
// indexedClasses[1] = PolytomousKey.class;\r
}\r
\r
@Override\r
- public List<FeatureTree> list() {\r
+ public List<TermTree> list() {\r
Criteria crit = getSession().createCriteria(type);\r
return crit.list();\r
}\r
}\r
\r
@Override\r
- public FeatureTree load(UUID uuid, List<String> propertyPaths) {\r
+ public TermTree load(UUID uuid, List<String> propertyPaths) {\r
if (uuid.equals(DefaultFeatureTreeUuid) || count() == 0){\r
return createDefaultFeatureTree();\r
}\r
}\r
\r
@Override\r
- public FeatureTree load(UUID uuid) {\r
+ public TermTree load(UUID uuid) {\r
if (uuid.equals(DefaultFeatureTreeUuid) || count() == 0){\r
return createDefaultFeatureTree();\r
}\r
/**\r
*\r
*/\r
- private FeatureTree createDefaultFeatureTree() {\r
+ private TermTree createDefaultFeatureTree() {\r
\r
TermVocabulary featureVocabulary = termVocabularyDao.findByUuid(VocabularyEnum.Feature.getUuid());\r
\r
selectedFeatures.add(feature);\r
}\r
}\r
- FeatureTree featureTree = FeatureTree.NewInstance(selectedFeatures);\r
+ TermTree featureTree = TermTree.NewInstance(selectedFeatures);\r
featureTree.setUuid(DefaultFeatureTreeUuid);\r
return featureTree;\r
}\r
\r
@Override\r
- public <S extends FeatureTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
+ public <S extends TermTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
String pattern) {\r
Session session = getSession();\r
Query query = session.createQuery(\r
import eu.etaxonomy.cdm.model.description.PolytomousKeyNode;
import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
* @author cmathew
}
- } else if(FeatureTree.class.isAssignableFrom(entityClazz)){
+ } else if(TermTree.class.isAssignableFrom(entityClazz)){
- FeatureTree<?> tree = (FeatureTree)entity;
+ TermTree<?> tree = (TermTree)entity;
for (TermTreeNode<?> node:tree.getRootChildren()){
node.removeNullValueFromChildren();
if (node.getChildNodes() != null){
<!-- Term Package -->
<mapping class="eu.etaxonomy.cdm.model.term.DefinedTerm"/>
<mapping class="eu.etaxonomy.cdm.model.term.DefinedTermBase"/>
- <mapping class="eu.etaxonomy.cdm.model.term.FeatureTree"/>
<mapping class="eu.etaxonomy.cdm.model.term.OrderedTerm"/>
<mapping class="eu.etaxonomy.cdm.model.term.OrderedTermBase"/>
<mapping class="eu.etaxonomy.cdm.model.term.OrderedTermVocabulary"/>
<mapping class="eu.etaxonomy.cdm.model.term.Representation"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermRelationshipType"/>
+ <mapping class="eu.etaxonomy.cdm.model.term.TermTree"/>
+ <mapping class="eu.etaxonomy.cdm.model.term.TermGraph"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermTreeNode"/>
+ <mapping class="eu.etaxonomy.cdm.model.term.TermRelation"/>
<mapping class="eu.etaxonomy.cdm.model.term.TermVocabulary"/>
<!-- Validation Package -->
import eu.etaxonomy.cdm.model.term.DefinedTerm;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.OrderedTermBase;
import eu.etaxonomy.cdm.model.term.OrderedTermVocabulary;
import eu.etaxonomy.cdm.model.term.Representation;
Distribution.class,
Feature.class,
TermTreeNode.class,
- FeatureTree.class,
+ TermTree.class,
MediaKey.class,
IndividualsAssociation.class,
MeasurementUnit.class,
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.location.NamedAreaLevel;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.remote.editor.DefinedTermBaseList;
import eu.etaxonomy.cdm.remote.editor.NamedAreaLevelPropertyEditor;
import eu.etaxonomy.cdm.remote.editor.TermBaseListPropertyEditor;
// will terminate thread
}
- FeatureTree featureTree = featureTreeService.load(featureTreeUuid, null);
+ TermTree featureTree = featureTreeService.load(featureTreeUuid, null);
if(featureTree == null){
HttpStatusMessage.UUID_NOT_FOUND.send(response);
// will terminate thread
import org.springframework.web.bind.annotation.RequestMapping;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import io.swagger.annotations.Api;
/**
@Controller
@Api("featureTree")
@RequestMapping(value = {"/featureTree/{uuid}"})
-public class FeatureTreeController extends AbstractIdentifiableController<FeatureTree, IFeatureTreeService> {
+public class FeatureTreeController extends AbstractIdentifiableController<TermTree, IFeatureTreeService> {
@SuppressWarnings("unused")
private static final Logger logger = Logger.getLogger(FeatureTreeController.class);
import org.springframework.web.bind.annotation.RequestMapping;
import eu.etaxonomy.cdm.api.service.IFeatureTreeService;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import io.swagger.annotations.Api;
/**
@Controller
@Api("featureTree")
@RequestMapping(value = {"/featureTree"})
-public class FeatureTreeListController extends AbstractIdentifiableListController<FeatureTree, IFeatureTreeService> {
+public class FeatureTreeListController extends AbstractIdentifiableListController<TermTree, IFeatureTreeService> {
@Override
@Autowired
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import io.swagger.annotations.Api;
/**
@Override
@RequestMapping(method = RequestMethod.GET)
- public FeatureTree doGet(@PathVariable("uuid") UUID uuid,
+ public TermTree doGet(@PathVariable("uuid") UUID uuid,
HttpServletRequest request,
HttpServletResponse response) throws IOException {
if(request != null) {
logger.info("doGet() " + request.getRequestURI());
}
- FeatureTree featureTree = null;
+ TermTree featureTree = null;
try {
featureTree = service.loadWithNodes(uuid, getInitializationStrategy(), featuretreeNodeInitStrategy);
} catch(EntityNotFoundException e){
import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionDao;
import eu.etaxonomy.cdm.persistence.dao.description.IDescriptionElementDao;
}
@Override
- public String generateNaturalLanguageDescription(FeatureTree featureTree,
+ public String generateNaturalLanguageDescription(TermTree featureTree,
TaxonDescription description, List<Language> preferredLanguages, String separator) {
Language lang = preferredLanguages.size() > 0 ? preferredLanguages.get(0) : Language.DEFAULT();
if(markerType!=null){
newTaxonDescription.addMarker(Marker.NewInstance(markerType, markerFlag));
}
- dataSet.getDescriptiveSystem().getDistinctFeatures().forEach(wsFeature->{
+ dataSet.getDescriptiveSystem().getDistinctTerms().forEach(wsFeature->{
if(wsFeature.isSupportsCategoricalData()){
newTaxonDescription.addElement(CategoricalData.NewInstance(wsFeature));
}
DescriptiveDataSet dataSet = load(descriptiveDataSetUuid);
SpecimenOrObservationBase specimen = occurrenceService.load(specimenUuid);
- Set<Character> datasetFeatures = dataSet.getDescriptiveSystem().getDistinctFeatures();
+ Set<Character> datasetFeatures = dataSet.getDescriptiveSystem().getDistinctTerms();
List<DescriptionElementBase> matchingDescriptionElements = new ArrayList<>();
for (SpecimenDescription specimenDescription : (Set<SpecimenDescription>) specimen.getDescriptions()) {
import eu.etaxonomy.cdm.model.common.CdmBase;
import eu.etaxonomy.cdm.model.description.Feature;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.dao.description.ITermTreeNodeDao;
if (ref instanceof TermTreeNode){
break;
}
- if (ref instanceof FeatureTree){
- FeatureTree refTree = HibernateProxyHelper.deproxy(ref, FeatureTree.class);
- if (node.getFeatureTree().equals((refTree))){
+ if (ref instanceof TermTree){
+ TermTree refTree = HibernateProxyHelper.deproxy(ref, TermTree.class);
+ if (node.getGraph().equals((refTree))){
break;
}
}
import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;\r
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.persistence.dao.description.ITermTreeNodeDao;\r
import eu.etaxonomy.cdm.persistence.dao.description.IFeatureTreeDao;\r
\r
@Service\r
@Transactional(readOnly = false)\r
-public class FeatureTreeServiceImpl extends IdentifiableServiceBase<FeatureTree, IFeatureTreeDao> implements IFeatureTreeService {\r
+public class FeatureTreeServiceImpl extends IdentifiableServiceBase<TermTree, IFeatureTreeDao> implements IFeatureTreeService {\r
\r
private ITermTreeNodeDao featureNodeDao;\r
\r
\r
@Override\r
@Transactional(readOnly = false)\r
- public UpdateResult updateCaches(Class<? extends FeatureTree> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<FeatureTree> cacheStrategy, IProgressMonitor monitor) {\r
+ public UpdateResult updateCaches(Class<? extends TermTree> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TermTree> cacheStrategy, IProgressMonitor monitor) {\r
if (clazz == null){\r
- clazz = FeatureTree.class;\r
+ clazz = TermTree.class;\r
}\r
return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor);\r
}\r
}\r
\r
@Override\r
- public FeatureTree loadWithNodes(UUID uuid, List<String> propertyPaths, List<String> nodePaths) {\r
+ public TermTree loadWithNodes(UUID uuid, List<String> propertyPaths, List<String> nodePaths) {\r
\r
if(nodePaths==null){\r
nodePaths = new ArrayList<>();\r
rootPaths.addAll(propertyPaths);\r
}\r
\r
- FeatureTree featureTree = load(uuid, rootPaths);\r
+ TermTree featureTree = load(uuid, rootPaths);\r
if(featureTree == null){\r
throw new EntityNotFoundException("No FeatureTree entity found for " + uuid);\r
}\r
* @see eu.etaxonomy.cdm.api.service.ServiceBase#load(java.util.UUID, java.util.List)\r
*/\r
@Override\r
- public FeatureTree load(UUID uuid, List<String> propertyPaths) {\r
+ public TermTree load(UUID uuid, List<String> propertyPaths) {\r
return super.load(uuid, propertyPaths);\r
}\r
\r
@Override\r
- public FeatureTree createTransientDefaultFeatureTree() {\r
+ public TermTree createTransientDefaultFeatureTree() {\r
return load(IFeatureTreeDao.DefaultFeatureTreeUuid);\r
}\r
\r
@Override\r
public DeleteResult delete(UUID featureTreeUuid){\r
DeleteResult result = new DeleteResult();\r
- FeatureTree tree = dao.load(featureTreeUuid);\r
+ TermTree tree = dao.load(featureTreeUuid);\r
\r
TermTreeNode rootNode = HibernateProxyHelper.deproxy(tree.getRoot());\r
FeatureNodeDeletionConfigurator config = new FeatureNodeDeletionConfigurator();\r
}\r
\r
@Override\r
- public <S extends FeatureTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
+ public <S extends TermTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
String pattern) {\r
return dao.getUuidAndTitleCacheByTermType(clazz, termType, limit, pattern);\r
}\r
import eu.etaxonomy.cdm.model.name.TaxonName;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.term.DefinedTerm;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.persistence.dao.initializer.IBeanInitializer;
import eu.etaxonomy.cdm.persistence.dto.MergeResult;
* @param separator
* @return
*/
- public String generateNaturalLanguageDescription(FeatureTree featureTree,TaxonDescription description, List<Language> preferredLanguages, String separator);
+ public String generateNaturalLanguageDescription(TermTree featureTree,TaxonDescription description, List<Language> preferredLanguages, String separator);
/**
* Preliminary method to test whether a description contains structured data.
import java.util.UUID;\r
\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermType;\r
import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;\r
\r
-public interface IFeatureTreeService extends IIdentifiableEntityService<FeatureTree> {\r
+public interface IFeatureTreeService extends IIdentifiableEntityService<TermTree> {\r
\r
public List<TermTreeNode> getFeatureNodesAll();\r
\r
* to initialize (e.g. feature).\r
*\r
*/\r
- public FeatureTree loadWithNodes(UUID uuid, List<String> propertyPaths, List<String> nodePaths);\r
+ public TermTree loadWithNodes(UUID uuid, List<String> propertyPaths, List<String> nodePaths);\r
\r
public Map<UUID, TermTreeNode> saveFeatureNodesAll(Collection<TermTreeNode> featureNodeCollection);\r
\r
public Map<UUID, TermTreeNode> saveOrUpdateFeatureNodesAll(Collection<TermTreeNode> featureNodeCollection);\r
\r
- public FeatureTree createTransientDefaultFeatureTree();\r
+ public TermTree createTransientDefaultFeatureTree();\r
\r
- public <S extends FeatureTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
+ public <S extends TermTree> List<UuidAndTitleCache<S>> getUuidAndTitleCacheByTermType(Class<S> clazz, TermType termType, Integer limit,\r
String pattern);\r
}\r
import eu.etaxonomy.cdm.model.common.Language;
import eu.etaxonomy.cdm.model.description.TaxonDescription;
import eu.etaxonomy.cdm.model.description.TextData;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
public interface INaturalLanguageGenerator {
- public List<TextData> generateNaturalLanguageDescription(FeatureTree featureTree, TaxonDescription descriptions);
+ public List<TextData> generateNaturalLanguageDescription(TermTree featureTree, TaxonDescription descriptions);
- public List<TextData> generateNaturalLanguageDescription(FeatureTree featureTree,TaxonDescription description, Language language);
+ public List<TextData> generateNaturalLanguageDescription(TermTree featureTree,TaxonDescription description, Language language);
- public List<TextData> generatePreferredNaturalLanguageDescription(FeatureTree featureTree, TaxonDescription description, List<Language> languages);
+ public List<TextData> generatePreferredNaturalLanguageDescription(TermTree featureTree, TaxonDescription description, List<Language> languages);
- public TextData generateSingleTextData(FeatureTree featureTree, TaxonDescription description);
+ public TextData generateSingleTextData(TermTree featureTree, TaxonDescription description);
- public TextData generateSingleTextData(FeatureTree featureTree, TaxonDescription description, Language language);
+ public TextData generateSingleTextData(TermTree featureTree, TaxonDescription description, Language language);
- public TextData generatePreferredSingleTextData(FeatureTree featureTree, TaxonDescription description, List<Language> languages);
+ public TextData generatePreferredSingleTextData(TermTree featureTree, TaxonDescription description, List<Language> languages);
}\r
import eu.etaxonomy.cdm.model.description.TextData;
import eu.etaxonomy.cdm.model.description.TextFormat;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
/**
* @return a list of TextData, each one being a basic element of the natural language description
*/
@Override
- public List<TextData> generateNaturalLanguageDescription(FeatureTree featureTree,TaxonDescription description) {
+ public List<TextData> generateNaturalLanguageDescription(TermTree featureTree,TaxonDescription description) {
return generateNaturalLanguageDescription(featureTree,description,Language.DEFAULT());
}
* @return a list of TextData, each one being a basic element of the natural language description
*/
@Override
- public List<TextData> generateNaturalLanguageDescription(FeatureTree featureTree, TaxonDescription description, Language language) {
+ public List<TextData> generateNaturalLanguageDescription(TermTree featureTree, TaxonDescription description, Language language) {
List<Language> languages = new ArrayList<Language>();
languages.add(language);
initNaturalLanguageDescriptionElementProcessors(description.getAnnotations());
* @return a list of TextData, each one being a basic element of the natural language description
*/
@Override
- public List<TextData> generatePreferredNaturalLanguageDescription(FeatureTree featureTree,TaxonDescription description, List<Language> languages) {
+ public List<TextData> generatePreferredNaturalLanguageDescription(TermTree featureTree,TaxonDescription description, List<Language> languages) {
initNaturalLanguageDescriptionElementProcessors(description.getAnnotations());
return buildBranchesDescr(featureTree.getRootChildren(), featureTree.getRoot(), description, languages,0);
}
* @return a TextData in the default language.
*/
@Override
- public TextData generateSingleTextData(FeatureTree featureTree, TaxonDescription description) {
+ public TextData generateSingleTextData(TermTree featureTree, TaxonDescription description) {
return generateSingleTextData(featureTree,description,Language.DEFAULT());
}
* @return a TextData in the specified language.
*/
@Override
- public TextData generateSingleTextData(FeatureTree featureTree, TaxonDescription description, Language language) {
+ public TextData generateSingleTextData(TermTree featureTree, TaxonDescription description, Language language) {
List<Language> languages = new ArrayList<Language>();
languages.add(language);
return generatePreferredSingleTextData(featureTree,description,languages);
* @return a TextData using the languages (in the given order of preference)
*/
@Override
- public TextData generatePreferredSingleTextData(FeatureTree featureTree, TaxonDescription description, List<Language> languages) {
+ public TextData generatePreferredSingleTextData(TermTree featureTree, TaxonDescription description, List<Language> languages) {
levels.clear(); // before the start, the table containing the levels of each node must be cleared
// Note: this is not the most efficient way to keep track of the levels of the nodes but it allows some flexibility
List<TextData> texts = generatePreferredNaturalLanguageDescription(featureTree,description, languages);// first get the description as a raw list of TextData
import eu.etaxonomy.cdm.model.taxon.Classification;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
import eu.etaxonomy.cdm.model.term.TermBase;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
return handleClassList(list, monitor);
}else if (clazz.isAssignableFrom(TermBase.class)){
@SuppressWarnings("rawtypes")
- List list = Arrays.asList(new Class[]{DefinedTermBase.class, FeatureTree.class, TermVocabulary.class });
+ List list = Arrays.asList(new Class[]{DefinedTermBase.class, TermTree.class, TermVocabulary.class });
return handleClassList(list, monitor);
}else{
return null;
try {
//TermBase
if (DefinedTermBase.class.isAssignableFrom(clazz)){
-
result.includeResult(termService.updateCaches((Class) clazz, null, null, subMonitor));
- }else if (FeatureTree.class.isAssignableFrom(clazz)){
+ }else if (TermTree.class.isAssignableFrom(clazz)){
result.includeResult(featureTreeService.updateCaches((Class) clazz, null, null, subMonitor));
}else if (TermVocabulary.class.isAssignableFrom(clazz)){
result.includeResult(vocabularyService.updateCaches((Class) clazz, null, null, subMonitor));
import eu.etaxonomy.cdm.model.taxon.Classification;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
import eu.etaxonomy.cdm.model.term.DefinedTermBase;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermVocabulary;
import eu.etaxonomy.cdm.strategy.cache.taxon.TaxonBaseShortSecCacheStrategy;
//TermBase
if (DefinedTermBase.class.isAssignableFrom(clazz)){
termService.updateCaches((Class) clazz, null, null, null);
- }else if (FeatureTree.class.isAssignableFrom(clazz)){
+ }else if (TermTree.class.isAssignableFrom(clazz)){
featureTreeService.updateCaches((Class) clazz, null, null, null);
}else if (TermVocabulary.class.isAssignableFrom(clazz)){
vocabularyService.updateCaches((Class) clazz, null, null, null);
import eu.etaxonomy.cdm.model.taxon.TaxonNode;\r
import eu.etaxonomy.cdm.model.term.DefinedTermBase;\r
import eu.etaxonomy.cdm.model.term.TermTreeNode;\r
-import eu.etaxonomy.cdm.model.term.FeatureTree;\r
+import eu.etaxonomy.cdm.model.term.TermTree;\r
import eu.etaxonomy.cdm.model.term.TermVocabulary;\r
\r
/**\r
// services.add(new EntityValidationUnit(OriginalSourceBase.class, appConfig.getCommonService()));\r
services.add(new EntityValidationUnit(DescriptionBase.class, appConfig.getDescriptionService()));\r
services.add(new EntityValidationUnit(TermTreeNode.class, appConfig.getFeatureNodeService()));\r
- services.add(new EntityValidationUnit(FeatureTree.class, appConfig.getFeatureTreeService()));\r
+ services.add(new EntityValidationUnit(TermTree.class, appConfig.getFeatureTreeService()));\r
services.add(new EntityValidationUnit(Group.class, appConfig.getGroupService()));\r
// Causes some AOP-related error when calling list() method on it\r
//services.add(new EntityValidationUnit(DefinedTermBase.class, appConfig.getLocationService()));\r
import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;
import eu.etaxonomy.cdm.model.common.ITreeNode;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
import eu.etaxonomy.cdm.test.integration.CdmTransactionalIntegrationTest;
@Test
public final void testIndexCreatRoot() {
- FeatureTree<Feature> featureTree = FeatureTree.NewInstance();
+ TermTree<Feature> featureTree = TermTree.NewInstance();
featureTreeService.save(featureTree);
Feature feature = (Feature)termService.find(914);
@DataSet(value="FeatureNodeServiceImplTest-indexing.xml")
public final void testIndexMoveNode() {
//in feature tree
- FeatureTree<Feature> featureTree = featureTreeService.load(featureTreeUuid);
+ TermTree<Feature> featureTree = featureTreeService.load(featureTreeUuid);
node2 = featureNodeService.load(node2Uuid);
node3 = featureNodeService.load(node3Uuid);
node3.addChild(node2);
Assert.assertEquals("Node6 treeindex is not correct", node3.treeIndex() + "2#4#6#", node6.treeIndex());
//root of new feature tree
- FeatureTree<Feature> featureTree2 = featureTreeService.load(featureTree2Uuid);
+ TermTree<Feature> featureTree2 = featureTreeService.load(featureTree2Uuid);
node2 = featureNodeService.load(node2Uuid);
featureTree2.getRoot().addChild(node2);
featureNodeService.saveOrUpdate(node2);
config.setChildHandling(ChildHandling.MOVE_TO_PARENT);
DeleteResult result = featureNodeService.deleteFeatureNode(node2Uuid, config);
commitAndStartNewTransaction(new String[]{"TaxonNode"});
- FeatureTree tree1 = featureTreeService.load(featureTreeUuid);
+ TermTree tree1 = featureTreeService.load(featureTreeUuid);
assertNotNull(tree1);
node2 = featureNodeService.load(node2Uuid);
assertNull(node2);
TermTreeNode node6 = featureNodeService.load(node6Uuid);
assertNull(node6);
- HibernateProxyHelper.deproxy(tree1, FeatureTree.class);
+ HibernateProxyHelper.deproxy(tree1, TermTree.class);
TermTreeNode rootNode = HibernateProxyHelper.deproxy(tree1.getRoot(), TermTreeNode.class);
assertNotNull(tree1);
featureTreeService.delete(tree1.getUuid());
import eu.etaxonomy.cdm.model.name.INonViralName;
import eu.etaxonomy.cdm.model.name.TaxonNameFactory;
import eu.etaxonomy.cdm.model.taxon.Taxon;
-import eu.etaxonomy.cdm.model.term.FeatureTree;
+import eu.etaxonomy.cdm.model.term.TermTree;
import eu.etaxonomy.cdm.model.term.TermTreeNode;
import eu.etaxonomy.cdm.test.integration.CdmIntegrationTest;
@SpringBeanByType
private INaturalLanguageGenerator generator;
- private FeatureTree featureTree;
+ private TermTree featureTree;
private TaxonDescription description;
Set<Feature> featureSet = new HashSet<Feature>();
Taxon taxon = Taxon.NewInstance(tnb, null);
description = TaxonDescription.NewInstance(taxon);
- featureTree= FeatureTree.NewInstance();
+ featureTree= TermTree.NewInstance();
TermTreeNode root = featureTree.getRoot();
String[][][] tableStrings = { { {"a","b"} } , { { "a1" , "a2" } , { "b1" } } };
buildBranches(root,tableStrings,0,2,0);
DatabaseTypeEnum dbType = DatabaseTypeEnum.MySQL;
-
String database = (schema == DbSchemaValidation.VALIDATE ? "cdm50" : "cdm55");
CdmDataSource dataSource = getDatasource(dbType, database);
-
try {
// int n = dataSource.executeUpdate("UPDATE CdmMetaData SET value = '3.1.0.0.201607300000' WHERE propertyname = 0 ");
CdmUpdater updater = new CdmUpdater();
BGBM BDI Projects / cdmlib.git / commitdiff