home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Shareware Supreme Volume 6 #1
/
swsii.zip
/
swsii
/
099
/
CL181.ZIP
/
CL.HPT
< prev
next >
Wrap
Text File
|
1993-04-26
|
11KB
|
447 lines
/*
cl.hpt -- Container Lite v 1.81 template
(C) Copyright 1993 John Webster Small
All rights reserved
*/
#ifndef cl_hpt
#define cl_hpt
#ifndef cl_hpp
#include "cl.hpp"
#endif
/* ITEM descriptors */
template <class ITEM>
int CL_D_cmp(const ITEM * D1, const ITEM * D2)
{ return ((*D1 == *D2)? 0 : ((*D1 > *D2)? 1 : -1)); }
template <class ITEM>
inline CLcmP(CL_D_cmP(CLcmP(cmP,ITEM)),void)
{ CLcmP(defaultCmP,ITEM) = CL_D_cmp;
return CLcmPcast((cmP? cmP : defaultCmP),void); }
#define ITEM_NO_REL_OPS(ITEM) \
inline CLcmP(CL_D_cmP(CLcmP(cmP,ITEM)),void) \
{ return CLcmPcast((cmP? cmP : CLcmP0(ITEM)),void); }
template <class ITEM>
inline void * CL_D_ASSIGN(ITEM * D,
ITEM * S)
{ *D = *S; return (void *) D; }
#define ITEM_TEST_ASSIGN(ITEM) \
inline void * CL_D_ASSIGN(ITEM * D, \
ITEM * S) \
{ return (void *) ((*D = *S)? D : 0); }
#define ITEM_NO_ASSIGN(ITEM) \
inline void * CL_D_ASSIGN(ITEM * D, \
ITEM *) \
{ return (void *) 0; }
template <class ITEM>
inline void * CL_D_NEW(ITEM * thiS)
{ return (void *) new ITEM(*thiS); }
#define ITEM_CLONE(ITEM) \
inline void * CL_D_NEW(ITEM * thiS) \
{ return (void *) thiS->clone(); }
#define ITEM_NO_COPYINIT(ITEM) \
inline void * CL_D_NEW(ITEM *) \
{ return (void *) 0; }
template <class ITEM>
inline void CL_D_DELETE(ITEM * D)
{ delete D; }
#define ITEM_STRM_MUT_DELETE(ITEM) \
inline void CL_D_DELETE(ITEM * D) \
{ if (!D->RefCount()) delete D; }
template <class ITEM>
inline int CL_D_LINK(ITEM *, void *)
{ return 1; }
#define ITEM_LINK(ITEM) inline int CL_D_LINK \
(ITEM * D, void * B) \
{ return D->link(B); }
template <class ITEM>
inline void CL_D_UNLINK(ITEM *, void *)
{}
#define ITEM_UNLINK(ITEM) inline void CL_D_UNLINK \
(ITEM * D, void * B) \
{ D->unlink(B); }
template <class ITEM>
inline ostream& operator<<(ostream& os,
ITEM ** D)
{ return os << **D << endm; }
#define ITEM_STRM_INSERT(ITEM,ITEM_STRM_BASE) \
inline ostream& operator<<(ostream& os, \
ITEM ** D) \
{ return os << *(ITEM_STRM_BASE *)*D; }
#define ITEM_NO_STRM_INSERT(ITEM) \
inline ostream& operator<<(ostream& os, \
ITEM **) { return os; }
template <class ITEM>
inline istream& operator>>(istream& is,
ITEM ** D)
{
if ((*D = new ITEM()) != (ITEM *)0)
is >> **D >> nextm;
return is;
}
#define ITEM_STRM_EXTRACT(ITEM,ITEM_STRM_BASE) \
inline istream& operator>>(istream& is, \
ITEM ** D) \
{ \
ITEM_STRM_BASE * S; \
is >> S; \
*D = (ITEM *) S; \
return is; \
}
#define ITEM_NO_STRM_EXTRACT(ITEM) \
inline istream& operator>>(istream& is, \
ITEM **) { return is; }
#define ITEM_NO_STRM_OPS(ITEM) \
ITEM_NO_STRM_INSERT(ITEM) \
ITEM_NO_STRM_EXTRACT(ITEM)
#define ITEM_NO_REL_STRM_OPS(ITEM) \
ITEM_NO_REL_OPS(ITEM) \
ITEM_NO_STRM_INSERT(ITEM) \
ITEM_NO_STRM_EXTRACT(ITEM)
#define ITEM_DEL_ONLY(ITEM) \
ITEM_NO_REL_OPS(ITEM) \
ITEM_NO_ASSIGN(ITEM) \
ITEM_NO_COPYINIT(ITEM) \
ITEM_NO_STRM_INSERT(ITEM) \
ITEM_NO_STRM_EXTRACT(ITEM)
#define ITEM_STRMABLE(ITEM,ITEM_STRM_BASE) \
ITEM_TEST_ASSIGN(ITEM) \
ITEM_CLONE(ITEM) \
ITEM_STRM_MUT_DELETE(ITEM) \
ITEM_LINK(ITEM) \
ITEM_UNLINK(ITEM) \
ITEM_STRM_INSERT(ITEM,ITEM_STRM_BASE) \
ITEM_STRM_EXTRACT(ITEM,ITEM_STRM_BASE)
template <class ITEM>
class CL : cl {
protected:
CL (defaultConstructor)
: cl(defaultConstruct) {}
void assign(CL<ITEM>& b)
{ cl::assign(b); }
cl:: destruct;
virtual voidCmP DcmP(voidCmP cmP)
{ return CL_D_cmP
(CLcmPcast(cmP,ITEM)); }
virtual void * Dassign(void * D,
const void * S)
{ return CL_D_ASSIGN
((ITEM *)D,(ITEM *)S); }
virtual void * Dnew(const void * D)
{ return CL_D_NEW
((ITEM *)D); }
virtual void Ddelete(void * D)
{ CL_D_DELETE((ITEM *)D); }
virtual int Dattach(void * D)
{ return CL_D_LINK((ITEM *)D,
(void *) this); }
virtual void Ddetach(void * D)
{ CL_D_UNLINK((ITEM *)D,
(void *) this); }
virtual int Dput(ostream& os, void * D)
{ return ((os << (ITEM **) &D)?
1 : 0); }
virtual void * Dget(istream& is)
{ ITEM * D; is >> &D;
return (void *) D; }
virtual int put(ostream& os)
{ return cl::put(os); }
virtual int get(istream& is)
{ return cl::get(is); }
friend ostream& operator<<(ostream& os,
CL<ITEM>& b);
friend istream& operator>>(istream& is,
CL<ITEM>& b);
cl:: vforEach;
public:
/* Constructors and destructor */
CL (unsigned flags = CL_BIND_ONLY,
unsigned maxNodes = CL_MAXNODES,
unsigned limit = CL_LIMIT,
unsigned delta = CL_DELTA) :
cl(flags,maxNodes,limit,delta)
{}
CL (ITEM * argv[],
unsigned argc = 0U,
unsigned flags = CL_BIND_ONLY)
: cl((void **)argv,argc,flags)
{}
CL (CL<ITEM>& b)
: cl(defaultConstruct)
{ assign(b); }
CL<ITEM>& operator=(CL<ITEM>& b)
{ assign(b); return *this; }
CL (const char * filename)
: cl(defaultConstruct)
{ (void) cl::load(filename); }
int load(const char * filename)
{ return cl::load(filename); }
int save(const char * filename)
{ return cl::save(filename); }
ITEM ** vector(ITEM ** argv = (ITEM **)0,
unsigned argc = 0U)
{ return (ITEM **)cl::
vector((void **)argv,argc); }
virtual ~CL() { destruct(); }
/* Housekeeping Primitives */
cl:: Limit;
cl:: setLimit;
cl:: pack;
cl:: Delta;
cl:: setDelta;
cl:: Nodes;
cl:: MaxNodes;
cl:: setMaxNodes;
cl:: vacancy;
cl:: vacancyNonElastic;
cl:: Flags;
cl:: setFlags;
cl:: resetFlags;
CL<ITEM>& operator<<(CL<ITEM>&
(*manipulator)(CL<ITEM>&))
{ return (manipulator?
(*manipulator)
(*this) : *this); }
/* Elastic Array Primitives */
ITEM * atIns(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atIns(n,(void *)D); }
ITEM * atInsNew(unsigned n, const ITEM * D)
{ return (ITEM *)cl::
atInsNew(n,(const void *)D); }
ITEM * atRmv(unsigned n)
{ return (ITEM *)cl::
atRmv(n); }
cl:: allRmv;
cl:: atDel;
ITEM * atDelAsg(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atDelAsg(n,(void *)D); }
cl:: allDel;
cl:: allClr;
ITEM * atPut(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atPut(n,(void *)D); }
ITEM * atPutNew(unsigned n, const ITEM * D)
{ return (ITEM *)cl::
atPutNew(n,(const void *)D); }
ITEM * atPutAsg(unsigned n, const ITEM * D)
{ return (ITEM *)cl::
atPutAsg(n,(const void *)D); }
ITEM * atGet(unsigned n)
{ return (ITEM *)cl::
atGet(n); }
ITEM * operator[](unsigned n)
{ return atGet(n); }
ITEM * atGetAsg(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atGetAsg(n,(void *) D); }
ITEM * atXchg(unsigned n, ITEM * D)
{ return (ITEM *)cl::
atXchg(n,(void *) D); }
unsigned index(const ITEM * D)
{ return cl::
index((const void *)D); }
void forEach(CLapplY(B,ITEM), ...)
{ va_list args;
va_start(args,B);
vforEach((voidApplY)B,args);
va_end(args); }
/* Stack - Deque - Queue Primitives */
ITEM * push(ITEM * D)
{ return (ITEM *)cl::
push((void *) D); }
ITEM * pushNew(const ITEM * D)
{ return (ITEM *)cl::
pushNew((const void *)D); }
ITEM * pop()
{ return (ITEM *)cl::
pop(); }
CL<ITEM>& operator>>(ITEM *& D)
{ D = atRmv(0U);
return *this; }
cl:: popDel;
ITEM * popDelAsg(ITEM * D)
{ return (ITEM *)cl::
popDelAsg((void *)D); }
ITEM * top()
{ return (ITEM *)cl::
top(); }
ITEM * topAsg(ITEM * D)
{ return (ITEM *)cl::
topAsg((void *)D); }
ITEM * insQ(ITEM * D)
{ return (ITEM *)cl::
insQ((void *)D); }
CL<ITEM>& operator<<(ITEM * D)
{ atIns(Nodes(),D);
return *this; }
ITEM * insQNew(const ITEM * D)
{ return (ITEM *)cl::
insQNew((const void *)D); }
ITEM * unQ()
{ return (ITEM *)cl::
unQ(); }
cl:: unQDel;
ITEM * unQDelAsg(ITEM * D)
{ return (ITEM *)cl::
unQDelAsg((void *)D); }
ITEM * rear()
{ return (ITEM *)cl::
rear(); }
ITEM * rearAsg(ITEM * D)
{ return (ITEM *)cl::
rearAsg((void *)D); }
/* List (single and double linked) Primitives */
cl:: CurNode;
cl:: setCurNode;
ITEM * ins(ITEM * D)
{ return (ITEM *)cl::
ins((void *)D); }
ITEM * insNew(const ITEM * D)
{ return (ITEM *)cl::
insNew((const void *)D); }
ITEM * rmv()
{ return (ITEM *)cl::
rmv(); }
cl:: del;
ITEM * delAsg(ITEM * D)
{ return (ITEM *)cl::
delAsg((void *)D); }
ITEM * put(ITEM * D)
{ return (ITEM *)cl::
put((void *)D); }
ITEM * putNew(const ITEM * D)
{ return (ITEM *)cl::
putNew((const void *)D); }
ITEM * putAsg(const ITEM * D)
{ return (ITEM *)cl::
putAsg((const void *)D); }
ITEM * get()
{ return (ITEM *)cl::
get(); }
operator ITEM *() { return get(); }
ITEM * getAsg(ITEM * D)
{ return (ITEM *)cl::
getAsg((void *)D); }
ITEM * next()
{ return (ITEM *)cl::
next(); }
ITEM * operator++()
{ return next(); }
ITEM * nextAsg(ITEM * D)
{ return (ITEM *)cl::
nextAsg((void *)D); }
ITEM * prev()
{ return (ITEM *)cl::
prev(); }
ITEM * operator--()
{ return prev(); }
ITEM * prevAsg(ITEM * D)
{ return (ITEM *)cl::
prevAsg((void *)D); }
/* Priority Q, Set, Bag, Dictionary, Sort Primitives */
cl:: Sorted;
cl:: unSort;
void setCmP(CLcmP(cmP,ITEM)
= CLcmP0(ITEM))
{ cl::setCmP
((voidCmP)cmP); }
CLcmP(CmPfnc,ITEM) { return CLcmPcast
(cl::CmP(),ITEM); }
int sort(CLcmP(cmP,ITEM)
= CLcmP0(ITEM))
{ return cl::sort
((voidCmP)cmP); }
ITEM * insSort(ITEM * D)
{ return (ITEM *)cl::
insSort((void *)D); }
ITEM * insSortNew(const ITEM * D)
{ return (ITEM *)cl::
insSortNew((const void *)D); }
ITEM * insUnique(ITEM * D)
{ return (ITEM *)cl::
insUnique((void *)D); }
ITEM * insUniqueNew(const ITEM * D)
{ return (ITEM *)cl::
insUniqueNew((const void *)D);}
ITEM * findFirst(const ITEM * K)
{ return (ITEM *)cl::
findFirst((const void *)K); }
ITEM * findNext(const ITEM * K)
{ return (ITEM *)cl::
findNext((const void *)K); }
ITEM * findLast (const ITEM * K)
{ return (ITEM *)cl::
findLast((const void *)K); }
ITEM * findPrev(const ITEM * K)
{ return (ITEM *)cl::
findPrev((const void *)K); }
unsigned findAll(const ITEM * K)
{ return cl::
findAll((const void *)K); }
}; /* class CL */
template <class ITEM>
inline ostream& operator<<(ostream& os,
CL<ITEM>& b)
{ (void) b.put(os); return os; }
template <class ITEM>
inline istream& operator>>(istream& is,
CL<ITEM>& b)
{ (void) b.get(is); return is; }
#endif /* cl_hpt */