ElkObjectFactory (ELK OWL Object Interfaces 0.4.2 API)

```
public interface ElkObjectFactory
```
Interface that provides methods for creating instances of ElkObjects.

Author:

Markus Kroetzsch, "Yevgeny Kazakov"

Method Summary

Methods
Modifier and Type	Method and Description
`ElkAnnotation`	`getAnnotation(ElkAnnotationProperty property, ElkAnnotationValue value)` Create an `ElkAnnotation`
`ElkAnnotationAssertionAxiom`	`getAnnotationAssertionAxiom(ElkAnnotationProperty property, ElkAnnotationSubject subject, ElkAnnotationValue value)` Create an `ElkAnnotationAssertionAxiom`
`ElkAnnotationProperty`	`getAnnotationProperty(ElkIri iri)` Create an `ElkAnnotationProperty`.
`ElkAnnotationPropertyDomainAxiom`	`getAnnotationPropertyDomainAxiom(ElkAnnotationProperty property, ElkIri domain)` Create an `ElkAnnotationPropertyDomainAxiom`
`ElkAnnotationPropertyRangeAxiom`	`getAnnotationPropertyRangeAxiom(ElkAnnotationProperty property, ElkIri range)` Create an `ElkAnnotationPropertyRangeAxiom`
`ElkAnonymousIndividual`	`getAnonymousIndividual(String nodeId)` Create an `ElkAnonymousIndividual`.
`ElkAsymmetricObjectPropertyAxiom`	`getAsymmetricObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkAsymmetricObjectPropertyAxiom`.
`ElkClass`	`getClass(ElkIri iri)` Create an `ElkClass`.
`ElkClassAssertionAxiom`	`getClassAssertionAxiom(ElkClassExpression classExpression, ElkIndividual individual)` Create an `ElkClassAssertionAxiom`.
`ElkDataAllValuesFrom`	`getDataAllValuesFrom(ElkDataRange dataRange, ElkDataPropertyExpression dpe1, ElkDataPropertyExpression... dpe)` Create an `ElkDataAllValuesFrom`.
`ElkDataAllValuesFrom`	`getDataAllValuesFrom(ElkDataRange dataRange, List<? extends ElkDataPropertyExpression> dpList)` Create an `ElkDataAllValuesFrom`.
`ElkDataComplementOf`	`getDataComplementOf(ElkDataRange dataRange)` Create an `ElkDataComplementOf`.
`ElkDataExactCardinality`	`getDataExactCardinality(ElkDataPropertyExpression dataPropertyExpression, int cardinality)` Create an `ElkDataExactCardinality`.
`ElkDataExactCardinalityQualified`	`getDataExactCardinalityQualified(ElkDataPropertyExpression dataPropertyExpression, int cardinality, ElkDataRange dataRange)` Create an `ElkDataExactCardinalityQualified`.
`ElkDataHasValue`	`getDataHasValue(ElkDataPropertyExpression dataPropertyExpression, ElkLiteral literal)` Create an `ElkDataHasValue`.
`ElkDataIntersectionOf`	`getDataIntersectionOf(ElkDataRange firstDataRange, ElkDataRange secondDataRange, ElkDataRange... otherDataRanges)` Create an `ElkDataIntersectionOf`.
`ElkDataIntersectionOf`	`getDataIntersectionOf(List<? extends ElkDataRange> dataRanges)` Create an `ElkDataIntersectionOf`.
`ElkDataMaxCardinality`	`getDataMaxCardinality(ElkDataPropertyExpression dataPropertyExpression, int cardinality)` Create an `ElkDataMaxCardinality`.
`ElkDataMaxCardinalityQualified`	`getDataMaxCardinalityQualified(ElkDataPropertyExpression dataPropertyExpression, int cardinality, ElkDataRange dataRange)` Create an `ElkDataMaxCardinalityQualified`.
`ElkDataMinCardinality`	`getDataMinCardinality(ElkDataPropertyExpression dataPropertyExpression, int cardinality)` Create an `ElkDataMinCardinality`.
`ElkDataMinCardinalityQualified`	`getDataMinCardinalityQualified(ElkDataPropertyExpression dataPropertyExpression, int cardinality, ElkDataRange dataRange)` Create an `ElkDataMinCardinalityQualified`.
`ElkDataOneOf`	`getDataOneOf(ElkLiteral firstLiteral, ElkLiteral... otherLiterals)` Create an `ElkDataOneOf`.
`ElkDataOneOf`	`getDataOneOf(List<? extends ElkLiteral> literals)` Create an `ElkDataOneOf`.
`ElkDataProperty`	`getDataProperty(ElkIri iri)` Create an `ElkDataProperty`.
`ElkDataPropertyAssertionAxiom`	`getDataPropertyAssertionAxiom(ElkDataPropertyExpression dataPropertyExpression, ElkIndividual individual, ElkLiteral literal)` Create an `ElkDataPropertyAssertionAxiom`.
`ElkDataPropertyDomainAxiom`	`getDataPropertyDomainAxiom(ElkDataPropertyExpression dataPropertyExpression, ElkClassExpression classExpression)` Create an `ElkDataPropertyDomainAxiom`.
`ElkDataPropertyRangeAxiom`	`getDataPropertyRangeAxiom(ElkDataPropertyExpression dataPropertyExpression, ElkDataRange dataRange)` Create an `ElkDataPropertyRangeAxiom`.
`ElkDataSomeValuesFrom`	`getDataSomeValuesFrom(ElkDataRange dataRange, ElkDataPropertyExpression firstDataPropertyExpression, ElkDataPropertyExpression... otherDataPropertyExpressions)` Create an `ElkDataSomeValuesFrom`
`ElkDataSomeValuesFrom`	`getDataSomeValuesFrom(ElkDataRange dataRange, List<? extends ElkDataPropertyExpression> dpList)` Create an `ElkDataSomeValuesFrom`
`ElkDatatype`	`getDatatype(ElkIri iri)` Create an `ElkDatatype`.
`ElkDatatypeDefinitionAxiom`	`getDatatypeDefinitionAxiom(ElkDatatype datatype, ElkDataRange dataRange)` Create an `ElkDatatypeDefinitionAxiom`
`ElkDatatype`	`getDatatypeRdfPlainLiteral()` Create the ElkDatatype for rdf:PlainLiteral}.
`ElkDatatypeRestriction`	`getDatatypeRestriction(ElkDatatype datatype, List<ElkFacetRestriction> facetRestrictions)` Create an `ElkDatatypeRestriction`.
`ElkDataUnionOf`	`getDataUnionOf(ElkDataRange firstDataRange, ElkDataRange secondDataRange, ElkDataRange... otherDataRanges)` Create an `ElkDataUnionOf`.
`ElkDataUnionOf`	`getDataUnionOf(List<? extends ElkDataRange> dataRanges)` Create an `ElkDataUnionOf`.
`ElkDeclarationAxiom`	`getDeclarationAxiom(ElkEntity entity)` Create an `ElkDeclarationAxiom`.
`ElkDifferentIndividualsAxiom`	`getDifferentIndividualsAxiom(ElkIndividual firstIndividual, ElkIndividual secondIndividual, ElkIndividual... otherIndividuals)` Create an `ElkDifferentIndividualsAxiom`.
`ElkDifferentIndividualsAxiom`	`getDifferentIndividualsAxiom(List<? extends ElkIndividual> individuals)` Create an `ElkDifferentIndividualsAxiom`.
`ElkDisjointClassesAxiom`	`getDisjointClassesAxiom(ElkClassExpression firstClassExpression, ElkClassExpression secondClassExpression, ElkClassExpression... otherClassExpressions)` Create an `ElkDisjointClassesAxiom`.
`ElkDisjointClassesAxiom`	`getDisjointClassesAxiom(List<? extends ElkClassExpression> disjointClassExpressions)` Create an `ElkDisjointClassesAxiom`.
`ElkDisjointDataPropertiesAxiom`	`getDisjointDataPropertiesAxiom(ElkDataPropertyExpression firstDataPropertyExpression, ElkDataPropertyExpression secondDataPropertyExpression, ElkDataPropertyExpression... otherDataPropertyExpressions)` Create an `ElkDisjointDataPropertiesAxiom`.
`ElkDisjointDataPropertiesAxiom`	`getDisjointDataPropertiesAxiom(List<? extends ElkDataPropertyExpression> disjointDataPropertyExpressions)` Create an `ElkDisjointDataPropertiesAxiom`.
`ElkDisjointObjectPropertiesAxiom`	`getDisjointObjectPropertiesAxiom(ElkObjectPropertyExpression firstObjectPropertyExpression, ElkObjectPropertyExpression secondObjectPropertyExpression, ElkObjectPropertyExpression... otherObjectPropertyExpressions)` Create an `ElkDisjointObjectPropertiesAxiom`.
`ElkDisjointObjectPropertiesAxiom`	`getDisjointObjectPropertiesAxiom(List<? extends ElkObjectPropertyExpression> disjointObjectPropertyExpressions)` Create an `ElkDisjointObjectPropertiesAxiom`.
`ElkDisjointUnionAxiom`	`getDisjointUnionAxiom(ElkClass definedClass, ElkClassExpression firstClassExpression, ElkClassExpression secondClassExpression, ElkClassExpression... otherClassExpressions)` Create an `ElkDisjointUnionAxiom`.
`ElkDisjointUnionAxiom`	`getDisjointUnionAxiom(ElkClass definedClass, List<? extends ElkClassExpression> disjointClassExpressions)` Create an `ElkDisjointUnionAxiom`.
`ElkEquivalentClassesAxiom`	`getEquivalentClassesAxiom(ElkClassExpression firstClassExpression, ElkClassExpression secondClassExpression, ElkClassExpression... otherClassExpressions)` Create an `ElkEquivalentClassesAxiom`.
`ElkEquivalentClassesAxiom`	`getEquivalentClassesAxiom(List<? extends ElkClassExpression> equivalentClassExpressions)` Create an `ElkEquivalentClassesAxiom`.
`ElkEquivalentDataPropertiesAxiom`	`getEquivalentDataPropertiesAxiom(ElkDataPropertyExpression firstDataPropertyExpression, ElkDataPropertyExpression secondDataPropertyExpression, ElkDataPropertyExpression... otherDataPropertyExpressions)` Create an `ElkEquivalentDataPropertiesAxiom`.
`ElkEquivalentDataPropertiesAxiom`	`getEquivalentDataPropertiesAxiom(List<? extends ElkDataPropertyExpression> equivalentDataPropertyExpressions)` Create an `ElkEquivalentDataPropertiesAxiom`.
`ElkEquivalentObjectPropertiesAxiom`	`getEquivalentObjectPropertiesAxiom(ElkObjectPropertyExpression firstObjectPropertyExpression, ElkObjectPropertyExpression secondObjectPropertyExpression, ElkObjectPropertyExpression... otherObjectPropertyExpressions)` Create an `ElkEquivalentObjectPropertiesAxiom`.
`ElkEquivalentObjectPropertiesAxiom`	`getEquivalentObjectPropertiesAxiom(List<? extends ElkObjectPropertyExpression> equivalentObjectPropertyExpressions)` Create an `ElkEquivalentObjectPropertiesAxiom`.
`ElkFacetRestriction`	`getFacetRestriction(ElkIri iri, ElkLiteral literal)` Create an `ElkFacetRestriction`
`ElkFunctionalDataPropertyAxiom`	`getFunctionalDataPropertyAxiom(ElkDataPropertyExpression dataPropertyExpression)` Create an `ElkFunctionalDataPropertyAxiom`.
`ElkFunctionalObjectPropertyAxiom`	`getFunctionalObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkFunctionalObjectPropertyAxiom`.
`ElkHasKeyAxiom`	`getHasKeyAxiom(ElkClassExpression classExpr, Set<ElkObjectPropertyExpression> objectPEs, Set<ElkDataPropertyExpression> dataPEs)` Create an `ElkHasKeyAxiom`
`ElkInverseFunctionalObjectPropertyAxiom`	`getInverseFunctionalObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkInverseFunctionalObjectPropertyAxiom`.
`ElkInverseObjectPropertiesAxiom`	`getInverseObjectPropertiesAxiom(ElkObjectPropertyExpression firstObjectPropertyExpression, ElkObjectPropertyExpression secondObjectPropertyExpression)` Create an `ElkInverseObjectPropertiesAxiom`.
`ElkIrreflexiveObjectPropertyAxiom`	`getIrreflexiveObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkIrreflexiveObjectPropertyAxiom`.
`ElkLiteral`	`getLiteral(String lexicalForm, ElkDatatype datatype)` Create an `ElkLiteral`.
`ElkNamedIndividual`	`getNamedIndividual(ElkIri iri)` Create an `ElkNamedIndividual`.
`ElkNegativeDataPropertyAssertionAxiom`	`getNegativeDataPropertyAssertionAxiom(ElkDataPropertyExpression dataPropertyExpression, ElkIndividual individual, ElkLiteral literal)` Create an `ElkNegativeDataPropertyAssertionAxiom`.
`ElkNegativeObjectPropertyAssertionAxiom`	`getNegativeObjectPropertyAssertionAxiom(ElkObjectPropertyExpression objectPropertyExpression, ElkIndividual firstIndividual, ElkIndividual secondIndividual)` Create an `ElkNegativeObjectPropertyAssertionAxiom`.
`ElkObjectAllValuesFrom`	`getObjectAllValuesFrom(ElkObjectPropertyExpression objectPropertyExpression, ElkClassExpression classExpression)` Create an `ElkObjectAllValuesFrom`.
`ElkObjectComplementOf`	`getObjectComplementOf(ElkClassExpression classExpression)` Create an `ElkObjectComplementOf`.
`ElkObjectExactCardinality`	`getObjectExactCardinality(ElkObjectPropertyExpression objectPropertyExpression, int cardinality)` Create an `ElkObjectExactCardinality`.
`ElkObjectExactCardinalityQualified`	`getObjectExactCardinalityQualified(ElkObjectPropertyExpression objectPropertyExpression, int cardinality, ElkClassExpression classExpression)` Create an `ElkObjectExactCardinalityQualified`.
`ElkObjectHasSelf`	`getObjectHasSelf(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkObjectHasSelf`.
`ElkObjectHasValue`	`getObjectHasValue(ElkObjectPropertyExpression objectPropertyExpression, ElkIndividual individual)` Create an `ElkObjectHasValue`.
`ElkObjectIntersectionOf`	`getObjectIntersectionOf(ElkClassExpression firstClassExpression, ElkClassExpression secondClassExpression, ElkClassExpression... otherClassExpressions)` Create an `ElkObjectIntersectionOf`.
`ElkObjectIntersectionOf`	`getObjectIntersectionOf(List<? extends ElkClassExpression> classExpressions)` Create an `ElkObjectIntersectionOf`.
`ElkObjectInverseOf`	`getObjectInverseOf(ElkObjectProperty objectProperty)` Create an `ElkObjectInverseOf`.
`ElkObjectMaxCardinality`	`getObjectMaxCardinality(ElkObjectPropertyExpression objectPropertyExpression, int cardinality)` Create an `ElkObjectMaxCardinality`.
`ElkObjectMaxCardinalityQualified`	`getObjectMaxCardinalityQualified(ElkObjectPropertyExpression objectPropertyExpression, int cardinality, ElkClassExpression classExpression)` Create an `ElkObjectMaxCardinalityQualified`.
`ElkObjectMinCardinality`	`getObjectMinCardinality(ElkObjectPropertyExpression objectPropertyExpression, int cardinality)` Create an `ElkObjectMinCardinality`.
`ElkObjectMinCardinalityQualified`	`getObjectMinCardinalityQualified(ElkObjectPropertyExpression objectPropertyExpression, int cardinality, ElkClassExpression classExpression)` Create an `ElkObjectMinCardinalityQualified`.
`ElkObjectOneOf`	`getObjectOneOf(ElkIndividual firstIndividual, ElkIndividual... otherIndividuals)` Create an `ElkObjectOneOf`.
`ElkObjectOneOf`	`getObjectOneOf(List<? extends ElkIndividual> individuals)` Create an `ElkObjectOneOf`.
`ElkObjectProperty`	`getObjectProperty(ElkIri iri)` Create an `ElkObjectProperty`.
`ElkObjectPropertyAssertionAxiom`	`getObjectPropertyAssertionAxiom(ElkObjectPropertyExpression objectPropertyExpression, ElkIndividual firstIndividual, ElkIndividual secondIndividual)` Create an `ElkObjectPropertyAssertionAxiom`.
`ElkObjectPropertyChain`	`getObjectPropertyChain(List<? extends ElkObjectPropertyExpression> objectPropertyExpressions)` Create an `ElkObjectPropertyChain`.
`ElkObjectPropertyDomainAxiom`	`getObjectPropertyDomainAxiom(ElkObjectPropertyExpression objectPropertyExpression, ElkClassExpression classExpression)` Create an `ElkObjectPropertyDomainAxiom`.
`ElkObjectPropertyRangeAxiom`	`getObjectPropertyRangeAxiom(ElkObjectPropertyExpression objectPropertyExpression, ElkClassExpression classExpression)` Create an `ElkObjectPropertyRangeAxiom`.
`ElkObjectSomeValuesFrom`	`getObjectSomeValuesFrom(ElkObjectPropertyExpression objectPropertyExpression, ElkClassExpression classExpression)` Create an `ElkObjectSomeValuesFrom`.
`ElkObjectUnionOf`	`getObjectUnionOf(ElkClassExpression firstClassExpression, ElkClassExpression secondClassExpression, ElkClassExpression... otherClassExpressions)` Create an `ElkObjectUnionOf`.
`ElkObjectUnionOf`	`getObjectUnionOf(List<? extends ElkClassExpression> classExpressions)` Create an `ElkObjectUnionOf`.
`ElkDataProperty`	`getOwlBottomDataProperty()` Create the `ElkDataProperty` representing owl:BottomDataProperty}.
`ElkObjectProperty`	`getOwlBottomObjectProperty()` Create the `ElkObjectProperty` representing owl:BottomObjectProperty}.
`ElkClass`	`getOwlNothing()` Create the `ElkClass` representing `owl:Nothing`.
`ElkClass`	`getOwlThing()` Create the `ElkClass` representing `owl:Thing`.
`ElkDataProperty`	`getOwlTopDataProperty()` Create the `ElkDataProperty` representing `owl:TopDataProperty`.
`ElkObjectProperty`	`getOwlTopObjectProperty()` Create the `ElkObjectProperty` representing `owl:TopObjectProperty`.
`ElkReflexiveObjectPropertyAxiom`	`getReflexiveObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkReflexiveObjectPropertyAxiom`.
`ElkSameIndividualAxiom`	`getSameIndividualAxiom(ElkIndividual firstIndividual, ElkIndividual secondIndividual, ElkIndividual... otherIndividuals)` Create an `ElkSameIndividualAxiom`.
`ElkSameIndividualAxiom`	`getSameIndividualAxiom(List<? extends ElkIndividual> individuals)` Create an `ElkSameIndividualAxiom`.
`ElkSubAnnotationPropertyOfAxiom`	`getSubAnnotationPropertyOfAxiom(ElkAnnotationProperty subAnnotationProperty, ElkAnnotationProperty superAnnotationProperty)` Create an `ElkSubAnnotationPropertyOfAxiom`
`ElkSubClassOfAxiom`	`getSubClassOfAxiom(ElkClassExpression subClassExpression, ElkClassExpression superClassExpression)` Create an `ElkSubClassOfAxiom`.
`ElkSubDataPropertyOfAxiom`	`getSubDataPropertyOfAxiom(ElkDataPropertyExpression subDataPropertyExpression, ElkDataPropertyExpression superDataPropertyExpression)` Create an `ElkSubDataPropertyOfAxiom`.
`ElkSubObjectPropertyOfAxiom`	`getSubObjectPropertyOfAxiom(ElkSubObjectPropertyExpression subObjectPropertyExpression, ElkObjectPropertyExpression superObjectPropertyExpression)` Create an `ElkSubObjectPropertyOfAxiom`.
`ElkSWRLRule`	`getSWRLRule()` No arguments since we don't have a full representation of SWRL rules
`ElkSymmetricObjectPropertyAxiom`	`getSymmetricObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkSymmetricObjectPropertyAxiom`.
`ElkTransitiveObjectPropertyAxiom`	`getTransitiveObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)` Create an `ElkTransitiveObjectPropertyAxiom`.

