Diff [66e95ead2481671ca5327eb6731a586ae0e2d542:b31bc446e44e3bd112547bd6f6c98e4deebd860d] for / – MoleCuilder

src/Actions/Action.cpp

-              r66e95e
+              rb31bc4
 #include "Actions/Action.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionHistory.hpp"
 using namespace std;
+// An empty state to indicate success
+Action::state_ptr Action::success = Action::state_ptr(new ActionState());
+Action::state_ptr Action::failure = Action::state_ptr(new ActionState());
 Action::Action(std::string _name,bool _doRegister) :
 …
+{
   if(_doRegister){
     ActionRegistry::getRegistry()->registerAction(this);
+    ActionRegistry::getInstance().registerAction(this);
+  }
+}
 …
   return name;
+}
+void Action::call(){
+  // forward to private virtual
+  state_ptr state = performCall();
+  if(shouldUndo() && state != failure){
+    if(canUndo()){
+      ActionHistory::getInstance().addElement(this,state);
+    }
+    else{
+      ActionHistory::getInstance().clear();
+    }
+  }
+}
+Action::state_ptr Action::undo(state_ptr _state) {
+  // forward to private virtual
+  return performUndo(_state);
+}
+Action::state_ptr Action::redo(state_ptr _state) {
+  // forward to private virtual
+  return performRedo(_state);
+}

src/Actions/Action.hpp

-              r66e95e
+              rb31bc4
 #include <string>
+#include <boost/shared_ptr.hpp>
+// forward declaration
+class ActionState;
+class ActionSequence;
 /**
 …
 class Action
+{
+protected:
+friend class ActionSequence;
 public:
+  typedef boost::shared_ptr<ActionState> state_ptr;
   Action(std::string _name,bool _doRegister=true);
   virtual ~Action();
+  virtual void call()=0;
+  virtual void undo()=0;
+  // this method only handles the infrastructure
+  // actuall action is passed on to a private virtual
+  void call();
+  state_ptr undo(state_ptr);
+  state_ptr redo(state_ptr);
   virtual bool canUndo()=0;
   //virtual bool shouldUndo()=0;
+  virtual bool shouldUndo()=0;
   virtual const std::string getName();
+protected:
+  static state_ptr success;
+  static state_ptr failure;
 private:
+  virtual state_ptr performCall()=0;
+  virtual state_ptr performUndo(state_ptr)=0;
+  virtual state_ptr performRedo(state_ptr)=0;
   std::string name;
 };
+/**
+ * This class can be used by actions to save the state.
+ *
+ * It is implementing a memento pattern. The base class is completely empty,
+ * since no general state internals can be given. The Action performing
+ * the Undo should downcast to the apropriate type.
+ */
+class ActionState{
+public:
+  ActionState(){}
+  virtual ~ActionState(){}
+};
 #endif /* ACTION_H_ */

src/Actions/ActionRegistry.cpp

-              r66e95e
+              rb31bc4
 #include "Actions/Action.hpp"
+#include "Patterns/Singleton_impl.hpp"
 #include <string>
 #include <cassert>
+#include "Helpers/Assert.hpp"
 #include <iostream>
 using namespace std;
-ActionRegistry *ActionRegistry::theInstance=0;
 ActionRegistry::ActionRegistry()
 …
   map<const string,Action*>::iterator iter;
   iter = actionMap.find(name);
   assert(iter!=actionMap.end() && "Query for an action not stored in registry");
+  ASSERT(iter!=actionMap.end(),"Query for an action not stored in registry");
   return iter->second;
+}
 …
   pair<map<const string,Action*>::iterator,bool> ret;
   ret = actionMap.insert(pair<const string,Action*>(action->getName(),action));
   assert(ret.second && "Two actions with the same name added to registry");
+  ASSERT(ret.second,"Two actions with the same name added to registry");
+}
+// singleton stuff
+ActionRegistry* ActionRegistry::getRegistry(){
+  if(!theInstance){
+    theInstance = new ActionRegistry();
+  }
+  return theInstance;
+}
+void ActionRegistry::purgeRegistry(){
+  if(theInstance){
+    delete theInstance;
+    theInstance = 0;
+  }
+}
+CONSTRUCT_SINGLETON(ActionRegistry)

src/Actions/ActionRegistry.hpp

-              r66e95e
+              rb31bc4
 #include <map>
+#include "Patterns/Singleton.hpp"
 class Action;
 class ActionRegistry
+class ActionRegistry : public Singleton<ActionRegistry>
+{
+  friend class Singleton<ActionRegistry>;
 public:
   Action* getActionByName(const std::string);
 …
   std::map<const std::string,Action*> actionMap;
-// singleton stuff
-public:
-  static ActionRegistry* getRegistry();
-  static void purgeRegistry();
 private:
   ActionRegistry();
   virtual ~ActionRegistry();
-  static ActionRegistry *theInstance;
 };

src/Actions/ActionSequence.cpp

-              r66e95e
+              rb31bc4
 #include "Actions/ActionSequence.hpp"
 #include "Actions/Action.hpp"
+#include "Helpers/Assert.hpp"
 using namespace std;
 …
