src/openbabel/obiter.hpp

/**********************************************************************
obiter.h - STL-style iterators for Open Babel.
 
Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
 
This file is part of the Open Babel project.
For more information, see <http://openbabel.sourceforge.net/>
 
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation version 2 of the License.
 
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
***********************************************************************/

#ifndef OB_OBITER_H
#define OB_OBITER_H

#include <vector>

namespace OpenBabel
{

  class OBMol;
  class OBAtom;
  class OBBond;
  class OBResidue;

  //! \brief Iterate over all atoms in an OBMol
class OBAPI OBMolAtomIter {
    std::vector<OBNodeBase*>::iterator _i;
    OBMol *_parent;
    OBAtom *_ptr;
public:

    OBMolAtomIter()              { _parent = NULL; _ptr = NULL; }
    OBMolAtomIter(OBMol *mol);
    OBMolAtomIter(OBMol &mol);
    OBMolAtomIter(const OBMolAtomIter &ai);

    OBMolAtomIter& operator=(const OBMolAtomIter &ai);
    operator bool() const        { return _ptr != NULL; }
    OBMolAtomIter operator++(int);
    OBAtom* operator->() const   { return _ptr;      }
    OBAtom& operator*() const    { return *_ptr;     }
};

  //! \brief Iterate over all bonds in an OBMol
class OBAPI OBMolBondIter {
    std::vector<OBEdgeBase*>::iterator _i;
    OBMol *_parent;
    OBBond *_ptr;
public:

    OBMolBondIter()              { _parent = NULL; _ptr = NULL; }
    OBMolBondIter(OBMol *mol);
    OBMolBondIter(OBMol &mol);
    OBMolBondIter(const OBMolBondIter &bi);

    OBMolBondIter& operator=(const OBMolBondIter &bi);
    operator bool() const        { return _ptr != NULL; }
    OBMolBondIter operator++(int);
    OBBond* operator->() const   { return _ptr;      }
    OBBond& operator*() const    { return *_ptr;     }
};

  //! \brief Iterate over all neighboring atoms to an OBAtom
class OBAPI OBAtomAtomIter {
    std::vector<OBEdgeBase*>::iterator _i;
    OBAtom *_parent;
    OBAtom *_ptr;
public:

    OBAtomAtomIter()             { _parent = NULL; _ptr = NULL; }
    OBAtomAtomIter(OBAtom *atm);
    OBAtomAtomIter(OBAtom &atm);
    OBAtomAtomIter(const OBAtomAtomIter &ai);

    OBAtomAtomIter& operator=(const OBAtomAtomIter &ai);
    operator bool() const        { return _ptr != NULL; }
    OBAtomAtomIter operator++(int);
    OBAtom* operator->() const   { return _ptr; }
    OBAtom& operator*() const    { return *_ptr;}
};

  //! \brief Iterate over all bonds on an OBAtom
class OBAPI OBAtomBondIter {
    std::vector<OBEdgeBase*>::iterator _i;
    OBAtom *_parent;
    OBBond *_ptr;
public:

    OBAtomBondIter()             { _parent = NULL; _ptr = NULL; }
    OBAtomBondIter(OBAtom *atm);
    OBAtomBondIter(OBAtom &atm);
    OBAtomBondIter(const OBAtomBondIter &bi);

    OBAtomBondIter& operator=(const OBAtomBondIter &bi);
    operator bool() const        { return _ptr != NULL; }
    OBAtomBondIter operator++(int);
    OBBond* operator->() const   { return _ptr; }
    OBBond& operator*() const    { return *_ptr;}
};

  //! \brief Iterate over all residues in an OBMol
class OBAPI OBResidueIter {
    std::vector<OBResidue*>::iterator _i;
    OBResidue *_ptr;
    OBMol *_parent;
public:

    OBResidueIter()              { _parent = NULL; _ptr = NULL; }
    OBResidueIter(OBMol *mol);
    OBResidueIter(OBMol &mol);
    OBResidueIter(const OBResidueIter &ri);

    OBResidueIter& operator=(const OBResidueIter &ri);
    operator bool() const        { return _ptr != NULL; }
    OBResidueIter operator++(int);
    OBResidue* operator->() const{ return _ptr; }
    OBResidue& operator*() const { return *_ptr;}
};