- Method Detail
  - getAnnotation
```
ElkAnnotation getAnnotation(ElkAnnotationProperty property,
                          ElkAnnotationValue value)
```
    Create an ElkAnnotation
    
    Parameters:
    property - the ElkAnnotationProperty for which the object should be created
    value - the ElkAnnotationValue for which the object should be created
    
    Returns:
    an ElkAnnotation corresponding to the input
  - getAnnotationProperty
```
ElkAnnotationProperty getAnnotationProperty(ElkIri iri)
```
    Create an ElkAnnotationProperty.
    
    Parameters:
    iri - the ElkIri for which the object should be created
    
    Returns:
    an ElkAnnotation corresponding to the input
  - getAnnotationAssertionAxiom
```
ElkAnnotationAssertionAxiom getAnnotationAssertionAxiom(ElkAnnotationProperty property,
                                                      ElkAnnotationSubject subject,
                                                      ElkAnnotationValue value)
```
    Create an ElkAnnotationAssertionAxiom
    
    Parameters:
    property - the ElkAnnotationProperty for which the axiom should be created
    subject - the ElkAnnotationSubject for which the axiom should be created
    value - the ElkAnnotationValue for which the axiom should be created
    
    Returns:
    an ElkAnnotationAssertionAxiom corresponding to the input
  - getAnnotationPropertyDomainAxiom
```
ElkAnnotationPropertyDomainAxiom getAnnotationPropertyDomainAxiom(ElkAnnotationProperty property,
                                                                ElkIri domain)
```
    Create an ElkAnnotationPropertyDomainAxiom
    
    Parameters:
    property - the ElkAnnotationProperty for which the axiom should be created
    domain - the ElkIri for which the axiom should be created
    
    Returns:
    an ElkAnnotationPropertyDomainAxiom corresponding to the input
  - getAnnotationPropertyRangeAxiom
```
ElkAnnotationPropertyRangeAxiom getAnnotationPropertyRangeAxiom(ElkAnnotationProperty property,
                                                              ElkIri range)
```
    Create an ElkAnnotationPropertyRangeAxiom
    
    Parameters:
    property - the ElkAnnotationProperty for which the axiom should be created
    range - the ElkIri for which the object axiom be created
    
    Returns:
    an ElkAnnotationPropertyRangeAxiom corresponding to the input
  - getAnonymousIndividual
```
ElkAnonymousIndividual getAnonymousIndividual(String nodeId)
```
    Create an ElkAnonymousIndividual.
    
    Parameters:
    nodeId - the String for which the object should be created
    
    Returns:
    an ElkAnonymousIndividual corresponding to the input
  - getAsymmetricObjectPropertyAxiom
```
ElkAsymmetricObjectPropertyAxiom getAsymmetricObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkAsymmetricObjectPropertyAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkAsymmetricObjectPropertyAxiom corresponding to the input
  - getClass
```
ElkClass getClass(ElkIri iri)
```
    Create an ElkClass.
    
    Parameters:
    iri - the ElkIri for which the object should be created
    
    Returns:
    an ElkClass corresponding to the input
  - getClassAssertionAxiom
```
ElkClassAssertionAxiom getClassAssertionAxiom(ElkClassExpression classExpression,
                                            ElkIndividual individual)
```
    Create an ElkClassAssertionAxiom.
    
    Parameters:
    classExpression - the ElkClassExpression for which the axiom should be created
    individual - the ElkIndividual for which the axiom should be created
    
    Returns:
    an ElkClassAssertionAxiom corresponding to the input
  - getDataAllValuesFrom
```
ElkDataAllValuesFrom getDataAllValuesFrom(ElkDataRange dataRange,
                                        ElkDataPropertyExpression dpe1,
                                        ElkDataPropertyExpression... dpe)
```
    Create an ElkDataAllValuesFrom.
    
    Parameters:
    dataRange - the ElkDataRange for which the object should be created
    dpe1 - the ElkDataPropertyExpression for which the object should be created
    dpe - the ElkDataPropertyExpressions for which the object should be created
    
    Returns:
    an ElkDataAllValuesFrom corresponding to the input
  - getDataAllValuesFrom
```
ElkDataAllValuesFrom getDataAllValuesFrom(ElkDataRange dataRange,
                                        List<? extends ElkDataPropertyExpression> dpList)