+}
+void ActionSequence::callAll(){
+  deque<Action*>::iterator it;
+  for(it=actions.begin(); it!=actions.end(); it++)
+    (*it)->call();
+ActionSequence::stateSet ActionSequence::callAll(){
+  stateSet states;
+  for(actionSet::iterator it=actions.begin(); it!=actions.end(); it++){
+    // we want to have a global bookkeeping for all actions in the sequence, so
+    // we bypass the normal call
+    Action::state_ptr state = (*it)->performCall();
+    states.push_back(state);
+  }
+  return states;
+}
+void ActionSequence::undoAll(){
+  deque<Action*>::reverse_iterator rit;
+  for(rit=actions.rbegin(); rit!=actions.rend(); rit++)
+    (*rit)->undo();
+ActionSequence::stateSet ActionSequence::undoAll(stateSet states){
+  ASSERT(canUndo(),"Trying to undo a sequence that contains methods that can't be undone");
+  stateSet res;
+  actionSet::reverse_iterator actionRit = actions.rbegin();
+  stateSet::reverse_iterator stateRit = states.rbegin();
+  for(;actionRit!=actions.rend();++actionRit,++stateRit){
+    ASSERT(stateRit!=states.rend(),"End of states prematurely reached.");
+    if((*actionRit)->shouldUndo()){
+      Action::state_ptr newState = (*actionRit)->performUndo(*stateRit);
+      // The order of the states has to correspond to the order of the actions
+      // this is why we have to add at the beginning
+      res.push_front(newState);
+    }
+    else{
+      res.push_front(Action::success);
+    }
+  }
+  return res;
+}
+ActionSequence::stateSet ActionSequence::redoAll(stateSet states){
+  stateSet res;
+  actionSet::iterator actionIt = actions.begin();
+  stateSet::iterator stateIt = states.begin();
+  for(;actionIt!=actions.end();++actionIt,++stateIt){
+    ASSERT(stateIt!=states.end(),"End of states prematurely reached.");
+    if((*actionIt)->shouldUndo()){
+      Action::state_ptr newState =(*actionIt)->performRedo(*stateIt);
+      res.push_back(newState);
+    }
+    else{
+      res.push_back(Action::success);
+    }
+  }
+  return res;
+}
 bool ActionSequence::canUndo(){
   bool canUndo=true;
+  deque<Action*>::iterator it;
+  for(it=actions.begin(); it!=actions.end(); it++)
+    canUndo &= (*it)->canUndo();
+  for(deque<Action*>::iterator it=actions.begin(); it!=actions.end(); ++it){
+    if((*it)->shouldUndo()){
+      canUndo &= (*it)->canUndo();
+    }
+  }
   return canUndo;
+}
+bool ActionSequence::shouldUndo(){
+  bool shouldUndo = false;
+  for(deque<Action*>::iterator it=actions.begin();it!=actions.end();++it){
+    shouldUndo |= (*it)->shouldUndo();
+  }
+  return shouldUndo;
+}

src/Actions/ActionSequence.hpp

-              r66e95e
+              rb31bc4
 #define ACTIONSEQUENZE_HPP_
+#include "Actions/Action.hpp"
 #include <deque>
-class Action;
 /**
 …
+{
 public:
+  typedef std::deque<Action*> actionSet;
+  typedef std::deque<Action::state_ptr> stateSet;
   ActionSequence();
   virtual ~ActionSequence();
 …
   Action* removeLastAction();
+  void callAll();
+  void undoAll();
+  stateSet callAll();
+  stateSet undoAll(stateSet);
+  stateSet redoAll(stateSet);
   bool canUndo();
+  bool shouldUndo();
 private:
   std::deque<Action*> actions;
+  actionSet actions;
 };

src/Actions/AtomsCalculation_impl.hpp

-              r66e95e
+              rb31bc4
 AtomsCalculation<T>::AtomsCalculation(boost::function<T(atom*)> _op,std::string name,AtomDescriptor _descr) :
   Calculation<std::vector<T> >(0,name,false),
   op(_op),
   descr(_descr)
+  descr(_descr),
+  op(_op)
 {}
 …
 template<typename T>
 std::vector<T>* AtomsCalculation<T>::doCalc(){
   World* world = World::get();
+  World* world = World::getPointer();
   int steps = world->numAtoms();
-  int count = 0;
   std::vector<T> *res = new std::vector<T>();
   res->reserve(steps);
   Process::setMaxSteps(steps);
   Process::start();
+  World::AtomIterator iter;
+  for(iter=world->getAtomIter(descr);iter!=world->atomEnd();++iter){
+  for(World::AtomIterator iter=world->getAtomIter(descr);iter!=world->atomEnd();++iter){
     Process::setCurrStep(iter.getCount());
     res->push_back(op(*iter));

src/Actions/Calculation.hpp

-              r66e95e
+              rb31bc4
    * from menu Items or other places.
    */
-  virtual void call();
-  virtual void undo();
   virtual bool canUndo();
+  virtual bool shouldUndo();
   /**
 …
   virtual T* doCalc()=0;
 private:
+  virtual Action::state_ptr performCall();
+  virtual Action::state_ptr performUndo(Action::state_ptr);
+  virtual Action::state_ptr performRedo(Action::state_ptr);
   bool done;
 };

src/Actions/Calculation_impl.hpp

-              r66e95e
+              rb31bc4
 Calculation<T>::Calculation(int _maxSteps, std::string _name, bool _doRegister) :
   Process(_maxSteps,_name,_doRegister),
   done(false),
   result(0)
+  result(0),
+  done(false)
 {}
 …
 template<typename T>
 void Calculation<T>::call(){
+Action::state_ptr Calculation<T>::performCall(){
   reset();
   (*this)();
+  return Action::success;
+}
 template<typename T>
+void Calculation<T>::undo(){}
+Action::state_ptr Calculation<T>::performUndo(Action::state_ptr){
+  ASSERT(0,"Cannot undo a calculation");
+  return Action::success;
+}
+template<typename T>
+Action::state_ptr Calculation<T>::performRedo(Action::state_ptr){
+  ASSERT(0,"Cannot redo a calculation");
+  return Action::success;
+}
 template<typename T>
 bool Calculation<T>::canUndo()
+{
+  return false;
+}
+template<typename T>
+bool Calculation<T>::shouldUndo()
+{
   return false;

src/Actions/ErrorAction.cpp

-              r66e95e
+              rb31bc4
 #include "log.hpp"
 #include "verbose.hpp"
+#include "Helpers/Assert.hpp"
 using namespace std;
 …
+}
 void ErrorAction::call() {
+Action::state_ptr ErrorAction::performCall() {
   Log() << Verbose(0) << errorMsg << endl;
+  return Action::success;
+}
+void ErrorAction::undo() {
+Action::state_ptr ErrorAction::performUndo(Action::state_ptr) {
+  ASSERT(0,"Undo called for an ErrorAction");
+  return Action::success;
+}
+Action::state_ptr ErrorAction::performRedo(Action::state_ptr) {
+  ASSERT(0,"Redo called for an ErrorAction");
+  return Action::success;
+}
 …
   return false;
+}
+bool ErrorAction::shouldUndo(){
+  return false;
+}

src/Actions/ErrorAction.hpp

-              r66e95e
+              rb31bc4
   virtual ~ErrorAction();
-  virtual void call();
-  virtual void undo();
   virtual bool canUndo();
+  virtual bool shouldUndo();
 private:
+  virtual Action::state_ptr performCall();
+  virtual Action::state_ptr performUndo(Action::state_ptr);
+  virtual Action::state_ptr performRedo(Action::state_ptr);
   std::string errorMsg;
 };

src/Actions/MakroAction.cpp

-              r66e95e
+              rb31bc4
 #include "Actions/Action.hpp"
 #include "Actions/ActionSequence.hpp"
+#include "Helpers/Assert.hpp"
 using namespace std;
+class MakroActionState : public ActionState{
+public:
+  MakroActionState(ActionSequence::stateSet _states) :
+    states(_states)
+  {}
+  virtual ~MakroActionState(){
+    // All contained states are destroyed by the shared ptrs
+  }
+  ActionSequence::stateSet states;
+};
 MakroAction::MakroAction(string _name,ActionSequence* _actions,bool _doRegister) :
 …
+void MakroAction::call(){
+  actions->callAll();
+Action::state_ptr MakroAction::performCall(){
+  ActionSequence::stateSet states = actions->callAll();
+  return Action::state_ptr(new MakroActionState(states));
+}
+void MakroAction::undo() {
+  actions->undoAll();
+Action::state_ptr MakroAction::performUndo(Action::state_ptr _state) {
+  MakroActionState *state = dynamic_cast<MakroActionState*>(_state.get());
+  ASSERT(state,"Type mismatch for the state of the MakroAction");
+  ActionSequence::stateSet states = actions->undoAll(state->states);
+  return Action::state_ptr(new MakroActionState(states));
+}
+Action::state_ptr MakroAction::performRedo(Action::state_ptr _state){
+  MakroActionState *state = dynamic_cast<MakroActionState*>(_state.get());
+  ASSERT(state,"Type mismatch for the state of the MakroAction");
+  ActionSequence::stateSet states = actions->redoAll(state->states);
+  return Action::state_ptr(new MakroActionState(states));
+}
 …
   return actions->canUndo();
+}
+bool MakroAction::shouldUndo() {
+  return actions->shouldUndo();
+}

src/Actions/MakroAction.hpp

-              r66e95e
+              rb31bc4
   virtual ~MakroAction();
+  virtual void call();
+  virtual void undo();
+  virtual bool canUndo();
+  bool canUndo();
+  bool shouldUndo();
 private:
+  virtual Action::state_ptr performCall();
+  virtual Action::state_ptr performUndo(Action::state_ptr);
+  virtual Action::state_ptr performRedo(Action::state_ptr);
   ActionSequence *actions;
 };

src/Actions/ManipulateAtomsProcess.cpp

-              r66e95e
+              rb31bc4
 #include <iostream>
+#include "World.hpp"
+#include "Helpers/Assert.hpp"
 using namespace std;
 …
 {}
+void ManipulateAtomsProcess::call(){
+  World::get()->doManipulate(this);
+Action::state_ptr ManipulateAtomsProcess::performCall(){
+  World::getInstance().doManipulate(this);
+  return Action::success;
+}
+void ManipulateAtomsProcess::undo(){
+Action::state_ptr ManipulateAtomsProcess::performUndo(Action::state_ptr){
+  ASSERT(0,"Undo called for a ManipulateAtomsProcess");
+  return Action::success;
+}
+Action::state_ptr ManipulateAtomsProcess::performRedo(Action::state_ptr){
+  ASSERT(0,"Redo called for a ManipulateAtomsProcess");
+  return Action::success;
+}
 …
+}
+bool ManipulateAtomsProcess::shouldUndo(){
+  return true;
+}
 void ManipulateAtomsProcess::doManipulate(World *world){
   setMaxSteps(world->numAtoms());
   start();
+  World::AtomIterator iter;
+  for(iter=world->getAtomIter(descr);iter!=world->atomEnd();++iter){
+  for(World::AtomIterator iter=world->getAtomIter(descr);iter!=world->atomEnd();++iter){
     setCurrStep(iter.getCount());
     operation(*iter);

src/Actions/ManipulateAtomsProcess.hpp

-              r66e95e
+              rb31bc4
 #include "Actions/Process.hpp"
+#include<boost/function.hpp>
 #include "Descriptors/AtomDescriptor.hpp"
+class World;
 class ManipulateAtomsProcess : public Process
 …
   virtual ~ManipulateAtomsProcess();
-  virtual void call();
-  virtual void undo();
   virtual bool canUndo();
+  virtual bool shouldUndo();
   virtual void doManipulate(World *);
 private:
+  virtual Action::state_ptr performCall();
+  virtual Action::state_ptr performUndo(Action::state_ptr);
+  virtual Action::state_ptr performRedo(Action::state_ptr);
   AtomDescriptor descr;
   boost::function<void(atom*)> operation;

src/Actions/MethodAction.cpp

-              r66e95e
+              rb31bc4
 #include <string>
+#include "MethodAction.hpp"
+#include "Actions/MethodAction.hpp"
+#include "Helpers/Assert.hpp"
 using namespace std;
 …
 MethodAction::~MethodAction()
+{
+  // TODO Auto-generated destructor stub
+{}
+Action::state_ptr MethodAction::performCall() {
+  executeMethod();
+  // we don't have a state to save so we return Action::success
+  return Action::success;
+}
+Action::state_ptr MethodAction::performUndo(Action::state_ptr) {
+  ASSERT(0,"Cannot undo a MethodAction");
+  return Action::success;
+}
+void MethodAction::call() {
+  executeMethod();
+}
+void MethodAction::undo() {
+Action::state_ptr MethodAction::performRedo(Action::state_ptr){
+  ASSERT(0,"Cannot redo a MethodAction");
+  return Action::success;
+}
 …
   return false;
+}
+bool MethodAction::shouldUndo(){
+  return true;
+}

src/Actions/MethodAction.hpp

-              r66e95e
+              rb31bc4
   MethodAction(std::string _name,boost::function<void()> _executeMethod,bool _doRegister=true);
   virtual ~MethodAction();
+  virtual bool canUndo();
+  virtual bool shouldUndo();
+  virtual void call();
+  virtual void undo();
+  virtual bool canUndo();
+private:
+  virtual Action::state_ptr performCall();
+  virtual Action::state_ptr performUndo(Action::state_ptr);
+  virtual Action::state_ptr performRedo(Action::state_ptr);
   boost::function<void()> executeMethod; //!< this stores the method to be called
 };

src/Actions/small_actions.cpp

-              r66e95e
+              rb31bc4
 /****** ChangeMoleculeNameAction *****/
+char ChangeMoleculeNameAction::NAME[] = "Change filename of Molecule";
+// memento to remember the state when undoing
+class ChangeMoleculeNameState : public ActionState {
+public:
+  ChangeMoleculeNameState(molecule* _mol,std::string _lastName) :
+    mol(_mol),
+    lastName(_lastName)
+  {}
+  molecule* mol;
+  std::string lastName;
+};
+const char ChangeMoleculeNameAction::NAME[] = "Change filename of Molecule";
 ChangeMoleculeNameAction::ChangeMoleculeNameAction(MoleculeListClass *_molecules) :
 …
 {}
 void ChangeMoleculeNameAction::call() {
+Action::state_ptr ChangeMoleculeNameAction::performCall() {
   string filename;
   molecule *mol = NULL;
   Dialog *dialog = UIFactory::get()->makeDialog();
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryMolecule("Enter index of molecule: ",&mol,molecules);
   dialog->queryString("Enter name: ",&filename);
   if(dialog->display()) {
+    string oldName = mol->getName();
     mol->setName(filename);
+    delete dialog;
+    return Action::state_ptr(new ChangeMoleculeNameState(mol,oldName));
+  }
   delete dialog;
+  return Action::failure;
+}
+void ChangeMoleculeNameAction::undo() {
+Action::state_ptr ChangeMoleculeNameAction::performUndo(Action::state_ptr _state) {
+  ChangeMoleculeNameState *state = dynamic_cast<ChangeMoleculeNameState*>(_state.get());
+  ASSERT(state,"State passed to ChangeMoleculeNameAction::performUndo did not have correct type");
+  string newName = state->mol->getName();
+  state->mol->setName(state->lastName);
+  return Action::state_ptr(new ChangeMoleculeNameState(state->mol,newName));
+}
+Action::state_ptr ChangeMoleculeNameAction::performRedo(Action::state_ptr _state){
+  // Undo and redo have to do the same for this action
+  return performUndo(_state);
+}
 bool ChangeMoleculeNameAction::canUndo() {
   return false;
+  return true;
+}

src/Actions/small_actions.hpp

-              r66e95e
+              rb31bc4
   virtual ~ChangeMoleculeNameAction();
-  void call();
-  void undo();
   bool canUndo();
   bool shouldUndo();
 …
   virtual const std::string getName();
 private:
+  virtual Action::state_ptr performCall();
+  virtual Action::state_ptr performUndo(Action::state_ptr);
+  virtual Action::state_ptr performRedo(Action::state_ptr);
   MoleculeListClass *molecules;
   static char NAME[];
+  static const char NAME[];
 };

src/Descriptors/AtomDescriptor.cpp

r66e95e	rb31bc4
68	68
69	69	World::AtomSet& AtomDescriptor_impl::getAtoms(){
70		return World::get~~()->~~atoms;
	70	return World::getInstance().atoms;
71	71	}
72	72

src/Descriptors/AtomDescriptor.hpp

r66e95e	rb31bc4
36	36	friend atom* World::getAtom(AtomDescriptor descriptor);
37	37	friend std::vector<atom*> World::getAllAtoms(AtomDescriptor descriptor);
38		~~friend class World::Atom~~Iterator;
	38	template <class,class,class> friend class SelectiveIterator;
39	39
40	40	friend AtomDescriptor operator&&(const AtomDescriptor &lhs, const AtomDescriptor &rhs);

src/Descriptors/AtomTypeDescriptor.cpp

-              r66e95e
+              rb31bc4
 #include "periodentafel.hpp"
 AtomTypeDescriptor_impl::AtomTypeDescriptor_impl(element* _type) :
+AtomTypeDescriptor_impl::AtomTypeDescriptor_impl(const element* _type) :
   type(_type)
 {}
 …
+}
 AtomDescriptor AtomByType(element *elem){
+AtomDescriptor AtomByType(const element *elem){
   return AtomDescriptor(AtomDescriptor::impl_ptr(new AtomTypeDescriptor_impl(elem)));
+}
 AtomDescriptor AtomByType(int Z){
   element * elem = World::get()->getPeriode()->FindElement(Z);
+  const element * elem = World::getInstance().getPeriode()->FindElement(Z);
   return AtomByType(elem);
+}

src/Descriptors/AtomTypeDescriptor.hpp

r66e95e	rb31bc4
13	13	class element;
14	14
15		AtomDescriptor AtomByType(element *);
	15	AtomDescriptor AtomByType(const element *);
16	16	AtomDescriptor AtomByType(int);
17	17

src/Descriptors/AtomTypeDescriptor_impl.hpp

-              r66e95e
+              rb31bc4
+{
 public:
   AtomTypeDescriptor_impl(element* _type);
+  AtomTypeDescriptor_impl(const element* _type);
   virtual ~AtomTypeDescriptor_impl();
   bool predicate(std::pair<atomId_t,atom*> atom);
 private:
   element *type;
+  const element * const type;
 };

src/Descriptors/MoleculeDescriptor.cpp

r66e95e	rb31bc4
68	68
69	69	World::MoleculeSet& MoleculeDescriptor_impl::getMolecules(){
70		return World::get~~()->~~molecules;
	70	return World::getInstance().molecules;
71	71	}
72	72

src/Descriptors/MoleculeDescriptor.hpp

-              r66e95e
+              rb31bc4
   friend molecule* World::getMolecule(MoleculeDescriptor descriptor);
   friend std::vector<molecule*> World::getAllMolecules(MoleculeDescriptor descriptor);
   friend class World::MoleculeIterator;
+  template <class,class,class> friend class SelectiveIterator;
   friend MoleculeDescriptor operator&&(const MoleculeDescriptor &lhs, const MoleculeDescriptor &rhs);
 …
 public:
+  typedef boost::shared_ptr<MoleculeDescriptor_impl> impl_ptr; //!< Allow easy changes of the pointer-to-implementation type
+  typedef MoleculeDescriptor_impl impl_t;
+  typedef boost::shared_ptr<impl_t> impl_ptr; //!< Allow easy changes of the pointer-to-implementation type
   MoleculeDescriptor(impl_ptr);

src/Legacy/oldmenu.cpp

-              r66e95e
+              rb31bc4
       case 'a': // absolute coordinates of atom
         Log() << Verbose(0) << "Enter absolute coordinates." << endl;
         first = World::get()->createAtom();
+        first = World::getInstance().createAtom();
         first->x.AskPosition(mol->cell_size, false);
         first->type = periode->AskElement();  // give type
 …
       case 'b': // relative coordinates of atom wrt to reference point
         first = World::get()->createAtom();
+        first = World::getInstance().createAtom();
         valid = true;
         do {
 …
       case 'c': // relative coordinates of atom wrt to already placed atom
         first = World::get()->createAtom();
+        first = World::getInstance().createAtom();
         valid = true;
         do {
 …
     case 'd': // two atoms, two angles and a distance
         first = World::get()->createAtom();
+        first = World::getInstance().createAtom();
         valid = true;
         do {
 …
       case 'e': // least square distance position to a set of atoms
         first = World::get()->createAtom();
+        first = World::getInstance().createAtom();
         atoms = new (Vector*[128]);
         valid = true;
 …
           mol->AddAtom(first);  // add to molecule
         } else {
           World::get()->destroyAtom(first);
+          World::getInstance().destroyAtom(first);
           Log() << Verbose(0) << "Please enter at least two vectors!\n";
+        }
 …
   int axis,faktor,count,j;
   atom *first = NULL;
   element **Elements;
+  const element **Elements;
   Vector x,y;
   Vector **vectors;
 …
     if (mol->AtomCount != 0) {  // if there is more than none
       count = mol->AtomCount;  // is changed becausing of adding, thus has to be stored away beforehand
       Elements = new element *[count];
+      Elements = new const element *[count];
       vectors = new Vector *[count];
       j = 0;
 …
         x.AddVector(&y); // per factor one cell width further
         for (int k=count;k--;) { // go through every atom of the original cell
           first = World::get()->createAtom(); // create a new body
+          first = World::getInstance().createAtom(); // create a new body
           first->x.CopyVector(vectors[k]);  // use coordinate of original atom
           first->x.AddVector(&x);     // translate the coordinates
 …
 void oldmenu::SimpleAddMolecules(MoleculeListClass *molecules) {
   molecule *srcmol = NULL, *destmol = NULL;
   Dialog *dialog = UIFactory::get()->makeDialog();
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryMolecule("Enter index of destination molecule: ",&destmol, molecules);
   dialog->queryMolecule("Enter index of source molecule to add from: ",&srcmol, molecules);
 …
 void oldmenu::embeddMolecules(MoleculeListClass *molecules) {
   molecule *srcmol = NULL, *destmol = NULL;
   Dialog *dialog = UIFactory::get()->makeDialog();
+  Dialog *dialog = UIFactory::getInstance().makeDialog();
   dialog->queryMolecule("Enter index of matrix molecule (the variable one): ",&srcmol,molecules);
   dialog->queryMolecule("Enter index of molecule to merge into (the fixed one): ",&destmol,molecules);
 …
     A++;
+  }
   World::get()->destroyMolecule(mol);
+  World::getInstance().destroyMolecule(mol);
 };

src/Makefile.am

-              r66e95e
+              rb31bc4
 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/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
+ACTIONSSOURCE = Actions/Action.cpp \
+                                Actions/ActionHistory.cpp \
+                                Actions/ActionRegistry.cpp \
+                                Actions/ActionSequence.cpp \
+                                Actions/ErrorAction.cpp \
+                                Actions/MakroAction.cpp \
+                                Actions/ManipulateAtomsProcess.cpp \
+                                Actions/MethodAction.cpp \
+                Actions/Process.cpp \
+                Actions/small_actions.cpp
+ACTIONSHEADER = Actions/Action.hpp \
+                                Actions/ActionHistory.hpp \
+                                Actions/ActionRegistry.hpp \
+                                Actions/ActionSequence.hpp \
+                            Actions/Calculation.hpp \
+                            Actions/Calculation_impl.hpp \
+                            Actions/ErrorAction.hpp \
+                            Actions/MakroAction.hpp \
+                            Actions/ManipulateAtomsProcess.hpp \
+                            Actions/MethodAction.hpp \
+                            Actions/Process.hpp \
+                            Actions/small_actions.hpp
 PATTERNSOURCE = Patterns/Observer.cpp
+PATTERNHEADER = Patterns/Observer.hpp Patterns/Cacheable.hpp
+PATTERNHEADER = Patterns/Cacheable.hpp \
+                                Patterns/Observer.hpp \
+                Patterns/Singleton.hpp
 VIEWSOURCE = Views/View.cpp Views/StringView.cpp Views/MethodStringView.cpp Views/StreamStringView.cpp
 …
                                    Descriptors/AtomTypeDescriptor.cpp \
                                    Descriptors/MoleculeDescriptor.cpp \
+                                   Descriptors/MoleculeIdDescriptor.cpp
+                                   Descriptors/MoleculeIdDescriptor.cpp
 DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
 …
                                    Descriptors/MoleculeDescriptor.hpp \
                                    Descriptors/MoleculeIdDescriptor.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 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
+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 \
+                 Helpers/Assert.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
 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

src/Menu/TextMenu.cpp

-              r66e95e
+              rb31bc4
 #include "Menu/TextMenu.hpp"
 #include "Menu/MenuItem.hpp"
+#include "Helpers/Assert.hpp"
 …
+}
+string TextMenu::getTitle(){
+  return title;
+}
 void TextMenu::addDefault(MenuItem* _defaultItem) {
   defaultItem = _defaultItem;
+}
+/****************************** Contained Actions ****************/
+const string TextMenu::LeaveAction::nameBase = "Leave menu: ";
+TextMenu::LeaveAction::LeaveAction(TextMenu* _menu) :
+Action(nameBase+_menu->getTitle()),
+menu(_menu)
+{}
+TextMenu::LeaveAction::~LeaveAction(){}
+bool TextMenu::LeaveAction::canUndo(){
+  return false;
+}
+bool TextMenu::LeaveAction::shouldUndo(){
+  return false;
+}
+Action::state_ptr TextMenu::LeaveAction::performCall(){
+  menu->doQuit();
+  return Action::success;
+}
+Action::state_ptr TextMenu::LeaveAction::performUndo(Action::state_ptr){
+  ASSERT(0,"Cannot undo leaving a menu");
+  return Action::success;
+}
+Action::state_ptr TextMenu::LeaveAction::performRedo(Action::state_ptr){
+  ASSERT(0,"Cannot redo leaving a menu");
+  return Action::success;
+}

src/Menu/TextMenu.hpp

-              r66e95e
+              rb31bc4
 #include "Menu/Menu.hpp"
+#include "Actions/Action.hpp"
 #include "defs.hpp"
 …
+{
 public:
+  class LeaveAction : public Action {
+  public:
+    LeaveAction(TextMenu*);
+    virtual ~LeaveAction();
+    bool canUndo();
+    bool shouldUndo();
+  private:
+    virtual Action::state_ptr performCall();
+    virtual Action::state_ptr performUndo(Action::state_ptr);
+    virtual Action::state_ptr performRedo(Action::state_ptr);
+    TextMenu* menu;
+    static const string nameBase;
+  };
   TextMenu(ostream& _outputter, string _title, char _spacer=STD_MENU_TITLE_SPACER,int _length=STD_MENU_LENGTH);
   virtual ~TextMenu();
 …
   virtual void removeItem(MenuItem*);
   virtual void display();
+  virtual string getTitle();
   /**

src/Patterns/Cacheable.hpp

-              r66e95e
+              rb31bc4
 #include "Patterns/Observer.hpp"
 #include <boost/function.hpp>
+#include <boost/shared_ptr.hpp>
+#include <iostream>
+#include "Helpers/Assert.hpp"
 #ifndef NO_CACHING
 …
   class Cacheable : public Observer
+  {
+    // we define the states of the cacheable so we can do very fast state-checks
+    class State{
+    public:
+      State(Cacheable *_owner) :
+        busy(false),
+        owner(_owner)
+        {}
+      virtual T getValue()=0;
+      virtual void invalidate()=0;
+      virtual bool isValid()=0;
+      virtual void enter()=0;
+      bool isBusy(){
+        return busy;
+      }
+    protected:
+      bool busy;
+      Cacheable *owner;
+    };
+    class InvalidState : public State{
+    public:
+      InvalidState(Cacheable *_owner):
+        State(_owner)
+        {}
+      virtual T getValue(){
+        // set the state to valid
+        State::owner->switchState(State::owner->validState);
+        // get the value from the now valid state
+        return State::owner->state->getValue();
+      }
+      virtual void invalidate(){
+        // nothing to do on this message
+      }
+      virtual bool isValid(){
+        return false;
+      }
+      virtual void enter(){
+        // nothing to do when entering this
+      }
+    };
+    class ValidState : public State{
+    public:
+      ValidState(Cacheable *_owner) :
+        State(_owner)
+        {}
+      virtual T getValue(){
+        return content;
+      }
+      virtual void invalidate(){
+        State::owner->switchState(State::owner->invalidState);
+      }
+      virtual bool isValid(){
+        return true;
+      }
+      virtual void enter(){
+        State::busy= true;
+        // as soon as we enter the valid state we recalculate
+        content = State::owner->recalcMethod();
+        State::busy = false;
+      }
+    private:
+      T content;
+    };
+    class DestroyedState : public State {
+    public:
+      DestroyedState(Cacheable *_owner) :
+        State(_owner)
+        {}
+      virtual T getValue(){
+        ASSERT(0,"Cannot get a value from a Cacheable after it's Observable has died");
+        // we have to return a grossly invalid reference, because no value can be produced anymore
+        return *(static_cast<T*>(0));
+      }
+      virtual void invalidate(){
+        ASSERT(0,"Cannot invalidate a Cacheable after it's Observable has died");
+      }
+      virtual bool isValid(){
+        ASSERT(0,"Cannot check validity of a Cacheable after it's Observable has died");
+        return false;
+      }
+      virtual void enter(){
+        // nothing to do when entering this state
+      }
+    };
+  typedef boost::shared_ptr<State> state_ptr;
   public:
     Cacheable(Observable *_owner, boost::function<T()> _recalcMethod);
     virtual ~Cacheable();
+    const bool isValid();
+    const T& operator*();
+    const bool operator==(const T&);
+    const bool operator!=(const T&);
+    const bool isValid() const;
+    const T operator*() const;
     // methods implemented for base-class Observer
 …
     void subjectKilled(Observable *subject);
   private:
+    void checkValid();
+    T content;
+    void switchState(state_ptr newState);
+    mutable state_ptr state;
+    // pre-defined state so we don't have to construct to much
+    state_ptr invalidState;
+    state_ptr validState;
+    // destroyed state is not predefined, because we rarely enter that state and never leave
     Observable *owner;
+    bool valid;
+    bool canBeUsed;
     boost::function<T()> recalcMethod;
+    // de-activated copy constructor
+    Cacheable(const Cacheable&);
   };
 …
   Cacheable<T>::Cacheable(Observable *_owner, boost::function<T()> _recalcMethod) :
     owner(_owner),
-    valid(false),
-    canBeUsed(true),
     recalcMethod(_recalcMethod)
+  {
+    // create all states needed for this object
+    invalidState = state_ptr(new InvalidState(this));
+    validState = state_ptr(new ValidState(this));
+    state = invalidState;
     // we sign on with the best(=lowest) priority, so cached values are recalculated before
     // anybody else might ask for updated values
 …
+  }
+  template<typename T>
+  const T& Cacheable<T>::operator*(){
+    checkValid();
+    return content;
+  }
+  template<typename T>
+  const bool Cacheable<T>::operator==(const T& rval){
+    checkValid();
+    return (content == rval);
+  }
+  template<typename T>
+  const bool Cacheable<T>::operator!=(const T& rval){
+    checkValid();
+    return (content != rval);
+  // de-activated copy constructor
+  template<typename T>
+  Cacheable<T>::Cacheable(const Cacheable&){
+    ASSERT(0,"Cacheables should never be copied");
+  }
+  template<typename T>
+  const T Cacheable<T>::operator*() const{
+    // we can only use the cacheable when the owner is not changing at the moment
+    if(!owner->isBlocked()){
+      return state->getValue();
+    }
+    else{
+      return recalcMethod();
+    }
+  }
 …
   template<typename T>
   const bool Cacheable<T>::isValid(){
     return valid;
+  const bool Cacheable<T>::isValid() const{
+    return state->isValid();
+  }
   template<typename T>
   void Cacheable<T>::update(Observable *subject) {
     valid = false;
+    state->invalidate();
+  }
   template<typename T>
   void Cacheable<T>::subjectKilled(Observable *subject) {
     valid = false;
     canBeUsed = false;
+  }
   template<typename T>
   void Cacheable<T>::checkValid(){
     assert(canBeUsed && "Cacheable used after owner was deleted");
     if(!isValid()){
       content = recalcMethod();
+    }
+  }
+    state_ptr destroyed = state_ptr(new DestroyedState(this));
+    switchState(destroyed);
+  }
+  template<typename T>
+  void Cacheable<T>::switchState(state_ptr newState){
+    ASSERT(!state->isBusy(),"LOOP DETECTED: Cacheable state switched while recalculating.\nDid the recalculation trigger the Observable?");
+    state = newState;
+    state->enter();
+  }
 #else
   template<typename T>
 …
     virtual ~Cacheable();
+    const bool isValid();
+    const T& operator*();
+    const bool operator==(const T&);
+    const bool operator!=(const T&);
+    const bool isValid() const;
+    const T operator*() const;
     // methods implemented for base-class Observer
 …
   template<typename T>
   const T& Cacheable<T>::operator*(){
+  const T Cacheable<T>::operator*() const{
     return recalcMethod();
+  }
-  template<typename T>
-  const bool Cacheable<T>::operator==(const T& rval){
-    return (recalcMethod() == rval);
+  }
-  template<typename T>
-  const bool Cacheable<T>::operator!=(const T& rval){
-    return (recalcMethod() != rval);
+  }
 …
   template<typename T>
   const bool Cacheable<T>::isValid(){
+  const bool Cacheable<T>::isValid() const{
     return true;
+  }
 …
   template<typename T>
   void Cacheable<T>::update(Observable *subject) {
     assert(0 && "Cacheable::update should never be called when caching is disabled");
+  }
   template<typename T>
   void Cacheable<T>::subjectKilled(Observable *subject) {
     assert(0 && "Cacheable::subjectKilled should never be called when caching is disabled");
+    ASSERT(0, "Cacheable::update should never be called when caching is disabled");
+  }
+  template<typename T>
+  void Cacheable<T>::subjectKilled(Observable *subject){
+    ASSERT(0, "Cacheable::subjectKilled should never be called when caching is disabled");
+  }
 #endif

src/Patterns/Observer.cpp

-              r66e95e
+              rb31bc4
 #include <iostream>
+#include <cassert>
+#include "Helpers/Assert.hpp"
 using namespace std;
 …
     // observers, but still we are called by one of our sub-Observables
     // we cannot be sure observation will still work at this point
     cerr << "Circle detected in observation-graph." << endl;
     cerr << "Observation-graph always needs to be a DAG to work correctly!" << endl;
     cerr << "Please check your observation code and fix this!" << endl;
+    ASSERT(0,"Circle detected in observation-graph.\n"
+             "Observation-graph always needs to be a DAG to work correctly!\n"
+             "Please check your observation code and fix this!\n");
     return;
+  }
 …
  */
 void Observable::signOn(Observer *target,int priority) {
   assert(priority>=-20 && priority<=+20 && "Priority out of range [-20:+20]");
+  ASSERT(priority>=-20 && priority<=+20, "Priority out of range [-20:+20] when signing on Observer");
   bool res = false;
   callees_t *callees = 0;
 …
  */
 void Observable::signOff(Observer *target) {
   assert(callTable.count(this) && "SignOff called for an Observable without Observers.");
+  ASSERT(callTable.count(this),"SignOff called for an Observable without Observers.");
   callees_t *callees = callTable[this];
   callees_t::iterator iter;
 …
     delete callees;
+  }
+}
+bool Observable::isBlocked(){
+  return depth.count(this) > 0;
+}

src/Patterns/Observer.hpp

-              r66e95e
+              rb31bc4
   virtual void signOff(Observer *target);
+  /**
+   * Ask an Observer if it is currently in a blocked state, i.e. if
+   * Changes are in Progress, that are not yet published.
+   */
+  virtual bool isBlocked();
 protected:
   virtual void update(Observable *publisher);
 …
   static std::set<Observable*> busyObservables;
+  //! @cond
   // Structure for RAII-Style notification
 protected:
 …
     Observable *protege;
   };
+  //! @endcond
 };

src/UIElements/TextWindow.cpp

-              r66e95e
+              rb31bc4
   populaters.MakeEditMoleculesMenu(editMoleculesMenu,molecules,configuration,periode);
   returnFromEditMoleculeAction = new MethodAction("returnAction",boost::bind(&TextMenu::doQuit,editMoleculesMenu),false);
+  Action *returnFromEditMoleculeAction = new TextMenu::LeaveAction(editMoleculesMenu);
   MenuItem *returnItem = new ActionMenuItem('q',"return to Main menu",editMoleculesMenu,returnFromEditMoleculeAction);
 …
   delete old_menu;
   delete quitAction;
-  delete returnFromEditMoleculeAction;
   delete moleculeView;
   delete statusIndicator;

src/UIElements/TextWindow.hpp

r66e95e	rb31bc4
29	29	// some actions only needed in textMenus
30	30	Action *quitAction;
31		~~Action *returnFromEditMoleculeAction;~~
32	31	// all views that are contained in the main Menu
33	32	StringView *moleculeView;

src/UIElements/UIFactory.cpp

-              r66e95e
+              rb31bc4
 #include <cassert>
+#include "Patterns/Singleton_impl.hpp"
 #include "UIElements/UIFactory.hpp"
 // all factories that can be used:
 #include "UIElements/TextUIFactory.hpp"
-UIFactory *UIFactory::theFactory = 0;
 UIFactory::UIFactory()
 …
 void UIFactory::makeUserInterface(InterfaceTypes type) {
-  assert(theFactory == 0 && "makeUserInterface should only be called once");
   switch(type) {
     case Text :
       theFactory = new TextUIFactory();
+      setInstance(new TextUIFactory());
       break;
 …
+}
+UIFactory* UIFactory::get(){
+  assert(theFactory != 0 && "No UserInterface created prior to factory access");
+  return theFactory;
+}
+void UIFactory::purgeInstance(){
+  if(theFactory) {
+    delete theFactory;
+    theFactory = 0;
+  }
+}
+CONSTRUCT_SINGLETON(UIFactory)

src/UIElements/UIFactory.hpp

-              r66e95e
+              rb31bc4
 struct menuPopulaters;
+#include "Patterns/Singleton.hpp"
 /**
  * Abstract Factory to create any kind of User interface object needed by the programm.
 …
  * UIs can be handled in a concise abstract way.
  */
 class UIFactory
+class UIFactory : public Singleton<UIFactory,false>
+{
 …
   UIFactory();
-// singleton stuff
-private:
-  static UIFactory *theFactory;
 public:
   /**
 …
   static void makeUserInterface(InterfaceTypes type);
-  /**
-   * get the previously created factory
-   */
-  static UIFactory* get();
-  /**
-   * Destroy the created factory.
+   *
-   * Make sure that all UIElements that were created by the factory are destroyed before calling this method.
-   */
-  static void purgeInstance();
 };

src/World.cpp

-              r66e95e
+              rb31bc4
 #include "Descriptors/MoleculeDescriptor.hpp"
 #include "Descriptors/MoleculeDescriptor_impl.hpp"
+#include "Descriptors/SelectiveIterator_impl.hpp"
 #include "Actions/ManipulateAtomsProcess.hpp"
+#include "Patterns/Singleton_impl.hpp"
 using namespace std;
 …
     atomId_t id = *(atomIdPool.begin());
     atomIdPool.erase(id);
+    return id;
+  }
+}
 …
 /******************************* Iterators ********************************/
 /*
+ * Actual Implementation of the iterators can be found in WorldIterators.cpp
+ */
+// Build the AtomIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(atom*,World::AtomSet,AtomDescriptor);
 World::AtomIterator World::getAtomIter(AtomDescriptor descr){
+  return AtomIterator(descr,this);
+}
+World::AtomSet::iterator World::atomEnd(){
+  return atoms.end();
+}
+  return AtomIterator(descr,atoms);
+}
+World::AtomIterator World::atomEnd(){
+  return AtomIterator(AllAtoms(),atoms,atoms.end());
+}
+// build the MoleculeIterator from template
+CONSTRUCT_SELECTIVE_ITERATOR(molecule*,World::MoleculeSet,MoleculeDescriptor);
 World::MoleculeIterator World::getMoleculeIter(MoleculeDescriptor descr){
   return MoleculeIterator(descr,this);
+}
 World::MoleculeSet::iterator World::moleculeEnd(){
   return molecules.end();
+  return MoleculeIterator(descr,molecules);
+}
+World::MoleculeIterator World::moleculeEnd(){
+  return MoleculeIterator(AllMolecules(),molecules,molecules.end());
+}
 /******************************* Singleton Stuff **************************/
-// TODO: Hide boost-thread using Autotools stuff when no threads are used
-World* World::theWorld = 0;
-boost::mutex World::worldLock;
 World::World() :
 …
+}
+World* World::get(){
+  // boost supports RAII-Style locking, so we don't need to unlock
+  boost::mutex::scoped_lock guard(worldLock);
+  if(!theWorld) {
+    theWorld = new World();
+  }
+  return theWorld;
+}
+void World::destroy(){
+  // boost supports RAII-Style locking, so we don't need to unlock
+  boost::mutex::scoped_lock guard(worldLock);
+  delete theWorld;
+  theWorld = 0;
+}
+World* World::reset(){
+  World* oldWorld = 0;
+  {
+    // boost supports RAII-Style locking, so we don't need to unlock
+    boost::mutex::scoped_lock guard(worldLock);
+    oldWorld = theWorld;
+    theWorld = new World();
+    // oldworld does not need protection any more,
+    // since we should have the only reference
+    // worldLock handles access to the pointer,
+    // not to the object
+  } // scope-end releases the lock
+  // we have to let all the observers know that the
+  // oldWorld was destroyed. oldWorld calls subjectKilled
+  // upon destruction. Every Observer getting that signal
+  // should see that it gets the updated new world
+  delete oldWorld;
+  return theWorld;
+}
+// Explicit instantiation of the singleton mechanism at this point
+CONSTRUCT_SINGLETON(World)
 /******************************* deprecated Legacy Stuff ***********************/

src/World.hpp

-              r66e95e
+              rb31bc4
 #include <boost/shared_ptr.hpp>
+#include "defs.hpp"
+#include "types.hpp"
+#include "Descriptors/SelectiveIterator.hpp"
 #include "Patterns/Observer.hpp"
 #include "Patterns/Cacheable.hpp"
+#include "Patterns/Singleton.hpp"
 // forward declarations
 …
 class AtomsCalculation;
+class World : public Observable
+class World : public Singleton<World>, public Observable
+{
+// Make access to constructor and destructor possible from inside the singleton
+friend class Singleton<World>;
 // necessary for coupling with descriptors
 friend class AtomDescriptor_impl;
 …
 template<typename> friend class AtomsCalculation;
 public:
+  // Types for Atom and Molecule structures
   typedef std::map<atomId_t,atom*> AtomSet;
   typedef std::map<moleculeId_t,molecule*> MoleculeSet;
 …
   // Atoms
+  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;
+  };
+  typedef SelectiveIterator<atom*,AtomSet,AtomDescriptor> AtomIterator;
   /**
 …
    * used for internal purposes, like AtomProcesses and AtomCalculations.
    */
   AtomSet::iterator atomEnd();
+  AtomIterator atomEnd();
   // Molecules
+  class MoleculeIterator {
+  public:
+    MoleculeIterator();
+    MoleculeIterator(MoleculeDescriptor, World*);
+    MoleculeIterator(const MoleculeIterator&);
+    MoleculeIterator& operator=(const MoleculeIterator&);
+    MoleculeIterator& operator++();     // prefix
+    MoleculeIterator  operator++(int);  // postfix with dummy parameter
+    bool operator==(const MoleculeIterator&);
+    bool operator==(const MoleculeSet::iterator&);
+    bool operator!=(const MoleculeIterator&);
+    bool operator!=(const MoleculeSet::iterator&);
+    molecule* operator*();
+    int getCount();
+  protected:
+    void advanceState();
+    MoleculeSet::iterator state;
+    boost::shared_ptr<MoleculeDescriptor_impl>  descr;
+    int index;
+    World* world;
+  };
+  typedef SelectiveIterator<molecule*,MoleculeSet,MoleculeDescriptor> MoleculeIterator;
   /**
 …
    * used for internal purposes, like MoleculeProcesses and MoleculeCalculations.
    */
   MoleculeSet::iterator moleculeEnd();
+  MoleculeIterator moleculeEnd();
 …
   periodentafel *periode;
+public:
   AtomSet atoms;
+private:
   std::set<atomId_t> atomIdPool; //<!stores the pool for all available AtomIds below currAtomId
   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:
   /**
 …
    */
   virtual ~World();
-  static World *theWorld;
-  // this mutex only saves the singleton pattern...
-  // use other mutexes to protect internal data as well
-  // this mutex handles access to the pointer, not to the object!!!
-  static boost::mutex worldLock;
   /*****

src/atom.cpp

r66e95e	rb31bc4
50	50	res->FixedIon = FixedIon;
51	51	res->node = &x;
52		World::get~~()->~~registerAtom(res);
	52	World::getInstance().registerAtom(res);
53	53	return res;
54	54	}

src/atom.hpp

r66e95e	rb31bc4
28	28	#include "atom_trajectoryparticle.hpp"
29	29	#include "tesselation.hpp"
	30	#include "types.hpp"
30	31
31	32	/**************************************** forward declarations ***************************/

src/atom_atominfo.cpp

-              r66e95e
+              rb31bc4
 };
 element *AtomInfo::getType(){
+const element *AtomInfo::getType(){
   return type;
+}
 void AtomInfo::setType(element* _type) {
+void AtomInfo::setType(const element* _type) {
   type = _type;
+}
 void AtomInfo::setType(int Z) {
   element *elem = World::get()->getPeriode()->FindElement(Z);
+  const element *elem = World::getInstance().getPeriode()->FindElement(Z);
   setType(elem);
+}

src/atom_atominfo.hpp

-              r66e95e
+              rb31bc4
   Vector v;       //!< velocity vector of atom, giving last velocity within cell
   Vector F;       //!< Force vector of atom, giving last force within cell
   element *type;  //!< pointing to element
+  const element *type;  //!< pointing to element
   AtomInfo();
   ~AtomInfo();
   element *getType();
   void setType(element *);
+  const element *getType();
+  void setType(const element *);
   void setType(int);

src/boundary.cpp

r66e95e	rb31bc4
801	801	{
802	802	Info FunctionInfo(__func__);
803		molecule *Filling = World::get~~()->~~createMolecule();
	803	molecule *Filling = World::getInstance().createMolecule();
804	804	Vector CurrentPosition;
805	805	int N[NDIM];

src/builder.cpp

-              r66e95e
+              rb31bc4
 #include "Menu/ActionMenuItem.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionHistory.hpp"
 #include "Actions/MethodAction.hpp"
 #include "Actions/small_actions.hpp"
 …
+     }
      if (mol == NULL) {
        mol = World::get()->createMolecule();
+       mol = World::getInstance().createMolecule();
        mol->ActiveFlag = true;
        if (ConfigFileName != NULL)
 …
                 SaveFlag = true;
                 Log() << Verbose(1) << "Adding new atom with element " << argv[argptr] << " at (" << argv[argptr+1] << "," << argv[argptr+2] << "," << argv[argptr+3] << "), ";
                 first = World::get()->createAtom();
+                first = World::getInstance().createAtom();
                 first->type = periode->FindElement(atoi(argv[argptr]));
                 if (first->type != NULL)
 …
+                }
                 LCList = new LinkedCell(Boundary, 2.*radius);
                 element *elemental = periode->FindElement((const int) atoi(argv[argptr]));
+                const element *elemental = periode->FindElement((atomicNumber_t) atoi(argv[argptr]));
                 FindNonConvexBorder(Boundary, TesselStruct, LCList, radius, NULL);
                 int ranges[NDIM] = {1,1,1};
 …
                 Log() << Verbose(1) << "Filling Box with water molecules." << endl;
                 // construct water molecule
                 molecule *filler = World::get()->createMolecule();
+                molecule *filler = World::getInstance().createMolecule();
                 molecule *Filling = NULL;
                 atom *second = NULL, *third = NULL;
 …
 //                first->x.Zero();
 //                filler->AddAtom(first);
                 first = World::get()->createAtom();
+                first = World::getInstance().createAtom();
                 first->type = periode->FindElement(1);
                 first->x.Init(0.441, -0.143, 0.);
                 filler->AddAtom(first);
                 second = World::get()->createAtom();
+                second = World::getInstance().createAtom();
                 second->type = periode->FindElement(1);
                 second->x.Init(-0.464, 1.137, 0.0);
                 filler->AddAtom(second);
                 third = World::get()->createAtom();
+                third = World::getInstance().createAtom();
                 third->type = periode->FindElement(8);
                 third->x.Init(-0.464, 0.177, 0.);
 …
                   molecules->insert(Filling);
+                }
                 World::get()->destroyMolecule(filler);
+                World::getInstance().destroyMolecule(filler);
                 argptr+=6;
+              }
 …
                   int faktor = atoi(argv[argptr++]);
                   int count;
                   element ** Elements;
+                  const element ** Elements;
                   Vector ** vectors;
                   if (faktor < 1) {
                     eLog() << Verbose(1) << "Repetition factor mus be greater than 1!" << endl;
+                    eLog() << Verbose(1) << "Repetition factor must be greater than 1!" << endl;
                     faktor = 1;
+                  }
 …
                   if (mol->AtomCount != 0) {  // if there is more than none
                     count = mol->AtomCount;   // is changed becausing of adding, thus has to be stored away beforehand
                     Elements = new element *[count];
+                    Elements = new const element *[count];
                     vectors = new Vector *[count];
                     j = 0;
 …
                       x.AddVector(&y); // per factor one cell width further
                       for (int k=count;k--;) { // go through every atom of the original cell
                         first = World::get()->createAtom(); // create a new body
+                        first = World::getInstance().createAtom(); // create a new body
                         first->x.CopyVector(vectors[k]);  // use coordinate of original atom
                         first->x.AddVector(&x);      // translate the coordinates
 …
 void cleanUp(config *configuration){
   UIFactory::purgeInstance();
   World::destroy();
+  World::purgeInstance();
   delete(configuration);
   Log() << Verbose(0) <<  "Maximum of allocated memory: "
 …
   logger::purgeInstance();
   errorLogger::purgeInstance();
   ActionRegistry::purgeRegistry();
+  ActionRegistry::purgeInstance();
+}
 …
     char *ConfigFileName = NULL;
     int j;
     setVerbosity(0);
+    // need to init the history before any action is created
+    ActionHistory::init();
     /* structure of ParseCommandLineOptions will be refactored later */
     j = ParseCommandLineOptions(argc, argv,  World::get()->getMolecules(), World::get()->getPeriode(), *configuration, ConfigFileName);
+    j = ParseCommandLineOptions(argc, argv,  World::getInstance().getMolecules(), World::getInstance().getPeriode(), *configuration, ConfigFileName);
     switch (j){
         case 255:
 …
             break;
+    }
     if(World::get()->numMolecules() == 0){
         mol = World::get()->createMolecule();
         World::get()->getMolecules()->insert(mol);
+    if(World::getInstance().numMolecules() == 0){
+        mol = World::getInstance().createMolecule();
+        World::getInstance().getMolecules()->insert(mol);
         cout << "Molecule created" << endl;
         if(mol->cell_size[0] == 0.){
 …
       UIFactory::makeUserInterface(UIFactory::Text);
       MainWindow *mainWindow = UIFactory::get()->makeMainWindow(populaters,World::get()->getMolecules(), configuration, World::get()->getPeriode(), ConfigFileName);
+      MainWindow *mainWindow = UIFactory::getInstance().makeMainWindow(populaters,World::getInstance().getMolecules(), configuration, World::getInstance().getPeriode(), ConfigFileName);
       mainWindow->display();
       delete mainWindow;
+    }
     if(World::get()->getPeriode()->StorePeriodentafel(configuration->databasepath))
+    if(World::getInstance().getPeriode()->StorePeriodentafel(configuration->databasepath))
         Log() << Verbose(0) << "Saving of elements.db successful." << endl;

src/config.cpp

-              r66e95e
+              rb31bc4
+{
   int MaxTypes = 0;
   element *elementhash[MAX_ELEMENTS];
+  const element *elementhash[MAX_ELEMENTS];
   char name[MAX_ELEMENTS];
   char keyword[MAX_ELEMENTS];
 …
             sprintf(keyword,"%s_%i",name, j+1);
             if (repetition == 0) {
               neues = World::get()->createAtom();
+              neues = World::getInstance().createAtom();
               AtomList[i][j] = neues;
               LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
 …
           sprintf(keyword,"%s_%i",name, j+1);
           if (repetition == 0) {
             neues = World::get()->createAtom();
+            neues = World::getInstance().createAtom();
             AtomList[i][j] = neues;
             LinearList[ FileBuffer->LineMapping[FileBuffer->CurrentLine] ] = neues;
 …
 void config::Load(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
+{
   molecule *mol = World::get()->createMolecule();
+  molecule *mol = World::getInstance().createMolecule();
   ifstream *file = new ifstream(filename);
   if (file == NULL) {
 …
 void config::LoadOld(const char * const filename, const string &BondGraphFileName, const periodentafel * const periode, MoleculeListClass * const &MolList)
+{
   molecule *mol = World::get()->createMolecule();
+  molecule *mol = World::getInstance().createMolecule();
   ifstream *file = new ifstream(filename);
   if (file == NULL) {
 …
   string zeile;
   string dummy;
   element *elementhash[128];
+  const element *elementhash[128];
   int Z = -1;
   int No = -1;
 …
+        }
         istringstream input2(zeile);
         atom *neues = World::get()->createAtom();
+        atom *neues = World::getInstance().createAtom();
         input2 >> neues->x.x[0]; // x
         input2 >> neues->x.x[1]; // y
 …
   char filename[MAXSTRINGSIZE];
   ofstream output;
   molecule *mol = World::get()->createMolecule();
+  molecule *mol = World::getInstance().createMolecule();
   mol->SetNameFromFilename(ConfigFileName);
 …
+  }
   World::get()->destroyMolecule(mol);
+  World::getInstance().destroyMolecule(mol);
 };

src/defs.hpp

-              r66e95e
+              rb31bc4
 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/element.cpp

-              r66e95e
+              rb31bc4
 #include "element.hpp"
+using namespace std;
 /************************************* Functions for class element **********************************/
 …
  * \param *out outstream
  */
 bool element::Output(ofstream * const out) const
+bool element::Output(ostream * const out) const
+{
   if (out != NULL) {
 …
  * \param NoOfAtoms total number of atom of this element type
  */
 bool element::Checkout(ofstream * const out, const int Number, const int NoOfAtoms) const
+bool element::Checkout(ostream * const out, const int Number, const int NoOfAtoms) const
+{
   if (out != NULL) {
 …
     return false;
 };
+atomicNumber_t element::getNumber() const{
+  return Z;
+}
+string element::getSymbol() const{
+  return string(symbol);
+}

src/element.hpp

-              r66e95e
+              rb31bc4
 #define ELEMENT_HPP_
-using namespace std;
 /*********************************************** includes ***********************************/
 …
 #include <iostream>
+#include <string>
 #include "defs.hpp"
+#include "types.hpp"
 /********************************************** declarations *******************************/
 …
   ~element();
+  // accessor functions
+  atomicNumber_t getNumber() const;
+  std::string getSymbol() const;
   //> print element entries to screen
   bool Output(ofstream * const out) const;
   bool Checkout(ofstream * const out, const int No, const int NoOfAtoms) const;
+  bool Output(std::ostream * const out) const;
+  bool Checkout(std::ostream * const out, const int No, const int NoOfAtoms) const;
   private:

src/errorlogger.cpp

-              r66e95e
+              rb31bc4
 #include "errorlogger.hpp"
 #include "verbose.hpp"
+#include "Patterns/Singleton_impl.hpp"
 ofstream null("/dev/null");
-errorLogger* errorLogger::instance = NULL;
 int errorLogger::verbosity = 2;
 ostream* errorLogger::nix = &null;
 …
 errorLogger::errorLogger()
+{
-  instance = NULL;
   verbosity = 2;
 };
 …
+}
+/**
+ * Returns the singleton errorLogger instance.
+ *
+ * \return errorLogger instance
+ */
+errorLogger* errorLogger::getInstance() {
+  if (instance == NULL) {
+    instance = new errorLogger();
+  }
+  return instance;
+}
+/**
+ * Purges the current errorLogger instance.
+ */
+void errorLogger::purgeInstance() {
+  if (instance != NULL) {
+    delete instance;
+  }
+  instance = NULL;
+}
+CONSTRUCT_SINGLETON(errorLogger)
 /**

src/errorlogger.hpp

-              r66e95e
+              rb31bc4
 #include <iostream>
+#include "Patterns/Singleton.hpp"
 using namespace std;
 class Verbose;
+class errorLogger {
+class errorLogger : public Singleton<errorLogger>{
+  friend class Singleton<errorLogger>;
 public :
   static ostream *nix;
   static int verbosity;
-  static errorLogger* getInstance();
-  static void purgeInstance();
   static bool DoOutput();
   static void setVerbosity(int verbosityLevel);
 …
   ~errorLogger();
-private:
-  static errorLogger* instance;
 };

src/helpers.hpp

-              r66e95e
+              rb31bc4
 #define PLURAL_S(v) (((v)==1)?"":"s")
+// this is to allow different modes of access for
+// maps and sets
+template<typename Res,typename T>
+struct _take{
+  Res get(T value) const;
+};
+// if we have a set,vector etc we can directly access the result
+template<typename Res>
+struct _take<Res,Res>{
+  static inline Res get(Res value){
+    return value;
+  }
+};
+// if we have a map we have to access the second part of
+// the pair
+template<typename Res,typename T1>
+struct _take<Res,std::pair<T1,Res> >{
+  static inline Res get(std::pair<T1,Res> value){
+    return value.second;
+  }
+};
 #endif /*HELPERS_HPP_*/

src/leastsquaremin.hpp

r66e95e	rb31bc4
42	42	gsl_vector *x;
43	43	const molecule *mol;
44		element *type;
	44	const element *type;
45	45	};
46	46

src/log.cpp

-              r66e95e
+              rb31bc4
  */
 void setVerbosity(int verbosityLevel) {
   logger::getInstance()->setVerbosity(verbosityLevel);
   errorLogger::getInstance()->setVerbosity(verbosityLevel);
+  logger::getInstance().setVerbosity(verbosityLevel);
+  errorLogger::getInstance().setVerbosity(verbosityLevel);
+}
 …
  * \param indentation level of the message to log
  */
 class logger * Log() {
+class logger& Log() {
   return logger::getInstance();
+}
 …
  * \param indentation level of the message to log
  */
 class errorLogger * eLog() {
+class errorLogger & eLog() {
   return errorLogger::getInstance();
+}

src/logger.cpp

-              r66e95e
+              rb31bc4
 #include "logger.hpp"
 #include "verbose.hpp"
+#include "Patterns/Singleton_impl.hpp"
 ofstream nullStream("/dev/null");
-logger* logger::instance = NULL;
 int logger::verbosity = 2;
 ostream* logger::nix = &nullStream;
 …
 logger::logger()
+{
-  instance = NULL;
   verbosity = 2;
 };
 …
+}
+/**
+ * Returns the singleton logger instance.
+ *
+ * \return logger instance
+ */
+logger* logger::getInstance() {
+  if (instance == NULL) {
+    instance = new logger();
+  }
+  return instance;
+}
+/**
+ * Purges the current logger instance.
+ */
+void logger::purgeInstance() {
+  if (instance != NULL) {
+    delete instance;
+  }
+  instance = NULL;
+}
+CONSTRUCT_SINGLETON(logger)
 /**

src/logger.hpp

-              r66e95e
+              rb31bc4
 #include <iostream>
+#include "Patterns/Singleton.hpp"
 using namespace std;
 class Verbose;
+class logger {
+class logger : public Singleton<logger> {
+  friend class Singleton<logger>;
 public :
   static ostream *nix;
   static int verbosity;
-  static logger* getInstance();
-  static void purgeInstance();
   static bool DoOutput();
   static void setVerbosity(int verbosityLevel);
 …
   /** Do not call this destructor directly, use purgeInstance() instead. */
   ~logger();
-private:
-  static logger* instance;
 };

src/molecule.cpp

-              r66e95e
+              rb31bc4
  * 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(World::get()->createAtom()), end(World::get()->createAtom()),
+molecule::molecule(const periodentafel * const teil) : elemente(teil), start(World::getInstance().createAtom()), end(World::getInstance().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.),
 …
 molecule *NewMolecule(){
   return new molecule(World::get()->getPeriode());
+  return new molecule(World::getInstance().getPeriode());
+}
 …
 std::string molecule::calcFormula(){
   int Counts[MAX_ELEMENTS];
+  std::map<atomicNumber_t,unsigned int> counts;
   stringstream sstr;
+  for (int j = 0; j<MAX_ELEMENTS;j++)
+    Counts[j] = 0;
+  periodentafel *periode = World::getInstance().getPeriode();
   for(atom *Walker = start; Walker != end; Walker = Walker->next) {
+    Counts[Walker->type->Z]++;
+  }
+  for(element* Elemental = elemente->end; Elemental != elemente->start; Elemental = Elemental->previous) {
+    if (Counts[Elemental->Z] != 0)
+      sstr << Elemental->symbol << Counts[Elemental->Z];
+    counts[Walker->type->getNumber()]++;
+  }
+  std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
+  for(iter = counts.rbegin(); iter != counts.rend(); ++iter) {
+    atomicNumber_t Z = (*iter).first;
+    sstr << periode->FindElement(Z)->symbol << (*iter).second;
+  }
   return sstr.str();
 …
   switch(TopBond->BondDegree) {
     case 1:
       FirstOtherAtom = World::get()->createAtom();    // new atom
+      FirstOtherAtom = World::getInstance().createAtom();    // new atom
       FirstOtherAtom->type = elemente->FindElement(1);  // element is Hydrogen
       FirstOtherAtom->v.CopyVector(&TopReplacement->v); // copy velocity
 …
       // create the two Hydrogens ...
       FirstOtherAtom = World::get()->createAtom();
       SecondOtherAtom = World::get()->createAtom();
+      FirstOtherAtom = World::getInstance().createAtom();
+      SecondOtherAtom = World::getInstance().createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
 …
     case 3:
       // take the "usual" tetraoidal angle and add the three Hydrogen in direction of the bond (height of the tetraoid)
       FirstOtherAtom = World::get()->createAtom();
       SecondOtherAtom = World::get()->createAtom();
       ThirdOtherAtom = World::get()->createAtom();
+      FirstOtherAtom = World::getInstance().createAtom();
+      SecondOtherAtom = World::getInstance().createAtom();
+      ThirdOtherAtom = World::getInstance().createAtom();
       FirstOtherAtom->type = elemente->FindElement(1);
       SecondOtherAtom->type = elemente->FindElement(1);
 …
     MDSteps++;
   for(i=0;i<NumberOfAtoms;i++){
     Walker = World::get()->createAtom();
+    Walker = World::getInstance().createAtom();
     getline(xyzfile,line,'\n');
     istringstream *item = new istringstream(line);

src/molecule_dynamics.cpp

-              r66e95e
+              rb31bc4
   bool status = true;
   int MaxSteps = configuration.MaxOuterStep;
   MoleculeListClass *MoleculePerStep = new MoleculeListClass(World::get());
+  MoleculeListClass *MoleculePerStep = new MoleculeListClass(World::getPointer());
   // Get the Permutation Map by MinimiseConstrainedPotential
   atom **PermutationMap = NULL;
 …
   Log() << Verbose(1) << "Filling intermediate " << MaxSteps << " steps with MDSteps of " << MDSteps << "." << endl;
   for (int step = 0; step <= MaxSteps; step++) {
     mol = World::get()->createMolecule();
+    mol = World::getInstance().createMolecule();
     MoleculePerStep->insert(mol);
     Walker = start;

src/molecule_fragmentation.cpp

-              r66e95e
+              rb31bc4
   //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(World::get());
+  BondFragments = new MoleculeListClass(World::getPointer());
   int k=0;
   for(Graph::iterator runner = TotalGraph.begin(); runner != TotalGraph.end(); runner++) {
 …
+{
   atom **SonList = Calloc<atom*>(AtomCount, "molecule::StoreFragmentFromStack: **SonList");
   molecule *Leaf = World::get()->createMolecule();
+  molecule *Leaf = World::getInstance().createMolecule();
 //  Log() << Verbose(1) << "Begin of StoreFragmentFromKeyset." << endl;

src/moleculelist.cpp

-              r66e95e
+              rb31bc4
 void MoleculeListClass::Enumerate(ostream *out)
+{
-  element* Elemental = NULL;
   atom *Walker = NULL;
+  int Counts[MAX_ELEMENTS];
+  periodentafel *periode = World::getInstance().getPeriode();
+  std::map<atomicNumber_t,unsigned int> counts;
   double size=0;
   Vector Origin;
 …
     Origin.Zero();
     for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
-      // reset element counts
-      for (int j = 0; j<MAX_ELEMENTS;j++)
-        Counts[j] = 0;
       // count atoms per element and determine size of bounding sphere
       size=0.;
 …
       while (Walker->next != (*ListRunner)->end) {
         Walker = Walker->next;
         Counts[Walker->type->Z]++;
+        counts[Walker->type->getNumber()]++;
         if (Walker->x.DistanceSquared(&Origin) > size)
           size = Walker->x.DistanceSquared(&Origin);
 …
       // output Index, Name, number of atoms, chemical formula
       (*out) << ((*ListRunner)->ActiveFlag ? "*" : " ") << (*ListRunner)->IndexNr << "\t" << (*ListRunner)->name << "\t\t" << (*ListRunner)->AtomCount << "\t";
+      Elemental = (*ListRunner)->elemente->end;
       while(Elemental->previous != (*ListRunner)->elemente->start) {
         Elemental = Elemental->previous;
         if (Counts[Elemental->Z] != 0)
           (*out) << Elemental->symbol << Counts[Elemental->Z];
+      std::map<atomicNumber_t,unsigned int>::reverse_iterator iter;
+      for(iter=counts.rbegin(); iter!=counts.rend();++iter){
+        atomicNumber_t Z =(*iter).first;
+        (*out) << periode->FindElement(Z)->getSymbol() << (*iter).second;
+      }
       // Center and size
 …
   // remove src
   ListOfMolecules.remove(srcmol);
   World::get()->destroyMolecule(srcmol);
+  World::getInstance().destroyMolecule(srcmol);
   return true;
 };
 …
   stringstream line;
   atom *Walker = NULL;
   element *runner = NULL;
+  periodentafel *periode=World::getInstance().getPeriode();
   // open file for the force factors
 …
     //output << prefix << "Forces" << endl;
     for (MoleculeList::iterator ListRunner = ListOfMolecules.begin(); ListRunner != ListOfMolecules.end(); ListRunner++) {
+      runner = (*ListRunner)->elemente->start;
+      while (runner->next != (*ListRunner)->elemente->end) { // go through every element
+        runner = runner->next;
+        if ((*ListRunner)->ElementsInMolecule[runner->Z]) { // if this element got atoms
+      periodentafel::const_iterator elemIter;
+      for(elemIter=periode->begin();elemIter!=periode->end();++elemIter){
+          if ((*ListRunner)->ElementsInMolecule[(*elemIter).first]) { // if this element got atoms
           Walker = (*ListRunner)->start;
           while (Walker->next != (*ListRunner)->end) { // go through every atom of this element
             Walker = Walker->next;
             if (Walker->type->Z == runner->Z) {
+            if (Walker->type->getNumber() == (*elemIter).first) {
               if ((Walker->GetTrueFather() != NULL) && (Walker->GetTrueFather() != Walker)) {// if there is a rea
                 //Log() << Verbose(0) << "Walker is " << *Walker << " with true father " << *( Walker->GetTrueFather()) << ", it
 …
 void MoleculeListClass::DissectMoleculeIntoConnectedSubgraphs(const periodentafel * const periode, config * const configuration)
+{
   molecule *mol = World::get()->createMolecule();
+  molecule *mol = World::getInstance().createMolecule();
   atom *Walker = NULL;
   atom *Advancer = NULL;
 …
+    }
     // remove the molecule
     World::get()->destroyMolecule(*MolRunner);
+    World::getInstance().destroyMolecule(*MolRunner);
     ListOfMolecules.erase(MolRunner);
+  }
 …
   molecule **molecules = Malloc<molecule *>(MolCount, "config::Load() - **molecules");
   for (int i=0;i<MolCount;i++) {
     molecules[i] = World::get()->createMolecule();
+    molecules[i] = World::getInstance().createMolecule();
     molecules[i]->ActiveFlag = true;
     strncpy(molecules[i]->name, mol->name, MAXSTRINGSIZE);
 …
   OBSERVE;
   molecule *mol = NULL;
   mol = World::get()->createMolecule();
+  mol = World::getInstance().createMolecule();
   insert(mol);
 };
 …
   char filename[MAXSTRINGSIZE];
   Log() << Verbose(0) << "Format should be XYZ with: ShorthandOfElement\tX\tY\tZ" << endl;
   mol = World::get()->createMolecule();
+  mol = World::getInstance().createMolecule();
   do {
     Log() << Verbose(0) << "Enter file name: ";
 …
       mol = *ListRunner;
       ListOfMolecules.erase(ListRunner);
       World::get()->destroyMolecule(mol);
+      World::getInstance().destroyMolecule(mol);
       break;
+    }
 …
   // remove the leaf itself
   if (Leaf != NULL) {
     World::get()->destroyMolecule(Leaf);
+    World::getInstance().destroyMolecule(Leaf);
     Leaf = NULL;
+  }

src/periodentafel.cpp

-              r66e95e
+              rb31bc4
 #include <fstream>
 #include <cstring>
+#include <cassert>
 #include "element.hpp"
 …
 #include "verbose.hpp"
+using namespace std;
 /************************************* Functions for class periodentafel ***************************/
 …
  * Initialises start and end of list and resets periodentafel::checkliste to false.
  */
+periodentafel::periodentafel() : start(new element), end(new element)
+{
+  start->previous = NULL;
+  start->next = end;
+  end->previous = start;
+  end->next = NULL;
+};
+periodentafel::periodentafel()
+{};
 /** destructor for class periodentafel
 …
+{
   CleanupPeriodtable();
-  delete(end);
-  delete(start);
 };
 …
  * \return true - succeeded, false - does not occur
  */
+bool periodentafel::AddElement(element * const pointer)
+{
+periodentafel::iterator periodentafel::AddElement(element * const pointer)
+{
+  atomicNumber_t Z = pointer->getNumber();
+  assert(!elements.count(Z));
   pointer->sort = &pointer->Z;
   if (pointer->Z < 1 && pointer->Z >= MAX_ELEMENTS)
+  if (pointer->getNumber() < 1 && pointer->getNumber() >= MAX_ELEMENTS)
     Log() << Verbose(0) << "Invalid Z number!\n";
+  return add(pointer, end);
+  pair<iterator,bool> res = elements.insert(pair<atomicNumber_t,element*>(Z,pointer));
+  return res.first;
 };
 …
  * \return true - succeeded, false - element not found
  */
+bool periodentafel::RemoveElement(element * const pointer)
+{
+  return remove(pointer, start, end);
+void periodentafel::RemoveElement(element * const pointer)
+{
+  atomicNumber_t Z = pointer->getNumber();
+  elements.erase(Z);
 };
 …
  * \return true - succeeded, false - does not occur
  */
+bool periodentafel::CleanupPeriodtable()
+{
+  return cleanup(start,end);
+void periodentafel::CleanupPeriodtable()
+{
+  for(iterator iter=elements.begin();iter!=elements.end();++iter){
+    delete(*iter).second;
+  }
+  elements.clear();
 };
 …
  * \return pointer to element or NULL if not found
  */
 element * const periodentafel::FindElement(const int Z) const
+{
   element *walker = find(&Z, start,end);
   return(walker);
+const element * periodentafel::FindElement(atomicNumber_t Z) const
+{
+  const_iterator res = elements.find(Z);
+  return res!=elements.end()?((*res).second):0;
 };
 …
  * \return pointer to element
  */
+element * const periodentafel::FindElement(const char * const shorthand) const
+{
+  element *walker =  periodentafel::start;
+  while (walker->next != periodentafel::end) {
+    walker = walker->next;
+    if (strncmp(walker->symbol, shorthand, 3) == 0)
+      return(walker);
+  }
+  return (NULL);
+const element * periodentafel::FindElement(const char * const shorthand) const
+{
+  element *res = 0;
+  for(const_iterator iter=elements.begin();iter!=elements.end();++iter) {
+    if((*iter).second->getSymbol() == shorthand){
+      res = (*iter).second;
+      break;
+    }
+  }
+  return res;
 };
 /** Asks for element number and returns pointer to element
  */
 element * const periodentafel::AskElement() const
+{
   element *walker = NULL;
+const element * periodentafel::AskElement() const
+{
+  const element *walker = NULL;
   int Z;
   do {
 …
  * \return pointer to either present or newly created element
  */
 element * const periodentafel::EnterElement()
+{
   element *walker = NULL;
   int Z = -1;
+const element * periodentafel::EnterElement()
+{
+  const element *res = NULL;
+  atomicNumber_t Z = 0;
   Log() << Verbose(0) << "Atomic number: " << Z << endl;
   cin >> Z;
+  walker = FindElement(Z);
+  if (walker == NULL) {
+  res = FindElement(Z);
+  if (!res) {
+    // TODO: make this using the constructor
+    element *tmp;
     Log() << Verbose(0) << "Element not found in database, please enter." << endl;
     walker = new element;
     walker->Z = Z;
+    tmp = new element;
+    tmp->Z = Z;
     Log() << Verbose(0) << "Mass: " << endl;
     cin >> walker->mass;
+    cin >> tmp->mass;
     Log() << Verbose(0) << "Name [max 64 chars]: " << endl;
     cin >> walker->name;
+    cin >> tmp->name;
     Log() << Verbose(0) << "Short form [max 3 chars]: " << endl;
+    cin >> walker->symbol;
+    periodentafel::AddElement(walker);
+  }
+  return(walker);
+};
+    cin >> tmp->symbol;
+    AddElement(tmp);
+    res = tmp;
+  }
+  return res;
+};
+/******************** Access to iterators ****************************/
+periodentafel::const_iterator periodentafel::begin(){
+  return elements.begin();
+}
+periodentafel::const_iterator periodentafel::end(){
+  return elements.end();
+}
+periodentafel::reverse_iterator periodentafel::rbegin(){
+  return reverse_iterator(elements.end());
+}
+periodentafel::reverse_iterator periodentafel::rend(){
+  return reverse_iterator(elements.begin());
+}
 /** Prints period table to given stream.
  * \param output stream
  */
 bool periodentafel::Output(ofstream * const output) const
+bool periodentafel::Output(ostream * const output) const
+{
   bool result = true;
-  element *walker = start;
   if (output != NULL) {
+    while (walker->next != end) {
+      walker = walker->next;
+      result = result && walker->Output(output);
+    for(const_iterator iter=elements.begin(); iter !=elements.end();++iter){
+      result = result && (*iter).second->Output(output);
+    }
     return result;
 …
  * \param *checkliste elements table for this molecule
  */
+bool periodentafel::Checkout(ofstream * const output, const int * const checkliste) const
+{
+  element *walker = start;
+bool periodentafel::Checkout(ostream * const output, const int * const checkliste) const
+{
   bool result = true;
   int No = 1;
 …
     *output << "# Ion type data (PP = PseudoPotential, Z = atomic number)" << endl;
     *output << "#Ion_TypeNr.\tAmount\tZ\tRGauss\tL_Max(PP)L_Loc(PP)IonMass\t# chemical name, symbol" << endl;
+    while (walker->next != end) {
+      walker = walker->next;
+      if ((walker != NULL) && (walker->Z > 0) && (walker->Z < MAX_ELEMENTS) && (checkliste[walker->Z])) {
+        walker->No = No;
+        result = result && walker->Checkout(output, No++, checkliste[walker->Z]);
+    for(const_iterator iter=elements.begin(); iter!=elements.end();++iter){
+      if (((*iter).first < MAX_ELEMENTS) && (checkliste[(*iter).first])) {
+        (*iter).second->No = No;
+        result = result && (*iter).second->Checkout(output, No++, checkliste[(*iter).first]);
+      }
+    }
 …
+{
   ifstream infile;
-  double tmp;
   element *ptr;
+  map<atomicNumber_t,element*> parsedElems;
   bool status = true;
   bool otherstatus = true;
 …
       //neues->Output((ofstream *)&cout);
       if ((neues->Z > 0) && (neues->Z < MAX_ELEMENTS))
         periodentafel::AddElement(neues);
+        parsedElems[neues->getNumber()] = neues;
       else {
         Log() << Verbose(0) << "Could not parse element: ";
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      infile >> ws;
+      infile >> FindElement((int)tmp)->Valence;
+      atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->Valence;
       infile >> ws;
       //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->Valence << " valence electrons." << endl;
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      infile >> ws;
+      infile >> FindElement((int)tmp)->NoValenceOrbitals;
+      atomicNumber_t Z;
+      infile >> Z;
+      infile >> ws;
+      infile >> parsedElems[Z]->NoValenceOrbitals;
       infile >> ws;
       //Log() << Verbose(3) << "Element " << (int)tmp << " has " << FindElement((int)tmp)->NoValenceOrbitals << " number of singly occupied valence orbitals." << endl;
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      ptr = FindElement((int)tmp);
+      atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
       infile >> ws;
       infile >> ptr->HBondDistance[0];
 …
   if (infile != NULL) {
     while (!infile.eof()) {
+      infile >> tmp;
+      ptr = FindElement((int)tmp);
+      atomicNumber_t Z;
+      infile >> Z;
+      ptr = parsedElems[Z];
       infile >> ws;
       infile >> ptr->HBondAngle[0];
 …
     otherstatus = false;
+  if (!otherstatus)
+  if (otherstatus){
+    map<atomicNumber_t,element*>::iterator iter;
+    for(iter=parsedElems.begin();iter!=parsedElems.end();++iter){
+      AddElement((*iter).second);
+    }
+  }
+  else{
     eLog() << Verbose(2) << "Something went wrong while parsing the other databases!" << endl;
+    map<atomicNumber_t,element*>::iterator iter;
+    for(iter=parsedElems.begin();iter!=parsedElems.end();++iter){
+      AddElement((*iter).second);
+    }
+  }
   return status;
 …
     f << header1 << endl;
     f << header2 << endl;
+    element *walker = periodentafel::start;
+    while (walker->next != periodentafel::end) {
+      walker = walker->next;
+      result = result && walker->Output(&f);
+    for(const_iterator iter=elements.begin();iter!=elements.end();++iter){
+         result = result && (*iter).second->Output(&f);
+    }
     f.close();

src/periodentafel.hpp

-              r66e95e
+              rb31bc4
 #ifndef PERIODENTAFEL_HPP_
 #define PERIODENTAFEL_HPP_
-using namespace std;
 /*********************************************** includes ***********************************/
 …
 #include <iostream>
+#include <map>
+#include <iterator>
 #include "defs.hpp"
+#include "types.hpp"
 /****************************************** forward declarations *****************************/
 …
  */
 class periodentafel {
+  /******* Types *********/
+  private:
+    typedef std::map<atomicNumber_t,element*> elementSet;
   public:
+    element *start; //!< start of element list
+    element *end;   //!< end of element list
+    typedef elementSet::iterator iterator;
+    typedef elementSet::const_iterator const_iterator;
+    typedef std::reverse_iterator<const_iterator> reverse_iterator;
+  public:
     char header1[MAXSTRINGSIZE]; //!< store first header line
     char header2[MAXSTRINGSIZE]; //!< store second header line
 …
   ~periodentafel();
+  bool AddElement(element * const pointer);
+  bool RemoveElement(element * const pointer);
+  bool CleanupPeriodtable();
+  element * const FindElement(const int Z) const;
+  element * const FindElement(const char * const shorthand) const;
+  element * const AskElement() const;
+  element * const EnterElement();
+  bool Output(ofstream * const output) const;
+  bool Checkout(ofstream * const output, const int * const checkliste) const;
+  iterator AddElement(element * const pointer);
+  void RemoveElement(element * const pointer);
+  void CleanupPeriodtable();
+  const element *FindElement(atomicNumber_t) const;
+  const element *FindElement(const char * const shorthand) const;
+  const element *AskElement() const;
+  const element *EnterElement();
+  const_iterator begin();
+  const_iterator end();
+  reverse_iterator rbegin();
+  reverse_iterator rend();
+  bool Output(std::ostream * const output) const;
+  bool Checkout(std::ostream * const output, const int * const checkliste) const;
   bool LoadPeriodentafel(const char * const path);
   bool StorePeriodentafel(const char * const path) const;
   private:
+    elementSet elements;
 };

src/unittests/ActionSequenceTest.cpp

-              r66e95e
+              rb31bc4
   virtual ~canUndoActionStub(){}
+  virtual void call(){}
+  virtual void undo(){}
+  virtual Action::state_ptr performCall(){
+    return Action::success;
+  }
+  virtual Action::state_ptr performUndo(Action::state_ptr){
+    return Action::success;
+  }
+  virtual Action::state_ptr performRedo(Action::state_ptr){
+    return Action::success;
+  }
   virtual bool canUndo(){
+    return true;
+  }
+  virtual bool shouldUndo(){
     return true;
+  }
 …
   virtual ~cannotUndoActionStub(){}
+  virtual void call(){}
+  virtual void undo(){}
+  virtual Action::state_ptr performCall(){
+    return Action::success;
+  }
+  virtual Action::state_ptr performUndo(Action::state_ptr){
+    return Action::success;
+  }
+  virtual Action::state_ptr performRedo(Action::state_ptr){
+    return Action::success;
+  }
   virtual bool canUndo(){
     return false;
+  }
+  virtual bool shouldUndo(){
+   return true;
+  }
 };
 …
   virtual ~wasCalledActionStub(){}
   virtual void call(){
+  virtual Action::state_ptr performCall(){
     called = true;
+  }
+  virtual void undo(){
+    return Action::success;
+  }
+  virtual Action::state_ptr performUndo(Action::state_ptr){
     called = false;
+    return Action::success;
+  }
+  virtual Action::state_ptr performRedo(Action::state_ptr){
+    called = true;
+    return Action::success;
+  }
   virtual bool canUndo(){
+    return true;
+  }
+  virtual bool shouldUndo(){
     return true;
+  }
 …
   sequence->addAction(shouldCall2);
   sequence->callAll();
   sequence->removeLastAction();
   sequence->removeLastAction();
   sequence->undoAll();
+  ActionSequence::stateSet states = sequence->callAll();
+  sequence->removeLastAction();
+  sequence->removeLastAction();
+  sequence->undoAll(states);
   CPPUNIT_ASSERT_EQUAL(true,shouldCall1->wasCalled());

src/unittests/AnalysisCorrelationToPointUnitTest.cpp

-              r66e95e
+              rb31bc4
   // construct periodentafel
   tafel = World::get()->getPeriode();
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::get()->createMolecule();
   Walker = World::get()->createAtom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
   TestList = World::get()->getMolecules();
+  TestList = World::getInstance().getMolecules();
   TestMolecule->ActiveFlag = true;
   TestList->insert(TestMolecule);
 …
   delete(point);
   World::destroy();
+  World::purgeInstance();
   MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();

src/unittests/AnalysisCorrelationToSurfaceUnitTest.cpp

-              r66e95e
+              rb31bc4
 #include "World.hpp"
+#include "Helpers/Assert.hpp"
 #ifdef HAVE_TESTRUNNER
 #include "UnitTestMain.hpp"
 …
 void AnalysisCorrelationToSurfaceUnitTest::setUp()
+{
+  ASSERT_DO(Assert::Throw);
   atom *Walker = NULL;
 …
   // construct periodentafel
   tafel = World::get()->getPeriode();
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
   // construct molecule (tetraeder of hydrogens) base
   TestMolecule = World::get()->createMolecule();
   Walker = World::get()->createAtom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
   TestList = World::get()->getMolecules();
+  TestList = World::getInstance().getMolecules();
   TestMolecule->ActiveFlag = true;
   TestList->insert(TestMolecule);
 …
   // add outer atoms
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 0., 4. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0., 4., 4. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(4., 4., 0. );
   TestMolecule->AddAtom(Walker);
   // add inner atoms
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );
 …
   // note that all the atoms are cleaned by TestMolecule
   delete(LC);
   World::destroy();
+  World::purgeInstance();
   MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();

src/unittests/AnalysisPairCorrelationUnitTest.cpp

-              r66e95e
+              rb31bc4
   // construct periodentafel
   tafel = World::get()->getPeriode();
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::get()->createMolecule();
   Walker = World::get()->createAtom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
   CPPUNIT_ASSERT_EQUAL( TestMolecule->AtomCount, 4 );
   TestList = World::get()->getMolecules();
+  TestList = World::getInstance().getMolecules();
   TestMolecule->ActiveFlag = true;
   TestList->insert(TestMolecule);
 …
   // note that all the atoms are cleaned by TestMolecule
   World::destroy();
+  World::purgeInstance();
   MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();

src/unittests/AtomDescriptorTest.cpp

-              r66e95e
+              rb31bc4
 // set up and tear down
 void AtomDescriptorTest::setUp(){
   World::get();
+  World::getInstance();
   for(int i=0;i<ATOM_COUNT;++i){
     atoms[i]= World::get()->createAtom();
+    atoms[i]= World::getInstance().createAtom();
     atomIds[i]= atoms[i]->getId();
+  }
 …
 void AtomDescriptorTest::tearDown(){
   World::destroy();
+  World::purgeInstance();
+}
 …
 void AtomDescriptorTest::AtomBaseSetsTest(){
   std::vector<atom*> allAtoms = World::get()->getAllAtoms(AllAtoms());
+  std::vector<atom*> allAtoms = World::getInstance().getAllAtoms(AllAtoms());
   CPPUNIT_ASSERT_EQUAL( true , hasAllAtoms(allAtoms,atomIds));
   CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateAtoms(allAtoms));
   std::vector<atom*> noAtoms = World::get()->getAllAtoms(NoAtoms());
+  std::vector<atom*> noAtoms = World::getInstance().getAllAtoms(NoAtoms());
   CPPUNIT_ASSERT_EQUAL( true , noAtoms.empty());
+}
 …
   // test Atoms from boundaries and middle of the set
   atom* testAtom;
   testAtom = World::get()->getAtom(AtomById(atomIds[0]));
+  testAtom = World::getInstance().getAtom(AtomById(atomIds[0]));
   CPPUNIT_ASSERT(testAtom);
   CPPUNIT_ASSERT_EQUAL( atomIds[0], testAtom->getId());
   testAtom = World::get()->getAtom(AtomById(atomIds[ATOM_COUNT/2]));
+  testAtom = World::getInstance().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]));
+  testAtom = World::getInstance().getAtom(AtomById(atomIds[ATOM_COUNT-1]));
   CPPUNIT_ASSERT(testAtom);
   CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT-1], testAtom->getId());
 …
+  }
   // test from outside of set
   testAtom = World::get()->getAtom(AtomById(outsideId));
+  testAtom = World::getInstance().getAtom(AtomById(outsideId));
   CPPUNIT_ASSERT(!testAtom);
+}
 …
   // test some elementary set operations
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()||NoAtoms());
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(AllAtoms()||NoAtoms());
     CPPUNIT_ASSERT_EQUAL( true , hasAllAtoms(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateAtoms(testAtoms));
 …
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||AllAtoms());
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(NoAtoms()||AllAtoms());
     CPPUNIT_ASSERT_EQUAL( true , hasAllAtoms(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateAtoms(testAtoms));
 …
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()&&AllAtoms());
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(NoAtoms()&&AllAtoms());
     CPPUNIT_ASSERT_EQUAL( true , testAtoms.empty());
+  }
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&NoAtoms());
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(AllAtoms()&&NoAtoms());
     CPPUNIT_ASSERT_EQUAL( true , testAtoms.empty());
+  }
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(!AllAtoms());
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(!AllAtoms());
     CPPUNIT_ASSERT_EQUAL( true , testAtoms.empty());
+  }
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(!NoAtoms());
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(!NoAtoms());
     CPPUNIT_ASSERT_EQUAL( true , hasAllAtoms(testAtoms,atomIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateAtoms(testAtoms));
+  }
   // exclude and include some atoms
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(AllAtoms()&&(!AtomById(atomIds[ATOM_COUNT/2])));
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(AllAtoms()&&(!AtomById(atomIds[ATOM_COUNT/2])));
     std::set<atomId_t> excluded;
     excluded.insert(atomIds[ATOM_COUNT/2]);
 …
+  {
     std::vector<atom*> testAtoms = World::get()->getAllAtoms(NoAtoms()||(AtomById(atomIds[ATOM_COUNT/2])));
+    std::vector<atom*> testAtoms = World::getInstance().getAllAtoms(NoAtoms()||(AtomById(atomIds[ATOM_COUNT/2])));
     CPPUNIT_ASSERT_EQUAL( (size_t)1, testAtoms.size());
     CPPUNIT_ASSERT_EQUAL( atomIds[ATOM_COUNT/2], testAtoms[0]->getId());

src/unittests/AtomDescriptorTest.hpp

r66e95e	rb31bc4
11	11	#include <cppunit/extensions/HelperMacros.h>
12	12
13		#include "~~def~~s.hpp"
	13	#include "types.hpp"
14	14
15	15	#define ATOM_COUNT (10)

src/unittests/CacheableTest.cpp

-              r66e95e
+              rb31bc4
 class threeNumbers : public Observable {
 public:
-  bool hasRecalced;
   int x;
   int y;
   int z;
+  Cacheable<int> sum;
+  bool hasRecalced;
   void setX(int _x){
 …
   threeNumbers(int _x,int _y, int _z) :
+    x(_x),y(_y),z(_z),
     sum(this,boost::bind(&threeNumbers::calcSum,this)),
-    x(_x),y(_y),z(_z),
     hasRecalced(false)
   {}
-  Cacheable<int> sum;
 };

src/unittests/Makefile.am

-              r66e95e
+              rb31bc4
   MoleculeDescriptorTest \
   ObserverTest \
+  SingletonTest \
   StackClassUnitTest \
   TesselationUnitTest \
 …
   MoleculeDescriptorTest.cpp \
   ObserverTest.cpp \
+  SingletonTest.cpp \
   stackclassunittest.cpp \
   tesselationunittest.cpp \
 …
 AnalysisPairCorrelationUnitTest_SOURCES = UnitTestMain.cpp analysis_correlation.hpp AnalysisPairCorrelationUnitTest.cpp AnalysisPairCorrelationUnitTest.hpp
 AnalysisPairCorrelationUnitTest_LDADD = ${ALLLIBS}
+atomsCalculationTest_SOURCES = UnitTestMain.cpp atomsCalculationTest.cpp atomsCalculationTest.hpp
+atomsCalculationTest_LDADD = ${ALLLIBS}
 BondGraphUnitTest_SOURCES = UnitTestMain.cpp bondgraphunittest.cpp bondgraphunittest.hpp
 …
 MoleculeDescriptorTest_LDADD = ${ALLLIBS}
+SingletonTest_SOURCES = UnitTestMain.cpp SingletonTest.cpp SingletonTest.hpp
+SingletonTest_LDADD = $(BOOST_LIB) ${BOOST_THREAD_LIB}
 StackClassUnitTest_SOURCES = UnitTestMain.cpp stackclassunittest.cpp stackclassunittest.hpp
 StackClassUnitTest_LDADD = ${ALLLIBS}
 …
 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/MoleculeDescriptorTest.cpp

-              r66e95e
+              rb31bc4
 // set up and tear down
 void MoleculeDescriptorTest::setUp(){
   World::get();
+  World::getInstance();
   for(int i=0;i<MOLECULE_COUNT;++i){
     molecules[i]= World::get()->createMolecule();
+    molecules[i]= World::getInstance().createMolecule();
     moleculeIds[i]= molecules[i]->getId();
+  }
 …
 void MoleculeDescriptorTest::tearDown(){
   World::destroy();
+  World::purgeInstance();
+}
 …
 void MoleculeDescriptorTest::MoleculeBaseSetsTest(){
   std::vector<molecule*> allMolecules = World::get()->getAllMolecules(AllMolecules());
+  std::vector<molecule*> allMolecules = World::getInstance().getAllMolecules(AllMolecules());
   CPPUNIT_ASSERT_EQUAL( true , hasAllMolecules(allMolecules,moleculeIds));
   CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateMolecules(allMolecules));
   std::vector<molecule*> noMolecules = World::get()->getAllMolecules(NoMolecules());
+  std::vector<molecule*> noMolecules = World::getInstance().getAllMolecules(NoMolecules());
   CPPUNIT_ASSERT_EQUAL( true , noMolecules.empty());
+}
 …
   // test Molecules from boundaries and middle of the set
   molecule* testMolecule;
   testMolecule = World::get()->getMolecule(MoleculeById(moleculeIds[0]));
+  testMolecule = World::getInstance().getMolecule(MoleculeById(moleculeIds[0]));
   CPPUNIT_ASSERT(testMolecule);
   CPPUNIT_ASSERT_EQUAL( moleculeIds[0], testMolecule->getId());
   testMolecule = World::get()->getMolecule(MoleculeById(moleculeIds[MOLECULE_COUNT/2]));
+  testMolecule = World::getInstance().getMolecule(MoleculeById(moleculeIds[MOLECULE_COUNT/2]));
   CPPUNIT_ASSERT(testMolecule);
   CPPUNIT_ASSERT_EQUAL( moleculeIds[MOLECULE_COUNT/2], testMolecule->getId());
   testMolecule = World::get()->getMolecule(MoleculeById(moleculeIds[MOLECULE_COUNT-1]));
+  testMolecule = World::getInstance().getMolecule(MoleculeById(moleculeIds[MOLECULE_COUNT-1]));
   CPPUNIT_ASSERT(testMolecule);
   CPPUNIT_ASSERT_EQUAL( moleculeIds[MOLECULE_COUNT-1], testMolecule->getId());
 …
+  }
   // test from outside of set
   testMolecule = World::get()->getMolecule(MoleculeById(outsideId));
+  testMolecule = World::getInstance().getMolecule(MoleculeById(outsideId));
   CPPUNIT_ASSERT(!testMolecule);
+}
 …
   // test some elementary set operations
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(AllMolecules()||NoMolecules());
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(AllMolecules()||NoMolecules());
     CPPUNIT_ASSERT_EQUAL( true , hasAllMolecules(testMolecules,moleculeIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateMolecules(testMolecules));
 …
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(NoMolecules()||AllMolecules());
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(NoMolecules()||AllMolecules());
     CPPUNIT_ASSERT_EQUAL( true , hasAllMolecules(testMolecules,moleculeIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateMolecules(testMolecules));
 …
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(NoMolecules()&&AllMolecules());
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(NoMolecules()&&AllMolecules());
     CPPUNIT_ASSERT_EQUAL( true , testMolecules.empty());
+  }
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(AllMolecules()&&NoMolecules());
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(AllMolecules()&&NoMolecules());
     CPPUNIT_ASSERT_EQUAL( true , testMolecules.empty());
+  }
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(!AllMolecules());
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(!AllMolecules());
     CPPUNIT_ASSERT_EQUAL( true , testMolecules.empty());
+  }
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(!NoMolecules());
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(!NoMolecules());
     CPPUNIT_ASSERT_EQUAL( true , hasAllMolecules(testMolecules,moleculeIds));
     CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateMolecules(testMolecules));
 …
   // exclude and include some molecules
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(AllMolecules()&&(!MoleculeById(moleculeIds[MOLECULE_COUNT/2])));
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(AllMolecules()&&(!MoleculeById(moleculeIds[MOLECULE_COUNT/2])));
     std::set<moleculeId_t> excluded;
     excluded.insert(moleculeIds[MOLECULE_COUNT/2]);
 …
+  {
     std::vector<molecule*> testMolecules = World::get()->getAllMolecules(NoMolecules()||(MoleculeById(moleculeIds[MOLECULE_COUNT/2])));
+    std::vector<molecule*> testMolecules = World::getInstance().getAllMolecules(NoMolecules()||(MoleculeById(moleculeIds[MOLECULE_COUNT/2])));
     CPPUNIT_ASSERT_EQUAL( (size_t)1, testMolecules.size());
     CPPUNIT_ASSERT_EQUAL( moleculeIds[MOLECULE_COUNT/2], testMolecules[0]->getId());

src/unittests/MoleculeDescriptorTest.hpp

r66e95e	rb31bc4
11	11	#include <cppunit/extensions/HelperMacros.h>
12	12
13		#include "~~def~~s.hpp"
	13	#include "types.hpp"
14	14
15	15	#define MOLECULE_COUNT (10)

src/unittests/ObserverTest.cpp

-              r66e95e
+              rb31bc4
 #include "Patterns/Observer.hpp"
+#include "Helpers/Assert.hpp"
 #include <iostream>
 …
 };
+class BlockObservable : public Observable {
+public:
+  void changeMethod1(){
+    OBSERVE;
+    // test if we report correctly as blocked
+    CPPUNIT_ASSERT(isBlocked());
+  }
+  void changeMethod2(){
+    OBSERVE;
+    internalMethod1();
+    internalMethod2();
+  }
+  void internalMethod1(){
+    // we did not block, but our caller did...
+    // see if this is found
+    CPPUNIT_ASSERT(isBlocked());
+  }
+  void internalMethod2(){
+    OBSERVE;
+    // Both this method and the caller do block
+    // Does the reporting still work as expected?
+    CPPUNIT_ASSERT(isBlocked());
+  }
+  void noChangeMethod(){
+    // No Block introduced here
+    // reported correctely?
+    CPPUNIT_ASSERT(!isBlocked());
+  }
+};
 class SuperObservable : public Observable {
 public:
 …
 void ObserverTest::setUp() {
+  ASSERT_DO(Assert::Throw);
   simpleObservable1 = new SimpleObservable();
   simpleObservable2 = new SimpleObservable();
   callObservable = new CallObservable();
   superObservable = new SuperObservable();
+  blockObservable = new BlockObservable();
   observer1 = new UpdateCountObserver();
 …
+}
+void ObserverTest::doesReportTest(){
+  // Actual checks are in the Stub-methods for this
+  blockObservable->changeMethod1();
+  blockObservable->changeMethod2();
+  blockObservable->noChangeMethod();
+}
 void ObserverTest::CircleDetectionTest() {
 …
   // make this Observable its own subject. NEVER DO THIS IN ACTUAL CODE
   simpleObservable1->signOn(simpleObservable1);
   simpleObservable1->changeMethod();
+  CPPUNIT_ASSERT_THROW(simpleObservable1->changeMethod(),Assert::AssertionFailure);
   // more complex test
 …
   simpleObservable1->signOn(simpleObservable2);
   simpleObservable2->signOn(simpleObservable1);
   simpleObservable1->changeMethod();
+  CPPUNIT_ASSERT_THROW(simpleObservable1->changeMethod(),Assert::AssertionFailure);
   simpleObservable1->signOff(simpleObservable2);
   simpleObservable2->signOff(simpleObservable1);

src/unittests/ObserverTest.hpp

-              r66e95e
+              rb31bc4
 class CallObservable;
 class SuperObservable;
+class BlockObservable;
 …
   CPPUNIT_TEST ( doesBlockUpdateTest );
   CPPUNIT_TEST ( doesSubObservableTest );
+  CPPUNIT_TEST ( doesReportTest );
   CPPUNIT_TEST ( CircleDetectionTest );
   CPPUNIT_TEST_SUITE_END();
 …
   void doesBlockUpdateTest();
   void doesSubObservableTest();
+  void doesReportTest();
   void CircleDetectionTest();
 …
   SimpleObservable *simpleObservable2;
   CallObservable *callObservable;
+  BlockObservable *blockObservable;
   SuperObservable *superObservable;
 };

src/unittests/analysisbondsunittest.cpp

-              r66e95e
+              rb31bc4
   strcpy(hydrogen->symbol, "H");
   carbon = new element;
   carbon->Z = 1;
+  carbon->Z = 2;
   carbon->Valence = 4;
   carbon->NoValenceOrbitals = 4;
 …
   // construct periodentafel
   tafel = World::get()->getPeriode();
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::get()->createMolecule();
   Walker = World::get()->createAtom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 0., 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1.5, 1.5 );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1.5, 1.5, 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = carbon;
   Walker->node->Init(0.5, 0.5, 0.5 );
 …
   // remove molecule
   World::get()->destroyMolecule(TestMolecule);
+  World::getInstance().destroyMolecule(TestMolecule);
   // note that all the atoms are cleaned by TestMolecule
   World::destroy();
+  World::purgeInstance();
 };

src/unittests/atomsCalculationTest.cpp

-              r66e95e
+              rb31bc4
 #include "atom.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 // Registers the fixture into the 'registry'
 CPPUNIT_TEST_SUITE_REGISTRATION( atomsCalculationTest );
-// some stubs
-class AtomStub : public atom {
-public:
-  AtomStub(atomId_t _id) :
-  atom(),
-  id(_id),
-  manipulated(false)
-  {}
-  virtual atomId_t getId(){
-    return id;
+  }
-  virtual void doSomething(){
-    manipulated = true;
+  }
-  bool manipulated;
-private:
-  atomId_t id;
-};
 // set up and tear down
 void atomsCalculationTest::setUp(){
   World::get();
+  World::getInstance();
   for(int i=0;i<ATOM_COUNT;++i){
     atoms[i]= new AtomStub(i);
     World::get()->registerAtom(atoms[i]);
+    atoms[i]= World::getInstance().createAtom();
+    atomIds[i]= atoms[i]->getId();
+  }
+}
 void atomsCalculationTest::tearDown(){
   World::destroy();
   ActionRegistry::purgeRegistry();
+  World::purgeInstance();
+  ActionRegistry::purgeInstance();
+}
 // some helper functions
+static bool hasAll(std::vector<int> ids,int min, int max, std::set<int> excluded = std::set<int>()){
+  for(int i=min;i<max;++i){
+    if(!excluded.count(i)){
+      std::vector<int>::iterator iter;
+static bool hasAllIds(std::vector<atomId_t> atoms,atomId_t ids[ATOM_COUNT], std::set<atomId_t> excluded = std::set<atomId_t>()){
+  for(int i=0;i<ATOM_COUNT;++i){
+    atomId_t id = ids[i];
+    if(!excluded.count(id)){
+      std::vector<atomId_t>::iterator iter;
       bool res=false;
       for(iter=ids.begin();iter!=ids.end();++iter){
         res |= (*iter) == i;
+      for(iter=atoms.begin();iter!=atoms.end();++iter){
+        res |= (*iter) == id;
+      }
       if(!res) {
         cout << "Atom " << i << " missing in returned list" << endl;
+        cout << "Atom " << id << " missing in returned list" << endl;
         return false;
+      }
 …
+}
 static bool hasNoDuplicates(std::vector<int> ids){
   std::set<int> found;
   std::vector<int>::iterator iter;
+static bool hasNoDuplicates(std::vector<atomId_t> ids){
+  std::set<atomId_t> found;
+  std::vector<atomId_t>::iterator iter;
   for(iter=ids.begin();iter!=ids.end();++iter){
     int id = (*iter);
 …
+}
-static void operation(atom* _atom){
-  AtomStub *atom = dynamic_cast<AtomStub*>(_atom);
-  assert(atom);
-  atom->doSomething();
+}
 void atomsCalculationTest::testCalculateSimple(){
   AtomsCalculation<int> *calc = World::get()->calcOnAtoms<int>(boost::bind(&atom::getId,_1),"FOO",AllAtoms());
   std::vector<int> allIds = (*calc)();
   CPPUNIT_ASSERT(hasAll(allIds,0,ATOM_COUNT));
+  AtomsCalculation<atomId_t> *calc = World::getInstance().calcOnAtoms<atomId_t>(boost::bind(&atom::getId,_1),"FOO",AllAtoms());
+  std::vector<atomId_t> allIds = (*calc)();
+  CPPUNIT_ASSERT(hasAllIds(allIds,atomIds));
   CPPUNIT_ASSERT(hasNoDuplicates(allIds));
+}
 void atomsCalculationTest::testCalculateExcluded(){
   int excluded = ATOM_COUNT/2;
   AtomsCalculation<int> *calc = World::get()->calcOnAtoms<int>(boost::bind(&atom::getId,_1),"FOO",AllAtoms() && !AtomById(excluded));
   std::vector<int> allIds = (*calc)();
   std::set<int> excluded_set;
+  atomId_t excluded = atomIds[ATOM_COUNT/2];
+  AtomsCalculation<atomId_t> *calc = World::getInstance().calcOnAtoms<atomId_t>(boost::bind(&atom::getId,_1),"FOO",AllAtoms() && !AtomById(excluded));
+  std::vector<atomId_t> allIds = (*calc)();
+  std::set<atomId_t> excluded_set;
   excluded_set.insert(excluded);
   CPPUNIT_ASSERT(hasAll(allIds,0,ATOM_COUNT,excluded_set));
+  CPPUNIT_ASSERT(hasAllIds(allIds,atomIds,excluded_set));
   CPPUNIT_ASSERT(hasNoDuplicates(allIds));
   CPPUNIT_ASSERT_EQUAL((size_t)(ATOM_COUNT-1),allIds.size());

src/unittests/atomsCalculationTest.hpp

-              r66e95e
+              rb31bc4
 #define ATOM_COUNT (10)
+#include "types.hpp"
 class atom;
 …
 private:
   atom *atoms [ATOM_COUNT];
   int atomIds [ATOM_COUNT];
+  atomId_t atomIds [ATOM_COUNT];
 };

src/unittests/bondgraphunittest.cpp

-              r66e95e
+              rb31bc4
   strcpy(hydrogen->symbol, "H");
   carbon = new element;
   carbon->Z = 1;
+  carbon->Z = 2;
   strcpy(carbon->name, "carbon");
   strcpy(carbon->symbol, "C");
 …
   // construct periodentafel
   tafel = World::get()->getPeriode();
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   tafel->AddElement(carbon);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::get()->createMolecule();
   Walker = World::get()->createAtom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
   // remove molecule
   World::get()->destroyMolecule(TestMolecule);
+  World::getInstance().destroyMolecule(TestMolecule);
   // note that all the atoms, molecules, the tafel and the elements
   // are all cleaned when the world is destroyed
   World::destroy();
+  World::purgeInstance();
   MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();

src/unittests/listofbondsunittest.cpp

-              r66e95e
+              rb31bc4
   // construct periodentafel
   tafel = World::get()->getPeriode();
+  tafel = World::getInstance().getPeriode();
   tafel->AddElement(hydrogen);
   // construct molecule (tetraeder of hydrogens)
   TestMolecule = World::get()->createMolecule();
   Walker = World::get()->createAtom();
+  TestMolecule = World::getInstance().createMolecule();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 0., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 1., 1. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(1., 1., 0. );
   TestMolecule->AddAtom(Walker);
   Walker = World::get()->createAtom();
+  Walker = World::getInstance().createAtom();
   Walker->type = hydrogen;
   Walker->node->Init(0., 0., 0. );
 …
+{
   // remove
   World::get()->destroyMolecule(TestMolecule);
+  World::getInstance().destroyMolecule(TestMolecule);
   // note that all the atoms, molecules, the tafel and the elements
   // are all cleaned when the world is destroyed
   World::destroy();
+  World::purgeInstance();
   MemoryUsageObserver::purgeInstance();
   logger::purgeInstance();
 …
   // remove atom2
   World::get()->destroyAtom(atom2);
+  World::getInstance().destroyAtom(atom2);
   // check bond if removed from other atom

src/unittests/logunittest.cpp

r66e95e	rb31bc4
40	40	void LogTest::logTest()
41	41	{
42		logger::getInstance()->setVerbosity(2);
	42	logger::getInstance().setVerbosity(2);
43	43	Log() << Verbose(0) << "Verbosity level is set to 2." << endl;
44	44	Log() << Verbose(0) << "Test level 0" << endl;

src/unittests/manipulateAtomsTest.cpp

-              r66e95e
+              rb31bc4
 #include "atom.hpp"
+#ifdef HAVE_TESTRUNNER
+#include "UnitTestMain.hpp"
+#endif /*HAVE_TESTRUNNER*/
 // Registers the fixture into the 'registry'
 CPPUNIT_TEST_SUITE_REGISTRATION( manipulateAtomsTest );
 …
   AtomStub(int _id) :
   atom(),
   id(_id),
   manipulated(false)
+  manipulated(false),
+  id(_id)
   {}
 …
 // set up and tear down
 void manipulateAtomsTest::setUp(){
   World::get();
+  World::getInstance();
   for(int i=0;i<ATOM_COUNT;++i){
     atoms[i]= new AtomStub(i);
     World::get()->registerAtom(atoms[i]);
+    World::getInstance().registerAtom(atoms[i]);
+  }
+}
 void manipulateAtomsTest::tearDown(){
+  World::destroy();
+  ActionRegistry::purgeRegistry();
+}
+// some helper functions
+static 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)){
+      std::vector<atom*>::iterator iter;
+      bool res=false;
+      for(iter=atoms.begin();iter!=atoms.end();++iter){
+        res |= (*iter)->getId() == i;
+      }
+      if(!res) {
+        cout << "Atom " << i << " missing in returned list" << endl;
+        return false;
+      }
+    }
+  }
+  return true;
+}
+static bool hasNoDuplicates(std::vector<atom*> atoms){
+  std::set<int> found;
+  std::vector<atom*>::iterator iter;
+  for(iter=atoms.begin();iter!=atoms.end();++iter){
+    int id = (*iter)->getId();
+    if(found.count(id))
+      return false;
+    found.insert(id);
+  }
+  return true;
+  World::purgeInstance();
+  ActionRegistry::purgeInstance();
+}
 …
 void manipulateAtomsTest::testManipulateSimple(){
   ManipulateAtomsProcess *proc = World::get()->manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms());
+  ManipulateAtomsProcess *proc = World::getInstance().manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms());
   proc->call();
   std::vector<atom*> allAtoms = World::get()->getAllAtoms(AllAtoms());
+  std::vector<atom*> allAtoms = World::getInstance().getAllAtoms(AllAtoms());
   std::vector<atom*>::iterator iter;
   for(iter=allAtoms.begin();iter!=allAtoms.end();++iter){
 …
 void manipulateAtomsTest::testManipulateExcluded(){
+  ManipulateAtomsProcess *proc = World::get()->manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms() && !AtomById(ATOM_COUNT/2));
+  ManipulateAtomsProcess *proc = World::getInstance().manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms() && !AtomById(ATOM_COUNT/2));
   proc->call();
   std::vector<atom*> allAtoms = World::get()->getAllAtoms(AllAtoms());
+  std::vector<atom*> allAtoms = World::getInstance().getAllAtoms(AllAtoms());
   std::vector<atom*>::iterator iter;
   for(iter=allAtoms.begin();iter!=allAtoms.end();++iter){
 …
 void manipulateAtomsTest::testObserver(){
   countObserver *obs = new countObserver();
   World::get()->signOn(obs);
   ManipulateAtomsProcess *proc = World::get()->manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms() && !AtomById(ATOM_COUNT/2));
+  World::getInstance().signOn(obs);
+  ManipulateAtomsProcess *proc = World::getInstance().manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms());
   proc->call();
   CPPUNIT_ASSERT_EQUAL(1,obs->count);
   World::get()->signOff(obs);
+  World::getInstance().signOff(obs);
   delete obs;
+}

Context Navigation

Changes in / [66e95e:b31bc4]

Legend:

Download in other formats: