RdfClass (Jena SPARQL API - Mapper 3.3.0-3 API)

java.lang.Object
- org.aksw.jena_sparql_api.mapper.impl.type.RdfTypeBase
- - org.aksw.jena_sparql_api.mapper.impl.type.RdfTypeComplexBase
  - - org.aksw.jena_sparql_api.mapper.impl.type.RdfClass

All Implemented Interfaces:

RdfType
```
public class RdfClass
extends RdfTypeComplexBase
```
An RdfClass is one type of implementation that can map Java objects to and from RDF graphs.

Field Summary

Fields
Modifier and Type	Field and Description
`protected Concept`	`concept` The concept that captures rdf terms that are instances of this class.
`protected java.util.function.Function<Object,String>`	`defaultIriFn` A function for obtaining a default IRI from an object
`protected EntityOps`	`entityOps` The affected class (maybe we should use the fully qualified class name instead?)
`protected boolean`	`isPopulated`
`protected List<RdfMapper>`	`populators` Populators are used to map between property values and RDF data A single populator may thereby set multiple properties at once.
`protected Map<String,RdfPropertyDescriptor>`	`propertyDescriptors` PropertyDescriptors map the Java property types to RdfType instances.

Constructor Summary

Constructors
Constructor and Description

RdfClass(EntityOps targetClass, java.util.function.Function<Object,String> defaultIriFn)

Constructors
Constructor and Description
`RdfClass(EntityOps targetClass, java.util.function.Function<Object,String> defaultIriFn)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addPropertyDescriptor(RdfPropertyDescriptor propertyDescriptor)`
`void`	`addPropertyMapper(RdfMapper populator)`
`void`	`checkPopulated()`
`Object`	`createJavaObject(org.apache.jena.rdf.model.RDFNode r)` Extract a Java (literal) object from a given node.
`Object`	`createProxy(org.apache.jena.sparql.core.DatasetGraph datasetGraph, org.apache.jena.graph.Node subject)` Deprecated. Use createJavaObject first, and initialize values from a datasetGraph using a separate call to one of the methods of this class TODO which method?
`void`	`exposeFragment(ResourceFragment out, org.apache.jena.rdf.model.Resource priorState, Object entity)` Return an RDF graph from the entity, where nodes may be placeholders
`void`	`exposeShape(ResourceShapeBuilder builder)`
`Concept`	`getConcept()`
`Class<?>`	`getEntityClass()` Return the Java class corresponding to this type (maybe it should be Type instead of Class)
`EntityOps`	`getEntityOps()`
`static MethodInterceptorRdf`	`getMethodInterceptor(Object o)`
`Collection<RdfPropertyDescriptor>`	`getPropertyDescriptors()`
`RdfPropertyDescriptor`	`getPropertyDescriptors(String propertyName)`
`Collection<RdfMapper>`	`getPropertyMappers()`
`org.apache.jena.graph.Node`	`getRootNode(Object o)` Returns the subject of a given object or null if not present.
`boolean`	`hasIdentity()` Flag to indicate whether entities created from this mapping have their own identity.
`boolean`	`isPopulated()` Whether this RdfClass instance is fully initialized.
`EntityFragment`	`populate(org.apache.jena.rdf.model.Resource shape, Object entity)` Set property values of the given target object based a DatasetGraph.
`PathFragment`	`resolve(String propertyName)`
`void`	`setPopulated(boolean isPopulated)`
`Object`	`toJava(org.apache.jena.graph.Node node)`
`String`	`toString()`

Methods inherited from class org.aksw.jena_sparql_api.mapper.impl.type.RdfTypeComplexBase
isSimpleType

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - entityOps
```
protected EntityOps entityOps
```
    The affected class (maybe we should use the fully qualified class name instead?)
  - concept