```
    Create an ElkDataAllValuesFrom.
    
    Parameters:
    dataRange - the ElkDataRange for which the object should be created
    dpList - the ElkDataPropertyExpressions for which the object should be created
    
    Returns:
    an ElkDataAllValuesFrom corresponding to the input
  - getDataComplementOf
```
ElkDataComplementOf getDataComplementOf(ElkDataRange dataRange)
```
    Create an ElkDataComplementOf.
    
    Parameters:
    dataRange - the ElkDataRange for which the object should be created
    
    Returns:
    an ElkDataComplementOf corresponding to the input
  - getDataExactCardinality
```
ElkDataExactCardinality getDataExactCardinality(ElkDataPropertyExpression dataPropertyExpression,
                                              int cardinality)
```
    Create an ElkDataExactCardinality.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    
    Returns:
    an ElkDataExactCardinality corresponding to the input
  - getDataExactCardinalityQualified
```
ElkDataExactCardinalityQualified getDataExactCardinalityQualified(ElkDataPropertyExpression dataPropertyExpression,
                                                                int cardinality,
                                                                ElkDataRange dataRange)
```
    Create an ElkDataExactCardinalityQualified.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    dataRange - the ElkDataRange for which the object should be created
    
    Returns:
    an ElkDataExactCardinalityQualified corresponding to the input
  - getDataHasValue
```
ElkDataHasValue getDataHasValue(ElkDataPropertyExpression dataPropertyExpression,
                              ElkLiteral literal)
```
    Create an ElkDataHasValue.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    literal - the ElkLiteral for which the object should be created
    
    Returns:
    an ElkDataHasValue corresponding to the input
  - getDataIntersectionOf
```
ElkDataIntersectionOf getDataIntersectionOf(ElkDataRange firstDataRange,
                                          ElkDataRange secondDataRange,
                                          ElkDataRange... otherDataRanges)
```
    Create an ElkDataIntersectionOf.
    
    Parameters:
    firstDataRange - the first ElkDataRange for which the object should be created
    secondDataRange - the second ElkDataRange for which the object should be created
    otherDataRanges - the ElkDataRange for which the object should be created
    
    Returns:
    an ElkDataIntersectionOf corresponding to the input
  - getDataIntersectionOf
```
ElkDataIntersectionOf getDataIntersectionOf(List<? extends ElkDataRange> dataRanges)
```
    Create an ElkDataIntersectionOf.
    
    Parameters:
    dataRanges - the ElkDataRanges for which the object should be created
    
    Returns:
    an ElkDataIntersectionOf corresponding to the input
  - getDataMaxCardinality
```
ElkDataMaxCardinality getDataMaxCardinality(ElkDataPropertyExpression dataPropertyExpression,
                                          int cardinality)
```
    Create an ElkDataMaxCardinality.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    
    Returns:
    an ElkDataMaxCardinality corresponding to the input
  - getDataMaxCardinalityQualified
```
ElkDataMaxCardinalityQualified getDataMaxCardinalityQualified(ElkDataPropertyExpression dataPropertyExpression,
                                                            int cardinality,
                                                            ElkDataRange dataRange)
```
    Create an ElkDataMaxCardinalityQualified.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    dataRange - the ElkDataRange for which the object should be created
    
    Returns:
    an ElkDataMaxCardinalityQualified corresponding to the input
  - getDataMinCardinality
```
ElkDataMinCardinality getDataMinCardinality(ElkDataPropertyExpression dataPropertyExpression,
                                          int cardinality)
```
    Create an ElkDataMinCardinality.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    
    Returns:
    an ElkDataMinCardinality corresponding to the input
  - getDataMinCardinalityQualified
```
ElkDataMinCardinalityQualified getDataMinCardinalityQualified(ElkDataPropertyExpression dataPropertyExpression,
                                                            int cardinality,
                                                            ElkDataRange dataRange)
```
    Create an ElkDataMinCardinalityQualified.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    dataRange - the ElkDataRange for which the object should be created
    
    Returns:
    an ElkDataMinCardinalityQualified corresponding to the input
  - getDataOneOf
```
ElkDataOneOf getDataOneOf(ElkLiteral firstLiteral,
                        ElkLiteral... otherLiterals)
```
    Create an ElkDataOneOf.
    
    Parameters:
    firstLiteral - the ElkLiteral for which the object should be created
    otherLiterals - other ElkLiterals for which the object should be created
    
    Returns:
    an ElkDataOneOf corresponding to the input
  - getDataOneOf
```
ElkDataOneOf getDataOneOf(List<? extends ElkLiteral> literals)
```
    Create an ElkDataOneOf.
    
    Parameters:
    literals - the ElkLiterals for which the object should be created
    
    Returns:
    an ElkDataOneOf corresponding to the input
  - getDataProperty
```
ElkDataProperty getDataProperty(ElkIri iri)
```
    Create an ElkDataProperty.
    
    Parameters:
    iri - the ElkIri for which the object should be created
    
    Returns:
    an ElkDataProperty corresponding to the input
  - getDataPropertyAssertionAxiom
```
ElkDataPropertyAssertionAxiom getDataPropertyAssertionAxiom(ElkDataPropertyExpression dataPropertyExpression,
                                                          ElkIndividual individual,
                                                          ElkLiteral literal)
```
    Create an ElkDataPropertyAssertionAxiom.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    individual - the ElkIndividual for which the object should be created
    literal - the ElkLiteral for which the object should be created
    
    Returns:
    an ElkDataPropertyAssertionAxiom corresponding to the input
  - getDataPropertyDomainAxiom
```
ElkDataPropertyDomainAxiom getDataPropertyDomainAxiom(ElkDataPropertyExpression dataPropertyExpression,
                                                    ElkClassExpression classExpression)
```
    Create an ElkDataPropertyDomainAxiom.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    classExpression - the ElkClassExpression for which the object should be created
    
    Returns:
    an ElkDataPropertyDomainAxiom corresponding to the input
  - getDataPropertyRangeAxiom
```
ElkDataPropertyRangeAxiom getDataPropertyRangeAxiom(ElkDataPropertyExpression dataPropertyExpression,
                                                  ElkDataRange dataRange)
```
    Create an ElkDataPropertyRangeAxiom.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the object should be created
    dataRange - the ElkDataRange for which the object should be created
    
    Returns:
    an ElkDataPropertyRangeAxiom corresponding to the input
  - getDataSomeValuesFrom
```
ElkDataSomeValuesFrom getDataSomeValuesFrom(ElkDataRange dataRange,
                                          ElkDataPropertyExpression firstDataPropertyExpression,
                                          ElkDataPropertyExpression... otherDataPropertyExpressions)
```
    Create an ElkDataSomeValuesFrom
    
    Parameters:
    dataRange - the ElkDataRange for which the object should be created
    firstDataPropertyExpression - the first ElkDataPropertyExpression for which the object should be created
    otherDataPropertyExpressions - other ElkDataPropertyExpressions for which the object should be created
    
    Returns:
    an ElkDataSomeValuesFrom corresponding to the input
  - getDataSomeValuesFrom
```
ElkDataSomeValuesFrom getDataSomeValuesFrom(ElkDataRange dataRange,
                                          List<? extends ElkDataPropertyExpression> dpList)
```
    Create an ElkDataSomeValuesFrom
    
    Parameters:
    dataRange - the ElkDataRange for which the object should be created
    dpList - the ElkDataPropertyExpressions for which the object should be created
    
    Returns:
    an ElkDataSomeValuesFrom corresponding to the input
  - getDatatype
```
ElkDatatype getDatatype(ElkIri iri)
```
    Create an ElkDatatype.
    
    Parameters:
    iri - the ElkIri for which the object should be created
    
    Returns:
    an ElkDatatype corresponding to the input
  - getDatatypeRdfPlainLiteral
```
ElkDatatype getDatatypeRdfPlainLiteral()
```
    Create the ElkDatatype for rdf:PlainLiteral}.
    
    Returns:
    an ElkDatatype corresponding to the input
  - getDatatypeRestriction
```
ElkDatatypeRestriction getDatatypeRestriction(ElkDatatype datatype,
                                            List<ElkFacetRestriction> facetRestrictions)
```
    Create an ElkDatatypeRestriction.
    
    Parameters:
    datatype - the ElkDatatype for which the object should be created
    facetRestrictions - the ElkFacetRestrictions for which the object should be created
    
    Returns:
    an ElkDatatypeRestriction corresponding to the input
  - getDataUnionOf
```
ElkDataUnionOf getDataUnionOf(ElkDataRange firstDataRange,
                            ElkDataRange secondDataRange,
                            ElkDataRange... otherDataRanges)
