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.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.options
uk.ac.manchester.cs.jfact.kernel.state
uk.ac.manchester.cs.jfact.kernel.todolist
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()
void	DataTypeReasoner.reportClash(DepSet dep, DatatypeClashes reason) set clash dep-set to DEP, report with given REASON
void	DataTypeReasoner.reportClash(DepSet dep1, DepSet dep2, DatatypeClashes reason) set clash dep-set to DEP, report with given REASON
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.clear() empty the delegate
static DepSet	DepSet.create()
static DepSet	DepSet.create(DepSet dep)
static DepSet	DepSet.create(int i)
static DepSet	DepSet.create(org.roaringbitmap.RoaringBitmap delegate)
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.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> save stack

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)
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(int 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 inner axiom class
class	AxiomSet set of axioms
class	CGLabel Completion graph label
class	ClassifiableEntry classifiable entry
class	Concept concept
class	ConceptWDep concept and dependency set
class	CWDArray List of concepts with dependencies
class	DlCompletionGraph completion graph
class	DlCompletionTree completion tree
class	DlCompletionTreeArc completion tree arc
class	DLConceptTaxonomy Concept taxonomy
class	DLDag directed acyclic graph
class	DlSatTester sat tester
class	ExpressionManager expression factory
class	ExpressionTranslator expression translator
class	InAx DLTREE utils
class	Individual individual
class	KBFlags flags
class	Lexeme lexeme
class	LogicFeatures logic features
class	MergableLabel label that can be merged
interface	NameCreator<T,K> name creator
class	NamedEntry named entry
class	NameSet<T,K> name set
class	NominalReasoner nominal reasoner
class	Ontology ontology
class	OntologyLoader ontology loader
class	RAStateTransitions class to represent transitions from a single state in an automaton
class	RATransition role automaton transition
class	ReasoningKernel Reasoning kernel
class	Related relation betweenindividuals
class	Restorer restorer
class	Role Role
class	RoleAutomaton role automaton
class	RoleMaster role master
class	SaveStackRare Rare stack
class	Taxonomy taxonomy
class	TaxonomyCreator taxonomy creator for DL
class	TaxonomyVertex taxonomy vertex
class	TBox tbox
class	TDag2Interface class to translate DAG entities into the TDL* expressions

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

Modifier and Type	Field and Description
static int	RoleAutomaton.final_state get the state

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() absorb into BOTTOM;
boolean	Axiom.absorbIntoConcept(TBox KB) absorb into concept; @return true if absorption is performed
boolean	Axiom.absorbIntoDomain(TBox KB) absorb single axiom AX into role domain; @return true if succeed
boolean	Axiom.absorbIntoNegConcept(TBox KB) absorb single concept into negation of a concept;
boolean	Axiom.absorbIntoTop(TBox KB) absorb into TOP;
AxiomInterface	Ontology.add(AxiomInterface p) add given axiom to the ontology
void	Axiom.add(DLTree p) add DLTree to an axiom
int	DLDag.add(DLVertex v)
T	NameSet.add(K id) unconditionally add new element with name ID to the set;
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
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	Concept.addExtraRule(int ruleIndex) add index of a simple rule in TBox to the ER set
void	Role.addFeaturesToSynonym() copy role information (like transitivity, functionality, R&D etc) to synonym
void	RATransition.addIfNew(RATransition trans) add label of transition TRANS to transition's label only if they are new
void	TaxonomyVertex.addNeighbour(boolean upDirection, TaxonomyVertex p) add link in given direction to vertex
boolean	TBox.addNonprimitiveDefinition(Concept left, Concept right, DLTree rightOrigin)
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	TaxonomyCreator.addPossibleParent(TaxonomyVertex parent) add PARENT as a parent if it exists and is direct parent
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
static void	RoleMaster.addRoleParent(DLTree tree, Role parent)
static void	RoleMaster.addRoleParent(Role role, Role parent) add parent for the input role
static void	RoleMaster.addRoleParentProper(Role role, Role parent) add parent for the input role
static void	RoleMaster.addRoleSynonym(Role role, Role syn) add synonym to existing role
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 E) add an axiom CN [= E for defined CN (CN=D already in base)
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
static ConceptExpression	ExpressionManager.and(ConceptExpression C, ConceptExpression D)
static ConceptExpression	ExpressionManager.and(List<ConceptExpression> l)
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)
DLTree	TBox.applyAxiomCNToC(DLTree CN, DLTree D)
DLTree	TBox.applyAxiomCToCN(DLTree D, DLTree CN)
int	TBox.atmost2dag(int n, Role R, int C)
static boolean	TBox.axiomToRangeDomain(DLTree sub, DLTree sup)
List<Role>	Role.begin_topfunc()
Collection<Role>	RATransition.begin()
List<RATransition>	RAStateTransitions.begin()
static ConceptBottom	ExpressionManager.bottom()
ModelCacheInterface	DlSatTester.buildCacheByCGraph(boolean sat)
ConceptExpression	TDag2Interface.buildCExpr(DLVertex v)
DlCompletionTree	TBox.buildCompletionTree(Concept pConcept) build a completion tree for a concept C (no caching as it breaks the idea of KE).
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() build dag
DataExpression	TDag2Interface.buildDExpr(DLVertex v)
TSignature	DLConceptTaxonomy.buildSignature(ClassifiableEntry p)
void	ReasoningKernel.buildSignature(NamedEntity entity, List<AxiomInterface> Module, Set<NamedEntity> toProcess) build signature for ENTITY and all dependent entities from toProcess; look for modules in Module;
void	TBox.buildSimpleCache() build simple cache
void	TBox.calculateStatistic() calculate statistics
void	TBox.calculateTSDepth() calculate TS depth for all concepts
int	Concept.calculateTSDepth()
boolean	Concept.canInitNonPrim(DLTree desc)
void	ClassifiableEntry.canonicaliseSynonym() make sure that synonym's representative is not a synonym itself
boolean	TBox.canUseSortedReasoning()
static ConceptExpression	ExpressionManager.cardinality(int n, DataRoleExpression R, DataExpression E)
static ConceptExpression	ExpressionManager.cardinality(int n, ObjectRoleExpression R, ConceptExpression C)
boolean	DlSatTester.checkDisjointRoles(Role R, Role S)
void	TBox.checkEarlySynonym(Concept p) checks if C is defined as C=D and set Synonyms accordingly
boolean	NominalReasoner.checkExtraCond()
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	TaxonomyCreator.classifyEntry(ClassifiableEntry p)
void	ReasoningKernel.classifyKB() ensure that KB is classified
void	TBox.classifyQueryConcept() classify query concept
void	TaxonomyVertex.clear() clears the vertex
void	SaveStackRare.clear() clear stack
void	Ontology.clear() clear the ontology
void	ExpressionCache.clear() clear the maps
void	DlCompletionGraph.clear() mark all heap elements as unused
void	Concept.clear() clear concept
void	TaxonomyVertex.clearCommon() zero common
void	TBox.clearFeatures() clear current features
boolean	ReasoningKernel.clearKB() reset current KB
void	TaxonomyVertex.clearLinks(boolean upDirection) clear all links in a given direction
void	ExpressionCache.clearNameCache() clear name caches
void	TBox.clearQueryConcept() delete all query-related stuff
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
int	DLDag.compare(int p1, int p2)
void	Role.completeAutomaton(int nRoles) complete role automaton
static ObjectRoleComplexExpression	ExpressionManager.compose(List<ObjectRoleExpression> l)
static ObjectRoleComplexExpression	ExpressionManager.compose(ObjectRoleExpression e1, ObjectRoleExpression e2)
ConceptName	ExpressionCache.concept(org.semanticweb.owlapi.model.IRI name)
int	TBox.concept2dag(Concept p)
void	Role.consistent() check whether role description is consistent
boolean	NominalReasoner.consistentNominalCloud()
boolean	CWDArray.contains(int bp)
boolean	CGLabel.contains(int p)
boolean	CGLabel.containsCC(int p)
boolean	TaxonomyVertex.correctCommon(int n) keep COMMON flag iff both flags are set;
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;
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)
static DataExpression	ExpressionManager.dataAnd(List<DataExpression> l)
int	TBox.dataAtMost2dag(int n, Role R, int C)
static DataBottom	ExpressionManager.dataBottom()
int	TBox.dataForall2dag(Role R, int C)
static DataExpression	ExpressionManager.dataNot(DataExpression E)
static DataExpression	ExpressionManager.dataOneOf(List<Literal<?>> l)
static DataExpression	ExpressionManager.dataOr(List<DataExpression> l)
DataRoleName	ExpressionCache.dataRole(org.semanticweb.owlapi.model.IRI name)
static DataRoleExpression	ExpressionManager.dataRoleBottom()
static DataRoleExpression	ExpressionManager.dataRoleTop()
static DataExpression	ExpressionManager.dataTop()
void	Taxonomy.deFinalise() unlink the bottom from the taxonomy
void	DlCompletionGraph.detectBlockedStatus(DlCompletionTree node)
void	TBox.determineSorts() determine sorts
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
void	ReasoningKernel.doIncremental() incrementally classify changes
void	Concept.dropRelevant() 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)
DLTree	ReasoningKernel.e(Expression expr)
Role	Role.eliminateToldCycles() eliminate told role cycle
boolean	RAStateTransitions.empty()
void	TDag2Interface.ensureDagSize() make sure that size of expression cache is the same as the size of a DAG
Expression	OntologyLoader.ensureNames(Expression Expr) ensure that the expression EXPR has its named entities linked to the KB ones
NamedEntry	RoleMaster.ensureRoleName(org.semanticweb.owlapi.model.IRI name)
static ConceptExpression	ExpressionManager.exists(DataRoleExpression R, DataExpression E)
static ConceptExpression	ExpressionManager.exists(ObjectRoleExpression R, ConceptExpression C)
<T extends Concept> int	TBox.fillArrays(Collection<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()
void	Taxonomy.finalise() call this method after taxonomy is built
boolean	DlSatTester.findConcept(CWDArray label, int p) try to add a concept to a label given by TAG; ~C can't appear in the label
void	DlCompletionGraph.finiIR() fini IR
void	Taxonomy.finishCurrentNode() insert current node either directly or as a synonym
void	TBox.finishLoading() let TBox know that the whole ontology is loaded
static ConceptExpression	ExpressionManager.forall(DataRoleExpression R, DataExpression E)
static ConceptExpression	ExpressionManager.forall(ObjectRoleExpression R, ConceptExpression C)
int	TBox.forall2dag(Role R, int C)
void	DLDag.gatherStatistic() stats collection
RAStateTransitions	RoleAutomaton.get(int i)
AxiomInterface	Ontology.get(int i)
DLVertex	DLDag.get(int i)
DepSet	CWDArray.get(int bp)
int	Role.getAbsoluteIndex()
List<Role>	Role.getAncestor()
Set<AxiomInterface>	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<AxiomInterface>	ReasoningKernel.getAtomModule(int index) get a set of axioms that corresponds to the module of the atom with the id INDEX
RoleAutomaton	Role.getAutomaton()
Concept	TBox.getAuxConcept(DLTree desc)
List<AxiomInterface>	Ontology.getAxioms()
List<RAStateTransitions>	RoleAutomaton.getBase()
List<ConceptWDep>	CWDArray.getBase()
DlCompletionTree	ReasoningKernel.getBlocker(DlCompletionTree node)
Individual	TBox.getBlockingInd(Concept C)
Role	RoleMaster.getBotRole()
TaxonomyVertex	Taxonomy.getBottomVertex()
int	Role.getBPDomain()
int	Role.getBPRange()
ModelCacheInterface	DLDag.getCache(int p)
ConceptWDep	CGLabel.getCCConceptWithBP(int bp)
ConceptExpression	TDag2Interface.getCExpr(int p)
Concept	TBox.getCI(DLTree name)
Concept.CTTag	Concept.getClassTag()
int	ConceptWDep.getConcept()
Concept	TBox.getConcept(org.semanticweb.owlapi.model.IRI name) return registered concept by given NAME;
Collection<Concept>	TBox.getConcepts()
Actor	ReasoningKernel.getConcepts(ConceptExpression C, boolean direct, Actor actor, boolean supDirection) apply actor__apply() to all DIRECT sub-concepts of [complex] C
<T extends Expression> TaxonomyActor<T>	ReasoningKernel.getConcepts(ConceptExpression C, boolean direct, TaxonomyActor<T> actor, boolean supDirection) apply actor__apply() to all super/sub-concepts of [complex] C
ConceptWDep	CGLabel.getConceptWithBP(int bp)
TaxonomyVertex	Taxonomy.getCurrent()
DLDag	TBox.getDag()
DLDag	DlSatTester.getDAG()
int	Lexeme.getData()
String	TBox.getDataEntryByBP(int bp)
List<DataExpression>	ReasoningKernel.getDataLabel(DlCompletionTree node, boolean onlyDet)
Collection<IndividualName>	ReasoningKernel.getDataRelatedIndividuals(RoleExpression R, RoleExpression S, int op, Collection<IndividualExpression> individuals) set RESULT into set of instances of A such that they do have data roles R and S
Set<DataRoleExpression>	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()
DataExpression	TDag2Interface.getDExpr(int p)
void	ReasoningKernel.getDirectInstances(ConceptExpression C, Actor actor) apply actor__apply() to all direct instances of given [complex] C
<T extends Expression> TaxonomyActor<T>	ReasoningKernel.getDisjointConcepts(ConceptExpression C, TaxonomyActor<T> actor) apply actor::apply() to all named concepts disjoint with [complex] C
MergableLabel	Role.getDomainLabel()
RoleMaster	TBox.getDRM()
<T extends ConceptExpression> TaxonomyActor<T>	ReasoningKernel.getDRoleDomain(DataRoleExpression r, boolean direct, TaxonomyActor<T> actor) apply actor::apply() to all DIRECT NC that are in the domain of data role R
NamedEntity	NamedEntry.getEntity()
<T extends Expression> TaxonomyActor<T>	ReasoningKernel.getEquivalentConcepts(ConceptExpression C, TaxonomyActor<T> actor) apply actor__apply() to all synonyms of [complex] C
<T extends RoleExpression> TaxonomyActor<T>	ReasoningKernel.getEquivalentRoles(RoleExpression r, TaxonomyActor<T> actor) apply actor__apply() to all synonyms of [complex] R
Expression	TDag2Interface.getExpr(int p, boolean data)
ExpressionCache	ReasoningKernel.getExpressionManager()
ExpressionCache	Ontology.getExpressionManager()
FastSet	Concept.getExtraRules()
DlCompletionTree	DlCompletionGraph.getFCViolator(int C)
DLTree	TBox.getFreshConcept()
TaxonomyVertex	Taxonomy.getFreshVertex(ClassifiableEntry e)
int	Role.getFunctional()
DLTree	AxiomSet.getGCI()
int	NamedEntry.getId()
abstract int	NamedEntry.getIndex()
int	ClassifiableEntry.getIndex() get the index value
Individual	OntologyLoader.getIndividual(IndividualExpression I, String reason)
Individual	TBox.getIndividual(org.semanticweb.owlapi.model.IRI name) return registered individual by given NAME;
void	ReasoningKernel.getInstances(ConceptExpression C, Actor actor) apply actor__apply() to all instances of given [complex] C
TaxonomyActor<IndividualExpression>	ReasoningKernel.getInstances(ConceptExpression C, TaxonomyActor<IndividualExpression> actor, boolean direct)
CWDArray	CGLabel.getLabel(DagTag tag)
long	ReasoningKernel.getLocCheckNumber()
OntologyBasedModularizer	ReasoningKernel.getModExtractor(boolean useSemantic)
List<AxiomInterface>	ReasoningKernel.getModule(List<Expression> signature, boolean useSemantic, ModuleType type)
org.semanticweb.owlapi.model.IRI	NamedEntry.getName()
NamedEntry	Lexeme.getNE()
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()
DlCompletionTree	DlCompletionGraph.getNode(int i)
Set<AxiomInterface>	ReasoningKernel.getNonLocal(List<Expression> signature, boolean useSemantic, ModuleType type)
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<ObjectRoleExpression>	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
Ontology	ReasoningKernel.getOntology()
JFactReasonerConfiguration	ReasoningKernel.getOptions()
RoleMaster	TBox.getORM()
<T extends ConceptExpression> TaxonomyActor<T>	ReasoningKernel.getORoleDomain(ObjectRoleExpression r, boolean direct, TaxonomyActor<T> actor) apply actor__apply() to all DIRECT NC that are in the domain of [complex] R
ClassifiableEntry	TaxonomyVertex.getPrimer()
MergableLabel	Role.getRangeLabel()
int	Restorer.getRaresavestackLevel()
RAStateTransitions	RoleAutomaton.getRAStateTransitions(int state)
DlSatTester	TBox.getReasoner()
List<Individual>	Individual.getRelatedCache(Role 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)
Role	Related.getRole()
List<Individual>	ReasoningKernel.getRoleFillers(IndividualExpression I, ObjectRoleExpression R)
List<Role>	RoleMaster.getRoles()
<T extends RoleExpression> TaxonomyActor<T>	ReasoningKernel.getRoles(RoleExpression r, boolean direct, TaxonomyActor<T> actor, boolean supDirection) apply actor__apply() to all DIRECT super-roles of [complex] R
DlCompletionTree	DlCompletionGraph.getRoot()
DlCompletionTree	DlSatTester.getRootNode()
<T extends Expression> TaxonomyActor<T>	ReasoningKernel.getSameAs(IndividualName I, TaxonomyActor<T> actor) apply actor__apply() to all synonyms of an individual I
ConceptWDep	CGLabel.getSCConceptWithBP(int bp)
TSignature	Ontology.getSignature()
uk.ac.manchester.cs.jfact.kernel.SimpleRule	TBox.getSimpleRule(int index)
Individual	TBox.getSPForConcept(Concept p)
KBStatus	TBox.getStatus()
ClassifiableEntry	ClassifiableEntry.getSynonym()
TaxonomyVertex	TaxonomyVertex.getSynonymNode()
Taxonomy	TBox.getTaxonomy()
Taxonomy	RoleMaster.getTaxonomy()
TaxonomyVertex	ClassifiableEntry.getTaxVertex()
TBox	ReasoningKernel.getTBox()
DLTree	Role.getTDomain()
int	TBox.getTG()
Token	Lexeme.getToken()
Collection<ClassifiableEntry>	ClassifiableEntry.getToldSubsumers()
Role	RoleMaster.getTopRole()
TaxonomyVertex	Taxonomy.getTopVertex()
List<AxiomInterface>	ReasoningKernel.getTrace()
int	RAStateTransitions.getTransitionEnd()
DLTree	TBox.getTree(Concept C)
DLTree	Role.getTSpecialDomain()
<T extends Expression> TaxonomyActor<T>	ReasoningKernel.getTypes(IndividualName I, boolean direct, TaxonomyActor<T> actor) apply actor__apply() to all DIRECT concepts that are types of an individual I
boolean	TaxonomyVertex.getValue()
boolean	TaxonomyCreator.getValue(TaxonomyVertex node)
boolean	RAStateTransitions.hasEmptyTransition()
boolean	Concept.hasExtraRules()
boolean	TBox.hasFC()
boolean	LogicFeatures.hasFunctionalRestriction()
boolean	LogicFeatures.hasInverseRole()
boolean	NominalReasoner.hasNominals() there are nominals
boolean	DlSatTester.hasNominals()
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()
boolean	LogicFeatures.hasTopRole()
boolean	RAStateTransitions.hasTopTransition()
boolean	DLDag.haveSameSort(int p, int q)
Collection<Individual>	TBox.i_begin()
void	TaxonomyVertex.incorporate(JFactReasonerConfiguration c)
int	CWDArray.index(int bp)
int	DLDag.index(NamedEntry c)
IndividualName	ExpressionCache.individual(org.semanticweb.owlapi.model.IRI name)
void	CWDArray.init() init/clear label
void	CGLabel.init() init the node - this is not in the constructor because objecs will be reused
boolean	AxiomSet.initAbsorptionFlags(String flags)
void	Role.initADbyTaxonomy(Taxonomy pTax, int nRoles)
void	RoleMaster.initAncDesc() init ancestor description
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	ReasoningKernel.initIncremental() initialise the incremental bits on full reload
void	DlCompletionGraph.initIR() init IR
boolean	DlCompletionTree.initIR(int level, DepSet ds) init IR with given entry and dep-set;
void	RoleAutomaton.initMap(int RASize, int fRA) init internal map according to RA size, with new initial state from chainState and (FRA) states
boolean	TBox.initNonPrimitive(Concept p, DLTree desc) add description to a concept;
void	TBox.initRangeDomain(RoleMaster RM)
void	TBox.initReasoner() init reasoner
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.initTaxonomy() init taxonomy and classifier
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;
T	NameSet.insert(K id) Insert id to a nameset (if necessary);
Role	Role.inverse()
ObjectRoleExpression	ExpressionCache.inverse(ObjectRoleExpression R)
boolean	Role.isAsymmetric()
boolean	ReasoningKernel.isAsymmetric(ObjectRoleExpression R)
boolean	Role.isAsymmetryKnown()
boolean	TBox.isBlockedInd(Concept C)
boolean	TBox.isBlockingDet(Concept C)
AtomicBoolean	TBox.isCancelled()
boolean	Ontology.isChanged()
boolean	TaxonomyVertex.isChecked(long checkLab)
boolean	ClassifiableEntry.isClassified()
boolean	TaxonomyVertex.isCommon()
boolean	RoleAutomaton.isCompleted()
boolean	TBox.isConsistent()
boolean	TBox.isCyclic(Concept C)
boolean	TaxonomyCreator.isDirectParent(TaxonomyVertex v)
boolean	Role.isDisjoint()
boolean	ReasoningKernel.isDisjoint(ConceptExpression C, ConceptExpression D)
boolean	Role.isDisjoint(Role 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()
boolean	LogicFeatures.isEmpty()
static boolean	ExpressionManager.isEmptyRole(RoleExpression R)
boolean	ReasoningKernel.isEquivalent(ConceptExpression C, ConceptExpression D)
boolean	Role.isFunctional()
boolean	ReasoningKernel.isFunctional(DataRoleExpression R)
boolean	ReasoningKernel.isFunctional(ObjectRoleExpression R)
boolean	Role.isFunctionalityKnown()
boolean	TBox.isIndividual(DLTree tree)
boolean	ReasoningKernel.isInstance(IndividualExpression I, ConceptExpression C)
boolean	TaxonomyVertex.isInUse()
boolean	ReasoningKernel.isInverseFunctional(ObjectRoleExpression R)
boolean	TBox.isIRinQuery()
boolean	Role.isIrreflexive()
boolean	ReasoningKernel.isIrreflexive(ObjectRoleExpression R)
boolean	TBox.isIrreflexive(Role R)
boolean	Role.isIrreflexivityKnown()
boolean	RoleAutomaton.isISafe()
boolean	ReasoningKernel.isKBClassified()
boolean	ReasoningKernel.isKBConsistent()
boolean	ReasoningKernel.isKBPreprocessed()
boolean	ReasoningKernel.isKBRealised()
boolean	DLDag.isLast(int p)
static boolean	InAx.isNP(Concept C, TBox t)
boolean	TBox.isNRinQuery()
boolean	RoleAutomaton.isOSafe()
boolean	Role.isReflexive()
boolean	ReasoningKernel.isReflexive(ObjectRoleExpression R)
boolean	Role.isReflexivityKnown()
boolean	Role.isRelevant(long lab)
boolean	Concept.isRelevant(long lab)
boolean	ReasoningKernel.isSameIndividuals(IndividualExpression I, IndividualExpression J)
boolean	TBox.isSameIndividuals(Individual _a, Individual _b)
boolean	MergableLabel.isSample()
boolean	TBox.isSatisfiable(Concept pConcept)
boolean	ReasoningKernel.isSatisfiable(ConceptExpression C)
boolean	RoleAutomaton.isSimple()
boolean	Role.isSimple()
static boolean	InAx.isSimpleForall(DLTree p)
boolean	RAStateTransitions.isSingleton()
boolean	ReasoningKernel.isSubChain(ObjectRoleComplexExpression R, List<ObjectRoleExpression> l)
boolean	TBox.isSubHolds(Concept pConcept, Concept qConcept)
boolean	ReasoningKernel.isSubRoles(RoleExpression R, RoleExpression S)
boolean	ReasoningKernel.isSubsumedBy(ConceptExpression C, ConceptExpression D)
boolean	Role.isSymmetric()
boolean	ReasoningKernel.isSymmetric(ObjectRoleExpression R)
boolean	Role.isSymmetryKnown()
boolean	ClassifiableEntry.isSynonym()
boolean	RATransition.isTop()
boolean	Role.isTopFunc()
boolean	Role.isTransitive()
boolean	ReasoningKernel.isTransitive(ObjectRoleExpression R)
boolean	Role.isTransitivityKnown()
static boolean	ExpressionManager.isUniversalRole(RoleExpression R)
boolean	TaxonomyVertex.isValued(long valueLab)
boolean	TaxonomyCreator.isValued(TaxonomyVertex node)
boolean	Taxonomy.isVisited(TaxonomyVertex node)
boolean	CGLabel.lesserequal(CGLabel label)
boolean	CWDArray.lesserequal(CWDArray label)
boolean	Role.lesserequal(Role r)
T	NameCreator.makeEntry(K name)
DLTree	TBox.makeNonPrimitive(Concept p, DLTree desc) make concept non-primitive;
DLTree	Concept.makeNonPrimitive(DLTree desc) switch primitive concept to non-primitive with new definition;
static ConceptExpression	ExpressionManager.maxCardinality(int n, DataRoleExpression R, DataExpression E)
static ConceptExpression	ExpressionManager.maxCardinality(int n, ObjectRoleExpression R, ConceptExpression C)
int	DLDag.maxSize()
int	DlCompletionGraph.maxSize()
void	DlCompletionGraph.merge(DlCompletionTree from, DlCompletionTree to, DepSet dep, List<DlCompletionTreeArc> edges) merge labels; see SHOIN paper for detailed description
void	MergableLabel.merge(MergableLabel p) make 2 labels equal
void	DLDag.merge(MergableLabel ml, int p) merge two given DAG entries
void	TaxonomyVertex.mergeIndepNode(TaxonomyVertex node, Set<TaxonomyVertex> excludes, ClassifiableEntry curEntry) merge NODE which is independent to THIS
void	LogicFeatures.mergeRoles() build bothRoles from single Roles flags
void	Role.mergeSupersDomain() merge domains
static ConceptExpression	ExpressionManager.minCardinality(int n, DataRoleExpression R, DataExpression E)
static ConceptExpression	ExpressionManager.minCardinality(int n, ObjectRoleExpression R, ConceptExpression C)
int	ExpressionCache.nConcepts()
int	ExpressionCache.nDRoles()
void	ReasoningKernel.needTracing() set need tracing to true
Iterable<TaxonomyVertex>	TaxonomyVertex.neigh(boolean upDirection)
int	RoleAutomaton.newState()
void	RoleAutomaton.nextChainTransition(int to) make the internal chain transition (between chainState and TO)
int	ExpressionCache.nIndividuals()
boolean	TaxonomyVertex.noNeighbours(boolean upDirection)
boolean	DlCompletionGraph.nonMergable(DlCompletionTree p, DlCompletionTree q, Reference<DepSet> dep)
boolean	DlCompletionTree.nonMergable(DlCompletionTree node, Reference<DepSet> dep)
int	ExpressionCache.nORoles()
static ConceptExpression	ExpressionManager.not(ConceptExpression C)
ObjectRoleName	ExpressionCache.objectRole(org.semanticweb.owlapi.model.IRI name)
static ObjectRoleExpression	ExpressionManager.objectRoleBottom()
static ObjectRoleExpression	ExpressionManager.objectRoleTop()
ConceptExpression	ExpressionCache.oneOf(IndividualExpression I)
ConceptExpression	ExpressionCache.oneOf(List<IndividualExpression> l)
static ConceptExpression	ExpressionManager.or(ConceptExpression C, ConceptExpression D)
static ConceptExpression	ExpressionManager.or(List<ConceptExpression> l)
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() post process
void	DLConceptTaxonomy.preClassificationActions() actions that to be done BEFORE entry will be classified
void	TBox.prepareFeatures(Concept pConcept, Concept qConcept)
void	TBox.prepareReasoning() prepare reasoning
void	TBox.preprocess() preprocess tbox
void	TBox.preprocessQueryConcept(Concept query) preprocess query concept: put description into DAG
void	TBox.preprocessRelated() preprocess related individuals
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() print features
void	TBox.printIndividuals(LogAdapter o) print all registered individuals
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)
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
void	TBox.processSame(List<DLTree> l)
static ObjectRoleComplexExpression	ExpressionManager.projectFrom(ObjectRoleExpression R, ConceptExpression C)
static ObjectRoleComplexExpression	ExpressionManager.projectInto(ObjectRoleExpression R, ConceptExpression C)
boolean	Taxonomy.queryMode()
Role	Role.realInverse()
void	ReasoningKernel.realiseKB() ensure that KB is realised
boolean	RAStateTransitions.recognise(Role R)
int	TBox.reflexive2dag(Role R)
void	TBox.registerIndividualRelation(NamedEntry a, NamedEntry R, NamedEntry b) individual relation (a,b):R
void	TaxonomyVertex.remove() remove given node from a graph
void	Concept.removeDescription() remove concept description (to save space)
void	TBox.removeExtraDescriptions() remove extra descritpions
boolean	TaxonomyVertex.removeLink(boolean upDirection, TaxonomyVertex p)
void	TaxonomyVertex.removeLinks(boolean upDirection) remove one half of a given node from a graph
void	Taxonomy.removeNode(TaxonomyVertex node) remove node from the taxonomy; assume no references to the node
void	DLDag.removeQuery() clean query
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
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
MergableLabel	MergableLabel.resolve() make label's depth lesser than or equal 2;
int	Concept.resolveId()
static Role	Role.resolveRole(DLTree t)
static Role	Role.resolveRole(DLTree t, String r)
static <T extends ClassifiableEntry> T	ClassifiableEntry.resolveSynonym(T p)
abstract void	Restorer.restore() restore an object based on saved information
void	SaveStackRare.restore(int level) get all object from the top of the stack with levels greater or equal LEVEL
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	DlCompletionGraph.retestCGBlockedStatus() retest every d-blocked node in the CG.
void	Ontology.retract(AxiomInterface p) retract given axiom to the ontology
void	DLConceptTaxonomy.runBottomUp() explicitely run BU phase
boolean	DlSatTester.runSat(int p, int q)
void	DLConceptTaxonomy.runTopDown() explicitely run TD phase
void	Ontology.safeClear() safe clear the ontology (do not remove axioms)
void	DlCompletionGraph.save() save dl completion graph
int	CWDArray.save() save label using given SS
void	CGLabel.save(SaveState 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	Concept.searchTSbyRoleAndSupers(Role r, Set<Role> RolesProcessed)
static ConceptExpression	ExpressionManager.selfReference(ObjectRoleExpression R)
void	Role.setAsymmetric(boolean value) set the asymmetry of both role and it's inverse
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;
void	TaxonomyVertex.setChecked(long checkLab)
void	TaxonomyVertex.setCommon() increment common
void	RoleAutomaton.setCompleted(boolean b) mark an automaton as completed
void	TaxonomyCreator.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)
void	Taxonomy.setCurrent(TaxonomyVertex cur) set current to a given node
void	Role.setDomain(DLTree p) add p to domain of the role
void	NamedEntry.setEntity(NamedEntity entity)
void	DLDag.setExpressionCache(boolean val) whether to use cache for nodes
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;
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	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	TaxonomyVertex.setInUse(boolean value) set the inUse value of the node
void	Role.setInverse(Role p) set inverse to given role
void	LogicFeatures.setInverseRoles() allow user to set presence of inverse roles
void	Role.setIrreflexive(boolean value) set the irreflexivity of both role and it's inverse
void	RoleAutomaton.setIUnsafe() state that the automaton is i-unsafe
void	TBox.setNameSigMap(Map<NamedEntity,TSignature> p) set NameSigMap
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(boolean value) set the reflexivity of both role and it's inverse
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	ExpressionTranslator.setSignature(TSignature s) set internal signature to a given signature S
void	Role.setSpecialDomain(int bp) set the special domain value
void	DLDag.setSubOrder() use SUB options to OR ordering
void	Role.setSymmetric(boolean value) set the symmetry of both role and it's inverse
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	Role.setTransitive(boolean value) set the transitivity of both role and it's inverse
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)
void	ReasoningKernel.setupSig(NamedEntity entity, List<AxiomInterface> Module) setup Name2Sig for a given entity;
boolean	TaxonomyCreator.setValue(TaxonomyVertex node, boolean value) set the classification value of a NODE to VALUE
boolean	TaxonomyVertex.setValued(boolean val, long valueLab)
void	TaxonomyVertex.setVertexAsHost(ClassifiableEntry entry) mark vertex as the one corresponding to a given ENTRY
void	Taxonomy.setVisited(TaxonomyVertex node) set node NODE as checked within taxonomy
void	Related.simplify() simplify structure wrt synonyms
Axiom	Axiom.simplifyCN(TBox t) replace a defined concept with its description
Axiom	Axiom.simplifyForall(TBox KB) replace a universal restriction with a fresh concept
int	RoleMaster.size()
int	RoleAutomaton.size()
int	Ontology.size()
int	DLDag.size()
int	CWDArray.size()
List<Axiom>	Axiom.split() split an axiom;
boolean	TBox.switchToNonprimitive(DLTree left, DLTree right)
Set<ClassifiableEntry>	TaxonomyVertex.synonyms()
ModelCacheState	TBox.testCachedNonSubsumption(Concept p, Concept q) test if 2 concept non-subsumption can be determined by cache merging
boolean	TBox.testHasNominals()
boolean	TBox.testHasTopRole()
boolean	TBox.testSortedNonSubsumption(Concept p, Concept q)
static ConceptTop	ExpressionManager.top()
void	TBox.transformSingletonHierarchy() transform singleton hierarchy
void	TBox.transformToldCycles() transform cycles
int	TBox.tree2dag(DLTree t)
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
Restorer	DlCompletionTree.updateIR(DlCompletionTree node, DepSet toAdd) update IR of the current node with IR from NODE and additional clash-set;
void	DLDag.updateSorts(int a, Role R, int b) update sorts for (a,b):R construction
static ConceptExpression	ExpressionManager.value(DataRoleExpression R, Literal<?> V)
static ConceptExpression	ExpressionManager.value(ObjectRoleExpression R, IndividualExpression I)
void	OntologyLoader.visitOntology(Ontology ontology) load ontology to a given KB
boolean	AxiomSet.wasRoleAbsorptionApplied()
void	TBox.writeReasoningResult(long time)
void	ReasoningKernel.writeReasoningResult(long time) dump query processing TIME, reasoning statistics and a (preprocessed) TBox
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 RI actor
class	SupConceptActor class for exploring concept taxonomy to find super classes
class	TaxonomyActor<T extends Expression> class for acting with concept taxonomy

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

