[2/4] jena git commit: initial changes on perm-interface-refactor as part of fix for JENA-992

[cl...@apache.org]

http://git-wip-us.apache.org/repos/asf/jena/blob/1dd6cfd1/jena-permissions/src/main/java/org/apache/jena/permissions/model/impl/SecuredModelImpl.java
----------------------------------------------------------------------
diff --git a/jena-permissions/src/main/java/org/apache/jena/permissions/model/impl/SecuredModelImpl.java b/jena-permissions/src/main/java/org/apache/jena/permissions/model/impl/SecuredModelImpl.java
index 52f413a..f64372f 100644
--- a/jena-permissions/src/main/java/org/apache/jena/permissions/model/impl/SecuredModelImpl.java
+++ b/jena-permissions/src/main/java/org/apache/jena/permissions/model/impl/SecuredModelImpl.java
@@ -17,260 +17,196 @@
  */
 package org.apache.jena.permissions.model.impl;
 
-import java.io.* ;
-import java.net.URL ;
-import java.util.* ;
+import java.io.*;
+import java.net.URL;
+import java.util.*;
 import java.util.function.Predicate;
 
-import org.apache.jena.datatypes.RDFDatatype ;
-import org.apache.jena.graph.Node ;
-import org.apache.jena.graph.NodeFactory ;
-import org.apache.jena.graph.Triple ;
-import org.apache.jena.graph.impl.CollectionGraph ;
+import org.apache.jena.datatypes.RDFDatatype;
+import org.apache.jena.graph.Node;
+import org.apache.jena.graph.NodeFactory;
+import org.apache.jena.graph.Triple;
+import org.apache.jena.graph.impl.CollectionGraph;
+import org.apache.jena.permissions.SecuredItem;
 import org.apache.jena.permissions.SecurityEvaluator;
-import org.apache.jena.permissions.SecurityEvaluator.SecTriple;
 import org.apache.jena.permissions.graph.SecuredGraph;
 import org.apache.jena.permissions.graph.SecuredPrefixMapping;
 import org.apache.jena.permissions.impl.ItemHolder;
-import org.apache.jena.permissions.impl.SecuredItem;
 import org.apache.jena.permissions.impl.SecuredItemImpl;
 import org.apache.jena.permissions.impl.SecuredItemInvoker;
 import org.apache.jena.permissions.model.*;
-import org.apache.jena.rdf.model.* ;
-import org.apache.jena.rdf.model.impl.RDFReaderFImpl ;
-import org.apache.jena.shared.* ;
-import org.apache.jena.util.iterator.ExtendedIterator ;
-import org.apache.jena.util.iterator.WrappedIterator ;
-import org.apache.jena.vocabulary.RDF ;
+import org.apache.jena.rdf.model.*;
+import org.apache.jena.rdf.model.impl.RDFReaderFImpl;
+import org.apache.jena.shared.*;
+import org.apache.jena.util.iterator.ExtendedIterator;
+import org.apache.jena.util.iterator.WrappedIterator;
+import org.apache.jena.vocabulary.RDF;
 
 /**
  * Implementation of SecuredModel to be used by a SecuredItemInvoker proxy.
  */
