Uses of Class org.semanticweb.owl.align.AlignmentException (Alignment API and Server)
Date: 2010-03-31

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Alignment API and Server 4.0
PREV NEXT | FRAMES NO FRAMES

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

Packages that use AlignmentException
fr.inrialpes.exmo.align.impl |
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.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` | `DistanceAlignment.addAlignDistanceCell(Object ob1, Object ob2, String relation, double measure)`
`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)`
`double` | `DistanceAlignment.getAlignedDistance1(Object ob)`
`double` | `DistanceAlignment.getAlignedDistance2(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
`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.edoal

Methods in fr.inrialpes.exmo.align.impl.edoal that throw AlignmentException
`void` | `ValueConstraint.accept(AlignmentVisitor visitor)`
`void` | `Value.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` | `Apply.accept(AlignmentVisitor visitor)`
`void` | `Value.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)`
`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)`

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` | `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)`
`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.
`boolean` | `ExtPREvaluator.isSuperProperty(Object prop1, Object prop2, HeavyLoadedOntology<Object> ontology)`
`protected int` | `ExtPREvaluator.relativePosition(Object o1, Object o2, HeavyLoadedOntology<Object> onto)`
`int` | `ExtPREvaluator.superClassPosition(Object class1, Object class2, HeavyLoadedOntology<Object> onto)`

Constructors in fr.inrialpes.exmo.align.impl.eval that throw AlignmentException
`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` | `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` | `RDFRendererVisitor.visit(ClassDomainRestriction c)`
`void` | `RDFRendererVisitor.visit(ClassExpression e)`
`void` | `RDFRendererVisitor.visit(ClassId e)`
`void` | `RDFRendererVisitor.visit(ClassOccurenceRestriction c)`
`void` | `RDFRendererVisitor.visit(ClassRestriction e)`
`void` | `RDFRendererVisitor.visit(ClassTypeRestriction c)`
`void` | `RDFRendererVisitor.visit(ClassValueRestriction c)`
`void` | `RDFRendererVisitor.visit(Datatype e)`
`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` | `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` | `RDFRendererVisitor.visit(InstanceId e)`
`void` | `RDFRendererVisitor.visit(PathExpression p)`
`void` | `RDFRendererVisitor.visit(PropertyConstruction e)`
`void` | `RDFRendererVisitor.visit(PropertyDomainRestriction c)`
`void` | `RDFRendererVisitor.visit(PropertyExpression e)`
`void` | `RDFRendererVisitor.visit(PropertyId e)`
`void` | `RDFRendererVisitor.visit(PropertyRestriction e)`
`void` | `RDFRendererVisitor.visit(PropertyTypeRestriction c)`
`void` | `RDFRendererVisitor.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` | `RDFRendererVisitor.visit(RelationConstruction e)`
`void` | `RDFRendererVisitor.visit(RelationDomainRestriction c)`
`void` | `RDFRendererVisitor.visit(RelationExpression e)`
`void` | `RDFRendererVisitor.visit(RelationId e)`
`void` | `RDFRendererVisitor.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(Value e)`
`void` | `RDFRendererVisitor.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 corresponding to the URI 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 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(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.
`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)`

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Alignment API and Server 4.0
PREV NEXT | FRAMES NO FRAMES

(C) INRIA & friends, 2003-2010