Modifier and Type	Method and Description
boolean	TaxonomyActor.apply(TaxonomyVertex v)
boolean	SupConceptActor.apply(TaxonomyVertex v)
boolean	AddRoleActor.apply(TaxonomyVertex v)
boolean	ActorImpl.apply(TaxonomyVertex v)
boolean	Actor.apply(TaxonomyVertex v) taxonomy walking method.
void	TaxonomyActor.clear()
void	ActorImpl.clear()
List<Collection<T>>	TaxonomyActor.getElements()
List<ClassifiableEntry>	ActorImpl.getElements1D()
List<List<ClassifiableEntry>>	ActorImpl.getElements2D()
Collection<T>	TaxonomyActor.getSynonyms()
void	ActorImpl.needConcepts() set the actor to look for classes
void	ActorImpl.needDataRoles() set the actor to look for individuals
void	ActorImpl.needIndividuals() set the actor to look for individuals
void	ActorImpl.needObjectRoles() set the actor to look for object properties
void	ActorImpl.setInterruptAfterFirstFound(boolean value)

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

Constructor and Description
TaxonomyActor(ExpressionCache em, Policy p)

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 concept intersection
class	ConceptBottom bottom
class	ConceptDataExactCardinality data exact cardinality
class	ConceptDataExists exist data restriction
class	ConceptDataForall forall data restriction
class	ConceptDataMaxCardinality data max cardinality
class	ConceptDataMinCardinality data min cardinality
class	ConceptDataValue concept data value
class	ConceptName named concept
class	ConceptNot concept negation
class	ConceptObjectExactCardinality object exact cardinality
class	ConceptObjectExists object exist restriction
class	ConceptObjectForall forall object restriction
class	ConceptObjectMaxCardinality object max cardinality
class	ConceptObjectMinCardinality object min cardinality
class	ConceptObjectSelf self object restriction
class	ConceptObjectValue object value restriction
class	ConceptOneOf<I extends IndividualExpression> object nominal
class	ConceptOr concept union
class	ConceptTop top
class	DataAnd data intersection
class	DataBottom data bottom concept
class	DataNot data negation
class	DataOneOf data one of
class	DataOr data union
class	DataRoleBottom data bottom property
class	DataRoleName data role name
class	DataRoleTop data role top
class	DataTop data top
class	IndividualName individual name
class	NamedEntityImpl named entity base class
class	NAryExpressionImpl<A extends Expression> nary expression base
class	ObjectRoleBottom bottom object role
class	ObjectRoleChain object role chain
class	ObjectRoleInverse object role inverse
class	ObjectRoleName object role
class	ObjectRoleProjectionFrom object role projection from
class	ObjectRoleProjectionInto object role projection into
class	ObjectRoleTop object role top

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.getIndividual()
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 SubClassOf
class	AxiomDeclaration declaration
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 data role domain
class	AxiomDRoleFunctional functional data role
class	AxiomDRoleRange data role range
class	AxiomDRoleSubsumption data role subsumption
class	AxiomEquivalentConcepts equivalent concepts
class	AxiomEquivalentDRoles Data Role equivalence axiom
class	AxiomEquivalentORoles Object Role equivalence axiom
class	AxiomFairnessConstraint Fairness constraint axiom
class	AxiomInstanceOf class assertion
class	AxiomORoleDomain object role domain
class	AxiomORoleFunctional functional object role
class	AxiomORoleRange object role range
class	AxiomORoleSubsumption object role subsumption
class	AxiomRelatedTo object role assertion
class	AxiomRelatedToNot negated object role assertion
class	AxiomRoleAsymmetric asymmetric object role
class	AxiomRoleInverse inverse object property
class	AxiomRoleInverseFunctional inverse functional object role
class	AxiomRoleIrreflexive irreflexive object role
class	AxiomRoleReflexive reflexive object role
class	AxiomRoleSymmetric symmetric object role
class	AxiomRoleTransitive transitive object role
class	AxiomSameIndividuals Same individuals axiom
class	AxiomSingleDRole data role axiom
class	AxiomSingleORole object role axiom
class	AxiomValueOf data has value axiom
class	AxiomValueOfNot negation of data hasvalue axiom

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()
DataRoleExpression	AxiomValueOf.getAttribute()
ConceptExpression	AxiomInstanceOf.getC()
ConceptExpression	AxiomDisjointUnion.getConcept()
Expression	AxiomDeclaration.getDeclaration()
ConceptExpression	AxiomORoleDomain.getDomain()
ConceptExpression	AxiomDRoleDomain.getDomain()
ObjectRoleExpression	AxiomRoleInverse.getInvRole()
ConceptExpression	AxiomORoleRange.getRange()
DataExpression	AxiomDRoleRange.getRange()
IndividualExpression	AxiomRelatedToNot.getRelatedIndividual()
IndividualExpression	AxiomRelatedTo.getRelatedIndividual()
ObjectRoleExpression	AxiomRelatedToNot.getRelation()
ObjectRoleExpression	AxiomRelatedTo.getRelation()
ObjectRoleExpression	AxiomSingleORole.getRole()
DataRoleExpression	AxiomSingleDRole.getRole()
ConceptExpression	AxiomConceptInclusion.getSubConcept()
ObjectRoleComplexExpression	AxiomORoleSubsumption.getSubRole()
DataRoleExpression	AxiomDRoleSubsumption.getSubRole()
ConceptExpression	AxiomConceptInclusion.getSupConcept()
Literal<?>	AxiomValueOfNot.getValue()
Literal<?>	AxiomValueOf.getValue()
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)

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	AxiomInterface Axiom interface
interface	ConceptArg concept expression
interface	ConceptDataCardinalityExpression general data role cardinality expression
interface	ConceptDataRoleExpression data role expression
interface	ConceptDataRVExpression data restriction
interface	ConceptExpression concept expression
interface	ConceptObjectCardinalityExpression object cardinality expression
interface	ConceptObjectRCExpression object restriction expression
interface	ConceptObjectRoleExpression general concept expression that contains an object role
interface	DataExpression data expression
interface	DataExpressionArg<T> data expression
interface	DataRoleArg data role
interface	DataRoleExpression data role expression
interface	Entity entity
interface	Expression expression
interface	IndividualExpression individual expression
interface	NamedEntity named entity
interface	NAryExpression<A extends Expression> nary expression
interface	NumberArg number arg
interface	ObjectRoleArg object role arg
interface	ObjectRoleComplexExpression object role complex expression
interface	ObjectRoleExpression object role expression
interface	RoleExpression role expression

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

