OpenDDS::DCPS::BasicQueue< T > Class Template Reference

#include <BasicQueue_T.h>

Inheritance diagram for OpenDDS::DCPS::BasicQueue< T >:

[legend]Collaboration diagram for OpenDDS::DCPS::BasicQueue< T >:

[legend]List of all members.

Public Member Functions
	BasicQueue (size_t links_per_pool, size_t initial_pools)
	~BasicQueue ()
int	put (T *elem)
	Put a pointer to an element (T*) on to the queue.
T *	peek () const
void	replace_head (T *value)
T *	get ()
size_t	size () const
	Accessor for the current number of elements in the queue.
void	accept_visitor (VisitorType &visitor) const
void	accept_remove_visitor (VisitorType &visitor)
void	accept_replace_visitor (VisitorType &visitor)
Private Types
typedef BasicQueueLinkPool< T >	PoolType
typedef BasicQueueLink< T >	LinkType
typedef BasicQueueVisitor< T >	VisitorType
Private Member Functions
void	remove_next (LinkType *prev)
Private Attributes
LinkType *	head_
	The first (oldest) link in the queue.
LinkType *	tail_
	The last (newest) link in the queue.
size_t	size_
	The number of links currently in the queue.
PoolType	pool_

---

Detailed Description

template<typename T>
class OpenDDS::DCPS::BasicQueue< T >

Definition at line 19 of file BasicQueue_T.h.

---

Member Typedef Documentation

template<typename T>

typedef BasicQueueLink<T> OpenDDS::DCPS::BasicQueue< T >::LinkType [private]

Definition at line 23 of file BasicQueue_T.h.

template<typename T>

typedef BasicQueueLinkPool<T> OpenDDS::DCPS::BasicQueue< T >::PoolType [private]

Definition at line 22 of file BasicQueue_T.h.

template<typename T>

typedef BasicQueueVisitor<T> OpenDDS::DCPS::BasicQueue< T >::VisitorType [private]

Definition at line 24 of file BasicQueue_T.h.

---

Constructor & Destructor Documentation

template<typename T>

OpenDDS::DCPS::BasicQueue< T >::BasicQueue	(	size_t	links_per_pool,
		size_t	initial_pools
	)			[inline]

Definition at line 28 of file BasicQueue_T.h.

  : head_(0),
    tail_(0),
    size_(0),
    pool_(links_per_pool, initial_pools)
  {}

template<typename T>

OpenDDS::DCPS::BasicQueue< T >::~BasicQueue

(

)

[inline]

Definition at line 35 of file BasicQueue_T.h.

                {
  }

---

Member Function Documentation

template<typename T>

void OpenDDS::DCPS::BasicQueue< T >::accept_remove_visitor

(

VisitorType &

visitor

)

[inline]

Alternate way to supply a visitor to the queue - this will invoke visit_element(T* element, int& remove) on the supplied visitor object once for each element in this BasicQueue<T> object, in order.

The remove argument is a flag that should be set to true (1) in the visitor's visit_element_remove(T* element, int& remove) method if the visitor decides that the element should be removed from the queue. The remove flag is always set to false (0) prior to calling the visitor's visit_element_remove(T* element, int& remove) method.

The visitor can stop visitation early by returning 0 from its visit_element_remove(T* element, int& remove) method.

Definition at line 159 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::TransportSendStrategy::clear(), and OpenDDS::DCPS::TransportSendStrategy::do_remove_sample().

                                                   {
    LinkType* prev_link = 0;
    LinkType* link = this->head_;

    while (link != 0) {
      // Save off the next_link now, in case we end up removing
      // (and releasing) the current link via a call to our
      // remove_next() call further on.
      LinkType* next_link = link->next();

      T* element = link->elem();

      int remove = 0;

      int keep_going = visitor.visit_element_remove(element, remove);

      if (remove == 1) {
        this->remove_next(prev_link);

        // We shouldn't change the prev_link here, because it
        // has become the prev_link of the next_link since the
        // (middle-man) link was just removed.

      } else {
        // Set it up for visitation of the next link.
        // Adjust the prev_link here because we didn't remove
        // the link.
        prev_link = link;
      }

      link = next_link;

      if (keep_going == 0) {
        // We are done.
        return;
      }
    }
  }