```
    Create an ElkDataUnionOf.
    
    Parameters:
    firstDataRange - the first ElkDataRange for which the object should be created
    secondDataRange - the second ElkDataRange for which the object should be created
    otherDataRanges - other ElkDataRanges for which the object should be created
    
    Returns:
    an ElkDataUnionOf corresponding to the input
  - getDataUnionOf
```
ElkDataUnionOf getDataUnionOf(List<? extends ElkDataRange> dataRanges)
```
    Create an ElkDataUnionOf.
    
    Parameters:
    dataRanges - the ElkDataRanges for which the object should be created
    
    Returns:
    an ElkDataUnionOf corresponding to the input
  - getDeclarationAxiom
```
ElkDeclarationAxiom getDeclarationAxiom(ElkEntity entity)
```
    Create an ElkDeclarationAxiom.
    
    Parameters:
    entity - the ElkEntity for which the axiom should be created
    
    Returns:
    an ElkDeclarationAxiom corresponding to the input
  - getDifferentIndividualsAxiom
```
ElkDifferentIndividualsAxiom getDifferentIndividualsAxiom(ElkIndividual firstIndividual,
                                                        ElkIndividual secondIndividual,
                                                        ElkIndividual... otherIndividuals)
```
    Create an ElkDifferentIndividualsAxiom.
    
    Parameters:
    firstIndividual - the first ElkIndividual for which the axiom should be created
    secondIndividual - the second ElkIndividual for which the axiom should be created
    otherIndividuals - other ElkIndividual for which the axiom should be created
    
    Returns:
    an ElkAnnotation corresponding to the input
  - getDifferentIndividualsAxiom
```
ElkDifferentIndividualsAxiom getDifferentIndividualsAxiom(List<? extends ElkIndividual> individuals)
```
    Create an ElkDifferentIndividualsAxiom.
    
    Parameters:
    individuals - the ElkIndividuals for which the axiom should be created
    
    Returns:
    an ElkDifferentIndividualsAxiom corresponding to the input
  - getDisjointClassesAxiom
```
ElkDisjointClassesAxiom getDisjointClassesAxiom(ElkClassExpression firstClassExpression,
                                              ElkClassExpression secondClassExpression,
                                              ElkClassExpression... otherClassExpressions)
```
    Create an ElkDisjointClassesAxiom.
    
    Parameters:
    firstClassExpression - the first ElkClassExpression for which the axiom should be created
    secondClassExpression - the second ElkClassExpression for which the axiom should be created
    otherClassExpressions - other ElkClassExpression for which the axiom should be created
    
    Returns:
    an ElkDisjointClassesAxiom corresponding to the input
  - getDisjointClassesAxiom
```
ElkDisjointClassesAxiom getDisjointClassesAxiom(List<? extends ElkClassExpression> disjointClassExpressions)
```
    Create an ElkDisjointClassesAxiom.
    
    Parameters:
    disjointClassExpressions - the ElkClassExpressions for which the axiom should be created
    
    Returns:
    an ElkDisjointClassesAxiom corresponding to the input
  - getDisjointDataPropertiesAxiom
```
ElkDisjointDataPropertiesAxiom getDisjointDataPropertiesAxiom(ElkDataPropertyExpression firstDataPropertyExpression,
                                                            ElkDataPropertyExpression secondDataPropertyExpression,
                                                            ElkDataPropertyExpression... otherDataPropertyExpressions)
```
    Create an ElkDisjointDataPropertiesAxiom.
    
    Parameters:
    firstDataPropertyExpression - the ElkDataPropertyExpression for which the axiom should be created
    secondDataPropertyExpression - the ElkDataPropertyExpression for which the axiom should be created
    otherDataPropertyExpressions - the ElkDataPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkDisjointDataPropertiesAxiom corresponding to the input
  - getDisjointDataPropertiesAxiom
```
ElkDisjointDataPropertiesAxiom getDisjointDataPropertiesAxiom(List<? extends ElkDataPropertyExpression> disjointDataPropertyExpressions)
```
    Create an ElkDisjointDataPropertiesAxiom.
    
    Parameters:
    disjointDataPropertyExpressions - the ElkDataPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkDisjointDataPropertiesAxiom corresponding to the input
  - getDisjointObjectPropertiesAxiom
```
ElkDisjointObjectPropertiesAxiom getDisjointObjectPropertiesAxiom(ElkObjectPropertyExpression firstObjectPropertyExpression,
                                                                ElkObjectPropertyExpression secondObjectPropertyExpression,
                                                                ElkObjectPropertyExpression... otherObjectPropertyExpressions)
```
    Create an ElkDisjointObjectPropertiesAxiom.
    
    Parameters:
    firstObjectPropertyExpression - the first ElkObjectPropertyExpression for which the axiom should be created
    secondObjectPropertyExpression - the second ElkObjectPropertyExpression for which the axiom should be created
    otherObjectPropertyExpressions - other ElkObjectPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkDisjointObjectPropertiesAxiom corresponding to the input
  - getDisjointObjectPropertiesAxiom
```
ElkDisjointObjectPropertiesAxiom getDisjointObjectPropertiesAxiom(List<? extends ElkObjectPropertyExpression> disjointObjectPropertyExpressions)
```
    Create an ElkDisjointObjectPropertiesAxiom.
    
    Parameters:
    disjointObjectPropertyExpressions - the ElkObjectPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkDisjointObjectPropertiesAxiom corresponding to the input
  - getDisjointUnionAxiom
```
ElkDisjointUnionAxiom getDisjointUnionAxiom(ElkClass definedClass,
                                          ElkClassExpression firstClassExpression,
                                          ElkClassExpression secondClassExpression,
                                          ElkClassExpression... otherClassExpressions)
```
    Create an ElkDisjointUnionAxiom.
    
    Parameters:
    definedClass - the defined ElkClassExpression for which the axiom should be created
    firstClassExpression - the first disjoint ElkClassExpression for which the axiom should be created
    secondClassExpression - the second disjoint ElkClassExpression for which the axiom should be created
    otherClassExpressions - other disjoint ElkClassExpressions for which the axiom should be created
    
    Returns:
    an ElkDisjointUnionAxiom corresponding to the input
  - getDisjointUnionAxiom
```
ElkDisjointUnionAxiom getDisjointUnionAxiom(ElkClass definedClass,
                                          List<? extends ElkClassExpression> disjointClassExpressions)
```
    Create an ElkDisjointUnionAxiom.
    
    Parameters:
    definedClass - the defined ElkClassExpression for which the axiom should be created
    disjointClassExpressions - the disjoint ElkClassExpressions for which the axiom should be created
    
    Returns:
    an ElkDisjointUnionAxiom corresponding to the input
  - getEquivalentClassesAxiom
```
ElkEquivalentClassesAxiom getEquivalentClassesAxiom(ElkClassExpression firstClassExpression,
                                                  ElkClassExpression secondClassExpression,
                                                  ElkClassExpression... otherClassExpressions)
```
    Create an ElkEquivalentClassesAxiom.
    
    Parameters:
    firstClassExpression - the first equivalent ElkClassExpression for which the axiom should be created
    secondClassExpression - the second equivalent ElkClassExpression for which the axiom should be created
    otherClassExpressions - other equivalent ElkClassExpressions for which the axiom should be created
    
    Returns:
    an ElkEquivalentClassesAxiom corresponding to the input
  - getEquivalentClassesAxiom
```
ElkEquivalentClassesAxiom getEquivalentClassesAxiom(List<? extends ElkClassExpression> equivalentClassExpressions)
```
    Create an ElkEquivalentClassesAxiom.
    
    Parameters:
    equivalentClassExpressions - the equivalent ElkClassExpressions for which the axiom should be created
    
    Returns:
    an ElkEquivalentClassesAxiom corresponding to the input
  - getEquivalentDataPropertiesAxiom
```
ElkEquivalentDataPropertiesAxiom getEquivalentDataPropertiesAxiom(ElkDataPropertyExpression firstDataPropertyExpression,
                                                                ElkDataPropertyExpression secondDataPropertyExpression,
                                                                ElkDataPropertyExpression... otherDataPropertyExpressions)
