Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

gttlist.hpp

Go to the documentation of this file.
00001 //************************************************************************************//
00002 // Module       : gttlist.hpp
00003 // Date         : 8/9/02 (DLR)
00004 // Copyright    : 2002-2006 Copyright University Corporation for Atmospheric
00005 //                Research
00006 // Description  : Encapsulates the methods and data associated with
00007 //                a simple template linked list of a template class.
00008 //                This class was taken largely from Algorithms and Data Structures 
00009 //                in C++ by Ameraal, although it has been recast as a template
00010 //                class.
00011 // Derived From : none.
00012 // Modifications:
00013 //************************************************************************************//
00014 #if !defined(GTTLIST_HPP)
00015 #define GTTLIST_HPP
00016 
00017 #include "gtypes.h"
00018 #include <iostream.h>
00019 #include <stdlib.h>
00020 #include "gtbuffer.hpp"
00021 #include "gtvector.hpp"
00022 
00023 
00024 #if !defined(FBuffList)
00025 #  define FBuffList GTTList<GDOUBLE,GBuffer>
00026 #endif
00027 
00028 #if !defined(IBuffList)
00029 #  define IBuffList GTTList<GINT ,GBuffer>
00030 #endif
00031 
00032 #if !defined(BTBuffList)
00033 #  define BTBuffList GTTList<BDYTYPE,GBuffer>
00034 #endif
00035 
00036 #if !defined(GVecList)
00037 #  define GVecList GTTList<GDOUBLE,GTVector>
00038 #endif
00039 
00040 
00041 #if !defined(TTLINKELEM)
00042 #define TTLINKELEM
00043 #define TTLinkElem LinkElemTT<TL,TT>
00044 template<class TL, template<class> class TT> class LinkElemTT {
00045 public:
00046 GINT       id;
00047 GBOOL      cf;
00048 TT<TL>     *member;
00049 TTLinkElem *next;
00050 TTLinkElem *prev;
00051 }; 
00052 #endif
00053 
00054 template<class TL, template<class> class TT> class GTTList
00055 {
00056 public:
00057                           GTTList(GBOOL renumber_on_delete=FALSE);
00058                           GTTList(GINT  nelems, GBOOL renumber_on_delete=FALSE);
00059                           GTTList(const GTTList &){};
00060                          ~GTTList();
00061 
00062          void             operator=(TL a);
00063          void             operator=(GTTList<TL,TT> &v);
00064          void             add();
00065          void             add(TT<TL> *c, GBOOL delete_here);
00066          void             add(TL *c, GINT  n, GBOOL delete_here);
00067          TT<TL>           *del(TTLinkElem *e);
00068          TT<TL>           *del(TT<TL> *c);
00069          TT<TL>           *del(GINT  id);
00070 inline   void             start(TTLinkElem *p=NULL) {
00071            pCurr = ( p!=NULL ? p : pStart );
00072          }
00073          GINT             size() ;
00074 inline   TT<TL>           *member() {
00075            return pCurr ? pCurr->member : NULL;
00076          }
00077 inline   TT<TL>           *member(GINT id) {
00078             TTLinkElem *e;
00079             if ( (e=find(id)) == NULL ) return NULL;
00080             return e->member;
00081          }
00082 inline   TTLinkElem       *next() {
00083            TTLinkElem *p = pCurr ? pCurr->next : NULL;
00084            pCurr = p;
00085            return pCurr;
00086          }
00087          TTLinkElem       *curr();
00088          TTLinkElem       *find(GINT  id) {
00089            TTLinkElem *p=pCurr;
00090            // check from current pointer first:
00091            if ( p && p->id == id ) return p;
00092            else if ( p && p->next && p->next->id == id ) {
00093              next(); return p->next;
00094            }
00095            start(); // start at beginning and search:
00096            while ( (p=curr()) != NULL ) {
00097              if ( p->id == id ) return p; next();
00098            }
00099            return NULL;
00100          }
00101          TTLinkElem       *find(TT<TL> *member) {
00102            TTLinkElem *p=pCurr;
00103            // check from current pointer first:
00104            if ( p && p->member == member ) return p;
00105            else if ( p && p->next && p->next->member == member ) {
00106               next(); return p->next;
00107            }
00108            start(); // start at beginning and search:
00109            while ( (p=curr()) != NULL ) {
00110              if ( p->member == member ) return p; next();
00111            }
00112            return NULL;
00113          }
00114 inline   TL               &operator()(const GINT iElem, const GINT i) {
00115            TT<TL> *tt;
00116 #if !defined(GLIST_BOUNDS)
00117            tt=member(iElem);
00118 #else
00119            if ( (tt=member(iElem)) == NULL ) {
00120              cout << "GTTList::operator(): Cannot access element " << iElem << endl;
00121              exit(1);
00122            }
00123 #endif
00124            return (*tt)(i) ;
00125          }
00126 inline   TT<TL>           *&operator()(const GINT iElem) {
00127            TTLinkElem  *tt;
00128 #if !defined(GLIST_BOUNDS)
00129            tt=find(iElem);
00130 #else
00131            if ( (tt=find(iElem)) == NULL ) {
00132              cout << "GTTList::operator(): Cannot access element " << iElem << endl;
00133              exit(1);
00134            }
00135 #endif
00136            return tt->member;
00137          }
00138 inline   TT<TL>           *&operator[](const GINT iElem) {
00139            TTLinkElem *tt;
00140 #if !defined(GLIST_BOUNDS)
00141            tt=find(iElem);
00142 #else
00143            if ( (tt=find(iElem)) == NULL ) {
00144              cout << "GTTList::operator[]: Cannot access element " << iElem << endl;
00145              exit(1);
00146            }
00147 #endif
00148            return tt->member;
00149          }
00150          GINT             dim(const GINT iElem);
00151          GBOOL            renumber();
00152          void             empty();
00153          friend ostream&  operator<<(ostream&, GTTList<GDOUBLE,GBuffer>&);
00154          friend ostream&  operator<<(ostream&, GTTList<GINT ,GBuffer>&);
00155          friend ostream&  operator<<(ostream&, GTTList<BDYTYPE,GBuffer>&);
00156          friend ostream&  operator<<(ostream&, GTTList<GDOUBLE  ,GTVector>&);
00157 #if 0
00158          friend ostream&  operator<<(ostream&, GTTList<TL,TT>&);
00159 #endif
00160 
00161 private:
00162 // Private methods:
00163 
00164 // Private data:
00165         GINT              nid;
00166         GINT              num;
00167         GBOOL             doRenumber;
00168         TTLinkElem        *pStart;
00169         TTLinkElem        *pCurr;
00170         TTLinkElem        *pEnd;
00171 
00172 };
00173 #  if defined(_LINUX) || defined(_AIX)
00174 template class GTTList<GDOUBLE,GBuffer>;
00175 template class GTTList<GINT ,GBuffer>;
00176 template class GTTList<BDYTYPE,GBuffer>;
00177 template class GTTList<GDOUBLE,GTVector>;
00178 ostream &operator <<(ostream&, GTTList<GDOUBLE,GBuffer>&);
00179 ostream &operator <<(ostream&, GTTList<GINT ,GBuffer>&);
00180 ostream &operator <<(ostream&, GTTList<BDYTYPE,GBuffer>&);
00181 ostream &operator <<(ostream&, GTTList<GDOUBLE,GTVector>&);
00182 # endif
00183 #  if 0
00184 GTTList<GDOUBLE,GBuffer>   __dec_SEFBList;
00185 GTTList<GINT ,GBuffer>   __dec_SEIList;
00186 GTTList<BDYTYPE,GBuffer> __dec_SEBTList;
00187 GTTList<GDOUBLE,GTVector>   __dec_GVecList;
00188 ostream &operator <<(ostream&, GTTList<GDOUBLE,GBuffer>&);
00189 ostream &operator <<(ostream&, GTTList<GINT ,GBuffer>&);
00190 ostream &operator <<(ostream&, GTTList<BDYTYPE,GBuffer>&);
00191 ostream &operator <<(ostream&, GTTList<GDOUBLE,GTVector>&);
00192 #  endif
00193 #endif
00194 

Generated on Wed Dec 21 16:00:48 2005 for Geophysics & Astrophysics Spectral Element Adaptive Refinement (GASpAR) 2D Code by  doxygen 1.4.4