fr.univnantes.termsuite.framework.service

Class TerminologyService

java.lang.Object

fr.univnantes.termsuite.framework.service.TerminologyService

public class TerminologyService
extends java.lang.Object

Constructor Summary

Constructors

Constructor and Description
TerminologyService(Terminology termino)

Method Summary

Modifier and Type	Method and Description
void	addRelation(Relation termVariation)
void	addRelations(java.util.Set<Relation> relations)
void	addTerm(Term term)
void	addWord(Word word)
RelationService	asRelationService(Relation relation)
TermService	asTermService(Term term)
void	cleanOrphanWords()
TerminologyService	cloneTerminology()
boolean	containsTerm(java.lang.String gKey)
boolean	containsWord(java.lang.String lemma)
RelationService	createVariation(VariationType variationType, Term from, Term to)
java.util.stream.Stream<RelationService>	extensionBases(Term term)
java.util.stream.Stream<RelationService>	extensions()
java.util.stream.Stream<RelationService>	extensions(Term from)
java.util.stream.Stream<RelationService>	extensions(Term from, Term to)
java.util.Optional<TermService>	findBiggestPrefix(java.util.List<TermWord> words) Finds in a Terminology the biggest prefix of a sequence of TermWords that exists as a term.
java.util.Optional<TermService>	findBiggestSuffix(java.util.List<TermWord> words) Finds in a Terminology the biggest suffix of a sequence of TermWords that exists as a term.
java.util.Optional<TermService>	getExtensionAffix(Term base, Term extension) Finds in a Terminology the biggest extension affix term of a term depending on a base term.
Lang	getLang()
java.util.Optional<RelationService>	getRelation(Term from, RelationType type, Term to)
RelationService	getRelationOrCreate(Term from, RelationType type, Term to)
java.util.stream.Stream<Relation>	getRelations(Term from, Term to, RelationType type, RelationType... types)
java.util.Optional<TermService>	getSwt(TermWord tw)
TermService	getTerm(java.lang.String termKey)
java.util.Collection<TermService>	getTerms()
java.util.List<TermService>	getTerms(TermOrdering ordering)
TermService	getTermUnchecked(java.lang.String termKey)
java.util.Optional<RelationService>	getVariation(Term from, Term to)
Word	getWord(java.lang.String lemma)
long	getWordAnnotationsNum()
java.util.Collection<Word>	getWords()
java.util.stream.Stream<RelationService>	inboundRelations(Term target)
java.util.stream.Stream<RelationService>	inboundRelations(Term target, RelationType rType, RelationType... relationTypes)
void	incrementSpottedTermsNum(int nbSpottedTerms)
void	incrementWordAnnotationNum(int nbWordAnnotations)
java.util.stream.Stream<RelationService>	outboundRelations(Term source)
java.util.stream.Stream<RelationService>	outboundRelations(Term source, RelationType rType, RelationType... relationTypes)
java.util.stream.Stream<RelationService>	relations()
java.util.stream.Stream<RelationService>	relations(RelationProperty property, java.lang.Object value)
java.util.stream.Stream<RelationService>	relations(RelationType type, RelationType... types)
java.util.stream.Stream<RelationService>	relations(Term from, Term to)
void	removeAll(java.util.function.Predicate<Term> predicate)
void	removeRelation(Relation relation)
void	removeRelation(RelationService variation)
void	removeRelations(java.util.Collection<Relation> relations)
void	removeTerm(Term t)
void	removeTerm(TermService t)
void	removeTerms(java.util.Collection<Term> terms)
long	termCount()
java.util.stream.Stream<TermService>	terms()
java.util.stream.Stream<TermService>	terms(java.util.Comparator<Term> comparator)
java.util.stream.Stream<TermService>	terms(TermOrdering termOrdering)
static java.util.Comparator<TermService>	toTermServiceComparator(java.util.Comparator<Term> comparator)
java.util.stream.Stream<RelationService>	variations()
java.util.stream.Stream<RelationService>	variations(java.lang.String fromKey, java.lang.String toKey)
java.util.stream.Stream<RelationService>	variations(Term from, Term to)
java.util.stream.Stream<RelationService>	variations(VariationType type)
java.util.stream.Stream<RelationService>	variationsFrom(Term from)
java.util.stream.Stream<RelationService>	variationsTo(Term to)
int	wordCount()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

TerminologyService

public TerminologyService(Terminology termino)

Method Detail

getRelationOrCreate

public RelationService getRelationOrCreate(Term from,
                                           RelationType type,
                                           Term to)

getRelation

public java.util.Optional<RelationService> getRelation(Term from,
                                                       RelationType type,
                                                       Term to)

getRelations

public java.util.stream.Stream<Relation> getRelations(Term from,
                                                      Term to,
                                                      RelationType type,
                                                      RelationType... types)

relations

public java.util.stream.Stream<RelationService> relations()

variations

public java.util.stream.Stream<RelationService> variations()

variations

public java.util.stream.Stream<RelationService> variations(VariationType type)

relations

