Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
Cleaning code for codestyle and using new varargs constructor from Rd…
…fStream
  • Loading branch information
ajs6f committed Oct 29, 2013
1 parent 79d6e3e commit 4537610
Show file tree
Hide file tree
Showing 4 changed files with 149 additions and 114 deletions.
Expand Up @@ -17,24 +17,22 @@
package org.fcrepo.kernel.rdf.impl;

import static com.google.common.base.Throwables.propagate;
import static com.google.common.collect.Iterators.filter;
import static com.google.common.collect.Iterators.forArray;
import static com.google.common.collect.Iterators.transform;
import static com.hp.hpl.jena.graph.NodeFactory.createLiteral;
import static com.hp.hpl.jena.graph.Triple.create;
import static com.hp.hpl.jena.rdf.model.ResourceFactory.createProperty;
import static com.hp.hpl.jena.vocabulary.RDFS.subClassOf;
import static org.fcrepo.kernel.utils.JcrRdfTools.getRDFNamespaceForJcrNamespace;
import static org.slf4j.LoggerFactory.getLogger;

import com.google.common.base.Function;
import com.google.common.base.Predicate;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.graph.Triple;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.ResourceFactory;
import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.RDFS;
import org.fcrepo.kernel.rdf.impl.mappings.NodeDefinitionToTriples;
Expand All @@ -50,40 +48,49 @@
import javax.jcr.nodetype.NodeTypeManager;

