|
Alignment API and Server 4.1.${version.update} | |||||||||
PREV NEXT | FRAMES NO FRAMES |
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)
|
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 |
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 |
EDOALRelation.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 |
EDOALRelation.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)
|
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)
|
Constructors in fr.inrialpes.exmo.align.impl.edoal that throw AlignmentException | |
---|---|
ClassId(String id)
|
|
EDOALCell(String id,
Expression ob1,
Expression ob2,
EDOALRelation rel,
double m)
Creation |
|
EDOALRelation(String t)
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 |
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 |
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)
|
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 |
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 |
IncompatRelation.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 |
OWLAxiomsRendererVisitor.visit(EDOALRelation o)
The current implementation is not satisfying: EDOALRelation is deconnected from Relation (for historical purposes) This is left this way because the complete relations should be reengineered |
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 |
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 |
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)
|
void |
TypeCheckingVisitor.visit(Apply e)
|
void |
TypeCheckingVisitor.visit(ClassConstruction e)
|
void |
TypeCheckingVisitor.visit(ClassDomainRestriction c)
|
void |
TypeCheckingVisitor.visit(ClassExpression e)
|
void |
TypeCheckingVisitor.visit(ClassId e)
|
void |
TypeCheckingVisitor.visit(ClassOccurenceRestriction c)
|
void |
TypeCheckingVisitor.visit(ClassRestriction e)
|
void |
TypeCheckingVisitor.visit(ClassTypeRestriction c)
|
void |
TypeCheckingVisitor.visit(ClassValueRestriction c)
|
void |
TypeCheckingVisitor.visit(Datatype e)
|
void |
TypeCheckingVisitor.visit(EDOALAlignment align)
|
void |
TypeCheckingVisitor.visit(EDOALCell cell)
|
void |
TypeCheckingVisitor.visit(Expression o)
|
void |
TypeCheckingVisitor.visit(InstanceExpression e)
|
void |
TypeCheckingVisitor.visit(InstanceId e)
|
void |
TypeCheckingVisitor.visit(PathExpression p)
|
void |
TypeCheckingVisitor.visit(PropertyConstruction e)
|
void |
TypeCheckingVisitor.visit(PropertyDomainRestriction c)
|
void |
TypeCheckingVisitor.visit(PropertyExpression e)
|
void |
TypeCheckingVisitor.visit(PropertyId e)
|
void |
TypeCheckingVisitor.visit(PropertyRestriction e)
|
void |
TypeCheckingVisitor.visit(PropertyTypeRestriction c)
|
void |
TypeCheckingVisitor.visit(PropertyValueRestriction c)
|
void |
TypeCheckingVisitor.visit(RelationCoDomainRestriction c)
|
void |
TypeCheckingVisitor.visit(RelationConstruction e)
|
void |
TypeCheckingVisitor.visit(RelationDomainRestriction c)
|
void |
TypeCheckingVisitor.visit(RelationExpression e)
|
void |
TypeCheckingVisitor.visit(RelationId e)
|
void |
TypeCheckingVisitor.visit(RelationRestriction e)
|
void |
TypeCheckingVisitor.visit(Transformation trsf)
|
void |
TypeCheckingVisitor.visit(Value e)
|
void |
TypeCheckingVisitor.visit(ValueExpression e)
|
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 | |
---|---|
static OntologyNetwork |
OntologyNetworkWeakener.dropAlignments(OntologyNetwork on,
double n)
randomly drops n% of all alignments n is a number between 0. |
static OntologyNetwork |
OntologyNetworkWeakener.dropAlignments(OntologyNetwork on,
int n)
|
Evaluator |
GroupOutput.eval(String alignName1,
String alignName2)
|
static OntologyNetwork |
OntologyNetworkWeakener.weakenAlignments(OntologyNetwork on,
double n,
boolean threshold)
suppress n% of the correspondences at random in all alignments n is a number between 0. |
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.1.${version.update} | |||||||||
PREV NEXT | FRAMES NO FRAMES |