src/openbabel/obiter.cpp

/**********************************************************************
obiter.cpp - 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.
***********************************************************************/

#include <vector>

#include "mol.hpp"
#include "obiter.hpp"

using namespace std;

namespace OpenBabel
{

  /** \class OBMolAtomIter

  To facilitate iteration through all atoms in a molecule, without resorting
  to atom indexes (which may change in the future) or the OBMol::BeginAtom()
  and OBMol::NextAtom() methods which may only be safely used by one method
  at once (e.g., if a method above your code or underneath your code uses these
  methods, errors will occur).

  Therefore, it is <strong>highly recommended</strong> to use the separate
  STL-style iterator classes.

  This has been made significantly easier by a series of macros in the 
  obiter.h header file:

  \code
    \#define FOR_ATOMS_OF_MOL(a,m)     for( OBMolAtomIter     a(m); a; a++ )
  \endcode

  Here is an example:
  \code
     #include "obiter.hpp"
   #include "mol.hpp"

   OBMol mol;
   double exactMass = 0.0f;
   FOR_ATOMS_OF_MOL(a, mol)
   {
       exactMass +=  a->GetExactMass();
   }
  \endcode
  **/

  OBMolAtomIter::OBMolAtomIter(OBMol *mol)
  {
    _parent = mol;
    _ptr = _parent->BeginAtom(_i);
  }

  OBMolAtomIter::OBMolAtomIter(OBMol &mol)
  {
    _parent = &mol;
    _ptr = _parent->BeginAtom(_i);
  }

  OBMolAtomIter::OBMolAtomIter(const OBMolAtomIter &ai)
  {
    _parent = ai._parent;
    _ptr = ai._ptr;
    _i = ai._i;
  }

  OBMolAtomIter& OBMolAtomIter::operator=(const OBMolAtomIter &ai)
  {
    if (this != &ai)
      {
        _parent = ai._parent;
        _ptr = ai._ptr;
        _i = ai._i;
      }
    return *this;
  }

  OBMolAtomIter OBMolAtomIter::operator++(int)
  {
    _ptr = _parent->NextAtom(_i);
    return *this;
  }


  /** \class OBMolBondIter

  To facilitate iteration through all bonds in a molecule, without resorting
  to bond indexes (which may change in the future) or the OBMol::BeginBond()
  and OBMol::NextBond() methods which may only be safely used by one method
  at once (e.g., if a method above your code or underneath your code uses these
  methods, errors will occur).

  Therefore, it is <strong>highly recommended</strong> to use the separate
  STL-style iterator classes.

  This has been made significantly easier by a series of macros in the 
  obiter.h header file:

  \code
    \#define FOR_BONDS_OF_MOL(b,m)     for( OBMolBondIter     b(m); b; b++ )
  \endcode

  Here is an example:
  \code
   #include "obiter.hpp"
   #include "mol.hpp"

   OBMol mol;
   unsigned int bondOrderSum = 0;
   FOR_BONDS_OF_MOL(b, mol)
   {
       bondOrderSum +=  b->GetBO();
   }
  \endcode
  **/

  OBMolBondIter::OBMolBondIter(OBMol *mol)
    {
        _parent = mol;
        _ptr = _parent->BeginBond(_i);
    }

  OBMolBondIter::OBMolBondIter(OBMol &mol)
    {
        _parent = &mol;
        _ptr = _parent->BeginBond(_i);
    }

  OBMolBondIter::OBMolBondIter(const OBMolBondIter &bi)
    {
        _parent = bi._parent;
        _ptr = bi._ptr;
        _i = bi._i;
    }

  OBMolBondIter& OBMolBondIter::operator=(const OBMolBondIter &bi)
    {
        if (this != &bi)
        {
            _parent = bi._parent;
            _ptr = bi._ptr;
            _i = bi._i;
        }
        return *this;
    }

  OBMolBondIter OBMolBondIter::operator++(int)
    {
        _ptr = _parent->NextBond(_i);
        return *this;
    }

