00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #ifndef OB_OBITER_H
00021 #define OB_OBITER_H
00022
00023 #include <openbabel/babelconfig.h>
00024 #include <openbabel/base.h>
00025 #include <openbabel/bitvec.h>
00026
00027 #include <vector>
00028 #include <stack>
00029 #include <queue>
00030
00031 namespace OpenBabel
00032 {
00033
00034 class OBMol;
00035 class OBAtom;
00036 class OBBond;
00037 class OBResidue;
00038
00039
00040
00042 class OBAPI OBMolAtomIter {
00043 std::vector<OBAtom*>::iterator _i;
00044 OBMol *_parent;
00045 OBAtom *_ptr;
00046 public:
00047
00048 OBMolAtomIter() :_parent(NULL), _ptr(NULL) { }
00049 OBMolAtomIter(OBMol *mol);
00050 OBMolAtomIter(OBMol &mol);
00051 OBMolAtomIter(const OBMolAtomIter &ai);
00052 ~OBMolAtomIter() { }
00053
00054 OBMolAtomIter& operator=(const OBMolAtomIter &ai);
00056 operator bool() const { return _ptr != NULL; }
00058 OBMolAtomIter& operator++();
00060 OBMolAtomIter operator++(int);
00062 OBAtom* operator->() const { return _ptr; }
00064 OBAtom& operator*() const { return *_ptr; }
00065 };
00066
00068 class OBAPI OBMolAtomDFSIter {
00069 OBMol *_parent;
00070 OBAtom *_ptr;
00071 OBBitVec _notVisited;
00072 std::stack<OBAtom *> _stack;
00073 public:
00074
00075 OBMolAtomDFSIter() : _parent(NULL), _ptr(NULL) { }
00076 OBMolAtomDFSIter(OBMol *mol, int StartIndex=1);
00077 OBMolAtomDFSIter(OBMol &mol, int StartIndex=1);
00078 OBMolAtomDFSIter(const OBMolAtomDFSIter &ai);
00079 ~OBMolAtomDFSIter() { }
00080
00081 OBMolAtomDFSIter& operator=(const OBMolAtomDFSIter &ai);
00083 operator bool() const { return _ptr != NULL; }
00085 OBMolAtomDFSIter& operator++();
00087 OBMolAtomDFSIter operator++(int);
00089 OBAtom* operator->() const { return _ptr; }
00091 OBAtom& operator*() const { return *_ptr; }
00093 OBAtom* next()
00094 {
00095 if(_stack.empty())
00096 return NULL;
00097 else
00098 return _stack.top();
00099 }
00100 };
00101
00103 class OBAPI OBMolAtomBFSIter {
00104 OBMol *_parent;
00105 OBAtom *_ptr;
00106 OBBitVec _notVisited;
00107 std::queue<OBAtom *> _queue;
00108 std::vector<int> _depth;
00109 public:
00110
00111 OBMolAtomBFSIter(): _parent(NULL), _ptr(NULL) { }
00112 OBMolAtomBFSIter(OBMol *mol, int StartIndex = 1);
00113 OBMolAtomBFSIter(OBMol &mol, int StartIndex = 1);
00114 OBMolAtomBFSIter(const OBMolAtomBFSIter &ai);
00115 ~OBMolAtomBFSIter() { }
00116
00117 OBMolAtomBFSIter& operator=(const OBMolAtomBFSIter &ai);
00119 operator bool() const { return _ptr != NULL; }
00121 OBMolAtomBFSIter& operator++();
00123 OBMolAtomBFSIter operator++(int);
00125 OBAtom* operator->() const { return _ptr; }
00127 OBAtom& operator*() const { return *_ptr; }
00130 int CurrentDepth() const;
00131 };
00132
00134 class OBAPI OBMolBondIter {
00135 std::vector<OBBond*>::iterator _i;
00136 OBMol *_parent;
00137 OBBond *_ptr;
00138 public:
00139
00140 OBMolBondIter() : _parent(NULL), _ptr(NULL) {}
00141 OBMolBondIter(OBMol *mol);
00142 OBMolBondIter(OBMol &mol);
00143 OBMolBondIter(const OBMolBondIter &bi);
00144 ~OBMolBondIter() { }
00145
00146 OBMolBondIter& operator=(const OBMolBondIter &bi);
00148 operator bool() const { return _ptr != NULL; }
00150 OBMolBondIter& operator++();
00152 OBMolBondIter operator++(int);
00154 OBBond* operator->() const { return _ptr; }
00156 OBBond& operator*() const { return *_ptr; }
00157 };
00158
00160 class OBAPI OBAtomAtomIter {
00161 std::vector<OBBond*>::iterator _i;
00162 OBAtom *_parent;
00163 OBAtom *_ptr;
00164 public:
00165
00166 OBAtomAtomIter() : _parent(NULL), _ptr(NULL) { }
00167 OBAtomAtomIter(OBAtom *atm);
00168 OBAtomAtomIter(OBAtom &atm);
00169 OBAtomAtomIter(const OBAtomAtomIter &ai);
00170 ~OBAtomAtomIter() { }
00171
00172 OBAtomAtomIter& operator=(const OBAtomAtomIter &ai);
00174 operator bool() const { return _ptr != NULL; }
00176 OBAtomAtomIter& operator++();
00178 OBAtomAtomIter operator++(int);
00180 OBAtom* operator->() const { return _ptr; }
00182 OBAtom& operator*() const { return *_ptr; }
00183 };
00184
00186 class OBAPI OBAtomBondIter {
00187 std::vector<OBBond*>::iterator _i;
00188 OBAtom *_parent;
00189 OBBond *_ptr;
00190 public:
00191
00192 OBAtomBondIter(): _parent(NULL), _ptr(NULL) { }
00193 OBAtomBondIter(OBAtom *atm);
00194 OBAtomBondIter(OBAtom &atm);
00195 OBAtomBondIter(const OBAtomBondIter &bi);
00196 ~OBAtomBondIter() { }
00197
00198 OBAtomBondIter& operator=(const OBAtomBondIter &bi);
00200 operator bool() const { return _ptr != NULL; }
00202 OBAtomBondIter& operator++();
00204 OBAtomBondIter operator++(int);
00206 OBBond* operator->() const { return _ptr; }
00208 OBBond& operator*() const { return *_ptr;}
00209 };
00210
00212 class OBAPI OBResidueIter {
00213 std::vector<OBResidue*>::iterator _i;
00214 OBResidue *_ptr;
00215 OBMol *_parent;
00216 public:
00217
00218 OBResidueIter() : _ptr(NULL), _parent(NULL) { }
00219 OBResidueIter(OBMol *mol);
00220 OBResidueIter(OBMol &mol);
00221 OBResidueIter(const OBResidueIter &ri);
00222 ~OBResidueIter() { }
00223
00224 OBResidueIter& operator=(const OBResidueIter &ri);
00226 operator bool() const { return _ptr != NULL; }
00228 OBResidueIter& operator++();
00230 OBResidueIter operator++(int);
00232 OBResidue* operator->() const{ return _ptr; }
00234 OBResidue& operator*() const { return *_ptr;}
00235 };
00236
00238 class OBAPI OBResidueAtomIter {
00239 std::vector<OBAtom*>::iterator _i;
00240 OBResidue *_parent;
00241 OBAtom *_ptr;
00242 public:
00243
00244 OBResidueAtomIter() : _parent(NULL), _ptr(NULL) { }
00245 OBResidueAtomIter(OBResidue *res);
00246 OBResidueAtomIter(OBResidue &res);
00247 OBResidueAtomIter(const OBResidueAtomIter &ri);
00248 ~OBResidueAtomIter() { }
00249
00250 OBResidueAtomIter &operator = (const OBResidueAtomIter &ri);
00252 operator bool() const { return _ptr != NULL; }
00254 OBResidueAtomIter& operator++ ();
00256 OBResidueAtomIter operator++ (int);
00258 OBAtom *operator->() const { return _ptr; }
00260 OBAtom &operator*() const { return *_ptr;}
00261 };
00262
00264 class OBAPI OBMolAngleIter {
00265 OBMol *_parent;
00266 std::vector<std::vector<unsigned int> > _vangle;
00267 std::vector<std::vector<unsigned int> >::iterator _i;
00268 std::vector<unsigned int> _angle;
00269 public:
00270
00271 OBMolAngleIter() :_parent(NULL) { }
00272 OBMolAngleIter(OBMol *mol);
00273 OBMolAngleIter(OBMol &mol);
00274 OBMolAngleIter(const OBMolAngleIter &ai);
00275 ~OBMolAngleIter() { }
00276
00277 OBMolAngleIter& operator=(const OBMolAngleIter &ai);
00279 operator bool() const { return (_i != _vangle.end()); }
00281 OBMolAngleIter& operator++();
00284 std::vector<unsigned int> operator*() const { return _angle; }
00285 };
00286
00288 class OBAPI OBMolTorsionIter {
00289 OBMol *_parent;
00290 std::vector<std::vector<unsigned int> > _vtorsion;
00291 std::vector<std::vector<unsigned int> >::iterator _i;
00292 std::vector<unsigned int> _torsion;
00293 public:
00294
00295 OBMolTorsionIter() :_parent(NULL) { }
00296 OBMolTorsionIter(OBMol *mol);
00297 OBMolTorsionIter(OBMol &mol);
00298 OBMolTorsionIter(const OBMolTorsionIter &ai);
00299 ~OBMolTorsionIter() { }
00300
00301 OBMolTorsionIter& operator=(const OBMolTorsionIter &ai);
00303 operator bool() const { return (_i != _vtorsion.end()); }
00305 OBMolTorsionIter& operator++();
00308 std::vector<unsigned int> operator*() const { return _torsion; }
00309 };
00310
00312 class OBAPI OBMolPairIter {
00313 std::vector<OBAtom*>::iterator _i;
00314 std::vector<OBAtom*>::iterator _j;
00315 OBMol *_parent;
00316
00317
00318 std::vector<unsigned int> _pair;
00319
00320 public:
00321
00322 OBMolPairIter() :_parent(NULL) { }
00323 OBMolPairIter(OBMol *mol);
00324 OBMolPairIter(OBMol &mol);
00325 OBMolPairIter(const OBMolPairIter &ai);
00326 ~OBMolPairIter() { }
00327
00328 OBMolPairIter& operator=(const OBMolPairIter &ai);
00330 operator bool() const { return _pair.size()>0; }
00332 OBMolPairIter& operator++();
00335 std::vector<unsigned int> operator*() const { return _pair; }
00336 };
00337
00338
00340 class OBAPI OBMolRingIter {
00341 std::vector<OBRing*>::iterator _i;
00342 OBRing *_ptr;
00343 OBMol *_parent;
00344 OBRingData *_rings;
00345 public:
00346
00347 OBMolRingIter() : _ptr(NULL), _parent(NULL), _rings(NULL) { }
00348 OBMolRingIter(OBMol *mol);
00349 OBMolRingIter(OBMol &mol);
00350 OBMolRingIter(const OBMolRingIter &ri);
00351 ~OBMolRingIter() { }
00352
00353 OBMolRingIter& operator=(const OBMolRingIter &ri);
00355 operator bool() const { return _ptr != NULL; }
00357 OBMolRingIter& operator++();
00359 OBMolRingIter operator++(int);
00361 OBRing* operator->() const { return _ptr; }
00363 OBRing& operator*() const { return *_ptr;}
00364 };
00365
00366 #define FOR_ATOMS_OF_MOL(a,m) for( OBMolAtomIter a(m); a; ++a )
00367 #define FOR_BONDS_OF_MOL(b,m) for( OBMolBondIter b(m); b; ++b )
00368 #define FOR_NBORS_OF_ATOM(a,p) for( OBAtomAtomIter a(p); a; ++a )
00369 #define FOR_BONDS_OF_ATOM(b,p) for( OBAtomBondIter b(p); b; ++b )
00370 #define FOR_RESIDUES_OF_MOL(r,m) for( OBResidueIter r(m); r; ++r )
00371 #define FOR_ATOMS_OF_RESIDUE(a,r) for( OBResidueAtomIter a(r); a; ++a )
00372 #define FOR_DFS_OF_MOL(a,m) for( OBMolAtomDFSIter a(m); a; ++a )
00373 #define FOR_BFS_OF_MOL(a,m) for( OBMolAtomBFSIter a(m); a; ++a )
00374 #define FOR_RINGS_OF_MOL(a,m) for( OBMolRingIter r(m); r; ++r )
00375 #define FOR_ANGLES_OF_MOL(a,m) for( OBMolAngleIter a(m); a; ++a )
00376 #define FOR_TORSIONS_OF_MOL(t,m) for( OBMolTorsionIter t(m); t; ++t )
00377 #define FOR_PAIRS_OF_MOL(p,m) for( OBMolPairIter p(m); p; ++p )
00378
00379 }
00380 #endif // OB_OBITER_H
00381