public class OWLGraphManipulator extends Object
Notably, at instantiation of this class, several operations are performed to obtain only
simple edges between classes, similar to what the method getOutgoingEdges
is simulating.
The operations performed are, in order:
OWLObjectUnionOf
s, that are part of
an OWLEquivalentClassesAxiom
, into individual OWLSubClassOfAxiom
s, where
the named classes part of the OWLObjectUnionOf
become subclasses, and
the top level named classes of the OWLEquivalentClassesAxiom
, superclass.
OWLEquivalentClassesAxiom
s into OWLSubClassOfAxiom
s
using a
ConvertEquivalentClassesToSuperClasses.
OWLSubClassOfAxiom
s, whose superclass is an
OWLObjectIntersectionOf
, into multiple OWLSubClassOfAxiom
s, using a
SplitSubClassAxioms.
OWLEquivalentClassesAxiom
or OWLSubClassOfAxiom
using
an OWLObjectUnionOf
.
OWLClass
es.
OWLEquivalentClassesAxiom
s, or OWLObjectIntersectionOf
s, or
OWLObjectUnionOf
s. These operations are doing for real what the method getOutgoingEdges
is simulating
under the hood.
Even before these operations take place, all imported ontologies are merged into the source ontology, then removed from the import closure, to be able to modify any relation or any class.
Warning: these operations must be performed on an ontology already reasoned, as this class does not accept any reasoner for now.
This class then allows to perform:
reduceRelations()
.
reducePartOfIsARelations()
.
removeClassAndPropagateEdges(String)
.
mapRelationsToParent(Collection)
and mapRelationsToParent(Collection, Collection)
filterRelations(Collection, boolean)
and removeRelations(Collection, boolean)
.
removeRelsToSubsets(Collection)
filterSubgraphs(Collection)
and
removeSubgraphs(Collection, boolean)
.
simplifies
.Constructor and Description |
---|
OWLGraphManipulator(OWLGraphWrapper owlGraphWrapper)
Constructor providing the
OWLGraphWrapper
wrapping the ontology on which modifications will be performed. |
OWLGraphManipulator(org.semanticweb.owlapi.model.OWLOntology ont)
Constructor providing the
OWLOntology on which modifications
will be performed, that will be wrapped in a OWLGraphWrapper . |
Modifier and Type | Method and Description |
---|---|
boolean |
addEdge(OWLGraphEdge edge)
Add
edge to its related ontology. |
int |
addEdges(Set<OWLGraphEdge> edges)
Add
edges to their related ontology. |
Set<org.semanticweb.owlapi.model.OWLClass> |
filterClasses(Set<org.semanticweb.owlapi.model.OWLClass> classesToKeep)
Filter from the ontologies all
OWLClass es
present in classesToKeep ,
and then update the OWLGraphWrapper container. |
int |
filterRelations(Collection<String> allowedRels,
boolean allowSubRels)
Filter the
OWLAxiom s in the ontologies to keep only
those that correspond to OWLObjectProperty s listed in allowedRels ,
as OBO-style IDs. |
Set<String> |
filterSubgraphs(Collection<String> allowedSubgraphRootIds)
Keep in the ontologies only the subgraphs starting
from the provided
OWLClass es, and their ancestors. |
OWLGraphWrapper |
getOwlGraphWrapper()
Get the
OWLGraphWrapper on which modifications
are performed. |
boolean |
isAPartOfEdge(OWLGraphEdge edge)
Determine if
edge represents a part_of relation or one of its sub-relations
(e.g., "deep_part_of"). |
boolean |
isASubClassOfEdge(OWLGraphEdge edge)
Determine if
edge represents an is_a relation. |
void |
makeSimpleOntology()
Make a basic ontology, with only is_a, part_of, and develops_from relations,
and redundant relations removed, and redundant relations over is_a/part_of
removed.
|
int |
mapRelationsToParent(Collection<String> parentRelations)
Replace the sub-relations of
parentRelations by these parent relations. |
int |
mapRelationsToParent(Collection<String> parentRelations,
Collection<String> relsExcluded)
Identical to
mapRelationsToParent(Collection) , except that this method
allows to filter relations not to be mapped to parents: |
int |
reducePartOfIsARelations()
Remove redundant relations by considering is_a (SubClassOf)
and part_of relations equivalent.
|
int |
reduceRelations()
Remove redundant relations.
|
boolean |
removeClass(org.semanticweb.owlapi.model.OWLClass classToDel)
Remove from all ontologies the
OWLClass classToDel ,
and then update the OWLGraphWrapper container. |
int |
removeClassAndPropagateEdges(String classToRemoveId)
Remove the
OWLClass with the OBO-style ID classToRemoveId
from the ontology, and propagate its incoming edges to the targets
of its outgoing edges. |
Set<org.semanticweb.owlapi.model.OWLClass> |
removeClasses(Set<org.semanticweb.owlapi.model.OWLClass> classesToDel)
Remove from all ontologies all
OWLClass es
present in classesToDel ,
and then update the OWLGraphWrapper container. |
int |
removeDirectEdgesBetween(String sourceId,
String targetId)
Remove direct edges between the
OWLObject s with the OBO-like IDs
sourceId and targetId . |
boolean |
removeEdge(OWLGraphEdge edge)
Remove
edge from its ontology. |
int |
removeEdges(Collection<OWLGraphEdge> edges)
Remove
edges from their related ontology. |
int |
removeRelations(Collection<String> forbiddenRels,
boolean forbidSubRels)
Remove the
OWLAxiom s in the ontologies
corresponding to the OWLObjectProperty s listed in forbiddenRels ,
as OBO-style IDs. |
int |
removeRelsToSubsets(Collection<String> subsets)
Delegates method call to
removeRelsToSubsets(Collection, Collection) ,
with no OWLClass es excluded specified. |
int |
removeRelsToSubsets(Collection<String> subsets,
Collection<String> classIdsExcluded)
Remove is_a and part_of incoming edges to
OWLClass es
in subsets , only if the source of the incoming edge
will not be left orphan of other is_a/part_of relations to OWLClass es
not in subsets . |
Set<String> |
removeSubgraphs(Collection<String> subgraphRootIds,
boolean keepSharedClasses)
Delegates to
removeSubgraphs(Collection, boolean, Collection) ,
with the last Collection argument being null . |
Set<String> |
removeSubgraphs(Collection<String> subgraphRootIds,
boolean keepSharedClasses,
Collection<String> allowedSubgraphRootIds)
Remove from the ontology the subgraphs starting
from the
OWLClass es with their ID in subgraphRootIds . |
void |
removeUnrelatedRelations(Collection<String> allowedRels)
Remove from all
OWLOntologies wrapped by this object
the OWLObjectProperty s not related to the provided allowedRels . |
void |
simplifies(Collection<String> classIdsToRemove,
Collection<String> relIds,
Collection<String> toRemoveSubgraphRootIds,
Collection<String> toFilterSubgraphRootIds,
Collection<String> subsetNames)
Helper method to perform standard simplifications.
|
public OWLGraphManipulator(org.semanticweb.owlapi.model.OWLOntology ont) throws org.semanticweb.owlapi.model.UnknownOWLOntologyException
OWLOntology
on which modifications
will be performed, that will be wrapped in a OWLGraphWrapper
.ont
- The OWLOntology
on which the operations will be
performed.org.semanticweb.owlapi.model.OWLOntologyCreationException
- If an error occurred while wrapping
the OWLOntology
into a
OWLGraphWrapper
.org.semanticweb.owlapi.model.UnknownOWLOntologyException
- If an error occurred while wrapping
the OWLOntology
into a
OWLGraphWrapper
.public OWLGraphManipulator(OWLGraphWrapper owlGraphWrapper)
OWLGraphWrapper
wrapping the ontology on which modifications will be performed.owlGraphWrapper
- The OWLGraphWrapper
on which the operations
will be performed.org.semanticweb.owlapi.model.OWLOntologyCreationException
- If an error occurred while merging
the imported ontologies into the source
ontology.public void makeSimpleOntology()
simplifies
, by providing only
the object property IDs of the "part_of" and "develops_from" relations.public void simplifies(Collection<String> classIdsToRemove, Collection<String> relIds, Collection<String> toRemoveSubgraphRootIds, Collection<String> toFilterSubgraphRootIds, Collection<String> subsetNames)
removeClassAndPropagateEdges(String)
on each of the String
in classIdsToRemove
.
removeUnrelatedRelations(Collection)
using relIds
.
reduceRelations()
reducePartOfIsARelations()
mapRelationsToParent(Collection)
using relIds
.
filterRelations(Collection, boolean)
using relIds
and
true
as the second parameter.
removeSubgraphs(Collection, boolean)
using toRemoveSubgraphRootIds
and false
as the second parameter.
filterSubgraphs(Collection)
using toFilterSubgraphRootIds
.
removeRelsToSubsets(Collection, Collection)
using subsetNames
as first argument, and toFilterSubgraphRootIds
as second argument.
classIdsToRemove
- A Collection
of String
s to call
removeClassAndPropagateEdges(String)
relIds
- A Collection
of String
s to call
mapRelationsToParent(Collection)
and
#filterRelations(Collection, boolean)}.toRemoveSubgraphRootIds
- A Collection
of String
s to call
removeSubgraphs(Collection, boolean)
.
on each of them.toFilterSubgraphRootIds
- A Collection
of String
s to call
filterSubgraphs(Collection)
.subsetNames
- A Collection
of String
s to call
removeRelsToSubsets(Collection)
.public int reduceRelations()
When combining the relations, they are also combined over super properties (see
OWLGraphWrapperEdgesExtended.combineEdgePairWithSuperPropsAndGCI(
OWLGraphEdge, OWLGraphEdge)
)
Examples of relations considered redundant by this method:
Important: If it is planed to also call
filterRelations(Collection, boolean)
, and the ontology is very large,
it is recommended to first call removeUnrelatedRelations(Collection)
,
before calling this method.
int
representing the number of relations removed.reducePartOfIsARelations()
,
removeUnrelatedRelations(Collection)
public int reducePartOfIsARelations()
This method is similar to reduceRelations()
, except is_a and part_of
are considered equivalent, and that only these "fake" redundant relations are removed.
Warning: if you call both the methods reduceRelations
and reducePartOfIsARelations
on the same ontologies,
you must call reduceRelations
first,
as it is a semantically correct reduction.
Here are examples of relations considered redundant by this method:
reduceRelations()
.int
representing the number of relations removed.reduceRelations()
public int removeClassAndPropagateEdges(String classToRemoveId) throws IllegalArgumentException
OWLClass
with the OBO-style ID classToRemoveId
from the ontology, and propagate its incoming edges to the targets
of its outgoing edges. Each incoming edges are composed with each outgoing edges (see
OWLGraphWrapperEdgesExtended#combineEdgePairWithSuperPropsAnGCI(
OWLGraphEdge, OWLGraphEdge)
).
This method returns the number of relations propagated and actually added
to the ontology (propagated relations corresponding to a relation already
existing in the ontology, or a less precise relation than an already existing one,
will not be counted). It returns 0 only when no relations were propagated (or added).
Rather than returning 0 when the OWLClass
could not be found or removed,
an IllegalArgumentException
is thrown.
classToRemoveId
- A String
corresponding to the OBO-style ID
of the OWLClass
to remove.int
corresponding to the number of relations
that could be combined, and that were actually added
to the ontology.IllegalArgumentException
- If no OWLClass
corresponding to
classToRemoveId
could be found,
or if the class could not be removed. This is for the sake
of not returning 0 when such problems appear, but only
when no relations were propagated.public int mapRelationsToParent(Collection<String> parentRelations)
parentRelations
by these parent relations.
parentRelations
contains the OBO-style IDs of the parent relations
(for instance, "BFO:0000050"). All their sub-relations will be replaced by
these parent relations. If a relation in parentRelations
is the sub-relation
of another parent relation, it will not be mapped to this other parent relation,
and their common sub-relations will be mapped to the more precise one.
For instance, if parentRelations
contains "RO:0002202" ("develops_from" ID),
all sub-relations will be replaced: "transformation_of" relations will be replaced
by "develops_from", "immediate_transformation_of" will be replaced by "develops_from", ...
Note that if mapping a relation to its parent produces an already existing relation, the sub-relation will then be simply removed.
Important: If it is planed to also call reduceRelations()
,
this method must be called first, otherwise, already mapped relations could reappear
due to property chain rules.
parentRelations
- A Collection
of String
s containing
the OBO-style IDs of the parent relations, that should replace
all their sub-relations.int
that is the number of relations replaced
or removed.mapRelationsToParent(Collection, Collection)
public int mapRelationsToParent(Collection<String> parentRelations, Collection<String> relsExcluded)
mapRelationsToParent(Collection)
, except that this method
allows to filter relations not to be mapped to parents:
If a sub-relation of a relation in parentRelations
should not be mapped,
its OBO-style ID should be added to relsExcluded
. All sub-relations
of relsExcluded
are excluded from replacement.
Note that if mapping a relation to its parent produces an already existing relation, the sub-relation will then be simply removed.
Important: If it is planed to also call reduceRelations()
,
this method must be called first, otherwise, already mapped relations could reappear
due to property chain rules.
parentRelations
- A Collection
of String
s containing
the OBO-style IDs of the parent relations, that should replace
all their sub-relations, except those in relsExcluded
.relsExcluded
- A Collection
of String
s containing
the OBO-style IDs of the relations excluded from replacement.
All their sub-relations will be also be excluded.int
that is the number of relations replaced
or removed.mapRelationsToParent(Collection)
public Set<String> filterSubgraphs(Collection<String> allowedSubgraphRootIds)
OWLClass
es, and their ancestors.
allowedSubgraphRootIds
contains the OBO-style IDs
of these subgraph roots as String
s.
All classes not part of these subgraphs, and not ancestors of these allowed roots, will be removed from the ontology. Also, any direct relation between an ancestor of a subgraph root and one of its descendants will be removed, as this would represent an undesired subgraph.
This method returns the OBO-like IDs of the OWLClass
es removed as a result.
This is the opposite method of removeSubgraphs(Collection, boolean)
.
allowedSubgraphRootIds
- A Collection
of String
s
representing the OBO-style IDs of the
OWLClass
es that are the roots of the
subgraphs that will be kept in the ontology.
Their ancestors will be kept as well.Collection
of String
s that are
the OBO-like ID of the OWLClass
es removed
as a result of this method call.removeSubgraphs(Collection, boolean)
public Set<String> removeSubgraphs(Collection<String> subgraphRootIds, boolean keepSharedClasses)
removeSubgraphs(Collection, boolean, Collection)
,
with the last Collection
argument being null
.subgraphRootIds
- See removeSubgraphs(Collection, boolean, Collection)
.keepSharedClasses
- See removeSubgraphs(Collection, boolean, Collection)
.removeSubgraphs(Collection, boolean, Collection)
.removeSubgraphs(Collection, boolean, Collection)
public Set<String> removeSubgraphs(Collection<String> subgraphRootIds, boolean keepSharedClasses, Collection<String> allowedSubgraphRootIds)
OWLClass
es with their ID in subgraphRootIds
.
The subgraph starting from the OWLClass
es with their ID
in allowedSubgraphRootIds
will not be removed, even if part of
subgraph to remove. subgraphRootIds
and allowedSubgraphRootIds
contain the OBO-style IDs of OWLClass
es.
If a class is part of a subgraph to remove, but also of a subgraph not to be removed,
it will be kept in the ontology if keepSharedClasses
is true
,
and only classes that are solely part of the subgraphs to remove
will be deleted. If keepSharedClasses
is false
,
all classes part of a subgraph to remove will be removed.
This method returns the number of OWLClass
es removed as a result.
This is the opposite method of filterSubgraphs(Collection<String>)
.
subgraphRootIds
- A Collection
of String
s
representing the OBO-style IDs of the OWLClass
es
that are the roots of the subgraphs to be removed.keepSharedClasses
- A boolean
defining whether classes part both of
a subgraph to remove and a subgraph not to be removed,
should be deleted. If true
, they will be kept,
otherwise, they will be deleted.allowedSubgraphRootIds
- A Collection
of String
s
representing the OBO-style IDs of the
OWLClass
es that are the roots of the
subgraphs that are excluded from removal.Collection
of String
s that are
the OBO-like ID of the OWLClass
es removed.filterSubgraphs(Collection)
public int filterRelations(Collection<String> allowedRels, boolean allowSubRels)
OWLAxiom
s in the ontologies to keep only
those that correspond to OWLObjectProperty
s listed in allowedRels
,
as OBO-style IDs. is_a
relations
will not be removed, whatever the content of allowedRels
.
If allowSubRels
is true
, then the relations
that are subproperties of the allowed relations are also kept
(e.g., if RO:0002131 "overlaps" is allowed, and allowSubRels
is true
, then RO:0002151 "partially_overlaps" is also allowed).
This method is similar to the Mooncat#retainAxiomsInPropertySubset
method, the differences lie only in
the options of these methods, and the way sub-properties are retrieved
(via a reasonner in Mooncat
, via OWLGraphWrapper
in this method).
Also, the Mooncat
method try to replace a OWLObjectProperty
to remove, by an allowed super-property, while here, users should use
mapRelationsToParent(Collection)
.
Important: If it is planed to also call reduceRelations()
,
and the ontology is very large, it is recommended to first call
removeUnrelatedRelations(Collection)
, before calling reduceRelations()
.
allowedRels
- A Collection
of String
s
representing the OBO-style IDs of the relations
to keep in the ontology, e.g. "BFO:0000050".allowSubRels
- A boolean
defining whether sub-relations
of the allowed relations should also be kept.int
representing the number of OWLSubClassOfAxiom
s
removed as a result (but other axioms are removed as well).IllegalArgumentException
- If an ID in rels
did not allow to identify
an OWLObjectProperty
.removeRelations(Collection, boolean)
,
removeUnrelatedRelations(Collection)
public void removeUnrelatedRelations(Collection<String> allowedRels)
OWLOntologies
wrapped by this object
the OWLObjectProperty
s not related to the provided allowedRels
.
This method is useful to mirror the method
filterRelations(Collection, boolean)
, to remove all completely unrelated relations
before calling reduceRelations()
. This is because relation reduction
can be slow for large ontologies, but we cannot simply call the method
filterRelations
before the reduction, as a composed relation
could for instance lead to an allowed relation; so we do not want to remove
the relations used for composition before relation reduction, but we do want
to remove relations that cannot lead to an allowed relation.
The OWLOntology
s wrapped by this object will be modified as a result
of the call to this method.
allowedRels
- A Collection
of String
s
representing the OBO-like IDs of the relations
to keep in the ontology, e.g. "BFO:0000050".reduceRelations()
,
filterRelations(Collection, boolean)
public int removeRelations(Collection<String> forbiddenRels, boolean forbidSubRels)
OWLAxiom
s in the ontologies
corresponding to the OWLObjectProperty
s listed in forbiddenRels
,
as OBO-style IDs. is_a
relations
will not be removed, whatever the content of forbiddenRels
.
If forbidSubRels
is true
, then the relations
that are subproperties of the relations to remove are also removed
(e.g., if RO:0002131 "overlaps" should be removed, and forbidSubRels
is true
, then RO:0002151 "partially_overlaps" is also removed).
This method is the inverse of the Mooncat#retainAxiomsInPropertySubset
method, the differences lie also in
the options of these methods, and the way sub-properties are retrieved
(via a reasonner in Mooncat
, via OWLGraphWrapper
in this method).
Also, the Mooncat
method try to replace a OWLObjectProperty
to remove, by an allowed super-property, while here, users should use
mapRelationsToParent(Collection)
.
Important: If it is planed to also call reduceRelations()
,
this method must be called first, otherwise, already removed relations could reappear
due to property chain rules.
forbiddenRels
- A Collection
of String
s
representing the OBO-style IDs of the relations
to remove from the ontology, e.g. "BFO:0000050".forbidSubRels
- A boolean
defining whether sub-relations
of the relations to remove should also be removed.int
representing the number of OWLSubClassOfAxiom
s
removed as a result (but other axioms are removed as well).IllegalArgumentException
- If an ID in rels
did not allow to identify
an OWLObjectProperty
.filterRelations(Collection, boolean)
public int removeRelsToSubsets(Collection<String> subsets)
removeRelsToSubsets(Collection, Collection)
,
with no OWLClass
es excluded specified.subsets
- See same name argument in
removeRelsToSubsets(Collection, Collection)
.removeRelsToSubsets(Collection, Collection)
.removeRelsToSubsets(Collection, Collection)
public int removeRelsToSubsets(Collection<String> subsets, Collection<String> classIdsExcluded)
OWLClass
es
in subsets
, only if the source of the incoming edge
will not be left orphan of other is_a/part_of relations to OWLClass
es
not in subsets
. OWLClass
es with their OBO-like ID or IRI
in classIdsExcluded
will be excluded from this mechanism, even if
they are part of a targeted subset (meaning, none of their incoming edges will be
removed)
Warning: please note that the resulting ontology will not be
semantically correct. It is the same kind of modifications made by
reducePartOfIsARelations()
, considering is_a (SubClassOf)
and part_of relations (or sub-relations, for instance, "in_deep_part_of") equivalent,
and that result in a simplified graph structure for display, but an incorrect ontology.
For instance:
subsets
- A Collection
of String
s representing
the names of the targeted subsets, for which
member OWLClass
es should have their is_a/part_of
incoming edges removed.classIdsExcluded
- A Collection
of String
s that are the OBO-like
IDs or IRIs of OWLClass
es, whose their incoming edges
should not be removed.int
that is the number of is_a/part_of
relations (or sub-relations) removed.public int removeDirectEdgesBetween(String sourceId, String targetId)
OWLObject
s with the OBO-like IDs
sourceId
and targetId
.sourceId
- A String
that is the OBO-like ID of the OWLObject
whose edges to remove outgoing from.targetId
- A String
that is the OBO-like ID of the OWLObject
whose edges to remove incoming to.int
that is the number of OWLGraphEdge
s
removed as a result.public boolean removeEdge(OWLGraphEdge edge)
edge
from its ontology. It means that the OWLAxiom
s
returned by the method OWLGraphEdge#getAxioms()
, that allowed to generate
edge
, will be removed from the ontology.edge
- The OWLGraphEdge
to be removed from the ontology.true
if all underlying OWLAxiom
s of edge
were actually present in its ontology, and removed.removeEdges(Collection)
public int removeEdges(Collection<OWLGraphEdge> edges)
edges
from their related ontology. It means that the OWLAxiom
s
returned by the method OWLGraphEdge#getAxioms()
, that allowed to generate
the OWLGraphEdge
s, will be removed from the ontology.edges
- A Collection
of OWLGraphEdge
s
to be removed from their ontology.int
representing the number of OWLGraphEdge
s
that were actually removedremoveEdge(OWLGraphEdge)
public boolean addEdge(OWLGraphEdge edge)
edge
to its related ontology.
This method transforms the OWLGraphEdge
edge
into an OWLSubClassOfAxiom
, then add it to the ontology
and update the OWLGraphWrapper
container.edge
- The OWLGraphEdge
to be added to its related ontology.true
if edge
was actually added
to the ontology.public int addEdges(Set<OWLGraphEdge> edges)
edges
to their related ontology.
This method transforms the OWLGraphEdge
s in edge
s
into OWLSubClassOfAxiom
s, then add them to the ontology,
and update the OWLGraphWrapper
container.edges
- A Set
of OWLGraphEdge
s
to be added to their ontology.int
representing the number of OWLGraphEdge
s
that were actually addedaddEdge(OWLGraphEdge)
public boolean removeClass(org.semanticweb.owlapi.model.OWLClass classToDel)
OWLClass
classToDel
,
and then update the OWLGraphWrapper
container.classToDel
- an OWLClass
to be removed
from the ontologies.true
if classToDel
was actually
removed from the ontology.public Set<org.semanticweb.owlapi.model.OWLClass> removeClasses(Set<org.semanticweb.owlapi.model.OWLClass> classesToDel)
OWLClass
es
present in classesToDel
,
and then update the OWLGraphWrapper
container.classesToDel
- a Set
of OWLClass
es
to be removed from the ontologies.Set
of OWLClass
es representing the classes
actually removed as a result.public Set<org.semanticweb.owlapi.model.OWLClass> filterClasses(Set<org.semanticweb.owlapi.model.OWLClass> classesToKeep)
OWLClass
es
present in classesToKeep
,
and then update the OWLGraphWrapper
container.classesToKeep
- a Set
of OWLClass
s
that are classes to be kept in the ontology.Set
of OWLClass
es representing the classes
actually removed as a result.public boolean isASubClassOfEdge(OWLGraphEdge edge)
edge
represents an is_a relation.edge
- The OWLGraphEdge
to test.true
if edge
is an is_a (SubClassOf) relation.public boolean isAPartOfEdge(OWLGraphEdge edge)
edge
represents a part_of relation or one of its sub-relations
(e.g., "deep_part_of").edge
- The OWLGraphEdge
to test.true
if edge
is a part_of relation,
or one of its sub-relations.public OWLGraphWrapper getOwlGraphWrapper()
OWLGraphWrapper
on which modifications
are performed.OWLGraphWrapper
wrapped by this class.Copyright © 2010–2015. All rights reserved.