template<typename T>

void OpenDDS::DCPS::BasicQueue< T >::accept_replace_visitor

(

VisitorType &

visitor

)

[inline]

This kind of visitation may cause the visitor to replace the currently visited element with a new element.

Definition at line 200 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::TransportSendStrategy::do_remove_sample().

                                                    {
    LinkType* link = this->head_;

    while (link != 0) {
      // The subtle difference between this visitation method
      // and the normal "accept_visitor" visitation method is
      // that we supply a reference to a pointer to an element
      // here rather than just a pointer to an element.  This
      // allows the visitor to "replace" the current element
      // with a new element.
      if (visitor.visit_element_ref(link->elem_ref()) == 0) {
        return;
      }

      link = link->next();
    }
  }

template<typename T>

void OpenDDS::DCPS::BasicQueue< T >::accept_visitor

(

VisitorType &

visitor

)

const [inline]

Standard way to supply a visitor to the queue - this will invoke visit_element(T* element) on the supplied visitor object once for each element in this BasicQueue<T> object, in order. The visitor can stop visitation early by returning 0 from its visit_element(T* element) method.

Definition at line 133 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::SingleSendBuffer::insert_buffer(), OpenDDS::DCPS::TransportSendStrategy::prepare_packet(), and OpenDDS::DCPS::ThreadPerConnectionSendTask::remove_sample().

                                                  {
    LinkType* link = this->head_;

    while (link != 0) {
      if (visitor.visit_element(link->elem()) == 0) {
        return;
      }

      link = link->next();
    }
  }

template<typename T>

T* OpenDDS::DCPS::BasicQueue< T >::get

(

)

[inline]

Extract the top element from the queue. Returns 0 if there are no elements in the queue.

Definition at line 90 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::TransportSendStrategy::adjust_packet_after_send(), and OpenDDS::DCPS::ThreadPerConnectionSendTask::svc().

           {
    LinkType* link = this->head_;

    if (link == 0) {
      // The queue is empty.  Return a NULL pointer (0).
      return 0;
    }

    // Adjust the head_ (and possibly the tail_ if there is only
    // one link currently in the queue).
    this->head_ = link->next();

    if (this->head_ == 0) {
      // That was the only link in the queue.  Now that the head_
      // indicates that the queue is empty, we need to update the
      // tail_ accordingly because we know it was pointing to the
      // same link as the head_.
      this->tail_ = 0;
    }

    // Save off the pointer to the link's elem().
    T* elem = link->elem();

    // Release the link object back to the pool.
    this->pool_.release(link);

    // Decrement our size_ by one.
    --this->size_;

    // And finally return the elem.
    return elem;
  }

template<typename T>

T* OpenDDS::DCPS::BasicQueue< T >::peek

(

)

const [inline]

Peek at the element at the top of the queue. This is just like the get() operation except that the queue remains intact.

Definition at line 73 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::TransportSendStrategy::adjust_packet_after_send(), OpenDDS::DCPS::TransportSendStrategy::current_packet_first_element(), OpenDDS::DCPS::TransportSendStrategy::get_packet_elems_from_queue(), and OpenDDS::DCPS::RtpsUdpDataLink::MultiSendBuffer::insert().

                  {
    if (this->head_ == 0) {
      // The queue is empty.  Return a NULL pointer (0).
      return 0;
    }

    return this->head_->elem();
  }

template<typename T>

int OpenDDS::DCPS::BasicQueue< T >::put

(

T *

elem

)

[inline]

Put a pointer to an element (T*) on to the queue.

Definition at line 39 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::ThreadPerConnectionSendTask::add_request(), OpenDDS::DCPS::TransportSendStrategy::get_packet_elems_from_queue(), and OpenDDS::DCPS::TransportSendStrategy::send().

                   {
    // Get a "new" link from the pool.
    LinkType* link = pool_.obtain(elem);

    if (link == 0) {
      // Shouldn't happen unless we run out of memory (or encounter
      // an internal error condition of some sort, making the
      // pool_ unable to provide us with a valid link).
      return -1;
    }

    // Insert the link on the the end of the queue.
    if (this->tail_ == 0) {
      // The tail_ is NULL only when the queue is empty.
      // Set both the head_ and tail_ to point to the "new" link.
      this->head_ = this->tail_ = link;

    } else {
      // There is at least one element in the queue.
      // Set the next() of the current tail_ link to point to
      // the "new" link.  Then set the tail_ to point to the
      // "new" link.
      this->tail_->next(link);
      this->tail_ = link;
    }

    // Increment our size_ by one.
    ++this->size_;

    return 0;
  }

template<typename T>

void OpenDDS::DCPS::BasicQueue< T >::remove_next

(

LinkType *

prev

)

[inline, private]

Used by our accept_remove_visitor() method when an element needs to be removed from this BasicQueue<T> object. The element that is supposed to be removed is the next() link object of the supplied "prev" link object. It's done this way so that the (singlely) linked-list can be stitched back together after the appropriate link has been removed.

Definition at line 226 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::accept_remove_visitor().

                                   {
    // We are either removing the head_ or the prev->next().
    // Note that we assume that in this contect, head_ will not
    // be NULL (0).  And, if prev is not NULL (0), then we assume
    // that prev->next() is not NULL (0).
    //
    // Note that we also assume that the prev link (if not NULL),
    // is indeed a member of the queue!
    LinkType* link = (prev == 0) ? this->head_ : prev->next();

    // Handle the case where the queue only contains one link
    // (we can then assume that this is the link we are removing).
    if (this->head_ == this->tail_) {
      // We are removing the only link in the queue.
      this->head_ = this->tail_ = 0;

    } else if (link == this->head_) {
      // We are removing the head link, and we know that there
      // are other links still in the queue.
      this->head_ = this->head_->next();

    } else if (link == this->tail_) {
      // We are removing the tail link, and we know that there
      // are other links still in the queue.
      prev->next(0);
      this->tail_ = prev;

    } else {
      // We are removing a link that is neither the head_ link
      // nor the tail_ link.
      prev->next(link->next());
    }

    // Decrement our size by one
    --this->size_;

    // And finally, we can release the link back to the pool.
    this->pool_.release(link);
  }

template<typename T>

void OpenDDS::DCPS::BasicQueue< T >::replace_head

(

T *

value

)

[inline]

Definition at line 82 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::TransportSendStrategy::get_packet_elems_from_queue().

                              {
    if (this->head_ != 0) {
      this->head_->elem(value);
    }
  }

template<typename T>

size_t OpenDDS::DCPS::BasicQueue< T >::size

(

)

const [inline]

Accessor for the current number of elements in the queue.

Definition at line 124 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::SingleSendBuffer::insert_buffer().

                      {
    return this->size_;
  }

---

Member Data Documentation

template<typename T>

LinkType* OpenDDS::DCPS::BasicQueue< T >::head_ [private]

The first (oldest) link in the queue.

Definition at line 267 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::accept_remove_visitor(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::accept_replace_visitor(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::accept_visitor(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::get(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::peek(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::put(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::remove_next(), and OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::replace_head().

template<typename T>

PoolType OpenDDS::DCPS::BasicQueue< T >::pool_ [private]

The pool of precreated LinkType objects (a "self-growing" allocator is used by the pool).

Definition at line 277 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::get(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::put(), and OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::remove_next().

template<typename T>

size_t OpenDDS::DCPS::BasicQueue< T >::size_ [private]

The number of links currently in the queue.

Definition at line 273 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::get(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::put(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::remove_next(), and OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::size().

template<typename T>

LinkType* OpenDDS::DCPS::BasicQueue< T >::tail_ [private]

The last (newest) link in the queue.

Definition at line 270 of file BasicQueue_T.h.

Referenced by OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::get(), OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::put(), and OpenDDS::DCPS::BasicQueue< OpenDDS::DCPS::TransportQueueElement >::remove_next().

---

The documentation for this class was generated from the following file:

• BasicQueue_T.h

---