activemq-cpp/src/main/decaf/util/ListIterator.h

/*
 * 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_LISTITERATOR_H_
#define _DECAF_UTIL_LISTITERATOR_H_

#include <decaf/util/Iterator.h>
#include <decaf/util/Config.h>
#include <decaf/lang/exceptions/IllegalArgumentException.h>

namespace decaf{
namespace util{

    /**
     * An iterator for lists that allows the programmer to traverse the list
     * in either direction, modify the list during iteration, and obtain the
     * iterator's current position in the list.
     *
     * Note that the remove() and set(Object) methods are not defined in terms
     * of the cursor position; they are defined to operate on the last element
     * returned by a call to next() or previous().
     */
    template< typename E>
    class ListIterator : public decaf::util::Iterator<E> {
    public:

        virtual ~ListIterator() {}

        /**
         * Inserts the specified element into the list (optional operation). The
         * element is inserted immediately before the next element that would be
         * returned by next, if any, and after the next element that would be
         * returned by previous, if any. (If the list contains no elements, the
         * new element becomes the sole element on the list.) The new element is
         * inserted before the implicit cursor: a subsequent call to next would
         * be unaffected, and a subsequent call to previous would return the new
         * element. (This call increases by one the value that would be returned
         * by a call to nextIndex or previousIndex.)
         *
         * @param e
         *      The element to insert into the List.
         *
         * @throw UnsupportedOperationException if the add method is not
         *        supported by this list iterator.
         * @throw IllegalArgumentException if some aspect of this element
         *        prevents it from being added to this list.
         */
        virtual void add(const E& e) = 0;

        /**
         * Replaces the last element returned by next or previous with the
         * specified element (optional operation). This call can be made only
         * if neither ListIterator.remove nor ListIterator.add have been
         * called after the last call to next or previous.
         *
         * @param e
         *      The element with which to replace the last element returned
         *      by next or previous.
         *
         * @throw UnsupportedOperationException if the add method is not
         *        supported by this list iterator.
         * @throw IllegalArgumentException if some aspect of this element
         *        prevents it from being added to this list.
         * @throw IllegalStateException if neither next nor previous have been
         *        called, or remove or add have been called after the last call to next
         *        or previous.
         */
        virtual void set(const E& e) = 0;

        /**
         * Returns true if this list iterator has more elements when traversing the
         * list in the reverse direction. (In other words, returns true if previous
         * would return an element rather than throwing an exception.)
         *
         * @return true if the list iterator has more elements when traversing the list
         *         in the reverse direction.
         */
        virtual bool hasPrevious() const = 0;

        /**
         * Returns the previous element in the list. This method may be called
         * repeatedly to iterate through the list backwards, or intermixed with
         * calls to next to go back and forth. (Note that alternating calls to
         * next and previous will return the same element repeatedly.)
         *
         * @return the previous element in the list.
         *
         * @throw NoSuchElementException if the iteration has no previous element.
         */
        virtual E previous() = 0;

        /**
         * Returns the index of the element that would be returned by a
         * subsequent call to next. (Returns list size if the list iterator
         * is at the end of the list.)
         *
         * @return the index of the element that would be returned by a
         *         subsequent call to next, or list size if list iterator is
         *         at end of list.
         */
        virtual int nextIndex() const = 0;

        /**
         * Returns the index of the element that would be returned by a
         * subsequent call to previous. (Returns -1 if the list iterator is
         * at the beginning of the list.)
         *
         * @return the index of the element that would be returned by a
         *         subsequent call to previous, or -1 if list iterator is
         *         at beginning of list.
         */
        virtual int previousIndex() const = 0;

    };

}}

#endif /*_DECAF_UTIL_LISTITERATOR_H_*/