  /** \class OBAtomAtomIter

  To facilitate iteration through all neighbors of an atom, without resorting
  to bond indexes (which may change in the future) or the OBAtom::BeginNbr()
  and OBAtom::NextNbr() methods which may only be safely used by one method
  at once (e.g., if a method above your code or underneath your code uses these
  methods, errors will occur).

  Therefore, it is <strong>highly recommended</strong> to use the separate
  STL-style iterator classes.

  This has been made significantly easier by a series of macros in the 
  obiter.h header file:

  \code
    \#define FOR_NBORS_OF_ATOM(a,p)     for( OBAtomAtomIter     a(p); a; a++ )
  \endcode

  Here is an example:
  \code
   #include "obiter.hpp"
   #include "mol.hpp"

   OBMol mol;
   FOR_ATOMS_OF_MOL(a, mol)
   {
     FOR_NBORS_OF_ATOM(b, a)
      {
         ...
      }
   }
  \endcode
  **/

  OBAtomAtomIter::OBAtomAtomIter(OBAtom *atm)
  {
    _parent = atm;
    _ptr = _parent->BeginNbrAtom(_i);
  }

  OBAtomAtomIter::OBAtomAtomIter(OBAtom &atm)
    {
        _parent = &atm;
        _ptr = _ptr->BeginNbrAtom(_i);
    }

  OBAtomAtomIter::OBAtomAtomIter(const OBAtomAtomIter &ai)
    {
        _parent = ai._parent;
        _ptr = ai._ptr;
        _i = ai._i;
    }

  OBAtomAtomIter& OBAtomAtomIter::operator=(const OBAtomAtomIter &ai)
    {
        if (this != &ai)
        {
            _parent = ai._parent;
            _ptr = ai._ptr;
            _i = ai._i;
        }
        return *this;
    }

  OBAtomAtomIter OBAtomAtomIter::operator++(int)
    {
        _ptr = _parent->NextNbrAtom(_i);
        return *this;
    }

  /** \class OBAtomBondIter

  To facilitate iteration through all bonds on an atom, without resorting
  to bond indexes (which may change in the future) or the OBAtom::BeginBond()
  and OBAtom::NextBond() methods which may only be safely used by one method
  at once (e.g., if a method above your code or underneath your code uses these
  methods, errors will occur).

  Therefore, it is <strong>highly recommended</strong> to use the separate
  STL-style iterator classes.

  This has been made significantly easier by a series of macros in the 
  obiter.h header file:

  \code
    \#define FOR_BONDS_OF_ATOM(b,p)     for( OBAtomBondIter     b(p); b; b++ )
  \endcode

  Here is an example:
  \code
   #include "obiter.hpp"
   #include "mol.hpp"

   OBAtom atom;
   unsigned int tripleBondCount;
   FOR_BONDS_OF_ATOM(b, atom)
   {
      if (b->GetBO() == 3)
         tripleBondCount++;
   }
  \endcode
  **/

  OBAtomBondIter::OBAtomBondIter(OBAtom *atm)
    {
        _parent = atm;
        _ptr = _parent->BeginBond(_i);
    }

  OBAtomBondIter::OBAtomBondIter(OBAtom &atm)
    {
        _parent = &atm;
        _ptr = _parent->BeginBond(_i);
    }

  OBAtomBondIter::OBAtomBondIter(const OBAtomBondIter &bi)
    {
        _parent = bi._parent;
        _ptr = bi._ptr;
        _i = bi._i;
    }

  OBAtomBondIter& OBAtomBondIter::operator=(const OBAtomBondIter &bi)
    {
        if (this != &bi)
        {
            _parent = bi._parent;
            _ptr = bi._ptr;
            _i = bi._i;
        }
        return *this;
    }

  OBAtomBondIter OBAtomBondIter::operator++(int)
    {
        _ptr = _parent->NextBond(_i);
        return *this;
    }

  /** \class OBResidueIter

  To facilitate iteration through all residues in a molecule, without resorting
  to residue indexes (which may change in the future) or the OBMol::BeginResidue()
  and OBMol::NextResidue() methods which may only be safely used by one method
  at once (e.g., if a method above your code or underneath your code uses these
  methods, errors will occur).

  Therefore, it is <strong>highly recommended</strong> to use the separate
  STL-style iterator classes.

  This has been made significantly easier by a series of macros in the 
  obiter.h header file:

  \code
    \#define FOR_RESIDUES_OF_MOL(a,m)     for( OBResidueIter     a(m); a; a++ )
  \endcode

  Here is an example:
  \code
   #include "obiter.hpp"
   #include "mol.hpp"

   OBMol mol;
   FOR_RESIDUES_OF_MOL(r, mol)
   {
     if (r->GetName() == resname && r->GetNum() == rnum) 
     {
       // got a match, let's go to work
       ...
     }
   }
  \endcode
  **/

