## NAME

ACE_Unbounded_Queue - A Queue of "infinite" length.

## SYNOPSIS

    #include <ace/Containers.h>

    template<class T>
    class ACE_Unbounded_Queue
    {
      public:
        friend class ACE_Unbounded_Queue_Iterator<T>;
        typedef ACE_Unbounded_Queue_Iterator<T> ITERATOR;
        ACE_Unbounded_Queue (ACE_Allocator *alloc = 0);
        ACE_Unbounded_Queue (const ACE_Unbounded_Queue<T> &);
        void operator= (const ACE_Unbounded_Queue<T> &);
        ~ACE_Unbounded_Queue (void);
        int is_empty (void) const;
        int is_full (void) const;
        int enqueue_tail (const T &new_item);
        int enqueue_head (const T &new_item);
        int dequeue_head (T &item);
        void reset (void);
        int get (T *&item, size_t slot = 0) const;
        int set (const T &item, size_t slot);
        size_t size (void) const;
        void dump (void) const;
        ACE_Unbounded_Queue_Iterator<T> begin (void);
        ACE_Unbounded_Queue_Iterator<T> end (void);
        ACE_ALLOC_HOOK_DECLARE;
      protected:
        void delete_nodes (void);
        void copy_nodes (const ACE_Unbounded_Queue<T> &);
        ACE_Node<T> *head_;
        size_t cur_size_;
        ACE_Allocator *allocator_;
    };

## DESCRIPTION

This implementation of an unbounded queue uses a circular linked list with a dummy node.

## Initialization and termination methods.

    ACE_Unbounded_Queue (ACE_Allocator *alloc = 0);

construction. Use user specified allocation strategy if specified.

    ACE_Unbounded_Queue (const ACE_Unbounded_Queue<T> &);

Copy constructor.

    void operator= (const ACE_Unbounded_Queue<T> &);

Assignment operator.

    ~ACE_Unbounded_Queue (void);

construction.

## Check boundary conditions.

    int is_empty (void) const;

Returns 1 if the container is empty, otherwise returns 0.

    int is_full (void) const;

Returns 1 if the container is full, otherwise returns 0.

## Classic queue operations.

    int enqueue_tail (const T &new_item);

Adds `new_item` to the tail of the queue. Returns 0 on success, -1 on failure.

    int enqueue_head (const T &new_item);

Adds `new_item` to the head of the queue. Returns 0 on success, -1 on failure.

    int dequeue_head (T &item);

Removes and returns the first `item` on the queue. Returns 0 on success, -1 if the queue was empty.

## Additional utility methods.

    void reset (void);

Reset the `ACE_Unbounded_Queue` to be empty.

    int get (T *&item, size_t slot = 0) const;

Get the `slot`th element in the set. Returns -1 if the element isn't in the range `0..size() - 1`, else 0.

    int set (const T &item, size_t slot);

Set the `slot`th element in the set. Will pad out the set with empty nodes if `slot` is beyond the range `0..size() - 1`. Returns -1 on failure, 0 if `slot` isn't initially in range, and 0 otherwise.

    size_t size (void) const;

The number of items in the queue.

    void dump (void) const;

Dump the state of an object.

## STL-styled unidirectional iterator factory.

    ACE_Unbounded_Queue_Iterator<T> begin (void);

    ACE_Unbounded_Queue_Iterator<T> end (void);

    ACE_ALLOC_HOOK_DECLARE;

Declare the dynamic allocation hooks.

## AUTHOR

Doug Schmidt

## LIBRARY

ace