Source: classlib/include/classlib/queues.h
|
|
|
|
/***************************************************************************
queues.h - code di oggetti
-------------------
begin : ven dic 7 17:40:01 CET 2001
copyright : (C) 2001 by Nicola De Nisco
email : nicola@winada.it
***************************************************************************/
/***************************************************************************
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
***************************************************************************/
#if !defined( __CLASSLIB_QUEUES_H )
#define __CLASSLIB_QUEUES_H
#if !defined( __CLASSLIB_DEFS_H )
#include "classlib/defs.h"
#endif // __CLASSLIB_DEFS_H
#if !defined( __CLASSLIB_DEQUES_H )
#include "classlib/deques.h"
#endif // __CLASSLIB_DEQUES_H
template class TMQueueAsVectorIterator;
/**
template class TMQueueAsVector
template class TMQueueAsVectorIterator
Implements a managed queue of objects of type T, using a vector as
the underlying implementation.
*/
template class TMQueueAsVector :
private TMDequeAsVector
{
typedef TMDequeAsVector Parent;
public:
friend class TMQueueAsVectorIterator;
TMQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
TMDequeAsVector(sz)
{
}
const T& Peek() const
{
return Parent::PeekRight();
}
T Get()
{
return Parent::GetRight();
}
void Put( const T& t )
{
Parent::PutLeft( t );
}
typedef void (*IterFunc)(T&, void *);
typedef int (*CondFunc)(const T&, void *);
Parent::ForEach;
Parent::FirstThat;
Parent::LastThat;
Parent::Flush;
Parent::IsFull;
Parent::IsEmpty;
Parent::GetItemsInContainer;
};
template class TMQueueAsVectorIterator :
public TMDequeAsVectorIterator
{
public:
TMQueueAsVectorIterator( const TMQueueAsVector& q ) :
TMDequeAsVectorIterator(q)
{
}
};
/**
template class TQueueAsVector
template class TQueueAsVectorIterator
Implements a queue of objects of type T, using a vector as
the underlying implementation.
*/
template class TQueueAsVector :
public TMQueueAsVector
{
public:
TQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
TMQueueAsVector(sz)
{
}
};
template class TQueueAsVectorIterator :
public TMQueueAsVectorIterator
{
public:
TQueueAsVectorIterator( const TQueueAsVector& q ) :
TMQueueAsVectorIterator(q)
{
}
};
template class TMIQueueAsVectorIterator;
/**
template class TMIQueueAsVector
template class TMIQueueAsVectorIterator
Implements a managed queue of pointers to objects of type T,
using a vector as the underlying implementation.
*/
template class TMIQueueAsVector :
private TMIDequeAsVector
{
typedef TMIDequeAsVector Parent;
public:
friend class TMIQueueAsVectorIterator;
TMIQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
TMIDequeAsVector(sz)
{
}
T *Peek() const
{
return Parent::PeekRight();
}
T *Get()
{
return Parent::GetRight();
}
void Put( T *t )
{
Parent::PutLeft( t );
}
typedef void (*IterFunc)(T&, void *);
typedef int (*CondFunc)(const T&, void *);
Parent::IsFull;
Parent::IsEmpty;
Parent::GetItemsInContainer;
Parent::Flush;
Parent::ForEach;
Parent::FirstThat;
Parent::LastThat;
Parent::OwnsElements;
};
template class TMIQueueAsVectorIterator :
public TMIDequeAsVectorIterator
{
public:
TMIQueueAsVectorIterator( const TMIQueueAsVector& q ) :
TMIDequeAsVectorIterator(q) {}
};
/**
template class TIQueueAsVector
template class TIQueueAsVectorIterator
Implements a queue of pointers to objects of type T,
using a vector as the underlying implementation and
TStandardAllocator as its memory manager.
*/
template class TIQueueAsVector :
public TMIQueueAsVector
{
public:
TIQueueAsVector( unsigned sz = DEFAULT_QUEUE_SIZE ) :
TMIQueueAsVector(sz)
{
}
};
template class TIQueueAsVectorIterator :
public TMIQueueAsVectorIterator
{
public:
TIQueueAsVectorIterator( const TIQueueAsVector& q ) :
TMIQueueAsVectorIterator(q)
{
}
};
template class TMQueueAsDoubleListIterator;
/**
template class TMQueueAsDoubleList
template class TMQueueAsDoubleListIterator
Implements a managed queue of objects of type T, using a double
linked list as the underlying implementation.
*/
template class TMQueueAsDoubleList :
private TMDequeAsDoubleList
{
typedef TMDequeAsDoubleList Parent;
public:
friend class TMQueueAsDoubleListIterator;
const T& Peek() const
{
return Parent::PeekRight();
}
T Get()
{
return Parent::GetRight();
}
void Put( const T& t )
{
Parent::PutLeft( t );
}
typedef void (*IterFunc)(T&, void *);
typedef int (*CondFunc)(const T&, void *);
Parent::IsFull;
Parent::IsEmpty;
Parent::GetItemsInContainer;
Parent::Flush;
Parent::ForEach;
Parent::FirstThat;
Parent::LastThat;
Parent::Detach;
};
template class TMQueueAsDoubleListIterator :
public TMDequeAsDoubleListIterator
{
public:
TMQueueAsDoubleListIterator( const TMQueueAsDoubleList& q ) :
TMDequeAsDoubleListIterator(q)
{
}
};
/**
template class TQueueAsDoubleList
template class TQueueAsDoubleListIterator
Implements a queue of objects of type T, using a double linked list
as the underlying implementation.
*/
template class TQueueAsDoubleList :
public TMQueueAsDoubleList
{
};
/**
template class TQueueAsDoubleList
template class TQueueAsDoubleListIterator
Implements a queue of objects of type T, using a double linked list
as the underlying implementation.
*/
template class TQueueAsDoubleListIterator :
public TMQueueAsDoubleListIterator
{
public:
TQueueAsDoubleListIterator( const TQueueAsDoubleList& q ) :
TMQueueAsDoubleListIterator(q)
{
}
};
template class TMIQueueAsDoubleListIterator;
/**
template class TMIQueueAsDoubleList
template class TMIQueueAsDoubleListIterator
Implements a managed queue of pointers to objects of type T,
using a double linked list as the underlying implementation.
*/
template class TMIQueueAsDoubleList :
private TMIDequeAsDoubleList
{
typedef TMIDequeAsDoubleList Parent;
public:
friend class TMIQueueAsDoubleListIterator;
T *Peek() const
{
return Parent::PeekRight();
}
T *Get()
{
return Parent::GetRight();
}
void Put( T *t )
{
Parent::PutLeft( t );
}
typedef void (*IterFunc)(T&, void *);
typedef int (*CondFunc)(const T&, void *);
Parent::IsFull;
Parent::IsEmpty;
Parent::GetItemsInContainer;
Parent::Flush;
Parent::ForEach;
Parent::FirstThat;
Parent::LastThat;
Parent::Detach;
Parent::OwnsElements;
};
/**
template class TMIQueueAsDoubleList
template class TMIQueueAsDoubleListIterator
Implements a managed queue of pointers to objects of type T,
using a double linked list as the underlying implementation.
*/
template class TMIQueueAsDoubleListIterator :
public TMIDequeAsDoubleListIterator
{
public:
TMIQueueAsDoubleListIterator( const TMIQueueAsDoubleList& q ) :
TMIDequeAsDoubleListIterator(q) {}
};
/**
template class TIQueueAsDoubleList
template class TIQueueAsDoubleListIterator
Implements a queue of pointers to objects of type T, using a double
linked list as the underlying implementation and TStandardAllocator
as its memory manager.
*/
template class TIQueueAsDoubleList :
public TMIQueueAsDoubleList
{
};
template class TIQueueAsDoubleListIterator :
public TMIQueueAsDoubleListIterator
{
public:
TIQueueAsDoubleListIterator( const TIQueueAsDoubleList& q ) :
TMIQueueAsDoubleListIterator(q) {}
};
/////////////////////////////////////////////////////////////////////////////////////
/**
template class TQueue
template class TQueueIterator
Easy names for TQueueAsVector and TQueueAsVectorIterator
*/
template class TQueue : public TQueueAsVector
{
public:
TQueue( unsigned max = DEFAULT_QUEUE_SIZE ) :
TQueueAsVector( max )
{
}
};
/**
template class TQueue
template class TQueueIterator
Easy names for TQueueAsVector and TQueueAsVectorIterator
*/
template class TQueueIterator :
public TQueueAsVectorIterator
{
public:
TQueueIterator( const TQueue& a ) :
TQueueAsVectorIterator(a)
{
}
};
/////////////////////////////////////////////////////////////////////////////////////
/**
template class TIQueue
template class TIQueueIterator
Easy names for TIQueueAsVector and TIQueueAsVectorIterator
*/
template class TIQueue : public TIQueueAsVector
{
public:
TIQueue( unsigned max = DEFAULT_QUEUE_SIZE ) :
TIQueueAsVector( max )
{
}
};
/**
template class TIQueue
template class TIQueueIterator
Easy names for TIQueueAsVector and TIQueueAsVectorIterator
*/
template class TIQueueIterator :
public TIQueueAsVectorIterator
{
public:
TIQueueIterator( const TIQueue& a ) :
TIQueueAsVectorIterator(a)
{
}
};
#endif // __CLASSLIB_QUEUES_H
| Generated by: nicola on gulliver.wadahome.it on Sun May 25 13:54:34 2003, using kdoc 2.0a53. |