Changes in / [e6fdbe:a1510d]

Files:

• doc/Doxyfile (modified) (1 diff)
• src/Actions/ActionRegistry.cpp (modified) (1 diff)
• src/Actions/AtomsCalculation.hpp (added)
• src/Actions/AtomsCalculation_impl.hpp (added)
• src/Actions/Calculation.hpp (added)
• src/Actions/Calculation_impl.hpp (added)
• src/Actions/MakroAction.cpp (modified) (1 diff)
• src/Actions/ManipulateAtomsProcess.cpp (added)
• src/Actions/ManipulateAtomsProcess.hpp (added)
• src/Actions/Process.cpp (modified) (4 diffs)
• src/Actions/Process.hpp (modified) (1 diff)
• src/Descriptors/AtomDescriptor.cpp (modified) (8 diffs)
• src/Descriptors/AtomDescriptor.hpp (modified) (2 diffs)
• src/Descriptors/AtomDescriptor_impl.hpp (modified) (7 diffs)
• src/Descriptors/AtomIdDescriptor.cpp (modified) (2 diffs)
• src/Descriptors/AtomIdDescriptor.hpp (modified) (1 diff)
• src/Descriptors/AtomIdDescriptor_impl.hpp (modified) (2 diffs)
• src/Descriptors/AtomTypeDescriptor.cpp (added)
• src/Descriptors/AtomTypeDescriptor.hpp (added)
• src/Descriptors/AtomTypeDescriptor_impl.hpp (added)
• src/Legacy/oldmenu.cpp (modified) (11 diffs)
• src/Makefile.am (modified) (3 diffs)
• src/Menu/DisplayMenuItem.cpp (modified) (1 diff)
• src/Menu/TextMenu.cpp (modified) (1 diff)
• src/Patterns/Cacheable.hpp (modified) (1 diff)
• src/Patterns/Observer.cpp (modified) (4 diffs)
• src/UIElements/Dialog.cpp (modified) (2 diffs)
• src/UIElements/TextDialog.cpp (modified) (1 diff)
• src/UIElements/TextStatusIndicator.cpp (modified) (1 diff)
• src/Views/MethodStringView.cpp (modified) (1 diff)
• src/Views/MethodStringView.hpp (modified) (1 diff)
• src/Views/StreamStringView.cpp (modified) (1 diff)
• src/Views/StreamStringView.hpp (modified) (2 diffs)
• src/Views/StringView.hpp (modified) (2 diffs)
• src/World.cpp (modified) (9 diffs)
• src/World.hpp (modified) (3 diffs)
• src/WorldIterators.cpp (added)
• src/World_calculations.hpp (added)
• src/atom.cpp (modified) (5 diffs)
• src/atom.hpp (modified) (4 diffs)
• src/atom_atominfo.cpp (modified) (2 diffs)
• src/atom_atominfo.hpp (modified) (1 diff)
• src/atom_particleinfo.cpp (modified) (2 diffs)
• src/atom_particleinfo.hpp (modified) (1 diff)
• src/boundary.cpp (modified) (4 diffs)
• src/builder.cpp (modified) (7 diffs)
• src/config.cpp (modified) (8 diffs)
• src/datacreator.cpp (modified) (2 diffs)
• src/defs.hpp (modified) (1 diff)
• src/lists.cpp (added)
• src/lists.hpp (modified) (11 diffs)
• src/molecule.cpp (modified) (10 diffs)
• src/molecule.hpp (modified) (7 diffs)
• src/molecule_dynamics.cpp (modified) (4 diffs)
• src/molecule_fragmentation.cpp (modified) (3 diffs)
• src/moleculelist.cpp (modified) (13 diffs)
• src/tesselationhelpers.cpp (modified) (1 diff)
• src/unittests/AnalysisCorrelationToPointUnitTest.cpp (modified) (4 diffs)
• src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp (modified) (5 diffs)
• src/unittests/AnalysisPairCorrelationUnitTest.cpp (modified) (4 diffs)
• src/unittests/DescriptorUnittest.cpp (modified) (8 diffs)
• src/unittests/DescriptorUnittest.hpp (modified) (1 diff)
• src/unittests/Makefile.am (modified) (3 diffs)
• src/unittests/analysisbondsunittest.cpp (modified) (3 diffs)
• src/unittests/atomsCalculationTest.cpp (added)
• src/unittests/atomsCalculationTest.hpp (added)
• src/unittests/bondgraphunittest.cpp (modified) (3 diffs)
• src/unittests/listofbondsunittest.cpp (modified) (4 diffs)
• src/unittests/manipulateAtomsTest.cpp (added)
• src/unittests/manipulateAtomsTest.hpp (added)

doc/Doxyfile

@@ -114 +114 @@
 EXCLUDE                = 
 EXCLUDE_SYMLINKS       = NO
-EXCLUDE_PATTERNS       = 
+EXCLUDE_PATTERNS       = */unittests/* \
+                                                 */test/*
 EXAMPLE_PATH           = 
 EXAMPLE_PATTERNS       = *

src/Actions/ActionRegistry.cpp

@@ -24 +24 @@
 {
   map<const string,Action*>::iterator iter;
-  for(iter=actionMap.begin();iter!=actionMap.end();iter++) {
+  for(iter=actionMap.begin();iter!=actionMap.end();++iter) {
     delete iter->second;
-    actionMap.erase(iter);
   }
+  actionMap.clear();
 }
 

src/Actions/MakroAction.cpp

@@ -23 +23 @@
 {
   Action* action;
-  while(action=actions->removeLastAction()){
+  while((action=actions->removeLastAction())){
     delete action;
   }

src/Actions/Process.cpp

@@ -13 +13 @@
   Action(_name,_doRegister),
   maxSteps(_maxSteps),
+  active(false),
   starts(false),
-  stops(false),
-  active(false)
+  stops(false)
 {}
 
@@ -38 +38 @@
 
 int Process::getCurrStep(){
+  OBSERVE;
   return currStep;
+}
+
+void Process::setCurrStep(int _currStep){
+  currStep = _currStep;
 }
 
@@ -47 +52 @@
     return 0;
 }
+
 int Process::getMaxSteps(){
   return maxSteps;
 }
 
+void Process::setMaxSteps(int _maxSteps){
+  maxSteps = _maxSteps;
+}
 
 void Process::start(){
@@ -69 +78 @@
   starts = false;
 }
+
 void Process::step(){
   OBSERVE;
   currStep++;
 }
+
 void Process::stop(){
   stops = true;

src/Actions/Process.hpp

@@ -29 +29 @@
   bool  doesStop();
   int   getCurrStep();
+  void  setCurrStep(int _currStep);
   float getDoneRatio();
   int   getMaxSteps();
+  void  setMaxSteps(int _maxSteps);
 
 protected:

src/Descriptors/AtomDescriptor.cpp

@@ -19 +19 @@
 using namespace std;
 
-typedef map<int,atom*> atoms_t;
-typedef atoms_t::iterator atoms_iter_t;
+typedef World::AtomSet::iterator atoms_iter_t;
 
 /************************ Forwarding object **************************************/
@@ -68 +67 @@
 }
 