public java.util.stream.Stream<RelationService> relations(RelationType type,
                                                          RelationType... types)

getTerms

public java.util.Collection<TermService> getTerms()

terms

public java.util.stream.Stream<TermService> terms()

asTermService

public TermService asTermService(Term term)

asRelationService

public RelationService asRelationService(Relation relation)

relations

public java.util.stream.Stream<RelationService> relations(Term from,
                                                          Term to)

inboundRelations

public java.util.stream.Stream<RelationService> inboundRelations(Term target)

inboundRelations

public java.util.stream.Stream<RelationService> inboundRelations(Term target,
                                                                 RelationType rType,
                                                                 RelationType... relationTypes)

outboundRelations

public java.util.stream.Stream<RelationService> outboundRelations(Term source)

outboundRelations

public java.util.stream.Stream<RelationService> outboundRelations(Term source,
                                                                  RelationType rType,
                                                                  RelationType... relationTypes)

variations

public java.util.stream.Stream<RelationService> variations(Term from,
                                                           Term to)

getVariation

public java.util.Optional<RelationService> getVariation(Term from,
                                                        Term to)

createVariation

public RelationService createVariation(VariationType variationType,
                                       Term from,
                                       Term to)

relations

public java.util.stream.Stream<RelationService> relations(RelationProperty property,
                                                          java.lang.Object value)

variations

public java.util.stream.Stream<RelationService> variations(java.lang.String fromKey,
                                                           java.lang.String toKey)

getTerm

public TermService getTerm(java.lang.String termKey)

getTermUnchecked

public TermService getTermUnchecked(java.lang.String termKey)

variationsFrom

public java.util.stream.Stream<RelationService> variationsFrom(Term from)

variationsTo

public java.util.stream.Stream<RelationService> variationsTo(Term to)

removeAll

public void removeAll(java.util.function.Predicate<Term> predicate)

termCount

public long termCount()

extensions

public java.util.stream.Stream<RelationService> extensions()

extensionBases

public java.util.stream.Stream<RelationService> extensionBases(Term term)

getWord

public Word getWord(java.lang.String lemma)

extensions

public java.util.stream.Stream<RelationService> extensions(Term from)

getWordAnnotationsNum

public long getWordAnnotationsNum()

containsWord

public boolean containsWord(java.lang.String lemma)

wordCount

public int wordCount()

getWords

public java.util.Collection<Word> getWords()

extensions

public java.util.stream.Stream<RelationService> extensions(Term from,
                                                           Term to)

getLang

public Lang getLang()

containsTerm

public boolean containsTerm(java.lang.String gKey)

addTerm

public void addTerm(Term term)

addWord

public void addWord(Word word)

cleanOrphanWords

public void cleanOrphanWords()

removeTerm

public void removeTerm(TermService t)

removeTerm

public void removeTerm(Term t)

removeTerms

public void removeTerms(java.util.Collection<Term> terms)

incrementWordAnnotationNum

public void incrementWordAnnotationNum(int nbWordAnnotations)

incrementSpottedTermsNum

public void incrementSpottedTermsNum(int nbSpottedTerms)

addRelation

public void addRelation(Relation termVariation)

removeRelation

public void removeRelation(RelationService variation)

removeRelations

public void removeRelations(java.util.Collection<Relation> relations)

removeRelation

public void removeRelation(Relation relation)

getTerms

public java.util.List<TermService> getTerms(TermOrdering ordering)

toTermServiceComparator

public static java.util.Comparator<TermService> toTermServiceComparator(java.util.Comparator<Term> comparator)

terms

public java.util.stream.Stream<TermService> terms(java.util.Comparator<Term> comparator)

terms

public java.util.stream.Stream<TermService> terms(TermOrdering termOrdering)

getExtensionAffix

public java.util.Optional<TermService> getExtensionAffix(Term base,
                                                         Term extension)

Finds in a Terminology the biggest extension affix term of a term depending on a base term. For example, the term "offshore wind turbine" is an extension of "wind turbine". The extension affix is the term "offshore".

Parameters:

base - The base term

extension - The extension term

Returns:

the extension affix found in termino, null if none has been found.

Throws:

java.lang.IllegalArgumentException - if extension id not an extension of the term base.

findBiggestPrefix

public java.util.Optional<TermService> findBiggestPrefix(java.util.List<TermWord> words)

Finds in a Terminology the biggest prefix of a sequence of TermWords that exists as a term.

Parameters:

words - the initial sequence of TermWords

Returns:

A Term found in termino that makes the biggest possible prefix sequence for words.

findBiggestSuffix

public java.util.Optional<TermService> findBiggestSuffix(java.util.List<TermWord> words)

Finds in a Terminology the biggest suffix of a sequence of TermWords that exists as a term.

Parameters:

words - the initial sequence of TermWords

Returns:

A Term found in termino that makes the biggest possible suffix sequence for words.

getSwt

public java.util.Optional<TermService> getSwt(TermWord tw)

addRelations

public void addRelations(java.util.Set<Relation> relations)

cloneTerminology

public TerminologyService cloneTerminology()