Modifier and Type | Method and Description |
---|---|
Evaluator |
GroupOutput.eval(java.lang.String alignName1,
java.lang.String alignName2) |
Modifier and Type | Method and Description |
---|---|
static Alterator |
AlteratorFactory.cascadeAlterators(Alterator init,
java.util.Properties params) |
Alterator |
TestGenerator.generate(org.apache.jena.ontology.OntModel onto,
java.util.Properties params,
java.util.Properties initalign) |
void |
TestSet.generate(java.util.Properties params) |
void |
TestSet.generateTest(TestCase c,
java.util.Properties align) |
java.util.Properties |
TestGenerator.incrementModifyOntology(java.lang.String prevTestDir,
java.util.Properties al,
java.lang.String testDir,
java.util.Properties params)
Generate a test by altering an existing test
|
java.util.Properties |
TestGenerator.incrementModifyOntology(java.lang.String pKey,
java.lang.String pVal,
java.lang.String suffix,
java.lang.String prevTest,
java.util.Properties al,
java.lang.String testNb)
Generate a test by altering an existing test
|
Alterator |
Alterator.modify(java.util.Properties params)
modify applies the alteration to the input (the results are kept in
internal structures.
|
java.util.Properties |
TestGenerator.modifyOntology(java.lang.String file,
java.util.Properties al,
java.lang.String dirName,
java.util.Properties params)
Generate a test from an ontology
|
private void |
TestGenerator.outputTestDirectory(org.apache.jena.ontology.OntModel onto,
Alignment align,
java.lang.String dirName) |
OntologyNetwork |
OntologyNetworkWeakener.weaken(OntologyNetwork on,
double n,
java.util.Properties p)
Weakens the ontology network of n%
|
OntologyNetwork |
NetworkDeconnector.weaken(OntologyNetwork on,
double n,
java.util.Properties p) |
OntologyNetwork |
NetworkCorrespondenceDropper.weaken(OntologyNetwork on,
double n,
java.util.Properties p) |
OntologyNetwork |
NetworkAlignmentWeakener.weaken(OntologyNetwork on,
double n,
java.util.Properties p) |
OntologyNetwork |
NetworkAlignmentDropper.weaken(OntologyNetwork on,
double n,
java.util.Properties p) |
OntologyNetwork |
OntologyNetworkWeakener.weaken(OntologyNetwork on,
int n,
java.util.Properties p)
Weakens the ontology network of n units
|
OntologyNetwork |
NetworkDeconnector.weaken(OntologyNetwork on,
int n,
java.util.Properties p) |
OntologyNetwork |
NetworkCorrespondenceDropper.weaken(OntologyNetwork on,
int n,
java.util.Properties p) |
OntologyNetwork |
NetworkAlignmentWeakener.weaken(OntologyNetwork on,
int n,
java.util.Properties p) |
OntologyNetwork |
NetworkAlignmentDropper.weaken(OntologyNetwork on,
int n,
java.util.Properties p) |
Modifier and Type | Method and Description |
---|---|
Alterator |
EmptyModification.modify(java.util.Properties params) |
abstract Alterator |
BasicAlterator.modify(java.util.Properties params) |
Modifier and Type | Method and Description |
---|---|
void |
URICell.accept(AlignmentVisitor visitor) |
void |
BasicRelation.accept(AlignmentVisitor visitor) |
void |
BasicCell.accept(AlignmentVisitor visitor) |
void |
BasicAlignment.accept(AlignmentVisitor visitor) |
void |
BasicRelation.accept(TypeCheckingVisitor visitor) |
Cell |
URIAlignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2) |
Cell |
BasicAlignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2) |
Cell |
URIAlignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2,
java.lang.String relation,
double measure) |
Cell |
BasicAlignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2,
java.lang.String relation,
double measure) |
Cell |
URIAlignment.addAlignCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure)
Cell methods
|
Cell |
BasicAlignment.addAlignCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure) |
BasicCell |
BasicAlignment.addAlignCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure,
Extensions extensions) |
Cell |
BasicAlignment.addAlignCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
java.lang.String relation,
double measure) |
void |
BasicOntologyNetwork.addAlignment(Alignment al) |
protected void |
BasicAlignment.addCell(Cell c) |
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.
|
void |
DistanceAlignment.align(Alignment alignment,
java.util.Properties params)
Process matching
- create distance data structures,
- compute distance or similarity
- extract alignment
|
protected boolean |
BasicOntologyNetwork.applyComposition(java.util.Properties params)
This only works on normalised networks (and returns a normalised network)
Like usually, it could be improved as:
for each triple of ontologies: o1, o2, o3
al(o1,o3) = al(o1,o3) & al(o1,o2) o al(o2,o3)
& al(o1,o2) o al(o3,o2)-1
& al(o2,o1)-1 o al(o2,o3)
& ...
|
void |
BasicOntologyNetwork.close(boolean reflexive,
boolean symmetric,
boolean transitive,
java.util.Properties params)
Computes the transitive, reflexive, symmetric closure of a network of ontology
Reflexive: LEFT UNDONE
Symmetric: for each pair of ontologies
Transitive: for each triple of ontologies, join its alignment with the composition of the others
Modifies the network (but preserves the semantics)
Reflexivity is left undone (empty alignments in principle)
Because it depends on (a) the type of alignment and (b) the ontology language
The code below is OK, but no alignment type is available...
|
AlgebraRelation<T> |
BitSetAlgebraRelation.compose(AlgebraRelation<T> dr) |
AlgebraRelation<T> |
AlgebraRelation.compose(AlgebraRelation<T> dr) |
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.
|
Cell |
ObjectCell.compose(Cell c) |
Cell |
BasicCell.compose(Cell c) |
ObjectAlignment |
BasicEvaluator.convertToObjectAlignment(Alignment al) |
void |
BasicEvaluator.convertToObjectAlignments(Alignment al1,
Alignment al2) |
URICell |
URIAlignment.createCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure) |
ObjectCell |
ObjectAlignment.createCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure) |
BasicCell |
BasicAlignment.createCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure) |
URIAlignment |
URIAlignment.createNewAlignment(java.lang.Object onto1,
java.lang.Object onto2,
java.lang.Class<? extends Relation> relType,
java.lang.Class<?> confType) |
ObjectAlignment |
ObjectAlignment.createNewAlignment(java.lang.Object onto1,
java.lang.Object onto2,
java.lang.Class<? extends Relation> relType,
java.lang.Class<?> confType)
Generate a copy of this alignment object
|
BasicAlignment |
BasicAlignment.createNewAlignment(java.lang.Object onto1,
java.lang.Object onto2,
java.lang.Class<? extends Relation> relType,
java.lang.Class<?> confType)
This method is used by the algebraic operators
It has to be overriden by implementations.
|
static BasicRelation |
BasicRelation.createRelation(java.lang.String rel)
The constructor to use
|
Relation |
BasicAlignment.createRelation(java.lang.String rel)
The constructor to use
|
void |
BasicAlignment.cut(double threshold)
Default cut implementation
For compatibility with API until version 1.1
|
void |
BasicAlignment.cut(java.lang.String method,
double threshold)
Cut refinement :
Rule:
threshold is betweew 1 and 0
|
void |
BasicAlignment.cut2(double threshold)
The cut function suppresses from an alignment all the cell over a
particular threshold
|
void |
BasicOntologyNetwork.denormalize()
Denormalizes an ontology network: suppress all empty alignments
Modifies the network
|
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.
|
static BasicOntologyNetwork |
BasicOntologyNetwork.diff(OntologyNetwork on1,
OntologyNetwork on2)
Difference between two ontology networks...
|
Alignment |
DistanceAlignment.extract(java.lang.String type,
java.util.Properties params)
Extract the alignment form the Similarity
|
Cell |
URIAlignment.getAlignCell1(java.lang.Object ob) |
Cell |
BasicAlignment.getAlignCell1(java.lang.Object ob) |
Cell |
URIAlignment.getAlignCell2(java.lang.Object ob) |
Cell |
BasicAlignment.getAlignCell2(java.lang.Object ob) |
java.util.Set<Cell> |
BasicAlignment.getAlignCells(java.lang.Object ob1,
java.lang.Object ob2) |
java.util.Set<Cell> |
URIAlignment.getAlignCells1(java.lang.Object ob) |
java.util.Set<Cell> |
BasicAlignment.getAlignCells1(java.lang.Object ob) |
java.util.Set<Cell> |
URIAlignment.getAlignCells2(java.lang.Object ob) |
java.util.Set<Cell> |
BasicAlignment.getAlignCells2(java.lang.Object ob) |
java.lang.Object |
BasicAlignment.getAlignedObject1(java.lang.Object ob) |
java.lang.Object |
BasicAlignment.getAlignedObject2(java.lang.Object ob) |
Relation |
BasicAlignment.getAlignedRelation1(java.lang.Object ob) |
Relation |
BasicAlignment.getAlignedRelation2(java.lang.Object ob) |
double |
BasicAlignment.getAlignedStrength1(java.lang.Object ob) |
double |
BasicAlignment.getAlignedStrength2(java.lang.Object ob) |
java.net.URI |
BasicCell.getObject1AsURI()
Since version 3.3, the interpretation of objects (and thus finding their
URI) depends on the Ontology API which is used.
|
java.net.URI |
URICell.getObject1AsURI(Alignment al) |
java.net.URI |
ObjectCell.getObject1AsURI(Alignment al) |
java.net.URI |
BasicCell.getObject1AsURI(Alignment al) |
java.net.URI |
BasicCell.getObject2AsURI()
Since version 3.3, the interpretation of objects (and thus finding their
URI) depends on the Ontology API which is used.
|
java.net.URI |
URICell.getObject2AsURI(Alignment al) |
java.net.URI |
ObjectCell.getObject2AsURI(Alignment al) |
java.net.URI |
BasicCell.getObject2AsURI(Alignment al) |
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...
|
void |
BasicAlignment.harden(double threshold)
The harden function acts like threshold but put all weights to 1.
|
void |
BasicAlignment.ingest(Alignment alignment)
Incorporate the cells of the alignment into its own alignment.
|
protected void |
IDDLOntologyNetwork.init() |
void |
URIAlignment.init(java.lang.Object o1,
java.lang.Object o2) |
void |
ObjectAlignment.init(java.lang.Object onto1,
java.lang.Object onto2) |
void |
BasicAlignment.init(java.lang.Object onto1,
java.lang.Object onto2) |
void |
BasicAlignment.init(java.lang.Object onto1,
java.lang.Object onto2,
java.lang.Class<? extends Relation> relType,
java.lang.Class<?> confType)
Initialises the Alignment object with two ontologies.
|
void |
BasicAlignment.init(java.lang.Object onto1,
java.lang.Object onto2,
java.lang.Object cache) |
Cell |
URICell.inverse() |
URIAlignment |
URIAlignment.inverse() |
Cell |
ObjectCell.inverse() |
ObjectAlignment |
ObjectAlignment.inverse() |
Cell |
BasicCell.inverse() |
BasicAlignment |
BasicAlignment.inverse()
A new alignment is created such that for
any pair (o, o', n, r) in O the resulting alignment will contain:
( o', o, n, inverse(r)) iff compose(r) exists.
|
void |
BasicOntologyNetwork.invert()
Invert all alignments in a network of ontologies
In fact, this is closing by invert!
Modifies the network
|
void |
BasicAlignment.invertContent(BasicAlignment result,
java.lang.String label,
java.lang.String method) |
boolean |
IDDLOntologyNetwork.isConsistent() |
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.
|
java.util.Set<Cell> |
BasicCell.join(Cell c) |
DisjunctiveRelation<T> |
DisjunctiveRelation.join(DisjunctiveRelation<T>... drs) |
DisjunctiveRelation<T> |
BitSetDisjunctiveRelation.join(DisjunctiveRelation<T>... drs) |
static BasicOntologyNetwork |
BasicOntologyNetwork.join(OntologyNetwork on1,
OntologyNetwork on2)
Union of two ontology networks...
|
void |
ObjectAlignment.loadInit(Alignment al) |
(package private) static LoadedOntology<?> |
ObjectAlignment.loadOntology(java.net.URI ref) |
void |
BasicOntologyNetwork.match(java.lang.String method,
boolean reflexive,
boolean symmetric,
java.util.Properties params)
Match ontologies in a network, using existing ontologies as input...
|
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.
|
java.util.Set<Cell> |
BasicCell.meet(Cell c) |
DisjunctiveRelation<T> |
DisjunctiveRelation.meet(DisjunctiveRelation<T>... drs) |
DisjunctiveRelation<T> |
BitSetDisjunctiveRelation.meet(DisjunctiveRelation<T>... drs) |
static BasicOntologyNetwork |
BasicOntologyNetwork.meet(OntologyNetwork on1,
OntologyNetwork on2)
Intersection of two ontology networks...
|
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 |
BasicAlignment.normalise() |
void |
BasicOntologyNetwork.normalize()
Normalizes an ontology network for it to have exactly one alignment between each pair of ontologies.
|
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...
|
static OntologyNetwork |
BasicOntologyNetwork.parse(org.apache.jena.rdf.model.Model rdfModel) |
static OntologyNetwork |
BasicOntologyNetwork.read(java.io.InputStream is) |
java.util.BitSet |
BitSetDisjunctiveRelation.read(java.lang.String rels) |
static OntologyNetwork |
BasicOntologyNetwork.read(java.lang.String uri)
Parsing
here we use Jena
|
void |
BasicOntologyNetwork.remAlignment(Alignment al) |
void |
BasicAlignment.remCell(Cell c) |
void |
BasicOntologyNetwork.remOntology(java.net.URI onto) |
void |
BasicAlignment.removeAlignCell(Cell c) |
void |
BasicAlignment.render(AlignmentVisitor renderer)
This should be rewritten in order to generate the axiom ontology instead
of printing it! And then use ontology serialization for getting it
printed.
|
OntologyNetwork |
AbstractRepairer.repair(OntologyNetwork network,
java.util.Properties param)
Performs a local repair of a network of ontology by
repairing all its alignments.
|
java.lang.String |
BasicAlignment.rewriteQuery(java.lang.String aQuery)
- replaces all entity IRI by their counterpart in the ontology
Caveats:
- This does only work for alignments with =
- This does not care for the *:x status of alignments
- This does work from ontology1 to ontology2, not the other way around
(use invert() in this case).
|
java.lang.String |
BasicAlignment.rewriteQuery(java.lang.String aQuery,
java.util.Properties prefix) |
java.lang.String |
BasicAlignment.rewriteSPARQLQuery(java.lang.String aQuery) |
java.lang.String |
BasicAlignment.rewriteSPARQLQuery(java.lang.String aQuery,
java.util.Properties prefix) |
void |
BasicAlignment.setConfidenceType(java.lang.String classname) |
void |
BasicCell.setObject1(java.lang.Object ob) |
void |
BasicCell.setObject2(java.lang.Object ob) |
void |
URIAlignment.setOntology1(java.lang.Object ontology) |
void |
BasicAlignment.setOntology1(java.lang.Object ontology) |
void |
URIAlignment.setOntology2(java.lang.Object ontology) |
void |
BasicAlignment.setOntology2(java.lang.Object ontology) |
void |
BasicAlignment.setRelationType(java.lang.String classname) |
static ObjectAlignment |
ObjectAlignment.toObjectAlignment(URIAlignment al) |
URIAlignment |
URIAlignment.toURIAlignment()
Returns default exception for conversion to URIAlignments
|
URIAlignment |
ObjectAlignment.toURIAlignment()
This is a clone with the URI instead of Object objects
|
URIAlignment |
BasicAlignment.toURIAlignment()
Returns default exception for conversion to URIAlignments
|
URIAlignment |
ObjectAlignment.toURIAlignment(boolean strict) |
void |
BasicOntologyNetwork.trim(java.lang.String method,
double threshold)
Applies a threshold to all alignments in a network
Modifies the network
|
void |
BasicOntologyNetwork.write(java.io.PrintWriter writer) |
Constructor and Description |
---|
BasicCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation rel,
double m)
Creation
Creates a correspondence
|
BasicEvaluator(Alignment align1,
Alignment align2)
Creation
Creates an evaluator
|
ObjectAlignment(ObjectAlignment al) |
ObjectAlignment(URIAlignment al) |
ObjectCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation rel,
double m)
Creation
|
URICell(java.lang.String id,
java.net.URI ob1,
java.net.URI ob2,
Relation rel,
double m)
Creation
|
Modifier and Type | Method and Description |
---|---|
abstract void |
BasicAggregator.extract()
Extract the alignment from consensus
This has to be implemented in concrete classes
|
void |
BasicAggregator.ingest(BasicAlignment al)
Record the content of alignments.
|
Modifier and Type | Method and Description |
---|---|
void |
EDOALCell.accept(AlignmentVisitor visitor) |
void |
ValueExpression.accept(EDOALVisitor v) |
void |
Value.accept(EDOALVisitor visitor) |
void |
Transformation.accept(EDOALVisitor visitor) |
void |
RelationId.accept(EDOALVisitor visitor) |
void |
RelationDomainRestriction.accept(EDOALVisitor visitor) |
void |
RelationConstruction.accept(EDOALVisitor visitor) |
void |
RelationCoDomainRestriction.accept(EDOALVisitor visitor) |
void |
PropertyValueRestriction.accept(EDOALVisitor visitor) |
void |
PropertyTypeRestriction.accept(EDOALVisitor visitor) |
void |
PropertyId.accept(EDOALVisitor visitor) |
void |
PropertyDomainRestriction.accept(EDOALVisitor visitor) |
void |
PropertyConstruction.accept(EDOALVisitor visitor) |
void |
LinkkeyIntersects.accept(EDOALVisitor visitor) |
void |
LinkkeyEquals.accept(EDOALVisitor visitor) |
abstract void |
LinkkeyBinding.accept(EDOALVisitor visitor) |
void |
Linkkey.accept(EDOALVisitor visitor) |
void |
InstanceId.accept(EDOALVisitor visitor) |
abstract void |
Expression.accept(EDOALVisitor visitor) |
void |
Datatype.accept(EDOALVisitor visitor) |
void |
ClassValueRestriction.accept(EDOALVisitor visitor) |
void |
ClassTypeRestriction.accept(EDOALVisitor visitor) |
void |
ClassOccurenceRestriction.accept(EDOALVisitor visitor) |
void |
ClassId.accept(EDOALVisitor visitor) |
void |
ClassDomainRestriction.accept(EDOALVisitor visitor) |
void |
ClassConstruction.accept(EDOALVisitor visitor) |
void |
Apply.accept(EDOALVisitor visitor) |
void |
Aggregate.accept(EDOALVisitor visitor) |
TypeCheckingVisitor.TYPE |
ValueExpression.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
Value.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
Transformation.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
RelationId.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
RelationDomainRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
RelationConstruction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
RelationCoDomainRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
PropertyValueRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
PropertyTypeRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
PropertyId.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
PropertyDomainRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
PropertyConstruction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
Linkkey.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
InstanceId.accept(TypeCheckingVisitor visitor) |
abstract TypeCheckingVisitor.TYPE |
Expression.accept(TypeCheckingVisitor visitor) |
void |
EDOALCell.accept(TypeCheckingVisitor visitor) |
void |
EDOALAlignment.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
Datatype.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
ClassValueRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
ClassTypeRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
ClassOccurenceRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
ClassId.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
ClassDomainRestriction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
ClassConstruction.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
Apply.accept(TypeCheckingVisitor visitor) |
TypeCheckingVisitor.TYPE |
Aggregate.accept(TypeCheckingVisitor visitor) |
EDOALCell |
EDOALAlignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2)
Cell methods
|
EDOALCell |
EDOALAlignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2,
java.lang.String relation,
double measure) |
EDOALCell |
EDOALAlignment.addAlignCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure) |
EDOALCell |
EDOALAlignment.addAlignCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure,
Extensions extensions) |
EDOALCell |
EDOALAlignment.addAlignCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
java.lang.String relation,
double measure) |
void |
PropertyConstruction.addComponent(PropertyExpression exp) |
void |
EDOALAlignment.convertToEDOAL(BasicAlignment al)
The EDOALAlignment has LoadedOntologies as ontologies
|
EDOALCell |
EDOALAlignment.createCell(java.lang.String id,
java.lang.Object ob1,
java.lang.Object ob2,
Relation relation,
double measure) |
private static Id |
EDOALAlignment.createEDOALExpression(LoadedOntology<java.lang.Object> o,
java.net.URI u) |
EDOALAlignment |
EDOALAlignment.createNewAlignment(java.lang.Object onto1,
java.lang.Object onto2,
java.lang.Class<? extends Relation> relType,
java.lang.Class<?> confType) |
Cell |
EDOALAlignment.getAlignCell1(java.lang.Object ob) |
Cell |
EDOALAlignment.getAlignCell2(java.lang.Object ob) |
java.util.Set<Cell> |
EDOALAlignment.getAlignCells1(java.lang.Object ob) |
java.util.Set<Cell> |
EDOALAlignment.getAlignCells2(java.lang.Object ob) |
java.net.URI |
EDOALCell.getObject1AsURI(Alignment al) |
java.net.URI |
EDOALCell.getObject2AsURI(Alignment al) |
void |
EDOALAlignment.init(java.lang.Object onto1,
java.lang.Object onto2) |
Transformation |
Transformation.inverse() |
EDOALCell |
EDOALCell.inverse() |
EDOALAlignment |
EDOALAlignment.inverse() |
void |
EDOALAlignment.loadInit(Alignment al) |
static LoadedOntology<? extends java.lang.Object> |
EDOALAlignment.loadOntology(Ontology<java.lang.Object> onto) |
static LoadedOntology<? extends java.lang.Object> |
EDOALAlignment.loadOntology(java.net.URI onto)
convert an URI alignment into a corresponding EDOALAlignment
The same could be implemented for ObjectAlignent if necessary
|
void |
EDOALAlignment.setOntology1(java.lang.Object ontology) |
void |
EDOALAlignment.setOntology2(java.lang.Object ontology) |
static EDOALAlignment |
EDOALAlignment.toEDOALAlignment(BasicAlignment al) |
static EDOALAlignment |
EDOALAlignment.toEDOALAlignment(ObjectAlignment al) |
static EDOALAlignment |
EDOALAlignment.toEDOALAlignment(URIAlignment al) |
URIAlignment |
EDOALAlignment.toURIAlignment()
This is a clone with the URI instead of Object objects
This conversion will drop any correspondences using something not identified by an URI
For converting to ObjectAlignment, first convert to URIAlignment and load as an ObjectAlignment
The same code as for ObjectAlignment works...
|
URIAlignment |
EDOALAlignment.toURIAlignment(boolean strict) |
void |
EDOALVisitor.visit(Aggregate o) |
void |
EDOALVisitor.visit(Apply o) |
void |
EDOALVisitor.visit(ClassConstruction o) |
void |
EDOALVisitor.visit(ClassDomainRestriction o) |
void |
EDOALVisitor.visit(ClassId o) |
void |
EDOALVisitor.visit(ClassOccurenceRestriction o) |
void |
EDOALVisitor.visit(ClassTypeRestriction o) |
void |
EDOALVisitor.visit(ClassValueRestriction o) |
void |
EDOALVisitor.visit(Datatype o) |
void |
EDOALVisitor.visit(InstanceId o) |
void |
EDOALVisitor.visit(Linkkey o) |
void |
EDOALVisitor.visit(LinkkeyEquals o) |
void |
EDOALVisitor.visit(LinkkeyIntersects o) |
void |
EDOALVisitor.visit(PropertyConstruction o) |
void |
EDOALVisitor.visit(PropertyDomainRestriction o) |
void |
EDOALVisitor.visit(PropertyId o) |
void |
EDOALVisitor.visit(PropertyTypeRestriction o) |
void |
EDOALVisitor.visit(PropertyValueRestriction o) |
void |
EDOALVisitor.visit(RelationCoDomainRestriction o) |
void |
EDOALVisitor.visit(RelationConstruction o) |
void |
EDOALVisitor.visit(RelationDomainRestriction o) |
void |
EDOALVisitor.visit(RelationId o) |
void |
EDOALVisitor.visit(Transformation o) |
void |
EDOALVisitor.visit(Value o) |
Constructor and Description |
---|
ClassId(java.lang.String id) |
EDOALAlignment(BasicAlignment al) |
EDOALAlignment(EDOALAlignment al)
Generate a (deeper) copy of the alignment object
It has the same content but a different id (no id indeed)
|
EDOALAlignment(ObjectAlignment al) |
EDOALAlignment(URIAlignment al) |
EDOALCell(java.lang.String id,
Expression ob1,
Expression ob2,
Relation rel,
double m)
Creation
|
RelationId(java.lang.String id) |
Transformation(java.lang.String type,
ValueExpression ob1,
ValueExpression ob2)
Creation
|
Modifier and Type | Method and Description |
---|---|
org.semanticweb.owlapi.model.OWLAxiom |
SemPRecEvaluator.correspToAxiom(ObjectAlignment al,
ObjectCell corresp) |
abstract java.util.Vector<Pair> |
GraphEvaluator.eval() |
double |
WeightedPREvaluator.eval(java.util.Properties params)
Computes the evaluation measure (the results are stored in the object)
The formulas are standard (see PREvaluation) except that they use
the difference between confidences instead of booleans
|
double |
SymMeanEvaluator.eval(java.util.Properties params) |
double |
SemPRecEvaluator.eval(java.util.Properties params)
Computes the evaluation measure (the results are stored in the object)
The formulas are standard (see PREvaluation) except that they use
the entailment of a correspondence by an alignment instead of set-membership
This takes semantics as a parameter which should be a litteral of fr.paris8.iut.info.draon.conf.Semantics
|
double |
PRecEvaluator.eval(java.util.Properties params)
Computes the evaluation measure (the results are stored in the object)
The formulas are standard:
given a reference alignment A
given an obtained alignment B
which are sets of cells (linking one entity of ontology O to another of ontolohy O').
|
abstract java.util.Vector<Pair> |
GraphEvaluator.eval(java.util.Properties params) |
double |
ExtPREvaluator.eval(java.util.Properties params)
This is a partial implementation of [Ehrig and Euzenat 2005]
because the relations are not taken into account
(they are supposed to be always =)
|
double |
DiffEvaluator.eval(java.util.Properties params) |
double |
WeightedPREvaluator.eval(java.util.Properties params,
java.lang.Object cache) |
double |
SymMeanEvaluator.eval(java.util.Properties params,
java.lang.Object cache) |
double |
PRecEvaluator.eval(java.util.Properties params,
java.lang.Object cache) |
double |
ExtPREvaluator.eval(java.util.Properties params,
java.lang.Object cache) |
double |
DiffEvaluator.eval(java.util.Properties params,
java.lang.Object cache) |
void |
AveragePRGraphEvaluator.evalAlignment(Alignment align1,
Alignment align2) |
double |
WeightedPREvaluator.getFallout() |
double |
PRecEvaluator.getFallout() |
int |
ExtPREvaluator.isSuperClass(java.lang.Object class1,
java.lang.Object class2,
HeavyLoadedOntology<java.lang.Object> ontology)
This is a strange method which returns an integer representing how
directly a class is superclass of another or not.
|
int |
ExtPREvaluator.isSuperProperty(java.lang.Object prop1,
java.lang.Object prop2,
HeavyLoadedOntology<java.lang.Object> ontology) |
void |
SemPRecEvaluator.loadAlignedOntologies(ObjectAlignment align)
Even simpler if they are loaded: just merge them on the spot
|
void |
SemPRecEvaluator.loadFileAlignedOntologies(ObjectAlignment align)
Loads the Aligned ontologies through an intermediate file
|
void |
SemPRecEvaluator.loadPipedAlignedOntologies(ObjectAlignment align)
Loads the Aligned ontologies without intermediate file
|
int |
SemPRecEvaluator.nbEntailedCorrespondences(ObjectAlignment al1,
ObjectAlignment al2) |
protected int |
ExtPREvaluator.relativePosition(java.lang.Object o1,
java.lang.Object o2,
HeavyLoadedOntology<java.lang.Object> onto)
Returns the relative position of two entities in an ontology
|
int |
ExtPREvaluator.superClassPosition(java.lang.Object class1,
java.lang.Object class2,
HeavyLoadedOntology<java.lang.Object> onto) |
int |
ExtPREvaluator.superPropertyPosition(java.lang.Object prop1,
java.lang.Object prop2,
HeavyLoadedOntology<java.lang.Object> onto) |
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 | 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
|
void |
StrucSubsDistAlignment.init(java.lang.Object o1,
java.lang.Object o2,
java.lang.Object ontologies)
Initialisation
The class requires HeavyLoadedOntologies
|
void |
NameAndPropertyAlignment.init(java.lang.Object o1,
java.lang.Object o2,
java.lang.Object ontologies)
Initialisation
The class requires HeavyLoadedOntologies
|
void |
ClassStructAlignment.init(java.lang.Object o1,
java.lang.Object o2,
java.lang.Object ontologies)
Initialisation
The class requires HeavyLoadedOntologies
|
Modifier and Type | Method and Description |
---|---|
void |
SubsumedRelation.accept(AlignmentVisitor visitor) |
void |
SubsumeRelation.accept(AlignmentVisitor visitor) |
void |
NonTransitiveImplicationRelation.accept(AlignmentVisitor visitor) |
void |
InstanceOfRelation.accept(AlignmentVisitor visitor) |
void |
IncompatRelation.accept(AlignmentVisitor visitor) |
void |
HasInstanceRelation.accept(AlignmentVisitor visitor) |
void |
EquivRelation.accept(AlignmentVisitor visitor) |
void |
SubsumedRelation.accept(TypeCheckingVisitor visitor) |
void |
SubsumeRelation.accept(TypeCheckingVisitor visitor) |
void |
NonTransitiveImplicationRelation.accept(TypeCheckingVisitor visitor) |
void |
InstanceOfRelation.accept(TypeCheckingVisitor visitor) |
void |
IncompatRelation.accept(TypeCheckingVisitor visitor) |
void |
HasInstanceRelation.accept(TypeCheckingVisitor visitor) |
void |
EquivRelation.accept(TypeCheckingVisitor visitor) |
static A16AlgebraRelation |
A16AlgebraRelation.createRelation(A16BaseRelation... rels) |
static A2AlgebraRelation |
A2AlgebraRelation.createRelation(A2BaseRelation... rels) |
static A5AlgebraRelation |
A5AlgebraRelation.createRelation(A5BaseRelation... rels) |
static A5AlgebraRelation |
A5AlgebraRelation.createRelation(java.lang.String rels) |
static A2AlgebraRelation |
A2AlgebraRelation.createRelation(java.lang.String rels) |
static A16AlgebraRelation |
A16AlgebraRelation.createRelation(java.lang.String rels) |
static A5AlgebraRelation |
A5AlgebraRelation.getIdRelation() |
static A2AlgebraRelation |
A2AlgebraRelation.getIdRelation() |
static A16AlgebraRelation |
A16AlgebraRelation.getIdRelation() |
static A5AlgebraRelation |
A5AlgebraRelation.getInconsistentRelation() |
static A2AlgebraRelation |
A2AlgebraRelation.getInconsistentRelation() |
static A16AlgebraRelation |
A16AlgebraRelation.getInconsistentRelation() |
static A5AlgebraRelation |
A5AlgebraRelation.getNoInfoRelation() |
static A2AlgebraRelation |
A2AlgebraRelation.getNoInfoRelation() |
static A16AlgebraRelation |
A16AlgebraRelation.getNoInfoRelation() |
Constructor and Description |
---|
A16AlgebraRelation(java.lang.String rels) |
A2AlgebraRelation(java.lang.String rels) |
A5AlgebraRelation(java.lang.String rels) |
Modifier and Type | Method and Description |
---|---|
private void |
XSLTRendererVisitor.collectURIs(Cell cell) |
protected void |
SPARQLConstructRendererVisitor.generateConstruct(Cell cell,
Expression expr1,
Expression expr2) |
void |
SWRLRendererVisitor.generateImplication(java.lang.Object ob1,
java.lang.Object ob2) |
void |
SWRLRendererVisitor.generateIncompatibility(java.lang.Object ob1,
java.lang.Object ob2) |
protected void |
SPARQLSelectRendererVisitor.generateSelect(Expression expr) |
private java.lang.String |
SILKRendererVisitor.generateSILKPath(java.lang.String var,
PathExpression pex)
This is incomplete as SILK is able to deal with reverse (\) and constraints ([])
|
void |
XSLTRendererVisitor.generateTransformation(Cell cell) |
static java.lang.String |
SEKTMappingRendererVisitor.getRelationDirection(Relation rel) |
java.lang.String |
SKOSRendererVisitor.getRelationName(Relation rel) |
static java.lang.String |
COWLMappingRendererVisitor.getRelationName(Relation rel) |
java.net.URI |
SKOSRendererVisitor.getURI2() |
protected void |
HTMLMetadataRendererVisitor.printAlignmentMetadata(Alignment align) |
void |
COWLMappingRendererVisitor.printObject(java.lang.Object ob,
LoadedOntology<?> onto) |
void |
OWLAxiomsRendererVisitor.printRel(java.lang.Object ob,
LoadedOntology<? extends java.lang.Object> onto,
Relation rel) |
void |
SPARQLLinkkerRendererVisitor.processInLinkKey(LinkkeyBinding binding) |
protected void |
GraphPatternRendererVisitor.resetVariables(Expression expr,
java.lang.String s,
java.lang.String o) |
boolean |
GenericReflectiveVisitor.subsumedInvocableMethod(java.lang.Object visitor,
java.lang.Object o,
java.lang.Class<?> cl) |
private java.lang.String |
GraphPatternRendererVisitor.valueToCompare(ValueExpression val,
java.lang.String var) |
void |
RDFRendererVisitor.visit(Aggregate e) |
void |
OWLAxiomsRendererVisitor.visit(Aggregate e) |
void |
JSONRendererVisitor.visit(Aggregate e) |
void |
GraphPatternRendererVisitor.visit(Aggregate e) |
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) |
void |
RDFRendererVisitor.visit(Apply e) |
void |
OWLAxiomsRendererVisitor.visit(Apply e) |
void |
JSONRendererVisitor.visit(Apply e) |
void |
GraphPatternRendererVisitor.visit(Apply e) |
void |
XSLTRendererVisitor.visit(Cell cell) |
void |
XMLMetadataRendererVisitor.visit(Cell c) |
void |
SWRLRendererVisitor.visit(Cell cell) |
void |
SPARQLSelectRendererVisitor.visit(Cell cell) |
void |
SPARQLLinkkerRendererVisitor.visit(Cell cell) |
void |
SPARQLConstructRendererVisitor.visit(Cell cell) |
void |
SKOSRendererVisitor.visit(Cell cell) |
void |
SILKRendererVisitor.visit(Cell cell) |
void |
SEKTMappingRendererVisitor.visit(Cell cell) |
void |
RDFRendererVisitor.visit(Cell cell) |
void |
OWLAxiomsRendererVisitor.visit(Cell cell) |
void |
JSONRendererVisitor.visit(Cell cell) |
void |
HTMLRendererVisitor.visit(Cell cell) |
void |
HTMLMetadataRendererVisitor.visit(Cell c) |
void |
CSVRendererVisitor.visit(Cell cell) |
void |
COWLMappingRendererVisitor.visit(Cell cell) |
void |
RDFRendererVisitor.visit(ClassConstruction e) |
void |
OWLAxiomsRendererVisitor.visit(ClassConstruction e) |
void |
JSONRendererVisitor.visit(ClassConstruction e) |
void |
GraphPatternRendererVisitor.visit(ClassConstruction e) |
void |
RDFRendererVisitor.visit(ClassDomainRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(ClassDomainRestriction c) |
void |
JSONRendererVisitor.visit(ClassDomainRestriction c) |
void |
GraphPatternRendererVisitor.visit(ClassDomainRestriction c) |
void |
RDFRendererVisitor.visit(ClassId e) |
void |
OWLAxiomsRendererVisitor.visit(ClassId e)
OWL, and in particular OWL 2, does not allow for more Relation (ObjectProperty)
and Property (DataProperty) constructor than owl:inverseOf
It is thus imposible to transcribe our and, or and not constructors.
|
void |
JSONRendererVisitor.visit(ClassId e) |
void |
GraphPatternRendererVisitor.visit(ClassId e) |
void |
RDFRendererVisitor.visit(ClassOccurenceRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(ClassOccurenceRestriction c) |
void |
JSONRendererVisitor.visit(ClassOccurenceRestriction c) |
void |
GraphPatternRendererVisitor.visit(ClassOccurenceRestriction c) |
void |
RDFRendererVisitor.visit(ClassTypeRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(ClassTypeRestriction c) |
void |
JSONRendererVisitor.visit(ClassTypeRestriction c) |
void |
GraphPatternRendererVisitor.visit(ClassTypeRestriction c) |
void |
RDFRendererVisitor.visit(ClassValueRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(ClassValueRestriction c) |
void |
JSONRendererVisitor.visit(ClassValueRestriction c) |
void |
GraphPatternRendererVisitor.visit(ClassValueRestriction c) |
void |
JSONRendererVisitor.visit(Datatype e) |
void |
GraphPatternRendererVisitor.visit(Datatype e) |
void |
OWLAxiomsRendererVisitor.visit(EDOALCell cell) |
void |
RDFRendererVisitor.visit(InstanceId e) |
void |
OWLAxiomsRendererVisitor.visit(InstanceId e) |
void |
JSONRendererVisitor.visit(InstanceId e) |
void |
GraphPatternRendererVisitor.visit(InstanceId e) |
void |
SPARQLSelectRendererVisitor.visit(Linkkey linkkey) |
void |
SPARQLLinkkerRendererVisitor.visit(Linkkey linkkey) |
void |
SILKRendererVisitor.visit(Linkkey linkkey) |
void |
RDFRendererVisitor.visit(Linkkey linkkey) |
void |
OWLAxiomsRendererVisitor.visit(Linkkey linkkey) |
void |
JSONRendererVisitor.visit(Linkkey linkkey) |
void |
SILKRendererVisitor.visit(LinkkeyBinding binding) |
void |
OWLAxiomsRendererVisitor.visit(LinkkeyBinding linkkeyBinding) |
void |
SPARQLSelectRendererVisitor.visit(LinkkeyEquals linkkeyEquals)
Linkkeys are irrelevant to SELECT queries
|
void |
SPARQLLinkkerRendererVisitor.visit(LinkkeyEquals linkkeyEquals)
Generate the constraint corresponding to:
MINUS { ?x pj ?wj .
|
void |
SILKRendererVisitor.visit(LinkkeyEquals linkkeyEquals) |
void |
RDFRendererVisitor.visit(LinkkeyEquals linkkeyEquals) |
void |
OWLAxiomsRendererVisitor.visit(LinkkeyEquals linkkeyEquals) |
void |
JSONRendererVisitor.visit(LinkkeyEquals linkkeyEquals) |
void |
SPARQLSelectRendererVisitor.visit(LinkkeyIntersects linkkeyIntersects)
Linkkeys are irrelevant to SELECT queries
|
void |
SPARQLLinkkerRendererVisitor.visit(LinkkeyIntersects linkkeyIntersects) |
void |
SILKRendererVisitor.visit(LinkkeyIntersects linkkeyIntersects) |
void |
RDFRendererVisitor.visit(LinkkeyIntersects linkkeyIntersects) |
void |
OWLAxiomsRendererVisitor.visit(LinkkeyIntersects linkkeyIntersects) |
void |
JSONRendererVisitor.visit(LinkkeyIntersects linkkeyIntersects) |
void |
RDFRendererVisitor.visit(PropertyConstruction e) |
void |
OWLAxiomsRendererVisitor.visit(PropertyConstruction e)
OWL, and in particular OWL 2, does not allow for more Relation (ObjectProperty)
and Property (DataProperty) constructor than owl:inverseOf
It is thus imposible to transcribe our and, or and not constructors.
|
void |
JSONRendererVisitor.visit(PropertyConstruction e) |
void |
GraphPatternRendererVisitor.visit(PropertyConstruction e) |
void |
RDFRendererVisitor.visit(PropertyDomainRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(PropertyDomainRestriction c) |
void |
JSONRendererVisitor.visit(PropertyDomainRestriction c) |
void |
GraphPatternRendererVisitor.visit(PropertyDomainRestriction c) |
void |
RDFRendererVisitor.visit(PropertyId e) |
void |
OWLAxiomsRendererVisitor.visit(PropertyId e) |
void |
JSONRendererVisitor.visit(PropertyId e) |
void |
GraphPatternRendererVisitor.visit(PropertyId e) |
void |
RDFRendererVisitor.visit(PropertyTypeRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(PropertyTypeRestriction c) |
void |
JSONRendererVisitor.visit(PropertyTypeRestriction c) |
void |
GraphPatternRendererVisitor.visit(PropertyTypeRestriction c) |
void |
RDFRendererVisitor.visit(PropertyValueRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(PropertyValueRestriction c) |
void |
JSONRendererVisitor.visit(PropertyValueRestriction c) |
void |
GraphPatternRendererVisitor.visit(PropertyValueRestriction c) |
void |
XSLTRendererVisitor.visit(Relation rel) |
void |
XMLMetadataRendererVisitor.visit(Relation r) |
void |
SWRLRendererVisitor.visit(Relation rel) |
void |
SPARQLSelectRendererVisitor.visit(Relation rel) |
void |
SPARQLLinkkerRendererVisitor.visit(Relation rel) |
void |
SPARQLConstructRendererVisitor.visit(Relation rel) |
void |
SKOSRendererVisitor.visit(Relation rel) |
void |
SILKRendererVisitor.visit(Relation rel) |
void |
SEKTMappingRendererVisitor.visit(Relation rel) |
void |
RDFRendererVisitor.visit(Relation rel) |
void |
OWLAxiomsRendererVisitor.visit(Relation rel) |
void |
JSONRendererVisitor.visit(Relation rel) |
void |
HTMLRendererVisitor.visit(Relation rel) |
void |
HTMLMetadataRendererVisitor.visit(Relation r) |
void |
CSVRendererVisitor.visit(Relation rel) |
void |
COWLMappingRendererVisitor.visit(Relation rel) |
void |
RDFRendererVisitor.visit(RelationCoDomainRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(RelationCoDomainRestriction c) |
void |
JSONRendererVisitor.visit(RelationCoDomainRestriction c) |
void |
GraphPatternRendererVisitor.visit(RelationCoDomainRestriction c) |
void |
RDFRendererVisitor.visit(RelationConstruction e) |
void |
OWLAxiomsRendererVisitor.visit(RelationConstruction e)
OWL, and in particular OWL 2, does not allow for more Relation (ObjectProperty)
and Property (DataProperty) constructor than owl:inverseOf
It is thus imposible to transcribe our and, or and not constructors.
|
void |
JSONRendererVisitor.visit(RelationConstruction e) |
void |
GraphPatternRendererVisitor.visit(RelationConstruction e) |
void |
RDFRendererVisitor.visit(RelationDomainRestriction c) |
void |
OWLAxiomsRendererVisitor.visit(RelationDomainRestriction c) |
void |
JSONRendererVisitor.visit(RelationDomainRestriction c) |
void |
GraphPatternRendererVisitor.visit(RelationDomainRestriction c) |
void |
RDFRendererVisitor.visit(RelationId e) |
void |
OWLAxiomsRendererVisitor.visit(RelationId e) |
void |
JSONRendererVisitor.visit(RelationId e) |
void |
GraphPatternRendererVisitor.visit(RelationId e) |
void |
RDFRendererVisitor.visit(Transformation transf) |
void |
OWLAxiomsRendererVisitor.visit(Transformation transf) |
void |
JSONRendererVisitor.visit(Transformation transf) |
void |
GraphPatternRendererVisitor.visit(Transformation transf) |
void |
RDFRendererVisitor.visit(Value e) |
void |
OWLAxiomsRendererVisitor.visit(Value e) |
void |
JSONRendererVisitor.visit(Value e) |
void |
GraphPatternRendererVisitor.visit(Value e) |
private void |
RDFRendererVisitor.visitLinkKeyBinding(LinkkeyBinding linkkeyBinding,
SyntaxElement syntaxElement) |
private void |
JSONRendererVisitor.visitLinkKeyBinding(LinkkeyBinding linkkeyBinding,
SyntaxElement syntaxElement) |
Modifier and Type | Method and Description |
---|---|
void |
JWNLAlignment.align(Alignment alignment,
java.util.Properties prop)
Processing
|
void |
JWNLAlignment.WordNetMatrixMeasure.init() |
void |
JWNLAlignment.WordNetMatrixMeasure.init(java.lang.String wndict) |
void |
JWNLAlignment.WordNetMatrixMeasure.init(java.lang.String wndict,
java.lang.String wnvers) |
void |
JWNLAlignment.WordNetMatrixMeasure.init(java.lang.String wndict,
java.lang.String wnvers,
int simFunction) |
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
|
protected java.net.URI |
RDFParser.getNodeId(org.apache.jena.rdf.model.Resource node) |
static java.lang.Object |
SyntaxElement.getResource(java.lang.String name) |
EDOALAlignment |
RDFParser.parse(java.io.File file) |
Alignment |
XMLParser.parse(java.io.InputStream s)
Parses a string instead of a URI
|
EDOALAlignment |
RDFParser.parse(java.io.InputStream is) |
Alignment |
AlignmentParser.parse(java.io.InputStream s)
Parses an inputStream
|
EDOALAlignment |
RDFParser.parse(org.apache.jena.rdf.model.Model rdfmodel)
Parse the input model.
|
Alignment |
XMLParser.parse(java.io.Reader r)
Parses a reader, used for reading from a string
|
EDOALAlignment |
RDFParser.parse(java.io.Reader is) |
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.
|
EDOALAlignment |
RDFParser.parse(java.lang.String uri) |
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
|
EDOALAlignment |
RDFParser.parseAlignment(org.apache.jena.rdf.model.Resource node)
Parses a mapping document.
|
protected EDOALCell |
RDFParser.parseCell(org.apache.jena.rdf.model.Resource node)
Parses a mapping rule.
|
protected ClassExpression |
RDFParser.parseClass(org.apache.jena.rdf.model.Resource node) |
protected Datatype |
RDFParser.parseDatatype(org.apache.jena.rdf.model.RDFNode nn) |
protected Expression |
RDFParser.parseExpression(org.apache.jena.rdf.model.Resource node) |
static void |
RDFParser.parseExtensions(org.apache.jena.rdf.model.Resource node,
Extensible ext) |
protected InstanceExpression |
RDFParser.parseInstance(org.apache.jena.rdf.model.Resource node) |
protected Linkkey |
RDFParser.parseLinkkey(org.apache.jena.rdf.model.Resource node) |
protected LinkkeyBinding |
RDFParser.parseLinkkeyBinding(org.apache.jena.rdf.model.Resource node) |
protected Ontology<java.lang.Object> |
RDFParser.parseOntology(org.apache.jena.rdf.model.Resource node)
Parse an ontology node
<onto1> or
<onto2> Node to an Ontology object. |
protected PathExpression |
RDFParser.parsePathExpression(org.apache.jena.rdf.model.Resource node) |
protected PropertyExpression |
RDFParser.parseProperty(org.apache.jena.rdf.model.Resource node) |
protected RelationExpression |
RDFParser.parseRelation(org.apache.jena.rdf.model.Resource node) |
Alignment |
AlignmentParser.parseString(java.lang.String s)
Parses the content of a string
|
protected Transformation |
RDFParser.parseTransformation(org.apache.jena.rdf.model.Resource node) |
protected ValueExpression |
RDFParser.parseValue(org.apache.jena.rdf.model.RDFNode node) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Apply e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassConstruction e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassDomainRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassId e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassOccurenceRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassTypeRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassValueRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Datatype e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(EDOALAlignment align) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(EDOALCell cell) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(InstanceId e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Linkkey linkkey) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(LinkkeyBinding linkkeyBinding) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyConstruction e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyDomainRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyId e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyTypeRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyValueRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Relation o) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationCoDomainRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationConstruction e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationDomainRestriction c) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationId e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Transformation trsf) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Value e) |
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ValueExpression e) |
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
|
void |
VolatilCache.close() |
void |
SQLCache.close() |
void |
Cache.close() |
void |
VolatilCache.eraseAlignment(java.lang.String uri,
boolean eraseFromDB)
Non publicised class
|
void |
Cache.eraseAlignment(java.lang.String uri,
boolean eraseFromDB)
Non publicised class
|
void |
VolatilCache.eraseOntologyNetwork(java.lang.String uri,
boolean eraseFromDB)
Non publicised class
|
void |
Cache.eraseOntologyNetwork(java.lang.String uri,
boolean eraseFromDB) |
ValueExpression |
EDOALSQLCache.extractApply(long intid,
int type) |
void |
EDOALSQLCache.extractBindings(long keyid,
Linkkey key) |
ClassConstruction |
EDOALSQLCache.extractClassConstruction(int op,
long intid) |
ClassExpression |
EDOALSQLCache.extractClassExpression(long intid) |
ClassId |
EDOALSQLCache.extractClassId(long intid) |
ClassRestriction |
EDOALSQLCache.extractClassRestriction(long intid) |
ClassValueRestriction |
EDOALSQLCache.extractClassValueRestriction(PathExpression pe,
long intid) |
java.net.URI |
EDOALSQLCache.extractDatatype(long intid) |
Expression |
EDOALSQLCache.extractExpression(long intid) |
InstanceExpression |
EDOALSQLCache.extractInstanceExpression(long intid) |
InstanceId |
EDOALSQLCache.extractInstanceId(long intid) |
void |
EDOALSQLCache.extractLinkkeys(java.lang.String cellid,
EDOALCell cell) |
PathExpression |
EDOALSQLCache.extractPathExpression(long intid) |
PropertyConstruction |
EDOALSQLCache.extractPropertyConstruction(int op,
long intid) |
PropertyDomainRestriction |
EDOALSQLCache.extractPropertyDomainRestriction(long intid) |
PropertyExpression |
EDOALSQLCache.extractPropertyExpression(long intid) |
PropertyId |
EDOALSQLCache.extractPropertyId(long intid) |
PropertyTypeRestriction |
EDOALSQLCache.extractPropertyTypeRestriction(long intid) |
PropertyValueRestriction |
EDOALSQLCache.extractPropertyValueRestriction(long intid) |
RelationCoDomainRestriction |
EDOALSQLCache.extractRelationCoDomainRestriction(long intid) |
RelationConstruction |
EDOALSQLCache.extractRelationConstruction(int op,
long intid) |
RelationDomainRestriction |
EDOALSQLCache.extractRelationDomainRestriction(long intid) |
RelationExpression |
EDOALSQLCache.extractRelationExpression(long intid) |
RelationId |
EDOALSQLCache.extractRelationId(long intid) |
void |
EDOALSQLCache.extractTransformations(java.lang.String cellid,
EDOALCell cell) |
Value |
EDOALSQLCache.extractValue(long intid) |
ValueExpression |
EDOALSQLCache.extractValueExpression(long intid) |
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)
|
java.util.Set<Alignment> |
Cache.getAlignmentByURI(java.lang.String uri)
retrieve full alignment from URI or description
|
java.util.Set<Alignment> |
Cache.getAlignmentsByDescription(java.lang.String desc) |
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
|
OntologyNetwork |
VolatilCache.getOntologyNetwork(java.lang.String uri)
retrieve network of ontologies from id
|
OntologyNetwork |
Cache.getOntologyNetwork(java.lang.String uri)
retrieve network of ontologies from id
|
void |
EDOALSQLCache.init() |
void |
AServProtocolManager.init(DBService connection,
java.util.Properties prop) |
void |
VolatilCache.init(java.util.Properties p,
java.lang.String prefix)
loads the alignment descriptions from the database and put them in the
alignmentTable hashtable
|
void |
SQLCache.init(java.util.Properties p,
java.lang.String prefix)
loads the alignment descriptions from the database and put them in the
alignmentTable hashtable
|
void |
Cache.init(java.util.Properties p,
java.lang.String prefix)
loads the alignment descriptions from the database and put them in the
alignmentTable hashtable
|
static BasicOntologyNetwork |
LOVAlignmentService.readLOV(java.lang.String uri) |
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
|
java.lang.String |
VolatilCache.recordNewNetwork(java.lang.String uri,
OntologyNetwork network,
boolean force)
records alignment identified by id
|
java.lang.String |
Cache.recordNewNetwork(java.lang.String uri,
OntologyNetwork network,
boolean force)
records network identified by id and returns its idenfifier
|
long |
EDOALSQLCache.registerClassRestriction(int type,
long path,
long joinid) |
void |
VolatilCache.reset() |
void |
SQLCache.reset() |
void |
Cache.reset() |
void |
SQLCache.resetDatabase(boolean force) |
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) != "") {
|
void |
SQLCache.retrieveOntology(java.lang.String uri,
Ontology<?> ob) |
void |
VolatilCache.storeAlignment(java.lang.String uri) |
void |
SQLCache.storeAlignment(java.lang.String uri) |
void |
Cache.storeAlignment(java.lang.String uri) |
void |
VolatilCache.storeOntologyNetwork(java.lang.String uri) |
void |
SQLCache.storeOntologyNetwork(java.lang.String uri) |
void |
Cache.storeOntologyNetwork(java.lang.String uri) |
void |
SQLCache.unstoreAlignment(java.lang.String uri)
Non publicised class
|
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) |
void |
SQLCache.unstoreOntologyNetwork(java.lang.String uri,
BasicOntologyNetwork network) |
void |
VolatilCache.unstoreOntologyNetwork(java.lang.String uri,
OntologyNetwork network) |
void |
SQLCache.updateDatabase()
These queries are NOT compiled (through they could for most of them)
As this is obviously called before queries could be compiled
|
long |
EDOALSQLCache.visit(Aggregate e) |
long |
EDOALSQLCache.visit(Apply e) |
long |
EDOALSQLCache.visit(ClassConstruction e) |
long |
EDOALSQLCache.visit(ClassExpression e) |
long |
EDOALSQLCache.visit(ClassId e) |
long |
EDOALSQLCache.visit(ClassRestriction e) |
long |
EDOALSQLCache.visit(Expression e) |
long |
EDOALSQLCache.visit(InstanceExpression e) |
private void |
EDOALSQLCache.visit(LinkkeyBinding linkkeyBinding,
long keyid) |
void |
EDOALSQLCache.visit(Linkkey linkkey,
java.lang.String cellid) |
long |
EDOALSQLCache.visit(long pathid,
ClassDomainRestriction c) |
long |
EDOALSQLCache.visit(long pathid,
ClassOccurenceRestriction c) |
long |
EDOALSQLCache.visit(long pathid,
ClassTypeRestriction c) |
long |
EDOALSQLCache.visit(long pathid,
ClassValueRestriction c) |
long |
EDOALSQLCache.visit(PathExpression e) |
long |
EDOALSQLCache.visit(PropertyConstruction e) |
long |
EDOALSQLCache.visit(PropertyDomainRestriction c) |
long |
EDOALSQLCache.visit(PropertyExpression e) |
long |
EDOALSQLCache.visit(PropertyTypeRestriction c) |
long |
EDOALSQLCache.visit(PropertyValueRestriction c) |
long |
EDOALSQLCache.visit(RelationCoDomainRestriction c) |
long |
EDOALSQLCache.visit(RelationConstruction e) |
long |
EDOALSQLCache.visit(RelationDomainRestriction c) |
long |
EDOALSQLCache.visit(RelationExpression e) |
long |
EDOALSQLCache.visit(RelationRestriction c) |
long |
EDOALSQLCache.visit(Transformation transf,
java.lang.String cellid) |
long |
EDOALSQLCache.visit(Value e)
Retrieves Value, if it does not exists adds it
|
long |
EDOALSQLCache.visit(ValueExpression e) |
Constructor and Description |
---|
QueryMediator(Alignment a) |
QueryMediator(QueryProcessor proc,
Alignment a) |
Modifier and Type | Method and Description |
---|---|
void |
Visitable.accept(AlignmentVisitor visitor) |
Cell |
Alignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2) |
Cell |
Alignment.addAlignCell(java.lang.Object ob1,
java.lang.Object ob2,
java.lang.String relation,
double measure)
Cells are created and indexed at once
|
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) |
Cell |
Cell.compose(Cell c) |
void |
Alignment.cut(double threshold) |
void |
Alignment.cut(java.lang.String method,
double threshold)
Trim an alignment under a particular threshold
|
Alignment |
Alignment.diff(Alignment align) |
double |
Evaluator.eval(java.util.Properties param)
Run the evaluation between the two ontologies.
|
double |
Evaluator.eval(java.util.Properties param,
java.lang.Object cache)
Run the evaluation between the two ontologies.
|
Cell |
Alignment.getAlignCell1(java.lang.Object ob)
Cells are retrieved
These primitives are deprecated.
|
Cell |
Alignment.getAlignCell2(java.lang.Object ob)
//@deprecated There is more than one cell about one object
|
java.util.Set<Cell> |
Alignment.getAlignCells1(java.lang.Object ob)
Cells are retrieved
These primitives are deprecated.
|
java.util.Set<Cell> |
Alignment.getAlignCells2(java.lang.Object ob) |
java.lang.Object |
Alignment.getAlignedObject1(java.lang.Object ob)
Each part of the cell can be queried independently.
|
java.lang.Object |
Alignment.getAlignedObject2(java.lang.Object ob) |
Relation |
Alignment.getAlignedRelation1(java.lang.Object ob) |
Relation |
Alignment.getAlignedRelation2(java.lang.Object ob) |
double |
Alignment.getAlignedStrength1(java.lang.Object ob) |
double |
Alignment.getAlignedStrength2(java.lang.Object ob) |
java.net.URI |
Cell.getObject1AsURI() |
java.net.URI |
Cell.getObject1AsURI(Alignment al) |
java.net.URI |
Cell.getObject2AsURI() |
java.net.URI |
Cell.getObject2AsURI(Alignment al) |
java.net.URI |
Alignment.getOntology1URI() |
java.net.URI |
Alignment.getOntology2URI() |
void |
Alignment.harden(double threshold) |
void |
Alignment.init(java.lang.Object onto1,
java.lang.Object onto2)
Initialize the alignement before using it
|
void |
Alignment.init(java.lang.Object onto1,
java.lang.Object onto2,
java.lang.Object cache)
Initialize the alignement before using it, with some ontology caching trick
//@deprecated The OntologyCache is now internal, use init( onto1, onto2 ) instead
|
void |
AlignmentRepairer.init(java.util.Properties param)
Has to be invoked before using repair.
|
Cell |
Cell.inverse() |
Alignment |
Alignment.inverse()
Algebra of alignment manipulation operations: compose, join, meet.
|
void |
OntologyNetwork.invert()
close reflexively the network.
|
boolean |
LogicOntologyNetwork.isConsistent() |
boolean |
LogicOntologyNetwork.isEntailed(Alignment al) |
Alignment |
Alignment.join(Alignment align) |
Alignment |
Alignment.meet(Alignment align) |
void |
OntologyNetwork.remAlignment(Alignment al) |
void |
Alignment.remCell(Cell c) |
void |
OntologyNetwork.remOntology(java.net.URI onto) |
void |
Alignment.render(AlignmentVisitor renderer)
Exporting
The alignments are exported for other purposes.
|
Alignment |
AlignmentRepairer.repair(Alignment alignment,
java.util.Properties param)
Perform repair on the alignment.
|
OntologyNetwork |
AlignmentRepairer.repair(OntologyNetwork network,
java.util.Properties param)
Perform repair on a whole network of ontologies.
|
void |
Cell.setObject1(java.lang.Object ob) |
void |
Cell.setObject2(java.lang.Object ob) |
void |
Alignment.setOntology1(java.lang.Object ontology) |
void |
Alignment.setOntology2(java.lang.Object ontology) |
void |
AlignmentVisitor.visit(Alignment o) |
void |
AlignmentVisitor.visit(Cell o) |
void |
AlignmentVisitor.visit(Relation o) |
(C) INRIA & friends, 2003-2020