```
    Create an ElkEquivalentDataPropertiesAxiom.
    
    Parameters:
    firstDataPropertyExpression - the fist equivalent ElkDataPropertyExpression for which the axiom should be created
    secondDataPropertyExpression - the second equivalent ElkDataPropertyExpression for which the axiom should be created
    otherDataPropertyExpressions - other equivalent ElkDataPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkEquivalentDataPropertiesAxiom corresponding to the input
  - getEquivalentDataPropertiesAxiom
```
ElkEquivalentDataPropertiesAxiom getEquivalentDataPropertiesAxiom(List<? extends ElkDataPropertyExpression> equivalentDataPropertyExpressions)
```
    Create an ElkEquivalentDataPropertiesAxiom.
    
    Parameters:
    equivalentDataPropertyExpressions - the equivalent ElkDataPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkEquivalentDataPropertiesAxiom corresponding to the input
  - getEquivalentObjectPropertiesAxiom
```
ElkEquivalentObjectPropertiesAxiom getEquivalentObjectPropertiesAxiom(ElkObjectPropertyExpression firstObjectPropertyExpression,
                                                                    ElkObjectPropertyExpression secondObjectPropertyExpression,
                                                                    ElkObjectPropertyExpression... otherObjectPropertyExpressions)
```
    Create an ElkEquivalentObjectPropertiesAxiom.
    
    Parameters:
    firstObjectPropertyExpression - the first equivalent ElkObjectPropertyExpression for which the axiom should be created
    secondObjectPropertyExpression - the second equivalent ElkObjectPropertyExpression for which the axiom should be created
    otherObjectPropertyExpressions - other equivalent ElkObjectPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkEquivalentObjectPropertiesAxiom corresponding to the input
  - getEquivalentObjectPropertiesAxiom
```
ElkEquivalentObjectPropertiesAxiom getEquivalentObjectPropertiesAxiom(List<? extends ElkObjectPropertyExpression> equivalentObjectPropertyExpressions)
```
    Create an ElkEquivalentObjectPropertiesAxiom.
    
    Parameters:
    equivalentObjectPropertyExpressions - the equivalent ElkObjectPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkEquivalentObjectPropertiesAxiom corresponding to the input
  - getFunctionalDataPropertyAxiom
```
ElkFunctionalDataPropertyAxiom getFunctionalDataPropertyAxiom(ElkDataPropertyExpression dataPropertyExpression)
```
    Create an ElkFunctionalDataPropertyAxiom.
    
    Parameters:
    dataPropertyExpression - the functional ElkDataPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkFunctionalDataPropertyAxiom corresponding to the input
  - getFunctionalObjectPropertyAxiom
```
ElkFunctionalObjectPropertyAxiom getFunctionalObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkFunctionalObjectPropertyAxiom.
    
    Parameters:
    objectPropertyExpression - the functional ElkObjectPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkFunctionalObjectPropertyAxiom corresponding to the input
  - getInverseFunctionalObjectPropertyAxiom
```
ElkInverseFunctionalObjectPropertyAxiom getInverseFunctionalObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkInverseFunctionalObjectPropertyAxiom.
    
    Parameters:
    objectPropertyExpression - the inverse functional ElkObjectPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkInverseFunctionalObjectPropertyAxiom corresponding to the input
  - getInverseObjectPropertiesAxiom
```
ElkInverseObjectPropertiesAxiom getInverseObjectPropertiesAxiom(ElkObjectPropertyExpression firstObjectPropertyExpression,
                                                              ElkObjectPropertyExpression secondObjectPropertyExpression)
```
    Create an ElkInverseObjectPropertiesAxiom.
    
    Parameters:
    firstObjectPropertyExpression - the first ElkObjectPropertyExpression that should be the inverse of the second one for which the axiom should be created
    secondObjectPropertyExpression - the second ElkObjectPropertyExpression that should be the inverse of the first one for which the axiom should be created
    
    Returns:
    an ElkInverseObjectPropertiesAxiom corresponding to the input
  - getIrreflexiveObjectPropertyAxiom
```
ElkIrreflexiveObjectPropertyAxiom getIrreflexiveObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkIrreflexiveObjectPropertyAxiom.
    
    Parameters:
    objectPropertyExpression - the irreflexive ElkObjectPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkIrreflexiveObjectPropertyAxiom corresponding to the input
  - getLiteral
```
ElkLiteral getLiteral(String lexicalForm,
                    ElkDatatype datatype)
```
    Create an ElkLiteral.
    
    Parameters:
    lexicalForm - the String for which the object should be created
    datatype - the ElkDatatype for which the object should be created
    
    Returns:
    an ElkLiteral corresponding to the input
  - getNamedIndividual
```
ElkNamedIndividual getNamedIndividual(ElkIri iri)
```
    Create an ElkNamedIndividual.
    
    Parameters:
    iri - the ElkIri for which the object should be created
    
    Returns:
    an ElkNamedIndividual corresponding to the input
  - getNegativeDataPropertyAssertionAxiom
```
ElkNegativeDataPropertyAssertionAxiom getNegativeDataPropertyAssertionAxiom(ElkDataPropertyExpression dataPropertyExpression,
                                                                          ElkIndividual individual,
                                                                          ElkLiteral literal)
```
    Create an ElkNegativeDataPropertyAssertionAxiom.
    
    Parameters:
    dataPropertyExpression - the ElkDataPropertyExpression for which the axiom should be created
    individual - the ElkIndividual for which the axiom should be created
    literal - the ElkLiteral for which the axiom should be created
    
    Returns:
    an ElkNegativeDataPropertyAssertionAxiom corresponding to the input
  - getNegativeObjectPropertyAssertionAxiom
```
ElkNegativeObjectPropertyAssertionAxiom getNegativeObjectPropertyAssertionAxiom(ElkObjectPropertyExpression objectPropertyExpression,
                                                                              ElkIndividual firstIndividual,
                                                                              ElkIndividual secondIndividual)
```
    Create an ElkNegativeObjectPropertyAssertionAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the axiom should be created
    firstIndividual - the ElkIndividual for which the axiom should be created
    secondIndividual - the ElkIndividual for which the axiom should be created
    
    Returns:
    an ElkNegativeObjectPropertyAssertionAxiom corresponding to the input
  - getObjectAllValuesFrom
```
ElkObjectAllValuesFrom getObjectAllValuesFrom(ElkObjectPropertyExpression objectPropertyExpression,
                                            ElkClassExpression classExpression)
```
    Create an ElkObjectAllValuesFrom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the axiom should be created
    classExpression - the ElkClassExpression for which the axiom should be created
    
    Returns:
    an ElkObjectAllValuesFrom corresponding to the input
  - getObjectComplementOf
```
ElkObjectComplementOf getObjectComplementOf(ElkClassExpression classExpression)
```
    Create an ElkObjectComplementOf.
    
    Parameters:
    classExpression -
    
    Returns:
    an ElkObjectComplementOf corresponding to the input
  - getObjectExactCardinality
```
ElkObjectExactCardinality getObjectExactCardinality(ElkObjectPropertyExpression objectPropertyExpression,
                                                  int cardinality)
```
    Create an ElkObjectExactCardinality.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    
    Returns:
    an ElkObjectExactCardinality corresponding to the input
  - getObjectExactCardinalityQualified
```
ElkObjectExactCardinalityQualified getObjectExactCardinalityQualified(ElkObjectPropertyExpression objectPropertyExpression,
                                                                    int cardinality,
                                                                    ElkClassExpression classExpression)
```
    Create an ElkObjectExactCardinalityQualified.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    classExpression - the ElkClassExpression for which the object should be created
    
    Returns:
    an ElkObjectExactCardinalityQualified corresponding to the input
  - getObjectHasSelf
```
ElkObjectHasSelf getObjectHasSelf(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkObjectHasSelf.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    
    Returns:
    an ElkObjectHasSelf corresponding to the input
  - getObjectHasValue
```
ElkObjectHasValue getObjectHasValue(ElkObjectPropertyExpression objectPropertyExpression,
                                  ElkIndividual individual)
```
    Create an ElkObjectHasValue.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    individual - the ElkIndividual for which the object should be created
    
    Returns:
    an ElkObjectHasValue corresponding to the input
  - getObjectIntersectionOf
```
ElkObjectIntersectionOf getObjectIntersectionOf(ElkClassExpression firstClassExpression,
                                              ElkClassExpression secondClassExpression,
                                              ElkClassExpression... otherClassExpressions)
