Uses of Class conformance.PortedFrom (JFact 5.0.0 API)

Packages that use PortedFrom
Package	Description
uk.ac.manchester.cs.jfact
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.visitors

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

Classes in uk.ac.manchester.cs.jfact with annotations of type PortedFrom
Modifier and Type	Class and Description
`class`	`KnowledgeExplorer` knowledge explorer

Methods in uk.ac.manchester.cs.jfact with annotations of type PortedFrom
Modifier and Type	Method and Description
`DlCompletionTree`	KnowledgeExplorer.`getBlocker(DlCompletionTree node)`
`List<DataExpression>`	KnowledgeExplorer.`getDataLabel(DlCompletionTree node, boolean onlyDet)`
`Set<DataRoleExpression>`	KnowledgeExplorer.`getDataRoles(DlCompletionTree node, boolean onlyDet)`
`List<DlCompletionTree>`	KnowledgeExplorer.`getNeighbours(DlCompletionTree node, Role no)`
`List<ConceptExpression>`	KnowledgeExplorer.`getObjectLabel(DlCompletionTree node, boolean onlyDet)`
`Set<ObjectRoleExpression>`	KnowledgeExplorer.`getObjectRoles(DlCompletionTree node, boolean onlyDet, boolean needIncoming)`

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)`

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
`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 final 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(TBox tbox)` absorb into BOTTOM;
`boolean`	Axiom.`absorbIntoConcept(TBox tbox)` absorb into concept; @return true if absorption is performed
`boolean`	Axiom.`absorbIntoDomain(TBox tbox)` absorb single axiom AX into role domain; @return true if succeed
`boolean`	Axiom.`absorbIntoNegConcept(TBox tbox)` absorb single concept into negation of a concept;
`boolean`	Axiom.`absorbIntoTop(TBox tbox)` absorb into TOP;
`org.semanticweb.owlapitools.decomposition.AxiomWrapper`	Ontology.`add(org.semanticweb.owlapitools.decomposition.AxiomWrapper 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, 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)`
`Collection<Role>`	RATransition.`begin()`
`List<RATransition>`	RAStateTransitions.`begin()`
`List<Role>`	Role.`beginTopfunc()`
`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)`
`org.semanticweb.owlapitools.decomposition.Signature`	DLConceptTaxonomy.`buildSignature(ClassifiableEntry p)`
`void`	ReasoningKernel.`buildSignature(org.semanticweb.owlapi.model.OWLEntity entity, Collection<org.semanticweb.owlapitools.decomposition.AxiomWrapper> module, Set<org.semanticweb.owlapi.model.OWLEntity> 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.OWLEntity 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, uk.ac.manchester.cs.chainsaw.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 rm)`
`static DataExpression`	ExpressionManager.`dataOneOf(List<Literal<?>> l)`
`static DataExpression`	ExpressionManager.`dataOr(List<DataExpression> l)`
`DataRoleName`	ExpressionCache.`dataRole(org.semanticweb.owlapi.model.OWLEntity 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, boolean knownNew)` 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(java.util.stream.Stream<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
`void`	Taxonomy.`finalise()` call this method after taxonomy is built
`int`	RATransition.`finalState()`
`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)`
`org.semanticweb.owlapitools.decomposition.AxiomWrapper`	Ontology.`get(int i)`
`DLVertex`	DLDag.`get(int i)`
`DepSet`	CWDArray.`get(int bp)`
`int`	Role.`getAbsoluteIndex()`
`List<Role>`	Role.`getAncestor()`
`List<org.semanticweb.owlapitools.decomposition.AxiomWrapper>`	ReasoningKernel.`getAtomAxioms(int index)` get a set of axioms that corresponds to the atom with the id INDEX
`Set<org.semanticweb.owlapitools.decomposition.OntologyAtom>`	ReasoningKernel.`getAtomDependents(int index)` get a set of atoms on which atom with index INDEX depends
`int`	ReasoningKernel.`getAtomicDecompositionSize(org.semanticweb.owlapi.model.OWLOntology o, boolean useSemantics, uk.ac.manchester.cs.owlapi.modularity.ModuleType type)` create new atomic decomposition of the loaded ontology using TYPE.
`List<org.semanticweb.owlapitools.decomposition.AxiomWrapper>`	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<org.semanticweb.owlapitools.decomposition.AxiomWrapper>`	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;
`java.util.stream.Stream<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 or, RoleExpression os, 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()`
`uk.ac.manchester.cs.chainsaw.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)`
`org.semanticweb.owlapi.model.IRI`	NamedEntry.`getIRI()`
`CWDArray`	CGLabel.`getLabel(DagTag tag)`
`org.semanticweb.owlapitools.decomposition.Decomposer`	ReasoningKernel.`getModExtractor(boolean useSemantic, org.semanticweb.owlapi.reasoner.OWLReasoner r)`
`Collection<org.semanticweb.owlapitools.decomposition.AxiomWrapper>`	ReasoningKernel.`getModule(List<Expression> signature, boolean useSemantic, uk.ac.manchester.cs.owlapi.modularity.ModuleType type, org.semanticweb.owlapi.reasoner.OWLReasoner r)`
`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<org.semanticweb.owlapitools.decomposition.AxiomWrapper>`	ReasoningKernel.`getNonLocal(List<Expression> signature, boolean useSemantic, uk.ac.manchester.cs.owlapi.modularity.ModuleType type, org.semanticweb.owlapi.reasoner.OWLReasoner r)`
`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)`
`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<org.semanticweb.owlapitools.decomposition.AxiomWrapper>`	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)`
`void`	TaxonomyVertex.`incorporate(JFactReasonerConfiguration c)`
`int`	CWDArray.`index(int bp)`
`int`	DLDag.`index(NamedEntry c)`
`IndividualName`	ExpressionCache.`individual(org.semanticweb.owlapi.model.OWLEntity name)`
`java.util.stream.Stream<Individual>`	TBox.`individuals()`
`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
`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 its 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 or, DataRoleExpression os)`
`boolean`	ReasoningKernel.`isDisjointRoles(List<? extends RoleExpression> l)`
`boolean`	ReasoningKernel.`isDisjointRoles(ObjectRoleExpression or, ObjectRoleExpression os)`
`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)`
`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 ie, IndividualExpression je)`
`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 or, RoleExpression os)`
`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)`
`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
`java.util.stream.Stream<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()`
`java.util.stream.Stream<DlCompletionTree>`	DlCompletionGraph.`nodes()`
`boolean`	TaxonomyVertex.`noNeighbours(boolean upDirection)`
`boolean`	DlCompletionGraph.`nonMergable(DlCompletionTree p, DlCompletionTree q, Reference<DepSet> dep)`
`boolean`	DlCompletionTree.`nonMergable(DlCompletionTree node, Reference<DepSet> dep)` check if the NODE's and current node's IR are labelled with the same level
`int`	ExpressionCache.`nORoles()`
`static ConceptExpression`	ExpressionManager.`not(ConceptExpression r)`
`ObjectRoleName`	ExpressionCache.`objectRole(org.semanticweb.owlapi.model.OWLEntity 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(org.semanticweb.owlapitools.decomposition.AxiomWrapper 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> l)`
`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<org.semanticweb.owlapi.model.OWLEntity,org.semanticweb.owlapitools.decomposition.Signature> 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(org.semanticweb.owlapitools.decomposition.Signature sig)` set the signature of the expression translator
`void`	ExpressionTranslator.`setSignature(org.semanticweb.owlapitools.decomposition.Signature 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(org.semanticweb.owlapi.model.OWLEntity entity)` 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
`java.util.stream.Stream<Expression>`	Ontology.`signature()`
`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(TBox tbox)` split an axiom;
`java.util.stream.Stream<RATransition>`	RAStateTransitions.`stream()`
`boolean`	TBox.`switchToNonprimitive(DLTree left, DLTree right)`
`java.util.stream.Stream<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 d, 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
`interface`	`WalkerInterface` Base class for taxonomy walkers that provide necessary interface.

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)`
`void`	TaxonomyActor.`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`	`AxiomImpl` Axiom implementation
`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)`
`abstract void`	AxiomImpl.`accept(DLAxiomVisitor visitor)` accept method for the visitor pattern
`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)`
`abstract <O> O`	AxiomImpl.`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`	`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`	RoleExpression.`accept(DLExpressionVisitor visitor)`
`void`	ObjectRoleExpression.`accept(DLExpressionVisitor visitor)`
`void`	ObjectRoleComplexExpression.`accept(DLExpressionVisitor visitor)`
`void`	IndividualExpression.`accept(DLExpressionVisitor visitor)`
`default 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)`
`default <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()`
`int`	NumberArg.`getCardinality()`
`ConceptExpression`	ConceptArg.`getConcept()`
`DataRoleExpression`	DataRoleArg.`getDataRoleExpression()`
`NamedEntry`	NamedEntity.`getEntry()`
`T`	DataExpressionArg.`getExpr()`
`ObjectRoleExpression`	ObjectRoleArg.`getOR()`
`boolean`	NAryExpression.`isEmpty()`
`void`	NamedEntity.`setEntry(NamedEntry e)`
`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.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

Uses of Classconformance.PortedFrom

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Uses of Class
conformance.PortedFrom