Modifier and Type	Method and Description
void	AxiomInterface.accept(DLAxiomVisitor visitor) accept method for the visitor pattern
<O> O	AxiomInterface.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(A p) add a single element to the array
void	NAryExpression.add(Collection<A> v) add a vector
List<A>	NAryExpression.getArguments()
TOntologyAtom	AxiomInterface.getAtom()
int	NumberArg.getCardinality()
ConceptExpression	ConceptArg.getConcept()
DataRoleExpression	DataRoleArg.getDataRoleExpression()
NamedEntry	NamedEntity.getEntry()
T	DataExpressionArg.getExpr()
int	AxiomInterface.getId()
ObjectRoleExpression	ObjectRoleArg.getOR()
TSignature	AxiomInterface.getSignature()
boolean	NAryExpression.isEmpty()
boolean	AxiomInterface.isInModule()
boolean	AxiomInterface.isInSS()
boolean	AxiomInterface.isUsed()
void	AxiomInterface.setAtom(TOntologyAtom atom)
void	NamedEntity.setEntry(NamedEntry e)
void	AxiomInterface.setId(int Id)
void	AxiomInterface.setInModule(boolean inModule)
void	AxiomInterface.setInSS(boolean flag)
void	AxiomInterface.setUsed(boolean Used)
int	NAryExpression.size()
A	NAryExpression.transform(Expression arg)

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 model cache const
class	ModelCacheIan model cache Ian (Horrocks)
class	ModelCacheInterface model cache
class	ModelCacheSingleton Model caching implementation for singleton models.

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;
abstract ModelCacheState	ModelCacheInterface.canMerge(ModelCacheInterface p) check whether two caches can be merged;
ModelCacheState	ModelCacheIan.canMerge(ModelCacheInterface p)
ModelCacheState	ModelCacheConst.canMerge(ModelCacheInterface p) check whether two caches can be merged;
void	ModelCacheIan.clear() clear the cache
static ModelCacheConst	ModelCacheConst.createConstCache(int bp)
ModelCacheType	ModelCacheSingleton.getCacheType() Get the tag identifying the cache type
ModelCacheType	ModelCacheInterface.getCacheType()
ModelCacheType	ModelCacheIan.getCacheType() Get the tag identifying the cache type
ModelCacheType	ModelCacheConst.getCacheType() Get the tag identifying the cache type
boolean	ModelCacheConst.getConst()
ModelCacheState	ModelCacheSingleton.getState() Check if the model contains clash
abstract ModelCacheState	ModelCacheInterface.getState()
ModelCacheState	ModelCacheIan.getState()
ModelCacheState	ModelCacheConst.getState() Check if the model contains clash
int	ModelCacheSingleton.getValue()
boolean	ModelCacheInterface.hasNominalClash(ModelCacheInterface p)
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)
abstract 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()
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.options

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

