Modifier and Type | Method and Description |
---|---|
Alignment |
Procalign.run(java.lang.String[] args) |
Modifier and Type | Method and Description |
---|---|
void |
GroupAggreg.print(Alignment al,
java.lang.String outputfilename)
Print the aggregated alignment, it is not void...
|
Modifier and Type | Field and Description |
---|---|
(package private) Alignment |
LCell.alignment |
private Alignment |
TestGenerator.resultAlignment |
Modifier and Type | Method and Description |
---|---|
(package private) Alignment |
LCell.getAlignment() |
Alignment |
Alterator.getAlignment() |
Modifier and Type | Method and Description |
---|---|
private void |
TestGenerator.outputTestDirectory(org.apache.jena.ontology.OntModel onto,
Alignment align,
java.lang.String dirName) |
Constructor and Description |
---|
LCell(Cell c,
Alignment al) |
Modifier and Type | Field and Description |
---|---|
protected Alignment |
BasicAlterator.extractedAlignment |
Modifier and Type | Method and Description |
---|---|
Alignment |
BasicAlterator.extractAlignment(java.lang.String base1,
java.lang.String base2) |
Alignment |
BasicAlterator.getAlignment() |
Modifier and Type | Class and Description |
---|---|
class |
BasicAlignment
Represents a basic ontology alignment, i.e., a fully functionnal alignment
for wich the type of aligned objects is not known.
|
class |
DistanceAlignment
The mother class for distance or similarity-based alignments.
|
class |
ObjectAlignment
Represents an OWL ontology alignment.
|
class |
URIAlignment
Represents an ontology alignment relating entities identified by their URIs
|
Modifier and Type | Field and Description |
---|---|
protected Alignment |
BasicEvaluator.align1 |
protected Alignment |
BasicEvaluator.align2 |
Modifier and Type | Field and Description |
---|---|
protected java.util.HashSet<Alignment> |
BasicOntologyNetwork.alignments |
protected java.util.HashMap<java.net.URI,java.util.Map<java.net.URI,java.util.Set<Alignment>>> |
BasicOntologyNetwork.onto2Align |
java.util.HashSet<Alignment> |
OntologyTriple.sourceAlignments |
java.util.HashSet<Alignment> |
OntologyTriple.targettingAlignments |
Modifier and Type | Method and Description |
---|---|
static Alignment |
BasicAlignment.aggregate(java.lang.String modality,
java.util.Set<BasicAlignment> aligns)
Aggregating several alignments with aggregator modality applied on confidence
For any set (o, o', n, r) in O and (o, o', n', r) in O' the resulting
alignment will contain:
( o, o', aggr(n,n'), r)
any pair which is in only one alignment is preserved.
|
Alignment |
BasicAlignment.compose(Alignment align)
The second alignment is composed with the first one meaning that for
any pair (o, o', n, r) in O and (o',o", n', r') in O' the resulting
alignment will contain:
( o, o", join(n,n'), compose(r, r')) iff compose(r,r') exists.
|
Alignment |
BasicAlignment.diff(Alignment align)
The second alignment is suppresed from the first one meaning that for
any pair (o, o', n, r) in O and (o, o', n', r) in O' the resulting
alignment will contain:
( o, o', diff(n,n'), r)
any pair which is only in the first alignment is preserved.
|
Alignment |
DistanceAlignment.extract(java.lang.String type,
java.util.Properties params)
Extract the alignment form the Similarity
|
Alignment |
DistanceAlignment.extractqq(double threshold,
java.util.Properties params)
Extract the alignment of a ?? type
exact algorithm using the Hungarian method.
|
Alignment |
DistanceAlignment.extractqqgreedy(double threshold,
java.util.Properties params)
Greedy algorithm:
1) dump the part of the matrix distance above threshold in a sorted set
2) traverse the sorted set and each time a correspondence involving two
entities that have no correspondence is encountered, add it to the
alignment.
|
Alignment |
DistanceAlignment.extractqs(double threshold,
java.util.Properties params) |
Alignment |
DistanceAlignment.extractsq(double threshold,
java.util.Properties params)
Extract the alignment of a ?* type
Non symmetric: for each entity of onto1, take the highest if superior to threshold
Complexity: O(n^2)
|
Alignment |
DistanceAlignment.extractss(double threshold,
java.util.Properties params)
Extract the alignment of a ** type
Symmetric: return all elements above threshold
Complexity: O(n^2)
|
static Alignment |
BasicOntologyNetwork.getQuasiNormalizedAlignment(OntologyNetwork on,
java.net.URI onto1,
java.net.URI onto2)
Only one alignment between onto1 and onto2, rassembling all those existing and all their inverse
The two ontologies must belong to the network otherwise they should be failure (Exception, null??)
What is missing is the transitive closure...
|
Alignment |
BasicAlignment.join(Alignment align)
The second alignment is join with the first one meaning that for
any pair (e, e', n, r) in A and (e, e', n', r) in A' the resulting
alignment will contain:
( e, e', join(n,n'), r)
any pair which is in only one alignment is preserved.
|
Alignment |
BasicAlignment.meet(Alignment align)
The second alignment is meet with the first one meaning that for
any pair (e, e', n, r) in A and (e, e', n', r) in A' the resulting
alignment will contain:
( e, e', meet(n,n'), r)
any pair which is in only one alignment is discarded.
|
protected static Alignment |
BasicOntologyNetwork.normalizeAlignmentSet(java.util.Set<Alignment> als,
Ontology<java.lang.Object> onto1,
Ontology<java.lang.Object> onto2)
Merge all alignments between the same ontology as one (conjunction)
Create a new alignment...
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<Alignment> |
BasicOntologyNetwork.getAlignments() |
protected java.util.Set<Alignment> |
BasicOntologyNetwork.getAlignments(OntologyTriple srcTriple,
OntologyTriple dstTriple) |
java.util.Set<Alignment> |
BasicOntologyNetwork.getAlignments(java.net.URI srcOnto,
java.net.URI dstOnto) |
java.util.Set<Alignment> |
BasicOntologyNetwork.getSourceAlignments(java.net.URI onto) |
java.util.Set<Alignment> |
BasicOntologyNetwork.getTargetingAlignments(java.net.URI onto) |
protected static java.util.Set<Alignment> |
BasicOntologyNetwork.intersectAlignments(java.util.Set<Alignment> s1,
java.util.Set<Alignment> s2) |
Modifier and Type | Method and Description |
---|---|
void |
BasicOntologyNetwork.addAlignment(Alignment al) |
void |
DistanceAlignment.align(Alignment alignment,
java.util.Properties params)
Process matching
- create distance data structures,
- compute distance or similarity
- extract alignment
|
Alignment |
BasicAlignment.compose(Alignment align)
The second alignment is composed with the first one meaning that for
any pair (o, o', n, r) in O and (o',o", n', r') in O' the resulting
alignment will contain:
( o, o", join(n,n'), compose(r, r')) iff compose(r,r') exists.
|
boolean |
BasicAlignment.contains(Alignment align)
Each cell of @align is contained in this alignment
no semantics (a semantic predicate would be entails).
|
ObjectAlignment |
BasicEvaluator.convertToObjectAlignment(Alignment al) |
void |
BasicEvaluator.convertToObjectAlignments(Alignment al1,
Alignment al2) |
Alignment |
BasicAlignment.diff(Alignment align)
The second alignment is suppresed from the first one meaning that for
any pair (o, o', n, r) in O and (o, o', n', r) in O' the resulting
alignment will contain:
( o, o', diff(n,n'), r)
any pair which is only in the first alignment is preserved.
|
boolean |
BasicAlignment.equals(Alignment align) |
java.net.URI |
URICell.getObject1AsURI(Alignment al) |
java.net.URI |
ObjectCell.getObject1AsURI(Alignment al) |
java.net.URI |
BasicCell.getObject1AsURI(Alignment al) |
java.net.URI |
URICell.getObject2AsURI(Alignment al) |
java.net.URI |
ObjectCell.getObject2AsURI(Alignment al) |
java.net.URI |
BasicCell.getObject2AsURI(Alignment al) |
void |
BasicAlignment.ingest(Alignment alignment)
Incorporate the cells of the alignment into its own alignment.
|
void |
Similarity.initialize(LoadedOntology<java.lang.Object> onto1,
LoadedOntology<java.lang.Object> onto2,
Alignment align) |
void |
MatrixMeasure.initialize(LoadedOntology<java.lang.Object> onto1,
LoadedOntology<java.lang.Object> onto2,
Alignment align) |
void |
InstanceBasedMatrixMeasure.initialize(LoadedOntology<java.lang.Object> onto1,
LoadedOntology<java.lang.Object> onto2,
Alignment align) |
boolean |
IDDLOntologyNetwork.isEntailed(Alignment al) |
Alignment |
BasicAlignment.join(Alignment align)
The second alignment is join with the first one meaning that for
any pair (e, e', n, r) in A and (e, e', n', r) in A' the resulting
alignment will contain:
( e, e', join(n,n'), r)
any pair which is in only one alignment is preserved.
|
void |
ObjectAlignment.loadInit(Alignment al) |
Alignment |
BasicAlignment.meet(Alignment align)
The second alignment is meet with the first one meaning that for
any pair (e, e', n, r) in A and (e, e', n', r) in A' the resulting
alignment will contain:
( e, e', meet(n,n'), r)
any pair which is in only one alignment is discarded.
|
protected void |
BasicOntologyNetwork.mergeAlignments(OntologyTriple ot1,
OntologyTriple ot2,
Alignment newal)
This only works on normalised networks (and returns a normalised network)
Combine all alignments into one (add an alignment to those existing merging everything)
|
void |
BasicOntologyNetwork.remAlignment(Alignment al) |
Modifier and Type | Method and Description |
---|---|
protected static java.util.Set<Alignment> |
BasicOntologyNetwork.intersectAlignments(java.util.Set<Alignment> s1,
java.util.Set<Alignment> s2) |
protected static java.util.Set<Alignment> |
BasicOntologyNetwork.intersectAlignments(java.util.Set<Alignment> s1,
java.util.Set<Alignment> s2) |
protected static Alignment |
BasicOntologyNetwork.normalizeAlignmentSet(java.util.Set<Alignment> als,
Ontology<java.lang.Object> onto1,
Ontology<java.lang.Object> onto2)
Merge all alignments between the same ontology as one (conjunction)
Create a new alignment...
|
Constructor and Description |
---|
BasicEvaluator(Alignment align1,
Alignment align2)
Creation
Creates an evaluator
|
Modifier and Type | Class and Description |
---|---|
class |
AverageAggregator |
class |
BasicAggregator |
class |
ConsensusAggregator |
Modifier and Type | Class and Description |
---|---|
class |
EDOALAlignment
An alignment between complex expressions built from the elements of two ontologies
It may make more sense to extend ObjectAlignment,
but EDOAL does not require the ontologies to be loaded.
|
Modifier and Type | Method and Description |
---|---|
java.net.URI |
EDOALCell.getObject1AsURI(Alignment al) |
java.net.URI |
EDOALCell.getObject2AsURI(Alignment al) |
void |
EDOALAlignment.loadInit(Alignment al) |
Modifier and Type | Method and Description |
---|---|
protected double |
ExtPREvaluator.computeEffSimilarity(Cell c1,
Alignment s2)
Effort-based relaxed precision and recal similarity
Note: it will be better if the parameters were replaced by the actual sibling (choice)
Table 3 of [Ehrig2005]
|
protected double |
ExtPREvaluator.computePrecisionOrientedSimilarity(Cell c1,
Alignment s2)
Oriented relaxed precision and recal similarity
Table 4 (and 5) of [Ehrig and Euzenat 2005]
|
protected double |
ExtPREvaluator.computeRecallOrientedSimilarity(Cell c1,
Alignment s2)
Oriented relaxed precision and recal similarity
Table 6 (and 7) of [Ehrig and Euzenat 2005]
|
protected double |
ExtPREvaluator.computeSymSimilarity(Cell c1,
Alignment s2)
Symmetric relaxed precision and recal similarity
This computes similarity depending on structural measures:
the similarity is symALPHA^(val1+val2), symALPHA being lower than 1.
|
void |
AveragePRGraphEvaluator.evalAlignment(Alignment align1,
Alignment align2) |
void |
GraphEvaluator.ingest(Alignment al,
Alignment ref)
Integrate the cells of the alignment to evaluate in cellSet if the cell is found in the reference alignment
|
void |
AveragePRGraphEvaluator.ingest(Alignment al,
Alignment reference) |
boolean |
GraphEvaluator.isCorrect(Cell c,
Alignment ref)
Tells if the cell is found in the reference alignment
(without relation consideration)
|
Constructor and Description |
---|
DiffEvaluator(Alignment align1,
Alignment align2)
Creation
Initiate Evaluator for precision and recall
|
ExtPREvaluator(Alignment align1,
Alignment align2)
Creation
|
PRecEvaluator(Alignment align1,
Alignment align2)
Creation
Initiate Evaluator for precision and recall
|
SemPRecEvaluator(Alignment al1,
Alignment al2)
Creation
Initiate Evaluator for precision and recall
|
SymMeanEvaluator(Alignment align1,
Alignment align2)
Creation
|
WeightedPREvaluator(Alignment align1,
Alignment align2)
Creation
Initiate Evaluator for precision and recall
|
Modifier and Type | Class and Description |
---|---|
class |
ClassStructAlignment
Establishes an alignment based on the comparison of the properties
that classes have in common.
|
class |
EditDistNameAlignment
This class aligns ontology with regard to the editing distance between
class names.
|
class |
NameAndPropertyAlignment
This class has been built for ISWC experiments with bibliography.
|
class |
NameEqAlignment
Matches two oontologies based on the equality of the name of their entities.
|
class |
SMOANameAlignment
This class aligns ontology with regard to the editing distance between
class names.
|
class |
StringDistAlignment
Represents an OWL ontology alignment.
|
class |
StrucSubsDistAlignment
This class has been built for ISWC experiments with bibliography.
|
class |
SubsDistNameAlignment
This class implements alignment based on substring distance
of class and property labels
THIS CLASS IS ONLY HERE FOR COMPATIBILITY PURPOSES
|
Modifier and Type | Method and Description |
---|---|
void |
StrucSubsDistAlignment.align(Alignment alignment,
java.util.Properties params)
Processing
|
void |
StringDistAlignment.align(Alignment alignment,
java.util.Properties params)
Processing
|
void |
NameAndPropertyAlignment.align(Alignment alignment,
java.util.Properties params)
Processing
|
void |
ClassStructAlignment.align(Alignment alignment,
java.util.Properties params)
Processing
|
Modifier and Type | Field and Description |
---|---|
(package private) Alignment |
XSLTRendererVisitor.alignment |
(package private) Alignment |
XMLMetadataRendererVisitor.alignment |
(package private) Alignment |
SWRLRendererVisitor.alignment |
(package private) Alignment |
SPARQLSelectRendererVisitor.alignment |
(package private) Alignment |
SPARQLLinkkerRendererVisitor.alignment |
(package private) Alignment |
SPARQLConstructRendererVisitor.alignment |
(package private) Alignment |
SKOSRendererVisitor.alignment |
(package private) Alignment |
SILKRendererVisitor.alignment |
(package private) Alignment |
SEKTMappingRendererVisitor.alignment |
(package private) Alignment |
RDFRendererVisitor.alignment |
(package private) Alignment |
OWLAxiomsRendererVisitor.alignment |
(package private) Alignment |
JSONRendererVisitor.alignment |
(package private) Alignment |
HTMLMetadataRendererVisitor.alignment |
(package private) Alignment |
GraphPatternRendererVisitor.alignment |
(package private) Alignment |
CSVRendererVisitor.alignment |
(package private) Alignment |
COWLMappingRendererVisitor.alignment |
Modifier and Type | Method and Description |
---|---|
protected void |
HTMLMetadataRendererVisitor.printAlignmentMetadata(Alignment align) |
protected void |
HTMLMetadataRendererVisitor.printHeaders(Alignment align) |
void |
XSLTRendererVisitor.visit(Alignment align) |
void |
XMLMetadataRendererVisitor.visit(Alignment align) |
void |
SWRLRendererVisitor.visit(Alignment align) |
void |
SPARQLSelectRendererVisitor.visit(Alignment align) |
void |
SPARQLLinkkerRendererVisitor.visit(Alignment align) |
void |
SPARQLConstructRendererVisitor.visit(Alignment align) |
void |
SKOSRendererVisitor.visit(Alignment align) |
void |
SILKRendererVisitor.visit(Alignment align) |
void |
SEKTMappingRendererVisitor.visit(Alignment align) |
void |
RDFRendererVisitor.visit(Alignment align) |
void |
OWLAxiomsRendererVisitor.visit(Alignment align) |
void |
JSONRendererVisitor.visit(Alignment align) |
void |
HTMLRendererVisitor.visit(Alignment align) |
void |
HTMLMetadataRendererVisitor.visit(Alignment align) |
void |
CSVRendererVisitor.visit(Alignment align) |
void |
COWLMappingRendererVisitor.visit(Alignment align) |
Modifier and Type | Class and Description |
---|---|
class |
JWNLAlignment
This Class uses JWNLDistances to align two ontologies.
|
Modifier and Type | Method and Description |
---|---|
void |
JWNLAlignment.align(Alignment alignment,
java.util.Properties prop)
Processing
|
Modifier and Type | Field and Description |
---|---|
protected Alignment |
AlignmentParser.alignment
the alignment that is parsed
We always create a URIAlignment (we could also use a BasicAlignment).
|
Modifier and Type | Method and Description |
---|---|
private Alignment |
AlignmentParser.callParser(java.lang.Object o)
Parses the document given in parameter
If the current process has links (import or include) to others documents then they are
parsed.
|
private Alignment |
AlignmentParser.callParser(RDFParser p,
java.lang.Object o) |
private Alignment |
AlignmentParser.callParser(XMLParser p,
java.lang.Object o)
This dispatch is ridiculous, but that's life
|
Alignment |
XMLParser.parse(java.io.InputStream s)
Parses a string instead of a URI
|
Alignment |
AlignmentParser.parse(java.io.InputStream s)
Parses an inputStream
|
Alignment |
XMLParser.parse(java.io.Reader r)
Parses a reader, used for reading from a string
|
Alignment |
AlignmentParser.parse(java.io.Reader r)
Parses a the content of a reader
|
Alignment |
XMLParser.parse(java.lang.String uri)
Parses the document corresponding to the URI given in parameter
If the current process has links (import or include) to others documents then they are
parsed.
|
Alignment |
AlignmentParser.parse(java.lang.String uri)
Parses a URI expressed as a String
|
Alignment |
AlignmentParser.parse(java.lang.String uri,
java.util.Hashtable<?,?> loaded)
Deprecated.
use parse( URI ) instead
|
Alignment |
AlignmentParser.parse(java.net.URI uri)
Parses a URI
|
Alignment |
AlignmentParser.parseString(java.lang.String s)
Parses the content of a string
|
Modifier and Type | Class and Description |
---|---|
class |
WSAlignment
This is an AlignmentProcess which perform matching by connecting
to an AlignmentServer and retrieving or computing an alignment.
|
Modifier and Type | Field and Description |
---|---|
private java.util.Hashtable<java.lang.String,Alignment> |
VolatilCache.alignmentTable |
protected java.util.Hashtable<java.lang.String,Alignment> |
VolatilCache.alignmentURITable |
private java.util.Hashtable<java.net.URI,java.util.Set<Alignment>> |
VolatilCache.ontologyTable |
Modifier and Type | Method and Description |
---|---|
protected Alignment |
VolatilCache.fetchAlignment(java.lang.String uri,
Alignment result) |
protected Alignment |
SQLCache.fetchAlignment(java.lang.String uri,
Alignment result)
retrieve full alignment from id (and cache it)
|
Alignment |
VolatilCache.getAlignment(java.lang.String uri)
retrieve full alignment from id (and cache it)
|
Alignment |
Cache.getAlignment(java.lang.String uri)
retrieve full alignment from id (and cache it)
|
Alignment |
VolatilCache.getMetadata(java.lang.String uri)
retrieve alignment metadata from id
This is more difficult because we return the alignment we have
disreagarding if it is complete o only metadata
|
Alignment |
Cache.getMetadata(java.lang.String uri)
retrieve alignment metadata from id
This is more difficult because we return the alignment we have
disreagarding if it is complete o only metadata
|
protected Alignment |
SQLCache.retrieveAlignment(java.lang.String uri,
Alignment alignment)
loads the full alignment from the database and put it in the
alignmentTable hastable
should be invoked when:
( result.getExtension(CACHED) == ""
AND result.getExtension(STORED) != "") {
|
protected Alignment |
SQLCache.retrieveDescription(java.lang.String id)
loads the description of alignments from the database and set them
in an alignment object
|
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Alignment> |
VolatilCache.alignments() |
java.util.Collection<Alignment> |
Cache.alignments() |
java.util.Collection<Alignment> |
AServProtocolManager.alignments() |
java.util.Collection<Alignment> |
VolatilCache.alignments(java.net.URI u1,
java.net.URI u2) |
java.util.Collection<Alignment> |
Cache.alignments(java.net.URI u1,
java.net.URI u2) |
java.util.Collection<Alignment> |
AServProtocolManager.alignments(java.net.URI uri1,
java.net.URI uri2) |
java.util.Set<Alignment> |
VolatilCache.getAlignmentByURI(java.lang.String uri)
Find alignments by URI
|
java.util.Set<Alignment> |
Cache.getAlignmentByURI(java.lang.String uri)
retrieve full alignment from URI or description
|
java.util.Set<Alignment> |
VolatilCache.getAlignments(java.net.URI uri)
Find alignments by ontology URIs
|
java.util.Set<Alignment> |
Cache.getAlignments(java.net.URI uri) |
java.util.Set<Alignment> |
VolatilCache.getAlignments(java.net.URI uri1,
java.net.URI uri2)
returns the alignments between two ontologies
if one of the ontologies is null, then return them all
|
java.util.Set<Alignment> |
Cache.getAlignments(java.net.URI uri1,
java.net.URI uri2)
returns the alignments between two ontologies
if one of the ontologies is null, then return them all
|
java.util.Set<Alignment> |
VolatilCache.getAlignmentsByDescription(java.lang.String desc)
Find alignments by pretty
TODO: NOT IMPLEMENTED YET
|
java.util.Set<Alignment> |
Cache.getAlignmentsByDescription(java.lang.String desc) |
protected java.util.Enumeration<Alignment> |
VolatilCache.listAlignments() |
Modifier and Type | Method and Description |
---|---|
void |
WSAlignment.align(Alignment alignment,
java.util.Properties params)
Process matching
This does not work with regular AServ web service because it returns an URL
|
protected Alignment |
VolatilCache.fetchAlignment(java.lang.String uri,
Alignment result) |
protected Alignment |
SQLCache.fetchAlignment(java.lang.String uri,
Alignment result)
retrieve full alignment from id (and cache it)
|
protected void |
VolatilCache.flushAlignment(Alignment alignment)
unload the cells of an alignment...
|
boolean |
VolatilCache.isAlignmentStored(Alignment alignment) |
boolean |
Cache.isAlignmentStored(Alignment alignment) |
java.lang.String |
VolatilCache.recordAlignment(java.lang.String uri,
Alignment alignment,
boolean force)
records alignment identified by id
force will register the new alignment even if it is already registered
|
java.lang.String |
VolatilCache.recordNewAlignment(Alignment alignment,
boolean force)
records newly created alignment
|
java.lang.String |
Cache.recordNewAlignment(Alignment alignment,
boolean force)
records newly created alignment and returns its idenfifier
|
java.lang.String |
VolatilCache.recordNewAlignment(java.lang.String uri,
Alignment al,
boolean force)
records alignment identified by id
|
java.lang.String |
Cache.recordNewAlignment(java.lang.String uri,
Alignment al,
boolean force)
records alignment identified by id and returns its idenfifier
|
void |
OysterDirectory.register(Alignment al)
Register an alignment to the directory (if necessary)
|
void |
Directory.register(Alignment al)
Register an alignment to the directory (if necessary)
|
void |
VolatilCache.resetCacheStamp(Alignment al) |
protected Alignment |
SQLCache.retrieveAlignment(java.lang.String uri,
Alignment alignment)
loads the full alignment from the database and put it in the
alignmentTable hastable
should be invoked when:
( result.getExtension(CACHED) == ""
AND result.getExtension(STORED) != "") {
|
boolean |
AServProtocolManager.storedAlignment(Alignment al) |
void |
VolatilCache.unRecordAlignment(Alignment alignment)
suppresses the record for an alignment
|
void |
OysterDirectory.unregister(Alignment al)
unregister an alignment from the directory (if necessary)
This is not implemented
|
void |
Directory.unregister(Alignment al)
Unregister an alignment to the directory (if necessary)
|
void |
VolatilCache.unstoreAlignment(java.lang.String uri,
Alignment alignment) |
void |
SQLCache.unstoreAlignment(java.lang.String uri,
Alignment alignment) |
void |
SQLCache.unstoreEDOALAlignment(java.lang.String id,
Alignment alignment) |
Modifier and Type | Method and Description |
---|---|
java.util.Collection<Alignment> |
Service.alignments() |
java.util.Collection<Alignment> |
Service.alignments(java.net.URI uri1,
java.net.URI uri2) |
Modifier and Type | Method and Description |
---|---|
boolean |
Service.storedAlignment(Alignment al)
store an alignment
|
Constructor and Description |
---|
QueryMediator(Alignment a) |
QueryMediator(QueryProcessor proc,
Alignment a) |
Modifier and Type | Interface and Description |
---|---|
interface |
AlignmentProcess
Represents an executable alignment
|
Modifier and Type | Method and Description |
---|---|
Alignment |
Alignment.compose(Alignment align) |
Alignment |
Alignment.diff(Alignment align) |
Alignment |
Alignment.inverse()
Algebra of alignment manipulation operations: compose, join, meet.
|
Alignment |
Alignment.join(Alignment align) |
Alignment |
Alignment.meet(Alignment align) |
Alignment |
AlignmentRepairer.repair(Alignment alignment,
java.util.Properties param)
Perform repair on the alignment.
|
Modifier and Type | Method and Description |
---|---|
java.util.Set<Alignment> |
OntologyNetwork.getAlignments() |
java.util.Set<Alignment> |
OntologyNetwork.getAlignments(java.net.URI srcOnto,
java.net.URI dstOnto) |
java.util.Set<Alignment> |
OntologyNetwork.getSourceAlignments(java.net.URI onto) |
java.util.Set<Alignment> |
OntologyNetwork.getTargetingAlignments(java.net.URI onto) |
Modifier and Type | Method and Description |
---|---|
void |
OntologyNetwork.addAlignment(Alignment al) |
void |
AlignmentProcess.align(Alignment alignment,
java.util.Properties param)
The align method computes the alignment from the ontologies.
|
Alignment |
Alignment.compose(Alignment align) |
Alignment |
Alignment.diff(Alignment align) |
java.net.URI |
Cell.getObject1AsURI(Alignment al) |
java.net.URI |
Cell.getObject2AsURI(Alignment al) |
boolean |
LogicOntologyNetwork.isEntailed(Alignment al) |
Alignment |
Alignment.join(Alignment align) |
Alignment |
Alignment.meet(Alignment align) |
void |
OntologyNetwork.remAlignment(Alignment al) |
Alignment |
AlignmentRepairer.repair(Alignment alignment,
java.util.Properties param)
Perform repair on the alignment.
|
void |
AlignmentVisitor.visit(Alignment o) |
(C) INRIA & friends, 2003-2020