container::QueueImpl Class Reference

An implementation of Queue that based on an OrderedList. More...

#include <queueimpl.h>

Inheritance diagram for container::QueueImpl:

[legend]

Collaboration diagram for container::QueueImpl:

[legend]

List of all members.

Public Member Functions
	QueueImpl (const QueueImpl &orig)
	QueueImpl (const QueueImpl &orig, bool deepCopy)
virtual	~QueueImpl ()
virtual ostream &	renderState (ostream &os) const
	Write the state of an Object for debugging and demonstration.
virtual const Info *	typeInfo () const
	Return the instance of Object::Info that describes the class of this object.
virtual Object *	clone (bool deepCopy=false) const
	A polymorphic copy constructor.
Static Public Member Functions
static Queue *	factoryLinkedComposition ()
	Constructs an QueueImpl with an underlying OrderedLinkedList.
static Queue *	factoryArrayComposition ()
	Constructs a QueueImpl with an underlying OrderedArrayList.
Static Public Attributes
static const Info *const	TYPE_INFO
Protected Member Functions
virtual void	enqueue_impl (Entity *entity)
	Called by a template method.
virtual Entity *	dequeue_impl ()
	Called by a template method.
Private Member Functions
	QueueImpl (OrderedList *list)
Private Attributes
OrderedList *const	list

---

Detailed Description

An implementation of Queue that based on an OrderedList.

Two factory methods are provided: factoryLinkedComposition() and factoryArrayComposition(). The first creates a Queue with an underlying OrderedLinkedList and the second with an underlying OrderedArrayList. Since both satisfy the OrderedList contract, no special handling was required for the either type.

---

Constructor & Destructor Documentation

container::QueueImpl::QueueImpl

(

OrderedList *

list

)

[private]

: list(lst) { }

Here is the caller graph for this function:

container::QueueImpl::QueueImpl

(

const QueueImpl &

orig

)

                                         : Queue(orig),
list(dynamic_cast<OrderedList * const>(orig.list->clone())) { }

container::QueueImpl::QueueImpl	(	const QueueImpl &	orig,
		bool	deepCopy
	)

                                                        : Queue(orig),
list(dynamic_cast<OrderedList * const>(orig.list->clone(deepCopy))) { }

container::QueueImpl::~QueueImpl

(

)

[virtual]

                      {
   delete list;
}

---

Member Function Documentation

Object * container::QueueImpl::clone

(

bool

deepCopy = false

)

const [virtual]

A polymorphic copy constructor.

Implements container::Queue.

                                            {
   return new QueueImpl(*this, deepCopy);
}

Here is the call graph for this function:

Entity * container::QueueImpl::dequeue_impl

(

)

[protected, virtual]

Called by a template method.

See also:

Details documented in method dequeue

Implements container::Queue.

                                 {
   if (list->toFirst()) {
      return list->extractCurrentEntity();
   } else {
      return NULL;
   }
}

Here is the call graph for this function:

void container::QueueImpl::enqueue_impl

(

Entity *

entity

)

[protected, virtual]

Called by a template method.

See also:

Details documented in method enqueue

Implements container::Queue.

                                           {
   list->append(entity);
}

Here is the call graph for this function:

Queue * container::QueueImpl::factoryArrayComposition

(

)

[static]

Constructs a QueueImpl with an underlying OrderedArrayList.

                                          {
   return new QueueImpl(new OrderedArrayList());
}

Here is the call graph for this function:

Queue * container::QueueImpl::factoryLinkedComposition

(

)

[static]

Constructs an QueueImpl with an underlying OrderedLinkedList.

                                           {
   return new QueueImpl(new OrderedLinkedList());
}

Here is the call graph for this function:

ostream & container::QueueImpl::renderState

(

ostream &

os

)

const [virtual]

Write the state of an Object for debugging and demonstration.

This method must not change the state of an Object; adding or removing debug statements should not change the behavior of a class. The implementation must be robust, e.g., NULL safe, etc. and work without an unrecoverable error for any state, excluding an Object's time of construction and destruction. It is not required for the implementation to be thread safe.

Precondition:

The Object has been fully constructed and is not in the process of destruction

Postcondition:

The state of the Object is unchanged

Reimplemented from container::Queue.

                                                  {

   this->Queue::renderState(os);
   os << " composed with an " << list->typeInfo()->typeName << " contents{";
   int i = 0;
   for (list->toFirst(); !list->isTail(); list->toNext()) {
      os << std::endl << "      [" << i << ']' << list->currentEntity();
      if (list->getCount() > 1) {
         if (list->isFirst()) {
            os << " <--FIRST";
         } else if (list->isLast()) {
            os << " <--LAST";
         }
      }
      i++;
   }
   return os << "}";
}

Here is the call graph for this function:

const Object::Info * container::QueueImpl::typeInfo

(

)

const [virtual]

Return the instance of Object::Info that describes the class of this object.

Instantiation of Object::Info is controlled by the protected method Object::typeInfoFactory(const string&). Each sub-class of Object should create one and only one instance of Object::Info.

Reimplemented from container::Queue.

                                            {
   return TYPE_INFO;
}

---

Member Data Documentation

OrderedList* const container::QueueImpl::list [private]

const Object::Info *const container::QueueImpl::TYPE_INFO [static]

Initial value:

      Object::typeInfoFactory("QueueImpl")

Reimplemented from container::Queue.

---

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

• queueimpl.h
• queueimpl.cpp