home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
World of Shareware - Software Farm 2
/
wosw_2.zip
/
wosw_2
/
CPROG
/
CL182.ZIP
/
CL.HPT
< prev
Wrap
Text File
|
1993-05-15
|
14KB
|
546 lines
/*
cl.hpt -- Container Lite v 1.82 template
(C) Copyright 1993 John Webster Small
All rights reserved
*/
#ifndef cl_hpt
#define cl_hpt
#ifndef cl_hpp
#include "cl.hpp"
#endif
#include <string.h>
/* ITEM descriptors */
// If your compiler's template facility doesn't
// support nested function templates you must define
// FNC_TEMPLATES_NO_NEST here or always invoke either
// ITEM_BINARY_CMP() or ITEM_NO_REL_OPS(), or define
// your own int CL_Dcmp() compare function before
// container template instantiation. "Form
// templates" are actually more powerful in this
// respect than C++ templates.
// #define FNC_TEMPLATES_NO_NEST
#if defined(FNC_TEMPLATES_NO_NEST)
template <class ITEM>
inline CLcmP(CL_DcmP(CLcmP(cmP,ITEM)),void) \
{ return CLcmPcast(cmP,void); }
#else
template <class ITEM>
int CL_Dcmp(const ITEM * D1, const ITEM * D2)
{ return ((*D1 == *D2)? 0 : ((*D1 > *D2)? 1 : -1)); }
// Must be invoked only one time, before container
// template instantiation!
#define ITEM_BINARY_CMP(ITEM) \
int CL_Dcmp(const ITEM * D1, const ITEM * D2) \
{ return memcmp(D1,D2,sizeof(ITEM)); }
template <class ITEM>
inline CLcmP(CL_DcmP(CLcmP(cmP,ITEM)),void)
{ CLcmP(defaultCmP,ITEM) = CL_Dcmp;
return CLcmPcast((cmP? cmP : defaultCmP),void); }
#define ITEM_NO_REL_OPS(ITEM) \
inline CLcmP(CL_DcmP(CLcmP(cmP,ITEM)),void) \
{ return CLcmPcast(cmP,void); }
#endif
template <class ITEM>
inline void * CL_Dassign(ITEM * D,
const ITEM * S, unsigned)
{ *D = *S; return (void *) D; }
#define ITEM_TEST_ASSIGN(ITEM) \
inline void * CL_Dassign(ITEM * D, \
const ITEM * S, unsigned) \
{ return (void *) ((*D = *S)? D : 0); }
#define ITEM_NO_ASSIGN(ITEM) \
inline void * CL_Dassign(ITEM *, \
const ITEM *, unsigned) \
{ return (void *) 0; }
inline void * CL_Dnew(const char * D)
{ return strdup(D); }
template <class ITEM>
inline void * CL_Dnew(const ITEM * D)
{ return (void *) new ITEM(*D); }
#define ITEM_CLONE(ITEM) \
inline void * CL_Dnew(const ITEM * D) \
{ return (void *) D->clone(); }
#define ITEM_NO_COPYINIT(ITEM) \
inline void * CL_Dnew(const ITEM *) \
{ return (void *) 0; }
template <class ITEM>
inline void CL_Ddelete(ITEM * D)
{ delete D; }
#define ITEM_STRM_MUT_DELETE(ITEM) \
inline void CL_Ddelete(ITEM * D) \
{ if (!D->RefCount()) delete D; }
#define ITEM_NO_DELETE(ITEM) \
inline void CL_Ddelete(ITEM *) \
{ return; }
template <class ITEM>
inline int CL_Dattach(ITEM *, const void *)
{ return 1; }
#define ITEM_LINK(ITEM) inline int CL_Dattach \
(ITEM * D, const void * B) \
{ return D->link(B); }
template <class ITEM>
inline void CL_Ddetach(ITEM *, const void *)
{}
#define ITEM_UNLINK(ITEM) inline void CL_Ddetach \
(ITEM * D, const void * B) \
{ D->unlink(B); }
inline ostream& operator<<(ostream& os, char ** D)
{
int len = (*D? strlen(*D) : 0);
if ((os << len << endm))
if (len)
os.write(*D,len);
return os;
}
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_BINARY_STRM_INSERT(ITEM) \
inline ostream& operator<<(ostream& os, \
ITEM ** D) \
{ return os.write((char *)*D,sizeof(ITEM)); }
#define ITEM_NO_STRM_INSERT(ITEM) \
inline ostream& operator<<(ostream& os, \
ITEM **) { return os; }
inline istream& operator>>(istream& is, char ** D)
{
int len;
if (*D) {
delete *D;
*D = (char *)0;
}
if ((is >> len >> nextm))
if (len)
if ((*D = new char[len+1])
!= (char *)0) {
is.read(*D,len);
(*D)[len] = '\0';
}
else
is.ignore(len);
return is;
}
template <class ITEM>
inline istream& operator>>(istream& is,
ITEM ** D)
{
if (*D) delete *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; \
if (*D) delete *D; \
*D = (ITEM *) S; \
return is; \
}
#define ITEM_BINARY_STRM_EXTRACT(ITEM) \
inline istream& operator>>(istream& is, \
ITEM ** D) \
{ \
if (*D) delete *D; \
if ((*D = new ITEM) != (ITEM *)0) \
return is.read((char *)*D,sizeof(ITEM));\
return is; \
}
#define ITEM_NO_STRM_EXTRACT(ITEM) \
inline istream& operator>>(istream& is, \
ITEM **) { return is; }
#define ITEM_BINARY_STRM(ITEM) \
ITEM_BINARY_STRM_INSERT(ITEM) \
ITEM_BINARY_STRM_EXTRACT(ITEM)
#define ITEM_BINARY_CMP_STRM(ITEM) \
ITEM_BINARY_CMP(ITEM) \
ITEM_BINARY_STRM(ITEM)
#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_DELETE_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_BIND_ONLY(ITEM) \
ITEM_DELETE_ONLY(ITEM) \
ITEM_NO_DELETE(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)
#define ITEM_str \
int CL_Dcmp \
(const char * D1, const char * D2) \
{ return strcmp(D1,D2); } \
ITEM_NO_ASSIGN(char)
#define CL_str CL<char>
template <class ITEM>
class CL : cl {
protected:
CL (defaultConstructor)
: cl(defaultConstruct) {}
void assign(const CL<ITEM>& b)
{ cl::assign(b); }
cl:: destruct;
virtual voidCmP DcmP(voidCmP cmP)
{ return CL_DcmP
(CLcmPcast(cmP,ITEM)); }
virtual void * Dassign(void * D,
const void * S)
{ return CL_Dassign
((ITEM *)D,(const ITEM *)S,
flags); }
virtual void * Dnew(const void * D)
{ return CL_Dnew
((const ITEM *)D); }
virtual void Ddelete(void * D)
{ CL_Ddelete((ITEM *)D); }
virtual int Dattach(void * D)
{ return CL_Dattach((ITEM *)D,
(const void *) this); }
virtual void Ddetach(void * D)
{ CL_Ddetach((ITEM *)D,
(const void *) this); }
virtual int Dput(ostream& os, void * D)
{ return ((os << (ITEM **) &D)?
1 : 0); }
virtual void * Dget(istream& is)
{ ITEM * D = 0; 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; }
int operator==(const CL<ITEM>& b) const
{ return cl::operator==(b); }
int operator> (const CL<ITEM>& b) const
{ return cl::operator>(b); }
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) const
{ 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) const
{ return (ITEM *)cl::
atGet(n); }
ITEM * operator[](unsigned n) const
{ 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) const
{ 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() const
{ 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() const
{ 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() const
{ return (ITEM *)cl::
get(); }
operator ITEM *() const { 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 * operator[](const ITEM * K)
{ return findFirst(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 */