* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

*

* <P>This class implements common methods, mainly convenience methods, for

*    model implementations.  It is intended use is as a base class from which

*    model implemenations can be derived.</P>

*/

    private static final RDFReaderF readerFactory = new RDFReaderFImpl();

    private static final RDFWriterF writerFactory = new RDFWriterFImpl();

    private Lock modelLock = null ;

    private static PrefixMapping defaultPrefixMapping = PrefixMapping.Factory.create();

    static {

        // This forces RIOT (in ARQ) to initialize but after Jena readers/writers

        // have cleanly initialized from the calls of  RDFReaderFImpl and RDFWriterFImpl

        // above.  RIOT initialization happens before model.read can be called.

       

        // Needs further testing :-(

        IO_Ctl.init();

    }

   

    /**

      make a model based on the specified graph

     */

    public ModelCom( Graph base )

    { this( base, BuiltinPersonalities.model ); }

    public ModelCom( Graph base, Personality<RDFNode> personality )

    { super( base, personality );

    withDefaultMappings( defaultPrefixMapping ); }

    public static PrefixMapping getDefaultModelPrefixes()

    { return defaultPrefixMapping; }

    public static PrefixMapping setDefaultModelPrefixes(PrefixMapping pm)

    {

        PrefixMapping result = defaultPrefixMapping ;

        defaultPrefixMapping = pm ;

        return result ;

    }

    @Override

    public Graph getGraph()

    { return graph; }

    protected static Model createWorkModel()

    { return ModelFactory.createDefaultModel(); }

    @Override

    public RDFNode asRDFNode( Node n )

    {

        return n.isLiteral()

            ? (RDFNode) this.getNodeAs( n, Literal.class )

            : (RDFNode) this.getNodeAs( n, Resource.class );

    }

    @Override

    public Resource wrapAsResource( Node n )

    {

        if (n.isLiteral())

            throw new UnsupportedOperationException( "literal cannot be converted to Resource" );

        return this.getNodeAs( n, Resource.class );

    }

    /**

        the ModelReifier does everything to do with reification.

     */

    protected ModelReifier modelReifier = new ModelReifier( this );

    @Override

    @Deprecated public Resource getResource(String uri, ResourceF f)  {

        try {

            return f.createResource(getResource(uri));

        } catch (Exception e) {

            throw new JenaException(e);

        }

    }

    @Override

    public Model addLiteral( Resource s, Property p, boolean o ) 

    { return add(s, p, createTypedLiteral( o ) ); }

    @Override

    public Model addLiteral( Resource s, Property p, long o ) 

    { return add(s, p, createTypedLiteral( o ) ); }

    @Override

    public Model addLiteral( Resource s, Property p, int o ) 

    { return add(s, p, createTypedLiteral( o ) ); }

    @Override

    public Model addLiteral( Resource s, Property p, char o ) 

    { return add(s, p, createTypedLiteral( o ) ); }

    @Override

    public Model addLiteral( Resource s, Property p, float o ) 

    { return add( s, p, createTypedLiteral( o ) ); }

    @Override

    public Model addLiteral( Resource s, Property p, double o ) 

    { return add(s, p, createTypedLiteral( o ) ); }

    @Override

    public Model add(Resource s, Property p, String o)  {

        return add( s, p, o, "", false );

    }

    @Override

    public Model add(Resource s, Property p, String o, boolean wellFormed)

    {

        add( s, p, literal( o, "", wellFormed ) );

        return this;

    }

    public Model add( Resource s, Property p, String o, String lang,

                      boolean wellFormed)  {

        add( s, p, literal( o, lang, wellFormed ) );

        return this;

    }

    @Override

    public Model add(Resource s, Property p, String lex, RDFDatatype datatype)

    {

        add( s, p, literal( lex, datatype)) ;

        return this;

    }

    private Literal literal( String s, String lang, boolean wellFormed )

    { return new LiteralImpl( Node.createLiteral( s, lang, wellFormed), this ); }

    private Literal literal( String lex, RDFDatatype datatype)

    { return new LiteralImpl( Node.createLiteral( lex, "", datatype), this ); }

    @Override

    public Model add( Resource s, Property p, String o, String l )

    { return add( s, p, o, l, false ); }

    @Override

    @Deprecated public Model addLiteral( Resource s, Property p, Object o ) 

    { return add( s, p, asObject( o ) ); }

    @Override

    public Model addLiteral( Resource s, Property p, Literal o ) 

    { return add( s, p, o ); }

    private RDFNode asObject( Object o )

    { return o instanceof RDFNode ? (RDFNode) o : createTypedLiteral( o ); }

    @Override

    public Model add( StmtIterator iter )  {

        try { GraphUtil.add( getGraph(), asTriples( iter ) ); }

        finally { iter.close(); }

        return this;

    }

    @Override

    public Model add( Model m ) 

    { return add( m, false ); }

    @Deprecated

    @Override

    public Model add( Model m, boolean suppressReifications ) {

        // suppressReifications is a no-op.

        GraphUtil.addInto( getGraph(), m.getGraph() );

        return this;

    }

    @Override

    public RDFReader getReader()  {

        return readerFactory.getReader();

    }

    @Override

    public RDFReader getReader(String lang)  {

        return readerFactory.getReader(lang);

    }

    @Override

    public String setReaderClassName(String lang, String className) {

        return readerFactory.setReaderClassName(lang, className);

    }

    @Override

    public Model read(String url)  {

        readerFactory .getReader() .read(this, url);

        return this;

    }

    @Override

    public Model read(Reader reader, String base)  {

        readerFactory .getReader() .read(this, reader, base);

        return this;

    }

    @Override

    public Model read(InputStream reader, String base)  {

        readerFactory .getReader() .read(this, reader, base);

        return this;

    }

    @Override

    public Model read(String url, String lang)  {

        readerFactory. getReader(lang) .read(this, url);

        return this;

    }

    @Override

    public Model read( String url, String base, String lang )

    {

        try

        {

            InputStream is = new URL( url ) .openStream();

            try { read( is, base, lang ); }

            finally { if (null != is) { is.close(); } }

        }

        catch (IOException e) { throw new WrappedIOException( e ); }

        return this;

    }

    @Override

    public Model read(Reader reader, String base, String lang)

    {

        readerFactory .getReader(lang) .read(this, reader, base);

        return this;

    }

    @Override

    public Model read(InputStream reader, String base, String lang)

    {

        readerFactory .getReader(lang) .read(this, reader, base);

        return this;

    }

    /**

        Get the model's writer after priming it with the model's namespace

        prefixes.

     */

    @Override

    public RDFWriter getWriter()  {

        return writerFactory.getWriter();

    }

    /**

        Get the model's writer after priming it with the model's namespace

        prefixes.

     */

    @Override

    public RDFWriter getWriter(String lang)  {

        return writerFactory.getWriter(lang);

    }

    @Override

    public String setWriterClassName(String lang, String className) {

        return writerFactory.setWriterClassName(lang, className);

    }

    @Override

    public Model write(Writer writer)

    {

        getWriter() .write(this, writer, "");

        return this;

    }

    @Override

    public Model write(Writer writer, String lang)

    {

        getWriter(lang) .write(this, writer, "");

        return this;

    }

    @Override

    public Model write(Writer writer, String lang, String base)

    {

        getWriter(lang) .write(this, writer, base);

        return this;

    }

    @Override

    public Model write( OutputStream writer )

    {

        getWriter() .write(this, writer, "");

        return this;   

    }

    @Override

    public Model write(OutputStream writer, String lang)

    {

        getWriter(lang) .write(this, writer, "");

        return this;

    }

    @Override

    public Model write(OutputStream writer, String lang, String base)

    {

        getWriter(lang) .write(this, writer, base);

        return this;

    }

    @Override

    public Model remove(Statement s)  {

        graph.delete(s.asTriple());

        return this;

    }

    @Override

    public Model remove( Resource s, Property p, RDFNode o ) {

        graph.delete( Triple.create( s.asNode(), p.asNode(), o.asNode() ) );

        return this;

    }

    @Override

    public Model remove( StmtIterator iter )

    {

        GraphUtil.delete( getGraph(), asTriples( iter ) );

        return this;

    }

    @Override

    public Model remove( Model m )

    { return remove( m, false ); }

    @Override

    @Deprecated

    public Model remove( Model m, boolean suppressReifications )

    {

        GraphUtil.deleteFrom( getGraph(), m.getGraph());

        return this;

    }

    @Override

    public Model removeAll()

    {

        getGraph().clear();

        return this;

    }

    @Override

    public Model removeAll( Resource s, Property p, RDFNode o )

    {

        getGraph().remove( asNode( s ), asNode( p ), asNode( o ) );

        return this;

    }

    @Override

    public boolean containsLiteral( Resource s, Property p, boolean o )

    { return contains(s, p, createTypedLiteral( o ) ); }

    @Override

    public boolean containsLiteral( Resource s, Property p, long o )

    { return contains(s, p, createTypedLiteral( o ) ); }

    @Override

    public boolean containsLiteral( Resource s, Property p, int o )

    { return contains(s, p, createTypedLiteral( o ) ); }

    @Override

    public boolean containsLiteral( Resource s, Property p, char o )

    { return contains(s, p, createTypedLiteral( o ) ); }

    @Override

    public boolean containsLiteral( Resource s, Property p, float o )

    { return contains(s, p, createTypedLiteral( o ) ); }

    @Override

    public boolean containsLiteral( Resource s, Property p, double o )

    { return contains(s, p, createTypedLiteral( o ) ); }

    @Override

    public boolean contains( Resource s, Property p, String o )

    { return contains( s, p, o, "" ); }

    @Override

    public boolean contains( Resource s, Property p, String o, String l )

    { return contains( s, p, literal( o, l, false ) ); }

    @Override

    public boolean containsLiteral(Resource s, Property p, Object o)

    { return contains( s, p, asObject( o ) ); }

    @Override

    public boolean containsAny( Model model )

    { return containsAnyThenClose( model.listStatements() ); }

    @Override

    public boolean containsAll( Model model ) 

    { return containsAllThenClose( model.listStatements() ); }

    protected boolean containsAnyThenClose( StmtIterator iter )

    { try { return containsAny( iter ); } finally { iter.close(); } }

    protected boolean containsAllThenClose( StmtIterator iter )

    { try { return containsAll( iter ); } finally { iter.close(); } }

    @Override

    public boolean containsAny( StmtIterator iter )

    {

        while (iter.hasNext()) if (contains(iter.nextStatement())) return true;

        return false;

    }

    @Override

    public boolean containsAll( StmtIterator iter ) 

    {

        while (iter.hasNext()) if (!contains(iter.nextStatement())) return false;

        return true;

    }

    protected StmtIterator listStatements( Resource S, Property P, Node O )

    {

        return IteratorFactory.asStmtIterator

            ( graph.find( asNode( S ), asNode( P ), O ), this );

    }

    @Override

    public StmtIterator listStatements( Resource S, Property P, RDFNode O )

    { return listStatements( S, P, asNode( O ) ); }

    @Override

    public StmtIterator listStatements( Resource S, Property P, String O ) {

        return O == null ? listStatements(S, P, Node.ANY)

                         :  listStatements( S, P, Node.createLiteral( O ) );

    }

    @Override

    public StmtIterator listStatements( Resource S, Property P, String O, String L ) {

        if (O != null) {

            // this is not OK when L is null: returns only the statements whose lang is ""

            // return listStatements( S, P, Node.createLiteral( O, L, false ) );

            if (L != null) return listStatements( S, P, Node.createLiteral( O, L, false ) );

            // there's maybe a better way

            return new StringFilteredStmtIterator(O, listStatements(S, P, Node.ANY));

        } else {

            return new LangFilteredStmtIterator(L, listStatements(S, P, Node.ANY));

        }

    }

   

    private class StringFilteredStmtIterator extends FilterKeepIterator<Statement> implements StmtIterator {

        public StringFilteredStmtIterator(final String str, Iterator<Statement> it ) {

            super(

                    new Filter<Statement>() {

                        @Override public boolean accept(Statement s) {

                            RDFNode o = s.getObject();

                            if (o instanceof Literal) {

                                if (str == null) return true; // should not happen

                                return (str.equals(((Literal) o).getString()));

                            }

                            return false;

                        }

              },

              it );

        }

        @Override public Statement nextStatement() { return next(); }

    }

   

    private class LangFilteredStmtIterator extends FilterKeepIterator<Statement> implements StmtIterator {

        public LangFilteredStmtIterator(final String l, Iterator<Statement> it ) {

            super(

                    new Filter<Statement>() {

                        @Override public boolean accept(Statement s) {

                            RDFNode o = s.getObject();

                            if (o instanceof Literal) {

                                if (l == null) return true;

                                return (l.equals(((Literal) o).getLanguage()));

                            }

                            return false;

                        }

              },

              it );

        }

        @Override public Statement nextStatement() { return next(); }

    }

 

    @Override

    public StmtIterator listLiteralStatements( Resource S, Property P, boolean O )

    { return listStatements( S, P, createTypedLiteral( O ) ); }

    @Override

    public StmtIterator listLiteralStatements( Resource S, Property P, long O )

    { return listStatements( S, P, createTypedLiteral( O ) ); }

    @Override

    public StmtIterator listLiteralStatements( Resource S, Property P, char  O )

    { return listStatements( S, P, createTypedLiteral( O ) ); }

    @Override

    public StmtIterator listLiteralStatements( Resource S, Property P, float O )

    { return listStatements( S, P, createTypedLiteral( O ) ); }

    @Override

    public StmtIterator listLiteralStatements( Resource S, Property P, double  O )

    { return listStatements( S, P, createTypedLiteral( O ) ); }

    /*

         list resources with property [was: list subjects with property]

     */

    @Override

    public ResIterator listResourcesWithProperty( Property p, boolean o )

    { return listResourcesWithProperty(p, createTypedLiteral( o ) ); }

    @Override

    public ResIterator listResourcesWithProperty( Property p, char o )

    { return listResourcesWithProperty(p, createTypedLiteral( o ) ); }

    @Override

    public ResIterator listResourcesWithProperty( Property p, long o )

    { return listResourcesWithProperty(p, createTypedLiteral( o ) ); }

    @Override

    public ResIterator listResourcesWithProperty( Property p, float o )

    { return listResourcesWithProperty(p, createTypedLiteral( o ) ); }

    @Override

    public ResIterator listResourcesWithProperty( Property p, double o )

    { return listResourcesWithProperty(p, createTypedLiteral( o ) ); }

    @Override

    public ResIterator listResourcesWithProperty( Property p, Object o )

    { return listResourcesWithProperty( p, createTypedLiteral( o ) ); }

    @Override

    public ResIterator listSubjectsWithProperty( Property p, RDFNode o )

    { return listResourcesWithProperty( p, o ); }

    @Override

    public ResIterator listSubjectsWithProperty( Property p, String o )

    { return listSubjectsWithProperty( p, o, "" ); }

    @Override

    public ResIterator listSubjectsWithProperty( Property p, String o, String l )

    { return listResourcesWithProperty(p, literal( o, l, false ) ); }

    @Override

    public Resource createResource( Resource type ) 

    { return createResource().addProperty( RDF.type, type ); }

    @Override

    public Resource createResource( String uri,Resource type )

    { return getResource( uri ).addProperty( RDF.type, type ); }

    @Override

    @Deprecated public Resource createResource( ResourceF f ) 

    { return createResource( null, f ); }

    @Override

    public Resource createResource( AnonId id )

    { return new ResourceImpl( id, this ); }

    @Override

    @Deprecated public Resource createResource( String uri, ResourceF f ) 

    { return f.createResource( createResource( uri ) ); }

    /** create a type literal from a boolean value.

     *

     * <p> The value is converted to a string using its <CODE>toString</CODE>

     * method. </p>

     * @param v the value of the literal

     *

     * @return a new literal representing the value v

     */

    @Override

    public Literal createTypedLiteral( boolean v )  {

        return createTypedLiteral( new Boolean( v ) );

    }

    /** create a typed literal from an integer value.

     *

     * @param v the value of the literal

     *

     * @return a new literal representing the value v

     */  

    @Override

    public Literal createTypedLiteral(int v)   {

        return createTypedLiteral(new Integer(v));

    }

    /** create a typed literal from a long integer value.

     *

     * @param v the value of the literal

     *

     * @return a new literal representing the value v

     */  

    @Override

    public Literal createTypedLiteral(long v)   {

        return createTypedLiteral(new Long(v));

    }

    /** create a typed literal from a char value.

     *

     * @param v the value of the literal

     *

     * @return a new literal representing the value v

     */

    @Override

    public Literal createTypedLiteral(char v)  {

        return createTypedLiteral(new Character(v));

    }

    /** create a typed literal from a float value.

     *

     * @param v the value of the literal

     *

     * @return a new literal representing the value v

     */

    @Override

    public Literal createTypedLiteral(float v)  {

        return createTypedLiteral(new Float(v));

    }

    /** create a typed literal from a double value.

     *

     * @param v the value of the literal

     *

     * @return a new literal representing the value v

     */

    @Override

    public Literal createTypedLiteral(double v)  {

        return createTypedLiteral(new Double(v));

    }

    /** create a typed literal from a String value.

     *

     * @param v the value of the literal

     *

     * @return a new literal representing the value v

     */

    @Override

    public Literal createTypedLiteral(String v)  {

        LiteralLabel ll = LiteralLabelFactory.create(v);

        return new LiteralImpl(Node.createLiteral(ll), this);

    }

    /**

     * Create a typed literal xsd:dateTime from a Calendar object.

     */

    @Override

    public Literal createTypedLiteral(Calendar cal) {

        Object value = new XSDDateTime(cal);

        LiteralLabel ll = LiteralLabelFactory.create(value, "", XSDDatatype.XSDdateTime);

        return new LiteralImpl(Node.createLiteral(ll), this);

    }

    /**

     * Build a typed literal from its lexical form. The

     * lexical form will be parsed now and the value stored. If

     * the form is not legal this will throw an exception.

     *

     * @param lex the lexical form of the literal

     * @param dtype the type of the literal, null for old style "plain" literals

     * @throws DatatypeFormatException if lex is not a legal form of dtype

     */

    @Override

    public Literal createTypedLiteral(String lex, RDFDatatype dtype)

        throws DatatypeFormatException {

        return new LiteralImpl( Node.createLiteral( lex, "", dtype ), this);

    }

    /**

     * Build a typed literal from its value form.

     *

     * @param value the value of the literal

     * @param dtype the type of the literal, null for old style "plain" literals

     */

    @Override

    public Literal createTypedLiteral(Object value, RDFDatatype dtype) {

        LiteralLabel ll = LiteralLabelFactory.create(value, "", dtype);

        return new LiteralImpl( Node.createLiteral(ll), this );

    }

    /**

     * Build a typed literal from its lexical form. The

     * lexical form will be parsed now and the value stored. If

     * the form is not legal this will throw an exception.

     *

     * @param lex the lexical form of the literal

     * @param typeURI the uri of the type of the literal, null for old style "plain" literals

     * @throws DatatypeFormatException if lex is not a legal form of dtype

     */

    @Override

    public Literal createTypedLiteral(String lex, String typeURI)  {

        RDFDatatype dt = TypeMapper.getInstance().getSafeTypeByName(typeURI);

        LiteralLabel ll = LiteralLabelFactory.createLiteralLabel( lex, "", dt );

        return new LiteralImpl( Node.createLiteral(ll), this );

    }

    /**

     * Build a typed literal from its value form.

     *

     * @param value the value of the literal

     * @param typeURI the URI of the type of the literal, null for old style "plain" literals

     */

    @Override

    public Literal createTypedLiteral(Object value, String typeURI) {

        RDFDatatype dt = TypeMapper.getInstance().getSafeTypeByName(typeURI);

        LiteralLabel ll = LiteralLabelFactory.create(value, "", dt);

        return new LiteralImpl(Node.createLiteral(ll), this);

    }

    /**

     * Build a typed literal label from its value form using

     * whatever datatype is currently registered as the the default

     * representation for this java class. No language tag is supplied.

     * @param value the literal value to encapsulate

     */

    @Override

    public Literal createTypedLiteral( Object value )

    {

        // Catch special case of a Calendar which we want to act as if it were an XSDDateTime

        if (value instanceof Calendar)

            return createTypedLiteral( (Calendar)value );

        LiteralLabel ll = LiteralLabelFactory.create( value );

        return new LiteralImpl( Node.createLiteral( ll ), this);

    }

    @Override

    public Literal createLiteral( String v ) 

    { return createLiteral( v, "" ); }

    @Override

    public Literal createLiteral( String v, String l ) 

    { return literal( v, l, false ); }

    @Override

    public Literal createLiteral( String v, boolean wellFormed )

    { return literal( v, "", wellFormed ); }

    public Literal createLiteral(String v, String l, boolean wellFormed)

    { return literal( v, l, wellFormed ); }

    @Override

    public Statement createLiteralStatement( Resource r, Property p, boolean o )

    { return createStatement( r, p, createTypedLiteral( o ) ); }

    @Override

    public Statement createLiteralStatement( Resource r, Property p, long o )

    { return createStatement( r, p, createTypedLiteral( o ) ); }

    @Override

    public Statement createLiteralStatement( Resource r, Property p, int o )

    { return createStatement( r, p, createTypedLiteral( o ) ); }

    @Override

    public Statement createLiteralStatement( Resource r, Property p, char o )

    { return createStatement( r, p, createTypedLiteral( o ) ); }

    @Override

    public Statement createLiteralStatement( Resource r, Property p, float o )

    { return createStatement( r, p, createTypedLiteral( o ) ); }

    @Override

    public Statement createLiteralStatement( Resource r, Property p, double o )

    { return createStatement( r, p, createTypedLiteral( o ) ); }

    @Override

    public Statement createStatement( Resource r, Property p, String o )

    { return createStatement( r, p, createLiteral( o ) ); }

    @Override

    public Statement createLiteralStatement( Resource r, Property p, Object o )

    { return createStatement( r, p, asObject( o ) ); }

    @Override

    public Statement createStatement

    ( Resource r, Property p, String o, boolean wellFormed ) 

    { return createStatement( r, p, o, "", wellFormed ); }

    @Override

    public Statement createStatement(Resource r, Property p, String o, String l)

    { return createStatement( r, p, o, l, false ); }

    @Override

    public Statement createStatement

    ( Resource r, Property p, String o, String l, boolean wellFormed ) 

    { return createStatement( r, p, literal( o, l, wellFormed ) ); }

    @Override

    public Bag createBag() 

    { return createBag( null ); }

    @Override

    public Alt createAlt() 

    { return createAlt( null ); }

    @Override

    public Seq createSeq() 

    { return createSeq( null ); }

    /**

        Answer a (the) new empty list

        @return An RDF-encoded list of no elements (ie nil)

     */

    @Override

    public RDFList createList()

    { return getResource( RDF.nil.getURI() ).as( RDFList.class ); }

    /**

     * <p>Answer a new list containing the resources from the given iterator, in order.</p>

     * @param members An iterator, each value of which is expected to be an RDFNode.

     * @return An RDF-encoded list of the elements of the iterator

     */

    @Override

    public RDFList createList( Iterator<? extends RDFNode> members )

    {

        RDFList list = createList();

        while (members != null && members.hasNext()) list = list.with( members.next() );

        return list;

    }

    /**

     * <p>Answer a new list containing the RDF nodes from the given array, in order</p>

     * @param members An array of RDFNodes that will be the members of the list

     * @return An RDF-encoded list

     */

    @Override

    public RDFList createList( RDFNode[] members ) {

        return createList( Arrays.asList( members ).iterator() );

    }

    @Override

    public RDFNode getRDFNode( Node n )

    { return asRDFNode( n ); }

    @Override

    public Resource getResource( String uri ) 

    { return IteratorFactory.asResource(makeURI(uri),this); }

    @Override

    public Property getProperty( String uri ) 

    {

        if (uri == null) throw new InvalidPropertyURIException( null );

        return IteratorFactory.asProperty( makeURI(uri), this );

    }

    @Override

    public Property getProperty( String nameSpace,String localName )

    { return getProperty( nameSpace + localName ); }

    @Override

    public Seq getSeq( String uri ) 

    { return (Seq) IteratorFactory.asResource( makeURI( uri ),Seq.class, this); }

    @Override

    public Seq getSeq( Resource r ) 

    { return r.as( Seq.class ); }

    @Override

    public Bag getBag( String uri ) 

    { return (Bag) IteratorFactory.asResource( makeURI( uri ),Bag.class, this ); }

    @Override

    public Bag getBag( Resource r ) 

    { return r.as( Bag.class ); }

    static private Node makeURI(String uri)

    { return uri == null ? Node.createAnon() : Node.createURI( uri ); }

    @Override

    public Alt getAlt( String uri ) 

    { return (Alt) IteratorFactory.asResource( makeURI(uri) ,Alt.class, this ); }

    @Override

    public Alt getAlt( Resource r ) 

    { return r.as( Alt.class ); }

    @Override

    public long size() 

    { return graph.size(); }

    @Override

    public boolean isEmpty()

    { return graph.isEmpty(); }

    private void updateNamespace( Set<String> set, Iterator<Node> it )

    {

        while (it.hasNext())

        {

            Node node = it.next();

            if (node.isURI())

            {

                String uri = node.getURI();

                String ns = uri.substring( 0, Util.splitNamespace( uri ) );

                // String ns = IteratorFactory.asResource( node, this ).getNameSpace();

                set.add( ns );

            }

        }

    }

    private ExtendedIterator<Node> listPredicates()

    { return GraphUtil.listPredicates(graph, Node.ANY, Node.ANY ); }

    private Iterator<Node> listTypes()

    {

        Set<Node> types = CollectionFactory.createHashedSet();

        ClosableIterator<Triple> it = graph.find( null, RDF.type.asNode(), null );

        while (it.hasNext()) types.add( it.next().getObject() );

        return types.iterator();

    }

    @Override

    public NsIterator listNameSpaces()  {

        Set<String> nameSpaces = CollectionFactory.createHashedSet();

        updateNamespace( nameSpaces, listPredicates() );

        updateNamespace( nameSpaces, listTypes() );

        return new NsIteratorImpl(nameSpaces.iterator(), nameSpaces);

    }

    private PrefixMapping getPrefixMapping()

    { return getGraph().getPrefixMapping(); }

    @Override

    public boolean samePrefixMappingAs( PrefixMapping other )

    { return getPrefixMapping().samePrefixMappingAs( other ); }

    @Override

    public PrefixMapping lock()

    {

        getPrefixMapping().lock();

        return this;

    }

    @Override

    public PrefixMapping setNsPrefix( String prefix, String uri )

    {

        getPrefixMapping().setNsPrefix( prefix, uri );

        return this;

    }

    @Override

    public PrefixMapping removeNsPrefix( String prefix )

    {

        getPrefixMapping().removeNsPrefix( prefix );

        return this;

    }

    @Override

    public PrefixMapping setNsPrefixes( PrefixMapping pm )

    {

        getPrefixMapping().setNsPrefixes( pm );

        return this;

    }

    @Override

    public PrefixMapping setNsPrefixes( Map<String, String> map )

    {

        getPrefixMapping().setNsPrefixes( map );

        return this;

    }

    @Override

    public PrefixMapping withDefaultMappings( PrefixMapping other )

    {

        getPrefixMapping().withDefaultMappings( other );

        return this;

    }

    @Override

    public String getNsPrefixURI( String prefix )

    { return getPrefixMapping().getNsPrefixURI( prefix ); }

    @Override

    public String getNsURIPrefix( String uri )

    { return getPrefixMapping().getNsURIPrefix( uri ); }

    @Override

    public Map<String, String> getNsPrefixMap()

    { return getPrefixMapping().getNsPrefixMap(); }

    @Override

    public String expandPrefix( String prefixed )

    { return getPrefixMapping().expandPrefix( prefixed ); }

    @Override

    public String qnameFor( String uri )

    { return getPrefixMapping().qnameFor( uri ); }

    @Override

    public String shortForm( String uri )

    { return getPrefixMapping().shortForm( uri ); }

    /**

        Service method to update the namespaces of  a Model given the

        mappings from prefix names to sets of URIs.

        If the prefix maps to multiple URIs, then we discard it completely.

        @param the Model who's namespace is to be updated

        @param ns the namespace map to add to the Model     

     */

    public static void addNamespaces( Model m, Map<String, Set<String>> ns )

    {

        PrefixMapping pm = m;

        Iterator<Map.Entry<String, Set<String>>> it  = ns.entrySet().iterator();

        while (it.hasNext())

        {

            Map.Entry<String, Set<String>> e = it.next();

            String key = e.getKey();

            Set<String>  values = e.getValue();

            Set<String> niceValues = CollectionFactory.createHashedSet();

            Iterator<String> them = values.iterator();

            while (them.hasNext())

            {

                String uri = them.next();

                if (PrefixMappingImpl.isNiceURI( uri )) niceValues.add( uri );

            }

            if (niceValues.size() == 1)

                pm.setNsPrefix( key, niceValues.iterator().next() );

        }           

    }

    @Override

    public StmtIterator listStatements() 

    { return IteratorFactory.asStmtIterator( GraphUtil.findAll( graph ), this); }

    /**

        add a Statement to this Model by adding its SPO components.

     */

    @Override

    public Model add( Statement s ) 

    {

        add( s.getSubject(), s.getPredicate(), s.getObject() );

        return this;

    }

    /**

        Add all the statements to the model by converting them to an array of corresponding

        triples and removing those from the underlying graph.

     */

    @Override

    public Model add( Statement [] statements )

    {

        GraphUtil.add(getGraph(), StatementImpl.asTriples( statements ) );

        return this;

    }

    /**

        Add all the statements to the model by converting the list to an array of

        Statement and removing that.

     */

    @Override

    public Model add( List<Statement> statements )

    {

        GraphUtil.add(getGraph(), asTriples( statements ) );

        return this;

    }

    private List<Triple> asTriples( List<Statement> statements )

    {

        List<Triple> L = new ArrayList<Triple>( statements.size() );

        for (int i = 0; i < statements.size(); i += 1)

            L.add( statements.get(i).asTriple() );

        return L;

    }

    private Iterator<Triple> asTriples( StmtIterator it )

    { return it.mapWith( mapAsTriple ); }

    private Map1<Statement, Triple> mapAsTriple = new Map1<Statement, Triple>() {

        @Override

        public Triple map1( Statement s ) { return s.asTriple(); }

    };

   

    /**

        remove all the Statements from the model by converting them to triples and

        removing those triples from the underlying graph.       

     */

    @Override

    public Model remove( Statement [] statements )

    {

        GraphUtil.delete( getGraph(), StatementImpl.asTriples( statements ) );       

        return this;

    }

    /**

        Remove all the Statements from the model by converting the List to a

        List(Statement) and removing that.

     */

    @Override

    public Model remove( List<Statement> statements )

    {

        GraphUtil.delete( getGraph(), asTriples( statements ) );

        return this;

    }

    @Override

    public Model add( Resource s, Property p, RDFNode o )  {

        modelReifier.noteIfReified( s, p, o );

        graph.add( Triple.create( s.asNode(), p.asNode(), o.asNode() ) );

        return this;

    }

    @Override

    @Deprecated

    public ReificationStyle getReificationStyle()

    { return modelReifier.getReificationStyle(); }

    /**

        @return an iterator which delivers all the ReifiedStatements in this model

     */

    @Override

    public RSIterator listReifiedStatements()

    { return modelReifier.listReifiedStatements(); }

    /**

        @return an iterator each of whose elements is a ReifiedStatement in this

            model such that it's getStatement().equals( st )

     */

    @Override

    public RSIterator listReifiedStatements( Statement st )

    { return modelReifier.listReifiedStatements( st ); }

    /**

        @return true iff this model has a reification of _s_ in some Statement

     */

    @Override

    public boolean isReified( Statement s )

    { return modelReifier.isReified( s ); }

    /**

        get any reification of the given statement in this model; make

        one if necessary.