  //! \brief Iterate over all atoms in an OBResidue
class OBAPI OBResidueAtomIter {
    std::vector<OBAtom*>::iterator _i;
    OBResidue *_parent;
    OBAtom    *_ptr;
public:

    OBResidueAtomIter()          { _parent = NULL; _ptr = NULL; }
    OBResidueAtomIter(OBResidue *res);
    OBResidueAtomIter(OBResidue &res);
    OBResidueAtomIter(const OBResidueAtomIter &ri);

    OBResidueAtomIter &operator = (const OBResidueAtomIter &ri);
    operator bool() const        { return _ptr != NULL; }
    OBResidueAtomIter operator++ (int);
    OBAtom *operator->() const   { return _ptr; }
    OBAtom &operator*() const    { return *_ptr;}
};

#define FOR_ATOMS_OF_MOL(a,m)     for( OBMolAtomIter     a(m); a; a++ )
#define FOR_BONDS_OF_MOL(b,m)     for( OBMolBondIter     b(m); b; b++ )
#define FOR_NBORS_OF_ATOM(a,p)    for( OBAtomAtomIter    a(p); a; a++ )
#define FOR_BONDS_OF_ATOM(b,p)    for( OBAtomBondIter    b(p); b; b++ )
#define FOR_RESIDUES_OF_MOL(r,m)  for( OBResidueIter     r(m); r; r++ )
#define FOR_ATOMS_OF_RESIDUE(a,r) for( OBResidueAtomIter a(r); a; a++ )

} // namespace OpenBabel
#endif // OB_OBITER_H

