Changeset 3efb4a for molecuilder/src/molecule_template.hpp

Timestamp:

Oct 9, 2009, 11:57:41 AM (16 years ago)

Author:

Frederik Heber <heber@…>

Children:

e71890

Parents:

17b3a5c

Message:

Implementing templated iterators done for molecule.cpp

• new functions in class atom: atom::DistanceSquaredToVector(), atom::DistanceToVector() and atom::AddKineticToTemperature()
• above used with ActOnAllAtoms() in molecule.cpp: molecule::OutputTemperatureFromTrajectories(), molecule::OutputListOfBonds() (uses atom::OutputBondOfAtom() which gives slightly different output than before but rather with more info)
• new template SetIndexedArrayForEachAtomTo() which sets the contents of an index array according to a member function result.
• above used in molecule::IsEqualToWithinThreshold()

File:

• molecuilder/src/molecule_template.hpp (modified) (13 diffs)

molecuilder/src/molecule_template.hpp

@@ -45 +45 @@
   }
 };
+template <typename res> void molecule::ActOnAllVectors( res (Vector::*f)() const ) const
+    {
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)();
+  }
+};
 // one argument
 template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T), T t )
@@ -70 +78 @@
   }
 };
+template <typename res, typename T> void molecule::ActOnAllVectors( res (Vector::*f)(T) const, T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t);
+  }
+};
 // two arguments
 template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U), T t, U u )
@@ -95 +111 @@
   }
 };
+template <typename res, typename T, typename U> void molecule::ActOnAllVectors( res (Vector::*f)(T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u);
+  }
+};
 // three arguments
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V), T t, U u, V v)
@@ -120 +144 @@
   }
 };
+template <typename res, typename T, typename U, typename V> void molecule::ActOnAllVectors( res (Vector::*f)(T, U, V) const, T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    ((Walker->node)->*f)(t, u, v);
+  }
+};
 
 // ================== Acting with each Atoms on same molecule ========================== //
@@ -148 +180 @@
   }
 };
+template <typename res> void molecule::ActWithEachAtom( res (molecule::*f)(atom *) const) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (*f)(Walker);
+  }
+};
 
 // ================== Acting with each Atoms on copy molecule ========================== //
@@ -176 +216 @@
   }
 };
+template <typename res> void molecule::ActOnCopyWithEachAtom( res (molecule::*f)(atom *) const, molecule *copy) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (copy->*f)(Walker);
+  }
+};
 
 // ================== Acting with each Atoms on copy molecule if true ========================== //
@@ -247 +295 @@
   }
 };
+template <typename res> void molecule::ActOnAllAtoms( res (atom::*f)() const) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)();
+  }
+};
 // one argument
 template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T), T t )
@@ -264 +320 @@
   }
 };
+template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T), T t ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t);
+  }
+};
 template <typename res, typename T> void molecule::ActOnAllAtoms( res (atom::*f)(T) const, T t ) const
 {
@@ -297 +361 @@
   }
 };
+template <typename res, typename T, typename U> void molecule::ActOnAllAtoms( res (atom::*f)(T, U) const, T t, U u ) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u);
+  }
+};
 // three argument
 template <typename res, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V), T t, U u, V v)
@@ -322 +394 @@
   }
 };
+template <typename res, typename T, typename U, typename V> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V) const, T t, U u, V v) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v);
+  }
+};
 // four arguments
 template <typename res, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V, W), T t, U u, V v, W w)
@@ -347 +427 @@
   }
 };
+template <typename res, typename T, typename U, typename V, typename W> void molecule::ActOnAllAtoms( res (atom::*f)(T, U, V, W) const, T t, U u, V v, W w) const
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    (Walker->*f)(t, u, v, w);
+  }
+};
 
 // ===================== Accesssing arrays indexed by some integer for each atom ======================
 
 // for atom ints
-template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int atom::*index, void (*Setor)(T *, T) )
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, void (*Setor)(T *, T) )
 {
   atom *Walker = start;
@@ -359 +447 @@
   }
 };
-template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int atom::*index, void (*Setor)(T *, T), T value )
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, void (*Setor)(T *, T), T value )
 {
   atom *Walker = start;
@@ -384 +472 @@
   }
 };
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, T (atom::*Setor)(Vector &), Vector atom::*value )
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (Walker->*value);
+  }
+};
+template <typename T> void molecule::SetIndexedArrayForEachAtomTo ( T *array, int TesselPoint::*index, T (atom::*Setor)(Vector &), Vector &vect )
+{
+  atom *Walker = start;
+  while (Walker->next != end) {
+    Walker = Walker->next;
+    array[(Walker->*index)] = (Walker->*Setor) (vect);
+  }
+};
 
 #endif /* MOLECULE_TEMPLATE_HPP_ */