Uses of Class
conformance.PortedFrom

Packages that use PortedFrom

Package	Description
uk.ac.manchester.cs.jfact.datatypes
uk.ac.manchester.cs.jfact.dep
uk.ac.manchester.cs.jfact.elf
uk.ac.manchester.cs.jfact.helpers
uk.ac.manchester.cs.jfact.kernel
uk.ac.manchester.cs.jfact.kernel.actors
uk.ac.manchester.cs.jfact.kernel.dl
uk.ac.manchester.cs.jfact.kernel.dl.axioms
uk.ac.manchester.cs.jfact.kernel.dl.interfaces
uk.ac.manchester.cs.jfact.kernel.modelcaches
uk.ac.manchester.cs.jfact.kernel.state
uk.ac.manchester.cs.jfact.split
uk.ac.manchester.cs.jfact.visitors

Uses of PortedFrom in uk.ac.manchester.cs.jfact.datatypes

Classes in uk.ac.manchester.cs.jfact.datatypes with annotations of type PortedFrom

Modifier and Type	Class and Description
class	DataTypeReasoner

Methods in uk.ac.manchester.cs.jfact.datatypes with annotations of type PortedFrom

Modifier and Type	Method and Description
boolean	DataTypeReasoner.addDataEntry(boolean positive, DagTag type, NamedEntry entry, DepSet dep)
boolean	DataTypeReasoner.checkClash()
DepSet	DataTypeReasoner.getClashSet() get clash-set
int	DatatypeEntry.getIndex() get pointer to DAG entry corresponding to the data entry
void	DatatypeEntry.setIndex(int p) set DAG index of the data entry

Uses of PortedFrom in uk.ac.manchester.cs.jfact.dep

Classes in uk.ac.manchester.cs.jfact.dep with annotations of type PortedFrom

Modifier and Type	Class and Description
class	DepSet Dependency set

Methods in uk.ac.manchester.cs.jfact.dep with annotations of type PortedFrom

Modifier and Type	Method and Description
void	DepSet.add(DepSet toAdd)
void	DepSet.add(FastSetSimple d)
void	DepSet.clear() empty the delegate
boolean	DepSet.contains(int level)
static DepSet	DepSet.create()
static DepSet	DepSet.create(DepSet dep)
static DepSet	DepSet.create(FastSetSimple delegate)
static DepSet	DepSet.create(int i)
int	DepSet.get(int i)
boolean	DepSet.isEmpty()
int	DepSet.level()
static DepSet	DepSet.plus(DepSet ds1, DepSet ds2)
void	DepSet.restrict(int level)
int	DepSet.size()

Uses of PortedFrom in uk.ac.manchester.cs.jfact.elf

Classes in uk.ac.manchester.cs.jfact.elf with annotations of type PortedFrom

