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

AtomSignature Class Reference

#include <structures.h>

List of all members.

Public Member Functions

 AtomSignature ()
 AtomSignature (const AtomSignature &sig)
AtomSignature & operator= (const AtomSignature &sig)
int operator== (const AtomSignature &sig) const
 ~AtomSignature ()
void removeEmptyTupleSigs ()
void pack (MOStream *msg)
void unpack (MIStream *msg)

Public Attributes

int bondCnt
int angleCnt
int dihedralCnt
int improperCnt
int crosstermCnt
TupleSignature * bondSigs
TupleSignature * angleSigs
TupleSignature * dihedralSigs
TupleSignature * improperSigs
TupleSignature * crosstermSigs

Constructor & Destructor Documentation

AtomSignature::AtomSignature (   )  [inline]
 

Definition at line 310 of file structures.h.

00310                    {
00311         bondCnt=angleCnt=dihedralCnt=improperCnt=crosstermCnt=0;
00312         bondSigs = NULL;
00313         angleSigs = NULL;
00314         dihedralSigs = NULL;
00315         improperSigs = NULL;
00316         crosstermSigs = NULL;
00317     }

AtomSignature::AtomSignature (  const AtomSignature &  sig  )  [inline]
 

Definition at line 318 of file structures.h.

References angleCnt, angleSigs, bondCnt, bondSigs, crosstermCnt, crosstermSigs, dihedralCnt, dihedralSigs, improperCnt, and improperSigs.

00318                                            {
00319         bondSigs = NULL;
00320         angleSigs = NULL;
00321         dihedralSigs = NULL;
00322         improperSigs = NULL;
00323         crosstermSigs = NULL;
00324 
00325         bondCnt = sig.bondCnt;
00326         if(bondCnt>0){            
00327             bondSigs = new TupleSignature[bondCnt];
00328             for(int i=0; i<bondCnt; i++)
00329                 bondSigs[i] = sig.bondSigs[i];
00330         }
00331 
00332         angleCnt = sig.angleCnt;
00333         if(angleCnt>0){            
00334             angleSigs = new TupleSignature[angleCnt];
00335             for(int i=0; i<angleCnt; i++)
00336                 angleSigs[i] = sig.angleSigs[i];
00337         }
00338         
00339         dihedralCnt = sig.dihedralCnt;
00340         if(dihedralCnt>0){            
00341             dihedralSigs = new TupleSignature[dihedralCnt];
00342             for(int i=0; i<dihedralCnt; i++)
00343                 dihedralSigs[i] = sig.dihedralSigs[i];
00344         }
00345         
00346         improperCnt = sig.improperCnt;
00347         if(improperCnt>0){
00348             improperSigs = new TupleSignature[improperCnt];
00349             for(int i=0; i<improperCnt; i++)
00350                 improperSigs[i] = sig.improperSigs[i];
00351         }      
00352 
00353         crosstermCnt = sig.crosstermCnt;
00354         if(crosstermCnt>0){
00355             crosstermSigs = new TupleSignature[crosstermCnt];
00356             for(int i=0; i<crosstermCnt; i++)
00357                 crosstermSigs[i] = sig.crosstermSigs[i];
00358         }        
00359     }

AtomSignature::~AtomSignature (   )  [inline]
 

Definition at line 428 of file structures.h.

00428                     {
00429         if(bondSigs) delete[] bondSigs;
00430         if(angleSigs) delete[] angleSigs;
00431         if(dihedralSigs) delete[] dihedralSigs;
00432         if(improperSigs) delete[] improperSigs;
00433         if(crosstermSigs) delete[] crosstermSigs;
00434     }

Member Function Documentation

AtomSignature& AtomSignature::operator= (  const AtomSignature &  sig  )  [inline]
 

Definition at line 360 of file structures.h.

References angleCnt, angleSigs, bondCnt, bondSigs, crosstermCnt, crosstermSigs, dihedralCnt, dihedralSigs, improperCnt, and improperSigs.