-atoms_t& AtomDescriptor_impl::getAtoms(){
+World::AtomSet& AtomDescriptor_impl::getAtoms(){
   return World::get()->atoms;
 }
 
 atom* AtomDescriptor_impl::find() {
-  atoms_t atoms = getAtoms();
+  World::AtomSet atoms = getAtoms();
   atoms_iter_t res = find_if(atoms.begin(),atoms.end(),boost::bind(&AtomDescriptor_impl::predicate,this,_1));
   return (res!=atoms.end())?((*res).second):0;
@@ -80 +79 @@
 vector<atom*> AtomDescriptor_impl::findAll() {
   vector<atom*> res;
-  atoms_t atoms = getAtoms();
+  World::AtomSet atoms = getAtoms();
   atoms_iter_t iter;
   for(iter=atoms.begin();iter!=atoms.end();++iter) {
@@ -98 +97 @@
 {}
 
-bool AtomAllDescriptor_impl::predicate(std::pair<int,atom*>){
+bool AtomAllDescriptor_impl::predicate(std::pair<atomId_t,atom*>){
   return true;
 }
@@ -112 +111 @@
 {}
 
-bool AtomNoneDescriptor_impl::predicate(std::pair<int,atom*>){
+bool AtomNoneDescriptor_impl::predicate(std::pair<atomId_t,atom*>){
   return false;
 }
@@ -130 +129 @@
 {}
 
-bool AtomAndDescriptor_impl::predicate(std::pair<int,atom*> atom){
+bool AtomAndDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
   return lhs->predicate(atom) && rhs->predicate(atom);
 }
@@ -146 +145 @@
 }
 
-bool AtomOrDescriptor_impl::predicate(std::pair<int,atom*> atom){
+bool AtomOrDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
   return lhs->predicate(atom) || rhs->predicate(atom);
 }
@@ -166 +165 @@
 }
 
-bool AtomNotDescriptor_impl::predicate(std::pair<int,atom*> atom){
+bool AtomNotDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom){
  return !(arg->predicate(atom));
 }

src/Descriptors/AtomDescriptor.hpp

@@ -15 +15 @@
 #include "World.hpp"
 
+class World;
 class atom;
 
@@ -21 +22 @@
 
 class AtomDescriptor {
+  // close coupling to the world to allow access
   friend atom* World::getAtom(AtomDescriptor descriptor);
   friend std::vector<atom*> World::getAllAtoms(AtomDescriptor descriptor);
+  friend class World::AtomIterator;
 
   friend AtomDescriptor operator&&(const AtomDescriptor &lhs, const AtomDescriptor &rhs);

src/Descriptors/AtomDescriptor_impl.hpp

@@ +1 @@
+#ifndef ATOMDESCRIPTOR_IMPL_HPP
+#define ATOMDESCRIPTOR_IMPL_HPP
+
 #include "Descriptors/AtomDescriptor.hpp"
 
@@ -11 +14 @@
   virtual ~AtomDescriptor_impl();
 
-  virtual bool predicate(std::pair<int,atom*>)=0;
+  virtual bool predicate(std::pair<atomId_t,atom*>)=0;
 
 protected:
   virtual atom* find();
   virtual std::vector<atom*> findAll();
-  std::map<int,atom*>& getAtoms();
+  World::AtomSet& getAtoms();
 };
 
@@ -25 +28 @@
   AtomAllDescriptor_impl();
   virtual ~AtomAllDescriptor_impl();
-  virtual bool predicate(std::pair<int,atom*>);
+  virtual bool predicate(std::pair<atomId_t,atom*>);
 };
 
@@ -32 +35 @@
   AtomNoneDescriptor_impl();
   virtual ~AtomNoneDescriptor_impl();
-  virtual bool predicate(std::pair<int,atom*>);
+  virtual bool predicate(std::pair<atomId_t,atom*>);
 };
 
@@ -42 +45 @@
   AtomAndDescriptor_impl(AtomDescriptor::impl_ptr _lhs, AtomDescriptor::impl_ptr _rhs);
   ~AtomAndDescriptor_impl();
-  virtual bool predicate(std::pair<int,atom*>);
+  virtual bool predicate(std::pair<atomId_t,atom*>);
 
 private:
@@ -54 +57 @@
   AtomOrDescriptor_impl(AtomDescriptor::impl_ptr _lhs, AtomDescriptor::impl_ptr _rhs);
   virtual ~AtomOrDescriptor_impl();
-  virtual bool predicate(std::pair<int,atom*>);
+  virtual bool predicate(std::pair<atomId_t,atom*>);
 
 private:
@@ -67 +70 @@
   virtual ~AtomNotDescriptor_impl();
 
-  virtual bool predicate(std::pair<int,atom*>);
+  virtual bool predicate(std::pair<atomId_t,atom*>);
 
 private:
   AtomDescriptor::impl_ptr arg;
 };
+
+#endif //ATOMDESCRIPTOR_IMPL_HPP

src/Descriptors/AtomIdDescriptor.cpp

@@ -14 +14 @@
 
 
-AtomIdDescriptor_impl::AtomIdDescriptor_impl(int _id) :
+AtomIdDescriptor_impl::AtomIdDescriptor_impl(atomId_t _id) :
   id(_id)
 {}
@@ -21 +21 @@
 {}
 
-bool AtomIdDescriptor_impl::predicate(std::pair<int,atom*> atom) {
-  return atom.second->getId()==id;
+bool AtomIdDescriptor_impl::predicate(std::pair<atomId_t,atom*> atom) {
+  return atom.first==id;
 }
 
-AtomDescriptor AtomById(int id){
+AtomDescriptor AtomById(atomId_t id){
   return AtomDescriptor(AtomDescriptor::impl_ptr(new AtomIdDescriptor_impl(id)));
 }
 
-#if 0
-
-// so far the lookuptable for Atoms-by-id does not work, since atoms don't get an ID upon creation.
-// instead of this we rely on walking through all atoms.
-
-atom *AtomIdDescriptor::find(){
-  map<int,atom*> atoms = getAtoms();
-  map<int,atom*>::iterator res = atoms.find(id);
+atom *AtomIdDescriptor_impl::find(){
+  World::AtomSet atoms = getAtoms();
+  World::AtomSet::iterator res = atoms.find(id);
   return (res!=atoms.end())?((*res).second):0;
 }
 
-vector<atom*> AtomIdDescriptor::findAll(){
+vector<atom*> AtomIdDescriptor_impl::findAll(){
   atom *res = find();
   return (res)?(vector<atom*>(1,res)):(vector<atom*>());
 }
-
-#endif

src/Descriptors/AtomIdDescriptor.hpp

@@ -9 +9 @@
 #define ATOMIDDESCRIPTOR_HPP_
 
+#include "defs.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
 
-AtomDescriptor AtomById(int id);
+AtomDescriptor AtomById(atomId_t id);
 
 #endif /* ATOMIDDESCRIPTOR_HPP_ */

src/Descriptors/AtomIdDescriptor_impl.hpp

@@ -1 @@
-#include "Descriptors/AtomIdDescriptor.hpp"
+#ifndef ATOMIDDESCRIPTOR_IMPL_HPP
+#define ATOMIDDESCRIPTOR_IMPL_HPP
+
 #include "Descriptors/AtomDescriptor_impl.hpp"
 
@@ -5 +7 @@
 {
 public:
-  AtomIdDescriptor_impl(int _id);
+  AtomIdDescriptor_impl(atomId_t _id);
   virtual ~AtomIdDescriptor_impl();
 
-  bool predicate(std::pair<int,atom*> atom);
+  bool predicate(std::pair<atomId_t,atom*> atom);
 
 protected:
-#if 0
-  atom *find();
-  std::vector<atom*> findAll();
-#endif
+  virtual atom *find();
+  virtual std::vector<atom*> findAll();
 private:
-  int id;
+  atomId_t id;
 };
+
+#endif //ATOMIDDESCRIPTOR_IMPL_HPP

src/Legacy/oldmenu.cpp

@@ -9 +9 @@
 #include "Legacy/oldmenu.hpp"
 #include "analysis_correlation.hpp"
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -77 +78 @@
       case 'a': // absolute coordinates of atom
         Log() << Verbose(0) << "Enter absolute coordinates." << endl;
-        first = new atom;
+        first = World::get()->createAtom();
         first->x.AskPosition(mol->cell_size, false);
         first->type = periode->AskElement();  // give type
@@ -84 +85 @@
 
       case 'b': // relative coordinates of atom wrt to reference point
-        first = new atom;
+        first = World::get()->createAtom();
         valid = true;
         do {
@@ -100 +101 @@
 
       case 'c': // relative coordinates of atom wrt to already placed atom
-        first = new atom;
+        first = World::get()->createAtom();
         valid = true;
         do {
@@ -116 +117 @@
 
     case 'd': // two atoms, two angles and a distance
-        first = new atom;
+        first = World::get()->createAtom();
         valid = true;
         do {
@@ -216 +217 @@
 
       case 'e': // least square distance position to a set of atoms
-        first = new atom;
+        first = World::get()->createAtom();
         atoms = new (Vector*[128]);
         valid = true;
@@ -238 +239 @@
           mol->AddAtom(first);  // add to molecule
         } else {
-          delete first;
+          World::get()->destroyAtom(first);
           Log() << Verbose(0) << "Please enter at least two vectors!\n";
         }
@@ -736 +737 @@
         Log() << Verbose(0) << "New element by atomic number Z: ";
         cin >> Z;
-        first->type = periode->FindElement(Z);
+        first->setType(Z);
         Log() << Verbose(0) << "Atom " << first->nr << "'s element is " << first->type->name << "." << endl;
       }
@@ -781 +782 @@
         x.AddVector(&y); // per factor one cell width further
         for (int k=count;k--;) { // go through every atom of the original cell
-          first = new atom(); // create a new body
+          first = World::get()->createAtom(); // create a new body
           first->x.CopyVector(vectors[k]);  // use coordinate of original atom
           first->x.AddVector(&x);     // translate the coordinates
@@ -811 +812 @@
 void oldmenu::ManipulateMolecules(periodentafel *periode, MoleculeListClass *molecules, config *configuration)
 {
-  atom *first = NULL;
   Vector x,y,z,n; // coordinates for absolute point in cell volume
-  int j, axis, count, faktor;
   char choice;  // menu choice char
   molecule *mol = NULL;
-  element **Elements;
-  Vector **vectors;
   MoleculeLeafClass *Subgraphs = NULL;
 
@@ -1092 +1089 @@
     A++;
   }
-  delete(mol);
+  World::get()->destroyMolecule(mol);
 };
 

src/Makefile.am

@@ -8 +8 @@
 ANALYSISHEADER = analysis_bonds.hpp analysis_correlation.hpp
 
-ACTIONSSOURCE = Actions/Action.cpp Actions/Process.cpp Actions/MethodAction.cpp Actions/ActionSequence.cpp Actions/MakroAction.cpp Actions/ErrorAction.cpp Actions/small_actions.cpp Actions/ActionRegistry.cpp 
-ACTIONSHEADER = Actions/Action.hpp Actions/Process.hpp Actions/MethodAction.hpp Actions/ActionSequence.hpp Actions/MakroAction.hpp Actions/ErrorAction.hpp Actions/small_actions.hpp Actions/ActionRegistry.hpp
+ACTIONSSOURCE = Actions/Action.cpp Actions/Process.cpp Actions/MethodAction.cpp Actions/ActionSequence.cpp Actions/MakroAction.cpp Actions/ErrorAction.cpp Actions/small_actions.cpp Actions/ManipulateAtomsProcess.cpp Actions/ActionRegistry.cpp 
+ACTIONSHEADER = Actions/Action.hpp Actions/Process.hpp Actions/Calculation.hpp Actions/Calculation_impl.hpp Actions/MethodAction.hpp Actions/ActionSequence.hpp Actions/MakroAction.hpp Actions/ErrorAction.hpp Actions/small_actions.hpp Actions/ManipulateAtomsProcess.hpp Actions/ActionRegistry.hpp
 
 PATTERNSOURCE = Patterns/Observer.cpp
@@ -29 +29 @@
 LEGACYHEADER = Legacy/oldmenu.hpp
 
-DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp Descriptors/AtomIdDescriptor.cpp
-DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp Descriptors/AtomIdDescriptor.hpp
+DESCRIPTORSOURCE = Descriptors/AtomDescriptor.cpp Descriptors/AtomIdDescriptor.cpp Descriptors/AtomTypeDescriptor.cpp
+DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp Descriptors/AtomIdDescriptor.hpp Descriptors/AtomTypeDescriptor.hpp
 
-SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE} ${UISOURCE} ${DESCRIPTORSOURCE} ${LEGACYSOURCE} bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.cpp info.cpp leastsquaremin.cpp linkedcell.cpp log.cpp logger.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp World.cpp 
+SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE} ${UISOURCE} ${DESCRIPTORSOURCE} ${LEGACYSOURCE} bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.cpp info.cpp leastsquaremin.cpp linkedcell.cpp lists.cpp log.cpp logger.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp World.cpp WorldIterators.cpp
 HEADER = ${ANALYSISHEADER} ${ATOMHEADER} ${PATTERNHEADER} ${UIHEADER} ${DESCRIPTORHEADER} ${LEGACYHEADER} bond.hpp bondgraph.hpp boundary.hpp config.hpp defs.hpp element.hpp ellipsoid.hpp errorlogger.hpp graph.hpp helpers.hpp info.hpp leastsquaremin.hpp linkedcell.hpp lists.hpp log.hpp logger.hpp memoryallocator.hpp memoryusageobserver.hpp molecule.hpp molecule_template.hpp parser.hpp periodentafel.hpp stackclass.hpp tesselation.hpp tesselationhelpers.hpp vector.hpp verbose.hpp World.hpp 
 
@@ -41 +41 @@
 bin_PROGRAMS = molecuilder joiner analyzer
 molecuilderdir = ${bindir}
-#libmolecuilder_a_CXXFLAGS = -DNO_CACHING
 libmolecuilder_a_SOURCES = ${SOURCE} ${HEADER}
 libgslwrapper_a_SOURCES = ${LINALGSOURCE} ${LINALGHEADER}
 molecuilder_DATA = elements.db valence.db orbitals.db Hbonddistance.db Hbondangle.db
 molecuilder_LDFLAGS = $(BOOST_LDFLAGS)
-molecuilder_CXXFLAGS = $(BOOST_CPPFLAGS)
-#molecuilder_CXXFLAGS += -DNO_CACHING
 molecuilder_SOURCES = builder.cpp
 molecuilder_LDADD = libmolecuilder.a libgslwrapper.a $(BOOST_LIB) ${BOOST_THREAD_LIB}

src/Menu/DisplayMenuItem.cpp

@@ -21 +21 @@
 
 DisplayMenuItem::DisplayMenuItem(Menu* _menu, StringView *_view, string _title, char _spacer, int _length ):
-MenuItem('\0',"",_menu),
-view(_view),
-title(_title),
-spacer(_spacer),
-length(_length)
+  MenuItem('\0',"",_menu),
+  view(_view),
+  title(_title),
+  length(_length),
+  spacer(_spacer)
 {
 }
 
 DisplayMenuItem::~DisplayMenuItem()
-{
-  // TODO Auto-generated destructor stub
-}
+{}
 
 

src/Menu/TextMenu.cpp

@@ -18 +18 @@
  */
 TextMenu::TextMenu(ostream& _outputter, string _title, char _spacer,int _length) :
-outputter(_outputter),
-title(_title),
-spacer(_spacer),
-length(_length),
-quit(false),
-defaultItem(0)
+  defaultItem(0),
+  outputter(_outputter),
+  title(_title),
+  spacer(_spacer),
+  length(_length),
+  quit(false)
 {
 }

src/Patterns/Cacheable.hpp

@@ -43 +43 @@
   Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
     owner(_owner),
-    recalcMethod(_recalcMethod),
     valid(false),
-    canBeUsed(true)
+    canBeUsed(true),
+    recalcMethod(_recalcMethod)
   {
     // we sign on with the best(=lowest) priority, so cached values are recalculated before

src/Patterns/Observer.cpp

@@ -108 +108 @@
     callees_t *callees = callTable[this];
     callees_t::iterator iter;
-    for(iter=callees->begin();iter!=callees->end();iter++){
+    for(iter=callees->begin();iter!=callees->end();++iter){
       (*iter).second->update(this);
     }
@@ -160 +160 @@
 
   callees_t::iterator iter;
-  for(iter=callees->begin();iter!=callees->end();iter++){
+  for(iter=callees->begin();iter!=callees->end();++iter){
     res |= ((*iter).second == target);
   }
@@ -177 +177 @@
   callees_t::iterator deliter;
   for(iter=callees->begin();iter!=callees->end();) {
-    deliter=iter++;
-    if((*deliter).second == target)
-      callees->erase(deliter);
+    if((*iter).second == target) {
+      callees->erase(iter++);
+    }
+    else {
+      ++iter;
+    }
   }
   if(callees->empty()){
@@ -208 +211 @@
     callees_t *callees = callTable[this];
     callees_t::iterator iter;
-    for(iter=callees->begin();iter!=callees->end();iter++){
+    for(iter=callees->begin();iter!=callees->end();++iter){
       (*iter).second->subjectKilled(this);
     }

src/UIElements/Dialog.cpp

@@ -102 +102 @@
 Dialog::MoleculeQuery::MoleculeQuery(string title, molecule **_target, MoleculeListClass *_molecules) :
     Query(title),
-    target(_target),
+    tmp(0),
     molecules(_molecules),
-    tmp(0)
+    target(_target)
+
 {}
 
@@ -116 +117 @@
 
 Dialog::VectorQuery::VectorQuery(std::string title,Vector *_target,const double *const _cellSize,bool _check) :
-  Query(title), target(_target), cellSize(_cellSize), check(_check)
+  Query(title),
+  cellSize(_cellSize),
+  check(_check),
+  target(_target)
 {
 tmp = new Vector();

src/UIElements/TextDialog.cpp

@@ -114 +114 @@
 bool TextDialog::VectorTextQuery::handle() {
  tmp->AskPosition(cellSize,check);
+ return true;
 }

src/UIElements/TextStatusIndicator.cpp

@@ -27 +27 @@
   Process *proc;
   // we are only observing Processes
-  if(proc=dynamic_cast<Process*>(subject)){
+  if((proc=dynamic_cast<Process*>(subject))){
     // see what kind of progress we have to display
     if(proc->getMaxSteps()>0){

src/Views/MethodStringView.cpp

@@ -7 +7 @@
 
 #include "MethodStringView.hpp"
+
+using namespace std;
 
 MethodStringView::MethodStringView(boost::function<string()> _displayMethod) :

src/Views/MethodStringView.hpp

@@ -19 +19 @@
 {
 public:
-  MethodStringView(boost::function<string()>);
+  MethodStringView(boost::function<std::string()>);
   virtual ~MethodStringView();
 
-  virtual const string toString();
+  virtual const std::string toString();
 
 private:
-  boost::function<string()> displayMethod;
+  boost::function<std::string()> displayMethod;
 };
 

src/Views/StreamStringView.cpp

@@ -7 +7 @@
 
 #include <sstream>
+#include <iostream>
 
 #include "StreamStringView.hpp"
 
-StreamStringView::StreamStringView(boost::function<void(ofstream *)> _displayMethod) :
+using namespace std;
+
+StreamStringView::StreamStringView(boost::function<void(ostream *)> _displayMethod) :
 StringView(),
 displayMethod(_displayMethod)
-{
-  // TODO Auto-generated constructor stub
-
-}
+{}
 
 StreamStringView::~StreamStringView()
-{
-  // TODO Auto-generated destructor stub
-}
+{}
 
 const string StreamStringView::toString() {
   stringstream s;
-  displayMethod((ofstream *)&s);
+  displayMethod(dynamic_cast<ostream *>(&s));
   return s.str();
 }

src/Views/StreamStringView.hpp

@@ -10 +10 @@
 
 #include <boost/function.hpp>
+#include <iostream>
 
 #include "Views/StringView.hpp"
@@ -24 +25 @@
 {
 public:
-  StreamStringView(boost::function<void(ofstream *)>);
+  StreamStringView(boost::function<void(std::ostream *)>);
   virtual ~StreamStringView();
 
-  virtual const string toString();
+  virtual const std::string toString();
 
 private:
-  boost::function<void(ofstream *)> displayMethod;
+  boost::function<void(std::ostream *)> displayMethod;
 };
 

src/Views/StringView.hpp

@@ -12 +12 @@
 #include "Views/View.hpp"
 
-using namespace std;
-
 /**
  * View to show something as a string
@@ -26 +24 @@
   virtual ~StringView();
 
-  virtual const string toString()=0;
+  virtual const std::string toString()=0;
 };
 

src/World.cpp

@@ -12 +12 @@
 #include "periodentafel.hpp"
 #include "Descriptors/AtomDescriptor.hpp"
+#include "Descriptors/AtomDescriptor_impl.hpp"
+#include "Actions/ManipulateAtomsProcess.hpp"
 
 using namespace std;
@@ -28 +30 @@
 }
 
+vector<atom*> World::getAllAtoms(){
+  return getAllAtoms(AllAtoms());
+}
+
 int World::numAtoms(){
   return atoms.size();
@@ -36 +42 @@
 }
 
+/******************** Methods to change World state *********************/
+
 molecule* World::createMolecule(){
   OBSERVE;
   molecule *mol = NULL;
-  mol = new molecule(periode);
-  molecules_deprecated->insert(mol);
-  molecules.insert(mol);
+  mol = NewMolecule();
+  assert(!molecules.count(currMoleculeId));
+  mol->setId(currMoleculeId++);
+  // store the molecule by ID
+  molecules[mol->getId()] = mol;
   mol->signOn(this);
   return mol;
 }
 
+void World::destroyMolecule(molecule* mol){
+  OBSERVE;
+  destroyMolecule(mol->getId());
+}
+
+void World::destroyMolecule(moleculeId_t id){
+  OBSERVE;
+  molecule *mol = molecules[id];
+  assert(mol);
+  DeleteMolecule(mol);
+  molecules.erase(id);
+}
+
+
+atom *World::createAtom(){
+  OBSERVE;
+  atom *res = NewAtom();
+  assert(!atoms.count(currAtomId));
+  res->setId(currAtomId++);
+  res->setWorld(this);
+  // store the atom by ID
+  atoms[res->getId()] = res;
+  return res;
+}
+
+int World::registerAtom(atom *atom){
+  OBSERVE;
+  assert(!atoms.count(currAtomId));
+  atom->setId(currAtomId++);
+  atom->setWorld(this);
+  atoms[atom->getId()] = atom;
+  return atom->getId();
+}
+
+void World::destroyAtom(atom* atom){
+  OBSERVE;
+  int id = atom->getId();
+  destroyAtom(id);
+}
+
+void World::destroyAtom(atomId_t id) {
+  OBSERVE;
+  atom *atom = atoms[id];
+  assert(atom);
+  DeleteAtom(atom);
+  atoms.erase(id);
+}
+
+ManipulateAtomsProcess* World::manipulateAtoms(boost::function<void(atom*)> op,std::string name,AtomDescriptor descr){
+  return new ManipulateAtomsProcess(op, descr,name,true);
+}
+
+ManipulateAtomsProcess* World::manipulateAtoms(boost::function<void(atom*)> op,std::string name){
+  return manipulateAtoms(op,name,AllAtoms());
+}
+
+/********************* Internal Change methods for double Callback and Observer mechanism ********/
+
+void World::doManipulate(ManipulateAtomsProcess *proc){
+  proc->signOn(this);
+  {
+    OBSERVE;
+    proc->doManipulate(this);
+  }
+  proc->signOff(this);
+}
+
+/******************************* Iterators ********************************/
+
+/*
+ * Actual Implementation of the iterators can be found in WorldIterators.cpp
+ */
+
+World::AtomIterator World::getAtomIter(AtomDescriptor descr){
+  return AtomIterator(descr,this);
+}
+
+World::AtomSet::iterator World::atomEnd(){
+  return atoms.end();
+}
 
 /******************************* Singleton Stuff **************************/
@@ -53 +143 @@
 boost::mutex World::worldLock;
 
-
-
 World::World() :
     periode(new periodentafel),
-    molecules_deprecated(new MoleculeListClass),
-    dummyId(0)
+    atoms(),
+    currAtomId(0),
+    molecules(),
+    currMoleculeId(0),
+    molecules_deprecated(new MoleculeListClass(this))
 {
   molecules_deprecated->signOn(this);
@@ -68 +159 @@
   delete molecules_deprecated;
   delete periode;
+  MoleculeSet::iterator molIter;
+  for(molIter=molecules.begin();molIter!=molecules.end();++molIter){
+    DeleteMolecule((*molIter).second);
+  }
+  molecules.clear();
+  AtomSet::iterator atIter;
+  for(atIter=atoms.begin();atIter!=atoms.end();++atIter){
+    DeleteAtom((*atIter).second);
+  }
+  atoms.clear();
 }
 
@@ -80 +181 @@
 
 void World::destroy(){
-  // For legacy reasons all atoms have to be destroyed first, since unregistering would cause deadlocks otherwise
-  theWorld->destroyLegacy();
-  //WARNING: at this point we have a small race condition, when sombody now tries to access the world.
-
   // boost supports RAII-Style locking, so we don't need to unlock
   boost::mutex::scoped_lock guard(worldLock);
@@ -91 +188 @@
 
 World* World::reset(){
-  // For legacy reasons all atoms have to be destroyed first, since unregistering would cause deadlocks otherwise
-  theWorld->destroyLegacy();
-  //WARNING: at this point we have a small race condition, when sombody now tries to access the world.
-
   World* oldWorld = 0;
   {
@@ -114 +207 @@
   // should see that it gets the updated new world
   delete oldWorld;
+  return theWorld;
 }
 
@@ -121 +215 @@
   return molecules_deprecated;
 }
-
-// some legacy stuff to let the World know about items created outside
-void World::registerAtom(atom *theAtom){
-  OBSERVE;
-  atoms[dummyId++] = theAtom;
-}
-
-void World::destroyLegacy(){
-  //delete molecules_deprecated;
-}
-
-void World::unregisterAtom(atom *theAtom){
-  OBSERVE;
-  atoms.erase(theAtom->getId());
-}

src/World.hpp

@@ -9 +9 @@
 #define WORLD_HPP_
 
-#include <boost/thread.hpp>
+#include <string>
 #include <map>
 #include <vector>
 #include <set>
-
+#include <boost/thread.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include "defs.hpp"
 #include "Patterns/Observer.hpp"
 #include "Patterns/Cacheable.hpp"
@@ -24 +27 @@
 class AtomDescriptor;
 class AtomDescriptor_impl;
+class ManipulateAtomsProcess;
+template<typename T>
+class AtomsCalculation;
 
 class World : public Observable
 {
+// necessary for coupling with descriptors
 friend class AtomDescriptor_impl;
+friend class AtomDescriptor;
+
+// Actions, calculations etc associated with the World
+friend class ManipulateAtomsProcess;
+template<typename> friend class AtomsCalculation;
 public:
+  typedef std::map<atomId_t,atom*> AtomSet;
+  typedef std::map<moleculeId_t,molecule*> MoleculeSet;
 
   /***** getter and setter *****/
   // reference to pointer is used for legacy reason... reference will be removed latter to keep encapsulation of World object
+  /**
+   * returns the periodentafel for the world.
+   */
   periodentafel *&getPeriode();
+
+  /**
+   * returns the first atom that matches a given descriptor.
+   * Do not rely on ordering for descriptors that match more than one atom.
+   */
   atom* getAtom(AtomDescriptor descriptor);
+
+  /**
+   * returns a vector containing all atoms that match a given descriptor
+   */
   std::vector<atom*> getAllAtoms(AtomDescriptor descriptor);
+  std::vector<atom*> getAllAtoms();
+
+  /**
+   * returns a calculation that calls a given function on all atoms matching a descriptor.
+   * the calculation is not called at this point and can be used as an action, i.e. be stored in
+   * menus, be kept around for later use etc.
+   */
+  template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,std::string,AtomDescriptor);
+  template<typename T> AtomsCalculation<T>* calcOnAtoms(boost::function<T(atom*)>,std::string);
+
+  /**
+   * get the number of atoms in the World
+   */
   int numAtoms();
+
+  /**
+   * get the number of molecules in the World
+   */
   int numMolecules();
 
   /***** Methods to work with the World *****/
+
+  /**
+   * create a new molecule. This method should be used whenever any kind of molecule is needed. Assigns a unique
+   * ID to the molecule and stores it in the World for later retrieval. Do not create molecules directly.
+   */
   molecule *createMolecule();
+
+  void destroyMolecule(molecule*);
+  void destroyMolecule(moleculeId_t);
+
+  /**
+   * Create a new atom. This method should be used whenever any atom is needed. Assigns a unique ID and stores
+   * the atom in the World. If the atom is not destroyed it will automatically be destroyed when the world ends.
+   */
+  atom *createAtom();
+
+  /**
+   * Registers a Atom unknown to world. Needed in some rare cases, e.g. when cloning atoms, or in some unittests.
+   * Do not re-register Atoms already known to the world since this will cause double-frees.
+   */
+  int registerAtom(atom*);
+
+  /**
+     * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
+     * atom directly since this will leave the pointer inside the world.
+   */
+  void destroyAtom(atom*);
+
+  /**
+   * Delete some atom and erase it from the world. Use this whenever you need to destroy any atom. Do not call delete on
+   * atom directly since this will leave the pointer inside the world.
+   */
+  void destroyAtom(atomId_t);
+
+  /**
+   * Produces a process that calls a function on all Atoms matching a given descriptor. The process is not
+   * called at this time, so it can be passed around, stored inside menuItems etc.
+   */
+  ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string,AtomDescriptor);
+  ManipulateAtomsProcess* manipulateAtoms(boost::function<void(atom*)>,std::string);
+
+protected:
+  /**** Iterators to use internal data structures */
+  class AtomIterator {
+  public:
+    AtomIterator();
+    AtomIterator(AtomDescriptor, World*);
+    AtomIterator(const AtomIterator&);
+    AtomIterator& operator=(const AtomIterator&);
+    AtomIterator& operator++();     // prefix
+    AtomIterator  operator++(int);  // postfix with dummy parameter
+    bool operator==(const AtomIterator&);
+    bool operator==(const AtomSet::iterator&);
+    bool operator!=(const AtomIterator&);
+    bool operator!=(const AtomSet::iterator&);
+    atom* operator*();
+
+    int getCount();
+  protected:
+    void advanceState();
+    AtomSet::iterator state;
+    boost::shared_ptr<AtomDescriptor_impl>  descr;
+    int index;
+
+    World* world;
+  };
+
+  /**
+   * returns an iterator over all Atoms matching a given descriptor.
+   * used for internal purposes, like AtomProcesses and AtomCalculations.
+   */
+  AtomIterator getAtomIter(AtomDescriptor descr);
+
+  /**
+   * returns an iterator to the end of the AtomSet. Due to overloading this iterator
+   * can be compared to iterators produced by getAtomIter (see the mis-matching types).
+   * Thus it can be used to detect when such an iterator is at the end of the list.
+   * used for internal purposes, like AtomProcesses and AtomCalculations.
+   */
+  AtomSet::iterator atomEnd();
+
+  /******* Internal manipulation routines for double callback and Observer mechanism ******/
+  void doManipulate(ManipulateAtomsProcess *);
+
 private:
   periodentafel *periode;
-  std::map<int,atom*> atoms;
-  std::set<molecule*> molecules;
+  AtomSet atoms;
+  atomId_t currAtomId; //!< stores the next available Id for atoms
+  MoleculeSet molecules;
+  moleculeId_t currMoleculeId;
 
 
   /***** singleton Stuff *****/
 public:
+
+  /**
+   * get the currently active instance of the World.
+   */
   static World* get();
+
+  /**
+   * destroy the currently active instance of the World.
+   */
   static void destroy();
+
+  /**
+   * destroy the currently active instance of the World and immidiately
+   * create a new one. Use this to reset while somebody is still Observing
+   * the world and should reset the observed instance. All observers will be
+   * sent the subjectKille() message from the old world.
+   */
   static World* reset();
 
 private:
+  /**
+   * private constructor to ensure creation of the world using
+   * the singleton pattern.
+   */
   World();
+
+  /**
+   * private destructor to ensure destruction of the world using the
+   * singleton pattern.
+   */
   virtual ~World();
 
@@ -68 +220 @@
   MoleculeListClass *&getMolecules();
 
-  // functions used for the WorldContent template mechanism
-  void registerAtom(atom *theAtom);
-  void unregisterAtom(atom *theAtom);
 private:
-  // this function cleans up anything that cannot be cleaned while the lock is active
-  // at a later point all these cleanups have to be moved to the World Class so the deadlock and
-  // race condition can both be avoided.
-  void destroyLegacy();
-
   MoleculeListClass *molecules_deprecated;
-
-  // this is needed to assign unique IDs to atoms... so far
-  // IDs are not assigned upon Atom creation, so we cannot query the ID
-  // during construction. By using the dummy ID we can make sure all atoms
-  // are actually stored in the map and don't overwrite each other.
-  int dummyId;
 };
 

src/atom.cpp

@@ -20 +20 @@
 /** Constructor of class atom.
  */
-atom::atom() : previous(NULL), next(NULL), father(this), sort(&nr)
-{
-  World::get()->registerAtom(this);
+atom::atom() :
+  previous(NULL), next(NULL), father(this), sort(&nr)
+{
   node = &x;  // TesselPoint::x can only be referenced from here
 };
@@ -28 +28 @@
 /** Constructor of class atom.
  */
-atom::atom(atom *pointer) : previous(NULL), next(NULL), father(pointer), sort(&nr)
-{
-  World::get()->registerAtom(this);
+atom::atom(atom *pointer) :
+    ParticleInfo(pointer),
+    previous(NULL), next(NULL), father(pointer), sort(&nr)
+{
   type = pointer->type;  // copy element of atom
   x.CopyVector(&pointer->x); // copy coordination
@@ -38 +39 @@
 };
 
+atom *atom::clone(){
+  atom *res = new atom();
+  res->previous=0;
+  res->next=0;
+  res->father = this;
+  res->sort = &nr;
+  res->type = type;
+  res->x.CopyVector(&this->x);
+  res->v.CopyVector(&this->v);
+  res->FixedIon = FixedIon;
+  res->node = &x;
+  World::get()->registerAtom(res);
+  return res;
+}
+
 
 /** Destructor of class atom.
@@ -43 +59 @@
 atom::~atom()
 {
-  World::get()->unregisterAtom(this);
   unlink(this);
 };
@@ -267 +282 @@
 };
 
+World *atom::getWorld(){
+  return world;
+}
+
+void atom::setWorld(World* _world){
+  world = _world;
+}
+
+void atom::setId(int _id) {
+  id=_id;
+}
+
+int atom::getId() {
+  return id;
+}
+
+atom* NewAtom(){
+  return new atom();
+}
+
+void  DeleteAtom(atom* atom){
+  delete atom;
+}

src/atom.hpp

@@ -32 +32 @@
 
 class Vector;
+class World;
 
 /********************************************** declarations *******************************/
@@ -39 +40 @@
  */
 class atom : public TesselPoint, public TrajectoryParticle, public GraphNode, public BondedParticle, public virtual ParticleInfo, public virtual AtomInfo {
+  friend atom* NewAtom();
+  friend void  DeleteAtom(atom*);
   public:
     atom *previous; //!< previous atom in molecule list
@@ -45 +48 @@
     int *sort;      //!< sort criteria
 
-  atom();
-  atom(class atom *pointer);
-  virtual ~atom();
+  virtual atom *clone();
 
   bool OutputIndexed(ofstream * const out, const int ElementNo, const int AtomNo, const char *comment = NULL) const;
@@ -67 +68 @@
   bool IsInParallelepiped(const Vector offset, const double *parallelepiped) const;
 
+  // getter and setter
+
+  /**
+   * returns the World that contains this atom.
+   * Use this if you need to get the world without locking
+   * the singleton for example.
+   *
+   */
+  World *getWorld();
+  void setWorld(World*);
+
+  virtual int getId();
+  virtual void setId(int);
+  protected:
+    /**
+     * Protected constructor to ensure construction of atoms through the world.
+     * see World::createAtom()
+     */
+    atom();
+
+    /**
+     * Protected copy-constructor to ensure construction of atoms by cloning.
+     * see atom::clone()
+     */
+    atom(class atom *pointer);
+
+    /**
+     * Protected destructor to ensure destruction of atoms through the world.
+     * see World::destroyAtom()
+     */
+    virtual ~atom();
   private:
+    World* world;
+    int id;
 };
 
+/**
+ * internal method used by the world. Do not use if you don't know what you are doing.
+ * You might get burned...
+ * Use World::createAtom() instead.
+ */
+atom* NewAtom();
+
+/**
+* internal method used by the world. Do not use if you don't know what you are doing.
+ * You might get burned...
+ * Use World::destroyAtom() instead.
+ */
+void  DeleteAtom(atom*);
+
+
 #endif /* ATOM_HPP_ */

src/atom_atominfo.cpp

@@ -6 +6 @@
  */
 
+#include "periodentafel.hpp"
+#include "World.hpp"
 #include "atom_atominfo.hpp"
 
@@ -18 +20 @@
 };
 
+element *AtomInfo::getType(){
+  return type;
+}
+
+void AtomInfo::setType(element* _type) {
+  type = _type;
+}
+
+void AtomInfo::setType(int Z) {
+  element *elem = World::get()->getPeriode()->FindElement(Z);
+  setType(elem);
+}

src/atom_atominfo.hpp

@@ -37 +37 @@
   ~AtomInfo();
 
+  element *getType();
+  void setType(element *);
+  void setType(int);
+
 private:
 };

src/atom_particleinfo.cpp

@@ -13 +13 @@
 ParticleInfo::ParticleInfo() : nr(-1), Name(NULL) {};
 
+ParticleInfo::ParticleInfo(ParticleInfo *pointer) :
+    nr(pointer->nr),
+    Name(pointer->Name)
+    {}
+
+
 /** Destructor of ParticleInfo.
  */
@@ -19 +25 @@
   Free(&Name);
 };
-
-int ParticleInfo::getId() {
-  return nr;
-}
 
 ostream & operator << (ostream &ost, const ParticleInfo &a)

src/atom_particleinfo.hpp

@@ -31 +31 @@
 
   ParticleInfo();
+  ParticleInfo(ParticleInfo*);
   ~ParticleInfo();
 
   ostream & operator << (ostream &ost) const;
-
-  virtual int getId();
 
 private:

src/boundary.cpp

@@ -4 +4 @@
  */
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -800 +801 @@
 {
         Info FunctionInfo(__func__);
-  molecule *Filling = new molecule(filler->elemente);
+  molecule *Filling = World::get()->createMolecule();
   Vector CurrentPosition;
   int N[NDIM];
@@ -887 +888 @@
             Walker = Walker->next;
             // copy atom ...
-            CopyAtoms[Walker->nr] = new atom(Walker);
+            CopyAtoms[Walker->nr] = Walker->clone();
 
             // create atomic random translation vector ...
@@ -964 +965 @@
   bool freeLC = false;
   bool status = false;
-  CandidateForTesselation *baseline = NULL;
+  CandidateForTesselation *baseline=0;
   LineMap::iterator testline;
   bool OneLoopWithoutSuccessFlag = true;  // marks whether we went once through all baselines without finding any without two triangles

src/builder.cpp

@@ -1432 +1432 @@
      }
      if (mol == NULL) {
-       mol = new molecule(periode);
+       mol = World::get()->createMolecule();
        mol->ActiveFlag = true;
        if (ConfigFileName != NULL)
@@ -1481 +1481 @@
                 SaveFlag = true;
                 Log() << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
-                first = new atom;
+                first = World::get()->createAtom();
                 first->type = periode->FindElement(atoi(argv[argptr]));
                 if (first->type != NULL)
@@ -1634 +1634 @@
                 Log() << Verbose(1) << "Filling Box with water molecules." << endl;
                 // construct water molecule
-                molecule *filler = new molecule(periode);
+                molecule *filler = World::get()->createMolecule();
                 molecule *Filling = NULL;
                 atom *second = NULL, *third = NULL;
@@ -1641 +1641 @@
 //                first->x.Zero();
 //                filler->AddAtom(first);
-                first = new atom();
+                first = World::get()->createAtom();
                 first->type = periode->FindElement(1);
                 first->x.Init(0.441, -0.143, 0.);
                 filler->AddAtom(first);
-                second = new atom();
+                second = World::get()->createAtom();
                 second->type = periode->FindElement(1);
                 second->x.Init(-0.464, 1.137, 0.0);
                 filler->AddAtom(second);
-                third = new atom();
+                third = World::get()->createAtom();
                 third->type = periode->FindElement(8);
                 third->x.Init(-0.464, 0.177, 0.);
@@ -1664 +1664 @@
                   molecules->insert(Filling);
                 }
-                delete(filler);
+                World::get()->destroyMolecule(filler);
                 argptr+=6;
               }
@@ -2097 +2097 @@
                       x.AddVector(&y); // per factor one cell width further
                       for (int k=count;k--;) { // go through every atom of the original cell
-                        first = new atom(); // create a new body
+                        first = World::get()->createAtom(); // create a new body
                         first->x.CopyVector(vectors[k]);  // use coordinate of original atom
                         first->x.AddVector(&x);      // translate the coordinates
@@ -2204 +2204 @@
     if(World::get()->numMolecules() == 0){
         mol = World::get()->createMolecule();
+        World::get()->getMolecules()->insert(mol);
+        cout << "Molecule created" << endl;
         if(mol->cell_size[0] == 0.){
             Log() << Verbose(0) << "enter lower tridiagonal form of basis matrix" << endl << endl;

src/config.cpp

@@ -8 +8 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -732 +733 @@
             sprintf(keyword,"%s_%i",name, j+1);
             if (repetition == 0) {
-              neues = new atom();
+              neues = World::get()->createAtom();
               AtomList[i][j] = neues;
               LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
@@ -811 +812 @@
           sprintf(keyword,"%s_%i",name, j+1);
           if (repetition == 0) {
-            neues = new atom();
+            neues = World::get()->createAtom();
             AtomList[i][j] = neues;
             LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
@@ -850 +851 @@
 void config::Load(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
 {
-  molecule *mol = new molecule(periode);
+  molecule *mol = World::get()->createMolecule();
   ifstream *file = new ifstream(filename);
   if (file == NULL) {
@@ -1088 +1089 @@
 void config::LoadOld(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
 {
-  molecule *mol = new molecule(periode);
+  molecule *mol = World::get()->createMolecule();
   ifstream *file = new ifstream(filename);
   if (file == NULL) {
@@ -1287 +1288 @@
         }
         istringstream input2(zeile);
-        atom *neues = new atom();
+        atom *neues = World::get()->createAtom();
         input2 >> neues->x.x[0]; // x
         input2 >> neues->x.x[1]; // y
@@ -1787 +1788 @@
   char filename[MAXSTRINGSIZE];
   ofstream output;
-  molecule *mol = new molecule(periode);
+  molecule *mol = World::get()->createMolecule();
   mol->SetNameFromFilename(ConfigFileName);
 
@@ -1898 +1899 @@
   }
 
-  delete(mol);
+  World::get()->destroyMolecule(mol);
 };
 

src/datacreator.cpp

@@ -771 +771 @@
 {
   stringstream line(Force.Header[Force.MatrixCounter]);
-  char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
+  const char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;
 
@@ -803 +803 @@
 {
   stringstream line(Force.Header[Force.MatrixCounter]);
-  char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
+  const char *fillcolor[5] = {"black", "red", "blue", "green", "cyan"};
   string token;
 

src/defs.hpp

@@ -32 +32 @@
 
 enum Shading { white, lightgray, darkgray, black };  //!< color in Breadth-First-Search analysis
+
+// some types that can stay abstract
+typedef unsigned int moleculeId_t;
+typedef unsigned int atomId_t;
 
 //enum CutCyclicBond { KeepBond,  SaturateBond }; //!< Saturation scheme either atom- or bondwise 

src/lists.hpp

@@ -9 +9 @@
 #define LISTS_HPP_
 
+class atom;
+
 /******************************** Some templates for list management ***********************************/
 
@@ -18 +20 @@
 {
   X *vorher = end->previous;
-  if (vorher != NULL)
+  if (vorher != 0)
     vorher->next = walker;
   end->previous = walker;
@@ -31 +33 @@
 template <typename X> void unlink(X *walker)
 {
-  if (walker->next != NULL)
+  if (walker->next != 0)
     walker->next->previous = walker->previous;
-  if (walker->previous != NULL)
+  if (walker->previous != 0)
     walker->previous->next = walker->next;
-  walker->next = NULL;
-  walker->previous= NULL;
+  walker->next = 0;
+  walker->previous= 0;
 };
 
@@ -46 +48 @@
 template <typename X>  bool add(X *pointer, X *end)
 {
-  if (end != NULL) {
+  if (end != 0) {
     link(pointer, end);
   } else {
-    pointer->previous = NULL;
-    pointer->next = NULL;
+    pointer->previous = 0;
+    pointer->next = 0;
   }
   return true;
@@ -59 +61 @@
  * \param *start  begin of list
  * \param *end  end of list
- * \return X - if found, NULL - if not found
+ * \return X - if found, 0 - if not found
  */
 template <typename X, typename Y> X * find(Y *suche, X *start, X *end)
@@ -68 +70 @@
     if (*walker->sort == *suche) return (walker);
   }
-  return NULL;
+  return 0;
 };
 
@@ -77 +79 @@
 template <typename X> void removewithoutcheck(X *walker)
 {
-  if (walker != NULL) {
+  if (walker != 0) {
     unlink(walker);
     delete(walker);
-    walker = NULL;
+    walker = 0;
   }
 };
+
+/** Removes an item from the list without check.
+ *  specialized for atoms, because these have to be removed from the world as well
+ *  the implementation for this declaration is in lists.cpp
+ * \param *walker item to be removed
+ * \return true - removing succeeded, false - given item not found in list
+ */
+template <> void removewithoutcheck<atom>(atom *walker);
 
 /** Removes an item from the list, checks if exists.
@@ -99 +109 @@
   }*/
   // atom found, now unlink
-  if (walker != NULL)
+  if (walker != 0)
     removewithoutcheck(walker);
   else
@@ -114 +124 @@
 {
   X *pointer = start->next;
-  X *walker = NULL;
+  X *walker = 0;
   while (pointer != end) { // go through list
     walker = pointer; // mark current
@@ -131 +141 @@
 {
   X *Binder = me;
-  while(Binder->previous != NULL)
+  while(Binder->previous != 0)
     Binder = Binder->previous;
   return Binder;
@@ -143 +153 @@
 {
   X *Binder = me;
-  while(Binder->next != NULL)
+  while(Binder->next != 0)
     Binder = Binder->next;
   return Binder;

src/molecule.cpp

@@ -8 +8 @@
 #include <boost/bind.hpp>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -30 +31 @@
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
  */
-molecule::molecule(const periodentafel * const teil) : elemente(teil), start(new atom), end(new atom), 
+molecule::molecule(const periodentafel * const teil) : elemente(teil), start(World::get()->createAtom()), end(World::get()->createAtom()),
   first(new bond(start, end, 1, -1)), last(new bond(start, end, 1, -1)), MDSteps(0), AtomCount(0), 
   BondCount(0), ElementCount(0), NoNonHydrogen(0), NoNonBonds(0), NoCyclicBonds(0), BondDistance(0.), 
-  ActiveFlag(false), IndexNr(-1), last_atom(0), InternalPointer(start),
-  formula(this,boost::bind(&molecule::calcFormula,this))
+  ActiveFlag(false), IndexNr(-1),
+  formula(this,boost::bind(&molecule::calcFormula,this)),
+  last_atom(0),
+  InternalPointer(start)
 {
   // init atom chain list
@@ -52 +55 @@
 };
 
+molecule *NewMolecule(){
+  return new molecule(World::get()->getPeriode());
+}
+
 /** Destructor of class molecule.
  * Initialises molecule list with correctly referenced start and end, and sets molecule::last_atom to zero.
@@ -60 +67 @@
   delete(first);
   delete(last);
-  delete(end);
-  delete(start);
-};
-
+  end->getWorld()->destroyAtom(end);
+  start->getWorld()->destroyAtom(start);
+};
+
+
+void DeleteMolecule(molecule *mol){
+  delete mol;
+}
 
 // getter and setter
@@ -73 +84 @@
   OBSERVE;
   strncpy(name,_name.c_str(),MAXSTRINGSIZE);
+}
+
+moleculeId_t molecule::getId(){
+  return id;
+}
+
+void molecule::setId(moleculeId_t _id){
+  id =_id;
 }
 
@@ -135 +154 @@
   OBSERVE;
   if (pointer != NULL) {
-    atom *walker = new atom(pointer);
+    atom *walker = pointer->clone();
     walker->Name = Malloc<char>(strlen(pointer->Name) + 1, "atom::atom: *Name");
     strcpy (walker->Name, pointer->Name);
@@ -242 +261 @@
   switch(TopBond->BondDegree) {
     case 1:
-      FirstOtherAtom = new atom();    // new atom
+      FirstOtherAtom = World::get()->createAtom();    // new atom
       FirstOtherAtom->type = elemente->FindElement(1);  // element is Hydrogen
       FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
@@ -299 +318 @@
 
       // create the two Hydrogens ...
-      FirstOtherAtom = new atom();
-      SecondOtherAtom = new atom();
+      FirstOtherAtom = World::get()->createAtom();
+      SecondOtherAtom = World::get()->createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
@@ -354 +373 @@
     case 3:
       // take the "usual" tetraoidal angle and add the three Hydrogen in direction of the bond (height of the tetraoid)
-      FirstOtherAtom = new atom();
-      SecondOtherAtom = new atom();
-      ThirdOtherAtom = new atom();
+      FirstOtherAtom = World::get()->createAtom();
+      SecondOtherAtom = World::get()->createAtom();
+      ThirdOtherAtom = World::get()->createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
@@ -475 +494 @@
     MDSteps++;
   for(i=0;i<NumberOfAtoms;i++){
-    Walker = new atom;
+    Walker = World::get()->createAtom();
     getline(xyzfile,line,'\n');
     istringstream *item = new istringstream(line);

src/molecule.hpp

@@ -29 +29 @@
 #include <string>
 
+#include "defs.hpp"
 #include "graph.hpp"
 #include "stackclass.hpp"
@@ -85 +86 @@
  */
 class molecule : public PointCloud , public Observable {
+  friend molecule *NewMolecule();
+  friend void DeleteMolecule(molecule *);
   public:
     double cell_size[6];//!< cell size
@@ -108 +111 @@
   private:
     Cacheable<string> formula;
+    moleculeId_t id;
+  protected:
+    molecule(const periodentafel * const teil);
+    virtual ~molecule();
+
 
 public:
-  molecule(const periodentafel * const teil);
-  virtual ~molecule();
-
   //getter and setter
   const std::string getName();
+  moleculeId_t getId();
+  void setId(moleculeId_t);
   void setName(const std::string);
   const std::string getFormula();
   std::string calcFormula();
+
 
   // re-definition of virtual functions from PointCloud
@@ -321 +329 @@
 };
 
+molecule *NewMolecule();
+void DeleteMolecule(molecule* mol);
+
 #include "molecule_template.hpp"
 
@@ -330 +341 @@
     int MaxIndex;
 
-  MoleculeListClass();
+  MoleculeListClass(World *world);
   ~MoleculeListClass();
 
@@ -339 +350 @@
   bool OutputConfigForListOfFragments(config *configuration, int *SortIndex);
   int NumberOfActiveMolecules();
-  void Enumerate(ofstream *out);
+  void Enumerate(ostream *out);
   void Output(ofstream *out);
   void DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration);
@@ -363 +374 @@
 
   private:
+  World *world; //!< The world this List belongs to. Needed to avoid deadlocks in the destructor
 };
 

src/molecule_dynamics.cpp

@@ -6 +6 @@
  */
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "config.hpp"
@@ -164 +165 @@
   double tmp = 0.;
   double result = 0.;
-
   // go through every atom
   atom *Runner = NULL;
@@ -486 +486 @@
   bool status = true;
   int MaxSteps = configuration.MaxOuterStep;
-  MoleculeListClass *MoleculePerStep = new MoleculeListClass();
+  MoleculeListClass *MoleculePerStep = new MoleculeListClass(World::get());
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
@@ -506 +506 @@
   Log() << Verbose(1) << "Filling intermediate " << MaxSteps << " steps with MDSteps of " << MDSteps << "." << endl;
   for (int step = 0; step <= MaxSteps; step++) {
-    mol = new molecule(elemente);
+    mol = World::get()->createMolecule();
     MoleculePerStep->insert(mol);
     Walker = start;

src/molecule_fragmentation.cpp

@@ -8 +8 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -675 +676 @@
   //if (FragmentationToDo) {    // we should always store the fragments again as coordination might have changed slightly without changing bond structure
   // allocate memory for the pointer array and transmorph graphs into full molecular fragments
-  BondFragments = new MoleculeListClass();
+  BondFragments = new MoleculeListClass(World::get());
   int k=0;
   for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
@@ -926 +927 @@
 {
   atom **SonList = Calloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
-  molecule *Leaf = new molecule(elemente);
+  molecule *Leaf = World::get()->createMolecule();
 
 //  Log() << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;

src/moleculelist.cpp

@@ -7 +7 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -24 +25 @@
 /** Constructor for MoleculeListClass.
  */
-MoleculeListClass::MoleculeListClass()
+MoleculeListClass::MoleculeListClass(World *_world) :
+  world(_world)
 {
   // empty lists
@@ -38 +40 @@
   for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
     Log() << Verbose(4) << "ListOfMolecules: Freeing " << *ListRunner << "." << endl;
-    delete (*ListRunner);
+    world->destroyMolecule(*ListRunner);
   }
   Log() << Verbose(4) << "Freeing ListOfMolecules." << endl;
@@ -137 +139 @@
  * \param *out output stream
  */
-void MoleculeListClass::Enumerate(ofstream *out)
+void MoleculeListClass::Enumerate(ostream *out)
 {
   element* Elemental = NULL;
@@ -213 +215 @@
   // remove src
   ListOfMolecules.remove(srcmol);
-  delete(srcmol);
+  World::get()->destroyMolecule(srcmol);
   return true;
 };
@@ -342 +344 @@
     Log() << Verbose(2) << "INFO: Current Walker is " << *Walker << "." << endl;
     if (!TesselStruct->IsInnerPoint(Walker->x, LCList)) {
-      CopyAtoms[Walker->nr] = new atom(Walker);
+      CopyAtoms[Walker->nr] = Walker->clone();
       mol->AddAtom(CopyAtoms[Walker->nr]);
       nr++;
@@ -748 +750 @@
 void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
 {
-  molecule *mol = new molecule(periode);
+  molecule *mol = World::get()->createMolecule();
   atom *Walker = NULL;
   atom *Advancer = NULL;
@@ -773 +775 @@
     }
     // remove the molecule
-    delete(*MolRunner);
+    World::get()->destroyMolecule(*MolRunner);
     ListOfMolecules.erase(MolRunner);
   }
@@ -795 +797 @@
   molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
   for (int i=0;i<MolCount;i++) {
-    molecules[i] = (molecule*) new molecule(mol->elemente);
+    molecules[i] = World::get()->createMolecule();
     molecules[i]->ActiveFlag = true;
     strncpy(molecules[i]->name, mol->name, MAXSTRINGSIZE);
@@ -893 +895 @@
   OBSERVE;
   molecule *mol = NULL;
-  mol = new molecule(periode);
+  mol = World::get()->createMolecule();
   insert(mol);
 };
@@ -902 +904 @@
   char filename[MAXSTRINGSIZE];
   Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
-  mol = new molecule(periode);
+  mol = World::get()->createMolecule();
   do {
     Log() << Verbose(0) << "Enter file name: ";
@@ -960 +962 @@
       mol = *ListRunner;
       ListOfMolecules.erase(ListRunner);
-      delete(mol);
+      World::get()->destroyMolecule(mol);
       break;
     }
@@ -1007 +1009 @@
   // remove the leaf itself
   if (Leaf != NULL) {
-    delete (Leaf);
+    World::get()->destroyMolecule(Leaf);
     Leaf = NULL;
   }

src/tesselationhelpers.cpp

@@ -27 +27 @@
   int signum;
   gsl_permutation *p = gsl_permutation_alloc(A->size1);
-  gsl_matrix *tmpA;
+  gsl_matrix *tmpA=0;
 
   if (inPlace)

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

@@ -17 +17 @@
 #include "AnalysisCorrelationToPointUnitTest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
@@ -56 +57 @@
 
   // construct periodentafel
-  tafel = new periodentafel;
+  tafel = World::get()->getPeriode();
   tafel->AddElement(hydrogen);
 
   // construct molecule (tetraeder of hydrogens)
-  TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  TestMolecule = World::get()->createMolecule();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
@@ -81 +82 @@
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
 
-  TestList = new MoleculeListClass;
+  TestList = World::get()->getMolecules();
   TestMolecule->ActiveFlag = true;
   TestList->insert(TestMolecule);
@@ -102 +103 @@
     delete(binmap);
 
-  // remove
-  delete(TestList);
-  // note that all the atoms are cleaned by TestMolecule
   delete(point);
-  delete(tafel);
-  // note that element is cleaned by periodentafel
   World::destroy();
   MemoryUsageObserver::purgeInstance();

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

@@ -17 +17 @@
 #include "AnalysisCorrelationToSurfaceUnitTest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
@@ -60 +61 @@
 
   // construct periodentafel
-  tafel = new periodentafel;
+  tafel = World::get()->getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
 
   // construct molecule (tetraeder of hydrogens) base
-  TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  TestMolecule = World::get()->createMolecule();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
@@ -86 +87 @@
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
 
-  TestList = new MoleculeListClass;
+  TestList = World::get()->getMolecules();
   TestMolecule->ActiveFlag = true;
   TestList->insert(TestMolecule);
@@ -99 +100 @@
 
   // add outer atoms
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 0., 4. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(0., 4., 4. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 4., 0. );
   TestMolecule->AddAtom(Walker);
   // add inner atoms
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );
@@ -131 +132 @@
     delete(binmap);
 
-  // remove
-  delete(TestList);
   delete(Surface);
   // note that all the atoms are cleaned by TestMolecule
   delete(LC);
-  delete(tafel);
-  // note that element is cleaned by periodentafel
   World::destroy();
   MemoryUsageObserver::purgeInstance();

src/unittests/AnalysisPairCorrelationUnitTest.cpp

@@ -17 +17 @@
 #include "AnalysisPairCorrelationUnitTest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "boundary.hpp"
@@ -55 +56 @@
 
   // construct periodentafel
-  tafel = new periodentafel;
+  tafel = World::get()->getPeriode();
   tafel->AddElement(hydrogen);
 
   // construct molecule (tetraeder of hydrogens)
-  TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  TestMolecule = World::get()->createMolecule();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
@@ -80 +81 @@
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
 
-  TestList = new MoleculeListClass;
+  TestList = World::get()->getMolecules();
   TestMolecule->ActiveFlag = true;
   TestList->insert(TestMolecule);
@@ -98 +99 @@
     delete(binmap);
 
-  // remove
-  delete(TestList);
   // note that all the atoms are cleaned by TestMolecule
-  delete(tafel);
-  // note that element is cleaned by periodentafel
   World::destroy();
   MemoryUsageObserver::purgeInstance();

src/unittests/DescriptorUnittest.cpp

@@ -27 +27 @@
 CPPUNIT_TEST_SUITE_REGISTRATION( DescriptorUnittest );
 
-// some stubs
-class AtomStub : public atom {
-public:
-  AtomStub(int _id) :
-  atom(),
-  id(_id)
-  {}
-
-  virtual int getId(){
-    return id;
-  }
-
-private:
-  int id;
-};
-
-
 // set up and tear down
 void DescriptorUnittest::setUp(){
   World::get();
   for(int i=0;i<ATOM_COUNT;++i){
-    atoms[i]= new AtomStub(i);
+    atoms[i]= World::get()->createAtom();
+    atomIds[i] = atoms[i]->getId();
   }
 }
 void DescriptorUnittest::tearDown(){
   World::destroy();
-  for(int i=0;i<ATOM_COUNT;++i){
-    delete atoms[i];
-  }
 }
 
 // some helper functions
-bool hasAll(std::vector<atom*> atoms,int min, int max, std::set<int> excluded = std::set<int>()){
-  for(int i=min;i<max;++i){
-    if(!excluded.count(i)){
+bool hasAll(std::vector<atom*> atoms,int ids[ATOM_COUNT], std::set<int> excluded = std::set<int>()){
+  for(int i=0;i<ATOM_COUNT;++i){
+    int id = ids[i];
+    if(!excluded.count(id)){
       std::vector<atom*>::iterator iter;
       bool res=false;
       for(iter=atoms.begin();iter!=atoms.end();++iter){
-        res |= (*iter)->getId() == i;
+        res |= (*iter)->getId() == id;
       }
       if(!res) {
-        cout << "Atom " << i << " missing in returned list" << endl;
+        cout << "Atom " << id << " missing in returned list" << endl;
         return false;
       }
@@ -91 +73 @@
 void DescriptorUnittest::AtomBaseSetsTest(){
   std::vector<atom*> allAtoms = World::get()->getAllAtoms(AllAtoms());
-  CPPUNIT_ASSERT_EQUAL( true , hasAll(allAtoms,0,ATOM_COUNT));
+  CPPUNIT_ASSERT_EQUAL( true , hasAll(allAtoms,atomIds));
   CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(allAtoms));
 
@@ -100 +82 @@
   // test Atoms from boundaries and middle of the set
   atom* testAtom;
-  testAtom = World::get()->getAtom(AtomById(0));
-  CPPUNIT_ASSERT_EQUAL( 0, testAtom->getId());
-  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT/2));
-  CPPUNIT_ASSERT_EQUAL( ATOM_COUNT/2, testAtom->getId());
-  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT-1));
-  CPPUNIT_ASSERT_EQUAL( ATOM_COUNT-1, testAtom->getId());
+  testAtom = World::get()->getAtom(AtomById(atomIds[0]));
+  CPPUNIT_ASSERT(testAtom);
+  CPPUNIT_ASSERT_EQUAL( atomIds[0], testAtom->getId());
+  testAtom = World::get()->getAtom(AtomById(atomIds[ATOM_COUNT/2]));
+  CPPUNIT_ASSERT(testAtom);
+  CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT/2], testAtom->getId());
+  testAtom = World::get()->getAtom(AtomById(atomIds[ATOM_COUNT-1]));
+  CPPUNIT_ASSERT(testAtom);
+  CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT-1], testAtom->getId());
 
+  // find some ID that has not been created
+  int outsideId =-1;
+  bool res = false;
+  while(!res) {
+    ++outsideId;
+    res = true;
+    for(int i = 0; i < ATOM_COUNT; ++i){
+      res &= atomIds[i]!=outsideId;
+    }
+  }
   // test from outside of set
-  testAtom = World::get()->getAtom(AtomById(ATOM_COUNT));
+  testAtom = World::get()->getAtom(AtomById(outsideId));
   CPPUNIT_ASSERT(!testAtom);
 }
@@ -115 +110 @@
   {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()||NoAtoms());
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
   }
@@ -121 +116 @@
   {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||AllAtoms());
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
   }
@@ -142 +137 @@
   {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(!NoAtoms());
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT));
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
   }
@@ -148 +143 @@
   // exclude and include some atoms
   {
-    std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&(!AtomById(ATOM_COUNT/2)));
+    std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&(!AtomById(atomIds[ATOM_COUNT/2])));
     std::set<int> excluded;
-    excluded.insert(ATOM_COUNT/2);
-    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,0,ATOM_COUNT,excluded));
+    excluded.insert(atomIds[ATOM_COUNT/2]);
+    CPPUNIT_ASSERT_EQUAL( true , hasAll(testAtoms,atomIds,excluded));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicates(testAtoms));
     CPPUNIT_ASSERT_EQUAL( (size_t)(ATOM_COUNT-1), testAtoms.size());
@@ -157 +152 @@
 
   {
-    std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||(AtomById(ATOM_COUNT/2)));
+    std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||(AtomById(atomIds[ATOM_COUNT/2])));
     CPPUNIT_ASSERT_EQUAL( (size_t)1, testAtoms.size());
-    CPPUNIT_ASSERT_EQUAL( ATOM_COUNT/2, testAtoms[0]->getId());
+    CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT/2], testAtoms[0]->getId());
   }
 }

src/unittests/DescriptorUnittest.hpp

@@ -33 +33 @@
 private:
   atom *atoms [ATOM_COUNT];
+  int atomIds [ATOM_COUNT];
 };
 

src/unittests/Makefile.am

@@ -30 +30 @@
   CacheableTest \
   DescriptorUnittest \
-  ${MENUTESTS}  
-    
+  manipulateAtomsTest \
+  atomsCalculationTest \
+  ${MENUTESTS}
+  
+
+      
   
 check_PROGRAMS = $(TESTS) 
@@ -60 +64 @@
   tesselation_insideoutsideunittest.cpp \
   vectorunittest.cpp \
-  ActionSequenceTest.cpp \
   ObserverTest.cpp \
   CacheableTest.cpp \
-  DescriptorUnittest.cpp
+  DescriptorUnittest.cpp \
+  manipulateAtomsTest.cpp \
+  atomsCalculationTest.cpp \
+  ActionSequenceTest.cpp
 
 TESTHEADERS = \
@@ -140 +146 @@
 DescriptorUnittest_LDADD = ${ALLLIBS}
 
+manipulateAtomsTest_SOURCES = UnitTestMain.cpp manipulateAtomsTest.cpp manipulateAtomsTest.hpp
+manipulateAtomsTest_LDADD = ${ALLLIBS}
+
+atomsCalculationTest_SOURCES = UnitTestMain.cpp atomsCalculationTest.cpp atomsCalculationTest.hpp
+atomsCalculationTest_LDADD = ${ALLLIBS}
+
 TestRunner_SOURCES = TestRunnerMain.cpp $(TESTSOURCES) $(TESTHEADERS)
 TestRunner_LDADD = ${ALLLIBS}

src/unittests/analysisbondsunittest.cpp

@@ -16 +16 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "analysis_bonds.hpp"
 #include "analysisbondsunittest.hpp"
@@ -60 +61 @@
 
   // construct periodentafel
-  tafel = new periodentafel;
+  tafel = World::get()->getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
 
   // construct molecule (tetraeder of hydrogens)
-  TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  TestMolecule = World::get()->createMolecule();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 0., 1.5 );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1.5, 1.5 );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 1.5, 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );
@@ -116 +117 @@
 
   // remove molecule
-  delete(TestMolecule);
+  World::get()->destroyMolecule(TestMolecule);
   // note that all the atoms are cleaned by TestMolecule
-  delete(tafel);
-  // note that element is cleaned by periodentafel
+  World::destroy();
 };
 

src/unittests/bondgraphunittest.cpp

@@ -16 +16 @@
 #include <cstring>
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -56 +57 @@
 
   // construct periodentafel
-  tafel = new periodentafel;
+  tafel = World::get()->getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
 
   // construct molecule (tetraeder of hydrogens)
-  TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  TestMolecule = World::get()->createMolecule();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
@@ -101 +102 @@
 
   // remove molecule
-  delete(TestMolecule);
-  // note that all the atoms are cleaned by TestMolecule
-  delete(tafel);
-  // note that element is cleaned by periodentafel
+  World::get()->destroyMolecule(TestMolecule);
+  // note that all the atoms, molecules, the tafel and the elements
+  // are all cleaned when the world is destroyed
   World::destroy();
   MemoryUsageObserver::purgeInstance();

src/unittests/listofbondsunittest.cpp

@@ -16 +16 @@
 #include "listofbondsunittest.hpp"
 
+#include "World.hpp"
 #include "atom.hpp"
 #include "bond.hpp"
@@ -50 +51 @@
 
   // construct periodentafel
-  tafel = new periodentafel;
+  tafel = World::get()->getPeriode();
   tafel->AddElement(hydrogen);
 
   // construct molecule (tetraeder of hydrogens)
-  TestMolecule = new molecule(tafel);
-  Walker = new atom();
+  TestMolecule = World::get()->createMolecule();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
-  Walker = new atom();
+  Walker = World::get()->createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
@@ -81 +82 @@
 {
   // remove
-  delete(TestMolecule);
-  // note that all the atoms are cleaned by TestMolecule
-  delete(tafel);
-  // note that element is cleaned by periodentafel
+  World::get()->destroyMolecule(TestMolecule);
+  // note that all the atoms, molecules, the tafel and the elements
+  // are all cleaned when the world is destroyed
   World::destroy();
   MemoryUsageObserver::purgeInstance();
@@ -250 +250 @@
 
   // remove atom2
-  delete(atom2);
+  World::get()->destroyAtom(atom2);
 
   // check bond if removed from other atom