Changeset 8ffe32 for molecuilder/src/molecule.hpp

Timestamp:

Oct 6, 2009, 5:57:01 PM (16 years ago)

Author:

Frederik Heber <heber@…>

Children:

567b7f

Parents:

a4644b

Message:

More functions of molecule now use templated iterators.

• the following template functions are defined in molecule.hpp and implemented in molecule_template.hpp
  • ActOnAllVectors() - Vector of current atom is object to member function pointer
  • ActOnAllAtoms() - current atom is object to member function pointer
  • ActWithEachAtom() - current atom is parameter to molecule member function not object
  • ActOnCopyWithEachAtom() - Same as ActWithEachAtom() but object is not this but an extra pointer to a copy
  • ActOnCopyWithEachAtomIfTrue() - Same as ActWithEachAtom() but with additional condition (bool member function of atom) that has to be true
  • SetIndexedArrayForEachAtomTo() - current atom's index or its element's Z acts as index to a given array in conjunction with a setor function
• the following functions were converted in molecule: molecule::CopyMolecule(), molecule::CopyMoleculeFromSubRegion(), molecule::Output(), molecule::OutputTrajectories(), molecule::OutputXYZ()
• atom.cpp: new functions IsInParallelepiped(), overloaded Output()
• helper.cpp: new template functions Increment() and AbsolutValue acting as wrapper to operator+=() and operator=()

File:

• molecuilder/src/molecule.hpp (modified) (2 diffs)

molecuilder/src/molecule.hpp

@@ -134 +134 @@
   // templates for allowing global manipulation of all vectors
   template <typename res> void ActOnAllVectors( res (Vector::*f)() );
+  template <typename res> void ActOnAllVectors( res (Vector::*f)() const);
+  template <typename res> void ActOnAllVectors( res (Vector::*f)() ) const;
   template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T), T t );
+  template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T) const, T t );
+  template <typename res, typename T> void ActOnAllVectors( res (Vector::*f)(T), T t ) const;
   template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U), T t, U u );
+  template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u );
+  template <typename res, typename T, typename U> void ActOnAllVectors( res (Vector::*f)(T, U), T t, U u ) const;
   template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v);
+  template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v);
+  template <typename res, typename T, typename U, typename V> void ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v) const;
+
+  // templates for allowing global manipulation of molecule with each atom as single argument
+  template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) );
+  template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) const);
+  template <typename res> void ActWithEachAtom( res (molecule::*f)(atom *) ) const;
+
+  // templates for allowing global copying of molecule with each atom as single argument
+  template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy);
+  template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const , molecule *copy);
+  template <typename res> void ActOnCopyWithEachAtom( res (molecule::*f)(atom *) , molecule *copy) const;
 
   // templates for allowing global manipulation of all atoms
-  template <typename res> void ActOnAllAtoms( res (molecule::*f)(atom *) );
   template <typename res> void ActOnAllAtoms( res (atom::*f)() );
+  template <typename res> void ActOnAllAtoms( res (atom::*f)() const );
+  template <typename res> void ActOnAllAtoms( res (atom::*f)() ) const;
   template <typename res, typename T> void ActOnAllAtoms( res (atom::*f)(T), T t );
+  template <typename res, typename T> void ActOnAllAtoms( res (atom::*f)(T) const, T t );
+  template <typename res, typename T> void ActOnAllAtoms( res (atom::*f)(T) const, T t ) const;
   template <typename res, typename T, typename U> void ActOnAllAtoms( res (atom::*f)(T, U), T t, U u );
+  template <typename res, typename T, typename U> void ActOnAllAtoms( res (atom::*f)(T, U) const, T t, U u );
+  template <typename res, typename T, typename U> void ActOnAllAtoms( res (atom::*f)(T, U), T t, U u ) const;
   template <typename res, typename T, typename U, typename V> void ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v);
+  template <typename res, typename T, typename U, typename V> void ActOnAllAtoms( res (atom::*f)(T, U, V) const, T t, U u, V v);
+  template <typename res, typename T, typename U, typename V> void ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v) const;
+  template <typename res, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (atom::*f)(T, U, V, W), T t, U u, V v, W w);
+  template <typename res, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (atom::*f)(T, U, V, W) const, T t, U u, V v, W w);
+  template <typename res, typename T, typename U, typename V, typename W> void ActOnAllAtoms( res (atom::*f)(T, U, V, W), T t, U u, V v, W w) const;
+
+  // templates for allowing conditional global copying of molecule with each atom as single argument
+  template <typename res> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) () );
+  template <typename res, typename T> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T), T t );
+  template <typename res, typename T, typename U> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U), T t, U u );
+  template <typename res, typename T, typename U, typename V> void ActOnCopyWithEachAtomIfTrue( res (molecule::*f)(atom *) , molecule *copy, bool (atom::*condition) (T, U, V), T t, U u, V v );
+
+  // templates for allowing global manipulation of an array with one entry per atom
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int atom::* index, void (*Setor)(T *, T));
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int atom::* index, void (*Setor)(T *, T), T);
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T));
+  template <typename T> void SetIndexedArrayForEachAtomTo ( T *array, int element::*index, void (*Setor)(T *, T), T);
 
   /// remove atoms from molecule.
@@ -262 +302 @@
 };
 
-
-template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() ) {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)();
-  }
-};
-template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t )
-{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)(t);
-  }
-};
-template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u )
-{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)(t, u);
-  }
-};
-template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v)
-{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    ((Walker->node)->*f)(t, u, v);
-  }
-};
-
-template <typename res> void molecule::ActOnAllAtoms( res (molecule::*f)(atom *)) {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (*f)(Walker);
-  }
-};
-
-template <typename res> void molecule::ActOnAllAtoms( res (atom::*f)()) {
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)();
-  }
-};
-template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T), T t )
-{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t);
-  }
-};
-template <typename res, typename T, typename U> void molecule::ActOnAllAtoms( res (atom::*f)(T, U), T t, U u )
-{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u);
-  }
-};
-template <typename res, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v)
-{
-  atom *Walker = start;
-  while (Walker->next != end) {
-    Walker = Walker->next;
-    (Walker->*f)(t, u, v);
-  }
-};
+#include "molecule_template.hpp"
 
 /** A list of \a molecule classes.