  OBResidueIter::OBResidueIter(OBMol *mol)
    {
        _parent = mol;
        _ptr = _parent->BeginResidue(_i);
    }

  OBResidueIter::OBResidueIter(OBMol &mol)
    {
        _parent = &mol;
        _ptr = _parent->BeginResidue(_i);
    }

  OBResidueIter::OBResidueIter(const OBResidueIter &ri)
    {
        _parent = ri._parent;
        _ptr = ri._ptr;
        _i = ri._i;
    }

  OBResidueIter& OBResidueIter::operator=(const OBResidueIter &ri)
    {
        if (this != &ri)
        {
            _parent = ri._parent;
            _ptr = ri._ptr;
            _i = ri._i;
        }
        return *this;
    }

  OBResidueIter OBResidueIter::operator++(int)
    {
        _ptr = _parent->NextResidue(_i);
        return *this;
    }

  /** \class OBResidueAtomIter

  To facilitate iteration through all atoms in a residue, without resorting
  to atom indexes (which may change in the future) or the OBResidue::BeginAtom()
  and OBResidue::NextAtom() methods which may only be safely used by one method
  at once (e.g., if a method above your code or underneath your code uses these
  methods, errors will occur).

  Therefore, it is <strong>highly recommended</strong> to use the separate
  STL-style iterator classes.

  This has been made significantly easier by a series of macros in the 
  obiter.h header file:

  \code
    \#define FOR_ATOMS_OF_RESIDUE(a,r)     for( OBResidueAtomIter     a(r); a; a++ )
  \endcode

  Here is an example:
  \code
   #include "obiter.hpp"
   #include "mol.hpp"

   OBMol mol;
   double residueMass = 0.0;
   FOR_RESIDUES_OF_MOL(r, mol)
   {
     if (r->GetName() == resname && r->GetNum() == rnum) 
     {
        FOR_ATOMS_OF_RESIDUE(a, r)
         {
           residueMass += a->GetMass();
         }
     }
   }
  \endcode
  **/

  OBResidueAtomIter::OBResidueAtomIter(OBResidue *res)
    {
        _parent = res;
        _ptr    = _parent->BeginAtom(_i);
    }

  OBResidueAtomIter::OBResidueAtomIter(OBResidue &res)
    {
        _parent = &res;
        _ptr    = _parent->BeginAtom(_i);
    }

  OBResidueAtomIter::OBResidueAtomIter(const OBResidueAtomIter &ri)
    {
        _parent = ri._parent;
        _ptr    = ri._ptr;
        _i      = ri._i;
    }

  OBResidueAtomIter & OBResidueAtomIter::operator = (const OBResidueAtomIter &ri)
    {
        if (this != &ri)
        {
            _parent = ri._parent;
            _ptr    = ri._ptr;
            _i      = ri._i;
        }

        return (*this);
    }

  OBResidueAtomIter OBResidueAtomIter::operator++ (int)
    {
        _ptr = _parent->NextAtom(_i);
        return (*this);
    }

} // namespace OpenBabel