/**
* Assemble {@link Triple}s derived from the {@link NodeType}s in a repository.
* @author cbeer
* Assemble {@link Triple}s derived from the {@link NodeType}s in a repository.
*
* @author cbeer
*/
public class NodeTypeRdfContext extends RdfStream {

private static Logger LOGGER = getLogger(NodeTypeRdfContext.class);

private static final Predicate<ItemDefinition> ignoreWildcardResidualDefinitions = new Predicate<ItemDefinition>() {
@Override
public boolean apply(final ItemDefinition input) {
return !input.getName().equals("*");
}
};
private static final Predicate<ItemDefinition> ignoreWildcardResidualDefinitions =
new Predicate<ItemDefinition>() {

@Override
public boolean apply(final ItemDefinition input) {
return !input.getName().equals("*");
}
};

/**
* Convert the NodeTypeManager to an RDF stream, including both
* primary and mixin node types.
* Convert the NodeTypeManager to an RDF stream, including both primary and
* mixin node types.
*
* @param nodeTypeManager
* @throws RepositoryException
*/
public NodeTypeRdfContext(final NodeTypeManager nodeTypeManager) throws RepositoryException {
public NodeTypeRdfContext(final NodeTypeManager nodeTypeManager)
throws RepositoryException {
super();

concat(new NodeTypeRdfContext(new NodeTypeIterator(nodeTypeManager.getPrimaryNodeTypes())));
concat(new NodeTypeRdfContext(new NodeTypeIterator(nodeTypeManager.getMixinNodeTypes())));
concat(new NodeTypeRdfContext(new NodeTypeIterator(nodeTypeManager
.getPrimaryNodeTypes())));
concat(new NodeTypeRdfContext(new NodeTypeIterator(nodeTypeManager
.getMixinNodeTypes())));

}

/**
* Convert a NodeType iterator into an RDF stream
*
* @param nodeTypeIterator
* @throws RepositoryException
*/
public NodeTypeRdfContext(final Iterable<NodeType> nodeTypeIterator) throws RepositoryException {
public NodeTypeRdfContext(final Iterable<NodeType> nodeTypeIterator)
throws RepositoryException {
super();

for (final NodeType t : nodeTypeIterator) {
Expand All @@ -92,66 +99,83 @@ public NodeTypeRdfContext(final Iterable<NodeType> nodeTypeIterator) throws Repo
}

/**
* Convert a NodeType into an RDF stream by capturing the supertypes,
* node definitions, and property definitions of the type as RDFS triples.
* Convert a NodeType into an RDF stream by capturing the supertypes, node
* definitions, and property definitions of the type as RDFS triples.
*
* @param nodeType
* @throws RepositoryException
*/
public NodeTypeRdfContext(final NodeType nodeType) throws RepositoryException {
public NodeTypeRdfContext(final NodeType nodeType)
throws RepositoryException {
super();

final ImmutableMap.Builder<String, String> namespaces =
ImmutableMap.builder();
final ImmutableCollection.Builder<Triple> nsTriples =
ImmutableSet.builder();

final Node nodeTypeResource = getResource((Namespaced)nodeType).asNode();
final Node nodeTypeResource =
getResource((Namespaced) nodeType).asNode();
final String nodeTypeName = nodeType.getName();

LOGGER.debug("Adding triples for nodeType {} with URI {}", nodeTypeName, nodeTypeResource.getURI());

nsTriples.add(create(nodeTypeResource, RDF.type.asNode(), RDFS.Class.asNode()));
nsTriples.add(create(nodeTypeResource, RDFS.label.asNode(), createLiteral(nodeTypeName)));

concat(transform(forArray(nodeType.getDeclaredSupertypes()), new Function<NodeType, Triple>() {
@Override
public Triple apply(NodeType input) {
final Node supertypeNode;
try {
supertypeNode = getResource(input).asNode();
LOGGER.trace("Adding triple for nodeType {} subclass {}", nodeTypeName, supertypeNode.getURI());
return create(nodeTypeResource, RDFS.subClassOf.asNode(), supertypeNode);

} catch (RepositoryException e) {
throw propagate(e);
}
}
}));

concat(Iterators.concat(transform(filter(forArray(nodeType.getDeclaredChildNodeDefinitions()), ignoreWildcardResidualDefinitions), new NodeDefinitionToTriples(nodeTypeResource))));

concat(Iterators.concat(transform(filter(forArray(nodeType.getDeclaredPropertyDefinitions()), ignoreWildcardResidualDefinitions), new PropertyDefinitionToTriples(nodeTypeResource))));

concat(nsTriples.build()).addNamespaces(namespaces.build());
LOGGER.debug("Adding triples for nodeType {} with URI {}",
nodeTypeName, nodeTypeResource.getURI());

nsTriples.add(create(nodeTypeResource, RDF.type.asNode(), RDFS.Class
.asNode()));
nsTriples.add(create(nodeTypeResource, RDFS.label.asNode(),
createLiteral(nodeTypeName)));

concat(Iterators.transform(forArray(nodeType.getDeclaredSupertypes()),
new Function<NodeType, Triple>() {

@Override
public Triple apply(final NodeType input) {
final Node supertypeNode;
try {
supertypeNode = getResource(input).asNode();
LOGGER.trace(
"Adding triple for nodeType {} subclass {}",
nodeTypeName, supertypeNode.getURI());
return create(nodeTypeResource,
subClassOf.asNode(), supertypeNode);

} catch (final RepositoryException e) {
throw propagate(e);
}
}
}));

concat(Iterators.concat(
Iterators.transform(Iterators.filter(
forArray(nodeType.getDeclaredChildNodeDefinitions()),
ignoreWildcardResidualDefinitions),
new NodeDefinitionToTriples(nodeTypeResource))));

concat(Iterators.concat(
Iterators.transform(Iterators.filter(
forArray(nodeType.getDeclaredPropertyDefinitions()),
ignoreWildcardResidualDefinitions),
new PropertyDefinitionToTriples(nodeTypeResource))));

concat(nsTriples.build());
}


/**
* Get a RDF Resource for a Namespaced JCR object
*
* @param namespacedObject
* @return
* @throws RepositoryException
*/
private Resource getResource(Namespaced namespacedObject) throws RepositoryException {
return ResourceFactory.createProperty(getRDFNamespaceForJcrNamespace(namespacedObject.getNamespaceURI()), namespacedObject.getLocalName()).asResource();
}

private Resource getResource(NodeType nodeType) throws RepositoryException {
return getResource((Namespaced) nodeType);
private Resource getResource(final Namespaced namespacedObject)
throws RepositoryException {
return createProperty(
getRDFNamespaceForJcrNamespace(namespacedObject
.getNamespaceURI()), namespacedObject.getLocalName())
.asResource();
}

private Resource getResource(ItemDefinition nodeType) throws RepositoryException {
private Resource getResource(final NodeType nodeType)
throws RepositoryException {
return getResource((Namespaced) nodeType);
}

Expand Down
Expand Up @@ -17,14 +17,12 @@
package org.fcrepo.kernel.rdf.impl.mappings;

import com.google.common.base.Function;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.graph.Triple;
import com.hp.hpl.jena.rdf.model.Resource;
import com.hp.hpl.jena.rdf.model.ResourceFactory;
import com.hp.hpl.jena.vocabulary.RDF;
import com.hp.hpl.jena.vocabulary.RDFS;

import org.fcrepo.kernel.utils.iterators.RdfStream;
import org.modeshape.jcr.api.Namespaced;
import org.slf4j.Logger;

Expand All @@ -36,13 +34,22 @@
import static com.google.common.base.Throwables.propagate;
import static com.hp.hpl.jena.graph.NodeFactory.createLiteral;
import static com.hp.hpl.jena.graph.Triple.create;
import static com.hp.hpl.jena.rdf.model.ResourceFactory.createProperty;
import static com.hp.hpl.jena.vocabulary.RDF.Property;
import static com.hp.hpl.jena.vocabulary.RDF.type;
import static com.hp.hpl.jena.vocabulary.RDFS.label;
import static org.fcrepo.kernel.utils.JcrRdfTools.getRDFNamespaceForJcrNamespace;
import static org.slf4j.LoggerFactory.getLogger;


/**
* Utility for moving generic Item Definitions into RDFS triples
* @author cbeer
* @author ajs6f
*
* @date Oct 2013
*
* @param <T>
*/
public class ItemDefinitionToTriples<T extends ItemDefinition> implements Function<T, Iterator<Triple>> {

Expand All @@ -60,26 +67,23 @@ public ItemDefinitionToTriples(final Node domain) {
}

@Override
public Iterator<Triple> apply(T input) {

final ImmutableCollection.Builder<Triple> nsTriples =
ImmutableSet.builder();
public Iterator<Triple> apply(final T input) {

try {

final Node propertyDefinitionNode = getResource(input).asNode();

LOGGER.trace("Adding triples for nodeType {} child nodes {}", domain.getURI(), propertyDefinitionNode.getURI());
LOGGER.trace("Adding triples for nodeType: {} with child nodes: {}", domain.getURI(), propertyDefinitionNode.getURI());

nsTriples.add(create(propertyDefinitionNode, RDF.type.asNode(), RDF.Property.asNode()));
nsTriples.add(create(propertyDefinitionNode, RDFS.domain.asNode(), domain));
nsTriples.add(create(propertyDefinitionNode, RDFS.label.asNode(), createLiteral(input.getName())));
return new RdfStream(
create(propertyDefinitionNode, type.asNode(), Property.asNode()),
create(propertyDefinitionNode, RDFS.domain.asNode(), domain),
create(propertyDefinitionNode, label.asNode(), createLiteral(input.getName())));

} catch (RepositoryException e) {
} catch (final RepositoryException e) {
throw propagate(e);
}

return nsTriples.build().iterator();
}

/**
Expand All @@ -89,15 +93,19 @@ public Iterator<Triple> apply(T input) {
* @return
* @throws javax.jcr.RepositoryException
*/
protected Resource getResource(Namespaced namespacedObject) throws RepositoryException {
return ResourceFactory.createProperty(getRDFNamespaceForJcrNamespace(namespacedObject.getNamespaceURI()), namespacedObject.getLocalName()).asResource();
protected Resource getResource(final Namespaced namespacedObject)
throws RepositoryException {
return createProperty(
getRDFNamespaceForJcrNamespace(namespacedObject
.getNamespaceURI()), namespacedObject.getLocalName())
.asResource();
}

protected Resource getResource(NodeType nodeType) throws RepositoryException {
protected Resource getResource(final NodeType nodeType) throws RepositoryException {
return getResource((Namespaced) nodeType);
}

protected Resource getResource(ItemDefinition nodeType) throws RepositoryException {
protected Resource getResource(final ItemDefinition nodeType) throws RepositoryException {
return getResource((Namespaced) nodeType);
}
}
Expand Up @@ -16,12 +16,10 @@

package org.fcrepo.kernel.rdf.impl.mappings;

import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterators;
import com.hp.hpl.jena.graph.Node;
import com.hp.hpl.jena.graph.Triple;
import com.hp.hpl.jena.vocabulary.RDFS;
import org.fcrepo.kernel.utils.iterators.RdfStream;
import org.slf4j.Logger;

import javax.jcr.RepositoryException;
Expand All @@ -31,6 +29,7 @@

import static com.google.common.base.Throwables.propagate;
import static com.hp.hpl.jena.graph.Triple.create;
import static com.hp.hpl.jena.vocabulary.RDFS.range;
import static org.slf4j.LoggerFactory.getLogger;

/**
Expand All @@ -46,17 +45,14 @@ public class NodeDefinitionToTriples extends ItemDefinitionToTriples<NodeDefinit
* the provided RDF Node
* @param domain
*/
public NodeDefinitionToTriples(Node domain) {
public NodeDefinitionToTriples(final Node domain) {
super(domain);
}

@Override
public Iterator<Triple> apply(NodeDefinition input) {
public Iterator<Triple> apply(final NodeDefinition input) {
final Iterator<Triple> itemDefinition = super.apply(input);

final ImmutableCollection.Builder<Triple> nsTriples =
ImmutableSet.builder();

try {

final Node propertyDefinitionNode = getResource(input).asNode();
Expand All @@ -68,15 +64,19 @@ public Iterator<Triple> apply(NodeDefinition input) {
LOGGER.trace("Skipping RDFS:range for {} with multiple primary types", propertyDefinitionNode.getName());
} else if (requiredPrimaryTypes.length == 1) {
LOGGER.trace("Adding RDFS:range for {} with primary types {}", input.getName(), requiredPrimaryTypes[0].getName());
nsTriples.add(create(propertyDefinitionNode, RDFS.range.asNode(), getResource(requiredPrimaryTypes[0]).asNode()));
final Triple nsTriple =
create(propertyDefinitionNode, range.asNode(), getResource(
requiredPrimaryTypes[0]).asNode());
return Iterators.concat(itemDefinition, new RdfStream(nsTriple));
} else {
LOGGER.trace("Skipping RDFS:range for {} with no required primary types");
}
return itemDefinition;

} catch (RepositoryException e) {
} catch (final RepositoryException e) {
throw propagate(e);
}

return Iterators.concat(itemDefinition, nsTriples.build().iterator());

}
}

0 comments on commit 4537610

Please sign in to comment.