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

gelemlist.hpp

Go to the documentation of this file.
00001 //************************************************************************************//
00002 // Module       : gelemlist.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 element linked list. This class was taken
00008 //                largely from Algorithms and Data Structures in C++
00009 //                by Ameraal, although it has been recast. 
00010 // Derived From : none.
00011 // Modifications:
00012 //************************************************************************************//
00013 #if !defined(GELEMLIST_HPP)
00014 #define GELEMLIST_HPP
00015 
00016 #include "gtypes.h"
00017 #include "rectquad2d.hpp"
00018 #include "defquad2d.hpp"
00019 #include <iostream.h>
00020 #include <stdlib.h>
00021 
00022 #if !defined(GELEMLIST_MEM)
00023 #define GELEMLIST_MEM
00024 struct ElemListSt {
00025 GINT       id;       // Key id
00026 GBOOL      cf;       // Was member fully instantiated?
00027 Elem2D     *member;  // Member data
00028 ELEMTYPE   type;     // Element type id
00029 ElemListSt *next;    // Next in list
00030 ElemListSt *prev;    // Previous in list
00031 }; 
00032 #endif
00033 
00034 class GElemList
00035 {
00036 
00037 public:
00038                            GElemList(GBOOL renumber_on_delete=FALSE);
00039                            GElemList(const GElemList &);
00040                           ~GElemList();
00041 
00042          void             add(ELEMTYPE itype, GINT ntmp);
00043          void             add(Elem2D *c);
00044          Elem2D           *del(ElemListSt *c);
00045          Elem2D           *del(Elem2D *c);
00046          Elem2D           *del(GINT  id);
00047 inline   void             start(ElemListSt *p=NULL) {
00048            pCurr = ( p!=NULL ? p : pStart );
00049          }
00050          GINT             size() const;
00051 inline   Elem2D           *member() {
00052            return pCurr ? pCurr->member : NULL;
00053          }
00054 inline   Elem2D           *member(GINT  id) {
00055            ElemListSt *e;
00056            if ( (e=find(id)) == NULL ) return NULL;
00057            return e->member;
00058          }
00059 inline   Elem2D           *member(GKEY key) {
00060            ElemListSt *e;
00061            if ( (e=find(key)) == NULL ) return NULL;
00062            return e->member;
00063          }
00064 inline   ElemListSt       *next() {
00065            ElemListSt *p = pCurr ? pCurr->next : NULL;
00066            pCurr = p; return pCurr;
00067          }
00068          ElemListSt       *curr();
00069 inline   ElemListSt       *find(GINT  id) {
00070            ElemListSt *p=pCurr;
00071            // check from current pointer first:
00072            if ( p && p->id == id ) return p;
00073            else if ( p && p->next && p->next->id == id ) {
00074              next();
00075              return p->next;
00076            }
00077            start(NULL); // start at beginning and search:
00078            while ( (p=curr()) != NULL ) {
00079              if ( p->id == id ) return p;
00080              next();
00081            }
00082            return NULL;
00083          }
00084 inline   ElemListSt       *find(Elem2D *member) {
00085            ElemListSt *p=pCurr;
00086            // check from current pointer first:
00087            if ( p && p->member == member ) return p;
00088            else if ( p && p->next && p->next->member == member ) { 
00089               next();
00090               return p->next;
00091            }
00092            start(NULL); // start at beginning and search:
00093            while ( (p=curr()) != NULL ) {
00094              if ( p->member == member ) return p;
00095              next();
00096            }
00097            return NULL;
00098          }
00099 inline   ElemListSt       *find(GKEY key) {
00100            ElemListSt *p=pCurr;
00101            // check from current pointer first:
00102            if ( p && p->member->GetID() == key ) return p;
00103            else if ( p && p->next && p->next->member->GetID() == key ) {
00104              next();
00105              return p->next;
00106            }
00107            start(NULL); // start at beginning and search:
00108            while ( (p=curr()) != NULL ) {
00109              if ( p->member->GetID() == key ) return p;
00110              next();
00111            }
00112            return NULL;
00113          }
00114          GVector          *X (const GINT  iElem, const GINT  idir);
00115          GDOUBLE            &X (const GINT  iElem, const GINT  idir, const GINT  i);
00116          GINT             dim(const GINT  iElem, const GINT  idir);
00117          GBOOL            renumber();
00118          void             empty();
00119 inline   Elem2D           *&operator()(const GINT  iElem) {
00120            ElemListSt *tt;
00121 #if !defined(GLIST_BOUNDS)
00122            tt=find(iElem);
00123 #else
00124            if ( (tt=find(iElem)) == NULL ) {
00125              cout << "GElemList::operator(): Cannot access element " << iElem << endl;
00126              exit(1);
00127            }
00128 #endif
00129            return tt->member ;
00130          }
00131 inline   Elem2D           *&operator[](const GINT  iElem) {
00132            ElemListSt *tt;
00133 #if !defined(GLIST_BOUNDS)
00134            tt=find(iElem); 
00135 #else
00136            if ( (tt=find(iElem)) == NULL ) {
00137              cout << "GElemList::operator[]: Cannot access element " << iElem << endl;
00138              exit(1);
00139            }
00140 #endif
00141            return tt->member ;
00142          }
00143          friend ostream&  operator<<(ostream&, GElemList&);
00144 
00145 
00146 
00147 private:
00148 // Private methods:
00149 // Private data:
00150         GINT               nid;
00151         GINT               num;
00152         GBOOL              doRenumber;
00153         ElemListSt        *pStart;
00154         ElemListSt        *pCurr;
00155         ElemListSt        *pEnd;
00156 
00157 };
00158 #endif
00159 

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