```
    Create an ElkObjectIntersectionOf.
    
    Parameters:
    firstClassExpression - the first ElkClassExpression for which the object should be created
    secondClassExpression - the second ElkClassExpression for which the object should be created
    otherClassExpressions - other ElkClassExpressions for which the object should be created
    
    Returns:
    an ElkObjectIntersectionOf corresponding to the input
  - getObjectIntersectionOf
```
ElkObjectIntersectionOf getObjectIntersectionOf(List<? extends ElkClassExpression> classExpressions)
```
    Create an ElkObjectIntersectionOf.
    
    Parameters:
    classExpressions - the ElkClassExpressions for which the object should be created
    
    Returns:
    an ElkObjectIntersectionOf corresponding to the input
  - getObjectInverseOf
```
ElkObjectInverseOf getObjectInverseOf(ElkObjectProperty objectProperty)
```
    Create an ElkObjectInverseOf.
    
    Parameters:
    objectProperty - the ElkObjectProperty for which the object should be created
    
    Returns:
    an ElkObjectInverseOf corresponding to the input
  - getObjectMaxCardinality
```
ElkObjectMaxCardinality getObjectMaxCardinality(ElkObjectPropertyExpression objectPropertyExpression,
                                              int cardinality)
```
    Create an ElkObjectMaxCardinality.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    
    Returns:
    an ElkObjectMaxCardinality corresponding to the input
  - getObjectMaxCardinalityQualified
```
ElkObjectMaxCardinalityQualified getObjectMaxCardinalityQualified(ElkObjectPropertyExpression objectPropertyExpression,
                                                                int cardinality,
                                                                ElkClassExpression classExpression)
```
    Create an ElkObjectMaxCardinalityQualified.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    classExpression - the ElkClassExpression for which the object should be created
    
    Returns:
    an ElkObjectMaxCardinalityQualified corresponding to the input
  - getObjectMinCardinality
```
ElkObjectMinCardinality getObjectMinCardinality(ElkObjectPropertyExpression objectPropertyExpression,
                                              int cardinality)
```
    Create an ElkObjectMinCardinality.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    
    Returns:
    an ElkObjectMinCardinality corresponding to the input
  - getObjectMinCardinalityQualified
```
ElkObjectMinCardinalityQualified getObjectMinCardinalityQualified(ElkObjectPropertyExpression objectPropertyExpression,
                                                                int cardinality,
                                                                ElkClassExpression classExpression)
```
    Create an ElkObjectMinCardinalityQualified.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    cardinality - the cardinality for which the object should be created
    classExpression - the ElkClassExpression for which the object should be created
    
    Returns:
    an ElkObjectMinCardinalityQualified corresponding to the input
  - getObjectOneOf
```
ElkObjectOneOf getObjectOneOf(ElkIndividual firstIndividual,
                            ElkIndividual... otherIndividuals)
```
    Create an ElkObjectOneOf.
    
    Parameters:
    firstIndividual - the first ElkIndividual for which the object should be created
    otherIndividuals - other ElkIndividuals for which the object should be created
    
    Returns:
    an ElkObjectOneOf corresponding to the input
  - getObjectOneOf
```
ElkObjectOneOf getObjectOneOf(List<? extends ElkIndividual> individuals)
```
    Create an ElkObjectOneOf.
    
    Parameters:
    individuals - the ElkIndividuals for which the object should be created
    
    Returns:
    an ElkObjectOneOf corresponding to the input
  - getObjectProperty
```
ElkObjectProperty getObjectProperty(ElkIri iri)
```
    Create an ElkObjectProperty.
    
    Parameters:
    iri - the ElkIri for which the object should be created
    
    Returns:
    an ElkObjectProperty corresponding to the input
  - getObjectPropertyAssertionAxiom
```
ElkObjectPropertyAssertionAxiom getObjectPropertyAssertionAxiom(ElkObjectPropertyExpression objectPropertyExpression,
                                                              ElkIndividual firstIndividual,
                                                              ElkIndividual secondIndividual)
```
    Create an ElkObjectPropertyAssertionAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the axiom should be created
    firstIndividual - the first ElkIndividual for which the axiom should be created
    secondIndividual - the second ElkIndividual for which the axiom should be created
    
    Returns:
    an ElkObjectPropertyAssertionAxiom corresponding to the input
  - getObjectPropertyChain
```
ElkObjectPropertyChain getObjectPropertyChain(List<? extends ElkObjectPropertyExpression> objectPropertyExpressions)
```
    Create an ElkObjectPropertyChain.
    
    Parameters:
    objectPropertyExpressions - the ElkObjectPropertyExpressions for which the object should be created
    
    Returns:
    an ElkObjectPropertyChain corresponding to the input
  - getObjectPropertyDomainAxiom
```
ElkObjectPropertyDomainAxiom getObjectPropertyDomainAxiom(ElkObjectPropertyExpression objectPropertyExpression,
                                                        ElkClassExpression classExpression)
```
    Create an ElkObjectPropertyDomainAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the axiom should be created
    classExpression - the ElkClassExpression for which the axiom should be created
    
    Returns:
    an ElkObjectPropertyDomainAxiom corresponding to the input
  - getObjectPropertyRangeAxiom
```
ElkObjectPropertyRangeAxiom getObjectPropertyRangeAxiom(ElkObjectPropertyExpression objectPropertyExpression,
                                                      ElkClassExpression classExpression)
```
    Create an ElkObjectPropertyRangeAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the axiom should be created
    classExpression - the ElkClassExpression for which the axiom should be created
    
    Returns:
    an ElkObjectPropertyRangeAxiom corresponding to the input
  - getObjectSomeValuesFrom
```
ElkObjectSomeValuesFrom getObjectSomeValuesFrom(ElkObjectPropertyExpression objectPropertyExpression,
                                              ElkClassExpression classExpression)
```
    Create an ElkObjectSomeValuesFrom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the object should be created
    classExpression - the ElkClassExpression for which the object should be created
    
    Returns:
    an ElkObjectSomeValuesFrom corresponding to the input
  - getObjectUnionOf
```
ElkObjectUnionOf getObjectUnionOf(ElkClassExpression firstClassExpression,
                                ElkClassExpression secondClassExpression,
                                ElkClassExpression... otherClassExpressions)
```
    Create an ElkObjectUnionOf.
    
    Parameters:
    firstClassExpression - the first ElkClassExpression of the union for which the object should be created
    secondClassExpression - the second ElkClassExpression of the union for which the object should be created
    otherClassExpressions - other ElkClassExpressions of the union for which the object should be created
    
    Returns:
    an ElkObjectUnionOf corresponding to the input
  - getObjectUnionOf
```
ElkObjectUnionOf getObjectUnionOf(List<? extends ElkClassExpression> classExpressions)
```
    Create an ElkObjectUnionOf.
    
    Parameters:
    classExpressions - the ElkClassExpressions for which the object should be created
    
    Returns:
    an ElkObjectUnionOf corresponding to the input
  - getOwlBottomDataProperty
```
ElkDataProperty getOwlBottomDataProperty()
```
    Create the ElkDataProperty representing owl:BottomDataProperty}.
    
    Returns:
    an ElkDataProperty corresponding to the input
  - getOwlBottomObjectProperty
```
ElkObjectProperty getOwlBottomObjectProperty()
```
    Create the ElkObjectProperty representing owl:BottomObjectProperty}.
    
    Returns:
    an ElkObjectProperty corresponding to the input
  - getOwlNothing
```
ElkClass getOwlNothing()
```
    Create the ElkClass representing owl:Nothing.
    
    Returns:
    an ElkClass corresponding to the input
  - getOwlThing
```
ElkClass getOwlThing()
```
    Create the ElkClass representing owl:Thing.
    
    Returns:
    an ElkClass corresponding to the input
  - getOwlTopDataProperty
```
ElkDataProperty getOwlTopDataProperty()
```
    Create the ElkDataProperty representing owl:TopDataProperty.
    
    Returns:
    an ElkDataProperty corresponding to the input
  - getOwlTopObjectProperty
```
ElkObjectProperty getOwlTopObjectProperty()
```
    Create the ElkObjectProperty representing owl:TopObjectProperty.
    
    Returns:
    an ElkObjectProperty corresponding to the input
  - getReflexiveObjectPropertyAxiom
```
ElkReflexiveObjectPropertyAxiom getReflexiveObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkReflexiveObjectPropertyAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkIri for which the axiom should be created
    
    Returns:
    an ElkReflexiveObjectPropertyAxiom corresponding to the input
  - getSameIndividualAxiom