```
protected Concept concept
```
    The concept that captures rdf terms that are instances of this class. In the simplest case this is { ?s | ?s a <http://example.org/ontology/SomeType> }
  - defaultIriFn
```
protected java.util.function.Function<Object,String> defaultIriFn
```
    A function for obtaining a default IRI from an object
  - populators
```
protected List<RdfMapper> populators
```
    Populators are used to map between property values and RDF data A single populator may thereby set multiple properties at once. However, the value and the RdfType of the property determine whether additional population is needed. A persistenceContext is used to keep track of beans that were not populated yet. Each property has a corresponding RdfType
  - propertyDescriptors
```
protected Map<String,RdfPropertyDescriptor> propertyDescriptors
```
    PropertyDescriptors map the Java property types to RdfType instances. The population status of a property value depends on the RdfType and value in regard to a persistenceContext.
  - isPopulated
```
protected boolean isPopulated
```
- Constructor Detail
  - RdfClass
```
public RdfClass(EntityOps targetClass,
                java.util.function.Function<Object,String> defaultIriFn)
```
- Method Detail
  - getPropertyMappers
```
public Collection<RdfMapper> getPropertyMappers()
```
  - getPropertyDescriptors
```
public Collection<RdfPropertyDescriptor> getPropertyDescriptors()
```
  - getPropertyDescriptors
```
public RdfPropertyDescriptor getPropertyDescriptors(String propertyName)
```
  - getEntityOps
```
public EntityOps getEntityOps()
```
  - getConcept
```
public Concept getConcept()
```
  - setPopulated
```
public void setPopulated(boolean isPopulated)
```
  - checkPopulated
```
public void checkPopulated()
```
  - addPropertyDescriptor
```
public void addPropertyDescriptor(RdfPropertyDescriptor propertyDescriptor)
```
  - addPropertyMapper
```
public void addPropertyMapper(RdfMapper populator)
```
  - isPopulated
```
public boolean isPopulated()
```
    Whether this RdfClass instance is fully initialized.
    
    Returns:
  - getEntityClass
```
public Class<?> getEntityClass()
```
    Description copied from interface: RdfType
    
    Return the Java class corresponding to this type (maybe it should be Type instead of Class)
    
    Returns:
  - exposeShape
```
public void exposeShape(ResourceShapeBuilder builder)
```
  - getMethodInterceptor
```
public static MethodInterceptorRdf getMethodInterceptor(Object o)
```
  - getRootNode
```
public org.apache.jena.graph.Node getRootNode(Object o)
```
    Returns the subject of a given object or null if not present. First the object is checked for whether it is a proxy referring to a prior subject, which is returned if present. Otherwise, a default iri will be generated.
    
    Parameters:
    
    o -
    
    Returns:
  - toJava
```
public Object toJava(org.apache.jena.graph.Node node)
```
  - populate
```
public EntityFragment populate(org.apache.jena.rdf.model.Resource shape,
                               Object entity)
```
    Set property values of the given target object based a DatasetGraph.
    
    Parameters:
    
    entity -
    
    datasetGraph -
  - createProxy
```
@Deprecated
public Object createProxy(org.apache.jena.sparql.core.DatasetGraph datasetGraph,
                                      org.apache.jena.graph.Node subject)
```
    Deprecated. Use createJavaObject first, and initialize values from a datasetGraph using a separate call to one of the methods of this class TODO which method?
    
    Create a proxied instance of the class based on the given graph
    
    Parameters:
    
    datasetGraph -
    
    Returns:
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - createJavaObject
```
public Object createJavaObject(org.apache.jena.rdf.model.RDFNode r)
```
    Description copied from interface: RdfType
    
    Extract a Java (literal) object from a given node. Note: Creating a *non-primitive* java object is not a concern of RdfType which only *MAPS* between a java object and its corresponding triples. The reason is, that via the RdfType's entity class the association to a newInstance method can be indirectly made on the outside, without RdfType having to be aware of it. Also, an RdfType reading a collection may be capable of reading and writing to any collection type, regardless of the concrete sub-type (list, set, etc). Create an empty java object (i.e. no properties set) based on the given node. In the case of primitive types (e.g. String, Long, etc), the object will already carry the correct value. In the case of classes, the result may either be a Java object regardless of the node argument, or a proxy to such java object that holds the node
    
    Returns:
  - hasIdentity
```
public boolean hasIdentity()
```
    Description copied from interface: RdfType
    
    Flag to indicate whether entities created from this mapping have their own identity. If not, ids are usually derived from the parent object
    
    Returns:
  - exposeFragment
```
public void exposeFragment(ResourceFragment out,
                           org.apache.jena.rdf.model.Resource priorState,
                           Object entity)
```
    Return an RDF graph from the entity, where nodes may be placeholders
    
    Parameters:
    
    entity -
  - resolve
```
public PathFragment resolve(String propertyName)
```
    Specified by:
    
    resolve in interface RdfType
    
    Overrides:
    
    resolve in class RdfTypeBase

Class RdfClass

Field Summary

Constructor Summary

Method Summary

Methods inherited from class org.aksw.jena_sparql_api.mapper.impl.type.RdfTypeComplexBase

Methods inherited from class java.lang.Object

Field Detail

entityOps

concept

defaultIriFn

populators

propertyDescriptors

isPopulated

Constructor Detail

RdfClass

Method Detail

getPropertyMappers

getPropertyDescriptors

getPropertyDescriptors

getEntityOps

getConcept

setPopulated

checkPopulated

addPropertyDescriptor

addPropertyMapper

isPopulated

getEntityClass

exposeShape

getMethodInterceptor

getRootNode

toJava

populate

createProxy

toString

createJavaObject

hasIdentity

exposeFragment

resolve