Modifier and Type	Class and Description
class	CAddFillerRule rule that checks an addition of C to S(Y) and checks whether there is X s.t.
class	CAndSubRule the rule for C1 and C2 [= D case
class	CExistSubRule rule that checks the addition of (X,Y) to R and finds a C in S(Y)
class	CSubRule the rule for C [= D case
class	ELFAxiomChecker
class	ELFExpressionChecker
class	ELFNormalizer
class	ELFReasoner
class	RAddRule the rule for C [= \ER.D case
class	RBotRule
class	RChainLRule the rule for R in R o S [= T case
class	RChainRRule the rule for S in R o S [= T case
class	RSubRule the rule for R [= S case

Methods in uk.ac.manchester.cs.jfact.elf with annotations of type PortedFrom

Modifier and Type	Method and Description
void	ELFReasoner.classify() classification method
protected uk.ac.manchester.cs.jfact.elf.TELFConcept	ELFReasoner.getC(ConceptExpression p) get concept (expression) corresponding to a given DL expression
protected void	ELFReasoner.processCI(AxiomConceptInclusion axiom) process concept inclusion axiom into the internal structures
protected void	ELFReasoner.processDeclaration(AxiomDeclaration axiom) process declaration axiom
boolean	ELFAxiomChecker.value()
void	ELFNormalizer.visitOntology(Ontology ontology)
void	ELFAxiomChecker.visitOntology(Ontology ontology)

Uses of PortedFrom in uk.ac.manchester.cs.jfact.helpers

Classes in uk.ac.manchester.cs.jfact.helpers with annotations of type PortedFrom

Modifier and Type	Class and Description
class	DLTree DLTree class
class	DLVertex DL Vertex
class	SaveStack<T>

Fields in uk.ac.manchester.cs.jfact.helpers with annotations of type PortedFrom

Modifier and Type	Field and Description
protected long	DLVertex.negUsage
protected long	DLVertex.posUsage usage statistic for pos- and neg occurences of a vertex
protected int[]	DLVertex.stat maximal depth, size and frequency of reference of the expression

Methods in uk.ac.manchester.cs.jfact.helpers with annotations of type PortedFrom

Modifier and Type	Method and Description
boolean	DLVertex.addChild(int p)
int[]	DLVertex.begin()
NamedEntry	DLVertex.getConcept()
int	DLVertex.getConceptIndex()
int	DLVertex.getDepth(boolean pos) general access to a stat value by index
int	DLVertex.getNumberGE()
int	DLVertex.getNumberLE()
Role	DLVertex.getProjRole()
Role	DLVertex.getRole()
MergableLabel	DLVertex.getSort() get RW access to the label
int	DLVertex.getStat(int i) general access to a stat value by index
int	DLVertex.getState()
long	DLVertex.getUsage(boolean pos) get access to a usage wrt POS
void	DLVertex.incFreqValue(boolean pos) increment frequency value
boolean	SaveStack.isEmpty()
void	DLVertex.merge(MergableLabel label) merge local label to label LABEL
T	SaveStack.pop()
T	SaveStack.pop(int depth) get an object from a fixed depth
void	SaveStack.push(T e)
void	DLVertex.setChild(int p) set a concept (child) to Name-like vertex
void	DLVertex.setConcept(NamedEntry p) set TConcept value to entry
void	DLVertex.sortEntry(DLDag dag)
T	SaveStack.top()
T	SaveStack.top(int depth) get an object from a fixed depth
void	DLVertex.updateStatValues(DLVertex v, boolean posV, boolean pos) add-up all values at once by a given vertex
void	DLVertex.updateStatValues(int d, int s, int b, int g, boolean pos) add-up all stat values at once by explicit values

Uses of PortedFrom in uk.ac.manchester.cs.jfact.kernel

Classes in uk.ac.manchester.cs.jfact.kernel with annotations of type PortedFrom

Modifier and Type	Class and Description
class	Axiom
class	AxiomSet
class	CGLabel
class	ClassifiableEntry
class	Concept
class	ConceptWDep
class	CWDArray
class	DlCompletionGraph
class	DlCompletionTree
class	DlCompletionTreeArc
class	DLConceptTaxonomy
class	DLDag
class	DlSatTester
class	ExpressionManager
class	ExpressionTranslator
class	InAx
class	Individual
class	KBFlags
class	Lexeme
class	LogicFeatures
class	MergableLabel
interface	NameCreator<T>
class	NamedEntry
class	NameSet<T>
class	NominalReasoner
class	Ontology
class	OntologyLoader
class	RAStateTransitions class to represent transitions from a single state in an automaton
class	RATransition
class	ReasoningKernel
class	Related
class	Restorer
class	Role
class	RoleAutomaton
class	RoleMaster
class	Taxonomy
class	TaxonomyVertex
class	TBox
class	TDag2Interface class to translate DAG entities into the TDL* expressions
class	ToDoList

Fields in uk.ac.manchester.cs.jfact.kernel with annotations of type PortedFrom

Modifier and Type	Field and Description
protected List<RATransition>	RAStateTransitions.base all transitions
protected uk.ac.manchester.cs.jfact.kernel.DlSatTester.BranchingContext	DlSatTester.bContext context from the restored branching rule
protected DlCompletionGraph	DlSatTester.cGraph Completion Graph of tested concept(s)
protected long	Taxonomy.checkLabel labellers for marking taxonomy
protected ClassifiableEntry	Taxonomy.curEntry pointer to currently classified entry
protected DlCompletionTree	DlSatTester.curNode currently processed CTree node
protected TaxonomyVertex	Taxonomy.current aux.
protected DLTree	Concept.description
protected DLDag	DlSatTester.dlHeap link to dag from TBox
protected boolean	RAStateTransitions.emptyTransition check whether there is an empty transition going from this state
protected NamedEntity	NamedEntry.entity
protected int	NamedEntry.extId entry identifier
protected String	NamedEntry.extName name of the entry
static int	RoleAutomaton.final_state get the state
protected int	ClassifiableEntry.index index as a vertex in the SubsumptionMap
protected LinkedList<uk.ac.manchester.cs.jfact.kernel.Taxonomy.KnownSubsumers>	Taxonomy.ksStack told subsumers corresponding to a given entry
protected int	TBox.nC number of concepts and individuals; used to set index for modelCache
protected long	Taxonomy.nCDEntries number of completely-defined entries
protected int	DLConceptTaxonomy.nCommon number of processed common parents
protected int	Taxonomy.nEntries number of tested entryes
protected List<Individual>	NominalReasoner.nominals all nominals defined in TBox
protected int	DlSatTester.nonDetShift shift in order to determine the 1st non-det application
protected int	TBox.nR number of all distinct roles; used to set index for modelCache
protected ClassifiableEntry	ClassifiableEntry.pSynonym pointer to synonym (entry which contains whole information the same as current)
TSplitVars	Ontology.Splits
protected uk.ac.manchester.cs.jfact.kernel.DlSatTester.BCStack	DlSatTester.stack stack for the local reasoner's state
protected TaxonomyVertex	ClassifiableEntry.taxVertex link to taxonomy entry for current entry
protected TBox	DlSatTester.tBox host TBox
protected TBox	AxiomSet.tboxHost host TBox that holds all concepts/etc
protected Set<ClassifiableEntry>	ClassifiableEntry.toldSubsumers links to 'told subsumers' (entries that are direct super-entries for current)
protected boolean	Taxonomy.useCompletelyDefined optimisation flag: if entry is completely defined by it's told subsumers, no other classification required
protected long	Taxonomy.valueLabel
protected boolean	Taxonomy.willInsertIntoTaxonomy behaviour flag: if true, insert temporary vertex into taxonomy

Methods in uk.ac.manchester.cs.jfact.kernel with annotations of type PortedFrom

Modifier and Type	Method and Description
int	AxiomSet.absorb()
void	TBox.absorbAxioms() absorb all axioms
boolean	Axiom.absorbIntoBottom(TBox KB) absorb into BOTTOM; @return true if absorption is performed
boolean	Axiom.absorbIntoConcept(TBox KB)
boolean	Axiom.absorbIntoDomain(TBox KB)
boolean	Axiom.absorbIntoNegConcept(TBox KB) absorb into negation of a concept; @return true if absorption is performed
boolean	Axiom.absorbIntoTop(TBox KB) absorb into TOP; @return true if absorption performs
Axiom	Ontology.add(Axiom p) add given axiom to the ontology
void	Axiom.add(DLTree p) add DLTree to an axiom
int	DLDag.add(DLVertex v)
void	RATransition.add(RATransition trans) add label of transition TRANS to transition's label
void	RAStateTransitions.add(RATransition trans) add a transition from a given state
T	NameSet.add(String id) unconditionally add new element with name ID to the set; return new element
void	AxiomSet.addAxiom(DLTree C, DLTree D) add axiom for the GCI C [= D
void	Role.addComposition(DLTree tree) add composition to a role
void	TBox.addConceptToHeap(Concept pConcept)
void	DlCompletionGraph.addConceptToNode(DlCompletionTree node, ConceptWDep c, DagTag tag) add concept C of a type TAG to NODE; call blocking check if appropriate
void	RoleAutomaton.addCopy(RoleAutomaton RA)
void	Taxonomy.addCurrentToSynonym(TaxonomyVertex syn)
int	TBox.addDataExprToHeap(DatatypeEntry p)
int	TBox.addDataExprToHeap(LiteralEntry p)
void	ConceptWDep.addDep(DepSet d) add dep-set to a CWD
void	Concept.addDesc(DLTree Desc)
void	Role.addDisjointRole(Role R) set R and THIS as a disjoint; use it after Anc/Desc are determined
void	RoleMaster.addDisjointRoles(Role R, Role S) a pair of disjoint roles
void	ToDoList.addEntry(DlCompletionTree node, DagTag type, ConceptWDep C) add entry with given NODE and CONCEPT with given OFFSET to the Todo table
void	Concept.addExtraRule(int p) add index of a simple rule in TBox to the ER set
void	Role.addFeaturesToSynonym()
void	TaxonomyVertex.addNeighbour(boolean upDirection, TaxonomyVertex p) add link in given direction to vertex
boolean	TBox.addNonprimitiveDefinition(DLTree left, DLTree right)
void	ClassifiableEntry.addParent(ClassifiableEntry parent) add told subsumer of entry (duplications possible)
void	ClassifiableEntry.addParentIfNew(ClassifiableEntry parent)
void	ClassifiableEntry.addParents(Collection<ClassifiableEntry> entries) add all parents (with duplicates) from the range to current node
void	RoleAutomaton.addRA(RoleAutomaton RA) add RA from a subrole to given one
void	Individual.addRelated(Individual p) add all the related elements from the given P
void	Individual.addRelated(Related p) set individual related
DlCompletionTreeArc	DlCompletionGraph.addRoleLabel(DlCompletionTree from, DlCompletionTree to, boolean isPredEdge, Role R, DepSet dep) add role R with dep-set DEP to the label of the TO arc
void	RoleMaster.addRoleParent(DLTree tree, Role parent)
void	RoleMaster.addRoleParentProper(Role role, Role parent) add parent for the input role
void	RoleMaster.addRoleSynonym(Role role, Role syn) add synonym to existing role
void	TBox.addSimpleRule(uk.ac.manchester.cs.jfact.kernel.SimpleRule Rule) add simple rule RULE to the TBox' rules
void	TBox.addSubsumeAxiom(Concept C, DLTree D) add axiom CN [= D for concept CN
void	TBox.addSubsumeAxiom(DLTree sub, DLTree sup)
void	TBox.addSubsumeForDefined(Concept C, DLTree D)
void	TaxonomyVertex.addSynonym(ClassifiableEntry p) add P as a synonym to curent vertex
boolean	RoleAutomaton.addToChain(RoleAutomaton RA, boolean oSafe) add an Automaton to the chain with a default state
boolean	RoleAutomaton.addToChain(RoleAutomaton RA, boolean oSafe, int fRA) add an Automaton to the chain that would start from the iRA; OSAFE shows the safety of a previous automaton in a chain
boolean	RAStateTransitions.addToExisting(RATransition trans) add information from TRANS to existing transition between the same states.
void	RoleAutomaton.addTransition(int from, RATransition trans) add TRANSition leading from a state FROM; all states are known to fit the ton
void	RoleAutomaton.addTransitionSafe(int state, RATransition trans) add TRANSition leading from a given STATE; check whether all states are correct
ConceptExpression	ExpressionManager.and(ConceptExpression C, ConceptExpression D)
ConceptExpression	ExpressionManager.and(List<Expression> l) get an n-ary conjunction expression; take the arguments from the last argument list
int	TBox.and2dag(DLVertex v, DLTree t) fills AND-like vertex V with an AND-like expression T; process result
boolean	RATransition.applicable(Role R) check whether transition is applicable wrt role R
protected boolean	DlSatTester.applicable(uk.ac.manchester.cs.jfact.kernel.SimpleRule rule)
DLTree	TBox.applyAxiomCNToC(DLTree CN, DLTree D)
DLTree	TBox.applyAxiomCToCN(DLTree D, DLTree CN)
int	TBox.atmost2dag(int n, Role R, int C)
boolean	TBox.axiomToRangeDomain(DLTree sub, DLTree sup)
Set<ClassifiableEntry>	TaxonomyVertex.begin_syn()
List<Role>	Role.begin_topfunc() get access to the func super-roles w/o func parents via iterator
Collection<Role>	RATransition.begin() get the 1st role in (multi-)transition
List<RATransition>	RAStateTransitions.begin() RW begin
RAStateTransitions	RoleAutomaton.begin(int state) get the 1st (multi-)transition starting in STATE
ConceptExpression	ExpressionManager.bottom() get BOTTOM concept
ModelCacheInterface	DlSatTester.buildCacheByCGraph(boolean sat) create model cache for the just-classified entry
ConceptExpression	TDag2Interface.buildCExpr(DLVertex v) build concept expression by a vertex V
DlCompletionTree	ReasoningKernel.buildCompletionTree(ConceptExpression C) build a completion tree for a concept expression C (no caching as it breaks the idea of KE).
void	TBox.buildDAG()
DataExpression	TDag2Interface.buildDExpr(DLVertex v) build data expression by a vertex V
void	TBox.buildSimpleCache()
List<Concept>	TBox.c_begin()
void	TBox.calculateStatistic()
void	TBox.calculateTSDepth() calculate TS depth for all concepts
int	Concept.calculateTSDepth()
boolean	Concept.canInitNonPrim(DLTree desc) check whether it is possible to init this as a non-primitive concept with DESC
void	ClassifiableEntry.canonicaliseSynonym() make sure that synonym's representative is not a synonym itself
boolean	TBox.canUseSortedReasoning() check if Sorted Reasoning is applicable
ConceptExpression	ExpressionManager.cardinality(int n, DataRoleExpression R, DataExpression E) get exact cardinality restriction wrt number N, a data role R and a data expression E
ConceptExpression	ExpressionManager.cardinality(int n, ObjectRoleExpression R, ConceptExpression C) get exact cardinality restriction wrt number N, an object role R and a concept C
protected boolean	DlSatTester.checkDisjointRoleClash(DlCompletionTree from, DlCompletionTree to, Role R, DepSet dep)
boolean	DlSatTester.checkDisjointRoles(Role R, Role S)
void	TBox.checkEarlySynonym(Concept p) checks if C is defined as C=D and set Synonyms accordingly
void	Role.checkHierarchicalDisjoint() check (and correct) case whether R != S for R [= S
boolean	DlSatTester.checkIrreflexivity(Role R)
Concept	TBox.checkToldCycle(Concept _p)
void	RoleAutomaton.checkTransition(int from, int to) check whether transition between FROM and TO breaks safety
void	TBox.classifyConcepts(List<Concept> collection, boolean curCompletelyDefined, String type)
void	Taxonomy.classifyEntry(ClassifiableEntry p)
void	ReasoningKernel.classifyKB() ensure that KB is classified
void	TBox.classifyQueryConcept() classify query concept
protected boolean	Taxonomy.classifySynonym()
protected boolean	DLConceptTaxonomy.classifySynonym()
void	ToDoList.clear() clear Todo table
void	TaxonomyVertex.clear() clears the vertex
void	Ontology.clear() clear the ontology
void	ExpressionManager.clear()
void	DlCompletionGraph.clear() mark all heap elements as unused
protected void	Taxonomy.clearCheckedLabel() clear the CHECKED label from all the taxonomy vertex
void	TaxonomyVertex.clearCommon()
void	TBox.clearFeatures() clear current features
boolean	ReasoningKernel.clearKB() reset current KB
protected void	Taxonomy.clearLabels()
void	TaxonomyVertex.clearLinks(boolean upDirection) clear all links in a given direction
void	ExpressionManager.clearNameCache()
void	ExpressionManager.clearNameCache(NameSet<?> ns)
void	TBox.clearRelevanceInfo() clear all relevance info
void	DlCompletionGraph.clearStatistics() clear all the session statistics
void	Role.collectDomainFromSupers() merge to Domain all domains from super-roles
void	Role.completeAutomaton(int nRoles) complete role automaton
ObjectRoleComplexExpression	ExpressionManager.compose(Expression e1, Expression e2)
ObjectRoleComplexExpression	ExpressionManager.compose(List<Expression> l) get a role chain corresponding to R1 o ...
ConceptExpression	ExpressionManager.concept(String name) get named concept
int	TBox.concept2dag(Concept p)
void	Role.consistent() check whether role description is consistent
boolean	NominalReasoner.consistentNominalCloud() check whether ontology with nominals is consistent
boolean	CWDArray.contains(int bp) check whether label contains BP (ignoring dep-set)
boolean	CGLabel.contains(int p)
boolean	CGLabel.containsCC(int p) check whether node is labelled by complex concept P
boolean	TaxonomyVertex.correctCommon(int n) keep COMMON flag iff both flags are set; @return true if it is the case
int	TBox.countSynonyms()
DLTree	Axiom.createAnAxiom(DLTree replaced) create a concept expression corresponding to a given GCI; ignore SKIP entry
void	DlSatTester.createBCTopLE() create BC for LE-rule
ModelCacheInterface	DlSatTester.createCache(int p, FastSet f)
DlCompletionTreeArc	DlCompletionGraph.createLoop(DlCompletionTree node, Role r, DepSet dep) Create an R-loop of NODE wrt dep-set DEP; @return a loop edge
protected ModelCacheInterface	DlSatTester.createModelCache(DlCompletionTree p) return cache of given completion tree (implementation)
DlCompletionTreeArc	DlCompletionGraph.createNeighbour(DlCompletionTree from, boolean isPredEdge, Role r, DepSet dep) Create an empty R-neighbour of FROM;
Concept	TBox.createQueryConcept(DLTree desc)
void	TBox.createTaxonomy(boolean needIndividual)
DataExpression	ExpressionManager.dataAnd(List<Expression> l) get an n-ary data conjunction expression
int	TBox.dataAtMost2dag(int n, Role R, int C) create atmost node for data role
DataExpression	ExpressionManager.dataBottom() get BOTTOM data element
int	TBox.dataForall2dag(Role R, int C) create forall node for data role
DataExpression	ExpressionManager.dataNot(DataExpression E) get negation of a data expression E
DataExpression	ExpressionManager.dataOneOf(List<Expression> l) get an n-ary data one-of expression
DataExpression	ExpressionManager.dataOr(List<Expression> l) get an n-ary data disjunction expression
DataRoleExpression	ExpressionManager.dataRole(String name) get named data role
DataRoleExpression	ExpressionManager.dataRoleBottom() get BOTTOM data role
DataRoleExpression	ExpressionManager.dataRoleTop() get TOP data role
DataExpression	ExpressionManager.dataTop() get TOP data element
Axiom	ReasoningKernel.declare(org.semanticweb.owlapi.model.OWLAxiom ax, Expression C) axiom declare(x)
void	DlCompletionGraph.detectBlockedStatus(DlCompletionTree node)
void	TBox.determineSorts()
void	DLDag.determineSorts(RoleMaster ORM, RoleMaster DRM) build the sort system for given TBox
int	DLDag.directAdd(DLVertex v) add vertex to the end of DAG and calculate it's statistic if necessary
int	DLDag.directAddAndCache(DLVertex v) add vertex to the end of DAG and calculate it's statistic if necessary; put it into cache
Axiom	ReasoningKernel.disjointConcepts(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom C1 != ...
Axiom	ReasoningKernel.disjointDRoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 != R2 != ...
Axiom	ReasoningKernel.disjointORoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 != R2 != ...
Axiom	ReasoningKernel.disjointUnion(org.semanticweb.owlapi.model.OWLAxiom ax, ConceptExpression C, List<Expression> l) axiom C = C1 or ...
void	Concept.dropRelevant(long lab) make given concept irrelevant to given Labeller's state
void	TBox.dumpAllRoles(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump)
void	TBox.dumpConcept(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump, Concept p)
void	TBox.dumpExpression(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump, int p)
void	TBox.dumpRole(uk.ac.manchester.cs.jfact.kernel.DumpInterface dump, Role p)
Role	Role.eliminateToldCycles() eliminate told role cycle
void	TDag2Interface.ensureDagSize() make sure that size of expression cache is the same as the size of a DAG
void	OntologyLoader.ensureNames(Expression Expr) ensure that the expression EXPR has its named entities linked to the KB ones
NamedEntry	RoleMaster.ensureRoleName(String name) create role entry with given name
Axiom	ReasoningKernel.equalConcepts(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom C1 = ...
Axiom	ReasoningKernel.equalDRoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 = R2 = ...
Axiom	ReasoningKernel.equalORoles(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) axiom R1 = R2 = ...
ConceptExpression	ExpressionManager.exists(DataRoleExpression R, DataExpression E) get existential restriction wrt a data role R and a data expression E
ConceptExpression	ExpressionManager.exists(ObjectRoleExpression R, ConceptExpression C) get existential restriction wrt an object role R and a concept C
<T extends Concept> int	TBox.fillArrays(List<T> begin)
void	LogicFeatures.fillConceptData(Concept p)
void	LogicFeatures.fillDAGData(DLVertex v, boolean pos)
void	RoleMaster.fillReflexiveRoles(List<Role> RR)
void	LogicFeatures.fillRoleData(Role p, boolean both)
void	TBox.fillsClassificationTag() mark all concepts wrt their classification tag
int	RATransition.final_state() give a point of the transition
void	Taxonomy.finalise() call this method after taxonomy is built
boolean	DlSatTester.findConcept(CWDArray lab, int p) try to add a concept to a label given by TAG; ~C can't appear in the label
void	DlCompletionGraph.finiIR()
void	TBox.finishLoading() let TBox know that the whole ontology is loaded
ConceptExpression	ExpressionManager.forall(DataRoleExpression R, DataExpression E) get universal restriction wrt a data role R and a data expression E
ConceptExpression	ExpressionManager.forall(ObjectRoleExpression R, ConceptExpression C) get universal restriction wrt an object role R and a concept C
int	TBox.forall2dag(Role R, int C)
void	DLDag.gatherStatistic()
Axiom	Ontology.get(int i)
DLVertex	DLDag.get(int i) access by index
DepSet	CWDArray.get(int bp)
int	Role.getAbsoluteIndex() get (unsigned) unique index of the role
List<Role>	Role.getAncestor()
Set<Axiom>	ReasoningKernel.getAtomAxioms(int index) get a set of axioms that corresponds to the atom with the id INDEX
Set<TOntologyAtom>	ReasoningKernel.getAtomDependents(int index) get a set of atoms on which atom with index INDEX depends
int	ReasoningKernel.getAtomicDecompositionSize(boolean useSemantics, ModuleType type) create new atomic decomposition of the loaded ontology using TYPE.
Set<Axiom>	ReasoningKernel.getAtomModule(int index) get a set of axioms that corresponds to the module of the atom with the id INDEX
RoleAutomaton	Role.getAutomaton() get access to a RA for the role
List<Axiom>	Ontology.getAxioms() RW begin() for the whole ontology
List<RAStateTransitions>	RoleAutomaton.getBase()
List<ConceptWDep>	CWDArray.getBase()
Individual	TBox.getBlockingInd(Concept C) get individual that blocks C; works only for blocked individuals C
TaxonomyVertex	Taxonomy.getBottomVertex() special access to BOTTOM of taxonomy
int	Role.getBPDomain() get domain-as-a-bipointer of the role
int	Role.getBPRange() get range-as-a-bipointer of the role
ModelCacheInterface	DLDag.getCache(int p) get cache for given BiPointer (may return null if no cache defined)
ConceptExpression	TDag2Interface.getCExpr(int p) get concept expression corresponding index of vertex
Concept	TBox.getCI(DLTree name) get TOP/BOTTOM/CN/IN by the DLTree entry
Concept.CTTag	Concept.getClassTag() get value of a tag; determine it if unset
int	ConceptWDep.getConcept()
Concept	TBox.getConcept(String name) return registered concept by given NAME; @return null if can't register
ConceptWDep	CGLabel.getConceptWithBP(int bp)
DLDag	TBox.getDag() get RO access to DAG (needed for KE)
DLDag	DlSatTester.getDAG() get access to the DAG associated with it (necessary for the blocking support)
int	Lexeme.getData() get data value of given lexeme
String	TBox.getDataEntryByBP(int bp) get concept by it's BP (non- version)
List<DataExpression>	ReasoningKernel.getDataLabel(DlCompletionTree node, boolean onlyDet)
Set<RoleExpression>	ReasoningKernel.getDataRoles(DlCompletionTree node, boolean onlyDet) build the set of data neighbours of a NODE, put the set of data roles into the RESULT variable
DepSet	ConceptWDep.getDep() get dep-set part
DataExpression	TDag2Interface.getDExpr(int p) get data expression corresponding index of vertex
void	ReasoningKernel.getDirectInstances(ConceptExpression C, Actor actor) apply actor__apply() to all direct instances of given [complex] C
void	ReasoningKernel.getDisjointConcepts(ConceptExpression C, Actor actor) apply actor::apply() to all named concepts disjoint with [complex] C
MergableLabel	Role.getDomainLabel() get label of the role's domain
RoleMaster	TBox.getDRM() get RW access to used DataRole Master
NamedEntity	NamedEntry.getEntity()
void	ReasoningKernel.getEquivalentConcepts(ConceptExpression C, Actor actor) apply actor__apply() to all synonyms of [complex] C
void	ReasoningKernel.getEquivalentRoles(RoleExpression r, Actor actor) apply actor__apply() to all synonyms of [complex] R
Expression	TDag2Interface.getExpr(int p, boolean data)
ExpressionManager	ReasoningKernel.getExpressionManager() get access to an expression manager
ExpressionManager	Ontology.getExpressionManager() get access to an expression manager
FastSet	Concept.getExtraRules() iterator for accessing DJ elements
DLTree	TBox.getFreshConcept() get fresh concept
int	Role.getFunctional() get the Functional DAG vertex
DLTree	AxiomSet.getGCI() get GCI of all non-absorbed axioms
int	NamedEntry.getId() get internal ID
int	Role.getIndex()
abstract int	NamedEntry.getIndex()
int	ClassifiableEntry.getIndex() get the index value
Individual	OntologyLoader.getIndividual(IndividualExpression I, String reason) get an individual be the DLTree; throw exception if unable
Individual	TBox.getIndividual(String name) return registered individual by given NAME; @return null if can't register
void	ReasoningKernel.getInstances(ConceptExpression C, Actor actor) apply actor__apply() to all instances of given [complex] C
void	ReasoningKernel.getInstances(ConceptExpression C, Actor actor, boolean direct)
CWDArray	CGLabel.getLabel(DagTag tag) get (RW) label associated with the concepts defined by TAG
TModularizer	ReasoningKernel.getModExtractor(boolean useSemantic)
List<Axiom>	ReasoningKernel.getModule(List<Expression> signature, boolean useSemantic, ModuleType type) get a set of axioms that corresponds to the atom with the id INDEX
String	NamedEntry.getName() gets name of given entry
NamedEntry	Lexeme.getNE() get name pointer of given lexeme
List<DlCompletionTree>	ReasoningKernel.getNeighbours(DlCompletionTree node, RoleExpression role) build the set of neighbours of a NODE via role ROLE; put the resulting list into RESULT
DlCompletionTree	DlCompletionGraph.getNewNode() get new node (with internal level)
ToDoList.ToDoEntry	ToDoList.getNextEntry()
DlCompletionTree	DlCompletionGraph.getNode(int i)
Set<Axiom>	ReasoningKernel.getNonLocal(List<Expression> signature, boolean useSemantic, ModuleType type) get a set of axioms that corresponds to the atom with the id INDEX
List<ConceptExpression>	ReasoningKernel.getObjectLabel(DlCompletionTree node, boolean onlyDet) put into RESULT all the expressions from the NODE label; if ONLYDET is true, return only deterministic elements
Set<RoleExpression>	ReasoningKernel.getObjectRoles(DlCompletionTree node, boolean onlyDet, boolean needIncoming) build the set of object neighbours of a NODE, put the set of object roles and inverses into the RESULT variable
RoleMaster	TBox.getORM() get RW access to used Role Master
void	ReasoningKernel.getORoleDomain(ObjectRoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT NC that are in the domain of [complex] R
ClassifiableEntry	TaxonomyVertex.getPrimer()
MergableLabel	Role.getRangeLabel() get label of the role's range
int	Restorer.getRaresavestackLevel() for accessing the level on TRareSaveStack
DlSatTester	TBox.getReasoner() get RW reasoner wrt nominal case
List<Individual>	Individual.getRelatedCache(Role R) get set of individuals related to THIS via R
void	Taxonomy.getRelativesInfo(TaxonomyVertex node, Actor actor, boolean needCurrent, boolean onlyDirect, boolean upDirection) apply ACTOR to subgraph starting from NODE as defined by flags;
boolean	Taxonomy.getRelativesInfo(TaxonomyVertex node, SupConceptActor actor, boolean needCurrent, boolean onlyDirect, boolean upDirection) apply ACTOR to subgraph starting from NODE as defined by flags; this version is intended to work only with SupConceptActor, which requires the method to return as soon as the apply() method returns false
RoleMaster	TBox.getRM(Role R) get RW access to the RoleMaster depending of the R
Role	Related.getRole() get access to role wrt the FROM direction
List<Individual>	ReasoningKernel.getRoleFillers(IndividualExpression I, ObjectRoleExpression R)
void	ReasoningKernel.getRoleRange(ObjectRoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT NC that are in the range of [complex] R
List<Role>	RoleMaster.getRoles()
DlCompletionTree	DlCompletionGraph.getRoot() get a root node (non-const)
DlCompletionTree	DlSatTester.getRootNode() get the ROOT node of the completion graph
void	ReasoningKernel.getSameAs(IndividualExpression I, Actor actor) apply actor__apply() to all synonyms of an individual I
uk.ac.manchester.cs.jfact.kernel.SimpleRule	TBox.getSimpleRule(int index) get simple rule by its INDEX
Individual	TBox.getSPForConcept(Concept p)
KBStatus	TBox.getStatus() get status flag
void	ReasoningKernel.getSubConcepts(ConceptExpression C, boolean direct, Actor actor) apply actor__apply() to all DIRECT sub-concepts of [complex] C
void	ReasoningKernel.getSubRoles(RoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT sub-roles of [complex] R
void	ReasoningKernel.getSupConcepts(ConceptExpression C, boolean direct, Actor actor) apply actor__apply() to all DIRECT super-concepts of [complex] C
void	ReasoningKernel.getSupRoles(RoleExpression r, boolean direct, Actor actor) apply actor__apply() to all DIRECT super-roles of [complex] R
ClassifiableEntry	ClassifiableEntry.getSynonym() get synonym of current entry
TaxonomyVertex	TaxonomyVertex.getSynonymNode()
DLConceptTaxonomy	TBox.getTaxonomy() get (READ-WRITE) access to internal Taxonomy of concepts
Taxonomy	RoleMaster.getTaxonomy() get access to the taxonomy
TaxonomyVertex	ClassifiableEntry.getTaxVertex() get taxonomy vertex of the entry
DLTree	Role.getTDomain() get domain-as-a-tree of the role
int	TBox.getTG() GCI Axioms access
Token	Lexeme.getToken() get Token of given Lexeme
Collection<ClassifiableEntry>	ClassifiableEntry.getToldSubsumers() told subsumers
TaxonomyVertex	Taxonomy.getTopVertex() special access to TOP of taxonomy
List<Axiom>	ReasoningKernel.getTrace()
int	RAStateTransitions.getTransitionEnd()
DLTree	TBox.getTree(Concept C) get a DL tree by a given concept-like C
DLTree	Role.getTSpecialDomain()
void	ReasoningKernel.getTypes(IndividualExpression I, boolean direct, Actor actor) apply actor__apply() to all DIRECT concepts that are types of an individual I
boolean	TaxonomyVertex.getValue()
boolean	RAStateTransitions.hasEmptyTransition()
boolean	Concept.hasExtraRules() check if a concept is in a disjoint relation with anything
boolean	TBox.hasFC()
boolean	LogicFeatures.hasFunctionalRestriction()
boolean	LogicFeatures.hasInverseRole()
boolean	NominalReasoner.hasNominals() there are nominals
boolean	DlSatTester.hasNominals() check whether reasoning with nominals is performed
boolean	LogicFeatures.hasNumberRestriction()
boolean	LogicFeatures.hasQNumberRestriction()
boolean	RoleMaster.hasReflexiveRoles()
boolean	Individual.hasRelatedCache(Role R)
boolean	LogicFeatures.hasSelfRef()
boolean	LogicFeatures.hasSingletons()
boolean	LogicFeatures.hasSomeAll()
boolean	Role.hasSpecialDomain()
boolean	ClassifiableEntry.hasToldSubsumers() check whether entry ihas any TS
boolean	LogicFeatures.hasTopRole()
boolean	DLDag.haveSameSort(int p, int q) check if two BPs are of the same sort
List<Individual>	TBox.i_begin() RW begin() for individuals
protected boolean	Taxonomy.immediatelyClassified() check if no classification needed (synonym, orphan, unsatisfiable)
protected boolean	DLConceptTaxonomy.immediatelyClassified()
Axiom	ReasoningKernel.impliesConcepts(org.semanticweb.owlapi.model.OWLAxiom ax, ConceptExpression C, ConceptExpression D) axiom C [= D
Axiom	ReasoningKernel.impliesDRoles(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R, DataRoleExpression S) axiom (R [= S)
Axiom	ReasoningKernel.impliesORoles(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleComplexExpression R, ObjectRoleExpression S) axiom (R [= S)
void	TaxonomyVertex.incorporate(JFactReasonerConfiguration c)
int	CWDArray.index(int bp)
int	DLDag.index(NamedEntry c)
IndividualExpression	ExpressionManager.individual(String name) get named individual
void	CWDArray.init() init/clear label
void	CGLabel.init()
boolean	AxiomSet.initAbsorptionFlags(String flags)
void	Role.initADbyTaxonomy(Taxonomy pTax, int nRoles)
void	RoleMaster.initAncDesc()
protected void	DlSatTester.initBC(uk.ac.manchester.cs.jfact.kernel.DlSatTester.BranchingContext c) init branching context with given rule type
ModelCacheInterface	TBox.initCache(Concept pConcept, boolean sub)
void	RoleAutomaton.initChain(int from) make the beginning of the chain
void	DlCompletionGraph.initContext(int nSkip, boolean useLB, boolean useAB) set flags for blocking
void	DlCompletionGraph.initIR()
void	RoleAutomaton.initMap(int RASize, int fRA) init internal map according to RA size, with new initial state from chainState and (FRA) states
protected boolean	DlSatTester.initNewNode(DlCompletionTree node, DepSet dep, int C)
protected boolean	NominalReasoner.initNominalNode(Individual nom) init single nominal node
boolean	TBox.initNonPrimitive(Concept p, DLTree desc) add description to a concept; @return true in case of error
void	TBox.initRangeDomain(RoleMaster RM)
void	TBox.initReasoner()
void	TBox.initRuleFields(List<Concept> v, int index) init Extra Rule field in concepts given by a vector V with a given INDEX
void	Role.initSpecialDomain() init special domain; call this only after *ALL* the domains are known
void	TBox.initToldSubsumers() set told TOP concept whether necessary
void	Individual.initToldSubsumers() init told subsumers of the individual by it's description
void	Concept.initToldSubsumers() init told subsumers of the concept by it's description
boolean	Concept.initToldSubsumers(DLTree _desc, Set<Role> RolesProcessed) init told subsumers of the concept by given DESCription; @return TRUE iff concept is CD
T	NameSet.insert(String id) Insert id to a nameset (if necessary); @return pointer to id structure created by external creator
Axiom	ReasoningKernel.instanceOf(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, ConceptExpression C) axiom I e C
Role	Role.inverse() get inverse of given role (non- version)
ObjectRoleExpression	ExpressionManager.inverse(ObjectRoleExpression R)
boolean	Role.isAsymmetric() check whether the role is asymmetric
boolean	ReasoningKernel.isAsymmetric(ObjectRoleExpression R)
boolean	Role.isAsymmetryKnown() check whether the asymmetry of a role is known
boolean	TBox.isBlockedInd(Concept C)
boolean	TBox.isBlockingDet(Concept C)
AtomicBoolean	TBox.isCancelled()
boolean	Ontology.isChanged()
boolean	TaxonomyVertex.isChecked(long checkLab)
boolean	ClassifiableEntry.isClassified() is current entry classified
boolean	TaxonomyVertex.isCommon()
boolean	TBox.isConsistent() check if the ontology is consistent
boolean	Role.isDisjoint() check whether a role is disjoint with anything
boolean	ReasoningKernel.isDisjoint(ConceptExpression C, ConceptExpression D)
boolean	Role.isDisjoint(Role r) check whether a role is disjoint with R
boolean	ReasoningKernel.isDisjointRoles(DataRoleExpression R, DataRoleExpression S)
boolean	ReasoningKernel.isDisjointRoles(List<? extends RoleExpression> l)
boolean	ReasoningKernel.isDisjointRoles(ObjectRoleExpression R, ObjectRoleExpression S)
boolean	TBox.isDisjointRoles(Role R, Role S)
boolean	RATransition.isEmpty() check whether transition is empty
boolean	RAStateTransitions.isEmpty()
boolean	LogicFeatures.isEmpty() check whether no flags are set
boolean	ExpressionManager.isEmptyRole(RoleExpression R)
boolean	ReasoningKernel.isEquivalent(ConceptExpression C, ConceptExpression D)
boolean	Role.isFunctional() test if role is functional (ie, have some functional ancestors)
boolean	ReasoningKernel.isFunctional(DataRoleExpression R)
boolean	ReasoningKernel.isFunctional(ObjectRoleExpression R)
boolean	Role.isFunctionalityKnown() check whether the functionality of a role is known
boolean	TBox.isIndividual(DLTree tree)
boolean	ReasoningKernel.isInstance(IndividualExpression I, ConceptExpression C)
boolean	ReasoningKernel.isInverseFunctional(ObjectRoleExpression R)
boolean	TBox.isIRinQuery() check if the relevant part of KB contains inverse roles.
boolean	Role.isIrreflexive() check whether the role is irreflexive
boolean	ReasoningKernel.isIrreflexive(ObjectRoleExpression R)
boolean	TBox.isIrreflexive(Role R) check if the role R is irreflexive
boolean	Role.isIrreflexivityKnown() check whether the irreflexivity of a role is known
boolean	RoleAutomaton.isISafe() get the i-safe value
boolean	ReasoningKernel.isKBClassified() return classification status of KB
boolean	ReasoningKernel.isKBConsistent() return consistency status of KB
boolean	ReasoningKernel.isKBPreprocessed() return classification status of KB
boolean	ReasoningKernel.isKBRealised() return realistion status of KB
boolean	DLDag.isLast(int p) check if given index points to the last DAG entry
protected boolean	NominalReasoner.isNNApplicable(Role r, int C, int stopper)
protected boolean	DlSatTester.isNNApplicable(Role r, int C, int stopper)
boolean	TBox.isNRinQuery() check if the relevant part of KB contains number restrictions.
boolean	RoleAutomaton.isOSafe() get the o-safe value
boolean	Role.isReflexive() check whether the role is reflexive
boolean	ReasoningKernel.isReflexive(ObjectRoleExpression R)
boolean	Role.isReflexivityKnown() check whether the reflexivity of a role is known
boolean	ReasoningKernel.isRelated(IndividualExpression I, ObjectRoleExpression R, IndividualExpression J)
boolean	Role.isRelevant(long lab) is given role relevant to given Labeller's state
boolean	Concept.isRelevant(long lab) is given concept relevant to given Labeller's state
boolean	ReasoningKernel.isSameIndividuals(IndividualExpression I, IndividualExpression J)
boolean	TBox.isSameIndividuals(Individual _a, Individual _b)
boolean	MergableLabel.isSample() is given lable a sample label
boolean	TBox.isSatisfiable(Concept pConcept)
boolean	ReasoningKernel.isSatisfiable(ConceptExpression C)
boolean	Role.isSimple() a Simple flag (not simple if role or any of its sub-roles is transitive)
boolean	RAStateTransitions.isSingleton()
boolean	ReasoningKernel.isSubChain(ObjectRoleComplexExpression R, List<ObjectRoleExpression> l)
boolean	TBox.isSubHolds(Concept pConcept, Concept qConcept)
boolean	ReasoningKernel.isSubRoles(DataRoleExpression R, DataRoleExpression S)
boolean	ReasoningKernel.isSubRoles(ObjectRoleComplexExpression R, ObjectRoleExpression S)
boolean	ReasoningKernel.isSubsumedBy(ConceptExpression C, ConceptExpression D)
boolean	Role.isSymmetric() check whether the role is symmetric
boolean	ReasoningKernel.isSymmetric(ObjectRoleExpression R)
boolean	Role.isSymmetryKnown() check whether the symmetry of a role is known
boolean	ClassifiableEntry.isSynonym() check if current entry is a synonym
boolean	Role.isTopFunc() check if the role is topmost-functional (ie, has no functional ancestors)
boolean	Role.isTransitive() check whether the role is transitive
boolean	ReasoningKernel.isTransitive(ObjectRoleExpression R)
boolean	Role.isTransitivityKnown() check whether the transitivity of a role is known
boolean	ExpressionManager.isUniversalRole(RoleExpression R)
boolean	TaxonomyVertex.isValued(long valueLab)
boolean	DLDag.less(int p1, int p2)
boolean	CGLabel.lesserequal(CGLabel label)
boolean	CWDArray.lesserequal(CWDArray label)
boolean	Role.lesserequal(Role r)
T	NameCreator.makeEntry(String name) create new Named Entry
DLTree	TBox.makeNonPrimitive(Concept p, DLTree desc) make concept non-primitive; @return it's old description
DLTree	Concept.makeNonPrimitive(DLTree desc) switch primitive concept to non-primitive with new definition; @return old definition
ConceptExpression	ExpressionManager.maxCardinality(int n, DataRoleExpression R, DataExpression E) get max cardinality restriction wrt number N, a data role R and a data expression E
ConceptExpression	ExpressionManager.maxCardinality(int n, ObjectRoleExpression R, ConceptExpression C) get max cardinality restriction wrt number N, an object role R and a concept C
int	DLDag.maxSize() get approximation of the size after query is added
int	DlCompletionGraph.maxSize() get number of nodes in the CGraph
void	DlCompletionGraph.merge(DlCompletionTree from, DlCompletionTree to, DepSet dep, List<DlCompletionTreeArc> edges)
void	MergableLabel.merge(MergableLabel p) make 2 labels equal
void	DLDag.merge(MergableLabel ml, int p) merge two given DAG entries
void	LogicFeatures.mergeRoles() build bothRoles from single Roles flags
ConceptExpression	ExpressionManager.minCardinality(int n, DataRoleExpression R, DataExpression E) get min cardinality restriction wrt number N, a data role R and a data expression E
ConceptExpression	ExpressionManager.minCardinality(int n, ObjectRoleExpression R, ConceptExpression C) get min cardinality restriction wrt number N, an object role R and a concept C
int	ExpressionManager.nConcepts() get number of registered concepts
int	ExpressionManager.nDRoles() get number of registered data roles
protected boolean	Taxonomy.needBottomUp() check if it is possible to skip BU phase
protected boolean	DLConceptTaxonomy.needBottomUp()
protected boolean	Taxonomy.needLogging() check if it is necessary to log taxonomy action
protected boolean	DLConceptTaxonomy.needLogging() check if it is necessary to log taxonomy action
protected boolean	Taxonomy.needTopDown() check if it is possible to skip TD phase
protected boolean	DLConceptTaxonomy.needTopDown()
void	ReasoningKernel.needTracing()
List<TaxonomyVertex>	TaxonomyVertex.neigh(boolean upDirection) indirect RW access to Links
int	RoleAutomaton.newState() create new state
void	RoleAutomaton.nextChainTransition(int to) make the internal chain transition (between chainState and TO)
int	ExpressionManager.nIndividuals() get number of registered individuals
protected boolean	DlSatTester.noBranchingOps()
boolean	TaxonomyVertex.noNeighbours(boolean upDirection) check if vertex has no neighbours in given direction
boolean	DlCompletionGraph.nonMergable(DlCompletionTree p, DlCompletionTree q, Reference<DepSet> dep) Class for maintaining graph of CT nodes.
int	ExpressionManager.nORoles() get number of registered object roles
ConceptExpression	ExpressionManager.not(ConceptExpression C) get negation of a concept C
ObjectRoleExpression	ExpressionManager.objectRole(String name) get named object role
ObjectRoleExpression	ExpressionManager.objectRoleBottom() get BOTTOM object role
ObjectRoleExpression	ExpressionManager.objectRoleTop() get TOP object role
ConceptExpression	ExpressionManager.oneOf(IndividualExpression I)
ConceptExpression	ExpressionManager.oneOf(List<Expression> l) get an n-ary one-of expression; take the arguments from the last argument list
ConceptExpression	ExpressionManager.or(ConceptExpression C, ConceptExpression D)
ConceptExpression	ExpressionManager.or(List<Expression> l) get an n-ary disjunction expression; take the arguments from the last argument list
void	LogicFeatures.or(LogicFeatures lf) operator add
void	TBox.performClassification() perform classification (assuming KB is consistent)
boolean	TBox.performConsistencyCheck()
void	TBox.performRealisation() perform realisation (assuming KB is consistent)
static LogicFeatures	LogicFeatures.plus(LogicFeatures f1, LogicFeatures f2)
void	Role.postProcess()
protected void	Taxonomy.preClassificationActions() actions that to be done BEFORE entry will be classified
void	DLConceptTaxonomy.preClassificationActions() actions that to be done BEFORE entry will be classified
void	TBox.prepareFeatures(Concept pConcept, Concept qConcept)
protected void	NominalReasoner.prepareReasoner() prerpare Nominal Reasoner to a new job
protected void	DlSatTester.prepareReasoner()
void	TBox.prepareReasoning()
void	TBox.preprocess()
void	TBox.preprocessRelated()
void	TBox.print() print TBox as a whole
void	RoleAutomaton.print(LogAdapter o)
void	Role.print(LogAdapter o)
void	RAStateTransitions.print(LogAdapter o) print all the transitions starting from the state FROM
void	DlCompletionGraph.print(LogAdapter o)
void	RATransition.print(LogAdapter o, int from) print the transition starting from FROM
void	RoleMaster.print(LogAdapter o, String type)
void	TBox.printAxioms(LogAdapter o)
void	TBox.printConcept(LogAdapter o, Concept p)
void	TBox.printConcepts(LogAdapter o) print all registered concepts
void	TBox.printDagEntry(LogAdapter o, int p)
void	DLDag.printDAGUsage(LogAdapter o)
void	TBox.printFeatures()
void	TBox.printIndividuals(LogAdapter o) print all registered individuals
String	TaxonomyVertex.printNeighbours(boolean upDirection)
float	DlSatTester.printReasoningTime(LogAdapter o)
void	TBox.printSimpleRules(LogAdapter o)
void	DLDag.printStat(LogAdapter o) print DAG size and number of cache hits, together with DAG usage
String	TaxonomyVertex.printSynonyms()
void	TBox.processDifferent(List<DLTree> l)
Axiom	ReasoningKernel.processDifferent(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) different individuals
void	TBox.processDisjoint(List<DLTree> beg) process a disjoint set [beg,end) in a usual manner
void	TBox.processDisjointC(Collection<DLTree> beg)
void	TBox.processDisjointR(List<DLTree> l)
void	TBox.processEquivalentC(List<DLTree> l)
void	TBox.processEquivalentR(List<DLTree> l)
void	TBox.processGCI(DLTree C, DLTree D) try to absorb GCI C[=D; if not possible, just record this GCI
protected boolean	AxiomSet.processNewAxiom(Axiom q) helper that inserts an axiom into Accum; @return bool if success
void	TBox.processSame(List<DLTree> l)
Axiom	ReasoningKernel.processSame(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) same individuals
ObjectRoleComplexExpression	ExpressionManager.projectFrom(ObjectRoleExpression R, ConceptExpression C) get a expression corresponding to R projected from C
ObjectRoleComplexExpression	ExpressionManager.projectInto(ObjectRoleExpression R, ConceptExpression C) get a expression corresponding to R projected into C
protected void	Taxonomy.propagateTrueUp(TaxonomyVertex node)
boolean	Taxonomy.queryMode()
Role	Role.realInverse() get real inverse of a role (RO)
void	ReasoningKernel.realiseKB() ensure that KB is realised
boolean	RAStateTransitions.recognise(Role R)
int	TBox.reflexive2dag(Role R) create REFLEXIVE node
void	TBox.registerIndividualRelation(NamedEntry a, NamedEntry R, NamedEntry b) individual relation :R
protected void	NominalReasoner.registerNominalCache(Individual p) create cache entry for given singleton
Axiom	ReasoningKernel.relatedTo(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, ObjectRoleExpression R, IndividualExpression J) axiom :R
Axiom	ReasoningKernel.relatedToNot(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, ObjectRoleExpression R, IndividualExpression J) axiom :\neg R
void	Concept.removeDescription() remove concept description (to save space)
void	TBox.removeExtraDescriptions()
void	TaxonomyVertex.removeLastLink(boolean upDirection) remove latest link (usually to the BOTTOM node)
boolean	TaxonomyVertex.removeLink(boolean upDirection, TaxonomyVertex p)
void	DLDag.removeQuery()
void	Concept.removeSelfFromDescription() remove concept from its own definition (like in case C [= (or C ...)
void	ClassifiableEntry.removeSynonymsFromParents() if two synonyms are in 'told' list, merge them
protected void	Taxonomy.removeTop() remove top entry
void	DlSatTester.repeatUnblockedNode(DlCompletionTree node, boolean direct) re-apply all the relevant expantion rules to a given unblocked NODE
Concept	TBox.replaceForall(DLTree RC) replace (AR:C) with X such that C [= AR^-:X for fresh X.
void	DLDag.replaceVertex(int i, DLVertex v, NamedEntry C) replace existing vertex at index I with a vertex V
protected void	DlSatTester.resetSessionFlags()
MergableLabel	MergableLabel.resolve() make label's depth <= 2; @return sample of the label
int	Concept.resolveId()
static Role	Role.resolveRole(DLTree t)
static <T extends ClassifiableEntry> T	ClassifiableEntry.resolveSynonym(T p)
abstract void	Restorer.restore() restore an object based on saved information
void	ToDoList.restore(int level) restore state to the given level using internal stack
protected void	DlSatTester.restore(int newTryLevel)
void	DlCompletionGraph.restore(int level)
void	CWDArray.restore(int ss, int level)
void	CGLabel.restore(SaveState ss, int level) restore label to given LEVEL using given SS
void	ToDoList.restoreState(uk.ac.manchester.cs.jfact.kernel.ToDoList.TODOListSaveState tss) restore Todo table content from given saveState entry
void	DlCompletionGraph.retestCGBlockedStatus() retest every d-blocked node in the CG.
void	ReasoningKernel.retract(Axiom axiom) retract an axiom
void	Ontology.retract(Axiom p) retract given axiom to the ontology
protected void	Taxonomy.runBottomUp() explicitely run BU phase
void	DLConceptTaxonomy.runBottomUp() explicitely run BU phase
protected boolean	DlSatTester.runSat()
boolean	DlSatTester.runSat(int p, int q)
protected void	Taxonomy.runTopDown() explicitely run TD phase
void	DLConceptTaxonomy.runTopDown() explicitely run TD phase
void	ToDoList.save() save current state using internal stack
protected void	DlSatTester.save()
void	DlCompletionGraph.save()
int	CWDArray.save() save label using given SS
void	CGLabel.save(SaveState ss) save label using given SS
void	DlCompletionGraph.saveNode(DlCompletionTree node, int level) save given node wrt level
void	DlCompletionGraph.saveRareCond(List<Restorer> p)
void	DlCompletionGraph.saveRareCond(Restorer p) save rarely appeared info if P is non-null
void	ToDoList.saveState(uk.ac.manchester.cs.jfact.kernel.ToDoList.TODOListSaveState tss) save current Todo table content to given saveState entry
void	Concept.searchTSbyRoleAndSupers(Role r, Set<Role> RolesProcessed)
ConceptExpression	ExpressionManager.selfReference(ObjectRoleExpression R) get self-reference restriction of an object role R
void	Role.setAsymmetric(boolean value) set the asymmetry of both role and it's inverse
Axiom	ReasoningKernel.setAsymmetric(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) AntySymmetric (R): disjoint(R,R^-)
void	DlSatTester.setBlockingMethod(boolean hasInverse, boolean hasQCR) set blocking method for a session
void	DlCompletionGraph.setBlockingMethod(boolean hasInverse, boolean hasQCR) set blocking method for a session
void	DLConceptTaxonomy.setBottomUp(KBFlags GCIs) set bottom-up flag
void	Role.setBPDomain(int p) set domain-as-a-bipointer to a role
void	DLDag.setCache(int p, ModelCacheInterface cache) set cache for given BiPointer; @return given cache
void	TaxonomyVertex.setChecked(long checkLab)
void	TaxonomyVertex.setCommon()
void	Taxonomy.setCompletelyDefined(boolean use) set Completely Defined flag
void	TBox.setConceptIndex(Concept C) set new concept index for given C wrt existing nC
void	TBox.setConsistency(boolean val) set consistency flag
boolean	DlCompletionGraph.setCurIR(DlCompletionTree node, DepSet ds)
protected void	Taxonomy.setCurrentEntry(ClassifiableEntry p) initialise aux entry with given concept p
Axiom	ReasoningKernel.setDDomain(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R, ConceptExpression C) Domain (R C)
Axiom	ReasoningKernel.setDFunctional(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R) Functional (R)
void	Role.setDomain(DLTree p) add p to domain of the role
Axiom	ReasoningKernel.setDRange(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression R, DataExpression E) Range (R E)
void	NamedEntry.setEntity(NamedEntity entity)
void	DLDag.setExpressionCache(boolean val) whether to use cache for nodes
Axiom	ReasoningKernel.setFairnessConstraint(org.semanticweb.owlapi.model.OWLAxiom ax, List<Expression> l) let all concept expressions in the ArgQueue to be fairness constraints
void	TBox.setFairnessConstraintDLTrees(List<DLTree> l)
void	DLDag.setFinalSize() set the DAG size
boolean	TBox.setForbidUndefinedNames(boolean val) set the flag that forbid usage of undefined names for concepts/roles; @return old value
void	Role.setFunctional() mark role (topmost) functional
void	Role.setFunctional(boolean value) set role functionality value
void	Role.setFunctional(int fNode) set functional attribute to given value (functional DAG vertex)
void	TaxonomyVertex.setHostVertex(ClassifiableEntry entry) mark vertex as the one corresponding to a given ENTRY
void	NamedEntry.setId(int id) set internal ID
void	ReasoningKernel.setIgnoreExprCache(boolean value) choose whether TExpr cache should be ignored
abstract void	NamedEntry.setIndex(int i)
void	ClassifiableEntry.setIndex(int ind) set the index value
void	Role.setInverse(Role p) set inverse to given role
Axiom	ReasoningKernel.setInverseFunctional(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) InverseFunctional (R)
void	LogicFeatures.setInverseRoles() allow user to set presence of inverse roles
Axiom	ReasoningKernel.setInverseRoles(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R, ObjectRoleExpression S) R = Inverse(S)
void	Role.setIrreflexive()
void	Role.setIrreflexive(boolean value) set the irreflexivity of both role and it's inverse
Axiom	ReasoningKernel.setIrreflexive(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Irreflexive (R): Domain(R) = \neg ER.Self
void	RoleAutomaton.setIUnsafe() state that the automaton is i-unsafe
Axiom	ReasoningKernel.setODomain(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R, ConceptExpression C) Domain (R C)
Axiom	ReasoningKernel.setOFunctional(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Functional (R)
Axiom	ReasoningKernel.setORange(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R, ConceptExpression C) Range (R C)
void	DLDag.setOrderDefaults(String defSat, String defSub)
void	DLDag.setOrderOptions(String opt)
void	RoleAutomaton.setOUnsafe() state that the automaton is o-unsafe
void	Ontology.setProcessed() set the processed marker to the end of the ontology
void	Role.setRange(DLTree p) add p to range of the role
void	Restorer.setRaresavestackLevel(int raresavestackLevel) for accessing the level on TRareSaveStack
void	Role.setReflexive()
void	Role.setReflexive(boolean value) set the reflexivity of both role and it's inverse
Axiom	ReasoningKernel.setReflexive(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Reflexive (R)
void	Individual.setRelatedCache(Role R, List<Individual> v) set the cache of individuals related to THIS via R
void	Role.setRelevant(long lab) make given role relevant to given Labeller's state
void	Concept.setRelevant(long lab) make given concept relevant to given Labeller's state
void	TaxonomyVertex.setSample(ClassifiableEntry entry, boolean linkBack) set sample to ENTRY
void	DLDag.setSatOrder() use SAT options to OR ordering;
void	ReasoningKernel.setSignature(TSignature sig) set the signature of the expression translator
void	Role.setSpecialDomain(int bp) set the special domain value
void	DLDag.setSubOrder() use SUB options to OR ordering
void	Role.setSymmetric()
void	Role.setSymmetric(boolean value) set the symmetry of both role and it's inverse
Axiom	ReasoningKernel.setSymmetric(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Symmetric (R): R [= R^-
void	ClassifiableEntry.setSynonym(ClassifiableEntry syn) add entry's synonym
void	ClassifiableEntry.setTaxVertex(TaxonomyVertex vertex) set up given entry
void	TBox.setToldTop() set told TOP concept whether necessary
void	Concept.setToldTop(Concept top) init TOP told subsumer if necessary
void	ReasoningKernel.setTopBottomRoleNames(String topO, String botO, String topD, String botD) set top/bottom role names to use them in the related output
void	ExpressionManager.setTopBottomRoles(String topORoleName, String botORoleName, String topDRoleName, String botDRoleName) set Top/Bot properties
void	Role.setTransitive()
void	Role.setTransitive(boolean value) set the transitivity of both role and it's inverse
Axiom	ReasoningKernel.setTransitive(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression R) Transitive (R)
void	RoleMaster.setUndefinedNames(boolean val) change the undefined names usage policy
void	RoleAutomaton.setup(int nRoles, boolean data) set up all transitions passing number of roles
void	RAStateTransitions.setup(int state, int nRoles, boolean data) set up state transitions: no more additions to the structure
boolean	DlSatTester.setupEdge(DlCompletionTreeArc pA, DepSet dep, int flags)
boolean	TaxonomyVertex.setValued(boolean val, long valueLab)
void	Related.simplify() simplify structure wrt synonyms
Axiom	Axiom.simplifyCN(TBox tbox) replace a defined concept with its description
Axiom	Axiom.simplifyForall(TBox KB) replace a universal restriction with a fresh concept
int	RoleMaster.size() get number of roles
int	RoleAutomaton.size() return number of distinct states
int	Ontology.size() size of the ontology
int	DLDag.size() get size of DAG
int	CWDArray.size()
protected boolean	AxiomSet.split(Axiom p) split given axiom
List<Axiom>	Axiom.split(TBox KB) split an axiom; @return new axiom and/or NULL
boolean	TBox.switchToNonprimitive(DLTree left, DLTree right)
ModelCacheState	TBox.testCachedNonSubsumption(Concept p, Concept q) test if 2 concept non-subsumption can be determined by cache merging
boolean	TBox.testHasNominals() check if the relevant part of KB contains singletons
boolean	TBox.testHasTopRole() check if the relevant part of KB contains top role
boolean	TBox.testSortedNonSubsumption(Concept p, Concept q) test if 2 concept non-subsumption can be determined by sorts checking
ConceptExpression	ExpressionManager.top() get TOP concept
void	TBox.transformSingletonHierarchy()
void	TBox.transformToldCycles()
int	TBox.tree2dag(DLTree t)
protected void	NominalReasoner.updateClassifiedSingleton(Individual p) use classification information for the nominal P
void	DlCompletionGraph.updateDBlockedStatus(DlCompletionTree node) update blocked status for d-blocked node
List<Restorer>	CWDArray.updateDepSet(DepSet dep)
Restorer	CWDArray.updateDepSet(int index, DepSet dep)
void	DLDag.updateIndex(DagTag tag, int value) update index corresponding to DLVertex's tag
void	DLDag.updateSorts(int a, Role R, int b) update sorts for :R construction
ConceptExpression	ExpressionManager.value(DataRoleExpression R, Literal<?> V) get value restriction wrt a data role R and a data value V
ConceptExpression	ExpressionManager.value(ObjectRoleExpression R, IndividualExpression I) get value restriction wrt an object role R and an individual I
Axiom	ReasoningKernel.valueOf(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, DataRoleExpression A, Literal<?> V) axiom (value I A V)
Axiom	ReasoningKernel.valueOfNot(org.semanticweb.owlapi.model.OWLAxiom ax, IndividualExpression I, DataRoleExpression A, Literal<?> V) axiom :\neg A
void	OntologyLoader.visitOntology(Ontology ontology) load ontology to a given KB
boolean	AxiomSet.wasRoleAbsorptionApplied()
void	ReasoningKernel.writeReasoningResult(LogAdapter o, long time) dump query processing TIME, reasoning statistics and a (preprocessed) TBox
void	TBox.writeReasoningResult(long time)
void	LogicFeatures.writeState(LogAdapter l)
void	DlSatTester.writeTotalStatistic(LogAdapter o)

Uses of PortedFrom in uk.ac.manchester.cs.jfact.kernel.actors

Classes in uk.ac.manchester.cs.jfact.kernel.actors with annotations of type PortedFrom

Modifier and Type	Interface and Description
interface	Actor Actor interface
class	AddRoleActor actor that accumulates primers
class	RIActor
class	SupConceptActor class for exploring concept taxonomy to find super classes

Fields in uk.ac.manchester.cs.jfact.kernel.actors with annotations of type PortedFrom

Modifier and Type	Field and Description
protected ClassifiableEntry	SupConceptActor.pe

Methods in uk.ac.manchester.cs.jfact.kernel.actors with annotations of type PortedFrom

Modifier and Type	Method and Description
boolean	SupConceptActor.apply(TaxonomyVertex v)
boolean	RIActor.apply(TaxonomyVertex v)
boolean	AddRoleActor.apply(TaxonomyVertex v)
boolean	Actor.apply(TaxonomyVertex v)
List<Individual>	RIActor.getAcc()

Uses of PortedFrom in uk.ac.manchester.cs.jfact.kernel.dl

Classes in uk.ac.manchester.cs.jfact.kernel.dl with annotations of type PortedFrom

Modifier and Type	Class and Description
class	ConceptAnd
class	ConceptBottom
class	ConceptDataExactCardinality
class	ConceptDataExists
class	ConceptDataForall
class	ConceptDataMaxCardinality
class	ConceptDataMinCardinality
class	ConceptDataValue
class	ConceptName
class	ConceptNot
class	ConceptObjectExactCardinality
class	ConceptObjectExists
class	ConceptObjectForall
class	ConceptObjectMaxCardinality
class	ConceptObjectMinCardinality
class	ConceptObjectSelf
class	ConceptObjectValue
class	ConceptOneOf
class	ConceptOr
class	ConceptTop
class	DataAnd
class	DataBottom
class	DataNot
class	DataOneOf
class	DataOr
class	DataRoleBottom
class	DataRoleName
class	DataRoleTop
class	DataTop
class	IndividualName
class	NamedEntityImpl
class	NAryExpressionImpl<Argument extends Expression>
class	ObjectRoleBottom
class	ObjectRoleChain
class	ObjectRoleInverse
class	ObjectRoleName
class	ObjectRoleProjectionFrom
class	ObjectRoleProjectionInto
class	ObjectRoleTop

Fields in uk.ac.manchester.cs.jfact.kernel.dl with annotations of type PortedFrom

Modifier and Type	Field and Description
protected Literal<?>	ConceptDataValue.dataValue data expression argument
protected DataExpression	DataNot.Expr data expression argument

Methods in uk.ac.manchester.cs.jfact.kernel.dl with annotations of type PortedFrom

Modifier and Type	Method and Description
void	ObjectRoleTop.accept(DLExpressionVisitor visitor)
void	ObjectRoleProjectionInto.accept(DLExpressionVisitor visitor)
void	ObjectRoleProjectionFrom.accept(DLExpressionVisitor visitor)
void	ObjectRoleName.accept(DLExpressionVisitor visitor)
void	ObjectRoleInverse.accept(DLExpressionVisitor visitor)
void	ObjectRoleChain.accept(DLExpressionVisitor visitor)
void	ObjectRoleBottom.accept(DLExpressionVisitor visitor)
void	IndividualName.accept(DLExpressionVisitor visitor)
void	DataTop.accept(DLExpressionVisitor visitor)
void	DataRoleTop.accept(DLExpressionVisitor visitor)
void	DataRoleName.accept(DLExpressionVisitor visitor)
void	DataRoleBottom.accept(DLExpressionVisitor visitor)
void	DataOr.accept(DLExpressionVisitor visitor)
void	DataOneOf.accept(DLExpressionVisitor visitor)
void	DataNot.accept(DLExpressionVisitor visitor)
void	DataBottom.accept(DLExpressionVisitor visitor)
void	DataAnd.accept(DLExpressionVisitor visitor)
void	ConceptTop.accept(DLExpressionVisitor visitor)
void	ConceptOr.accept(DLExpressionVisitor visitor)
void	ConceptOneOf.accept(DLExpressionVisitor visitor)
void	ConceptObjectValue.accept(DLExpressionVisitor visitor)
void	ConceptObjectSelf.accept(DLExpressionVisitor visitor)
void	ConceptObjectMinCardinality.accept(DLExpressionVisitor visitor)
void	ConceptObjectMaxCardinality.accept(DLExpressionVisitor visitor)
void	ConceptObjectForall.accept(DLExpressionVisitor visitor)
void	ConceptObjectExists.accept(DLExpressionVisitor visitor)
void	ConceptObjectExactCardinality.accept(DLExpressionVisitor visitor)
void	ConceptNot.accept(DLExpressionVisitor visitor)
void	ConceptName.accept(DLExpressionVisitor visitor)
void	ConceptDataValue.accept(DLExpressionVisitor visitor)
void	ConceptDataMinCardinality.accept(DLExpressionVisitor visitor)
void	ConceptDataMaxCardinality.accept(DLExpressionVisitor visitor)
void	ConceptDataForall.accept(DLExpressionVisitor visitor)
void	ConceptDataExists.accept(DLExpressionVisitor visitor)
void	ConceptDataExactCardinality.accept(DLExpressionVisitor visitor)
void	ConceptBottom.accept(DLExpressionVisitor visitor)
void	ConceptAnd.accept(DLExpressionVisitor visitor)
<O> O	ObjectRoleTop.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ObjectRoleProjectionInto.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ObjectRoleProjectionFrom.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ObjectRoleName.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ObjectRoleInverse.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ObjectRoleChain.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ObjectRoleBottom.accept(DLExpressionVisitorEx<O> visitor)
<O> O	IndividualName.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataTop.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataRoleTop.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataRoleName.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataRoleBottom.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataOr.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataOneOf.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataNot.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataBottom.accept(DLExpressionVisitorEx<O> visitor)
<O> O	DataAnd.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptTop.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptOr.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptOneOf.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptObjectValue.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptObjectSelf.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptObjectMinCardinality.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptObjectMaxCardinality.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptObjectForall.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptObjectExists.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptObjectExactCardinality.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptNot.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptName.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptDataValue.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptDataMinCardinality.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptDataMaxCardinality.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptDataForall.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptDataExists.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptDataExactCardinality.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptBottom.accept(DLExpressionVisitorEx<O> visitor)
<O> O	ConceptAnd.accept(DLExpressionVisitorEx<O> visitor)
int	ConceptObjectMinCardinality.getCardinality()
int	ConceptObjectMaxCardinality.getCardinality()
int	ConceptObjectExactCardinality.getCardinality()
int	AbstractConceptDataCardinality.getCardinality()
ConceptExpression	ObjectRoleProjectionInto.getConcept()
ConceptExpression	ObjectRoleProjectionFrom.getConcept()
ConceptExpression	ConceptObjectMinCardinality.getConcept()
ConceptExpression	ConceptObjectMaxCardinality.getConcept()
ConceptExpression	ConceptObjectForall.getConcept() get access to the argument
ConceptExpression	ConceptObjectExists.getConcept() get access to the argument
ConceptExpression	ConceptObjectExactCardinality.getConcept()
ConceptExpression	ConceptNot.getConcept() get access to the argument
DataExpression	DataNot.getExpr() get access to the argument
Literal<?>	ConceptDataValue.getExpr() get access to the argument
DataExpression	ConceptDataForall.getExpr()
DataExpression	ConceptDataExists.getExpr()
DataExpression	AbstractConceptDataCardinality.getExpr()
IndividualExpression	ConceptObjectValue.getI()
ObjectRoleExpression	ObjectRoleProjectionInto.getOR()
ObjectRoleExpression	ObjectRoleProjectionFrom.getOR()
ObjectRoleExpression	ObjectRoleInverse.getOR() get access to the argument
ObjectRoleExpression	ConceptObjectValue.getOR()
ObjectRoleExpression	ConceptObjectSelf.getOR() get access to the argument
ObjectRoleExpression	ConceptObjectMinCardinality.getOR()
ObjectRoleExpression	ConceptObjectMaxCardinality.getOR()
ObjectRoleExpression	ConceptObjectForall.getOR()
ObjectRoleExpression	ConceptObjectExists.getOR()
ObjectRoleExpression	ConceptObjectExactCardinality.getOR()
boolean	NAryExpressionImpl.isEmpty()

Uses of PortedFrom in uk.ac.manchester.cs.jfact.kernel.dl.axioms

Classes in uk.ac.manchester.cs.jfact.kernel.dl.axioms with annotations of type PortedFrom

Modifier and Type	Class and Description
class	AxiomConceptInclusion
class	AxiomDeclaration
class	AxiomDifferentIndividuals Different individuals axiom
class	AxiomDisjointConcepts Concept disjointness axiom
class	AxiomDisjointDRoles Data Role disjointness axiom
class	AxiomDisjointORoles Object Role disjointness axiom
class	AxiomDisjointUnion Disjoint Union axiom
class	AxiomDRoleDomain
class	AxiomDRoleFunctional
class	AxiomDRoleRange
class	AxiomDRoleSubsumption
class	AxiomEquivalentConcepts
class	AxiomEquivalentDRoles Data Role equivalence axiom
class	AxiomEquivalentORoles Object Role equivalence axiom
class	AxiomFairnessConstraint Fairness constraint axiom
class	AxiomInstanceOf
class	AxiomORoleDomain
class	AxiomORoleFunctional
class	AxiomORoleRange
class	AxiomORoleSubsumption
class	AxiomRelatedTo
class	AxiomRelatedToNot
class	AxiomRoleAsymmetric
class	AxiomRoleInverse
class	AxiomRoleInverseFunctional
class	AxiomRoleIrreflexive
class	AxiomRoleReflexive
class	AxiomRoleSymmetric
class	AxiomRoleTransitive
class	AxiomSameIndividuals Same individuals axiom
class	AxiomSingleDRole
class	AxiomSingleORole
class	AxiomValueOf
class	AxiomValueOfNot

Methods in uk.ac.manchester.cs.jfact.kernel.dl.axioms with annotations of type PortedFrom

Modifier and Type	Method and Description
void	AxiomValueOfNot.accept(DLAxiomVisitor visitor)
void	AxiomValueOf.accept(DLAxiomVisitor visitor)
void	AxiomSameIndividuals.accept(DLAxiomVisitor visitor)
void	AxiomRoleTransitive.accept(DLAxiomVisitor visitor)
void	AxiomRoleSymmetric.accept(DLAxiomVisitor visitor)
void	AxiomRoleReflexive.accept(DLAxiomVisitor visitor)
void	AxiomRoleIrreflexive.accept(DLAxiomVisitor visitor)
void	AxiomRoleInverseFunctional.accept(DLAxiomVisitor visitor)
void	AxiomRoleInverse.accept(DLAxiomVisitor visitor)
void	AxiomRoleAsymmetric.accept(DLAxiomVisitor visitor)
void	AxiomRelatedToNot.accept(DLAxiomVisitor visitor)
void	AxiomRelatedTo.accept(DLAxiomVisitor visitor)
void	AxiomORoleSubsumption.accept(DLAxiomVisitor visitor)
void	AxiomORoleRange.accept(DLAxiomVisitor visitor)
void	AxiomORoleFunctional.accept(DLAxiomVisitor visitor)
void	AxiomORoleDomain.accept(DLAxiomVisitor visitor)
void	AxiomInstanceOf.accept(DLAxiomVisitor visitor)
void	AxiomFairnessConstraint.accept(DLAxiomVisitor visitor)
void	AxiomEquivalentORoles.accept(DLAxiomVisitor visitor)
void	AxiomEquivalentDRoles.accept(DLAxiomVisitor visitor)
void	AxiomEquivalentConcepts.accept(DLAxiomVisitor visitor)
void	AxiomDRoleSubsumption.accept(DLAxiomVisitor visitor)
void	AxiomDRoleRange.accept(DLAxiomVisitor visitor)
void	AxiomDRoleFunctional.accept(DLAxiomVisitor visitor)
void	AxiomDRoleDomain.accept(DLAxiomVisitor visitor)
void	AxiomDisjointUnion.accept(DLAxiomVisitor visitor)
void	AxiomDisjointORoles.accept(DLAxiomVisitor visitor)
void	AxiomDisjointDRoles.accept(DLAxiomVisitor visitor)
void	AxiomDisjointConcepts.accept(DLAxiomVisitor visitor)
void	AxiomDifferentIndividuals.accept(DLAxiomVisitor visitor)
void	AxiomDeclaration.accept(DLAxiomVisitor visitor)
void	AxiomConceptInclusion.accept(DLAxiomVisitor visitor)
<O> O	AxiomValueOfNot.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomValueOf.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomSameIndividuals.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRoleTransitive.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRoleSymmetric.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRoleReflexive.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRoleIrreflexive.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRoleInverseFunctional.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRoleInverse.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRoleAsymmetric.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRelatedToNot.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomRelatedTo.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomORoleSubsumption.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomORoleRange.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomORoleFunctional.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomORoleDomain.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomInstanceOf.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomFairnessConstraint.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomEquivalentORoles.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomEquivalentDRoles.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomEquivalentConcepts.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDRoleSubsumption.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDRoleRange.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDRoleFunctional.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDRoleDomain.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDisjointUnion.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDisjointORoles.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDisjointDRoles.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDisjointConcepts.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDifferentIndividuals.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomDeclaration.accept(DLAxiomVisitorEx<O> visitor)
<O> O	AxiomConceptInclusion.accept(DLAxiomVisitorEx<O> visitor)
List<I>	AbstractNaryAxiom.getArguments()
DataRoleExpression	AxiomValueOfNot.getAttribute() access to role
DataRoleExpression	AxiomValueOf.getAttribute() access to role
ConceptExpression	AxiomInstanceOf.getC() access
ConceptExpression	AxiomDisjointUnion.getC()
Expression	AxiomDeclaration.getDeclaration()
ConceptExpression	AxiomORoleDomain.getDomain() access
ConceptExpression	AxiomDRoleDomain.getDomain()
ObjectRoleExpression	AxiomRoleInverse.getInvRole() access to role
ConceptExpression	AxiomORoleRange.getRange() access
DataExpression	AxiomDRoleRange.getRange() access
IndividualExpression	AxiomRelatedToNot.getRelatedIndividual() access
IndividualExpression	AxiomRelatedTo.getRelatedIndividual() access
ObjectRoleExpression	AxiomRelatedToNot.getRelation() access
ObjectRoleExpression	AxiomRelatedTo.getRelation() access
ObjectRoleExpression	AxiomSingleORole.getRole() access to role
DataRoleExpression	AxiomSingleDRole.getRole() access to role
ConceptExpression	AxiomConceptInclusion.getSubConcept()
ObjectRoleComplexExpression	AxiomORoleSubsumption.getSubRole() access to role
DataRoleExpression	AxiomDRoleSubsumption.getSubRole() access to role
ConceptExpression	AxiomConceptInclusion.getSupConcept()
Literal<?>	AxiomValueOfNot.getValue() access to value
Literal<?>	AxiomValueOf.getValue() access to value
boolean	AbstractNaryAxiom.isEmpty()
int	AbstractNaryAxiom.size()

Constructors in uk.ac.manchester.cs.jfact.kernel.dl.axioms with annotations of type PortedFrom

Constructor and Description
AxiomDRoleDomain(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression role, ConceptExpression domain)
AxiomDRoleRange(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression role, DataExpression range)
AxiomDRoleSubsumption(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression subRole, DataRoleExpression supRole)
AxiomORoleRange(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression role, ConceptExpression range)
AxiomSingleDRole(org.semanticweb.owlapi.model.OWLAxiom ax, DataRoleExpression role)
AxiomSingleORole(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression role)

Constructor parameters in uk.ac.manchester.cs.jfact.kernel.dl.axioms with annotations of type PortedFrom

Constructor and Description
AxiomORoleDomain(org.semanticweb.owlapi.model.OWLAxiom ax, ObjectRoleExpression role, ConceptExpression domain)

Uses of PortedFrom in uk.ac.manchester.cs.jfact.kernel.dl.interfaces

Classes in uk.ac.manchester.cs.jfact.kernel.dl.interfaces with annotations of type PortedFrom

Modifier and Type	Interface and Description
interface	Axiom
interface	ConceptArg
interface	ConceptDataCardinalityExpression general data role cardinality expression
interface	ConceptDataRoleExpression
interface	ConceptDataRVExpression
interface	ConceptExpression
interface	ConceptObjectCardinalityExpression
interface	ConceptObjectRCExpression
interface	ConceptObjectRoleExpression general concept expression that contains an object role
interface	DataExpression
interface	DataExpressionArg<T>
interface	DataRoleArg
interface	DataRoleExpression
interface	Entity
interface	Expression
interface	IndividualExpression
interface	NamedEntity
interface	NAryExpression<Argument extends Expression>
interface	NumberArg
interface	ObjectRoleArg
interface	ObjectRoleComplexExpression
interface	ObjectRoleExpression
interface	RoleExpression

Methods in uk.ac.manchester.cs.jfact.kernel.dl.interfaces with annotations of type PortedFrom

Modifier and Type	Method and Description
void	Axiom.accept(DLAxiomVisitor visitor) accept method for the visitor pattern
<O> O	Axiom.accept(DLAxiomVisitorEx<O> visitor)
void	RoleExpression.accept(DLExpressionVisitor visitor)
void	ObjectRoleExpression.accept(DLExpressionVisitor visitor)
void	ObjectRoleComplexExpression.accept(DLExpressionVisitor visitor)
void	IndividualExpression.accept(DLExpressionVisitor visitor)
void	Expression.accept(DLExpressionVisitor visitor) accept method for the visitor pattern
void	DataRoleExpression.accept(DLExpressionVisitor visitor)
void	ConceptObjectRoleExpression.accept(DLExpressionVisitor visitor)
void	ConceptObjectRCExpression.accept(DLExpressionVisitor visitor)
void	ConceptObjectCardinalityExpression.accept(DLExpressionVisitor visitor)
void	ConceptExpression.accept(DLExpressionVisitor visitor)
void	ConceptDataRVExpression.accept(DLExpressionVisitor visitor)
void	ConceptDataRoleExpression.accept(DLExpressionVisitor visitor)
void	ConceptDataCardinalityExpression.accept(DLExpressionVisitor visitor)
<O> O	Expression.accept(DLExpressionVisitorEx<O> visitor)
void	NAryExpression.add(Collection<Expression> v) add a vector
void	NAryExpression.add(Expression p) add a single element to the array
List<Argument>	NAryExpression.getArguments() access to members
TOntologyAtom	Axiom.getAtom()
int	NumberArg.getCardinality() get access to the argument
ConceptExpression	ConceptArg.getConcept() get access to the argument
DataRoleExpression	DataRoleArg.getDataRoleExpression() get access to the argument
NamedEntry	NamedEntity.getEntry()
T	DataExpressionArg.getExpr() get access to the argument
int	Axiom.getId() get the id
String	NamedEntity.getName() get access to the name
ObjectRoleExpression	ObjectRoleArg.getOR() get access to the argument
TSignature	Axiom.getSignature()
boolean	NAryExpression.isEmpty()
boolean	Axiom.isInModule()
boolean	Axiom.isInSS() get the value of the isSearchSpace flag
boolean	Axiom.isUsed() get the value of the used flag
void	Axiom.setAtom(TOntologyAtom atom)
void	NamedEntity.setEntry(NamedEntry e)
void	Axiom.setId(int Id) set the id
void	Axiom.setInModule(boolean inModule)
void	Axiom.setInSS(boolean flag)
void	Axiom.setUsed(boolean Used) set the used flag
int	NAryExpression.size()
Argument	NAryExpression.transform(Expression arg) transform general expression into the argument one

Uses of PortedFrom in uk.ac.manchester.cs.jfact.kernel.modelcaches

Classes in uk.ac.manchester.cs.jfact.kernel.modelcaches with annotations of type PortedFrom

Modifier and Type	Class and Description
class	ModelCacheConst
class	ModelCacheIan
class	ModelCacheInterface
class	ModelCacheSingleton Model caching implementation for singleton models.

Fields in uk.ac.manchester.cs.jfact.kernel.modelcaches with annotations of type PortedFrom

Modifier and Type	Field and Description
ModelCacheState	ModelCacheIan.curState current state of cache model; recalculates on every change
FastSet	ModelCacheIan.existsRoles role names that are labels of the outgoing edges from the root node
FastSet	ModelCacheIan.extraDConcepts extra det-lly concepts that are (partial) Simple Rule applications
FastSet	ModelCacheIan.extraNConcepts extra non-det concepts that are (partial) Simple Rule applications
FastSet	ModelCacheIan.forallRoles role names that appears in the \A restrictions in the root node
FastSet	ModelCacheIan.funcRoles role names that appears in the atmost restrictions in the root node
BitSet	ModelCacheIan.negDConcepts named concepts that appears negatively det-lly in a root node of a cache
BitSet	ModelCacheIan.negNConcepts named concepts that appears negatively non-det in a root node of a cache
BitSet	ModelCacheIan.posDConcepts named concepts that appears positively det-lly in a root node of a cache
BitSet	ModelCacheIan.posNConcepts named concepts that appears positively non-det in a root node of a cache

Methods in uk.ac.manchester.cs.jfact.kernel.modelcaches with annotations of type PortedFrom

Modifier and Type	Method and Description
ModelCacheState	ModelCacheSingleton.canMerge(ModelCacheInterface p) check whether two caches can be merged; @return state of "merged" model
abstract ModelCacheState	ModelCacheInterface.canMerge(ModelCacheInterface p) check whether two caches can be merged; @return state of "merged" model
ModelCacheState	ModelCacheIan.canMerge(ModelCacheInterface p)
ModelCacheState	ModelCacheConst.canMerge(ModelCacheInterface p) check whether two caches can be merged; @return state of "merged" model
void	ModelCacheIan.clear() clear the cache
static ModelCacheConst	ModelCacheConst.createConstCache(int bp) create const cache by BP; BP should be either bpTOP or bpBOTTOM
ModelCacheType	ModelCacheSingleton.getCacheType() Get the tag identifying the cache type
ModelCacheType	ModelCacheInterface.getCacheType() Get the tag identifying the cache type
ModelCacheType	ModelCacheIan.getCacheType() Get the tag identifying the cache type
ModelCacheType	ModelCacheConst.getCacheType() Get the tag identifying the cache type
boolean	ModelCacheConst.getConst() get the value of the constant
ModelCacheState	ModelCacheSingleton.getState() Check if the model contains clash
abstract ModelCacheState	ModelCacheInterface.getState() Check the model cache internal state.
ModelCacheState	ModelCacheIan.getState()
ModelCacheState	ModelCacheConst.getState() Check if the model contains clash
int	ModelCacheSingleton.getValue() access to internal value
boolean	ModelCacheInterface.hasNominalClash(ModelCacheInterface p) check whether both models have nominals; in this case, merge is impossible
void	ModelCacheIan.initRolesFromArcs(DlCompletionTree pCT) init existRoles from arcs; can be used to create pseudo-cache with deps of CT edges
ModelCacheState	ModelCacheIan.isMergableIan(ModelCacheIan q)
ModelCacheState	ModelCacheIan.isMergableSingleton(int Singleton, boolean pos)
void	ModelCacheSingleton.logCacheEntry(int level, LogAdapter l) log this cache entry (with given level)
void	ModelCacheInterface.logCacheEntry(int level, LogAdapter l) log this cache entry (with given level)
void	ModelCacheIan.logCacheEntry(int level, LogAdapter l)
void	ModelCacheConst.logCacheEntry(int level, LogAdapter l) log this cache entry (with given level)
ModelCacheState	ModelCacheIan.merge(ModelCacheInterface p)
void	ModelCacheIan.processAutomaton(DLVertex cur)
void	ModelCacheIan.processConcept(DLVertex cur, boolean pos, boolean det)
boolean	ModelCacheInterface.shallowCache() get type of cache (deep or shallow)
boolean	ModelCacheIan.shallowCache() get type of cache (deep or shallow)
void	ModelCacheInterface.updateNominalStatus(ModelCacheInterface p) update knoweledge about nominals in the model after merging

Uses of PortedFrom in uk.ac.manchester.cs.jfact.kernel.state

Classes in uk.ac.manchester.cs.jfact.kernel.state with annotations of type PortedFrom

Modifier and Type	Class and Description
class	DLCompletionGraphSaveState class for S/R local state
class	DLCompletionTreeSaveState class for saving Completion Tree nodes state
class	SaveList
class	SaveState class for save/restore

Methods in uk.ac.manchester.cs.jfact.kernel.state with annotations of type PortedFrom

Modifier and Type	Method and Description
DLCompletionTreeSaveState	SaveList.pop()
DLCompletionTreeSaveState	SaveList.pop(int level) get element from stack with given level

Uses of PortedFrom in uk.ac.manchester.cs.jfact.split

Classes in uk.ac.manchester.cs.jfact.split with annotations of type PortedFrom

Modifier and Type	Class and Description
class	AOStructure atomical ontology structure
class	AtomicDecomposer atomical decomposer of the ontology
class	BotEquivalenceEvaluator check whether class expressions are equivalent to bottom wrt given locality class
class	KnowledgeExplorer
interface	LocalityChecker
class	SemanticLocalityChecker semantic locality checker for DL axioms
class	SigAccessor helper class to set signature and locality class
class	SigIndex
class	SyntacticLocalityChecker syntactic locality checker for DL axioms
class	TAxiomSplitter
class	TModularizer class to create modules of an ontology wrt module type
class	TOntologyAtom
class	TopEquivalenceEvaluator check whether class expressions are equivalent to top wrt given locality class
class	TSignature class to hold the signature of a module
class	TSignatureUpdater update signature by adding the signature of a given axiom to it
class	TSplitRules all split rules: vector of rules with init and access methods
class	TSplitVar this is to keep the track of new vars/axioms for C >< C0, C1, ..., Cn
class	TSplitVars set of all known var splits with access by name

Fields in uk.ac.manchester.cs.jfact.split with annotations of type PortedFrom

Modifier and Type	Field and Description
protected List<TSplitVar>	TSplitVars.Base
protected Map<ConceptName,Set<AxiomConceptInclusion>>	TAxiomSplitter.ImplNames
protected Map<ConceptName,TAxiomSplitter.TRecord>	TAxiomSplitter.ImpRens
protected Map<ConceptName,TSplitVar>	TSplitVars.Index
protected TModularizer	TAxiomSplitter.mod
protected Ontology	TAxiomSplitter.O
protected List<TAxiomSplitter.TRecord>	TAxiomSplitter.R2
protected Set<ConceptName>	TAxiomSplitter.Rejects
protected Set<TSplitVar>	TAxiomSplitter.RejSplits
protected List<TAxiomSplitter.TRecord>	TAxiomSplitter.Renames
protected TSignature	TAxiomSplitter.sig
protected Set<ConceptName>	TAxiomSplitter.SubNames

Methods in uk.ac.manchester.cs.jfact.split with annotations of type PortedFrom

Modifier and Type	Method and Description
void	TSignature.add(NamedEntity p) add names to signature
void	TOntologyAtom.addAxiom(Axiom ax) add axiom AX to an atom
void	TOntologyAtom.addDepAtom(TOntologyAtom atom) add atom to the dependency set
protected void	TAxiomSplitter.addSingleCI(AxiomConceptInclusion ci) add axiom CI in a form C [= D for D != TOP
Set<NamedEntity>	TSignature.begin()
List<TOntologyAtom>	AOStructure.begin() RW iterator begin
void	TOntologyAtom.buildAllDepAtoms(Set<TOntologyAtom> checked) build all dep atoms; filter them from DepAtoms
protected void	TAxiomSplitter.buildSig(TAxiomSplitter.TRecord rec) create a signature of a module corresponding to a new axiom in record
void	TAxiomSplitter.buildSplit()
protected boolean	TAxiomSplitter.checkSplitCorrectness(TAxiomSplitter.TRecord rec) check whether the record is independent wrt modularity; @return true iff split was incorrect
void	TSignature.clear() clear the signature
void	SigIndex.clear() clear internal structures
protected void	TAxiomSplitter.clearModules() clear modules of Imp and Eq split records
boolean	TSignature.contains(Expression p)
protected void	TAxiomSplitter.createAllImplications() create all the necessary records for the implications
void	TSplitRules.createSplitRules(TSplitVars Splits) create all the split rules by given split set SPLITS
boolean	TSplitVars.empty()
void	TSplitRules.ensureDagSize(int dagSize) ensure that Map has the same size as DAG, so there would be no access violation
void	TModularizer.extract(Collection<Axiom> begin, TSignature signature, ModuleType type) extract module wrt SIGNATURE and TYPE from the set of axioms [BEGIN,END)
List<Axiom>	TModularizer.extractModule(List<Axiom> list, TSignature signature, ModuleType type) extract module wrt SIGNATURE and TYPE from O; @return result in the Set
void	TOntologyAtom.filterDep() remove all atoms in AllDepAtoms from DepAtoms
TOntologyAtom	AOStructure.get(int index) get RW atom by its index
Set<TOntologyAtom>	TOntologyAtom.getAllDepAtoms(Set<TOntologyAtom> checked) get all the atoms the current one depends on; build this set if necessary
AOStructure	AtomicDecomposer.getAOS()
AOStructure	AtomicDecomposer.getAOS(Ontology O, ModuleType t) get the atomic structure for given module type T
Set<Axiom>	TOntologyAtom.getAtomAxioms() get all the atom's axioms
Collection<Axiom>	SigIndex.getAxioms(NamedEntity entity) given an entity, return a set of all axioms that tontain this entity in a signature
List<DataExpression>	KnowledgeExplorer.getDataLabel(DlCompletionTree node, boolean onlyDet)
Set<RoleExpression>	KnowledgeExplorer.getDataRoles(DlCompletionTree node, boolean onlyDet)
Set<TOntologyAtom>	TOntologyAtom.getDepAtoms() get atoms a given one depends on
NamedEntity	TSplitRules.getEntity(int bp)
List<TSplitVar>	TSplitVars.getEntries()
protected ConceptName	TAxiomSplitter.getEqSplit(AxiomEquivalentConcepts ce) check whether an equivalent axiom is splittable; @return split name or NULL if not splittable
protected ConceptExpression	SemanticLocalityChecker.getExpr(Axiom axiom)
int	TOntologyAtom.getId() get the value of the id
protected TAxiomSplitter.TRecord	TAxiomSplitter.getImpRec(ConceptName oldName) get imp record of a given name; create if necessary
LocalityChecker	TModularizer.getLocalityChecker() get access to the Locality checker
Set<Axiom>	TOntologyAtom.getModule() get all the module axioms
List<Axiom>	TModularizer.getModule() get the last computed module
List<DlCompletionTree>	KnowledgeExplorer.getNeighbours(DlCompletionTree node, Role R) build the set of neighbours of a NODE via role ROLE; put the resulting list into RESULT
Set<Axiom>	SigIndex.getNonLocal(boolean top) get the non-local axioms with top-locality value TOP
List<ConceptExpression>	KnowledgeExplorer.getObjectLabel(DlCompletionTree node, boolean onlyDet) put into RESULT all the data expressions from the NODE label
Set<RoleExpression>	KnowledgeExplorer.getObjectRoles(DlCompletionTree node, boolean onlyDet, boolean needIncoming) build the set of object neighbours of a NODE; incoming edges are counted iff NEEDINCOMING is true
List<TSplitRules.TSplitRule>	TSplitRules.getRules()
SigIndex	TModularizer.getSigIndex() get RW access to the sigIndex (mainly to (un-)register axioms on the fly)
TSignature	TModularizer.getSignature() get access to a signature
TSignature	LocalityChecker.getSignature()
void	TSplitRules.initEntityMap(DLDag Dag) init entity map using given DAG.
protected void	TAxiomSplitter.keepIndependentSplits() move all independent splits in R2; delete all the rest
boolean	SyntacticLocalityChecker.local(Axiom axiom)
boolean	LocalityChecker.local(Axiom axiom)
protected void	TAxiomSplitter.makeEqSplit(AxiomEquivalentConcepts ce) make the axiom split for the equivalence axiom
protected TAxiomSplitter.TRecord	TAxiomSplitter.makeImpSplit(ConceptName oldName) make implication split for a given old NAME
TOntologyAtom	AOStructure.newAtom() create a new atom and get a pointer to it
int	SigIndex.nProcessedAx()
void	TModularizer.preprocessOntology(Collection<Axiom> vec) allow the checker to preprocess an ontology if necessary
void	SigIndex.preprocessOntology(Collection<Axiom> axioms) preprocess given set of axioms
void	SemanticLocalityChecker.preprocessOntology(Collection<Axiom> axioms) init kernel with the ontology signature
void	LocalityChecker.preprocessOntology(Collection<Axiom> vec) allow the checker to preprocess an ontology if necessary
void	SigIndex.processAx(Axiom ax) process an axiom wrt its Used status
void	TAxiomSplitter.processRec(TAxiomSplitter.TRecord rec) process (register/unregister) axioms in a record REC
void	AOStructure.reduceGraph() reduce graph of the atoms in the structure
protected void	TAxiomSplitter.registerCIs() register all axioms in a form C [= D
protected void	TAxiomSplitter.registerEQ() split all possible EQ axioms
void	TSignature.remove(NamedEntity p) remove given element from a signature
protected ConceptName	TAxiomSplitter.rename(ConceptName oldName) rename old concept into a new one with a fresh name
void	TOntologyAtom.setId(int id) set the value of the id to ID
void	TSignature.setLocality(boolean top) set new locality polarity
void	TSignature.setLocality(boolean topC, boolean topR) set new locality polarity
void	TOntologyAtom.setModule(Collection<Axiom> module) set the module axioms
void	LocalityChecker.setSignatureValue(TSignature sig)
int	TSignature.size()
int	AOStructure.size() size of the structure
protected void	TAxiomSplitter.splitImplications() split all implications for which equivalences were split as well
protected TSplitVar	TAxiomSplitter.splitImplicationsFor(ConceptName oldName) split all implications corresponding to oldName; @return split pointer
boolean	TSignature.topCLocal()
boolean	SigAccessor.topCLocal()
boolean	TSignature.topRLocal()
boolean	SigAccessor.topRLocal()
void	TSignatureUpdater.visitOntology(Ontology ontology) load ontology to a given KB
void	SemanticLocalityChecker.visitOntology(Ontology ontology) load ontology to a given KB

Uses of PortedFrom in uk.ac.manchester.cs.jfact.visitors

Classes in uk.ac.manchester.cs.jfact.visitors with annotations of type PortedFrom

Modifier and Type	Interface and Description
interface	DLAxiomVisitor
interface	DLExpressionVisitor

Methods in uk.ac.manchester.cs.jfact.visitors with annotations of type PortedFrom

Modifier and Type	Method and Description
void	DLAxiomVisitor.visitOntology(Ontology ontology)