//! \file obiter.h
//! \brief STL-style iterators for Open Babel.
Revision:	741
Committed:	Wed Nov 16 19:42:11 2005 UTC (19 years, 5 months ago) by tim
File size:	5213 byte(s)
Log Message:	adding openbabel
#	User	Rev	Content
1	tim	741	/**********************************************************************
2			obiter.h - STL-style iterators for Open Babel.
3
4			Copyright (C) 1998-2001 by OpenEye Scientific Software, Inc.
5			Some portions Copyright (C) 2001-2005 by Geoffrey R. Hutchison
6
7			This file is part of the Open Babel project.
8			For more information, see <http://openbabel.sourceforge.net/>
9
10			This program is free software; you can redistribute it and/or modify
11			it under the terms of the GNU General Public License as published by
12			the Free Software Foundation version 2 of the License.
13
14			This program is distributed in the hope that it will be useful,
15			but WITHOUT ANY WARRANTY; without even the implied warranty of
16			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17			GNU General Public License for more details.
18			***********************************************************************/
19
20			#ifndef OB_OBITER_H
21			#define OB_OBITER_H
22
23			#include <vector>
24
25			namespace OpenBabel
26			{
27
28			class OBMol;
29			class OBAtom;
30			class OBBond;
31			class OBResidue;
32
33			//! \brief Iterate over all atoms in an OBMol
34			class OBAPI OBMolAtomIter {
35			std::vector<OBNodeBase*>::iterator _i;
36			OBMol *_parent;
37			OBAtom *_ptr;
38			public:
39
40			OBMolAtomIter() { _parent = NULL; _ptr = NULL; }
41			OBMolAtomIter(OBMol *mol);
42			OBMolAtomIter(OBMol &mol);
43			OBMolAtomIter(const OBMolAtomIter &ai);
44
45			OBMolAtomIter& operator=(const OBMolAtomIter &ai);
46			operator bool() const { return _ptr != NULL; }
47			OBMolAtomIter operator++(int);
48			OBAtom* operator->() const { return _ptr; }
49			OBAtom& operator() const { return _ptr; }
50			};
51
52			//! \brief Iterate over all bonds in an OBMol
53			class OBAPI OBMolBondIter {
54			std::vector<OBEdgeBase*>::iterator _i;
55			OBMol *_parent;
56			OBBond *_ptr;
57			public:
58
59			OBMolBondIter() { _parent = NULL; _ptr = NULL; }
60			OBMolBondIter(OBMol *mol);
61			OBMolBondIter(OBMol &mol);
62			OBMolBondIter(const OBMolBondIter &bi);
63
64			OBMolBondIter& operator=(const OBMolBondIter &bi);
65			operator bool() const { return _ptr != NULL; }
66			OBMolBondIter operator++(int);
67			OBBond* operator->() const { return _ptr; }
68			OBBond& operator() const { return _ptr; }
69			};
70
71			//! \brief Iterate over all neighboring atoms to an OBAtom
72			class OBAPI OBAtomAtomIter {
73			std::vector<OBEdgeBase*>::iterator _i;
74			OBAtom *_parent;
75			OBAtom *_ptr;
76			public:
77
78			OBAtomAtomIter() { _parent = NULL; _ptr = NULL; }
79			OBAtomAtomIter(OBAtom *atm);
80			OBAtomAtomIter(OBAtom &atm);
81			OBAtomAtomIter(const OBAtomAtomIter &ai);
82
83			OBAtomAtomIter& operator=(const OBAtomAtomIter &ai);
84			operator bool() const { return _ptr != NULL; }
85			OBAtomAtomIter operator++(int);
86			OBAtom* operator->() const { return _ptr; }
87			OBAtom& operator() const { return _ptr;}
88			};
89
90			//! \brief Iterate over all bonds on an OBAtom
91			class OBAPI OBAtomBondIter {
92			std::vector<OBEdgeBase*>::iterator _i;
93			OBAtom *_parent;
94			OBBond *_ptr;
95			public:
96
97			OBAtomBondIter() { _parent = NULL; _ptr = NULL; }
98			OBAtomBondIter(OBAtom *atm);
99			OBAtomBondIter(OBAtom &atm);
100			OBAtomBondIter(const OBAtomBondIter &bi);
101
102			OBAtomBondIter& operator=(const OBAtomBondIter &bi);
103			operator bool() const { return _ptr != NULL; }
104			OBAtomBondIter operator++(int);
105			OBBond* operator->() const { return _ptr; }
106			OBBond& operator() const { return _ptr;}
107			};
108
109			//! \brief Iterate over all residues in an OBMol
110			class OBAPI OBResidueIter {
111			std::vector<OBResidue*>::iterator _i;
112			OBResidue *_ptr;
113			OBMol *_parent;
114			public:
115
116			OBResidueIter() { _parent = NULL; _ptr = NULL; }
117			OBResidueIter(OBMol *mol);
118			OBResidueIter(OBMol &mol);
119			OBResidueIter(const OBResidueIter &ri);
120
121			OBResidueIter& operator=(const OBResidueIter &ri);
122			operator bool() const { return _ptr != NULL; }
123			OBResidueIter operator++(int);
124			OBResidue* operator->() const{ return _ptr; }
125			OBResidue& operator() const { return _ptr;}
126			};
127
128			//! \brief Iterate over all atoms in an OBResidue
129			class OBAPI OBResidueAtomIter {
130			std::vector<OBAtom*>::iterator _i;
131			OBResidue *_parent;
132			OBAtom *_ptr;
133			public:
134
135			OBResidueAtomIter() { _parent = NULL; _ptr = NULL; }
136			OBResidueAtomIter(OBResidue *res);
137			OBResidueAtomIter(OBResidue &res);
138			OBResidueAtomIter(const OBResidueAtomIter &ri);
139
140			OBResidueAtomIter &operator = (const OBResidueAtomIter &ri);
141			operator bool() const { return _ptr != NULL; }
142			OBResidueAtomIter operator++ (int);
143			OBAtom *operator->() const { return _ptr; }
144			OBAtom &operator() const { return _ptr;}
145			};
146
147			#define FOR_ATOMS_OF_MOL(a,m) for( OBMolAtomIter a(m); a; a++ )
148			#define FOR_BONDS_OF_MOL(b,m) for( OBMolBondIter b(m); b; b++ )
149			#define FOR_NBORS_OF_ATOM(a,p) for( OBAtomAtomIter a(p); a; a++ )
150			#define FOR_BONDS_OF_ATOM(b,p) for( OBAtomBondIter b(p); b; b++ )
151			#define FOR_RESIDUES_OF_MOL(r,m) for( OBResidueIter r(m); r; r++ )
152			#define FOR_ATOMS_OF_RESIDUE(a,r) for( OBResidueAtomIter a(r); a; a++ )
153
154			} // namespace OpenBabel
155			#endif // OB_OBITER_H
156
157			//! \file obiter.h
158			//! \brief STL-style iterators for Open Babel.