00360                                                       {        
00361         bondCnt = sig.bondCnt;
00362         if(bondSigs) delete [] bondSigs;
00363         if(bondCnt>0){
00364             bondSigs = new TupleSignature[bondCnt];
00365             for(int i=0; i<bondCnt; i++)
00366                 bondSigs[i] = sig.bondSigs[i];
00367         }else
00368             bondSigs = NULL;
00369 
00370         angleCnt = sig.angleCnt;
00371         if(angleSigs) delete [] angleSigs;
00372         if(angleCnt>0){
00373             angleSigs = new TupleSignature[angleCnt];
00374             for(int i=0; i<angleCnt; i++)
00375                 angleSigs[i] = sig.angleSigs[i];
00376         }else
00377             angleSigs = NULL;
00378         
00379         dihedralCnt = sig.dihedralCnt;
00380         if(dihedralSigs) delete [] dihedralSigs;
00381         if(dihedralCnt>0){
00382             dihedralSigs = new TupleSignature[dihedralCnt];
00383             for(int i=0; i<dihedralCnt; i++)
00384                 dihedralSigs[i] = sig.dihedralSigs[i];
00385         }else
00386             dihedralSigs = NULL;
00387         
00388         improperCnt = sig.improperCnt;
00389         if(improperSigs) delete [] improperSigs;
00390         if(improperCnt>0){
00391             improperSigs = new TupleSignature[improperCnt];
00392             for(int i=0; i<improperCnt; i++)
00393                 improperSigs[i] = sig.improperSigs[i];
00394         }else
00395             improperSigs = NULL;      
00396 
00397         crosstermCnt = sig.crosstermCnt;
00398         if(crosstermSigs) delete [] crosstermSigs;
00399         if(crosstermCnt>0){
00400             crosstermSigs = new TupleSignature[crosstermCnt];
00401             for(int i=0; i<crosstermCnt; i++)
00402                 crosstermSigs[i] = sig.crosstermSigs[i];
00403         }else
00404             crosstermSigs = NULL;
00405 
00406         return *this;
00407     }

int AtomSignature::operator== (  const AtomSignature &  sig  )  const [inline]
 

Definition at line 408 of file structures.h.

References angleCnt, bondCnt, CMPSIGS, crosstermCnt, dihedralCnt, and improperCnt.

00408                                                   {
00409             if(bondCnt!=sig.bondCnt) return 0;
00410             if(angleCnt!=sig.angleCnt) return 0;
00411             if(dihedralCnt!=sig.dihedralCnt) return 0;
00412             if(improperCnt!=sig.improperCnt) return 0;
00413             if(crosstermCnt!=sig.crosstermCnt) return 0;
00414         
00415         #define CMPSIGS(TUPLE) \
00416         for(int i=0; i<sig.TUPLE##Cnt; i++){ \
00417             if(!(TUPLE##Sigs[i]==sig.TUPLE##Sigs[i])) return 0; \
00418         } \
00419         
00420             CMPSIGS(bond)
00421             CMPSIGS(angle)
00422             CMPSIGS(dihedral)
00423             CMPSIGS(improper)
00424             CMPSIGS(crossterm)
00425         
00426             return 1;
00427         }

void AtomSignature::pack (  MOStream *  msg  ) 
 

void AtomSignature::removeEmptyTupleSigs (   ) 
 

void AtomSignature::unpack (  MIStream *  msg  ) 
 

Member Data Documentation

int AtomSignature::angleCnt
 

Definition at line 299 of file structures.h.

Referenced by AtomSignature(), dumpbench(), AngleElem::getTupleInfo(), operator=(), and operator==().

TupleSignature* AtomSignature::angleSigs
 

Definition at line 305 of file structures.h.

Referenced by AtomSignature(), dumpbench(), AngleElem::getTupleInfo(), and operator=().

int AtomSignature::bondCnt
 

Definition at line 298 of file structures.h.

Referenced by AtomSignature(), dumpbench(), ExclElem::getTupleInfo(), BondElem::getTupleInfo(), operator=(), operator==(), and Molecule::print_bonds().

TupleSignature* AtomSignature::bondSigs
 

Definition at line 304 of file structures.h.

Referenced by AtomSignature(), dumpbench(), ExclElem::getTupleInfo(), BondElem::getTupleInfo(), operator=(), and Molecule::print_bonds().

int AtomSignature::crosstermCnt
 

Definition at line 302 of file structures.h.

Referenced by AtomSignature(), CrosstermElem::getTupleInfo(), operator=(), and operator==().

TupleSignature* AtomSignature::crosstermSigs
 

Definition at line 308 of file structures.h.

Referenced by AtomSignature(), CrosstermElem::getTupleInfo(), and operator=().

int AtomSignature::dihedralCnt
 

Definition at line 300 of file structures.h.

Referenced by AtomSignature(), dumpbench(), DihedralElem::getTupleInfo(), operator=(), and operator==().

TupleSignature* AtomSignature::dihedralSigs
 

Definition at line 306 of file structures.h.

Referenced by AtomSignature(), dumpbench(), DihedralElem::getTupleInfo(), and operator=().

int AtomSignature::improperCnt
 

Definition at line 301 of file structures.h.

Referenced by AtomSignature(), dumpbench(), ImproperElem::getTupleInfo(), operator=(), and operator==().

TupleSignature* AtomSignature::improperSigs
 

Definition at line 307 of file structures.h.

Referenced by AtomSignature(), dumpbench(), ImproperElem::getTupleInfo(), and operator=().

The documentation for this class was generated from the following file:
Generated on Mon Nov 23 04:59:31 2009 for NAMD by  doxygen 1.3.9.1