src/main/decaf/util/StlList.h

Go to the documentation of this file.

/*
 * 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.
 */

#ifndef _DECAF_UTIL_STLLIST_H_
#define _DECAF_UTIL_STLLIST_H_

#include <list>
#include <algorithm>
#include <memory>
#include <decaf/lang/exceptions/UnsupportedOperationException.h>
#include <decaf/util/NoSuchElementException.h>
#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>
#include <decaf/util/Config.h>
#include <decaf/util/Iterator.h>
#include <decaf/util/ListIterator.h>
#include <decaf/util/List.h>
#include <decaf/util/AbstractList.h>

namespace decaf{
namespace util{

    template <typename E>
    class StlList : public decaf::util::AbstractList<E> {
    private:

        std::list<E> values;

    private:

        class StlListIterator : public ListIterator<E> {
        private:

            typename std::list<E>::iterator current;
            typename std::list<E>::iterator prev;
            typename std::list<E>* list;

        private:

            StlListIterator( const StlListIterator& );
            StlListIterator operator= ( const StlListIterator& );

        public:

            StlListIterator( typename std::list<E>* list, int index ) :
                current( list->begin() ), prev( list->end() ), list( list ) {

                if( index < (int)list->size() ) {
                    std::advance( this->current, index );
                } else {
                    this->current = list->end();
                }
            }

            virtual ~StlListIterator() {}

            virtual E next() {
                if( this->current == list->end() ) {
                    throw NoSuchElementException(
                        __FILE__, __LINE__,
                        "List::Iterator::next - No more elements to return" );
                }

                this->prev = this->current;
                return *( this->current++ );
            }

            virtual bool hasNext() const {
                return ( this->current != list->end() );
            }

            virtual void remove() {
                if( this->prev == list->end() ) {
                    throw lang::exceptions::IllegalStateException(
                        __FILE__, __LINE__,
                        "List::Iterator::remove - Invalid State to call remove" );
                }

                this->list->erase( this->prev );
                this->prev = this->list->end();
            }

            virtual void add( const E& e ) {
                this->list->insert( this->current, e );
            }

            virtual void set( const E& e ) {

                if( this->current == list->end() ) {
                    this->list->insert( this->current, e );
                } else {
                    *( this->current ) = e;
                }
            }

            virtual bool hasPrevious() const {
                return ( this->current != this->list->begin() );
            }

            virtual E previous() {
                if( this->current == this->list->begin() ) {
                    throw NoSuchElementException(
                        __FILE__, __LINE__,
                        "List::ListIterator::previous - No Previous element." );
                }

                typename std::list<E>::const_iterator iter = this->current;
                return *( iter-- );
            }

            virtual int nextIndex() const {
                if( this->current == this->list->end() ) {
                    return (int)this->list->size();
                }

                return (int)std::distance( this->list->begin(), this->current );
            }

            virtual int previousIndex() const {
                if( this->current == this->list->begin() ) {
                    return -1;
                }

                return (int)std::distance( this->list->begin(), this->current ) - 1;
            }

        };

        class ConstStlListIterator : public decaf::util::ListIterator<E> {
        private:

            typename std::list<E>::const_iterator current;
            typename std::list<E>::const_iterator prev;
            const typename std::list<E>* list;

        private:

            ConstStlListIterator( const ConstStlListIterator& );
            ConstStlListIterator operator= ( const ConstStlListIterator& );

        public:

            ConstStlListIterator( const typename std::list<E>* list, int index ) :
                ListIterator<E>(), current( list->begin() ), prev( list->end() ), list( list ) {

                if( index < (int)list->size() ) {
                    std::advance( this->current, index );
                } else {
                    this->current = list->end();
                }
            }

            virtual ~ConstStlListIterator() {}

            virtual E next() {
                if( this->current == list->end() ) {
                    throw NoSuchElementException(
                        __FILE__, __LINE__,
                        "List::Iterator::next - No more elements to return" );
                }

                this->prev = this->current;
                return *( this->current++ );
            }

            virtual bool hasNext() const {
                return ( this->current != list->end() );
            }

            virtual void remove() {

                throw lang::exceptions::UnsupportedOperationException(
                    __FILE__, __LINE__,
                    "List::ListIterator::remove - Const Iterator." );
            }

            virtual void add( const E& e DECAF_UNUSED ) {

                throw lang::exceptions::UnsupportedOperationException(
                    __FILE__, __LINE__,
                    "List::ListIterator::add - Const Iterator." );
            }

            virtual void set( const E& e DECAF_UNUSED ) {

                throw lang::exceptions::UnsupportedOperationException(
                    __FILE__, __LINE__,
                    "List::ListIterator::set - Const Iterator." );
            }

            virtual bool hasPrevious() const {
                return ( this->current != this->list->begin() );
            }

            virtual E previous() {
                if( this->current == this->list->begin() ) {
                    throw NoSuchElementException(
                        __FILE__, __LINE__,
                        "List::ListIterator::previous - No Previous element." );
                }

                typename std::list<E>::const_iterator iter = this->current;
                return *( iter-- );
            }

            virtual int nextIndex() const {
                if( this->current == this->list->end() ) {
                    return (int)this->list->size();
                }

                return (int)std::distance( this->list->begin(), this->current );
            }

            virtual int previousIndex() const {
                if( this->current == this->list->begin() ) {
                    return -1;
                }

                return (int)std::distance( this->list->begin(), this->current ) - 1;
            }
        };

    public:

        StlList() : AbstractList<E>(), values() {}