-public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
-{
+public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel {
 
 	// a class that implements ModelChangedListener
-	private class SecuredModelChangedListener implements ModelChangedListener
-	{
+	private class SecuredModelChangedListener implements ModelChangedListener {
 		private final ModelChangedListener wrapped;
 
-		private SecuredModelChangedListener( final ModelChangedListener wrapped )
-		{
+		private SecuredModelChangedListener(final ModelChangedListener wrapped) {
 			this.wrapped = wrapped;
 		}
 
 		@Override
-		public void addedStatement( final Statement s )
-		{
-			if (canRead(s.asTriple()))
-			{
+		public void addedStatement(final Statement s) {
+			if (canRead(s)) {
 				wrapped.addedStatement(s);
 			}
 		}
 
 		@Override
-		public void addedStatements( final List<Statement> statements )
-		{
-			if (canRead(Triple.ANY))
-			{
+		public void addedStatements(final List<Statement> statements) {
+			if (canRead(Triple.ANY)) {
 				wrapped.addedStatements(statements);
-			}
-			else
-			{
+			} else {
 				final SecuredStatementIterator iter = new SecuredStatementIterator(
 						holder.getSecuredItem(),
 						WrappedIterator.create(statements.iterator()));
-				try
-				{
+				try {
 					wrapped.addedStatements(iter.toList());
-				}
-				finally
-				{
+				} finally {
 					iter.close();
 				}
 			}
 		}
 
 		@Override
-		public void addedStatements( final Model m )
-		{
-			if (canRead(Triple.ANY))
-			{
+		public void addedStatements(final Model m) {
+			if (canRead(Triple.ANY)) {
 				wrapped.addedStatements(m);
-			}
-			else
-			{
+			} else {
 				wrapped.addedStatements(SecuredModelImpl.getInstance(
 						holder.getSecuredItem(), m));
 			}
 		}
 
 		@Override
-		public void addedStatements( final Statement[] statements )
-		{
-			if (canRead(Triple.ANY))
-			{
+		public void addedStatements(final Statement[] statements) {
+			if (canRead(Triple.ANY)) {
 				wrapped.addedStatements(statements);
-			}
-			else
-			{
+			} else {
 				final SecuredStatementIterator iter = new SecuredStatementIterator(
 						holder.getSecuredItem(), WrappedIterator.create(Arrays
 								.asList(statements).iterator()));
-				try
-				{
+				try {
 					final List<Statement> stmts = iter.toList();
 					wrapped.addedStatements(stmts.toArray(new Statement[stmts
 							.size()]));
-				}
-				finally
-				{
+				} finally {
 					iter.close();
 				}
 			}
 		}
 
 		@Override
-		public void addedStatements( final StmtIterator statements )
-		{
-			if (canRead(Triple.ANY))
-			{
+		public void addedStatements(final StmtIterator statements) {
+			if (canRead(Triple.ANY)) {
 				wrapped.addedStatements(statements);
-			}
-			else
-			{
+			} else {
 				final SecuredStatementIterator iter = new SecuredStatementIterator(
 						holder.getSecuredItem(), statements);
-				try
-				{
+				try {
 					wrapped.addedStatements(iter);
-				}
-				finally
-				{
+				} finally {
 					iter.close();
 				}
 			}
 		}
 
 		@Override
-		public void notifyEvent( final Model m, final Object event )
-		{
+		public void notifyEvent(final Model m, final Object event) {
 			wrapped.notifyEvent(m, event);
 		}
 
 		@Override
-		public void removedStatement( final Statement s )
-		{
-			if (canRead(s.asTriple()))
-			{
+		public void removedStatement(final Statement s) {
+			if (canRead(s)) {
 				wrapped.removedStatement(s);
 			}
 		}
 
 		@Override
-		public void removedStatements( final List<Statement> statements )
-		{
+		public void removedStatements(final List<Statement> statements) {
 
-			if (canRead(Triple.ANY))
-			{
+			if (canRead(Triple.ANY)) {
 				wrapped.removedStatements(statements);
-			}
-			else
-			{
+			} else {
 				final SecuredStatementIterator iter = new SecuredStatementIterator(
 						holder.getSecuredItem(),
 						WrappedIterator.create(statements.iterator()));
-				try
-				{
+				try {
 					wrapped.removedStatements(iter.toList());
-				}
-				finally
-				{
+				} finally {
 					iter.close();
 				}
 			}
 		}
 
 		@Override
-		public void removedStatements( final Model m )
-		{
-			if (canRead(Triple.ANY))
-			{
+		public void removedStatements(final Model m) {
+			if (canRead(Triple.ANY)) {
 				wrapped.removedStatements(m);
-			}
-			else
-			{
+			} else {
 				wrapped.removedStatements(SecuredModelImpl.getInstance(
 						holder.getSecuredItem(), m));
 			}
 		}
 
 		@Override
-		public void removedStatements( final Statement[] statements )
-		{
-			if (canRead(Triple.ANY))
-			{
+		public void removedStatements(final Statement[] statements) {
+			if (canRead(Triple.ANY)) {
 				wrapped.removedStatements(statements);
-			}
-			else
-			{
+			} else {
 				final SecuredStatementIterator iter = new SecuredStatementIterator(
 						holder.getSecuredItem(), WrappedIterator.create(Arrays
 								.asList(statements).iterator()));
-				try
-				{
+				try {
 					final List<Statement> stmts = iter.toList();
 					wrapped.removedStatements(stmts.toArray(new Statement[stmts
 							.size()]));
-				}
-				finally
-				{
+				} finally {
 					iter.close();
 				}
 			}
 		}
 
 		@Override
-		public void removedStatements( final StmtIterator statements )
-		{
-			if (canRead(Triple.ANY))
-			{
+		public void removedStatements(final StmtIterator statements) {
+			if (canRead(Triple.ANY)) {
 				wrapped.removedStatements(statements);
-			}
-			else
-			{
+			} else {
 				final SecuredStatementIterator iter = new SecuredStatementIterator(
 						holder.getSecuredItem(), statements);
-				try
-				{
+				try {
 					wrapped.removedStatements(iter);
-				}
-				finally
-				{
+				} finally {
 					iter.close();
 				}
 			}
 		}
 	}
 
-	/*private class  ReadFilter extends Filter<Resource> {
-		private SecuredItem si;
-		private SecuredResource r;
-		private Property p;
-		ReadFilter( SecuredItem si, SecuredResource r, Property p )
-		{
-			this.si = si;
-			this.r = r;
-			this.p = p;
-		}
-		@Override
-		public boolean test(Resource o) {
-			Triple t = new Triple( r.asNode(), p.asNode(), o.asNode());
-			return si.canRead( SecuredItemImpl.convert( t ) );
-		}};
-*/
+	/*
+	 * private class ReadFilter extends Filter<Resource> { private SecuredItem
+	 * si; private SecuredResource r; private Property p; ReadFilter(
+	 * SecuredItem si, SecuredResource r, Property p ) { this.si = si; this.r =
+	 * r; this.p = p; }
+	 * 
+	 * @Override public boolean test(Resource o) { Triple t = new Triple(
+	 * r.asNode(), p.asNode(), o.asNode()); return si.canRead(
+	 * SecuredItemImpl.convert( t ) ); }};
+	 */
 	private static final RDFReaderF readerFactory = new RDFReaderFImpl();
-	//private static final RDFWriterF writerFactory = new RDFWriterFImpl();
+
+	// private static final RDFWriterF writerFactory = new RDFWriterFImpl();
 
 	/**
 	 * Get an instance of SecuredModel
@@ -281,9 +217,8 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	 *            the Model to secure.
 	 * @return The SecuredModel
 	 */
-	public static SecuredModel getInstance( final SecuredItem securedItem,
-			final Model model )
-	{
+	public static SecuredModel getInstance(final SecuredItem securedItem,
+			final Model model) {
 		return org.apache.jena.permissions.Factory.getInstance(
 				securedItem.getSecurityEvaluator(), securedItem.getModelIRI(),
 				model);
@@ -302,8 +237,7 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	 */
 	public static SecuredModel getInstance(
 			final SecurityEvaluator securityEvaluator, final String modelIRI,
-			final Model model )
-	{
+			final Model model) {
 		final ItemHolder<Model, SecuredModel> holder = new ItemHolder<Model, SecuredModel>(
 				model);
 
@@ -311,10 +245,8 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 				securityEvaluator, modelIRI, holder);
 		// if we are going to create a duplicate proxy, just return this
 		// one.
-		if (model instanceof SecuredModel)
-		{
-			if (checker.isEquivalent((SecuredModel) model))
-			{
+		if (model instanceof SecuredModel) {
+			if (checker.isEquivalent((SecuredModel) model)) {
 				return (SecuredModel) model;
 			}
 		}
@@ -341,51 +273,45 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	 * @param holder
 	 *            The item holder that will contain this SecuredModel.
 	 */
-	private SecuredModelImpl( final SecurityEvaluator securityEvaluator,
-			final String modelURI, final ItemHolder<Model, SecuredModel> holder )
-	{
+	private SecuredModelImpl(final SecurityEvaluator securityEvaluator,
+			final String modelURI, final ItemHolder<Model, SecuredModel> holder) {
 		super(securityEvaluator, modelURI, holder);
-		this.graph = org.apache.jena.permissions.Factory.getInstance(securityEvaluator, modelURI, holder
-				.getBaseItem().getGraph());
-		this.holder = holder; 
+		this.graph = org.apache.jena.permissions.Factory.getInstance(
+				securityEvaluator, modelURI, holder.getBaseItem().getGraph());
+		this.holder = holder;
+	}
+
+	private RDFNode asObject(Object o) {
+		return o instanceof RDFNode ? (RDFNode) o : ResourceFactory
+				.createTypedLiteral(o);
 	}
-	
-	 private RDFNode asObject( Object o )
-     { 
-		 return o instanceof RDFNode ? (RDFNode) o : ResourceFactory.createTypedLiteral( o ); 
-     }
 
 	@Override
-	public SecuredModel abort()
-	{
+	public SecuredModel abort() {
 		holder.getBaseItem().abort();
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel add( final List<Statement> statements )
-	{
+	public SecuredModel add(final List<Statement> statements) {
 		checkUpdate();
-		checkCreateStatement(WrappedIterator.create(statements.iterator()));
+		checkCreateFrontsTriples(WrappedIterator.create(statements.iterator()));
 		holder.getBaseItem().add(statements);
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel add( final Model m )
-	{
+	public SecuredModel add(final Model m) {
 		checkUpdate();
-		if (!canCreate(Triple.ANY))
-		{
-			checkCreateStatement(m.listStatements());
+		if (!canCreate(Triple.ANY)) {
+			checkCreateFrontsTriples(m.listStatements());
 		}
 		holder.getBaseItem().add(m);
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel add( final Resource s, final Property p, final RDFNode o )
-	{
+	public SecuredModel add(final Resource s, final Property p, final RDFNode o) {
 		checkUpdate();
 		checkCreate(new Triple(s.asNode(), p.asNode(), o.asNode()));
 		holder.getBaseItem().add(s, p, o);
@@ -393,62 +319,54 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	}
 
 	@Override
-	public SecuredModel add( final Resource s, final Property p, final String o )
-	{
-		return add( s, p, o, false );
+	public SecuredModel add(final Resource s, final Property p, final String o) {
+		return add(s, p, o, false);
 	}
 
 	@Override
-	public SecuredModel add( final Resource s, final Property p,
-			final String o, final boolean wellFormed )
-	{
+	public SecuredModel add(final Resource s, final Property p, final String o,
+			final boolean wellFormed) {
 		checkUpdate();
-		checkCreate(new Triple(s.asNode(), p.asNode(), NodeFactory.createLiteral(o,
-				"", wellFormed)));
+		checkCreate(new Triple(s.asNode(), p.asNode(),
+				NodeFactory.createLiteral(o, "", wellFormed)));
 		holder.getBaseItem().add(s, p, o, wellFormed);
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel add( final Resource s, final Property p,
-			final String lex, final RDFDatatype datatype )
-	{
+	public SecuredModel add(final Resource s, final Property p,
+			final String lex, final RDFDatatype datatype) {
 		checkUpdate();
-		checkCreate(new Triple(s.asNode(), p.asNode(), NodeFactory.createLiteral(lex,
-				datatype)));
+		checkCreate(new Triple(s.asNode(), p.asNode(),
+				NodeFactory.createLiteral(lex, datatype)));
 		holder.getBaseItem().add(s, p, lex, datatype);
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel add( final Resource s, final Property p,
-			final String o, final String l )
-	{
+	public SecuredModel add(final Resource s, final Property p, final String o,
+			final String l) {
 		checkUpdate();
-		checkCreate(new Triple(s.asNode(), p.asNode(), NodeFactory.createLiteral(o, l,
-				false)));
+		checkCreate(new Triple(s.asNode(), p.asNode(),
+				NodeFactory.createLiteral(o, l, false)));
 		holder.getBaseItem().add(s, p, o, l);
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel add( final Statement s )
-	{
+	public SecuredModel add(final Statement s) {
 		checkUpdate();
-		checkCreate(s.asTriple());
+		checkCreate(s);
 		holder.getBaseItem().add(s);
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel add( final Statement[] statements )
-	{
+	public SecuredModel add(final Statement[] statements) {
 		checkUpdate();
-		if (!canCreate(Triple.ANY))
-		{
-			for (final Statement s : statements)
-			{
-				checkCreate(s.asTriple());
+		if (!canCreate(Triple.ANY)) {
+			for (final Statement s : statements) {
+				checkCreate(s);
 			}
 		}
 		holder.getBaseItem().add(statements);
@@ -457,386 +375,314 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	}
 
 	@Override
-	public SecuredModel add( final StmtIterator iter )
-	{
+	public SecuredModel add(final StmtIterator iter) {
 		checkUpdate();
-		if (!canCreate(Triple.ANY))
-		{
+		if (!canCreate(Triple.ANY)) {
 			final List<Triple> lst = new ArrayList<Triple>();
-			try
-			{
-				while (iter.hasNext())
-				{
+			try {
+				while (iter.hasNext()) {
 					final Statement s = iter.next();
-					checkCreate(s.asTriple());
+					checkCreate(s);
 					lst.add(s.asTriple());
 				}
 				final Model m = ModelFactory
 						.createModelForGraph(new CollectionGraph(lst));
 				holder.getBaseItem().add(m.listStatements());
-			}
-			finally
-			{
+			} finally {
 				iter.close();
 			}
-		}
-		else
-		{
+		} else {
 			holder.getBaseItem().add(iter);
 		}
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final boolean o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final boolean o) {
 		final Literal l = ResourceFactory.createTypedLiteral(o);
-		if (l == null)
-		{
-			throw new IllegalArgumentException( "HOw did we get a null");
+		if (l == null) {
+			throw new IllegalArgumentException("HOw did we get a null");
 		}
 		return add(s, p, l);
 	}
 
 	@Override
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final char o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final char o) {
 		final Literal l = ResourceFactory.createTypedLiteral(o);
 		return add(s, p, l);
 	}
 
 	@Override
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final double o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final double o) {
 		final Literal l = ResourceFactory.createTypedLiteral(o);
 		return add(s, p, l);
 	}
 
 	@Override
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final float o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final float o) {
 		final Literal l = ResourceFactory.createTypedLiteral(o);
 		return add(s, p, l);
 	}
 
 	@Override
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final int o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final int o) {
 		final Literal l = ResourceFactory.createTypedLiteral(o);
 		return add(s, p, l);
 	}
 
 	@Override
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final Literal o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final Literal o) {
 		return add(s, p, o);
 	}
 
 	@Override
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final long o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final long o) {
 		final Literal l = ResourceFactory.createTypedLiteral(o);
 		return add(s, p, l);
 	}
 
 	@Override
 	@Deprecated
-	public SecuredModel addLiteral( final Resource s, final Property p,
-			final Object o )
-	{
+	public SecuredModel addLiteral(final Resource s, final Property p,
+			final Object o) {
 		return add(s, p, asObject(o));
 	}
 
 	@Override
-	public SecuredRDFNode asRDFNode( final Node n )
-	{
-		return SecuredRDFNodeImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.asRDFNode(n));
+	public SecuredRDFNode asRDFNode(final Node n) {
+		return SecuredRDFNodeImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().asRDFNode(n));
 	}
 
 	@Override
-	public SecuredStatement asStatement( final Triple t )
-	{
+	public SecuredStatement asStatement(final Triple t) {
 		final ExtendedIterator<Triple> iter = holder.getBaseItem().getGraph()
 				.find(t);
 		final boolean exists = iter.hasNext();
 		iter.close();
-		if (exists)
-		{
+		if (exists) {
 			checkRead();
 			checkRead(t);
-		}
-		else
-		{
+		} else {
 			checkUpdate();
 			checkCreate(t);
 		}
-		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.asStatement(t));
+		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().asStatement(t));
 	}
 
 	@Override
-	public SecuredModel begin()
-	{
+	public SecuredModel begin() {
 		holder.getBaseItem().begin();
 		return holder.getSecuredItem();
 	}
 
-	private void checkCreate( final SecurityEvaluator.SecNode n, final Triple t )
-	{
-		checkRead(t);
-		checkCreate(new SecurityEvaluator.SecTriple(n,
-				SecuredItemImpl.convert(RDF.subject.asNode()),
-				SecuredItemImpl.convert(t.getSubject())));
-		checkCreate(new SecurityEvaluator.SecTriple(n,
-				SecuredItemImpl.convert(RDF.predicate.asNode()),
-				SecuredItemImpl.convert(t.getPredicate())));
-		checkCreate(new SecurityEvaluator.SecTriple(n,
-				SecuredItemImpl.convert(RDF.object.asNode()),
-				SecuredItemImpl.convert(t.getObject())));
-	}
+	// private void checkCreate( final Node n, final Triple t )
+	// {
+	// checkRead(t);
+	// checkCreate(new SecurityEvaluator.SecTriple(n,
+	// SecuredItemImpl.convert(RDF.subject.asNode()),
+	// SecuredItemImpl.convert(t.getSubject())));
+	// checkCreate(new SecurityEvaluator.SecTriple(n,
+	// SecuredItemImpl.convert(RDF.predicate.asNode()),
+	// SecuredItemImpl.convert(t.getPredicate())));
+	// checkCreate(new SecurityEvaluator.SecTriple(n,
+	// SecuredItemImpl.convert(RDF.object.asNode()),
+	// SecuredItemImpl.convert(t.getObject())));
+	// }
 
 	/*
 	 * private void checkCreateAnonymousResource( final
-	 * SecurityEvaluator.SecNode n )
-	 * {
-	 * checkUpdate();
-	 * final SecurityEvaluator.SecTriple t = new SecurityEvaluator.SecTriple(n,
+	 * SecurityEvaluator.SecNode n ) { checkUpdate(); final
+	 * SecurityEvaluator.SecTriple t = new SecurityEvaluator.SecTriple(n,
 	 * SecurityEvaluator.SecNode.IGNORE, SecurityEvaluator.SecNode.IGNORE);
-	 * checkCreate(t);
-	 * }
+	 * checkCreate(t); }
 	 */
 	@Override
-	public void close()
-	{
+	public void close() {
 		holder.getBaseItem().close();
 	}
 
 	@Override
-	public SecuredModel commit()
-	{
+	public SecuredModel commit() {
 		holder.getBaseItem().commit();
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public boolean contains( final Resource s, final Property p )
-	{
+	public boolean contains(final Resource s, final Property p) {
 		checkRead();
 		final SecuredStatementIterator iter = new SecuredStatementIterator(
-				holder.getSecuredItem(), holder.getBaseItem().listStatements(s, p, (RDFNode) null));
-		try
-		{
+				holder.getSecuredItem(), holder.getBaseItem().listStatements(s,
+						p, (RDFNode) null));
+		try {
 			return iter.hasNext();
-		}
-		finally
-		{
+		} finally {
 			iter.close();
 		}
 	}
 
 	@Override
-	public boolean contains( final Resource s, final Property p, final RDFNode o )
-	{
+	public boolean contains(final Resource s, final Property p, final RDFNode o) {
 		checkRead();
 		final SecuredStatementIterator iter = new SecuredStatementIterator(
-				holder.getSecuredItem(), holder.getBaseItem().listStatements(s, p, o));
-		try
-		{
+				holder.getSecuredItem(), holder.getBaseItem().listStatements(s,
+						p, o));
+		try {
 			return iter.hasNext();
-		}
-		finally
-		{
+		} finally {
 			iter.close();
 		}
 	}
 
 	@Override
-	public boolean contains( final Resource s, final Property p, final String o )
-	{
+	public boolean contains(final Resource s, final Property p, final String o) {
 		checkRead();
 		final SecuredStatementIterator iter = new SecuredStatementIterator(
-				holder.getSecuredItem(), holder.getBaseItem().listStatements(s, p, o));
-		try
-		{
+				holder.getSecuredItem(), holder.getBaseItem().listStatements(s,
+						p, o));
+		try {
 			return iter.hasNext();
-		}
-		finally
-		{
+		} finally {
 			iter.close();
 		}
 	}
 
 	@Override
-	public boolean contains( final Resource s, final Property p,
-			final String o, final String l )
-	{
+	public boolean contains(final Resource s, final Property p, final String o,
+			final String l) {
 		checkRead();
 		final SecuredStatementIterator iter = new SecuredStatementIterator(
-				holder.getSecuredItem(), holder.getBaseItem().listStatements(s, p, o, l));
-		try
-		{
+				holder.getSecuredItem(), holder.getBaseItem().listStatements(s,
+						p, o, l));
+		try {
 			return iter.hasNext();
-		}
-		finally
-		{
+		} finally {
 			iter.close();
 		}
 	}
 
 	@Override
-	public boolean contains( final Statement s )
-	{
+	public boolean contains(final Statement s) {
 		checkRead();
 		checkRead(s);
 		return holder.getBaseItem().contains(s);
 	}
 
 	@Override
-	public boolean containsAll( final Model model )
-	{
+	public boolean containsAll(final Model model) {
 		return containsAll(model.listStatements());
 	}
 
 	@Override
-	public boolean containsAll( final StmtIterator iter )
-	{
+	public boolean containsAll(final StmtIterator iter) {
 		checkRead();
 		final boolean doCheck = canRead(Triple.ANY);
-		try
-		{
-			while (iter.hasNext())
-			{
+		try {
+			while (iter.hasNext()) {
 				final Statement stmt = iter.next();
-				if (doCheck)
-				{
+				if (doCheck) {
 					checkRead(stmt);
 				}
-				if (!holder.getBaseItem().contains(stmt))
-				{
+				if (!holder.getBaseItem().contains(stmt)) {
 					return false;
 				}
 			}
 			return true;
-		}
-		finally
-		{
+		} finally {
 			iter.close();
 		}
 	}
 
 	@Override
-	public boolean containsAny( final Model model )
-	{
+	public boolean containsAny(final Model model) {
 		return containsAny(model.listStatements());
 
 	}
 
 	@Override
-	public boolean containsAny( final StmtIterator iter )
-	{
+	public boolean containsAny(final StmtIterator iter) {
 		checkRead();
 		final boolean skipCheck = canRead(Triple.ANY);
-		try
-		{
-			while (iter.hasNext())
-			{
+		try {
+			while (iter.hasNext()) {
 				final Statement stmt = iter.next();
-				if (skipCheck || canRead(stmt))
-				{
-					if (holder.getBaseItem().contains(stmt))
-					{
+				if (skipCheck || canRead(stmt)) {
+					if (holder.getBaseItem().contains(stmt)) {
 						return true;
 					}
 				}
 			}
 			return false;
-		}
-		finally
-		{
+		} finally {
 			iter.close();
 		}
 	}
 
 	@Override
-	public boolean containsLiteral( final Resource s, final Property p,
-			final boolean o )
-	{
+	public boolean containsLiteral(final Resource s, final Property p,
+			final boolean o) {
 		return contains(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public boolean containsLiteral( final Resource s, final Property p,
-			final char o )
-	{
+	public boolean containsLiteral(final Resource s, final Property p,
+			final char o) {
 		return contains(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public boolean containsLiteral( final Resource s, final Property p,
-			final double o )
-	{
+	public boolean containsLiteral(final Resource s, final Property p,
+			final double o) {
 		return contains(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public boolean containsLiteral( final Resource s, final Property p,
-			final float o )
-	{
+	public boolean containsLiteral(final Resource s, final Property p,
+			final float o) {
 		return contains(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public boolean containsLiteral( final Resource s, final Property p,
-			final int o )
-	{
+	public boolean containsLiteral(final Resource s, final Property p,
+			final int o) {
 		return contains(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public boolean containsLiteral( final Resource s, final Property p,
-			final long o )
-	{
+	public boolean containsLiteral(final Resource s, final Property p,
+			final long o) {
 		return contains(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public boolean containsLiteral( final Resource s, final Property p,
-			final Object o )
-	{
+	public boolean containsLiteral(final Resource s, final Property p,
+			final Object o) {
 		return contains(s, p, asObject(o));
 	}
 
 	@Override
-	public boolean containsResource( final RDFNode r )
-	{
+	public boolean containsResource(final RDFNode r) {
 		checkRead();
-		if (canRead(new Triple(Node.ANY, Node.ANY, Node.ANY)))
-		{
+		if (canRead(new Triple(Node.ANY, Node.ANY, Node.ANY))) {
 			return holder.getBaseItem().containsResource(r);
-		}
-		else
-		{
+		} else {
 			ExtendedIterator<Statement> iter = listStatements(null, null, r);
-			if (r.isResource())
-			{
+			if (r.isResource()) {
 
-				if (r.isURIResource())
-				{
+				if (r.isURIResource()) {
 					iter = iter
 							.andThen(listStatements(null, ResourceFactory
 									.createProperty(r.asNode().getURI()),
 									(RDFNode) null));
-				}
-				else
-				{
+				} else {
 					iter = iter.andThen(listStatements(null, ResourceFactory
 							.createProperty(r.asNode().getBlankNodeLabel()),
 							(RDFNode) null));
@@ -844,695 +690,567 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 				iter = iter.andThen(listStatements(r.asResource(), null,
 						(RDFNode) null));
 			}
-			try
-			{
+			try {
 				return iter.hasNext();
-			}
-			finally
-			{
+			} finally {
 				iter.close();
 			}
 		}
 	}
 
 	@Override
-	public SecuredAlt createAlt()
-	{
+	public SecuredAlt createAlt() {
 		checkUpdate();
-		checkCreate(new SecurityEvaluator.SecTriple(
-				SecurityEvaluator.SecNode.FUTURE,
-				SecuredItemImpl.convert(RDF.type.asNode()),
-				SecuredItemImpl.convert(RDF.Alt.asNode())));
-		return SecuredAltImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createAlt());
+		checkCreate(new Triple(SecurityEvaluator.FUTURE, RDF.type.asNode(),
+				RDF.Alt.asNode()));
+		return SecuredAltImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createAlt());
 	}
 
 	@Override
-	public SecuredAlt createAlt( final String uri )
-	{
+	public SecuredAlt createAlt(final String uri) {
 		checkUpdate();
 		checkCreate(new Triple(NodeFactory.createURI(uri), RDF.type.asNode(),
 				RDF.Alt.asNode()));
-		return SecuredAltImpl.getInstance(holder.getSecuredItem(),
-				holder.getBaseItem().createAlt(uri));
+		return SecuredAltImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createAlt(uri));
 	}
 
 	@Override
-	public SecuredBag createBag()
-	{
+	public SecuredBag createBag() {
 		checkUpdate();
-		checkCreate(new SecurityEvaluator.SecTriple(
-				SecurityEvaluator.SecNode.FUTURE,
-				SecuredItemImpl.convert(RDF.type.asNode()),
-				SecuredItemImpl.convert(RDF.Bag.asNode())));
-		return SecuredBagImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createBag());
+		checkCreate(new Triple(SecurityEvaluator.FUTURE,
+				RDF.type.asNode(),
+				RDF.Bag.asNode()));
+		return SecuredBagImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createBag());
 	}
 
 	@Override
-	public SecuredBag createBag( final String uri )
-	{
+	public SecuredBag createBag(final String uri) {
 		checkUpdate();
 		checkCreate(new Triple(NodeFactory.createURI(uri), RDF.type.asNode(),
 				RDF.Bag.asNode()));
-		return SecuredBagImpl.getInstance(holder.getSecuredItem(),
-				holder.getBaseItem().createBag(uri));
+		return SecuredBagImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createBag(uri));
 	}
 
-	private Model createCopy()
-	{
+	private Model createCopy() {
 		return ModelFactory.createDefaultModel().add(holder.getSecuredItem());
 	}
 
 	@Override
-	public SecuredRDFList createList()
-	{
+	public SecuredRDFList createList() {
 		checkUpdate();
-		return SecuredRDFListImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createList());
+		return SecuredRDFListImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createList());
 	}
 
 	@Override
-	public SecuredRDFList createList( final Iterator<? extends RDFNode> members )
-	{
+	public SecuredRDFList createList(final Iterator<? extends RDFNode> members) {
 		checkUpdate();
-		checkCreate(new SecurityEvaluator.SecTriple(
-				SecurityEvaluator.SecNode.FUTURE,
-				SecuredItemImpl.convert(RDF.rest.asNode()),
-				SecurityEvaluator.SecNode.FUTURE));
-		if (!(canCreate(new SecurityEvaluator.SecTriple(
-				SecurityEvaluator.SecNode.FUTURE,
-				SecuredItemImpl.convert(RDF.first.asNode()),
-				SecuredItemImpl.convert(Node.ANY)))))
-		{
+		checkCreate(new Triple(SecurityEvaluator.FUTURE, RDF.rest.asNode(),
+				SecurityEvaluator.FUTURE));
+
+		boolean canCreateAny = canCreate(new Triple(SecurityEvaluator.FUTURE,
+				RDF.first.asNode(), Node.ANY));
+		if (!canCreateAny) {
+			// have to check each of the possible entries in the list for
+			// creation.
 			final List<RDFNode> nodes = new ArrayList<RDFNode>();
-			while (members.hasNext())
-			{
+			while (members.hasNext()) {
 
 				final RDFNode n = members.next();
-				checkCreate(new SecurityEvaluator.SecTriple(
-						SecurityEvaluator.SecNode.FUTURE,
-						SecuredItemImpl.convert(RDF.first.asNode()),
-						SecuredItemImpl.convert(n.asNode())));
+				checkCreate(new Triple(SecurityEvaluator.FUTURE,
+						RDF.first.asNode(), n.asNode()));
 				nodes.add(n);
 			}
-			return SecuredRDFListImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-					.createList(nodes.iterator()));
+			return SecuredRDFListImpl.getInstance(holder.getSecuredItem(),
+					holder.getBaseItem().createList(nodes.iterator()));
 
-		}
-		else
-		{
-			return SecuredRDFListImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-					.createList(members));
+		} else {
+			return SecuredRDFListImpl.getInstance(holder.getSecuredItem(),
+					holder.getBaseItem().createList(members));
 		}
 	}
 
 	@Override
-	public SecuredRDFList createList( final RDFNode[] members )
-	{
+	public SecuredRDFList createList(final RDFNode[] members) {
 		return createList(Arrays.asList(members).iterator());
 	}
 
 	@Override
-	public SecuredLiteral createLiteral( final String v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createLiteral(v));
+	public SecuredLiteral createLiteral(final String v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createLiteral( final String v,
-			final boolean wellFormed )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createLiteral(v, wellFormed));
+	public SecuredLiteral createLiteral(final String v, final boolean wellFormed) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createLiteral(v, wellFormed));
 
 	}
 
 	@Override
-	public SecuredLiteral createLiteral( final String v, final String language )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createLiteral(v, language));
+	public SecuredLiteral createLiteral(final String v, final String language) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createLiteral(v, language));
 	}
 
 	@Override
-	public SecuredStatement createLiteralStatement( final Resource s,
-			final Property p, final boolean o )
-	{
-		return createStatement(s, p,
-				ResourceFactory.createTypedLiteral(o));
+	public SecuredStatement createLiteralStatement(final Resource s,
+			final Property p, final boolean o) {
+		return createStatement(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public SecuredStatement createLiteralStatement( final Resource s,
-			final Property p, final char o )
-	{
-		return createStatement(s, p,
-				ResourceFactory.createTypedLiteral(o));
+	public SecuredStatement createLiteralStatement(final Resource s,
+			final Property p, final char o) {
+		return createStatement(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public SecuredStatement createLiteralStatement( final Resource s,
-			final Property p, final double o )
-	{
-		return createStatement(s, p,
-				ResourceFactory.createTypedLiteral(o));
+	public SecuredStatement createLiteralStatement(final Resource s,
+			final Property p, final double o) {
+		return createStatement(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public SecuredStatement createLiteralStatement( final Resource s,
-			final Property p, final float o )
-	{
-		return createStatement(s, p,
-				ResourceFactory.createTypedLiteral(o));
+	public SecuredStatement createLiteralStatement(final Resource s,
+			final Property p, final float o) {
+		return createStatement(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public SecuredStatement createLiteralStatement( final Resource s,
-			final Property p, final int o )
-	{
-		return createStatement(s, p,
-				ResourceFactory.createTypedLiteral(o));
+	public SecuredStatement createLiteralStatement(final Resource s,
+			final Property p, final int o) {
+		return createStatement(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public SecuredStatement createLiteralStatement( final Resource s,
-			final Property p, final long o )
-	{
-		return createStatement(s, p,
-				ResourceFactory.createTypedLiteral(o));
+	public SecuredStatement createLiteralStatement(final Resource s,
+			final Property p, final long o) {
+		return createStatement(s, p, ResourceFactory.createTypedLiteral(o));
 	}
 
 	@Override
-	public SecuredStatement createLiteralStatement( final Resource s,
-			final Property p, final Object o )
-	{
+	public SecuredStatement createLiteralStatement(final Resource s,
+			final Property p, final Object o) {
 		return createStatement(s, p, asObject(o));
 	}
 
 	@Override
-	public SecuredProperty createProperty( final String uri )
-	{
-		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createProperty(uri));
+	public SecuredProperty createProperty(final String uri) {
+		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createProperty(uri));
 	}
 
 	@Override
-	public SecuredProperty createProperty( final String nameSpace,
-			final String localName )
-	{
+	public SecuredProperty createProperty(final String nameSpace,
+			final String localName) {
 		checkUpdate();
-		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createProperty(nameSpace, localName));
+		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createProperty(nameSpace, localName));
 	}
 
 	@Override
-	public ReifiedStatement createReifiedStatement( final Statement s )
-	{
+	public ReifiedStatement createReifiedStatement(final Statement s) {
 		checkUpdate();
-		checkCreate(SecurityEvaluator.SecNode.FUTURE, s.asTriple());
-		return SecuredReifiedStatementImpl.getInstance(holder.getSecuredItem(), holder
-				.getBaseItem().createReifiedStatement(s));
+		checkCreateReified(null, s);
+		return SecuredReifiedStatementImpl.getInstance(holder.getSecuredItem(),
+				holder.getBaseItem().createReifiedStatement(s));
 	}
 
 	@Override
-	public ReifiedStatement createReifiedStatement( final String uri,
-			final Statement s )
-	{
+	public ReifiedStatement createReifiedStatement(final String uri,
+			final Statement s) {
 		checkUpdate();
-		checkCreate(new SecurityEvaluator.SecNode(
-				SecurityEvaluator.SecNode.Type.URI, uri), s.asTriple());
-		return SecuredReifiedStatementImpl.getInstance(holder.getSecuredItem(), holder
-				.getBaseItem().createReifiedStatement(uri, s));
+		checkCreateReified(uri, s);
+		return SecuredReifiedStatementImpl.getInstance(holder.getSecuredItem(),
+				holder.getBaseItem().createReifiedStatement(uri, s));
 	}
 
 	@Override
-	public SecuredResource createResource()
-	{
-		// checkCreateAnonymousResource(SecurityEvaluator.SecNode.FUTURE);
-		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createResource());
+	public SecuredResource createResource() {
+		// checkCreateAnonymousResource(SecurityEvaluator.FUTURE);
+		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createResource());
 	}
 
 	@Override
-	public SecuredResource createResource( final AnonId id )
-	{
+	public SecuredResource createResource(final AnonId id) {
 		// checkCreateAnonymousResource(new SecurityEvaluator.SecNode(
 		// SecurityEvaluator.SecNode.Type.Anonymous, id.getLabelString()));
-		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createResource(id));
+		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createResource(id));
 	}
 
 	@Override
-	public SecuredResource createResource( final Resource type )
-	{
+	public SecuredResource createResource(final Resource type) {
 		checkUpdate();
-		final SecurityEvaluator.SecTriple t = new SecurityEvaluator.SecTriple(
-				SecurityEvaluator.SecNode.FUTURE,
-				SecuredItemImpl.convert(RDF.type.asNode()),
-				SecuredItemImpl.convert(type.asNode()));
+		final Triple t = new Triple(SecurityEvaluator.FUTURE,
+				RDF.type.asNode(), type.asNode());
 		checkCreate(t);
 
-		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createResource(type));
+		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createResource(type));
 	}
 
 	@Override
 	@Deprecated
-	public SecuredResource createResource( final ResourceF f )
-	{
+	public SecuredResource createResource(final ResourceF f) {
 		return createResource(null, f);
 	}
 
 	@Override
-	public SecuredResource createResource( final String uri )
-	{
-		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createResource(uri));
+	public SecuredResource createResource(final String uri) {
+		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createResource(uri));
 
 	}
 
 	@Override
-	public SecuredResource createResource( final String uri, final Resource type )
-	{
+	public SecuredResource createResource(final String uri, final Resource type) {
 		final Resource r = ResourceFactory.createResource(uri);
-		final SecurityEvaluator.SecTriple t = new SecurityEvaluator.SecTriple(
-				SecuredItemImpl.convert(r.asNode()),
-				SecuredItemImpl.convert(RDF.type.asNode()),
-				SecuredItemImpl.convert(type.asNode()));
-		if (holder.getBaseItem().contains(r, RDF.type, type))
-		{
+		final Triple t = new Triple(r.asNode(), RDF.type.asNode(),
+				type.asNode());
+		if (holder.getBaseItem().contains(r, RDF.type, type)) {
 			checkRead();
 			checkRead(t);
-		}
-		else
-		{
+		} else {
 			checkUpdate();
 			checkCreate(t);
 		}
-		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createResource(uri, type));
+		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createResource(uri, type));
 
 	}
 
 	@Override
 	@Deprecated
-	public SecuredResource createResource( final String uri, final ResourceF f )
-	{
-		// Resource resource = f.createResource( ResourceFactory.createResource( uri )
-		// );
-		// checkCreateResource( resource );
-		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createResource(uri, f));
+	public SecuredResource createResource(final String uri, final ResourceF f) {
+		return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createResource(uri, f));
 	}
 
 	@Override
-	public SecuredSeq createSeq()
-	{
+	public SecuredSeq createSeq() {
 		checkUpdate();
-		checkCreate(new SecurityEvaluator.SecTriple(
-				SecurityEvaluator.SecNode.FUTURE,
-				SecuredItemImpl.convert(RDF.type.asNode()),
-				SecuredItemImpl.convert(RDF.Alt.asNode())));
-		return SecuredSeqImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createSeq());
+		checkCreate(new Triple(SecurityEvaluator.FUTURE,
+				RDF.type.asNode(),
+				RDF.Alt.asNode()));
+		return SecuredSeqImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createSeq());
 	}
 
 	@Override
-	public SecuredSeq createSeq( final String uri )
-	{
+	public SecuredSeq createSeq(final String uri) {
 		checkUpdate();
 		checkCreate(new Triple(NodeFactory.createURI(uri), RDF.type.asNode(),
 				RDF.Alt.asNode()));
-		return SecuredSeqImpl.getInstance(holder.getSecuredItem(),
-				holder.getBaseItem().createSeq(uri));
+		return SecuredSeqImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createSeq(uri));
 	}
 
 	@Override
-	public SecuredStatement createStatement( final Resource s,
-			final Property p, final RDFNode o )
-	{
+	public SecuredStatement createStatement(final Resource s, final Property p,
+			final RDFNode o) {
 		checkUpdate();
 		checkCreate(new Triple(s.asNode(), p.asNode(), o.asNode()));
-		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createStatement(s, p, o));
+		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createStatement(s, p, o));
 	}
 
 	@Override
-	public SecuredStatement createStatement( final Resource s,
-			final Property p, final String o )
-	{
+	public SecuredStatement createStatement(final Resource s, final Property p,
+			final String o) {
 		checkUpdate();
 		checkCreate(new Triple(s.asNode(), p.asNode(), NodeFactory.createURI(o)));
-		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createStatement(s, p, o));
+		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createStatement(s, p, o));
 	}
 
 	@Override
-	public SecuredStatement createStatement( final Resource s,
-			final Property p, final String o, final boolean wellFormed )
-	{
+	public SecuredStatement createStatement(final Resource s, final Property p,
+			final String o, final boolean wellFormed) {
 		return createStatement(s, p, o, "", wellFormed);
 	}
 
 	@Override
-	public SecuredStatement createStatement( final Resource s,
-			final Property p, final String o, final String l )
-	{
+	public SecuredStatement createStatement(final Resource s, final Property p,
+			final String o, final String l) {
 		return createStatement(s, p, o, l, false);
 	}
 
 	@Override
-	public SecuredStatement createStatement( final Resource s,
-			final Property p, final String o, final String l,
-			final boolean wellFormed )
-	{
+	public SecuredStatement createStatement(final Resource s, final Property p,
+			final String o, final String l, final boolean wellFormed) {
 		checkUpdate();
-		checkCreate(new Triple(s.asNode(), p.asNode(), NodeFactory.createLiteral(o, l,
-				wellFormed)));
-		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createStatement(s, p, o, l, wellFormed));
+		checkCreate(new Triple(s.asNode(), p.asNode(),
+				NodeFactory.createLiteral(o, l, wellFormed)));
+		return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createStatement(s, p, o, l, wellFormed));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final boolean v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(v));
+	public SecuredLiteral createTypedLiteral(final boolean v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final Calendar d )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(d));
+	public SecuredLiteral createTypedLiteral(final Calendar d) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(d));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final char v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(v));
+	public SecuredLiteral createTypedLiteral(final char v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final double v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(v));
+	public SecuredLiteral createTypedLiteral(final double v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final float v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(v));
+	public SecuredLiteral createTypedLiteral(final float v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final int v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(v));
+	public SecuredLiteral createTypedLiteral(final int v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final long v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(v));
+	public SecuredLiteral createTypedLiteral(final long v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final Object value )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(value));
+	public SecuredLiteral createTypedLiteral(final Object value) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(value));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final Object value,
-			final RDFDatatype dtype )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(value, dtype));
+	public SecuredLiteral createTypedLiteral(final Object value,
+			final RDFDatatype dtype) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(value, dtype));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final Object value,
-			final String typeURI )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(value, typeURI));
+	public SecuredLiteral createTypedLiteral(final Object value,
+			final String typeURI) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(value, typeURI));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final String v )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(v));
+	public SecuredLiteral createTypedLiteral(final String v) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(v));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final String lex,
-			final RDFDatatype dtype )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(lex, dtype));
+	public SecuredLiteral createTypedLiteral(final String lex,
+			final RDFDatatype dtype) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(lex, dtype));
 	}
 
 	@Override
-	public SecuredLiteral createTypedLiteral( final String lex,
-			final String typeURI )
-	{
-		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.createTypedLiteral(lex, typeURI));
+	public SecuredLiteral createTypedLiteral(final String lex,
+			final String typeURI) {
+		return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().createTypedLiteral(lex, typeURI));
 	}
 
 	@Override
-	public Model difference( final Model model )
-	{
+	public Model difference(final Model model) {
 		checkRead();
-		if (canRead(Triple.ANY))
-		{
+		if (canRead(Triple.ANY)) {
 			return holder.getBaseItem().difference(model);
-		}
-		else
-		{
+		} else {
 			return createCopy().difference(model);
 		}
 	}
 
 	@Override
-	public void enterCriticalSection( final boolean readLockRequested )
-	{
-		if (readLockRequested)
-		{
+	public void enterCriticalSection(final boolean readLockRequested) {
+		if (readLockRequested) {
 			checkRead();
-		}
-		else
-		{
+		} else {
 			checkUpdate();
 		}
 		holder.getBaseItem().enterCriticalSection(readLockRequested);
 	}
 
 	@Override
-	public Object executeInTransaction( final Command cmd )
-	{
+	public Object executeInTransaction(final Command cmd) {
 		return holder.getBaseItem().executeInTransaction(cmd);
 	}
 
 	@Override
-	public String expandPrefix( final String prefixed )
-	{
+	public String expandPrefix(final String prefixed) {
 		checkRead();
 		return holder.getBaseItem().expandPrefix(prefixed);
 	}
 
 	@Override
-	public SecuredAlt getAlt( final Resource r )
-	{
+	public SecuredAlt getAlt(final Resource r) {
 		checkRead();
 		checkRead(new Triple(r.asNode(), RDF.type.asNode(), RDF.Alt.asNode()));
-		return SecuredAltImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem().getAlt(r));
+		return SecuredAltImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getAlt(r));
 	}
 
 	@Override
-	public SecuredAlt getAlt( final String uri )
-	{
+	public SecuredAlt getAlt(final String uri) {
 		checkRead();
 		checkRead(new Triple(NodeFactory.createURI(uri), RDF.type.asNode(),
 				RDF.Alt.asNode()));
-		return SecuredAltImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.getAlt(uri));
+		return SecuredAltImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getAlt(uri));
 	}
 
 	@Override
-	public SecuredResource getAnyReifiedStatement( final Statement s )
-	{
+	public SecuredResource getAnyReifiedStatement(final Statement s) {
 		final RSIterator it = listReifiedStatements(s);
-		if (it.hasNext())
-		{
-			try
-			{
-				return SecuredReifiedStatementImpl.getInstance(holder.getSecuredItem(),
-						it.nextRS());
-			}
-			finally
-			{
+		if (it.hasNext()) {
+			try {
+				return SecuredReifiedStatementImpl.getInstance(
+						holder.getSecuredItem(), it.nextRS());
+			} finally {
 				it.close();
 			}
-		}
-		else
-		{
-			return SecuredReifiedStatementImpl.getInstance(holder.getSecuredItem(),
-					createReifiedStatement(s));
+		} else {
+			return SecuredReifiedStatementImpl.getInstance(
+					holder.getSecuredItem(), createReifiedStatement(s));
 		}
 	}
 
 	@Override
-	public SecuredBag getBag( final Resource r )
-	{
+	public SecuredBag getBag(final Resource r) {
 		checkRead();
 		checkRead(new Triple(r.asNode(), RDF.type.asNode(), RDF.Bag.asNode()));
-		return SecuredBagImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem().getBag(r));
+		return SecuredBagImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getBag(r));
 	}
 
 	@Override
-	public SecuredBag getBag( final String uri )
-	{
+	public SecuredBag getBag(final String uri) {
 		checkRead();
 		checkRead(new Triple(NodeFactory.createURI(uri), RDF.type.asNode(),
 				RDF.Bag.asNode()));
-		return SecuredBagImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.getBag(uri));
+		return SecuredBagImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getBag(uri));
 	}
 
 	@Override
-	public SecuredGraph getGraph()
-	{
+	public SecuredGraph getGraph() {
 		return graph;
 	}
 
 	@Override
-	public Lock getLock()
-	{
+	public Lock getLock() {
 		return holder.getBaseItem().getLock();
 	}
 
 	@Override
-	public Map<String, String> getNsPrefixMap()
-	{
+	public Map<String, String> getNsPrefixMap() {
 		checkRead();
 		return holder.getBaseItem().getNsPrefixMap();
 	}
 
 	@Override
-	public String getNsPrefixURI( final String prefix )
-	{
+	public String getNsPrefixURI(final String prefix) {
 		checkRead();
 		return holder.getBaseItem().getNsPrefixURI(prefix);
 	}
 
 	@Override
-	public String getNsURIPrefix( final String uri )
-	{
+	public String getNsURIPrefix(final String uri) {
 		checkRead();
 		return holder.getBaseItem().getNsURIPrefix(uri);
 	}
 
 	@Override
-	public SecuredStatement getProperty( final Resource s, final Property p )
-	{
+	public SecuredStatement getProperty(final Resource s, final Property p) {
 		final StmtIterator stmt = listStatements(s, p, (RDFNode) null);
-		try
-		{
-			if (stmt.hasNext())
-			{
-				return SecuredStatementImpl.getInstance(holder.getSecuredItem(), stmt.next());
+		try {
+			if (stmt.hasNext()) {
+				return SecuredStatementImpl.getInstance(
+						holder.getSecuredItem(), stmt.next());
 			}
 			return null;
-		}
-		finally
-		{
-			if (stmt != null)
-			{
+		} finally {
+			if (stmt != null) {
 				stmt.close();
 			}
 		}
 	}
 
 	@Override
-	public SecuredProperty getProperty( final String uri )
-	{
+	public SecuredProperty getProperty(final String uri) {
 		checkRead();
-		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.getProperty(uri));
+		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getProperty(uri));
 	}
 
 	@Override
-	public SecuredProperty getProperty( final String nameSpace,
-			final String localName )
-	{
+	public SecuredProperty getProperty(final String nameSpace,
+			final String localName) {
 		checkRead();
-		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.getProperty(nameSpace, localName));
+		return SecuredPropertyImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getProperty(nameSpace, localName));
 	}
 
 	@Override
-	public SecuredRDFNode getRDFNode( final Node n )
-	{
+	public SecuredRDFNode getRDFNode(final Node n) {
 		RDFNode rdfNode = null;
-		if (n.isLiteral())
-		{
+		if (n.isLiteral()) {
 			rdfNode = ResourceFactory.createTypedLiteral(
 					n.getLiteralLexicalForm(), n.getLiteralDatatype());
-		}
-		else if (n.isURI())
-		{
+		} else if (n.isURI()) {
 			rdfNode = ResourceFactory.createProperty(n.getURI());
-		}
-		else if (n.isBlank())
-		{
+		} else if (n.isBlank()) {
 			rdfNode = ResourceFactory.createResource(n.getBlankNodeId()
 					.toString());
-		}
-		else
-		{
+		} else {
 			throw new IllegalArgumentException("Illegal SecNode type: " + n);
 		}
 
-		if (holder.getBaseItem().containsResource(rdfNode))
-		{
+		if (holder.getBaseItem().containsResource(rdfNode)) {
 			checkRead();
-		}
-		else
-		{
+		} else {
 			checkUpdate();
 		}
-		if (n.isLiteral())
-		{
-			return SecuredLiteralImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-					.getRDFNode(n).asLiteral());
-		}
-		else
-		{
-			return SecuredResourceImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-					.getRDFNode(n).asResource());
+		if (n.isLiteral()) {
+			return SecuredLiteralImpl.getInstance(holder.getSecuredItem(),
+					holder.getBaseItem().getRDFNode(n).asLiteral());
+		} else {
+			return SecuredResourceImpl.getInstance(holder.getSecuredItem(),
+					holder.getBaseItem().getRDFNode(n).asResource());
 		}
 	}
 
 	@Override
-	public RDFReader getReader()
-	{
+	public RDFReader getReader() {
 		return holder.getBaseItem().getReader();
 	}
 
 	@Override
-	public RDFReader getReader( final String lang )
-	{
+	public RDFReader getReader(final String lang) {
 		return holder.getBaseItem().getReader(lang);
 	}
 
@@ -1547,82 +1265,67 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	public String removeReader(String lang) throws IllegalArgumentException {
 		return holder.getBaseItem().removeReader(lang);
 	}
-	
+
 	@Override
-	public SecuredStatement getRequiredProperty( final Resource s,
-			final Property p )
-	{
+	public SecuredStatement getRequiredProperty(final Resource s,
+			final Property p) {
 		checkRead();
-		if (canRead(Triple.ANY))
-		{
-			return SecuredStatementImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-					.getRequiredProperty(s, p));
-		}
-		else
-		{
+		if (canRead(Triple.ANY)) {
+			return SecuredStatementImpl.getInstance(holder.getSecuredItem(),
+					holder.getBaseItem().getRequiredProperty(s, p));
+		} else {
 			final SecuredStatementIterator si = listStatements(s, p,
 					(RDFNode) null);
-			try
-			{
-				if (si.hasNext())
-				{
+			try {
+				if (si.hasNext()) {
 					return (SecuredStatement) si.next();
-				}
-				else
-				{
+				} else {
 					throw new PropertyNotFoundException(p);
 				}
-			}
-			finally
-			{
+			} finally {
 				si.close();
 			}
 		}
 	}
 
 	@Override
-	public SecuredResource getResource( final String uri )
-	{
+	public SecuredResource getResource(final String uri) {
 		return createResource(uri);
 	}
 
 	@Override
 	@Deprecated
-	public SecuredResource getResource( final String uri, final ResourceF f )
-	{
+	public SecuredResource getResource(final String uri, final ResourceF f) {
 		return createResource(uri, f);
 	}
 
 	@Override
-	public SecuredSeq getSeq( final Resource r )
-	{
+	public SecuredSeq getSeq(final Resource r) {
 		checkRead();
 		checkRead(new Triple(r.asNode(), RDF.type.asNode(), RDF.Seq.asNode()));
-		return SecuredSeqImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem().getSeq(r));
+		return SecuredSeqImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getSeq(r));
 	}
 
 	@Override
-	public SecuredSeq getSeq( final String uri )
-	{
+	public SecuredSeq getSeq(final String uri) {
 		checkRead();
 		checkRead(new Triple(NodeFactory.createURI(uri), RDF.type.asNode(),
 				RDF.Seq.asNode()));
-		return SecuredSeqImpl.getInstance(holder.getSecuredItem(), holder.getBaseItem()
-				.getSeq(uri));
+		return SecuredSeqImpl.getInstance(holder.getSecuredItem(), holder
+				.getBaseItem().getSeq(uri));
 	}
 
 	@Override
-	public RDFWriter getWriter()
-	{
+	public RDFWriter getWriter() {
 		return holder.getBaseItem().getWriter();
 	}
 
 	@Override
-	public RDFWriter getWriter( final String lang )
-	{
+	public RDFWriter getWriter(final String lang) {
 		return holder.getBaseItem().getWriter(lang);
 	}
-	
+
 	@SuppressWarnings("deprecation")
 	@Override
 	public void resetRDFWriterF() {
@@ -1636,64 +1339,49 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	}
 
 	@Override
-	public boolean independent()
-	{
+	public boolean independent() {
 		return false;
 	}
 
 	@Override
-	public Model intersection( final Model model )
-	{
+	public Model intersection(final Model model) {
 		checkRead();
-		if (!canRead(Triple.ANY))
-		{
+		if (!canRead(Triple.ANY)) {
 			return holder.getBaseItem().intersection(model);
-		}
-		else
-		{
+		} else {
 			return createCopy().intersection(model);
 		}
 	}
 
 	@Override
-	public boolean isClosed()
-	{
+	public boolean isClosed() {
 		return holder.getBaseItem().isClosed();
 	}
 
 	@Override
-	public boolean isEmpty()
-	{
+	public boolean isEmpty() {
 		checkRead();
 		return holder.getBaseItem().isEmpty();
 	}
 
 	@Override
-	public boolean isIsomorphicWith( final Model g )
-	{
+	public boolean isIsomorphicWith(final Model g) {
 		checkRead();
 		final boolean retval = holder.getBaseItem().isIsomorphicWith(g);
-		if (retval && !canRead(Triple.ANY))
-		{
+		if (retval && !canRead(Triple.ANY)) {
 			// in this case we have to check all the items in the graph to see
 			// if the user can read
 			// them all.
 			final ExtendedIterator<Statement> stmtIter = holder.getBaseItem()
 					.listStatements();
-			try
-			{
-				while (stmtIter.hasNext())
-				{
-					if (!canRead(stmtIter.next().asTriple()))
-					{
+			try {
+				while (stmtIter.hasNext()) {
+					if (!canRead(stmtIter.next())) {
 						return false;
 					}
 				}
-			}
-			finally
-			{
-				if (stmtIter != null)
-				{
+			} finally {
+				if (stmtIter != null) {
 					stmtIter.close();
 				}
 			}
@@ -1702,531 +1390,495 @@ public class SecuredModelImpl extends SecuredItemImpl implements SecuredModel
 	}
 
 	@Override
-	public boolean isReified( final Statement s )
-	{
+	public boolean isReified(final Statement s) {
 		checkRead();
-		checkRead(s.asTriple());
+		checkRead(s);
 
 		final RSIterator it = listReifiedStatements(s);
-		try
-		{
+		try {
 			return it.hasNext();
-		}
-		finally
-		{
+		} finally {
 			it.close();
 		}
 	}
 
 	@Override
-	public void leaveCriticalSection()
-	{
+	public void leaveCriticalSection() {
 		holder.getBaseItem().leaveCriticalSection();
 	}
 
 	@Override
 	public SecuredStatementIterator listLiteralStatements(
 			final Resource subject, final Property predicate,
-			final boolean object )
-	{
+			final boolean object) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem()
 				.listLiteralStatements(subject, predicate, object));
 	}
 
 	@Override
 	public SecuredStatementIterator listLiteralStatements(
-			final Resource subject, final Property predicate, final char object )
-	{
+			final Resource subject, final Property predicate, final char object) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem()
 				.listLiteralStatements(subject, predicate, object));
 	}
 
 	@Override
 	public SecuredStatementIterator listLiteralStatements(
 			final Resource subject, final Property predicate,
-			final double object )
-	{
+			final double object) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem()
 				.listLiteralStatements(subject, predicate, object));
 	}
 
 	@Override
 	public SecuredStatementIterator listLiteralStatements(
-			final Resource subject, final Property predicate, final float object )
-	{
+			final Resource subject, final Property predicate, final float object) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem()
 				.listLiteralStatements(subject, predicate, object));
 	}
 
 	@Override
 	public SecuredStatementIterator listLiteralStatements(
-			final Resource subject, final Property predicate, final long object )
-	{
+			final Resource subject, final Property predicate, final long object) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem()
 				.listLiteralStatements(subject, predicate, object));
 	}
 
 	@Override
-	public NsIterator listNameSpaces()
-	{
+	public NsIterator listNameSpaces() {
 		checkRead();
 		return holder.getBaseItem().listNameSpaces();
 	}
 
 	@Override
-	public SecuredNodeIterator<RDFNode> listObjects()
-	{
+	public SecuredNodeIterator<RDFNode> listObjects() {
 		checkRead();
 		ExtendedIterator<RDFNode> nIter = holder.getBaseItem().listObjects();
-		if (!canRead(SecTriple.ANY))
-		{
-			nIter = nIter.filterKeep( new ObjectFilter());
+		if (!canRead(Triple.ANY)) {
+			nIter = nIter.filterKeep(new ObjectFilter());
 		}
 		return new SecuredNodeIterator<RDFNode>(holder.getSecuredItem(), nIter);
 	}
 
 	@Override
-	public SecuredNodeIterator<RDFNode> listObjectsOfProperty( final Property p )
-	{
+	public SecuredNodeIterator<RDFNode> listObjectsOfProperty(final Property p) {
 		checkRead();
-		ExtendedIterator<RDFNode> nIter = holder.getBaseItem().listObjectsOfProperty(p);
-		if (!canRead(SecTriple.ANY))
-		{
-			nIter = nIter.filterKeep( new ObjectFilter(p));
+		ExtendedIterator<RDFNode> nIter = holder.getBaseItem()
+				.listObjectsOfProperty(p);
+		if (!canRead(Triple.ANY)) {
+			nIter = nIter.filterKeep(new ObjectFilter(p));
 		}
 		return new SecuredNodeIterator<RDFNode>(holder.getSecuredItem(), nIter);
 	}
 
 	@Override
-	public SecuredNodeIterator<RDFNode> listObjectsOfProperty( final Resource s,
-			final Property p )
-	{
+	public SecuredNodeIterator<RDFNode> listObjectsOfProperty(final Resource s,
+			final Property p) {
 		checkRead();
-		ExtendedIterator<RDFNode> nIter = holder.getBaseItem().listObjectsOfProperty(s, p);
-		if (!canRead(SecTriple.ANY))
-		{
-			nIter = nIter.filterKeep( new ObjectFilter(p));
+		ExtendedIterator<RDFNode> nIter = holder.getBaseItem()
+				.listObjectsOfProperty(s, p);
+		if (!canRead(Triple.ANY)) {
+			nIter = nIter.filterKeep(new ObjectFilter(p));
 		}
 		return new SecuredNodeIterator<RDFNode>(holder.getSecuredItem(), nIter);
 	}
 
 	@Override
-	public SecuredRSIterator listReifiedStatements()
-	{
+	public SecuredRSIterator listReifiedStatements() {
 		checkRead();
-		return new SecuredRSIterator(holder.getSecuredItem(), holder.getBaseItem()
-				.listReifiedStatements());
+		return new SecuredRSIterator(holder.getSecuredItem(), holder
+				.getBaseItem().listReifiedStatements());
 	}
 
 	@Override
-	public SecuredRSIterator listReifiedStatements( final Statement st )
-	{
+	public SecuredRSIterator listReifiedStatements(final Statement st) {
 		checkRead();
 		checkRead(st);
-		return new SecuredRSIterator(holder.getSecuredItem(), holder.getBaseItem()
-				.listReifiedStatements(st));
+		return new SecuredRSIterator(holder.getSecuredItem(), holder
+				.getBaseItem().listReifiedStatements(st));
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
-		
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
+
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p,
-			final boolean o )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p,
+			final boolean o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createTypedLiteral(o)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createTypedLiteral(o)));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p,
-			final char o )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p,
+			final char o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createTypedLiteral(o)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createTypedLiteral(o)));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p,
-			final double o )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p,
+			final double o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createTypedLiteral(o)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createTypedLiteral(o)));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p,
-			final float o )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p,
+			final float o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createTypedLiteral(o)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createTypedLiteral(o)));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p,
-			final long o )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p,
+			final long o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createTypedLiteral(o)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createTypedLiteral(o)));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p,
-			final Object o )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p,
+			final Object o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createTypedLiteral(o)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createTypedLiteral(o)));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listResourcesWithProperty( final Property p,
-			final RDFNode o )
-	{
+	public SecuredResIterator listResourcesWithProperty(final Property p,
+			final RDFNode o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listResourcesWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, o));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listResourcesWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, o));
 		}
-		return new SecuredResIterator( holder.getSecuredItem(), rIter );
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredStatementIterator listStatements()
-	{
+	public SecuredStatementIterator listStatements() {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
-				.listStatements());
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem().listStatements());
 	}
 
 	@Override
-	public SecuredStatementIterator listStatements( final Resource s,
-			final Property p, final RDFNode o )
-	{
+	public SecuredStatementIterator listStatements(final Resource s,
+			final Property p, final RDFNode o) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
-				.listStatements(s, p, o));
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem().listStatements(s, p, o));
 	}
 
 	@Override
-	public SecuredStatementIterator listStatements( final Resource subject,
-			final Property predicate, final String object )
-	{
+	public SecuredStatementIterator listStatements(final Resource subject,
+			final Property predicate, final String object) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
-				.listStatements(subject, predicate, object));
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem().listStatements(subject, predicate, object));
 	}
 
 	@Override
-	public SecuredStatementIterator listStatements( final Resource subject,
-			final Property predicate, final String object, final String lang )
-	{
+	public SecuredStatementIterator listStatements(final Resource subject,
+			final Property predicate, final String object, final String lang) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
-				.listStatements(subject, predicate, object, lang));
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem().listStatements(subject, predicate, object, lang));
 	}
 
 	@Override
-	public SecuredStatementIterator listStatements( final Selector s )
-	{
+	public SecuredStatementIterator listStatements(final Selector s) {
 		checkRead();
-		return new SecuredStatementIterator(holder.getSecuredItem(), holder.getBaseItem()
-				.listStatements(s));
+		return new SecuredStatementIterator(holder.getSecuredItem(), holder
+				.getBaseItem().listStatements(s));
 	}
 
 	@Override
-	public SecuredResIterator listSubjects()
-	{
+	public SecuredResIterator listSubjects() {
 		checkRead();
 		ExtendedIterator<Resource> rIter = holder.getBaseItem().listSubjects();
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter());
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter());
 		}
-		return new SecuredResIterator(holder.getSecuredItem(),rIter);
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listSubjectsWithProperty( final Property p )
-	{
+	public SecuredResIterator listSubjectsWithProperty(final Property p) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listSubjectsWithProperty(p);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listSubjectsWithProperty(p);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p));
 		}
-		return new SecuredResIterator(holder.getSecuredItem(),rIter);
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listSubjectsWithProperty( final Property p,
-			final RDFNode o )
-	{
+	public SecuredResIterator listSubjectsWithProperty(final Property p,
+			final RDFNode o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listSubjectsWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, o));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listSubjectsWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, o));
 		}
-		return new SecuredResIterator(holder.getSecuredItem(),rIter);
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listSubjectsWithProperty( final Property p,
-			final String o )
-	{
+	public SecuredResIterator listSubjectsWithProperty(final Property p,
+			final String o) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listSubjectsWithProperty(p, o);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createPlainLiteral(o)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listSubjectsWithProperty(p, o);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createPlainLiteral(o)));
 		}
-		return new SecuredResIterator(holder.getSecuredItem(),rIter);
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredResIterator listSubjectsWithProperty( final Property p,
-			final String o, final String l )
-	{
+	public SecuredResIterator listSubjectsWithProperty(final Property p,
+			final String o, final String l) {
 		checkRead();
-		ExtendedIterator<Resource> rIter = holder.getBaseItem().listSubjectsWithProperty(p, o, l);
-		if (!canRead( SecTriple.ANY))
-		{
-			rIter=rIter.filterKeep( new ResourceFilter(p, ResourceFactory.createLangLiteral(o, l)));
+		ExtendedIterator<Resource> rIter = holder.getBaseItem()
+				.listSubjectsWithProperty(p, o, l);
+		if (!canRead(Triple.ANY)) {
+			rIter = rIter.filterKeep(new ResourceFilter(p, ResourceFactory
+					.createLangLiteral(o, l)));
 		}
-		return new SecuredResIterator(holder.getSecuredItem(),rIter);	
+		return new SecuredResIterator(holder.getSecuredItem(), rIter);
 	}
 
 	@Override
-	public SecuredPrefixMapping lock()
-	{
+	public SecuredPrefixMapping lock() {
 		checkUpdate();
 		holder.getBaseItem().lock();
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public SecuredModel notifyEvent( final Object e )
-	{
+	public SecuredModel notifyEvent(final Object e) {
 		holder.getBaseItem().notifyEvent(e);
 		return holder.getSecuredItem();
 	}
 
 	@Override
-	public String qnameFor( final String uri )
-	{
+	public String qnameFor(final String uri) {
 		checkRead();
 		return holder.getBaseItem().qnameFor(uri);
 	}
 
 	@Override
-	public SecuredModel query( final Selector s )
-	{
+	public SecuredModel query(final Selector s) {
 		checkRead();
-		return SecuredModelImpl.getInstance(holder.getSecuredItem(),
-				holder.getBaseItem().query(new SecuredSelector(holder.getSecuredItem(), s)));
+		return SecuredModelImpl.getInstance(
+				holder.getSecuredItem(),
+				holder.getBaseItem().query(
+						new SecuredSelector(holder.getSecuredItem(), s)));
 	}
 
 	@Override
-	public SecuredModel read( final InputStream in, final String base )
-	{
+	public SecuredModel read(final InputStream in, final String base) {
 		checkUpdate();
-//		try
-//		{
-			SecuredModelImpl.readerFactory.getReader().read(holder.getSecuredItem(), in, base);
-			return holder.getSecuredItem();
-//		}
-//		catch (final JenaException e)
-//		{
-//			if ((e.getCause() != null)
-//					&& (e.getCause() instanceof AccessDeniedRuntimeException))
-//			{
-//				throw (AccessDeniedRuntimeException) e.getCause();
-//			}
-//			throw e;
-//		}
-	}
-
-	@Override
-	public SecuredModel read( final InputStream in, final String base,
-			final String lang )
-	{
+		// try
+		// {
+		SecuredModelImpl.readerFactory.getReader().read(
+				holder.getSecuredItem(), in, base);
+		return holder.getSecuredItem();
+		// }
+		// catch (final JenaException e)
+		// {
+		// if ((e.getCause() != null)
+		// && (e.getCause() instanceof AccessDeniedRuntimeException))
+		// {
+		// throw (AccessDeniedRuntimeException) e.getCause();
+		// }
+		// throw e;
+		// }
+	}
+
+	@Override
+	public SecuredModel read(final InputStream in, final String base,
+			final String lang) {
 		checkUpdate();
-//		try
-//		{
-			SecuredModelImpl.readerFactory.getReader(lang).read(holder.getSecuredItem(), in, base);
-			return holder.getSecuredItem();
-//		}
-//		catch (final JenaException e)
-//		{
-//			if ((e.getCause() != null)
-//					&& (e.getCause() instanceof AccessDeniedRuntimeException))
-//			{
-//				throw (AccessDeniedRuntimeException) e.getCause();
-//			}
-//			throw e;
-//		}
-	}
-
-	@Override
-	public SecuredModel read( final Reader reader, final String base )
-	{
+		// try
+		// {
+		SecuredModelImpl.readerFactory.getReader(lang).read(
+				holder.getSecuredItem(), in, base);
+		return holder.getSecuredItem();
+		// }
+		// catch (final JenaException e)
+		// {
+		// if ((e.getCause() != null)
+		// && (e.getCause() instanceof AccessDeniedRuntimeException))
+		// {
+		// throw (AccessDeniedRuntimeException) e.getCause();
+		// }
+		// throw e;
+		// }
+	}
+
+	@Override
+	public SecuredModel read(final Reader reader, final String base) {
 		checkUpdate();
-//		try
-//		{
-			SecuredModelImpl.readerFactory.getReader().read(holder.getSecuredItem(), reader, base);
-			return holder.getSecuredItem();
-//		}
-//		catch (final JenaException e)
-//		{
-//			if ((e.getCause() != null)
-//					&& (e.getCause() instanceof AccessDeniedRuntimeException))
-//			{
-//				throw (AccessDeniedRuntimeException) e.getCause();
-//			}
-//			throw e;
-//		}
-	}
-
-	@Override
-	public SecuredModel read( final Reader reader, final String base,
-			final String lang )
-	{
+		// try
+		// {
+		SecuredModelImpl.readerFactory.getReader().read(
+				holder.getSecuredItem(), reader, base);
+		return holder.getSecuredItem();
+		// }
+		// catch (final JenaException e)
+		// {
+		// if ((e.getCause() != null)
+		// && (e.getCause() instanceof AccessDeniedRuntimeException))
+		// {
+		// throw (AccessDeniedRuntimeException) e.getCause();
+		// }
+		// throw e;
+		// }
+	}
+
+	@Override
+	public SecuredModel read(final Reader reader, final String base,
+			final String lang) {
 		checkUpdate();
-//		try
-//		{
-			SecuredModelImpl.readerFactory.getReader(lang).read(holder.getSecuredItem(), reader,
-					base);
-			return holder.getSecuredItem();
-//		}
-//		catch (final JenaException e)
-//		{
-//			if ((e.getCause() != null)
-//					&& (e.getCause() instanceof AccessDeniedRuntimeException))
-//			{
-//				throw (AccessDeniedRuntimeException) e.getCause();
-//			}
-//			throw e;
-//		}
-	}
-
-	@Override
-	public SecuredModel read( final String url )
-	{
+		// try
+		// {
+		SecuredModelImpl.readerFactory.getReader(lang).read(
+				holder.getSecuredItem(), reader, base);
+		return holder.getSecuredItem();
+		// }
+		// catch (final JenaException e)
+		// {
+		// if ((e.getCause() != null)
+		// && (e.getCause() instanceof AccessDeniedRuntimeException))
+		// {
+		// throw (AccessDeniedRuntimeException) e.getCause();
+		// }
+		// throw e;
+		// }
+	}
+
+	@Override
+	public SecuredModel read(final String url) {
 		checkUpdate();
-//		try
-//		{
-			SecuredModelImpl.readerFactory.getReader().read(holder.getSecuredItem(), url);
-			return holder.getSecuredItem();
-//		}
-//		catch (final JenaException e)
-//		{
-//			if ((e.getCause() != null)
-//					&& (e.getCause() instanceof AccessDeniedRuntimeException))
-//			{
-//				throw (AccessDeniedRuntimeException) e.getCause();
-//			}
-//			throw e;
-//		}
-	}
-
-	@Override
-	public SecuredModel read( final String url, final String lang )
-	{
+		// try
+		// {
+		SecuredModelImpl.readerFactory.getReader().read(
+				holder.getSecuredItem(), url);
+		return holder.getSecuredItem();
+		// }
+		// catch (final JenaException e)
+		// {
+		// if ((e.getCause() != null)
+		// && (e.getCause() instanceof AccessDeniedRuntimeException))
+		// {
+		// throw (AccessDeniedRuntimeException) e.getCause();
+		// }
+		// throw e;
+		// }
+	}
+
+	@Override
+	public SecuredModel read(final String url, final String lang) {
 		checkUpdate();
-//		try
-//		{
-			SecuredModelImpl.readerFactory.getReader(lang).read(holder.getSecuredItem(), url);
-			return holder.getSecuredItem();
-//		}
-//		catch (final JenaException e)
-//		{
-//			if ((e.getCause() != null)
-//					&& (e.getCause() instanceof AccessDeniedRuntimeException))
-//			{
-//				throw (AccessDeniedRuntimeException) e.getCause();
-//			}
-//			throw e;
-//		}
-	}
-
-	@Override
-	public SecuredModel read( final String url, final String base,
-			final String lang )
-	{
-		try
-		{
+		// try
+		// {
+		SecuredModelImpl.readerFactory.getReader(lang).read(
+				holder.getSecuredItem(), url);
+		return holder.getSecuredItem();
+		// }
+		// catch (final JenaException e)
+		// {
+		// if ((e.getCause() != null)
+		// && (e.getCause() instanceof AccessDeniedRuntimeException))
+		// {
+		// throw (AccessDeniedRuntimeException) e.getCause();
+		// }
+		// throw e;
+		// }
+	}
+
+	@Override
+	public SecuredModel read(final String url, final String base,
+			final String lang) {
+		try {
 			final InputStream is = new URL(url).openStream();
-			try
-			{
+			try {
 				read(is, base, lang);
-			}
-			finally
-			{
-				if (null != is)
-				{
+			} finally {
+				if (null != is) {
 					is.close();
 				}
 			}
-		}
-		catch (fin

<TRUNCATED>