|
Alignment API and Server 4.2.${version.update} | |||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of AlignmentException in fr.inrialpes.exmo.align.gen |
---|
Methods in fr.inrialpes.exmo.align.gen that throw AlignmentException | |
---|---|
OntologyNetwork |
OntologyNetworkWeakener.weaken(OntologyNetwork on,
double n,
Properties p)
Weakens the ontology network of n% |
OntologyNetwork |
NetworkDeconnector.weaken(OntologyNetwork on,
double n,
Properties p)
|
OntologyNetwork |
NetworkCorrespondenceDropper.weaken(OntologyNetwork on,
double n,
Properties p)
|
OntologyNetwork |
NetworkAlignmentWeakener.weaken(OntologyNetwork on,
double n,
Properties p)
|
OntologyNetwork |
NetworkAlignmentDropper.weaken(OntologyNetwork on,
double n,
Properties p)
|
OntologyNetwork |
OntologyNetworkWeakener.weaken(OntologyNetwork on,
int n,
Properties p)
Weakens the ontology network of n units |
OntologyNetwork |
NetworkDeconnector.weaken(OntologyNetwork on,
int n,
Properties p)
|
OntologyNetwork |
NetworkCorrespondenceDropper.weaken(OntologyNetwork on,
int n,
Properties p)
|
OntologyNetwork |
NetworkAlignmentWeakener.weaken(OntologyNetwork on,
int n,
Properties p)
|
OntologyNetwork |
NetworkAlignmentDropper.weaken(OntologyNetwork on,
int n,
Properties p)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.impl |
---|
Methods in fr.inrialpes.exmo.align.impl that throw AlignmentException | |
---|---|
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(Object ob1,
Object ob2)
|
Cell |
BasicAlignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
URIAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
BasicAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
URIAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
Cell methods |
Cell |
BasicAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
BasicAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure,
Extensions extensions)
Cell methods |
void |
BasicOntologyNetwork.addAlignment(Alignment al)
|
protected void |
BasicAlignment.addCell(Cell c)
|
void |
DistanceAlignment.align(Alignment alignment,
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. |
Cell |
ObjectCell.compose(Cell c)
|
Cell |
BasicCell.compose(Cell c)
|
Cell |
URIAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
ObjectAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
BasicAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
URIAlignment |
URIAlignment.createNewAlignment(Object onto1,
Object onto2)
|
ObjectAlignment |
ObjectAlignment.createNewAlignment(Object onto1,
Object onto2)
Generate a copy of this alignment object |
BasicAlignment |
BasicAlignment.createNewAlignment(Object onto1,
Object onto2)
Algebraic part This is to be improved by (TODO): - improving cell equivalence (maybe not dependent on the confidence... |
void |
BasicAlignment.cut(double threshold)
Default cut implementation For compatibility with API until version 1.1 |
void |
BasicAlignment.cut(String method,
double threshold)
Cut refinement : - getting those cells with strength above n (hard) - getting the n best cells (best) - getting those cells with strength at worse n under the best (span) - getting the n% best cells (perc) - getting those cells with strength at worse n% of the best (prop) - getting all cells until a gap of n (hardgap) - getting all cells until a gap of n% of the last (propgap) 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 |
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(String type,
Properties params)
Extract the alignment form the Similarity There are theoretically 16 types of extractors composing the characteristics [q]estion mark = ?, one or zero relation [s]tar = *, one, zero or many relations [1] = 1, exactly one relation [p]lus = +, one or many relations for each place of the relation. |
Cell |
URIAlignment.getAlignCell1(Object ob)
|
Cell |
BasicAlignment.getAlignCell1(Object ob)
|
Cell |
URIAlignment.getAlignCell2(Object ob)
|
Cell |
BasicAlignment.getAlignCell2(Object ob)
|
Set<Cell> |
URIAlignment.getAlignCells1(Object ob)
|
Set<Cell> |
BasicAlignment.getAlignCells1(Object ob)
|
Set<Cell> |
URIAlignment.getAlignCells2(Object ob)
|
Set<Cell> |
BasicAlignment.getAlignCells2(Object ob)
|
Object |
BasicAlignment.getAlignedObject1(Object ob)
|
Object |
BasicAlignment.getAlignedObject2(Object ob)
|
Relation |
BasicAlignment.getAlignedRelation1(Object ob)
|
Relation |
BasicAlignment.getAlignedRelation2(Object ob)
|
double |
BasicAlignment.getAlignedStrength1(Object ob)
|
double |
BasicAlignment.getAlignedStrength2(Object ob)
|
URI |
BasicCell.getObject1AsURI()
Since version 3.3, the interpretation of objects (and thus finding their URI) depends on the Ontology API which is used. |
URI |
URICell.getObject1AsURI(Alignment al)
|
URI |
ObjectCell.getObject1AsURI(Alignment al)
Used to order the cells in an alignment: -- this > c iff this.getStrength() < c.getStrength() -- public int compareTo( Cell c ){ //if ( ! (c instanceof Cell) ) return 1; if ( c.getStrength() > getStrength() ) return 1; if ( getStrength() > c.getStrength() ) return -1; return 0; } |
URI |
BasicCell.getObject1AsURI(Alignment al)
|
URI |
BasicCell.getObject2AsURI()
Since version 3.3, the interpretation of objects (and thus finding their URI) depends on the Ontology API which is used. |
URI |
URICell.getObject2AsURI(Alignment al)
|
URI |
ObjectCell.getObject2AsURI(Alignment al)
|
URI |
BasicCell.getObject2AsURI(Alignment al)
|
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. |
void |
URIAlignment.init(Object o1,
Object o2)
|
void |
ObjectAlignment.init(Object onto1,
Object onto2)
|
void |
BasicAlignment.init(Object onto1,
Object onto2)
|
void |
BasicAlignment.init(Object onto1,
Object onto2,
Object cache)
Initialises the Alignment object with two ontologies. |
Cell |
URICell.inverse()
|
Cell |
ObjectCell.inverse()
|
Cell |
BasicCell.inverse()
|
Alignment |
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()
|
Alignment |
BasicAlignment.join(Alignment align)
The second alignment is join 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'), r) any pair which is in only one alignment is discarded. |
void |
ObjectAlignment.loadInit(Alignment al)
|
(package private) static LoadedOntology |
ObjectAlignment.loadOntology(URI ref)
|
Alignment |
BasicAlignment.meet(Alignment align)
The second alignment is meet 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', meet(n,n'), r) any pair which is in only one alignment is preserved. |
void |
BasicOntologyNetwork.remAlignment(Alignment al)
|
void |
BasicAlignment.remCell(Cell c)
|
void |
BasicOntologyNetwork.remOntology(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. |
void |
BasicCell.setObject1(Object ob)
|
void |
BasicCell.setObject2(Object ob)
|
void |
URIAlignment.setOntology1(Object ontology)
|
void |
BasicAlignment.setOntology1(Object ontology)
|
void |
URIAlignment.setOntology2(Object ontology)
|
void |
BasicAlignment.setOntology2(Object ontology)
|
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)
|
Constructors in fr.inrialpes.exmo.align.impl that throw AlignmentException | |
---|---|
BasicCell(String id,
Object ob1,
Object ob2,
Relation rel,
double m)
Creation |
|
BasicEvaluator(Alignment align1,
Alignment align2)
Creation |
|
ObjectCell(String id,
Object ob1,
Object ob2,
Relation rel,
double m)
Creation |
|
URICell(String id,
URI ob1,
URI ob2,
Relation rel,
double m)
Creation |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.aggr |
---|
Methods in fr.inrialpes.exmo.align.impl.aggr that throw AlignmentException | |
---|---|
void |
ConsensusAggregator.extract(double minVal,
boolean absolute)
Extract the alignment from consensus If absolute, then retain correspondences scoring more than n Otherwise, retain those scoring more than n in average, i.e., n*nbAlignments |
void |
ConsensusAggregator.extract(int minVal,
boolean absolute)
Extract the alignment from consensus If absolute, then retain correspondences found in more than n alignments Otherwise, retain those found in more than n% of alignments |
void |
ConsensusAggregator.ingest(Alignment al)
Extract the alignment from consensus |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.edoal |
---|
Methods in fr.inrialpes.exmo.align.impl.edoal that throw AlignmentException | |
---|---|
void |
ValueConstraint.accept(AlignmentVisitor visitor)
|
void |
Value.accept(AlignmentVisitor visitor)
|
void |
Transformation.accept(AlignmentVisitor visitor)
|
void |
TransfService.accept(AlignmentVisitor visitor)
|
void |
RelationRestriction.accept(AlignmentVisitor visitor)
|
void |
RelationExpression.accept(AlignmentVisitor visitor)
|
void |
PropertyRestriction.accept(AlignmentVisitor visitor)
|
void |
PropertyExpression.accept(AlignmentVisitor visitor)
|
void |
PathExpression.accept(AlignmentVisitor visitor)
|
void |
InstanceExpression.accept(AlignmentVisitor visitor)
|
void |
Expression.accept(AlignmentVisitor visitor)
|
void |
EDOALCell.accept(AlignmentVisitor visitor)
|
void |
Datatype.accept(AlignmentVisitor visitor)
|
void |
Apply.accept(AlignmentVisitor visitor)
|
void |
Value.accept(TypeCheckingVisitor visitor)
|
void |
Transformation.accept(TypeCheckingVisitor visitor)
|
void |
PathExpression.accept(TypeCheckingVisitor visitor)
|
void |
Expression.accept(TypeCheckingVisitor visitor)
|
void |
EDOALCell.accept(TypeCheckingVisitor visitor)
|
void |
EDOALAlignment.accept(TypeCheckingVisitor visitor)
|
void |
Apply.accept(TypeCheckingVisitor visitor)
|
Cell |
EDOALAlignment.addAlignCell(EDOALCell rule)
Cell methods |
Cell |
EDOALAlignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
EDOALAlignment.addAlignCell(Object ob1,
Object ob2,
String relation,
double measure)
|
Cell |
EDOALAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
EDOALAlignment.addAlignCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure,
Extensions extensions)
|
Cell |
EDOALAlignment.createCell(String id,
Object ob1,
Object ob2,
Relation relation,
double measure)
|
Cell |
EDOALAlignment.getAlignCell1(Object ob)
|
Cell |
EDOALAlignment.getAlignCell2(Object ob)
|
Set<Cell> |
EDOALAlignment.getAlignCells1(Object ob)
|
Set<Cell> |
EDOALAlignment.getAlignCells2(Object ob)
|
private static Id |
EDOALAlignment.getEntity(LoadedOntology<Object> o,
URI u)
|
URI |
EDOALCell.getObject1AsURI(Alignment al)
|
URI |
EDOALCell.getObject2AsURI(Alignment al)
|
void |
EDOALAlignment.init(Object onto1,
Object onto2)
|
Transformation |
Transformation.inverse()
|
Cell |
EDOALCell.inverse()
|
void |
EDOALAlignment.loadInit(Alignment al)
|
void |
EDOALAlignment.setOntology1(Object ontology)
|
void |
EDOALAlignment.setOntology2(Object ontology)
|
static EDOALAlignment |
EDOALAlignment.toEDOALAlignment(URIAlignment al)
convert an URI alignment into a corresponding EDOALAlignment The same could be implemented for ObjectAlignent if necessary |
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)
|
Constructors in fr.inrialpes.exmo.align.impl.edoal that throw AlignmentException | |
---|---|
ClassId(String id)
|
|
EDOALCell(String id,
Expression ob1,
Expression ob2,
Relation rel,
double m)
Creation |
|
RelationId(String id)
|
|
Transformation(String type,
ValueExpression ob1,
ValueExpression ob2)
Creation |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.eval |
---|
Methods in fr.inrialpes.exmo.align.impl.eval that throw AlignmentException | |
---|---|
abstract Vector<Pair> |
GraphEvaluator.eval()
Returns the points to display in a graph |
double |
WeightedPREvaluator.eval(Properties params)
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'). |
double |
SymMeanEvaluator.eval(Properties params)
|
double |
PRecEvaluator.eval(Properties params)
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 Vector<Pair> |
GraphEvaluator.eval(Properties params)
Returns the points to display in a graph |
double |
ExtPREvaluator.eval(Properties params)
This is a partial implementation of [Ehrig & Euzenat 2005] because the relations are not taken into account (they are supposed to be always =) |
double |
DiffEvaluator.eval(Properties params)
|
double |
WeightedPREvaluator.eval(Properties params,
Object cache)
|
double |
SymMeanEvaluator.eval(Properties params,
Object cache)
|
double |
SemPRecEvaluator.eval(Properties params,
Object cache)
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'). |
double |
PRecEvaluator.eval(Properties params,
Object cache)
|
double |
ExtPREvaluator.eval(Properties params,
Object cache)
|
double |
DiffEvaluator.eval(Properties params,
Object cache)
|
void |
AveragePRGraphEvaluator.evalAlignment(Alignment align1,
Alignment align2)
|
double |
WeightedPREvaluator.getFallout()
|
double |
PRecEvaluator.getFallout()
|
int |
ExtPREvaluator.isSuperClass(Object class1,
Object class2,
HeavyLoadedOntology<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(Object prop1,
Object prop2,
HeavyLoadedOntology<Object> ontology)
|
protected int |
ExtPREvaluator.relativePosition(Object o1,
Object o2,
HeavyLoadedOntology<Object> onto)
Returns the relative position of two entities: 0: unrelated n: o1 is a n-step sub-entity of o2 -n: o2 is a n-step sub-entity of o1 |
int |
ExtPREvaluator.superClassPosition(Object class1,
Object class2,
HeavyLoadedOntology<Object> onto)
|
int |
ExtPREvaluator.superPropertyPosition(Object prop1,
Object prop2,
HeavyLoadedOntology<Object> onto)
|
Constructors in fr.inrialpes.exmo.align.impl.eval that throw AlignmentException | |
---|---|
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 align1,
Alignment align2)
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 |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.method |
---|
Methods in fr.inrialpes.exmo.align.impl.method that throw AlignmentException | |
---|---|
void |
StrucSubsDistAlignment.align(Alignment alignment,
Properties params)
Processing |
void |
StringDistAlignment.align(Alignment alignment,
Properties params)
|
void |
NameAndPropertyAlignment.align(Alignment alignment,
Properties params)
Processing |
void |
ClassStructAlignment.align(Alignment alignment,
Properties params)
Processing |
void |
StrucSubsDistAlignment.init(Object o1,
Object o2,
Object ontologies)
Initialisation The class requires HeavyLoadedOntologies |
void |
NameAndPropertyAlignment.init(Object o1,
Object o2,
Object ontologies)
Initialisation The class requires HeavyLoadedOntologies |
void |
ClassStructAlignment.init(Object o1,
Object o2,
Object ontologies)
Initialisation The class requires HeavyLoadedOntologies |
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.rel |
---|
Methods in fr.inrialpes.exmo.align.impl.rel that throw AlignmentException | |
---|---|
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)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.impl.renderer |
---|
Methods in fr.inrialpes.exmo.align.impl.renderer that throw AlignmentException | |
---|---|
private void |
XSLTRendererVisitor.collectURIs(Cell cell)
|
URI |
SKOSRendererVisitor.getURI2()
|
void |
COWLMappingRendererVisitor.printObject(Object ob,
LoadedOntology onto)
|
void |
XSLTRendererVisitor.visit(Alignment align)
|
void |
XMLMetadataRendererVisitor.visit(Alignment align)
|
void |
SWRLRendererVisitor.visit(Alignment align)
|
void |
SKOSRendererVisitor.visit(Alignment align)
|
void |
SEKTMappingRendererVisitor.visit(Alignment align)
|
void |
RDFRendererVisitor.visit(Alignment align)
|
void |
OWLAxiomsRendererVisitor.visit(Alignment align)
|
void |
HTMLRendererVisitor.visit(Alignment align)
|
void |
HTMLMetadataRendererVisitor.visit(Alignment align)
|
void |
COWLMappingRendererVisitor.visit(Alignment align)
|
void |
RDFRendererVisitor.visit(Apply e)
|
void |
OWLAxiomsRendererVisitor.visit(Apply e)
|
void |
XSLTRendererVisitor.visit(Cell cell)
|
void |
SWRLRendererVisitor.visit(Cell cell)
|
void |
SKOSRendererVisitor.visit(Cell cell)
|
void |
SEKTMappingRendererVisitor.visit(Cell cell)
|
void |
RDFRendererVisitor.visit(Cell cell)
|
void |
OWLAxiomsRendererVisitor.visit(Cell cell)
|
void |
HTMLRendererVisitor.visit(Cell cell)
|
void |
COWLMappingRendererVisitor.visit(Cell cell)
|
void |
RDFRendererVisitor.visit(ClassConstruction e)
|
void |
OWLAxiomsRendererVisitor.visit(ClassConstruction e)
|
void |
RDFRendererVisitor.visit(ClassDomainRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(ClassDomainRestriction c)
|
void |
RDFRendererVisitor.visit(ClassExpression e)
|
void |
OWLAxiomsRendererVisitor.visit(ClassExpression e)
|
void |
RDFRendererVisitor.visit(ClassId e)
|
void |
OWLAxiomsRendererVisitor.visit(ClassId e)
|
void |
RDFRendererVisitor.visit(ClassOccurenceRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(ClassOccurenceRestriction c)
|
void |
RDFRendererVisitor.visit(ClassRestriction e)
|
void |
OWLAxiomsRendererVisitor.visit(ClassRestriction e)
|
void |
RDFRendererVisitor.visit(ClassTypeRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(ClassTypeRestriction c)
|
void |
RDFRendererVisitor.visit(ClassValueRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(ClassValueRestriction c)
|
void |
RDFRendererVisitor.visit(Datatype e)
|
void |
OWLAxiomsRendererVisitor.visit(EDOALCell cell)
|
void |
XSLTRendererVisitor.visit(EquivRelation rel)
|
void |
SWRLRendererVisitor.visit(EquivRelation rel)
|
void |
SKOSRendererVisitor.visit(EquivRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(EquivRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(EquivRelation rel)
|
void |
COWLMappingRendererVisitor.visit(EquivRelation rel)
|
void |
RDFRendererVisitor.visit(Expression o)
|
void |
OWLAxiomsRendererVisitor.visit(Expression o)
|
void |
OWLAxiomsRendererVisitor.visit(HasInstanceRelation rel)
|
void |
SKOSRendererVisitor.visit(IncompatRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(IncompatRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(IncompatRelation rel)
|
void |
COWLMappingRendererVisitor.visit(IncompatRelation rel)
|
void |
RDFRendererVisitor.visit(InstanceExpression e)
|
void |
OWLAxiomsRendererVisitor.visit(InstanceExpression e)
|
void |
RDFRendererVisitor.visit(InstanceId e)
|
void |
OWLAxiomsRendererVisitor.visit(InstanceId e)
|
void |
OWLAxiomsRendererVisitor.visit(InstanceOfRelation rel)
|
void |
RDFRendererVisitor.visit(PathExpression p)
|
void |
OWLAxiomsRendererVisitor.visit(PathExpression p)
|
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 |
RDFRendererVisitor.visit(PropertyDomainRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(PropertyDomainRestriction c)
|
void |
RDFRendererVisitor.visit(PropertyExpression e)
|
void |
OWLAxiomsRendererVisitor.visit(PropertyExpression e)
|
void |
RDFRendererVisitor.visit(PropertyId e)
|
void |
OWLAxiomsRendererVisitor.visit(PropertyId e)
|
void |
RDFRendererVisitor.visit(PropertyRestriction e)
|
void |
OWLAxiomsRendererVisitor.visit(PropertyRestriction e)
|
void |
RDFRendererVisitor.visit(PropertyTypeRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(PropertyTypeRestriction c)
|
void |
RDFRendererVisitor.visit(PropertyValueRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(PropertyValueRestriction c)
|
void |
XSLTRendererVisitor.visit(Relation rel)
|
void |
SWRLRendererVisitor.visit(Relation rel)
|
void |
SKOSRendererVisitor.visit(Relation rel)
|
void |
SEKTMappingRendererVisitor.visit(Relation rel)
|
void |
OWLAxiomsRendererVisitor.visit(Relation rel)
|
void |
COWLMappingRendererVisitor.visit(Relation rel)
|
void |
RDFRendererVisitor.visit(RelationCoDomainRestriction c)
|
void |
OWLAxiomsRendererVisitor.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 |
RDFRendererVisitor.visit(RelationDomainRestriction c)
|
void |
OWLAxiomsRendererVisitor.visit(RelationDomainRestriction c)
|
void |
RDFRendererVisitor.visit(RelationExpression e)
|
void |
OWLAxiomsRendererVisitor.visit(RelationExpression e)
|
void |
RDFRendererVisitor.visit(RelationId e)
|
void |
OWLAxiomsRendererVisitor.visit(RelationId e)
|
void |
RDFRendererVisitor.visit(RelationRestriction e)
|
void |
OWLAxiomsRendererVisitor.visit(RelationRestriction e)
|
void |
SKOSRendererVisitor.visit(SubsumedRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(SubsumedRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(SubsumedRelation rel)
|
void |
COWLMappingRendererVisitor.visit(SubsumedRelation rel)
|
void |
SKOSRendererVisitor.visit(SubsumeRelation rel)
|
void |
SEKTMappingRendererVisitor.visit(SubsumeRelation rel)
|
void |
OWLAxiomsRendererVisitor.visit(SubsumeRelation rel)
|
void |
COWLMappingRendererVisitor.visit(SubsumeRelation rel)
|
void |
RDFRendererVisitor.visit(Transformation transf)
|
void |
OWLAxiomsRendererVisitor.visit(Transformation transf)
|
void |
RDFRendererVisitor.visit(Value e)
|
void |
OWLAxiomsRendererVisitor.visit(Value e)
|
void |
RDFRendererVisitor.visit(ValueExpression e)
|
void |
OWLAxiomsRendererVisitor.visit(ValueExpression e)
|
void |
XSLTRendererVisitor.visit(Visitable o)
|
void |
XMLMetadataRendererVisitor.visit(Visitable o)
|
void |
SWRLRendererVisitor.visit(Visitable o)
|
void |
SKOSRendererVisitor.visit(Visitable o)
|
void |
SEKTMappingRendererVisitor.visit(Visitable o)
|
void |
RDFRendererVisitor.visit(Visitable o)
|
void |
OWLAxiomsRendererVisitor.visit(Visitable o)
|
void |
HTMLRendererVisitor.visit(Visitable o)
|
void |
HTMLMetadataRendererVisitor.visit(Visitable o)
|
void |
COWLMappingRendererVisitor.visit(Visitable o)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.ling |
---|
Methods in fr.inrialpes.exmo.align.ling that throw AlignmentException | |
---|---|
void |
JWNLAlignment.align(Alignment alignment,
Properties prop)
Processing |
void |
JWNLAlignment.WordNetMatrixMeasure.init()
|
void |
JWNLAlignment.WordNetMatrixMeasure.init(String wndict)
|
void |
JWNLAlignment.WordNetMatrixMeasure.init(String wndict,
String wnvers)
|
void |
JWNLAlignment.WordNetMatrixMeasure.init(String wndict,
String wnvers,
int simFunction)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.parser |
---|
Methods in fr.inrialpes.exmo.align.parser that throw AlignmentException | |
---|---|
private Alignment |
AlignmentParser.callParser(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,
Object o)
|
private Alignment |
AlignmentParser.callParser(XMLParser p,
Object o)
This dispatch is ridiculous, but that's life |
protected URI |
RDFParser.getNodeId(com.hp.hpl.jena.rdf.model.Resource node)
|
static Object |
SyntaxElement.getResource(String name)
Returns the resource of the element. |
EDOALAlignment |
RDFParser.parse(File file)
|
Alignment |
XMLParser.parse(InputStream s)
Parses a string instead of a URI |
EDOALAlignment |
RDFParser.parse(InputStream is)
|
Alignment |
AlignmentParser.parse(InputStream s)
Parses an inputStream |
EDOALAlignment |
RDFParser.parse(com.hp.hpl.jena.rdf.model.Model rdfmodel)
Parse the input model. |
Alignment |
XMLParser.parse(Reader r)
Parses a reader, used for reading from a string |
EDOALAlignment |
RDFParser.parse(Reader is)
|
Alignment |
AlignmentParser.parse(Reader r)
Parses a the content of a reader |
Alignment |
XMLParser.parse(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(String uri)
|
Alignment |
AlignmentParser.parse(String uri)
Parses a URI expressed as a String |
Alignment |
AlignmentParser.parse(String uri,
Hashtable loaded)
Deprecated. use parse( URI ) instead |
Alignment |
AlignmentParser.parse(URI uri)
Parses a URI |
EDOALAlignment |
RDFParser.parseAlignment(com.hp.hpl.jena.rdf.model.Resource node)
Parses a mapping document. |
protected void |
RDFParser.parseAnnotation(com.hp.hpl.jena.rdf.model.Statement stmt,
EDOALAlignment al)
Parses a given annotaion in the the given node. |
protected EDOALCell |
RDFParser.parseCell(com.hp.hpl.jena.rdf.model.Resource node)
Parses a mapping rule. |
protected ClassExpression |
RDFParser.parseClass(com.hp.hpl.jena.rdf.model.Resource node)
|
protected Expression |
RDFParser.parseExpression(com.hp.hpl.jena.rdf.model.Resource node)
|
protected InstanceExpression |
RDFParser.parseInstance(com.hp.hpl.jena.rdf.model.Resource node)
|
protected Ontology |
RDFParser.parseOntology(com.hp.hpl.jena.rdf.model.Resource node)
Parse an ontology node <onto1> or
<onto2> Node to an Ontology object. |
protected PathExpression |
RDFParser.parsePathExpression(com.hp.hpl.jena.rdf.model.Resource node)
|
protected PropertyExpression |
RDFParser.parseProperty(com.hp.hpl.jena.rdf.model.Resource node)
|
protected RelationExpression |
RDFParser.parseRelation(com.hp.hpl.jena.rdf.model.Resource node)
|
Alignment |
AlignmentParser.parseString(String s)
Parses the content of a string |
protected Transformation |
RDFParser.parseTransformation(com.hp.hpl.jena.rdf.model.Resource node)
|
protected ValueExpression |
RDFParser.parseValue(com.hp.hpl.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(ClassExpression e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassId e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassOccurenceRestriction c)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ClassRestriction e)
|
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(Expression o)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(InstanceExpression e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(InstanceId e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PathExpression p)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyConstruction e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyDomainRestriction c)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyExpression e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyId e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyRestriction e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyTypeRestriction c)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(PropertyValueRestriction c)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationCoDomainRestriction c)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationConstruction e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationDomainRestriction c)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationExpression e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationId e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(RelationRestriction e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Transformation trsf)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Value e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(ValueExpression e)
|
TypeCheckingVisitor.TYPE |
TypeCheckingVisitor.visit(Visitable o)
|
Uses of AlignmentException in fr.inrialpes.exmo.align.service |
---|
Methods in fr.inrialpes.exmo.align.service that throw AlignmentException | |
---|---|
void |
WSAlignment.align(Alignment alignment,
Properties params)
Process matching This does not work with regular AServ web service because it returns an URL |
Alignment |
CacheImpl.getAlignment(String id)
retrieve full alignment from id (and cache it) |
Alignment |
CacheImpl.getMetadata(String id)
retrieve alignment metadata from id This is more difficult because we return the alignment we have disreagarding if it is complete o only metadata |
void |
AServProtocolManager.init(DBService connection,
Properties prop)
|
void |
CacheImpl.init(Properties p)
loads the alignment descriptions from the database and put them in the alignmentTable hashtable |
String |
CacheImpl.recordNewAlignment(String id,
Alignment al,
boolean force)
records alignment identified by id |
void |
CacheImpl.resetDatabase(boolean force)
|
protected Alignment |
CacheImpl.retrieveAlignment(String id,
Alignment alignment)
loads the full alignments from the database and put them in the alignmentTable hastable should be invoked when: ( result.getExtension(CACHED) == "" && result.getExtension(STORED) != "") { |
String |
QueryMediator.rewriteQuery(String aQuery)
|
static String |
QueryMediator.rewriteSPARQLQuery(String aQuery,
Alignment align)
|
void |
CacheImpl.storeAlignment(String id)
|
void |
CacheImpl.unstoreAlignment(String id)
Non publicised class |
void |
CacheImpl.updateDatabase()
|
Uses of AlignmentException in fr.inrialpes.exmo.align.util |
---|
Methods in fr.inrialpes.exmo.align.util that throw AlignmentException | |
---|---|
Evaluator |
GroupOutput.eval(String alignName1,
String alignName2)
|
Uses of AlignmentException in org.semanticweb.owl.align |
---|
Methods in org.semanticweb.owl.align that throw AlignmentException | |
---|---|
void |
Visitable.accept(AlignmentVisitor visitor)
|
Cell |
Alignment.addAlignCell(Object ob1,
Object ob2)
|
Cell |
Alignment.addAlignCell(Object ob1,
Object ob,
String relation,
double measure)
Cells are created and indexed at once |
void |
OntologyNetwork.addAlignment(Alignment al)
|
void |
AlignmentProcess.align(Alignment alignment,
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(String method,
double threshold)
|
Alignment |
Alignment.diff(Alignment align)
|
double |
Evaluator.eval(Properties param)
Run the evaluation between the two ontologies. |
double |
Evaluator.eval(Properties param,
Object cache)
Run the evaluation between the two ontologies. |
Cell |
Alignment.getAlignCell1(Object ob)
Cells are retrieved These primitives are deprecated. |
Cell |
Alignment.getAlignCell2(Object ob)
//@deprecated There is more than one cell about one object |
Set<Cell> |
Alignment.getAlignCells1(Object ob)
Cells are retrieved These primitives are deprecated. |
Set<Cell> |
Alignment.getAlignCells2(Object ob)
|
Object |
Alignment.getAlignedObject1(Object ob)
Each part of the cell can be queried independently. |
Object |
Alignment.getAlignedObject2(Object ob)
|
Relation |
Alignment.getAlignedRelation1(Object ob)
|
Relation |
Alignment.getAlignedRelation2(Object ob)
|
double |
Alignment.getAlignedStrength1(Object ob)
|
double |
Alignment.getAlignedStrength2(Object ob)
|
URI |
Cell.getObject1AsURI()
//@deprecated use getObject1AsURI( null ) instead |
URI |
Cell.getObject1AsURI(Alignment al)
|
URI |
Cell.getObject2AsURI()
//@deprecated use getObject2AsURI( null ) instead |
URI |
Cell.getObject2AsURI(Alignment al)
|
URI |
Alignment.getOntology1URI()
|
URI |
Alignment.getOntology2URI()
|
void |
Alignment.harden(double threshold)
|
void |
Alignment.init(Object onto1,
Object onto2)
Initialize the alignement before using it |
void |
Alignment.init(Object onto1,
Object onto2,
Object cache)
Initialize the alignement before using it, with some ontology caching trick //@deprecated The OntologyCache is now internal, use init( onto1, onto2 ) instead |
Cell |
Cell.inverse()
|
Alignment |
Alignment.inverse()
Algebra of alignment manipulation operations: compose, join, meet. |
void |
OntologyNetwork.invert()
close reflexively the network. |
Alignment |
Alignment.join(Alignment align)
|
Alignment |
Alignment.meet(Alignment align)
|
void |
OntologyNetwork.remAlignment(Alignment al)
|
void |
Alignment.remCell(Cell c)
|
void |
OntologyNetwork.remOntology(URI onto)
|
void |
Alignment.render(AlignmentVisitor renderer)
Exporting The alignments are exported for other purposes. |
void |
Cell.setObject1(Object ob)
|
void |
Cell.setObject2(Object ob)
|
void |
Alignment.setOntology1(Object ontology)
|
void |
Alignment.setOntology2(Object ontology)
|
void |
AlignmentVisitor.visit(Visitable o)
|
|
Alignment API and Server 4.2.${version.update} | |||||||||
PREV NEXT | FRAMES NO FRAMES |