//! \file obiter.cpp
//! \brief STL-style iterators for Open Babel.
Revision:	2440
Committed:	Wed Nov 16 19:42:11 2005 UTC (18 years, 8 months ago) by tim
File size:	11020 byte(s)
Log Message:	adding openbabel
#	User	Rev	Content
1	tim	2440	/**********************************************************************
2			obiter.cpp - 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			#include <vector>
21
22			#include "mol.hpp"
23			#include "obiter.hpp"
24
25			using namespace std;
26
27			namespace OpenBabel
28			{
29
30			/** \class OBMolAtomIter
31
32			To facilitate iteration through all atoms in a molecule, without resorting
33			to atom indexes (which may change in the future) or the OBMol::BeginAtom()
34			and OBMol::NextAtom() methods which may only be safely used by one method
35			at once (e.g., if a method above your code or underneath your code uses these
36			methods, errors will occur).
37
38			Therefore, it is <strong>highly recommended</strong> to use the separate
39			STL-style iterator classes.
40
41			This has been made significantly easier by a series of macros in the
42			obiter.h header file:
43
44			\code
45			\#define FOR_ATOMS_OF_MOL(a,m) for( OBMolAtomIter a(m); a; a++ )
46			\endcode
47
48			Here is an example:
49			\code
50			#include "obiter.hpp"
51			#include "mol.hpp"
52
53			OBMol mol;
54			double exactMass = 0.0f;
55			FOR_ATOMS_OF_MOL(a, mol)
56			{
57			exactMass += a->GetExactMass();
58			}
59			\endcode
60			**/
61
62			OBMolAtomIter::OBMolAtomIter(OBMol *mol)
63			{
64			_parent = mol;
65			_ptr = _parent->BeginAtom(_i);
66			}
67
68			OBMolAtomIter::OBMolAtomIter(OBMol &mol)
69			{
70			_parent = &mol;
71			_ptr = _parent->BeginAtom(_i);
72			}
73
74			OBMolAtomIter::OBMolAtomIter(const OBMolAtomIter &ai)
75			{
76			_parent = ai._parent;
77			_ptr = ai._ptr;
78			_i = ai._i;
79			}
80
81			OBMolAtomIter& OBMolAtomIter::operator=(const OBMolAtomIter &ai)
82			{
83			if (this != &ai)
84			{
85			_parent = ai._parent;
86			_ptr = ai._ptr;
87			_i = ai._i;
88			}
89			return *this;
90			}
91
92			OBMolAtomIter OBMolAtomIter::operator++(int)
93			{
94			_ptr = _parent->NextAtom(_i);
95			return *this;
96			}
97
98
99			/** \class OBMolBondIter
100
101			To facilitate iteration through all bonds in a molecule, without resorting
102			to bond indexes (which may change in the future) or the OBMol::BeginBond()
103			and OBMol::NextBond() methods which may only be safely used by one method
104			at once (e.g., if a method above your code or underneath your code uses these
105			methods, errors will occur).
106
107			Therefore, it is <strong>highly recommended</strong> to use the separate
108			STL-style iterator classes.
109
110			This has been made significantly easier by a series of macros in the
111			obiter.h header file:
112
113			\code
114			\#define FOR_BONDS_OF_MOL(b,m) for( OBMolBondIter b(m); b; b++ )
115			\endcode
116
117			Here is an example:
118			\code
119			#include "obiter.hpp"
120			#include "mol.hpp"
121
122			OBMol mol;
123			unsigned int bondOrderSum = 0;
124			FOR_BONDS_OF_MOL(b, mol)
125			{
126			bondOrderSum += b->GetBO();
127			}
128			\endcode
129			**/
130
131			OBMolBondIter::OBMolBondIter(OBMol *mol)
132			{
133			_parent = mol;
134			_ptr = _parent->BeginBond(_i);
135			}
136
137			OBMolBondIter::OBMolBondIter(OBMol &mol)
138			{
139			_parent = &mol;
140			_ptr = _parent->BeginBond(_i);
141			}
142
143			OBMolBondIter::OBMolBondIter(const OBMolBondIter &bi)
144			{
145			_parent = bi._parent;
146			_ptr = bi._ptr;
147			_i = bi._i;
148			}
149
150			OBMolBondIter& OBMolBondIter::operator=(const OBMolBondIter &bi)
151			{
152			if (this != &bi)
153			{
154			_parent = bi._parent;
155			_ptr = bi._ptr;
156			_i = bi._i;
157			}
158			return *this;
159			}
160
161			OBMolBondIter OBMolBondIter::operator++(int)
162			{
163			_ptr = _parent->NextBond(_i);
164			return *this;
165			}
166
167			/** \class OBAtomAtomIter
168
169			To facilitate iteration through all neighbors of an atom, without resorting
170			to bond indexes (which may change in the future) or the OBAtom::BeginNbr()
171			and OBAtom::NextNbr() methods which may only be safely used by one method
172			at once (e.g., if a method above your code or underneath your code uses these
173			methods, errors will occur).
174
175			Therefore, it is <strong>highly recommended</strong> to use the separate
176			STL-style iterator classes.
177
178			This has been made significantly easier by a series of macros in the
179			obiter.h header file:
180
181			\code
182			\#define FOR_NBORS_OF_ATOM(a,p) for( OBAtomAtomIter a(p); a; a++ )
183			\endcode
184
185			Here is an example:
186			\code
187			#include "obiter.hpp"
188			#include "mol.hpp"
189
190			OBMol mol;
191			FOR_ATOMS_OF_MOL(a, mol)
192			{
193			FOR_NBORS_OF_ATOM(b, a)
194			{
195			...
196			}
197			}
198			\endcode
199			**/
200
201			OBAtomAtomIter::OBAtomAtomIter(OBAtom *atm)
202			{
203			_parent = atm;
204			_ptr = _parent->BeginNbrAtom(_i);
205			}
206
207			OBAtomAtomIter::OBAtomAtomIter(OBAtom &atm)
208			{
209			_parent = &atm;
210			_ptr = _ptr->BeginNbrAtom(_i);
211			}
212
213			OBAtomAtomIter::OBAtomAtomIter(const OBAtomAtomIter &ai)
214			{
215			_parent = ai._parent;
216			_ptr = ai._ptr;
217			_i = ai._i;
218			}
219
220			OBAtomAtomIter& OBAtomAtomIter::operator=(const OBAtomAtomIter &ai)
221			{
222			if (this != &ai)
223			{
224			_parent = ai._parent;
225			_ptr = ai._ptr;
226			_i = ai._i;
227			}
228			return *this;
229			}
230
231			OBAtomAtomIter OBAtomAtomIter::operator++(int)
232			{
233			_ptr = _parent->NextNbrAtom(_i);
234			return *this;
235			}
236
237			/** \class OBAtomBondIter
238
239			To facilitate iteration through all bonds on an atom, without resorting
240			to bond indexes (which may change in the future) or the OBAtom::BeginBond()
241			and OBAtom::NextBond() methods which may only be safely used by one method
242			at once (e.g., if a method above your code or underneath your code uses these
243			methods, errors will occur).
244
245			Therefore, it is <strong>highly recommended</strong> to use the separate
246			STL-style iterator classes.
247
248			This has been made significantly easier by a series of macros in the
249			obiter.h header file:
250
251			\code
252			\#define FOR_BONDS_OF_ATOM(b,p) for( OBAtomBondIter b(p); b; b++ )
253			\endcode
254
255			Here is an example:
256			\code
257			#include "obiter.hpp"
258			#include "mol.hpp"
259
260			OBAtom atom;
261			unsigned int tripleBondCount;
262			FOR_BONDS_OF_ATOM(b, atom)
263			{
264			if (b->GetBO() == 3)
265			tripleBondCount++;
266			}
267			\endcode
268			**/
269
270			OBAtomBondIter::OBAtomBondIter(OBAtom *atm)
271			{
272			_parent = atm;
273			_ptr = _parent->BeginBond(_i);
274			}
275
276			OBAtomBondIter::OBAtomBondIter(OBAtom &atm)
277			{
278			_parent = &atm;
279			_ptr = _parent->BeginBond(_i);
280			}
281
282			OBAtomBondIter::OBAtomBondIter(const OBAtomBondIter &bi)
283			{
284			_parent = bi._parent;
285			_ptr = bi._ptr;
286			_i = bi._i;
287			}
288
289			OBAtomBondIter& OBAtomBondIter::operator=(const OBAtomBondIter &bi)
290			{
291			if (this != &bi)
292			{
293			_parent = bi._parent;
294			_ptr = bi._ptr;
295			_i = bi._i;
296			}
297			return *this;
298			}
299
300			OBAtomBondIter OBAtomBondIter::operator++(int)
301			{
302			_ptr = _parent->NextBond(_i);
303			return *this;
304			}
305
306			/** \class OBResidueIter
307
308			To facilitate iteration through all residues in a molecule, without resorting
309			to residue indexes (which may change in the future) or the OBMol::BeginResidue()
310			and OBMol::NextResidue() methods which may only be safely used by one method
311			at once (e.g., if a method above your code or underneath your code uses these
312			methods, errors will occur).
313
314			Therefore, it is <strong>highly recommended</strong> to use the separate
315			STL-style iterator classes.
316
317			This has been made significantly easier by a series of macros in the
318			obiter.h header file:
319
320			\code
321			\#define FOR_RESIDUES_OF_MOL(a,m) for( OBResidueIter a(m); a; a++ )
322			\endcode
323
324			Here is an example:
325			\code
326			#include "obiter.hpp"
327			#include "mol.hpp"
328
329			OBMol mol;
330			FOR_RESIDUES_OF_MOL(r, mol)
331			{
332			if (r->GetName() == resname && r->GetNum() == rnum)
333			{
334			// got a match, let's go to work
335			...
336			}
337			}
338			\endcode
339			**/
340
341			OBResidueIter::OBResidueIter(OBMol *mol)
342			{
343			_parent = mol;
344			_ptr = _parent->BeginResidue(_i);
345			}
346
347			OBResidueIter::OBResidueIter(OBMol &mol)
348			{
349			_parent = &mol;
350			_ptr = _parent->BeginResidue(_i);
351			}
352
353			OBResidueIter::OBResidueIter(const OBResidueIter &ri)
354			{
355			_parent = ri._parent;
356			_ptr = ri._ptr;
357			_i = ri._i;
358			}
359
360			OBResidueIter& OBResidueIter::operator=(const OBResidueIter &ri)
361			{
362			if (this != &ri)
363			{
364			_parent = ri._parent;
365			_ptr = ri._ptr;
366			_i = ri._i;
367			}
368			return *this;
369			}
370
371			OBResidueIter OBResidueIter::operator++(int)
372			{
373			_ptr = _parent->NextResidue(_i);
374			return *this;
375			}
376
377			/** \class OBResidueAtomIter
378
379			To facilitate iteration through all atoms in a residue, without resorting
380			to atom indexes (which may change in the future) or the OBResidue::BeginAtom()
381			and OBResidue::NextAtom() methods which may only be safely used by one method
382			at once (e.g., if a method above your code or underneath your code uses these
383			methods, errors will occur).
384
385			Therefore, it is <strong>highly recommended</strong> to use the separate
386			STL-style iterator classes.
387
388			This has been made significantly easier by a series of macros in the
389			obiter.h header file:
390
391			\code
392			\#define FOR_ATOMS_OF_RESIDUE(a,r) for( OBResidueAtomIter a(r); a; a++ )
393			\endcode
394
395			Here is an example:
396			\code
397			#include "obiter.hpp"
398			#include "mol.hpp"
399
400			OBMol mol;
401			double residueMass = 0.0;
402			FOR_RESIDUES_OF_MOL(r, mol)
403			{
404			if (r->GetName() == resname && r->GetNum() == rnum)
405			{
406			FOR_ATOMS_OF_RESIDUE(a, r)
407			{
408			residueMass += a->GetMass();
409			}
410			}
411			}
412			\endcode
413			**/
414
415			OBResidueAtomIter::OBResidueAtomIter(OBResidue *res)
416			{
417			_parent = res;
418			_ptr = _parent->BeginAtom(_i);
419			}
420
421			OBResidueAtomIter::OBResidueAtomIter(OBResidue &res)
422			{
423			_parent = &res;
424			_ptr = _parent->BeginAtom(_i);
425			}
426
427			OBResidueAtomIter::OBResidueAtomIter(const OBResidueAtomIter &ri)
428			{
429			_parent = ri._parent;
430			_ptr = ri._ptr;
431			_i = ri._i;
432			}
433
434			OBResidueAtomIter & OBResidueAtomIter::operator = (const OBResidueAtomIter &ri)
435			{
436			if (this != &ri)
437			{
438			_parent = ri._parent;
439			_ptr = ri._ptr;
440			_i = ri._i;
441			}
442
443			return (*this);
444			}
445
446			OBResidueAtomIter OBResidueAtomIter::operator++ (int)
447			{
448			_ptr = _parent->NextAtom(_i);
449			return (*this);
450			}
451
452			} // namespace OpenBabel
453
454			//! \file obiter.cpp
455			//! \brief STL-style iterators for Open Babel.