        StlList( const StlList& source ) : AbstractList<E>(), values() {
            copy( source );
        }

        StlList( const Collection<E>& source ) : AbstractList<E>(), values() {
            AbstractList<E>::copy( source );
        }

        virtual bool equals( const Collection<E>& collection ) const {

            const StlList<E>* listptr = dynamic_cast<const StlList<E>*>( &collection );
            if( listptr == NULL ) {
                return AbstractList<E>::equals( collection );
            }

            return this->values == listptr->values;
        }

        virtual void copy( const Collection<E>& collection ) {

            const StlList<E>* listptr = dynamic_cast<const StlList<E>*>( &collection );
            if( listptr == NULL ) {
                AbstractList<E>::copy( collection );
                return;
            }

            this->values.clear();
            this->values = listptr->values;
        }

        virtual Iterator<E>* iterator() {
            return new StlListIterator( &values, 0 );
        }
        virtual Iterator<E>* iterator() const {
            return new ConstStlListIterator( &values, 0 );
        }

        virtual ListIterator<E>* listIterator() {
            return new StlListIterator( &values, 0 );
        }
        virtual ListIterator<E>* listIterator() const {
            return new ConstStlListIterator( &values, 0 );
        }

        virtual ListIterator<E>* listIterator( int index ) {

            if( index < 0 || index > this->size() ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__,
                    "List::listIterator - Index greater than size() or negative" );
            }

            return new StlListIterator( &values, index );
        }
        virtual ListIterator<E>* listIterator( int index ) const {

            if( index < 0 || index > this->size() ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__,
                    "List::listIterator - Index greater than size() or negative" );
            }

            return new ConstStlListIterator( &values, index );
        }

        virtual void clear() {
            values.clear();
        }

        virtual bool isEmpty() const {
            return values.empty();
        }

        virtual int size() const {
            return (int)values.size();
        }

        virtual E get( int index ) const {

            if( index < 0 || index >= this->size() ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__,
                    "List::get - Index greater than size() or negative" );
            }

            // Advance from begin and return the value at that location.
            typename std::list<E>::const_iterator iter = this->values.begin();
            std::advance( iter, index );
            return *( iter );
        }

        virtual E set( int index, const E& element ) {

            if( index < 0 || index >= this->size() ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__,
                    "List::get - Index greater than size() or negative" );
            }

            // Advance from begin and return the value at that location
            // after setting the value to the new value.
            typename std::list<E>::iterator iter = this->values.begin();
            std::advance( iter, index );
            E oldValue = *iter;
            *iter = element;

            return oldValue;
        }

        virtual void add( int index, const E& element ) {

            if( index < 0 || index > this->size() ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__,
                    "List::add - Index greater than size()" );
            }

            // Advance from begin and insert the value at that location
            typename std::list<E>::iterator iter = this->values.begin();
            std::advance( iter, index );
            this->values.insert( iter, element );
        }

        virtual bool add( const E& value ) {
            values.insert( values.end(), value );
            return true;
        }

        virtual bool addAll( const Collection<E>& collection ) {

            if( collection.isEmpty() ) {
                return false;
            }

            std::vector<E> array = collection.toArray();
            typename std::vector<E>::const_iterator vecIter = array.begin();

            std::auto_ptr< ListIterator<E> > iter( this->listIterator( (int)this->values.size() ) );

            while( vecIter != array.end() ) {
                iter->add( *( vecIter++) );
            }

            return true;
        }

        virtual bool addAll( int index, const Collection<E>& collection ) {

            if( index < 0 || index > this->size() ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__,
                    "List::addAll - Index greater than size()" );
            }

            if( collection.isEmpty() ) {
                return false;
            }

            std::vector<E> array = collection.toArray();
            typename std::vector<E>::const_iterator vecIter = array.begin();

            std::auto_ptr< ListIterator<E> > iter( this->listIterator( index ) );

            while( vecIter != array.end() ) {
                iter->add( *( vecIter++) );
            }

            return true;
        }

        virtual bool remove( const E& value ) {

            int origSize = this->size();
            this->values.remove( value );
            return origSize != this->size();
        }

        virtual E removeAt( int index ) {

            if( index < 0 || index >= this->size() ) {
                throw decaf::lang::exceptions::IndexOutOfBoundsException(
                    __FILE__, __LINE__,
                    "List::removeAt - Index greater than size() or negative" );
            }

            // Advance from begin and insert the value at that location
            typename std::list<E>::iterator iter = this->values.begin();
            std::advance( iter, index );
            E oldValue = *iter;
            this->values.erase( iter );

            return oldValue;
        }

        virtual int indexOf( const E& value ) const {

            typename std::list<E>::const_iterator iter;
            iter = std::find( values.begin(), values.end(), value );

            if( iter == values.end() ) {
                return -1;
            }

            return (int)std::distance( values.begin(), iter );
        }

        virtual int lastIndexOf( const E& value ) const {

            typename std::list<E>::const_reverse_iterator iter;
            iter = std::find( values.rbegin(), values.rend(), value );

            if( iter == values.rend() ) {
                return -1;
            }

            // Now reverse the result to get the last index
            return (int)( this->size() - std::distance( values.rbegin(), iter ) - 1 );
        }

        virtual bool contains( const E& value ) const {
            typename std::list<E>::const_iterator iter;
            iter = std::find( values.begin(), values.end(), value );
            return iter != values.end();
        }

    };

}}

#endif /*_DECAF_UTIL_STLLIST_H_*/