Author: tabish
Date: Fri May 30 07:58:02 2008
New Revision: 661747
URL: http://svn.apache.org/viewvc?rev=661747&view=rev
Log:
http://issues.apache.org/activemq/browse/AMQCPP-172
Added:
activemq/activemq-cpp/trunk/src/main/decaf/util/List.h
Added: activemq/activemq-cpp/trunk/src/main/decaf/util/List.h
URL:
http://svn.apache.org/viewvc/activemq/activemq-cpp/trunk/src/main/decaf/util/List.h?rev=661747&view=auto
==============================================================================
--- activemq/activemq-cpp/trunk/src/main/decaf/util/List.h (added)
+++ activemq/activemq-cpp/trunk/src/main/decaf/util/List.h Fri May 30 07:58:02
2008
@@ -0,0 +1,405 @@
+/*
+ * 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_LIST_H_
+#define _DECAF_UTIL_LIST_H_
+
+#include <list>
+#include <algorithm>
+#include <decaf/lang/exceptions/NoSuchElementException.h>
+#include <decaf/lang/exceptions/IndexOutOfBoundsException.h>
+#include <decaf/util/concurrent/Synchronizable.h>
+#include <decaf/util/concurrent/Mutex.h>
+#include <decaf/util/Iterator.h>
+
+namespace decaf{
+namespace util{
+
+ /**
+ * Set template that wraps around a std::set to provide a more
+ * user-friendly interface and to provide common functions that do
+ * not exist in std::list.
+ */
+ template <typename E> class List : public util::concurrent::Synchronizable
{
+ private:
+
+ std::list<E> values;
+ util::concurrent::Mutex mutex;
+
+ private:
+
+ class ListIterator : public Iterator<E> {
+ private:
+
+ typename std::list<E>::iterator current;
+ typename std::list<E>::iterator previous;
+ typename std::list<E>* list;
+
+ public:
+
+ ListIterator( typename std::list<E>* list ) {
+ this->current = list->begin();
+ this->previous = list->end();
+ this->list = list;
+ }
+ virtual ~ListIterator() {}
+
+ virtual E next() throw( lang::exceptions::NoSuchElementException ){
+ if( this->current == list->end() ) {
+ throw lang::exceptions::NoSuchElementException(
+ __FILE__, __LINE__,
+ "List::Iterator::next - No more elements to return" );
+ }
+
+ this->previous = this->current;
+ return *( this->current++ );
+ }
+
+ virtual bool hasNext() const {
+ return ( this->current != list->end() );
+ }
+
+ virtual void remove() throw (
lang::exceptions::IllegalStateException,
+
lang::exceptions::UnsupportedOperationException ){
+ if( this->previous == list->end() ) {
+ throw lang::exceptions::IllegalStateException(
+ __FILE__, __LINE__,
+ "List::Iterator::remove - Invalid State to call
remove" );
+ }
+
+ this->list->erase( this->previous );
+ this->previous = this->list->end();
+ }
+ };
+
+ public:
+
+ /**
+ * Default constructor - does nothing.
+ */
+ List(){}
+
+ /**
+ * Copy constructor - copies the content of the given set into this
+ * one.
+ * @param source The source set.
+ */
+ List( const List& source ){
+ copy( source );
+ }
+
+ virtual ~List(){}
+
+ /**
+ * Returns an iterator for this collection. The order of Iteration
+ * is in no particular order other than the natural ording of the
+ * elements in the List class.
+ * @returns Iterator<E> for this collection
+ */
+ Iterator<E>* iterator() {
+ return new ListIterator( &values );
+ }
+
+ /**
+ * Copies the content of the source set into this set. Erases
+ * all existing data in this st.
+ * @param source The source object to copy from.
+ */
+ virtual void copy( const List& source ) {
+ // Add all of the entries to this map.
+ values = source.values;
+ }
+
+ /**
+ * Removes all values from this set.
+ */
+ virtual void clear() {
+ values.clear();
+ }
+
+ /**
+ * Indicates whether or this set contains the given value.
+ * @param value The value to look up.
+ * @return true if this set contains the value, otherwise false.
+ */
+ 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();
+ }
+
+ /**
+ * Returns the index of the first occurrence of the specified element
in
+ * this list, or -1 if this list does not contain the element. More
+ * formally, returns the lowest index i such that get(i) == value, or
+ * -1 if there is no such index.
+ *
+ * @param value - element to search for
+ * @return the index of the first occurrence of the specified element
in
+ * this list,
+ * @throw NoSuchElementException if value is not in the list
+ */
+ virtual size_t indexOf( const E& value )
+ throw ( decaf::lang::exceptions::NoSuchElementException ) {
+
+ typename std::list<E>::iterator iter;
+ iter = std::find( values.begin(), values.end(), value );
+
+ if( iter == values.end() ) {
+ throw decaf::lang::exceptions::NoSuchElementException(
+ __FILE__, __LINE__,
+ "List::indexOf - No matching element in list" );
+ }
+
+ return std::distance( values.begin(), iter );
+ }
+
+ /**
+ * Returns the index of the last occurrence of the specified element in
+ * this list, or -1 if this list does not contain the element. More
+ * formally, returns the highest index i such that get(i) == value
+ * or -1 if there is no such index.
+ *
+ * @param value - element to search for
+ * @return the index of the last occurrence of the specified element in
+ * this list.
+ * @throw NoSuchElementException if value is not in the list
+ */
+ virtual size_t lastIndexOf( const E& value ) {
+ typename std::list<E>::reverse_iterator iter;
+ iter = std::find( values.rbegin(), values.rend(), value );
+
+ if( iter == values.rend() ) {
+ throw decaf::lang::exceptions::NoSuchElementException(
+ __FILE__, __LINE__,
+ "List::lastIndexOf - No matching element in list" );
+ }
+
+ // Now reverse the result to get the last index
+ return this->size() - std::distance( values.rbegin(), iter ) - 1;
+ }
+
+ /**
+ * @return if the set contains any element or not, TRUE or FALSE
+ */
+ virtual bool isEmpty() const {
+ return values.empty();
+ }
+
+ /**
+ * @return The number of elements in this set.
+ */
+ virtual std::size_t size() const {
+ return values.size();
+ }
+
+ /**
+ * Gets the element contained at position passed
+ * @param index - position to get
+ * @return value at index
+ */
+ virtual E get( std::size_t index ) const
+ throw ( decaf::lang::exceptions::IndexOutOfBoundsException ) {
+
+ if( index >= this->size() ) {
+ throw decaf::lang::exceptions::IndexOutOfBoundsException(
+ __FILE__, __LINE__,
+ "List::get - Index greater than size()" );
+ }
+
+ // 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 );
+ }
+
+ /**
+ * Replaces the element at the specified position in this list with the
+ * specified element.
+ *
+ * @param index - index of the element to replace
+ * @param element - element to be stored at the specified position
+ * @return the element previously at the specified position
+ * @throw IndexOutOfBoundsException - if the index is greater tham size
+ */
+ virtual E set( std::size_t index, E element )
+ throw ( decaf::lang::exceptions::IndexOutOfBoundsException ){
+
+ if( index >= this->size() ) {
+ throw decaf::lang::exceptions::IndexOutOfBoundsException(
+ __FILE__, __LINE__,
+ "List::get - Index greater than size()" );
+ }
+
+ // 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;
+ }
+
+ /**
+ * Adds the given value to the set.
+ * @param value The value to add.
+ */
+ virtual void add( const E& value ) {
+ values.insert( values.end(), value );
+ }
+
+ /**
+ * Inserts the specified element at the specified position in this
list.
+ * Shifts the element currently at that position (if any) and any
+ * subsequent elements to the right (adds one to their indices).
+ *
+ * @param index - index at which the specified element is to be
inserted
+ * @param element - element to be inserted
+ * @throw IndexOutOfBoundsException - if the index is greater tham size
+ */
+ virtual void add( std::size_t index, E element )
+ throw ( decaf::lang::exceptions::IndexOutOfBoundsException ){
+
+ if( 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 );
+ }
+
+ /**
+ * Removes the value from the set.
+ * @param value The value to be removed.
+ */
+ virtual void remove( const E& value ) {
+ values.remove( value );
+ }
+
+ /**
+ * Removes the element at the specified position in this list.
+ * Shifts any subsequent elements to the left (subtracts one from their
+ * indices). Returns the element that was removed from the list.
+ *
+ * @param index - the index of the element to be removed
+ * @return the element previously at the specified position
+ * @throw IndexOutOfBoundsException - if the index >= size()
+ */
+ virtual E remove( std::size_t index ) {
+
+ if( 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 );
+ E oldValue = *iter;
+ this->values.erase( iter );
+
+ return oldValue;
+ }
+
+ /**
+ * @return the all values in this set as a std::vector.
+ */
+ virtual std::vector<E> toArray() const {
+ std::vector<E> valueArray( values.size() );
+
+ typename std::list<E>::const_iterator iter;
+ iter=values.begin();
+ for( int ix=0; iter != values.end(); ++iter, ++ix ){
+ valueArray[ix] = *iter;
+ }
+
+ return valueArray;
+ }
+
+ public: // Methods from Synchronizable
+
+ /**
+ * Locks the object.
+ * @throws Exception
+ */
+ virtual void lock() throw( lang::Exception ) {
+ mutex.lock();
+ }
+
+ /**
+ * Unlocks the object.
+ * @throws Exception
+ */
+ virtual void unlock() throw( lang::Exception ) {
+ mutex.unlock();
+ }
+
+ /**
+ * Waits on a signal from this object, which is generated
+ * by a call to Notify. Must have this object locked before
+ * calling.
+ * @throws Exception
+ */
+ virtual void wait() throw( lang::Exception ) {
+ mutex.wait();
+ }
+
+ /**
+ * Waits on a signal from this object, which is generated
+ * by a call to Notify. Must have this object locked before
+ * calling. This wait will timeout after the specified time
+ * interval.
+ * @param millisecs the time in millisecsonds to wait, or
+ * WAIT_INIFINITE
+ * @throws Exception
+ */
+ virtual void wait( unsigned long millisecs )
+ throw( lang::Exception ) {
+ mutex.wait( millisecs );
+ }
+
+ /**
+ * Signals a waiter on this object that it can now wake
+ * up and continue. Must have this object locked before
+ * calling.
+ * @throws Exception
+ */
+ virtual void notify() throw( lang::Exception ) {
+ mutex.notify();
+ }
+
+ /**
+ * Signals the waiters on this object that it can now wake
+ * up and continue. Must have this object locked before
+ * calling.
+ * @throws Exception
+ */
+ virtual void notifyAll() throw( lang::Exception ) {
+ mutex.notifyAll();
+ }
+
+ };
+
+}}
+
+#endif /*_DECAF_UTIL_LIST_H_*/
