Alignment API and Server 4.2.${version.update}

Uses of Class
org.semanticweb.owl.align.AlignmentException

Packages that use AlignmentException
fr.inrialpes.exmo.align.gen   
fr.inrialpes.exmo.align.impl   
fr.inrialpes.exmo.align.impl.aggr   
fr.inrialpes.exmo.align.impl.edoal   
fr.inrialpes.exmo.align.impl.eval   
fr.inrialpes.exmo.align.impl.method   
fr.inrialpes.exmo.align.impl.rel   
fr.inrialpes.exmo.align.impl.renderer   
fr.inrialpes.exmo.align.ling   
fr.inrialpes.exmo.align.parser   
fr.inrialpes.exmo.align.service   
fr.inrialpes.exmo.align.util   
org.semanticweb.owl.align   
 

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}

(C) INRIA & friends, 2003-${curryear}