```
ElkSameIndividualAxiom getSameIndividualAxiom(ElkIndividual firstIndividual,
                                            ElkIndividual secondIndividual,
                                            ElkIndividual... otherIndividuals)
```
    Create an ElkSameIndividualAxiom.
    
    Parameters:
    firstIndividual - the first equivalent ElkIndividual for which the axiom should be created
    secondIndividual - the second equivalent ElkIndividual for which the axiom should be created
    otherIndividuals - other equivalent ElkIndividual for which the axiom should be created
    
    Returns:
    an ElkSameIndividualAxiom corresponding to the input
  - getSameIndividualAxiom
```
ElkSameIndividualAxiom getSameIndividualAxiom(List<? extends ElkIndividual> individuals)
```
    Create an ElkSameIndividualAxiom.
    
    Parameters:
    individuals - the equivalent ElkIndividual for which the axiom should be created
    
    Returns:
    an ElkSameIndividualAxiom corresponding to the input
  - getSubAnnotationPropertyOfAxiom
```
ElkSubAnnotationPropertyOfAxiom getSubAnnotationPropertyOfAxiom(ElkAnnotationProperty subAnnotationProperty,
                                                              ElkAnnotationProperty superAnnotationProperty)
```
    Create an ElkSubAnnotationPropertyOfAxiom
    
    Parameters:
    subAnnotationProperty - the sub-ElkAnnotationProperty for which the object should be created
    superAnnotationProperty - the super-ElkAnnotationProperty for which the object should be created
    
    Returns:
    an ElkSubAnnotationPropertyOfAxiom corresponding to the input
  - getSubClassOfAxiom
```
ElkSubClassOfAxiom getSubClassOfAxiom(ElkClassExpression subClassExpression,
                                    ElkClassExpression superClassExpression)
```
    Create an ElkSubClassOfAxiom.
    
    Parameters:
    subClassExpression - the ElkClassExpression for which the axiom should be created
    superClassExpression - the ElkClassExpression for which the axiom should be created
    
    Returns:
    an ElkSubClassOfAxiom corresponding to the input
  - getSubDataPropertyOfAxiom
```
ElkSubDataPropertyOfAxiom getSubDataPropertyOfAxiom(ElkDataPropertyExpression subDataPropertyExpression,
                                                  ElkDataPropertyExpression superDataPropertyExpression)
```
    Create an ElkSubDataPropertyOfAxiom.
    
    Parameters:
    subDataPropertyExpression - the sub-ElkDataPropertyExpression for which the axiom should be created
    superDataPropertyExpression - the super-ElkDataPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkSubDataPropertyOfAxiom corresponding to the input
  - getSubObjectPropertyOfAxiom
```
ElkSubObjectPropertyOfAxiom getSubObjectPropertyOfAxiom(ElkSubObjectPropertyExpression subObjectPropertyExpression,
                                                      ElkObjectPropertyExpression superObjectPropertyExpression)
```
    Create an ElkSubObjectPropertyOfAxiom.
    
    Parameters:
    subObjectPropertyExpression - the ElkSubObjectPropertyExpression for which the axiom should be created
    superObjectPropertyExpression - the super-ElkObjectPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkSubObjectPropertyOfAxiom corresponding to the input
  - getSymmetricObjectPropertyAxiom
```
ElkSymmetricObjectPropertyAxiom getSymmetricObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkSymmetricObjectPropertyAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkIri for which the axiom should be created
    
    Returns:
    an ElkAnnotation corresponding to the input
  - getTransitiveObjectPropertyAxiom
```
ElkTransitiveObjectPropertyAxiom getTransitiveObjectPropertyAxiom(ElkObjectPropertyExpression objectPropertyExpression)
```
    Create an ElkTransitiveObjectPropertyAxiom.
    
    Parameters:
    objectPropertyExpression - the ElkObjectPropertyExpression for which the axiom should be created
    
    Returns:
    an ElkTransitiveObjectPropertyAxiom corresponding to the input
  - getHasKeyAxiom
```
ElkHasKeyAxiom getHasKeyAxiom(ElkClassExpression classExpr,
                            Set<ElkObjectPropertyExpression> objectPEs,
                            Set<ElkDataPropertyExpression> dataPEs)
```
    Create an ElkHasKeyAxiom
    
    Parameters:
    classExpr - the ElkClassExpression for which the axiom should be created
    objectPEs - the ElkObjectPropertyExpressions for which the axiom should be created
    dataPEs - the ElkDataPropertyExpressions for which the axiom should be created
    
    Returns:
    an ElkHasKeyAxiom corresponding to the input
  - getDatatypeDefinitionAxiom
```
ElkDatatypeDefinitionAxiom getDatatypeDefinitionAxiom(ElkDatatype datatype,
                                                    ElkDataRange dataRange)
```
    Create an ElkDatatypeDefinitionAxiom
    
    Parameters:
    datatype - the ElkDatatype for which the axiom should be created
    dataRange - the ElkDataRange for which the axiom should be created
    
    Returns:
    an ElkDatatypeDefinitionAxiom corresponding to the input
  - getFacetRestriction
```
ElkFacetRestriction getFacetRestriction(ElkIri iri,
                                      ElkLiteral literal)
```
    Create an ElkFacetRestriction
    
    Parameters:
    iri - the ElkIri for which the object should be created
    literal - the ElkLiteral for which the object should be created
    
    Returns:
    an ElkFacetRestriction corresponding to the input
  - getSWRLRule
```
ElkSWRLRule getSWRLRule()
```
    No arguments since we don't have a full representation of SWRL rules
    
    Returns:
    a dummy object

Interface ElkObjectFactory

Method Summary

Method Detail

getAnnotation

getAnnotationProperty

getAnnotationAssertionAxiom

getAnnotationPropertyDomainAxiom

getAnnotationPropertyRangeAxiom

getAnonymousIndividual

getAsymmetricObjectPropertyAxiom

getClass

getClassAssertionAxiom

getDataAllValuesFrom

getDataAllValuesFrom

getDataComplementOf

getDataExactCardinality

getDataExactCardinalityQualified

getDataHasValue

getDataIntersectionOf

getDataIntersectionOf

getDataMaxCardinality

getDataMaxCardinalityQualified

getDataMinCardinality

getDataMinCardinalityQualified

getDataOneOf

getDataOneOf

getDataProperty

getDataPropertyAssertionAxiom

getDataPropertyDomainAxiom

getDataPropertyRangeAxiom

getDataSomeValuesFrom

getDataSomeValuesFrom

getDatatype

getDatatypeRdfPlainLiteral

getDatatypeRestriction

getDataUnionOf

getDataUnionOf

getDeclarationAxiom

getDifferentIndividualsAxiom

getDifferentIndividualsAxiom

getDisjointClassesAxiom

getDisjointClassesAxiom

getDisjointDataPropertiesAxiom

getDisjointDataPropertiesAxiom

getDisjointObjectPropertiesAxiom

getDisjointObjectPropertiesAxiom

getDisjointUnionAxiom

getDisjointUnionAxiom

getEquivalentClassesAxiom

getEquivalentClassesAxiom

getEquivalentDataPropertiesAxiom

getEquivalentDataPropertiesAxiom

getEquivalentObjectPropertiesAxiom

getEquivalentObjectPropertiesAxiom

getFunctionalDataPropertyAxiom

getFunctionalObjectPropertyAxiom

getInverseFunctionalObjectPropertyAxiom

getInverseObjectPropertiesAxiom

getIrreflexiveObjectPropertyAxiom

getLiteral

getNamedIndividual

getNegativeDataPropertyAssertionAxiom

getNegativeObjectPropertyAssertionAxiom

getObjectAllValuesFrom

getObjectComplementOf

getObjectExactCardinality

getObjectExactCardinalityQualified

getObjectHasSelf

getObjectHasValue

getObjectIntersectionOf

getObjectIntersectionOf

getObjectInverseOf

getObjectMaxCardinality

getObjectMaxCardinalityQualified

getObjectMinCardinality

getObjectMinCardinalityQualified

getObjectOneOf

getObjectOneOf

getObjectProperty

getObjectPropertyAssertionAxiom