Diff [cd032d428ec733430510dfedd7dc4bcf1df63fd4:68d781e05c955813adeac99c094cf27f14b90f46] for / – MoleCuilder

src/Actions/Action.cpp

-              rcd032d
+              r68d781
 #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) :
 …
   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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #include <string>
 #include <cassert>
+#include "Helpers/Assert.hpp"
 #include <iostream>
 …
   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");
+}

src/Actions/ActionSequence.cpp

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 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)
 {}
 …
   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

-              rcd032d
+              r68d781
    * 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

-              rcd032d
+              r68d781
 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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
   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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
   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

-              rcd032d
+              r68d781
 #include <iostream>
+#include "World.hpp"
+#include "Helpers/Assert.hpp"
 using namespace std;
 …
 {}
 void ManipulateAtomsProcess::call(){
+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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
   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

-              rcd032d
+              r68d781
 /****** 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->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

-              rcd032d
+              r68d781
   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.hpp

rcd032d	r68d781
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

-              rcd032d
+              r68d781
 #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::getInstance().getPeriode()->FindElement(Z);
+  const element * elem = World::getInstance().getPeriode()->FindElement(Z);
   return AtomByType(elem);
+}

src/Descriptors/AtomTypeDescriptor.hpp

rcd032d	r68d781
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

-              rcd032d
+              r68d781
+{
 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.hpp

-              rcd032d
+              r68d781
   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

-              rcd032d
+              r68d781
   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;

src/Makefile.am

-              rcd032d
+              r68d781
 ANALYSISHEADER = analysis_bonds.hpp analysis_correlation.hpp
+# only include Actions that are free of user interaction at this point
+# the UIFactory et. al. wont be known for the libmolecuilder, so the user interaction cannot be done.
+ACTIONSSOURCE = Actions/Action.cpp Actions/Process.cpp Actions/MethodAction.cpp Actions/ActionSequence.cpp Actions/MakroAction.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/ManipulateAtomsProcess.hpp Actions/ActionRegistry.hpp
+ACTIONSSOURCE = Actions/Action.cpp \
+                                Actions/ActionHistory.cpp \
+                                Actions/ActionRegistry.cpp \
+                                Actions/ActionSequence.cpp \
+                                Actions/MakroAction.cpp \
+                                Actions/ManipulateAtomsProcess.cpp \
+                                Actions/MethodAction.cpp \
+                Actions/Process.cpp
+ACTIONSHEADER = Actions/Action.hpp \
+                                Actions/ActionHistory.hpp \
+                                Actions/ActionRegistry.hpp \
+                                Actions/ActionSequence.hpp \
+                            Actions/Calculation.hpp \
+                            Actions/Calculation_impl.hpp \
+                            Actions/MakroAction.hpp \
+                            Actions/ManipulateAtomsProcess.hpp \
+                            Actions/MethodAction.hpp \
+                            Actions/Process.hpp
 # All actions that need user interaction go here
 MENUACTIONSSOURCE = Actions/ErrorAction.cpp Actions/small_actions.cpp
 …
                                    Descriptors/AtomTypeDescriptor.cpp \
                                    Descriptors/MoleculeDescriptor.cpp \
+                                   Descriptors/MoleculeIdDescriptor.cpp
+                                   Descriptors/MoleculeIdDescriptor.cpp
 DESCRIPTORHEADER = Descriptors/AtomDescriptor.hpp \
 …
                                    Descriptors/MoleculeDescriptor.hpp \
                                    Descriptors/MoleculeIdDescriptor.hpp
 QTUISOURCE = ${QTUIMOC_TARGETS} \
 …
 QTUI_DEFS =
+SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE} ${ACTIONSSOURCE} ${DESCRIPTORSOURCE}  bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.cpp info.cpp leastsquaremin.cpp linkedcell.cpp lists.cpp log.cpp logger.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp World.cpp WorldIterators.cpp
+HEADER = ${ANALYSISHEADER} ${ATOMHEADER} ${PATTERNHEADER} ${ACTIONSHEADER} ${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
+#SOURCE = ${ANALYSISSOURCE} ${ATOMSOURCE} ${PATTERNSOURCE}  ${DESCRIPTORSOURCE}  bond.cpp bondgraph.cpp boundary.cpp config.cpp element.cpp ellipsoid.cpp errorlogger.cpp graph.cpp helpers.cpp info.cpp leastsquaremin.cpp linkedcell.cpp lists.cpp log.cpp logger.cpp memoryusageobserver.cpp moleculelist.cpp molecule.cpp molecule_dynamics.cpp molecule_fragmentation.cpp molecule_geometry.cpp molecule_graph.cpp molecule_pointcloud.cpp parser.cpp periodentafel.cpp tesselation.cpp tesselationhelpers.cpp vector.cpp verbose.cpp World.cpp WorldIterators.cpp
+#HEADER = ${ANALYSISHEADER} ${ATOMHEADER} ${PATTERNHEADER} ${ACTIONSHEADER} ${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
+SOURCE = ${ANALYSISSOURCE} \
+                 ${ATOMSOURCE} \
+                 ${PATTERNSOURCE} \
+                 ${ACTIONSSOURCE} \
+                 ${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} \
+         ${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
 BOOST_LIB = $(BOOST_LDFLAGS) $(BOOST_MPL_LIB)

src/Menu/TextMenu.cpp

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
   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/Patterns/Singleton.hpp

-              rcd032d
+              r68d781
 /**
  * This template produces the generic singleton pattern using the CRTP idiom.
+ *
+ * <h1> Singleton Howto </h1>
+ * <h2> Introduction </h2>
+ *
+ * A Singleton is a class of which there can only be a single Object in the programm. It is
+ * described as an design-pattern in Gof:96 (the famous design-pattern book). In the
+ * molecuilder there are so far several Singletons serving a wide range of purposes:
+ *
+ * - the World, which handles all atoms, molecules and bonds
+ * - the ActionRegistry, which stores all created actions by name for later use
+ * - the UIFactory, which is an AbstractFactory (another design-pattern from Gof:96) and
+ *   handles all creation of gui elements to ensure a single type throughout the programm
+ * - the logger and errorLogger classes, that can be used to output messages on the screen
+ *   depending on certain conditions
+ *
+ * Because those classes can only be instantiated once you cannot simply call <code>new World()</code>
+ * or <code>delete</code> on them. Rather they have to be constructed and accessed using the singleton
+ * mechanism. This mechanism consists of four static functions (and a fifth that is used internally,
+ * but we will get to that later). These functions are:
+ *
+ * - <code>Singleton& Singleton::getInstance()</code> : returns the instance of the singleton as
+ *    a reference
+ * - <code>Singleton* Singleton::getPointer()</code> : returns the instance of the singleton as a
+ *    pointer
+ * - <code>void Singleton::purgeInstance()</code> : destroys the single Instance of the singleton
+ * - <code>Singleton& Singleton::resetInstance()</code> : resets the Singleton, i.e. destroys the
+ *    old instance and creates a new one
+ *
+ * If you need the instance of the singleton it is usually fine just to use one off the accessor
+ * functions (i.e. <code>getInstance()</code> or <code>getPointer()</code>. Any creation of the
+ * Singleton is then handled by these functions, so that the same object will be returned whenever
+ * one of these functions is called. This easy process is true for most singletons you will need
+ * to use. The only special singleton is the UIFactory.
+ *
+ * <h3>Special functions of the UIFactory</h3>
+ *
+ * If you simply call the <code>getInstance()</code> method of the UIFactory class the program
+ * will crash. This happens, because the UIFactory in itself is abstract and needs to know what
+ * kind of user interface it should produce later on. You need to tell the class the type of UI
+ * using the void <code>UIFactory::makeUserInterface(InterfaceTypes type)</code> method. This will
+ * also take care of creating the sole instance, so that the accessor functions will work afterwards.
+ * What this also means is, that you cannot <code>reset()</code> the UIFactory, because at that
+ * point it wont know anymore what to construct. A sequence of <code>UIFactory::purgeInstance()</code>,
+ * <code>UIFactory::makeUserInterface()</code> and <code>UIFactory::getInstance()</code> will work
+ * though.
+ *
+ * In order to make life easier and propagate changes to the singleton mechanism to all those
+ * classes, there is a simple framework class that can be used to make any other class a
+ * singleton through inheritance. This class can be found in the Pattern directory.
+ *
+ * <h2>How to make a class Singleton</h2>
+ *
+ * Most of the time you will only need singletons that don't require additional
+ * information for creation. So I will cover the basic case for constructing singletons
+ * first and then explain what has to be changed to make it accept special parameters.
+ * Singletons are created by inheriting from the <code>Singleton<class T></code> template
+ * using the Curiously recurring template pattern (CRTP). What this means is, that the
+ * class they inherit from carries the inheriting class as a template parameter. For example
+ * <code>class MySingletonExaple : public Singleton<MySingletonExample>{...}</code>. If you
+ * want to know more about this idiom have a look at the
+ * <A HREF="http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern">wikipedia
+ * page for this idiom</A>, but don't worry if you don't quite get how this works for now, for
+ * the use of the singleton framework this is not important.
+ *
+ * If you want to make a class a singleton you can use the following sequence of steps.
+ *
+ * - Inherit from the singleton pattern using the CRTP as above:<br>
+ *   @code
+ *     class MySingletonExaple : public Singleton<MySingletonExample>{ ...}
+ *   @endcode
+ * - Make constructor and destructor private to avoid creation or destruction from
+ *   outside the class:<br>
+ *    @code
+ *      class MySingletonExaple : public Singleton<MySingletonExample>{
+ *        private:
+ *          MySingletonExample();
+ *          ~MySingletonExample();
+ *      ...}
+ *    @endcode
+ * - give the inherited class access to the class internals using a friend declaration:<br>
+ *    @code
+ *       class MySingletonExaple : public Singleton<MySingletonExample>{
+ *         friend class Singleton<MySingletonExample>; // don't forget the template parameters here
+ *         private:
+ *           MySingletonExample();
+ *           ~MySingletonExample();
+ *       ...}
+ *    @endcode
+ *
+ * - include the file "Patterns/Singleton_impl.hpp" that carries the implementation details of
+ *   the singleton functions in your implementation file of the class.
+ * - make the compiler construct the template instantiations. For this you can use the defined
+ *   keyword <code>CONSTRUCT_SINGLETON(name)</code> at any toplevel point in the implementation
+ *   file:<br>
+ *    @code
+ *       void MySingletonExample::foo(){...}
+ *       void MySingletonExample::bar(){...}
+ *       CONSTRUCT_SINGLETON(MySingletonExample) // no ; after this
+ *     @endcode
+ *
+ * <h3>Singleton with initialization parameters</h3>
+ *
+ * Sometimes it is necessary for a singleton to be passed some initilization parameters. For
+ * example the UIFactory mentioned above needs to know what kind of user interface it has to
+ * produce. Making a singleton that takes initialization parameters is only sligtly different
+ * from the steps lined out above. Here are all the differences:
+ *
+ * - pass an extra <code>false</code> to the template to deactivate the standard instantiation
+ *   mechanism
+ * - write a method that handles the special parameters and instantiation. In this method you
+ *   can use the <code>setInstance(T*)</code> method inherited from the singleton pattern to set
+ *   the created instance. The <code>setInstance()</code> method will only work when the
+ *   <code>false<code> template parameter has been set and produce errors otherwise.
+ *
  */
 template <class T, bool _may_create=true>
 …
+{
 private:
+  // simple auto_ptr that allows destruction of the object
+  // std::auto_ptr cannot do this because the destructor of T is ussually private
+  /**
+   * simple auto_ptr that is used by Singleton template
+   *
+   * This ptr_t allows destruction of the object using a private destructor,
+   * when only the Singleton pattern is friend with the class
+   *
+   * All methods have similar sematics to auto_ptr
+   */
   class ptr_t {
   public:
 …
     void reset(T* _content);
     void reset();
     ptr_t& operator=(ptr_t& rhs);
+    ptr_t& operator=(const ptr_t& rhs);
   private:
+    T* content;
+  };
+  /**
+   * this creator checks what it may or may not do
+    mutable T* content;
+  };
+  /**
+   * This object handles the actual creation inside the singleton
+   *
+   * Using template specialization this will allways know what it can
+   * do or cannot do at compile time
    */
   template<class creator_T, bool creator_may_create>
   struct creator_t {
     static creator_T* make();
     static void set(creator_T*&,creator_T*);
+    inline static creator_T* make();
+    inline static void set(creator_T*&,creator_T*);
   };
   // specialization to allow fast creations
+  /**
+   * Specialized template that allows automatic construction only
+   */
   template<class creator_T>
   struct creator_t<creator_T,true>{
     static creator_T* make(){
+    inline static creator_T* make(){
       return new creator_T();
+    }
     static void set(creator_T*&,creator_T*){
+    inline static void set(creator_T*&,creator_T*){
       assert(0 && "Cannot set the Instance for a singleton of this type");
+    }
   };
+  /**
+   * specialized template that allows setting only
+   */
   template<class creator_T>
   struct creator_t<creator_T,false>{
     static creator_T* make(){
+    inline static creator_T* make(){
       assert(0 && "Cannot create a singleton of this type directly");
+    }
     static void set(ptr_t& dest,creator_T* src){
+    inline static void set(ptr_t& dest,creator_T* src){
       dest.reset(src);
+    }
   };
+  // this is used for creation
+  typedef creator_t<T,_may_create> creator; //< the creator used
 public:
   // make the state of this singleton accessible
+  static const bool may_create=_may_create;
+  // this is used for creation
+  typedef creator_t<T,_may_create> creator;
+  static const bool may_create=_may_create; //!< the type of singleton that we have
+  /**
+   * returns the instance of this Singleton as a reference
+   *
+   * If no Singleton exists at this point and we are allowed to create one
+   * a new one is created and stored inside the singleton
+   *
+   * If no automatic creation is allowed, make sure to create an instance first
+   * using the appropriate methods of the derived class. Otherwise this method
+   * would fail.
+   */
   static T& getInstance();
+  /**
+   * returns the instance of this singleton as a pointer
+   *
+   * If no Singleton exists at this point and we are allowed to create one
+   * a new one is created and stored inside the singleton.
+   *
+   * If no automatic creation is allowed, make sure to create an instance first
+   * using the appropriate methods of the derived class. Otherwise this method
+   * would fail.
+   */
   static T* getPointer();
+  /**
+   * destroys the current instance of this singleton
+   */
   static void purgeInstance();
+  /**
+   * destroys the current instance of the singleton and immidiately constructs
+   * a new one. Similar to using <code>purgeInstance()</code> and <code>getInstance()</code>
+   * but plays more nicely when observers are present. Especially the new instance is created
+   * before the old one is destroyed so observers can switch their targets, when they are notified
+   * of the destruction.
+   *
+   * If no automatic creation is allowed this method wont work.
+   */
   static T&   resetInstance();
+protected:
+  /**
+   * Method used to set the instance, when no automatic creation is allowed.
+   *
+   * Call this after the instantiation method in the derived class has created
+   * it's instance and want's the singleton mechanism to keep it around for later
+   * use.
+   *
+   * This method will always fail when automatic creation is enabled.
+   */
   static void setInstance(T*);
+protected:
+  /**
+   * empty constructor to allow creation of subclases
+   */
+  Singleton();
 private:
+  static boost::recursive_mutex instanceLock;
+  static ptr_t theInstance;
+  /**
+   * the copy constructor is private to avoid accidental copying of Singletons, for example
+   * when passing singletons to functions by value instead of by reference. If you
+   * need copying of singletons call the default constructor in the copy constructor
+   * of the derived object. The copyied object wont be known to the singleton mechanism.
+   */
+  Singleton(const Singleton&);
+  static boost::recursive_mutex instanceLock; //!< a lock for the pointer of the instance
+  static ptr_t theInstance; //!< the actual instance of the singleton
 };

src/Patterns/Singleton_impl.hpp

-              rcd032d
+              r68d781
+}
+template<class T, bool _may_create>
+Singleton<T,_may_create>::Singleton(){/* empty */}
+// private copy constructor to avoid unintended copying
+template <class T, bool _may_create>
+Singleton<T,_may_create>::Singleton(const Singleton<T,_may_create>&){
+  assert(0 && "Copy constructor of singleton template called");
+}
 /**
  * This define allows simple instantiation of the necessary singleton functions
 …
 template <class T,bool _may_create>
 typename Singleton<T,_may_create>::ptr_t& Singleton<T,_may_create>::ptr_t::operator=(typename Singleton<T,_may_create>::ptr_t& rhs){
+typename Singleton<T,_may_create>::ptr_t& Singleton<T,_may_create>::ptr_t::operator=(const typename Singleton<T,_may_create>::ptr_t& rhs){
   if(&rhs!=this){
     delete content;

src/UIElements/Dialog.cpp

-              rcd032d
+              r68d781
 // Element Queries
 Dialog::ElementQuery::ElementQuery(std::string title, element **_target) :
+Dialog::ElementQuery::ElementQuery(std::string title, const element **_target) :
   Query(title),
   target(_target),
   tmp(0)
+  tmp(0),
+  target(_target)
   {}

src/UIElements/Dialog.hpp

-              rcd032d
+              r68d781
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*)=0;
   virtual void queryVector(const char*,Vector *,const double *const,bool)=0;
   virtual void queryElement(const char*,element **)=0;
+  virtual void queryElement(const char*,const element **)=0;
   virtual bool display();
 …
   class ElementQuery : public Query {
   public:
     ElementQuery(std::string title, element**_target);
+    ElementQuery(std::string title, const element**_target);
     virtual ~ElementQuery();
     virtual bool handle()=0;
     virtual void setResult();
   protected:
     element *tmp;
+    const element *tmp;
   private:
     element **target;
+    const element **target;
   };

src/UIElements/QT4/QTDialog.cpp

-              rcd032d
+              r68d781
+}
 void QTDialog::queryElement(const char* title, element **target){
+void QTDialog::queryElement(const char* title, const element **target){
   registerQuery(new ElementQTQuery(title,target,inputLayout,this));
+}
 …
 QTDialog::ElementQTQuery::ElementQTQuery(std::string _title, element **_target, QBoxLayout *_parent, QTDialog *_dialog) :
+QTDialog::ElementQTQuery::ElementQTQuery(std::string _title, const element **_target, QBoxLayout *_parent, QTDialog *_dialog) :
     Dialog::ElementQuery(_title,_target),
     parent(_parent)
 …
   titleLabel = new QLabel(QString(getTitle().c_str()));
   inputBox = new QComboBox();
+  element* Elemental = 0;
+  for(Elemental = periode->start->next;
+      Elemental!=periode->end;
+      Elemental = Elemental->next)
+  for(periodentafel::const_iterator iter = periode->begin();
+      iter!=periode->end();
+      ++iter)
+  {
     stringstream sstr;
     sstr << Elemental->Z << "\t" << Elemental->name;
     inputBox->addItem(QString(sstr.str().c_str()),QVariant(Elemental->Z));
+    sstr << (*iter).first << "\t" << (*iter).second->name;
+    inputBox->addItem(QString(sstr.str().c_str()),QVariant((*iter).first));
+  }
   parent->addLayout(thisLayout);
 …
+}
 ElementQTQueryPipe::ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox) :
+ElementQTQueryPipe::ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox) :
   content(_content),
   dialog(_dialog),

src/UIElements/QT4/QTDialog.hpp

-              rcd032d
+              r68d781
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*);
   virtual void queryVector(const char*,Vector *,const double *const,bool);
   virtual void queryElement(const char*,element **);
+  virtual void queryElement(const char*,const element **);
   virtual bool display();
 …
     class ElementQTQuery : public Dialog::ElementQuery {
     public:
       ElementQTQuery(std::string _title, element **_target, QBoxLayout *_parent, QTDialog *_dialog);
+      ElementQTQuery(std::string _title, const element **_target, QBoxLayout *_parent, QTDialog *_dialog);
       virtual ~ElementQTQuery();
       virtual bool handle();
 …
   Q_OBJECT
 public:
   ElementQTQueryPipe(element **_content, QTDialog *_dialog, QComboBox *_theBox);
+  ElementQTQueryPipe(const element **_content, QTDialog *_dialog, QComboBox *_theBox);
   virtual ~ElementQTQueryPipe();
 …
 private:
   element **content;
+  const element **content;
   QTDialog *dialog;
   QComboBox *theBox;

src/UIElements/TextDialog.cpp

-              rcd032d
+              r68d781
+}
 void TextDialog::queryElement(const char* title, element **target){
+void TextDialog::queryElement(const char* title, const element **target){
   registerQuery(new ElementTextQuery(title,target));
+}
 …
 TextDialog::ElementTextQuery::ElementTextQuery(std::string title, element **target) :
+TextDialog::ElementTextQuery::ElementTextQuery(std::string title, const element **target) :
     Dialog::ElementQuery(title,target)
 {}

src/UIElements/TextDialog.hpp

-              rcd032d
+              r68d781
   virtual void queryMolecule(const char*,molecule**,MoleculeListClass*);
   virtual void queryVector(const char*,Vector *,const double * const,bool);
   virtual void queryElement(const char*,element **);
+  virtual void queryElement(const char*,const element **);
 protected:
 …
   class ElementTextQuery : public Dialog::ElementQuery {
   public:
     ElementTextQuery(std::string title, element **_target);
+    ElementTextQuery(std::string title, const element **_target);
     virtual ~ElementTextQuery();
     virtual bool handle();

src/UIElements/TextWindow.cpp

-              rcd032d
+              r68d781
 #include "Actions/MethodAction.hpp"
 #include "Actions/ErrorAction.hpp"
+#include "Actions/ActionRegistry.hpp"
 #include "Views/StreamStringView.hpp"
 #include "Views/MethodStringView.hpp"
 …
   moleculeView = new StreamStringView(boost::bind(&MoleculeListClass::Enumerate,molecules,_1));
   new DisplayMenuItem(main_menu,moleculeView,"Molecule List");
+  new SeperatorItem(main_menu);
+  Action* undoAction = ActionRegistry::getInstance().getActionByName("Undo");
+  new ActionMenuItem('u',"Undo last operation",main_menu,undoAction);
+  Action* redoAction = ActionRegistry::getInstance().getActionByName("Redo");
+  new ActionMenuItem('r',"Redo last operation",main_menu,redoAction);
   new SeperatorItem(main_menu);
 …
   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

rcd032d	r68d781
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/World.cpp

-              rcd032d
+              r68d781
 #include "Descriptors/MoleculeDescriptor.hpp"
 #include "Descriptors/MoleculeDescriptor_impl.hpp"
+#include "Descriptors/SelectiveIterator_impl.hpp"
 #include "Actions/ManipulateAtomsProcess.hpp"
 …
 /******************************* 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());
+}

src/World.hpp

-              rcd032d
+              r68d781
 #include <boost/shared_ptr.hpp>
+#include "defs.hpp"
+#include "types.hpp"
+#include "Descriptors/SelectiveIterator.hpp"
 #include "Patterns/Observer.hpp"
 #include "Patterns/Cacheable.hpp"
 …
   // Atoms
+  class AtomIterator :
+    public std::iterator<std::iterator_traits<AtomSet::iterator>::difference_type,
+                         std::iterator_traits<AtomSet::iterator>::value_type,
+                         std::iterator_traits<AtomSet::iterator>::pointer,
+                         std::iterator_traits<AtomSet::iterator>::reference>
+  {
+  public:
+    typedef AtomSet::iterator _Iter;
+    typedef _Iter::value_type value_type;
+    typedef _Iter::difference_type difference_type;
+    typedef _Iter::pointer pointer;
+    typedef _Iter::reference reference;
+    typedef _Iter::iterator_category iterator_category;
+    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 std::iterator<std::iterator_traits<MoleculeSet::iterator>::difference_type,
+                         std::iterator_traits<MoleculeSet::iterator>::value_type,
+                         std::iterator_traits<MoleculeSet::iterator>::pointer,
+                         std::iterator_traits<MoleculeSet::iterator>::reference>
+  {
+  public:
+    typedef MoleculeSet::iterator _Iter;
+    typedef _Iter::value_type value_type;
+    typedef _Iter::difference_type difference_type;
+    typedef _Iter::pointer pointer;
+    typedef _Iter::reference reference;
+    typedef _Iter::iterator_category iterator_category;
+    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

src/atom.hpp

rcd032d	r68d781
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

-              rcd032d
+              r68d781
 };
 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::getInstance().getPeriode()->FindElement(Z);
+  const element *elem = World::getInstance().getPeriode()->FindElement(Z);
   setType(elem);
+}

src/atom_atominfo.hpp

-              rcd032d
+              r68d781
   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/builder.cpp

-              rcd032d
+              r68d781
 #include "Menu/ActionMenuItem.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionHistory.hpp"
 #include "Actions/MethodAction.hpp"
 #include "Actions/small_actions.hpp"
 …
+                }
                 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};
 …
                   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;
 …
     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::getInstance().getMolecules(), World::getInstance().getPeriode(), *configuration, ConfigFileName);

src/config.cpp

-              rcd032d
+              r68d781
+{
   int MaxTypes = 0;
   element *elementhash[MAX_ELEMENTS];
+  const element *elementhash[MAX_ELEMENTS];
   char name[MAX_ELEMENTS];
   char keyword[MAX_ELEMENTS];
 …
   string zeile;
   string dummy;
   element *elementhash[128];
+  const element *elementhash[128];
   int Z = -1;
   int No = -1;

src/defs.hpp

-              rcd032d
+              r68d781
 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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #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/helpers.hpp

-              rcd032d
+              r68d781
 #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

rcd032d	r68d781
42	42	gsl_vector *x;
43	43	const molecule *mol;
44		element *type;
	44	const element *type;
45	45	};
46	46

src/molecule.cpp

-              rcd032d
+              r68d781
 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();

src/molecule.hpp

rcd032d	r68d781
29	29	#include <string>
30	30
31		#include "~~def~~s.hpp"
	31	#include "types.hpp"
32	32	#include "graph.hpp"
33	33	#include "stackclass.hpp"

src/moleculelist.cpp

-              rcd032d
+              r68d781
 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
 …
   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

src/periodentafel.cpp

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
   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/AnalysisCorrelationToSurfaceUnitTest.cpp

-              rcd032d
+              r68d781
 #include "World.hpp"
+#include "Helpers/Assert.hpp"
 #ifdef HAVE_TESTRUNNER
 #include "UnitTestMain.hpp"
 …
 void AnalysisCorrelationToSurfaceUnitTest::setUp()
+{
+  ASSERT_DO(Assert::Throw);
   atom *Walker = NULL;

src/unittests/AtomDescriptorTest.cpp

rcd032d	r68d781
140	140	CPPUNIT_ASSERT_EQUAL( true , hasNoDuplicateAtoms(testAtoms));
141	141	}
142
143	142	// exclude and include some atoms
144	143	{

src/unittests/AtomDescriptorTest.hpp

rcd032d	r68d781
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

-              rcd032d
+              r68d781
 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

-              rcd032d
+              r68d781
 AnalysisPairCorrelationUnitTest_LDADD = ${ALLLIBS}
+atomsCalculationTest_SOURCES = UnitTestMain.cpp atomsCalculationTest.cpp atomsCalculationTest.hpp
+atomsCalculationTest_LDADD = ${ALLLIBS}
 BondGraphUnitTest_SOURCES = UnitTestMain.cpp bondgraphunittest.cpp bondgraphunittest.hpp
 BondGraphUnitTest_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.hpp

rcd032d	r68d781
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

-              rcd032d
+              r68d781
 #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

-              rcd032d
+              r68d781
 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/SingletonTest.cpp

-              rcd032d
+              r68d781
     count1++;
+  }
+  // explicit copy constructor to catch if this is ever called
+  SingletonStub1(const SingletonStub1&){
+    CPPUNIT_FAIL    ( "Copy constructor of Singleton called" );
+  }
   virtual ~SingletonStub1(){
     count2++;
 …
   SingletonStub2(){
     count1++;
+  }
+  // explicit copy constructor to catch if thsi is ever called
+  SingletonStub2(const SingletonStub2&){
+    CPPUNIT_FAIL    ( "Copy constructor of Singleton called" );
+  }
   virtual ~SingletonStub2(){

src/unittests/analysisbondsunittest.cpp

rcd032d	r68d781
53	53	strcpy(hydrogen->symbol, "H");
54	54	carbon = new element;
55		carbon->Z = 1;
	55	carbon->Z = 2;
56	56	carbon->Valence = 4;
57	57	carbon->NoValenceOrbitals = 4;

src/unittests/atomsCalculationTest.cpp

-              rcd032d
+              r68d781
 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::getInstance();
   for(int i=0;i<ATOM_COUNT;++i){
     atoms[i]= new AtomStub(i);
     World::getInstance().registerAtom(atoms[i]);
+    atoms[i]= World::getInstance().createAtom();
+    atomIds[i]= atoms[i]->getId();
+  }
+}
 …
 // 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);
 …
 void atomsCalculationTest::testCalculateSimple(){
   AtomsCalculation<int> *calc = World::getInstance().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::getInstance().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

-              rcd032d
+              r68d781
 #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

rcd032d	r68d781
51	51	strcpy(hydrogen->symbol, "H");
52	52	carbon = new element;
53		carbon->Z = 1;
	53	carbon->Z = 2;
54	54	strcpy(carbon->name, "carbon");
55	55	strcpy(carbon->symbol, "C");

src/unittests/manipulateAtomsTest.cpp

-              rcd032d
+              r68d781
 #include "Actions/ManipulateAtomsProcess.hpp"
 #include "Actions/ActionRegistry.hpp"
+#include "Actions/ActionHistory.hpp"
 #include "World.hpp"
 …
 // set up and tear down
 void manipulateAtomsTest::setUp(){
+  ActionHistory::init();
   World::getInstance();
   for(int i=0;i<ATOM_COUNT;++i){
 …
   World::purgeInstance();
   ActionRegistry::purgeInstance();
+  ActionHistory::purgeInstance();
+}
 …
 void manipulateAtomsTest::testManipulateExcluded(){
   ManipulateAtomsProcess *proc = World::getInstance().manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms() && !AtomById(ATOM_COUNT/2));
   proc->call();
 …
   countObserver *obs = new countObserver();
   World::getInstance().signOn(obs);
   ManipulateAtomsProcess *proc = World::getInstance().manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms() && !AtomById(ATOM_COUNT/2));
+  ManipulateAtomsProcess *proc = World::getInstance().manipulateAtoms(boost::bind(operation,_1),"FOO",AllAtoms());
   proc->call();

Context Navigation

Changes in / [cd032d:68d781]

Legend:

Download in other formats: