//Auto-generated by kalyptus. DO NOT EDIT.
namespace Soprano {
    using Soprano;
    using System;
    using Qyoto;
    using System.Collections.Generic;
    /// <remarks>
    ///  \class StatementIterator statementiterator.h Soprano/StatementIterator
    ///  \brief An iterator that provides a stream of Statements.
    ///  The most common use of StatementIterator is through Model.ListStatements().
    ///  Many backends do lock the underlying Model during iteration. Thus, 
    ///  it is always a good idea to cache the results if they are to be used
    ///  to modify the model to prevent a deadlock:
    ///  <pre>
    ///  Soprano.StatementIterator it = model.ListStatements();
    ///  QList<Statement> allStatements = it.allElements();
    ///  Q_FOREACH( Soprano.Statement s, allStatements ) {
    ///     modifyTheModel( model, s );
    ///  }
    ///  </pre>
    ///  Iterators have to be closed.
    ///  This can either be achieved by deleting the iterator, finishing it (next() does return <pre>false</pre>),
    ///  or calling close(). Before that other operations on the Model may block.
    ///  Iterators are not thread-safe. Two threads using the same iterator may result
    ///  in undefined behaviour and even crashes. An iterator needs to be closed by the
    ///  same thread that opened it (except if the iterator contains special code to handle such
    ///  a situation.)
    ///  \warning Be aware that iterators in Soprano are shared objects which means
    ///  that copies of one iterator object work on the same data.
    ///  For further details on %Soprano iterators see Iterator.
    ///  \author Daniele Galdi <daniele.galdi@gmail.com><br>Sebastian Trueg <trueg@kde.org>
    ///      </remarks>        <short>    \class StatementIterator statementiterator.</short>
    [SmokeClass("Soprano::StatementIterator")]
    public class StatementIterator : Soprano.Iterator, IDisposable {
        protected StatementIterator(Type dummy) : base((Type) null) {}
        protected new void CreateProxy() {
            interceptor = new SmokeInvocation(typeof(StatementIterator), this);
        }
        // Soprano::StatementIterator* StatementIterator(Soprano::IteratorBackend<Soprano::Statement>* arg1); >>>> NOT CONVERTED
        /// <remarks>
        ///  Creates and empty, invalid iterator.
        ///          </remarks>        <short>    Creates and empty, invalid iterator.</short>
        public StatementIterator() : this((Type) null) {
            CreateProxy();
            interceptor.Invoke("StatementIterator", "StatementIterator()", typeof(void));
        }
        public StatementIterator(Soprano.StatementIterator sti) : this((Type) null) {
            CreateProxy();
            interceptor.Invoke("StatementIterator#", "StatementIterator(const Soprano::StatementIterator&)", typeof(void), typeof(Soprano.StatementIterator), sti);
        }
        /// <remarks>
        ///  Convenience method which extracts all statements (this does not include the
        ///  statements that have already been read from the iterator) from the iterator
        ///  and returns them in a list.
        ///  Be aware that after calling this method the iterator will be invalid.
        ///  \return A list of all statements that rest in the iterator.
        ///          </remarks>        <short>    Convenience method which extracts all statements (this does not include the  statements that have already been read from the iterator) from the iterator  and returns them in a list.</short>
        public List<Soprano.Statement> AllStatements() {
            return (List<Soprano.Statement>) interceptor.Invoke("allStatements", "allStatements()", typeof(List<Soprano.Statement>));
        }
        /// <remarks>
        ///  Convenience method that creates an iterator over the subject nodes of the statements
        ///  in this iterator.
        ///  \warning The new iterator is just a wrapper around this one. Thus, changing it will also
        ///  change this one.
        ///  \return A wrapper iterator over the subject nodes.
        ///          </remarks>        <short>    Convenience method that creates an iterator over the subject nodes of the statements  in this iterator.</short>
        public Soprano.NodeIterator IterateSubjects() {
            return (Soprano.NodeIterator) interceptor.Invoke("iterateSubjects", "iterateSubjects() const", typeof(Soprano.NodeIterator));
        }
        /// <remarks>
        ///  Convenience method that creates an iterator over the predicate nodes of the statements
        ///  in this iterator.
        ///  \warning The new iterator is just a wrapper around this one. Thus, changing it will also
        ///  change this one.
        ///  \return A wrapper iterator over the predicate nodes.
        ///          </remarks>        <short>    Convenience method that creates an iterator over the predicate nodes of the statements  in this iterator.</short>
        public Soprano.NodeIterator IteratePredicates() {
            return (Soprano.NodeIterator) interceptor.Invoke("iteratePredicates", "iteratePredicates() const", typeof(Soprano.NodeIterator));
        }
        /// <remarks>
        ///  Convenience method that creates an iterator over the object nodes of the statements
        ///  in this iterator.
        ///  \warning The new iterator is just a wrapper around this one. Thus, changing it will also
        ///  change this one.
        ///  \return A wrapper iterator over the object nodes.
        ///          </remarks>        <short>    Convenience method that creates an iterator over the object nodes of the statements  in this iterator.</short>
        public Soprano.NodeIterator IterateObjects() {
            return (Soprano.NodeIterator) interceptor.Invoke("iterateObjects", "iterateObjects() const", typeof(Soprano.NodeIterator));
        }
        /// <remarks>
        ///  Convenience method that creates an iterator over the context nodes of the statements
        ///  in this iterator.
        ///  \warning The new iterator is just a wrapper around this one. Thus, changing it will also
        ///  change this one.
        ///  \return A wrapper iterator over the context nodes.
        ///          </remarks>        <short>    Convenience method that creates an iterator over the context nodes of the statements  in this iterator.</short>
        public Soprano.NodeIterator IterateContexts() {
            return (Soprano.NodeIterator) interceptor.Invoke("iterateContexts", "iterateContexts() const", typeof(Soprano.NodeIterator));
        }
        ~StatementIterator() {
            interceptor.Invoke("~StatementIterator", "~StatementIterator()", typeof(void));
        }
        public void Dispose() {
            interceptor.Invoke("~StatementIterator", "~StatementIterator()", typeof(void));
        }
    }
}