Modifier and Type	Method and Description
JFactReasonerConfiguration	JFactReasonerConfiguration.setUseNodeCache(boolean val) set flag to use node cache to value VAL.

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 save list
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)

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

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

Modifier and Type	Class and Description
class	ToDoList todo list
class	ToDoPriorMatrix priority matrix

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

Modifier and Type	Field and Description
static int	ToDoPriorMatrix.nRegularOptions number of regular options (o- and NN-rules are not included)

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

Modifier and Type	Method and Description
void	ToDoList.addEntry(DlCompletionTree node, DagTag type, ConceptWDep C) add entry with given NODE and CONCEPT with given OFFSET to the Todo table
void	ToDoList.clear() clear Todo table
void	ArrayQueue.clear() clear queue
int	ToDoPriorMatrix.getIndex(DagTag Op, boolean Sign, boolean NominalNode)
ToDoEntry	ToDoList.getNextEntry()
void	ToDoPriorMatrix.initPriorities(String options) Auxiliary class to get priorities on operations
boolean	ArrayQueue.isEmpty()
void	ToDoList.restore(int level) restore state to the given level using internal stack
void	ArrayQueue.restore(int[][] tss, int pos) restore queue content from the given entry
void	ArrayQueue.restore(int sp, int ep)
void	ToDoList.restoreState(TODOListSaveState tss) restore Todo table content from given saveState entry
void	ToDoList.save() save current state using internal stack
void	ArrayQueue.save(int[][] tss, int pos) save queue content to the given entry
void	ToDoList.saveState(TODOListSaveState tss) save current Todo table content to given saveState entry

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	GeneralSyntacticLocalityChecker syntactic locality checker for DL axioms
class	KnowledgeExplorer knowledge explorer
interface	LocalityChecker locality checker
class	OntologyBasedModularizer modularizer
class	SemanticLocalityChecker semantic locality checker for DL axioms
class	SigAccessor helper class to set signature and locality class
class	SigIndex signature index
class	SyntacticLocalityChecker syntactic locality checker for DL axioms
class	TModularizer class to create modules of an ontology wrt module type
class	TOntologyAtom ontology atom
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

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	TSignature.add(TSignature Sig) add another signature to a given one
void	TOntologyAtom.addAxiom(AxiomInterface ax) add axiom AX to an atom
void	TOntologyAtom.addDepAtom(TOntologyAtom atom) add atom to the dependency set
Set<NamedEntity>	TSignature.begin()
boolean	TSignature.botCLocal()
boolean	TSignature.botRLocal()
void	TOntologyAtom.buildAllDepAtoms(Set<TOntologyAtom> checked) build all dep atoms; filter them from DepAtoms
void	TSignature.clear() clear the signature
void	SigIndex.clear() clear internal structures
boolean	TSignature.contains(Expression p)
void	TModularizer.extract(AxiomInterface begin, TSignature signature, ModuleType type)
void	TModularizer.extract(Collection<AxiomInterface> begin, TSignature signature, ModuleType type) extract module wrt SIGNATURE and TYPE from the set of axioms [BEGIN,END)
List<AxiomInterface>	TModularizer.extractModule(List<AxiomInterface> list, TSignature signature, ModuleType type) extract module wrt SIGNATURE and TYPE from O;
void	TOntologyAtom.filterDep() remove all atoms in AllDepAtoms from DepAtoms
TOntologyAtom	AOStructure.get(int index)
Set<TOntologyAtom>	TOntologyAtom.getAllDepAtoms(Set<TOntologyAtom> checked)
AOStructure	AtomicDecomposer.getAOS()
AOStructure	AtomicDecomposer.getAOS(Ontology O, ModuleType t)
Set<AxiomInterface>	TOntologyAtom.getAtomAxioms()
List<TOntologyAtom>	AOStructure.getAtoms()
Collection<AxiomInterface>	SigIndex.getAxioms(NamedEntity entity) given an entity,
DlCompletionTree	KnowledgeExplorer.getBlocker(DlCompletionTree node)
List<DataExpression>	KnowledgeExplorer.getDataLabel(DlCompletionTree node, boolean onlyDet)
Set<DataRoleExpression>	KnowledgeExplorer.getDataRoles(DlCompletionTree node, boolean onlyDet)
Set<TOntologyAtom>	TOntologyAtom.getDepAtoms()
int	TOntologyAtom.getId()
LocalityChecker	TModularizer.getLocalityChecker()
long	AtomicDecomposer.getLocChekNumber()
TModularizer	OntologyBasedModularizer.getModularizer()
Set<AxiomInterface>	TOntologyAtom.getModule()
List<AxiomInterface>	TModularizer.getModule()
List<AxiomInterface>	OntologyBasedModularizer.getModule(List<AxiomInterface> axioms, TSignature sig, ModuleType type)
List<AxiomInterface>	OntologyBasedModularizer.getModule(TSignature sig, ModuleType type)
long	TModularizer.getNChecks()
List<DlCompletionTree>	KnowledgeExplorer.getNeighbours(DlCompletionTree node, Role R)
Set<AxiomInterface>	SigIndex.getNonLocal(boolean top)
List<ConceptExpression>	KnowledgeExplorer.getObjectLabel(DlCompletionTree node, boolean onlyDet)
Set<ObjectRoleExpression>	KnowledgeExplorer.getObjectRoles(DlCompletionTree node, boolean onlyDet, boolean needIncoming)
SigIndex	TModularizer.getSigIndex()
TSignature	TModularizer.getSignature()
TSignature	LocalityChecker.getSignature()
boolean	TModularizer.isTautology(AxiomInterface ax, ModuleType type)
boolean	TopEquivalenceEvaluator.isTopEquivalent(Expression expr)
boolean	LocalityChecker.local(AxiomInterface axiom)
boolean	GeneralSyntacticLocalityChecker.local(AxiomInterface axiom)
boolean	TSignature.nc(NamedEntity entity)
TOntologyAtom	AOStructure.newAtom()
int	SigIndex.nProcessedAx()
void	TModularizer.preprocessOntology(Collection<AxiomInterface> vec) allow the checker to preprocess an ontology if necessary
void	SigIndex.preprocessOntology(Collection<AxiomInterface> axioms) preprocess given set of axioms
void	SemanticLocalityChecker.preprocessOntology(Collection<AxiomInterface> axioms) init kernel with the ontology signature
void	LocalityChecker.preprocessOntology(Collection<AxiomInterface> vec) allow the checker to preprocess an ontology if necessary
void	SigIndex.processAx(AxiomInterface ax) process an axiom wrt its Used status
void	AOStructure.reduceGraph() reduce graph of the atoms in the structure
void	TSignature.remove(NamedEntity p) remove given element from a signature
void	TopEquivalenceEvaluator.setBotEval(BotEquivalenceEvaluator eval) set the corresponding bottom evaluator
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<AxiomInterface> module) set the module axioms
void	AtomicDecomposer.setProgressIndicator(uk.ac.manchester.cs.jfact.split.ProgressIndicatorInterface pi)
void	LocalityChecker.setSignatureValue(TSignature sig)
int	TSignature.size()
int	AOStructure.size()
boolean	TSignature.subset(TSignature sig, boolean improper)
boolean	TSignature.topCLocal()
boolean	SigAccessor.topCLocal()
boolean	TSignature.topRLocal()
boolean	SigAccessor.topRLocal()

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

Constructor and Description
OntologyBasedModularizer(Ontology ontology, TModularizer mod)

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 axiom visitor
interface	DLExpressionVisitor expression visitor