Changeset 765f16 for src

Timestamp:

Oct 14, 2011, 3:15:30 PM (13 years ago)

Author:

Frederik Heber <heber@…>

Branches:

Action_Thermostats, Add_AtomRandomPerturbation, Add_FitFragmentPartialChargesAction, Add_RotateAroundBondAction, Add_SelectAtomByNameAction, Added_ParseSaveFragmentResults, AddingActions_SaveParseParticleParameters, Adding_Graph_to_ChangeBondActions, Adding_MD_integration_tests, Adding_ParticleName_to_Atom, Adding_StructOpt_integration_tests, AtomFragments, Automaking_mpqc_open, AutomationFragmentation_failures, Candidate_v1.5.4, Candidate_v1.6.0, Candidate_v1.6.1, ChangeBugEmailaddress, ChangingTestPorts, ChemicalSpaceEvaluator, CombiningParticlePotentialParsing, Combining_Subpackages, Debian_Package_split, Debian_package_split_molecuildergui_only, Disabling_MemDebug, Docu_Python_wait, EmpiricalPotential_contain_HomologyGraph, EmpiricalPotential_contain_HomologyGraph_documentation, Enable_parallel_make_install, Enhance_userguide, Enhanced_StructuralOptimization, Enhanced_StructuralOptimization_continued, Example_ManyWaysToTranslateAtom, Exclude_Hydrogens_annealWithBondGraph, FitPartialCharges_GlobalError, Fix_BoundInBox_CenterInBox_MoleculeActions, Fix_ChargeSampling_PBC, Fix_ChronosMutex, Fix_FitPartialCharges, Fix_FitPotential_needs_atomicnumbers, Fix_ForceAnnealing, Fix_IndependentFragmentGrids, Fix_ParseParticles, Fix_ParseParticles_split_forward_backward_Actions, Fix_PopActions, Fix_QtFragmentList_sorted_selection, Fix_Restrictedkeyset_FragmentMolecule, Fix_StatusMsg, Fix_StepWorldTime_single_argument, Fix_Verbose_Codepatterns, Fix_fitting_potentials, Fixes, ForceAnnealing_goodresults, ForceAnnealing_oldresults, ForceAnnealing_tocheck, ForceAnnealing_with_BondGraph, ForceAnnealing_with_BondGraph_continued, ForceAnnealing_with_BondGraph_continued_betteresults, ForceAnnealing_with_BondGraph_contraction-expansion, FragmentAction_writes_AtomFragments, FragmentMolecule_checks_bonddegrees, GeometryObjects, Gui_Fixes, Gui_displays_atomic_force_velocity, ImplicitCharges, IndependentFragmentGrids, IndependentFragmentGrids_IndividualZeroInstances, IndependentFragmentGrids_IntegrationTest, IndependentFragmentGrids_Sole_NN_Calculation, JobMarket_RobustOnKillsSegFaults, JobMarket_StableWorkerPool, JobMarket_unresolvable_hostname_fix, MoreRobust_FragmentAutomation, ODR_violation_mpqc_open, PartialCharges_OrthogonalSummation, PdbParser_setsAtomName, PythonUI_with_named_parameters, QtGui_reactivate_TimeChanged_changes, Recreated_GuiChecks, Rewrite_FitPartialCharges, RotateToPrincipalAxisSystem_UndoRedo, SaturateAtoms_findBestMatching, SaturateAtoms_singleDegree, StoppableMakroAction, Subpackage_CodePatterns, Subpackage_JobMarket, Subpackage_LinearAlgebra, Subpackage_levmar, Subpackage_mpqc_open, Subpackage_vmg, Switchable_LogView, ThirdParty_MPQC_rebuilt_buildsystem, TrajectoryDependenant_MaxOrder, TremoloParser_IncreasedPrecision, TremoloParser_MultipleTimesteps, TremoloParser_setsAtomName, Ubuntu_1604_changes, stable

Children:

d3d6c6

Parents:

9a6b76e

git-author:

Frederik Heber <heber@…> (09/27/11 19:04:36)

git-committer:

Frederik Heber <heber@…> (10/14/11 15:15:30)

Message:

Huge Refactoring of FormatParserStorage and all FormatParser's.

FormatParser:

• FormatParser is now a template, specialized by enum ParserTypes.
• new struct FormatParserTrait is as well a template of same type, containing parser-specific information in static entities.
• all FormatParsers are now specializations of this FormatParser.
• all Parsers can be accessed in a unified manner, given in the new class FormatParserInterface.
• common functions are placed in FormatParser_common.hpp as one cannot partially specialize a function class.
• some boost preprocessor magic is used in ParserTypes and FormatParserTraits to define the template specialization or to create the ParserTypes enumeration.

FormatParserStorage:

• We construct all lookup tables and alikes via boost preprocessor magic from a list of all available parser (enums).
• we use the templated getParser() and addParser() functions to serve parsers to the outside. Instances are as usual created only once.

Tests:

• tests only had to be changed because of the "renaming" of the Parsers.

Location:

src

Files:

• Actions/MoleculeAction/FillVoidWithMoleculeAction.cpp (modified) (2 diffs)
• Actions/MoleculeAction/FillWithMoleculeAction.cpp (modified) (2 diffs)
• Actions/MoleculeAction/LoadAction.cpp (modified) (1 diff)
• Actions/ParserAction/ParseTremoloPotentialsAction.cpp (modified) (2 diffs)
• Actions/ParserAction/SetMpqcParametersAction.cpp (modified) (3 diffs)
• Actions/ParserAction/SetTremoloAtomdataAction.cpp (modified) (1 diff)
• Parser/FormatParser.hpp (modified) (1 diff)
• Parser/FormatParserInterface.hpp (added)
• Parser/FormatParserStorage.cpp (modified) (5 diffs)
• Parser/FormatParserStorage.hpp (modified) (5 diffs)
• Parser/FormatParserTrait.hpp (added)
• Parser/FormatParserTrait_specializations_header.hpp (added)
• Parser/FormatParser_common.cpp (moved) (moved from src/Parser/FormatParser.cpp ) (9 diffs)
• Parser/FormatParser_common.hpp (added)
• Parser/FormatParser_specializations_header.hpp (added)
• Parser/Makefile.am (modified) (2 diffs)
• Parser/MpqcParser.cpp (modified) (8 diffs)
• Parser/MpqcParser.hpp (modified) (1 diff)
• Parser/ParserTypes.cpp (added)
• Parser/ParserTypes.def (added)
• Parser/ParserTypes.hpp (modified) (1 diff)
• Parser/ParserTypes.undef (added)
• Parser/PcpParser.cpp (modified) (15 diffs)
• Parser/PcpParser.hpp (modified) (2 diffs)
• Parser/PdbAtomInfoContainer.hpp (modified) (2 diffs)
• Parser/PdbParser.cpp (modified) (28 diffs)
• Parser/PdbParser.hpp (modified) (2 diffs)
• Parser/TremoloParser.cpp (modified) (30 diffs)
• Parser/TremoloParser.hpp (modified) (3 diffs)
• Parser/XyzParser.cpp (modified) (6 diffs)
• Parser/XyzParser.hpp (modified) (1 diff)
• Parser/unittests/ParserMpqcUnitTest.cpp (modified) (11 diffs)
• Parser/unittests/ParserMpqcUnitTest.hpp (modified) (1 diff)
• Parser/unittests/ParserPcpUnitTest.cpp (modified) (6 diffs)
• Parser/unittests/ParserPcpUnitTest.hpp (modified) (2 diffs)
• Parser/unittests/ParserPdbUnitTest.cpp (modified) (7 diffs)
• Parser/unittests/ParserPdbUnitTest.hpp (modified) (2 diffs)
• Parser/unittests/ParserTremoloUnitTest.cpp (modified) (17 diffs)
• Parser/unittests/ParserTremoloUnitTest.hpp (modified) (2 diffs)
• Parser/unittests/ParserXyzUnitTest.cpp (modified) (9 diffs)
• Parser/unittests/ParserXyzUnitTest.hpp (modified) (2 diffs)
• moleculelist.cpp (modified) (1 diff)

src/Actions/MoleculeAction/FillVoidWithMoleculeAction.cpp

@@ -28 +28 @@
 #include "Descriptors/MoleculeOrderDescriptor.hpp"
 #include "molecule.hpp"
+#include "Parser/FormatParserInterface.hpp"
 #include "Parser/FormatParserStorage.hpp"
 #include "World.hpp"
@@ -67 +68 @@
   input.open(params.fillername.string().c_str());
   ParserTypes type = FormatParserStorage::getInstance().getTypeFromSuffix(FilenameSuffix);
-  FormatParser &parser = FormatParserStorage::getInstance().get(type);
+  FormatParserInterface &parser = FormatParserStorage::getInstance().get(type);
   parser.load(&input);
 

src/Actions/MoleculeAction/FillWithMoleculeAction.cpp

@@ -28 +28 @@
 #include "Descriptors/MoleculeOrderDescriptor.hpp"
 #include "molecule.hpp"
+#include "Parser/FormatParserInterface.hpp"
 #include "Parser/FormatParserStorage.hpp"
 #include "World.hpp"
@@ -61 +62 @@
   input.open(params.fillername.string().c_str());
   ParserTypes type = FormatParserStorage::getInstance().getTypeFromSuffix(FilenameSuffix);
-  FormatParser &parser = FormatParserStorage::getInstance().get(type);
+  FormatParserInterface &parser = FormatParserStorage::getInstance().get(type);
   parser.load(&input);
 

src/Actions/MoleculeAction/LoadAction.cpp

@@ -23 +23 @@
 #include "CodePatterns/Verbose.hpp"
 #include "Descriptors/MoleculeIdDescriptor.hpp"
+#include "Parser/FormatParserInterface.hpp"
 #include "Parser/FormatParserStorage.hpp"
 #include "Parser/FormatParser_Parameters.hpp"

src/Actions/ParserAction/ParseTremoloPotentialsAction.cpp

@@ -43 +43 @@
 
   boost::filesystem::ifstream test;
-  TremoloParser &tremolo = FormatParserStorage::getInstance().getParser<TremoloParser>();
+  FormatParser<tremolo> &parser = FormatParserStorage::getInstance().getParser<tremolo>();
   // parsing file if present
   if (!boost::filesystem::exists(params.filename)) {
     DoLog(1) && (Log() << Verbose(1) << "Specified potentials file " << params.filename << " not found." << endl);
     // DONT FAIL: it's just empty we re-create default id-mapping
-    tremolo.createKnownTypesByIdentity();
+    parser.createKnownTypesByIdentity();
 
   } else {
@@ -55 +55 @@
     // parse the file
     test.open(params.filename);
-    TremoloParser &tremolo = FormatParserStorage::getInstance().getParser<TremoloParser>();
-    tremolo.parseKnownTypes(test);
+    parser.parseKnownTypes(test);
     test.close();
   }

src/Actions/ParserAction/SetMpqcParametersAction.cpp

@@ -38 +38 @@
 /** =========== define the function ====================== */
 Action::state_ptr ParserSetMpqcParametersAction::performCall() {
-  MpqcParser_Parameters &mpqc = FormatParserStorage::getInstance().getParser<MpqcParser>().getParams();
+  MpqcParser_Parameters &parser = FormatParserStorage::getInstance().getParser<mpqc>().getParams();
 
   std::stringstream oldparamstream;
-  oldparamstream << mpqc;
+  oldparamstream << parser;
   // obtain information
   getParametersfromValueStorage();
   std::stringstream newparamstream(params.newparams);
-  newparamstream >> mpqc;
+  newparamstream >> parser;
 
   return Action::state_ptr(new ParserSetMpqcParametersState(oldparamstream.str(), params));
@@ -53 +53 @@
   ParserSetMpqcParametersState *state = assert_cast<ParserSetMpqcParametersState*>(_state.get());
 
-  MpqcParser_Parameters &mpqc = FormatParserStorage::getInstance().getParser<MpqcParser>().getParams();
+  MpqcParser_Parameters &parser = FormatParserStorage::getInstance().getParser<mpqc>().getParams();
   std::stringstream oldparamstream(state->oldparams);
-  oldparamstream >> mpqc;
+  oldparamstream >> parser;
 
   return Action::state_ptr(_state);
@@ -63 +63 @@
   ParserSetMpqcParametersState *state = assert_cast<ParserSetMpqcParametersState*>(_state.get());
 
-  MpqcParser_Parameters &mpqc = FormatParserStorage::getInstance().getParser<MpqcParser>().getParams();
+  MpqcParser_Parameters &parser = FormatParserStorage::getInstance().getParser<mpqc>().getParams();
   std::stringstream newparamstream(state->params.newparams);
-  newparamstream >> mpqc;
+  newparamstream >> parser;
 
   return Action::state_ptr(_state);

src/Actions/ParserAction/SetTremoloAtomdataAction.cpp

@@ -42 +42 @@
   getParametersfromValueStorage();
 
-  TremoloParser &tremolo = FormatParserStorage::getInstance().getParser<TremoloParser>();
+  FormatParser<tremolo> &parser = FormatParserStorage::getInstance().getParser<tremolo>();
 
   DoLog(1) && (Log() << Verbose(1) << "Setting Tremolo's ATOMDATA to: '" << params.atomdata_string << "'" << std::endl);
 
-  tremolo.setAtomData(params.atomdata_string);
+  parser.setAtomData(params.atomdata_string);
 
   return Action::success;

src/Parser/FormatParser.hpp

@@ -14 +14 @@
 #endif
 
+#include <iosfwd>
+#include <string>
+#include <vector>
 
-#include "CodePatterns/Observer.hpp"
-#include "ChangeTracker.hpp"
-#include "FormatParser_Parameters.hpp"
-#include "parser.hpp"
+#include "CodePatterns/Assert.hpp"
 
-namespace MoleCuilder {
-  class MoleculeLoadAction;
-}
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
 
 class atom;
 
 /**
+ * @file
+ * <H1> FormatParser Howto </H1>
+ *
+ * <H2> Introduction </H2>
+ *
+ * FormatParsers parse external streams (files) and bring their information
+ * into the World. That is they implement load and save functions that work
+ * on a specific vector atoms.
+ *
+ * <H2> Building your own Parsers </H2>
+ *
+ * Building Parsers is easy. All you have to do is the following:
+ * -# add a new parser type to the file ParserTypes.def.
+ * -# add a new template specialization of FormatParser in a new header and
+ *    module that implement the virtual load and save functions.
+ * -# Add the header file of your new parser to FormatParserStorage.cpp.
+ *
+ * <H3> Specific notes on the macros </H3>
+ *
+ * To clarify a bit the internals of all the different FormatParser... files, here
+ * are some notes:
+ * -# We make use of boost::preprocessor to generate lists from the sequence
+ *    given in ParserTypes.def (and undefined in ParserTypes.undef). These might
+ *    be forward declarations of even implementations. This is to assure that
+ *    none are forgotten when a new FormatParser is added.
+ * -# Thanks to the above construct FormatParserStorage also immediately knows
+ *    about any new parsers and can get and add such instances.
+ */
+
+/**
  * General parser which observes the change tracker.
  */
-class FormatParser : public Observer {
-  friend class MoleCuilder::MoleculeLoadAction;
-public:
-  FormatParser();
-  virtual ~FormatParser();
-  virtual void save(std::ostream* file, const std::vector<atom *> &atoms)=0;
-  virtual void load(std::istream* file)=0;
-  void setOstream(std::ostream* file);
+template <enum ParserTypes Ptype>
+class FormatParser : virtual public FormatParserInterface, public FormatParser_common {
+  FormatParser() :
+    FormatParser_common(NULL)
+  {
+    ASSERT(0, "FormatParser<>::FormatParser() - unspecialized function cannot be called."); 
+  }
+  virtual ~FormatParser()
+  {
+    ASSERT(0, "FormatParser<>::~FormatParser() - unspecialized function cannot be called."); 
+  }
 
-protected:
-  void update(Observable *publisher);
-  void recieveNotification(Observable *publisher, Notification_ptr notification);
-  void subjectKilled(Observable *publisher);
-
-  // these functions are called when atoms are inserted or removed
-  virtual void AtomInserted(atomId_t) {};
-  virtual void AtomRemoved(atomId_t) {};
-
-  FormatParser_Parameters *parameters;
-private:
-
-  std::ostream* saveStream;
+  void load(std::istream *file) 
+  {
+    ASSERT(0, "FormatParser<>::load() - unspecialized function cannot be called."); 
+  }
+  void save(std::ostream *file, const std::vector<atom *> &atoms)
+  {
+    ASSERT(0, "FormatParser<>::save() - unspecialized function cannot be called."); 
+  }
 };
 
+#include "FormatParser_specializations_header.hpp"
+
 #endif /* FORMATPARSER_HPP_ */

src/Parser/FormatParserStorage.cpp

@@ -23 +23 @@
 #include <fstream>
 
-#include "Parser/FormatParserStorage.hpp"
-
+#include <boost/preprocessor/iteration/local.hpp>
+
+#include "CodePatterns/Assert.hpp"
 #include "CodePatterns/Log.hpp"
-#include "CodePatterns/Verbose.hpp"
-
-#include "CodePatterns/Assert.hpp"
 
 #include "molecule.hpp"
+#include "FormatParserStorage.hpp"
+#include "ParserTypes.hpp"
+
+#include "MpqcParser.hpp"
+#include "PcpParser.hpp"
+#include "PdbParser.hpp"
+#include "TremoloParser.hpp"
+#include "XyzParser.hpp"
 
 #include "CodePatterns/Singleton_impl.hpp"
 
-template <> enum ParserTypes getPType<MpqcParser>() { return (enum ParserTypes)mpqc;  }
-template <> enum ParserTypes getPType<PcpParser>() { return (enum ParserTypes)pcp;  }
-template <> enum ParserTypes getPType<PdbParser>() { return (enum ParserTypes)pdb;  }
-template <> enum ParserTypes getPType<TremoloParser>() { return (enum ParserTypes)tremolo;  }
-template <> enum ParserTypes getPType<XyzParser>() { return (enum ParserTypes)xyz;  }
-
-/** Increment operator for the enumeration ParserTypes to allow loops.
- * \param &type value
- * \return value incremented by one
- */
-ParserTypes &operator++(ParserTypes &type)
-{
-  return type = ParserTypes(type+1);
-}
 
 /** Constructor of class FormatParserStorage.
@@ -57 +49 @@
   ParserPresent.resize(ParserTypes_end, false);
 
-  ParserNames[mpqc] = "mpqc";
-  ParserNames[pcp] = "pcp";
-  ParserNames[pdb] = "pdb";
-  ParserNames[tremolo] = "tremolo";
-  ParserNames[xyz] = "xyz";
+#include "ParserTypes.def"
+
+#define insert_print(z,n,seq,map, before, after) \
+   map .insert( std::make_pair(  \
+     BOOST_PP_SEQ_ELEM(n, seq) \
+     , before < \
+       BOOST_PP_SEQ_ELEM(n, seq) \
+       > after \
+     ) );
   
-  for (std::map<ParserTypes, std::string>::const_iterator it = ParserNames.begin(); it != ParserNames.end(); ++it)
-    ParserLookupNames.insert(pair<std::string, ParserTypes>(it->second,it->first) );
-
-  ParserSuffixes[mpqc] = "in";
-  ParserSuffixes[pcp] = "conf";
-  ParserSuffixes[pdb] = "pdb";
-  ParserSuffixes[tremolo] = "data";
-  ParserSuffixes[xyz] = "xyz";
-
-  for (std::map<ParserTypes, std::string>::const_iterator it = ParserSuffixes.begin(); it != ParserSuffixes.end(); ++it)
-    ParserLookupSuffixes.insert(pair<std::string, ParserTypes>(it->second,it->first) );
-
-  ParserAddFunction[mpqc] = &FormatParserStorage::addParser<MpqcParser>;
-  ParserAddFunction[pcp] = &FormatParserStorage::addParser<PcpParser>;
-  ParserAddFunction[pdb] = &FormatParserStorage::addParser<PdbParser>;
-  ParserAddFunction[tremolo] = &FormatParserStorage::addParser<TremoloParser>;
-  ParserAddFunction[xyz] = &FormatParserStorage::addParser<XyzParser>;
+#define insert_invert_print(z,n,seq,map, before, after) \
+   map .insert( std::make_pair( before < \
+   BOOST_PP_SEQ_ELEM(n, seq) \
+   > after, \
+   BOOST_PP_SEQ_ELEM(n, seq) \
+  ) );
+
+  // fill ParserNames
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_print(~, n, PARSERSEQUENCE, ParserNames, FormatParserTrait, ::name)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+
+  // fill ParserLookupNames
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_invert_print(~, n, PARSERSEQUENCE, ParserLookupNames, FormatParserTrait, ::name)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+
+  // fill ParserSuffixes
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_print(~, n, PARSERSEQUENCE, ParserSuffixes, FormatParserTrait, ::suffix)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+
+  // fill ParserLookupSuffixes
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_invert_print(~, n, PARSERSEQUENCE, ParserLookupSuffixes, FormatParserTrait, ::suffix)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+
+  // fill ParserAddFunction
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) insert_print(~, n, PARSERSEQUENCE, ParserAddFunction, &FormatParserStorage::addParser, )
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#endif
+
+#undef insert_print
+#undef insert_invert_print
+#include "ParserTypes.undef"
+
+  //std::cout << "ParserNames:" << std::endl << ParserNames << std::endl;
+  //std::cout << "ParserSuffixes:" << std::endl << ParserSuffixes << std::endl;
+  //std::cout << "ParserLookupNames:" << std::endl << ParserLookupNames << std::endl;
+  //std::cout << "ParserLookupSuffixes:" << std::endl << ParserLookupSuffixes << std::endl;
+  //std::cout << "ParserAddFunction:" << std::endl << ParserAddFunction << std::endl;
+
 }
 
@@ -142 +173 @@
   if (ptype != ParserTypes_end) {
     if (ParserAddFunction.find(ptype) != ParserAddFunction.end()) {
-      DoLog(0) && (Log() << Verbose(0) << "Adding " << ParserNames[ptype] << " type to output." << endl);
+      LOG(0, "STATUS: Adding " << ParserNames[ptype] << " type to output.");
       (getInstance().*(ParserAddFunction[ptype]))(); // we still need an object to work on ...
       return true;
     } else {
-      DoeLog(1) && (eLog() << Verbose(1) << "No parser to add for this known type " << ParserNames[ptype] << ", not implemented?" << endl);
+      ELOG(1, "No parser to add for this known type " << ParserNames[ptype] << ", not implemented?");
       return false;
     }
@@ -156 +187 @@
 bool FormatParserStorage::add(std::string type)
 {
-  return add(getTypeFromName(type));
+  enum ParserTypes Ptype = getTypeFromName(type);
+  return add(Ptype);
 }
 
@@ -246 +278 @@
  * \return reference to the output FormatParser with desired type
  */
-FormatParser &FormatParserStorage::get(ParserTypes _type)
+FormatParserInterface &FormatParserStorage::get(ParserTypes _type)
 {
   if (!ParserPresent[_type]) {

src/Parser/FormatParserStorage.hpp

@@ -16 +16 @@
 #include "CodePatterns/Singleton.hpp"
 
+#include <iosfwd>
+#include <map>
 #include <string>
-#include <map>
 #include <vector>
 
-#include "Parser/ParserTypes.hpp"
-#include "Parser/FormatParser.hpp"
-#include "Parser/MpqcParser.hpp"
-#include "Parser/PcpParser.hpp"
-#include "Parser/PdbParser.hpp"
-#include "Parser/TremoloParser.hpp"
-#include "Parser/XyzParser.hpp"
+#include "CodePatterns/Assert.hpp"
+#include "CodePatterns/Log.hpp"
+#include "FormatParser.hpp"
+#include "ParserTypes.hpp"
 
 class atom;
-
-template <class T> enum ParserTypes getPType();
-template <> enum ParserTypes getPType<MpqcParser>();
-template <> enum ParserTypes getPType<PcpParser>();
-template <> enum ParserTypes getPType<PdbParser>();
-template <> enum ParserTypes getPType<TremoloParser>();
-template <> enum ParserTypes getPType<XyzParser>();
-
+class FormatParserInterface;
 
 class FormatParserStorage : public Singleton<FormatParserStorage> {
@@ -51 +42 @@
   bool saveWorld(std::ostream &output, std::string suffix);
   
-  FormatParser &get(enum ParserTypes _type);
+  FormatParserInterface &get(ParserTypes _type);
 
   ParserTypes getTypeFromName(std::string type);
@@ -65 +56 @@
   
   // list of allocated parsers
-  std::vector<FormatParser *> ParserList;
+  std::vector<FormatParserInterface *> ParserList;
 
   // list of allocated strams
@@ -84 +75 @@
   std::map<std::string, ParserTypes> ParserLookupNames;
 
-
   // prefix of the filenames to use on save
   std::string prefix;
 
 public:
-
-  template<class ParserT> void addParser()
+  template<ParserTypes Ptype> void addParser()
   {
-    enum ParserTypes Ptype = getPType<ParserT>();
     if (!ParserPresent[Ptype]) {
-      ParserList[Ptype] = new ParserT();
+      ParserList[Ptype] = new FormatParser<Ptype>();
       ParserPresent[Ptype] = true;
     } else {
@@ -108 +96 @@
   }
 
-  template<class ParserT> ParserT &getParser() 
+  template<ParserTypes Ptype> FormatParser<Ptype> &getParser() 
   {
-    enum ParserTypes Ptype = getPType<ParserT>();
     if(!ParserPresent[Ptype])
-      addParser<ParserT>();
-    return dynamic_cast<ParserT &>(*ParserList[Ptype]);
+      addParser< Ptype >();
+    return dynamic_cast<FormatParser<Ptype> &>(*ParserList[Ptype]);
   }
-
 };
 

src/Parser/FormatParser_common.cpp

@@ -7 +7 @@
 
 /*
- * FormatParser.cpp
+ * FormatParser_common_common.cpp
  *
  *  Created on: Mar 1, 2010
@@ -20 +20 @@
 #include "CodePatterns/MemDebug.hpp"
 
-#include "FormatParser.hpp"
 #include <iostream>
+
+#include "CodePatterns/Observer.hpp"
+#include "World.hpp"
+#include "ChangeTracker.hpp"
+#include "FormatParser_common.hpp"
 
 using namespace std;
@@ -28 +32 @@
  * Constructor.
  */
-FormatParser::FormatParser() :
-  Observer("FormatParser"),
-  parameters(NULL),
-  saveStream(NULL)
+FormatParser_common::FormatParser_common(FormatParser_Parameters *_parameters) :
+  Observer("FormatParser_common")
 {
+  parameters = _parameters;
   ChangeTracker::getInstance().signOn(this);
   World::getInstance().signOn(this, World::getInstance().getChannel(World::AtomInserted));
@@ -41 +44 @@
  * Destructor.
  */
-FormatParser::~FormatParser() {
+FormatParser_common::~FormatParser_common() 
+{
   ChangeTracker::getInstance().signOff(this);
   World::getInstance().signOff(this, World::getInstance().getChannel(World::AtomInserted));
   World::getInstance().signOff(this, World::getInstance().getChannel(World::AtomRemoved));
+  if (parameters != NULL)
+    delete parameters;
 }
 
@@ -51 +57 @@
  * change tracker here).
  */
-void FormatParser::update(Observable *publisher) {
+void FormatParser_common::update(Observable *publisher) {
   if (!saveStream) {
     cerr << "Please invoke setOstream() so the parser knows where to save the World's data." << endl;
@@ -64 +70 @@
  * With this, each format parser is informed about specific changes in the World.
  */
-void FormatParser::recieveNotification(Observable *publisher, Notification_ptr notification) {
+void FormatParser_common::recieveNotification(Observable *publisher, Notification_ptr notification) {
   switch (notification->getChannelNo()) {
     case World::AtomInserted:
@@ -74 +80 @@
     default:
       ASSERT(0,
-          "FormatParser::recieveNotification() - unknown notification "
+          "FormatParser_common::recieveNotification() - unknown notification "
           +toString(notification->getChannelNo())+" received.");
       break;
@@ -83 +89 @@
  * The observable can tell when it dies.
  */
-void FormatParser::subjectKilled(Observable *publisher) {}
-
+void FormatParser_common::subjectKilled(Observable *publisher) {}
 
 /**
@@ -92 +97 @@
  * \param ostream where to save the World's state
  */
-void FormatParser::setOstream(ostream* output) {
+void FormatParser_common::setOstream(ostream* output) {
   saveStream = output;
 }

src/Parser/Makefile.am

@@ -5 +5 @@
 PARSERSOURCE = \
   Parser/ChangeTracker.cpp \
-  Parser/FormatParser.cpp \
+  Parser/FormatParser_common.cpp \
   Parser/FormatParserStorage.cpp \
   Parser/MpqcParser.cpp \
   Parser/MpqcParser_Parameters.cpp \
   Parser/MpqcParser_Parameters_initBasis.cpp \
+  Parser/ParserTypes.cpp \
   Parser/PcpParser.cpp \
   Parser/PdbAtomInfoContainer.cpp \
@@ -20 +21 @@
   Parser/ChangeTracker.hpp \
   Parser/FormatParser.hpp \
+  Parser/FormatParser_specializations_header.hpp \
+  Parser/FormatParser_common.hpp \
+  Parser/FormatParserInterface.hpp \
+  Parser/FormatParserTrait.hpp \
+  Parser/FormatParserTrait_specializations_header.hpp \
   Parser/FormatParser_Parameters.hpp \
   Parser/FormatParserStorage.hpp \
   Parser/MpqcParser.hpp \
   Parser/MpqcParser_Parameters.hpp \
+  Parser/ParserTypes.hpp \
+  Parser/ParserTypes.def \
+  Parser/ParserTypes.undef \
   Parser/PcpParser.hpp \
   Parser/PdbAtomInfoContainer.hpp \

src/Parser/MpqcParser.cpp

@@ -38 +38 @@
 #include "World.hpp"
 
+// declare specialized static variables
+const std::string FormatParserTrait<mpqc>::name = "mpqc";
+const std::string FormatParserTrait<mpqc>::suffix = "in";
+const ParserTypes FormatParserTrait<mpqc>::type = mpqc;
 
 /** Constructor of MpqcParser.
  *
  */
-MpqcParser::MpqcParser()
-{
-  parameters = new MpqcParser_Parameters();
-}
+FormatParser< mpqc >::FormatParser() :
+  FormatParser_common(new MpqcParser_Parameters())
+{}
 
 /** Destructor of MpqcParser.
  *
  */
-MpqcParser::~MpqcParser()
-{
-  delete parameters;
-}
+FormatParser< mpqc >::~FormatParser()
+{}
 
 /** Load an MPQC config file into the World.
  * \param *file input stream
  */
-void MpqcParser::load(istream *file)
+void FormatParser< mpqc >::load(istream *file)
 {
   bool MpqcSection = false;
@@ -96 +97 @@
         tokenizer::iterator tok_iter = tokens.begin();
         ASSERT(tok_iter != tokens.end(),
-            "MpqcParser::load() - missing token for MoleculeSection in line "+linestring+"!");
+            "FormatParser< mpqc >::load() - missing token for MoleculeSection in line "+linestring+"!");
         std::stringstream whitespacefilter(*tok_iter++);
         std::string element;
         whitespacefilter >> ws >> element;
         ASSERT(tok_iter != tokens.end(),
-            "MpqcParser::load() - missing token for MoleculeSection in line "+linestring+"!");
+            "FormatParser< mpqc >::load() - missing token for MoleculeSection in line "+linestring+"!");
         std::string vector = *tok_iter;
         tokenizer vectorcomponents(vector, whitesep);
@@ -125 +126 @@
         ++tok_iter;
         ASSERT(tok_iter != tokens.end(),
-            "MpqcParser::load() - missing token in brackets<> for mole< in line "+linestring+"!");
+            "FormatParser< mpqc >::load() - missing token in brackets<> for mole< in line "+linestring+"!");
         std::string value(*tok_iter);
         std::stringstream linestream("theory = "+value);
@@ -134 +135 @@
         ++tok_iter;
         ASSERT(tok_iter != tokens.end(),
-            "MpqcParser::load() - missing token in brackets<> for integrals< in line "+linestring+"!");
+            "FormatParser< mpqc >::load() - missing token in brackets<> for integrals< in line "+linestring+"!");
         std::string value(*tok_iter);
         std::stringstream linestream("integration = "+value);
@@ -143 +144 @@
         tokenizer::iterator tok_iter = tokens.begin();
         ASSERT(tok_iter != tokens.end(),
-            "MpqcParser::load() - missing token before '=' for MpqcSection in line "+linestring+"!");
+            "FormatParser< mpqc >::load() - missing token before '=' for MpqcSection in line "+linestring+"!");
         std::stringstream whitespacefilter(*tok_iter);
         std::string key;
@@ -159 +160 @@
       tokenizer::iterator tok_iter = tokens.begin();
       ASSERT(tok_iter != tokens.end(),
-          "MpqcParser::load() - missing token for BasisSection in line "+linestring+"!");
+          "FormatParser< mpqc >::load() - missing token for BasisSection in line "+linestring+"!");
       std::string key(*tok_iter++);
       ASSERT(tok_iter != tokens.end(),
-          "MpqcParser::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
+          "FormatParser< mpqc >::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
       std::string value(*tok_iter);
       tok_iter++;
       // TODO: use exception instead of ASSERT
       ASSERT(tok_iter == tokens.end(),
-          "MpqcParser::load() - more than (key = value) on line "+linestring+".");
+          "FormatParser< mpqc >::load() - more than (key = value) on line "+linestring+".");
       if (key == "name") {
         std::stringstream linestream("basis = "+value);
@@ -177 +178 @@
       tokenizer::iterator tok_iter = tokens.begin();
       ASSERT(tok_iter != tokens.end(),
-          "MpqcParser::load() - missing token for AuxBasisSection in line "+linestring+"!");
+          "FormatParser< mpqc >::load() - missing token for AuxBasisSection in line "+linestring+"!");
       std::string key(*tok_iter++);
       ASSERT(tok_iter != tokens.end(),
-          "MpqcParser::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
+          "FormatParser< mpqc >::load() - missing value for BasisSection after key "+key+" in line "+linestring+"!");
       std::string value(*tok_iter);
       tok_iter++;
       // TODO: use exception instead of ASSERT
       ASSERT(tok_iter == tokens.end(),
-          "MpqcParser::load() - more than (key = value) on line "+linestring+".");
+          "FormatParser< mpqc >::load() - more than (key = value) on line "+linestring+".");
       if (key == "name") {
         std::stringstream linestream("aux_basis = "+value);
@@ -216 +217 @@
  * \param atoms atoms to store
  */
-void MpqcParser::save(ostream *file, const std::vector<atom *> &atoms)
+void FormatParser< mpqc >::save(ostream *file, const std::vector<atom *> &atoms)
 {
   Vector center;

src/Parser/MpqcParser.hpp

@@ -16 +16 @@
 
 #include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+
 #include "MpqcParser_Parameters.hpp"
 
 #include <iosfwd>
 
+// declaration of specialized FormatParserTrait
+template<>
+struct FormatParserTrait<mpqc>
+{
+  //!> Name of the parser
+  static const std::string name;
+  //!> suffix of the files the parser understands to read and write
+  static const std::string suffix;
+  //!> ParserTypes enumeration for the parser
+  static const enum ParserTypes type;
+};
+
 /**
  * Loads a MPQC config file into the World and saves the World as a tremolo file.
  */
-class MpqcParser : public FormatParser
+template <>
+class FormatParser< mpqc >  : virtual public FormatParserInterface, public FormatParser_common
 {
   friend class ParserMpqcUnitTest;
 public:
+  FormatParser();
+  virtual ~FormatParser();
 
-  MpqcParser();
-  virtual ~MpqcParser();
-  void load(std::istream* file);
-  void save(std::ostream* file, const std::vector<atom *> &atoms);
+  void load(std::istream *file);
+  void save(std::ostream *file, const std::vector<atom *> &atoms); 
 
   /** Getter for parameter set.

src/Parser/ParserTypes.hpp

@@ -14 +14 @@
 #endif
 
-// enum has to be outside of class for operator++ to be possible
-enum ParserTypes { mpqc, pcp, pdb, tremolo, xyz, ParserTypes_end, ParserTypes_begin = mpqc };
+#include <boost/preprocessor/seq/elem.hpp>
+#include <boost/preprocessor/seq/seq.hpp>
+#include <boost/preprocessor/seq/size.hpp>
+#include <boost/preprocessor/iteration/local.hpp>
+
+
+#include "ParserTypes.def"
+
+//!> function to print each member of the sequence in the enumeration
+#define sequence_print(z,n,seq) \
+  BOOST_PP_SEQ_ELEM(n, seq) ,
+
+//!> Enumeration of all known parsers
+enum ParserTypes { 
+// some proprocessor magic to generate the body from the above sequence
+#if defined ParserTypes_END // do we have parameters at all?
+#define BOOST_PP_LOCAL_MACRO(n) sequence_print(~, n, PARSERSEQUENCE)
+#define BOOST_PP_LOCAL_LIMITS  (0, ParserTypes_END-1)
+#include BOOST_PP_LOCAL_ITERATE()
+#undef BOOST_PP_LOCAL_MACRO
+#undef BOOST_PP_LOCAL_LIMITS
+#endif
+  ParserTypes_end = ParserTypes_END, 
+  ParserTypes_begin = BOOST_PP_SEQ_HEAD(PARSERSEQUENCE)
+};
+
+#undef sequence_print
+
+//!> Number of known ParserTypes
+const size_t ParserTypesMax = ParserTypes_END;
+
+#include "ParserTypes.undef"
+
+//!> Typedef for enumeration to ease its use
 typedef enum ParserTypes ParserTypes;
+
+/** Increment operator for the enumeration ParserTypes to allow loops.
+ * \param &type value
+ * \return value incremented by one
+ */
+ParserTypes &operator++(ParserTypes &type);
 
 #endif /* PARSERTYPES_HPP_ */

src/Parser/PcpParser.cpp

@@ -40 +40 @@
 
 
-PcpParser::StructParallelization::StructParallelization() :
+// declare specialized static variables
+const std::string FormatParserTrait<pcp>::name = "pcp";
+const std::string FormatParserTrait<pcp>::suffix = "conf";
+const ParserTypes FormatParserTrait<pcp>::type = pcp;
+
+FormatParser< pcp >::StructParallelization::StructParallelization() :
   ProcPEGamma(8),
   ProcPEPsi(1)
 {}
 
-PcpParser::StructParallelization::~StructParallelization()
-{}
-
-PcpParser::StructPaths::StructPaths() :
+FormatParser< pcp >::StructParallelization::~StructParallelization()
+{}
+
+FormatParser< pcp >::StructPaths::StructPaths() :
   databasepath(NULL),
   configname(NULL),
@@ -56 +61 @@
 {}
 
-PcpParser::StructPaths::~StructPaths()
-{}
-
-PcpParser::StructSwitches::StructSwitches() :
+FormatParser< pcp >::StructPaths::~StructPaths()
+{}
+
+FormatParser< pcp >::StructSwitches::StructSwitches() :
   DoConstrainedMD(0),
   DoOutVis(0),
@@ -71 +76 @@
 {}
 
-PcpParser::StructSwitches::~StructSwitches()
-{}
-
-PcpParser::StructLocalizedOrbitals::StructLocalizedOrbitals() :
+FormatParser< pcp >::StructSwitches::~StructSwitches()
+{}
+
+FormatParser< pcp >::StructLocalizedOrbitals::StructLocalizedOrbitals() :
   CommonWannier(0),
   SawtoothStart(0.01),
@@ -84 +89 @@
 {}
 
-PcpParser::StructLocalizedOrbitals::~StructLocalizedOrbitals()
-{}
-
-PcpParser::StructStepCounts::StructStepCounts() :
+FormatParser< pcp >::StructLocalizedOrbitals::~StructLocalizedOrbitals()
+{}
+
+FormatParser< pcp >::StructStepCounts::StructStepCounts() :
   MaxMinStopStep(1),
   InitMaxMinStopStep(1),
@@ -104 +109 @@
 {}
 
-PcpParser::StructStepCounts::~StructStepCounts()
-{}
-
-PcpParser::StructPlaneWaveSpecifics::StructPlaneWaveSpecifics() :
+FormatParser< pcp >::StructStepCounts::~StructStepCounts()
+{}
+
+FormatParser< pcp >::StructPlaneWaveSpecifics::StructPlaneWaveSpecifics() :
   PsiType(0),
   MaxPsiDouble(0),
@@ -123 +128 @@
 {}
 
-PcpParser::StructPlaneWaveSpecifics::~StructPlaneWaveSpecifics()
+FormatParser< pcp >::StructPlaneWaveSpecifics::~StructPlaneWaveSpecifics()
 {}
 
@@ -129 +134 @@
  *
  */
-PcpParser::PcpParser() :
+FormatParser< pcp >::FormatParser() :
+  FormatParser_common(NULL),
   FastParsing(false),
   Deltat(0.01),
@@ -141 +147 @@
  *
  */
-PcpParser::~PcpParser()
-{}
-
-void PcpParser::load(std::istream* file)
+FormatParser< pcp >::~FormatParser()
+{}
+
+void FormatParser< pcp >::load(std::istream* file)
 {
   if (file->fail()) {
@@ -380 +386 @@
  * \param atoms atoms to store
  */
-void PcpParser::save(std::ostream* file, const std::vector<atom *> &atoms)
+void FormatParser< pcp >::save(std::ostream* file, const std::vector<atom *> &atoms)
 {
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to pcp." << std::endl);
@@ -414 +420 @@
     *file << "DoFullCurrent\t" << Switches.DoFullCurrent << "\t# Do full perturbation" << endl;
     *file << "DoConstrainedMD\t" << Switches.DoConstrainedMD << "\t# Do perform a constrained (>0, relating to current MD step) instead of unconstrained (0) MD" << endl;
-    ASSERT(Thermostats != NULL, "PcpParser::save() - Thermostats not initialized!");
+    ASSERT(Thermostats != NULL, "FormatParser< pcp >::save() - Thermostats not initialized!");
     *file << "Thermostat\t" << Thermostats->activeThermostat->name() << "\t";
     *file << Thermostats->activeThermostat->writeParams();
@@ -487 +493 @@
  * \param &allatoms all atoms to store away
  */
-void PcpParser::CalculateOrbitals(const std::vector<atom *> &allatoms)
+void FormatParser< pcp >::CalculateOrbitals(const std::vector<atom *> &allatoms)
 {
   PlaneWaveSpecifics.MaxPsiDouble = PlaneWaveSpecifics.PsiMaxNoDown = PlaneWaveSpecifics.PsiMaxNoUp = PlaneWaveSpecifics.PsiType = 0;
@@ -520 +526 @@
  * \param &ZtoIndexMap map of which atoms belong to which ion number
  */
-void PcpParser::OutputElements(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
+void FormatParser< pcp >::OutputElements(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
 {
   map<int, int> PresentElements;
@@ -550 +556 @@
  * \param &ZtoIndexMap map of which atoms belong to which ion number
  */
-void PcpParser::OutputAtoms(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
+void FormatParser< pcp >::OutputAtoms(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap)
 {
   *file << "#Ion_TypeNr._Nr.R[0]    R[1]    R[2]    MoveType (0 MoveIon, 1 FixedIon)" << endl;
@@ -598 +604 @@
  * \param *fb file buffer containing the config file
  */
-void PcpParser::ParseThermostats(class ConfigFileBuffer * const fb)
+void FormatParser< pcp >::ParseThermostats(class ConfigFileBuffer * const fb)
 {
   char * const thermo = new char[12];
@@ -615 +621 @@
 };
 
-bool PcpParser::operator==(const PcpParser& b) const
+bool FormatParser< pcp >::operator==(const FormatParser< pcp >& b) const
 {
   ASSERT(Parallelization.ProcPEGamma == b.Parallelization.ProcPEGamma, "PcpParser ==: ProcPEGamma not");

src/Parser/PcpParser.hpp

@@ -14 +14 @@
 #endif
 
+#include <iosfwd>
+#include <map>
+#include <string>
+#include <vector>
 
-#include <iosfwd>
-#include "Parser/FormatParser.hpp"
+#include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+
+class atom;
+
+// declaration of specialized FormatParserTrait
+template<>
+struct FormatParserTrait<pcp>
+{
+  //!> Name of the parser
+  static const std::string name;
+  //!> suffix of the files the parser understands to read and write
+  static const std::string suffix;
+  //!> ParserTypes enumeration for the parser
+  static const enum ParserTypes type;
+};
 
 /**
  * Parser for PCP config files.
  */
-class PcpParser : public FormatParser {
+template <>
+class FormatParser< pcp >  : virtual public FormatParserInterface, public FormatParser_common
+{
 public:
-  PcpParser();
-  virtual ~PcpParser();
+  FormatParser();
+  virtual ~FormatParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);
 
-  bool operator==(const PcpParser& b) const;
+  bool operator==(const FormatParser< pcp >& b) const;
 
 private:
 
   void ParseThermostats(class ConfigFileBuffer * const fb);
-  void OutputAtoms(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap);
-  void OutputElements(ostream *file, const std::vector<atom *> &allatoms, map<int, int> &ZtoIndexMap);
+  void OutputAtoms(std::ostream *file, const std::vector<atom *> &allatoms, std::map<int, int> &ZtoIndexMap);
+  void OutputElements(std::ostream *file, const std::vector<atom *> &allatoms, std::map<int, int> &ZtoIndexMap);
   void CalculateOrbitals(const std::vector<atom *> &allatoms);
 
@@ -154 +177 @@
   int StructOpt;
   int MaxTypes;
-  string basis;
+  std::string basis;
 };
 

src/Parser/PdbAtomInfoContainer.hpp

@@ -14 +14 @@
 #endif
 
+#include <string>
+#include <typeinfo>
 
+#include "LinearAlgebra/Vector.hpp"
 #include "PdbKey.hpp"
 
-class PdbParser;
-class Vector;
+#include "ParserTypes.hpp"
 
-#include <string>
-#include <typeinfo>
+//template <class T> class FormatParser;
+//template<> class FormatParser< pdb >;
 
 /**
@@ -27 +29 @@
  */
 class PdbAtomInfoContainer {
-  friend class PdbParser;
+  //!> Grant all FormatParser specializations access, otherwise we have to fully define FormatParser<pdb>
+  template<enum ParserTypes> friend class FormatParser;
 public:
   PdbAtomInfoContainer();

src/Parser/PdbParser.cpp

@@ -44 +44 @@
 using namespace std;
 
+// declare specialized static variables
+const std::string FormatParserTrait<pdb>::name = "pdb";
+const std::string FormatParserTrait<pdb>::suffix = "pdb";
+const ParserTypes FormatParserTrait<pdb>::type = pdb;
+
 /**
  * Constructor.
  */
-PdbParser::PdbParser() {
+FormatParser< pdb >::FormatParser() :
+  FormatParser_common(NULL)
+{
   knownTokens["ATOM"] = PdbKey::Atom;
   knownTokens["HETATM"] = PdbKey::Atom;
@@ -65 +72 @@
  * Destructor.
  */
-PdbParser::~PdbParser() {
+FormatParser< pdb >::~FormatParser() 
+{
   PdbAtomInfoContainer::clearknownDataKeys();
   additionalAtomData.clear();
@@ -77 +85 @@
  * @return token type
  */
-enum PdbKey::KnownTokens PdbParser::getToken(string &line)
+enum PdbKey::KnownTokens FormatParser< pdb >::getToken(string &line)
 {
   // look for first space
@@ -105 +113 @@
  * \param PDB file
  */
-void PdbParser::load(istream* file) {
+void FormatParser< pdb >::load(istream* file) {
   string line;
   size_t linecount  = 0;
@@ -148 +156 @@
             // TODO: put a throw here
             DoeLog(2) && (eLog() << Verbose(2) << "Unknown token: '" << line << "' for time step " << step << "." << std::endl);
-            //ASSERT(0, "PdbParser::load() - Unknown token in line "+toString(linecount)+": "+line+".");
+            //ASSERT(0, "FormatParser< pdb >::load() - Unknown token in line "+toString(linecount)+": "+line+".");
             break;
         }
@@ -170 +178 @@
  * \param atoms atoms to store
  */
-void PdbParser::save(ostream* file, const std::vector<atom *> &AtomList)
+void FormatParser< pdb >::save(ostream* file, const std::vector<atom *> &AtomList)
 {
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to pdb." << std::endl);
@@ -240 +248 @@
         } else {
           ASSERT(MolIdMap.find(mol->getId()) != MolIdMap.end(),
-              "PdbParser::save() - Mol id "+toString(mol->getId())+" not present despite we set it?!");
+              "FormatParser< pdb >::save() - Mol id "+toString(mol->getId())+" not present despite we set it?!");
           MolNo = MolIdMap[mol->getId()];
           atomInfo.set(PdbKey::resSeq, toString(MolIdMap[mol->getId()]));
@@ -289 +297 @@
  * @param id of atom
  */
-void PdbParser::AtomInserted(atomId_t id)
-{
-  //LOG(3, "PdbParser::AtomInserted() - notified of atom " << id << "'s insertion.");
+void FormatParser< pdb >::AtomInserted(atomId_t id)
+{
+  //LOG(3, "FormatParser< pdb >::AtomInserted() - notified of atom " << id << "'s insertion.");
   ASSERT(!isPresentadditionalAtomData(id),
-      "PdbParser::AtomInserted() - additionalAtomData already present for newly added atom "
+      "FormatParser< pdb >::AtomInserted() - additionalAtomData already present for newly added atom "
       +toString(id)+".");
   // don't insert here as this is our check whether we are in the first time step
@@ -304 +312 @@
  * @param id of atom
  */
-void PdbParser::AtomRemoved(atomId_t id)
-{
-  //LOG(3, "PdbParser::AtomRemoved() - notified of atom " << id << "'s removal.");
+void FormatParser< pdb >::AtomRemoved(atomId_t id)
+{
+  //LOG(3, "FormatParser< pdb >::AtomRemoved() - notified of atom " << id << "'s removal.");
   std::map<size_t, PdbAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
   // as we do not insert AtomData on AtomInserted, we cannot be assured of its presence
 //  ASSERT(iter != additionalAtomData.end(),
-//      "PdbParser::AtomRemoved() - additionalAtomData is not present for atom "
+//      "FormatParser< pdb >::AtomRemoved() - additionalAtomData is not present for atom "
 //      +toString(id)+" to remove.");
   if (iter != additionalAtomData.end()) {
@@ -325 +333 @@
  * @return true - entry present, false - only for atom's father or no entry
  */
-bool PdbParser::isPresentadditionalAtomData(unsigned int _id)
+bool FormatParser< pdb >::isPresentadditionalAtomData(unsigned int _id)
 {
   return (additionalAtomData.find(_id) != additionalAtomData.end());
@@ -336 +344 @@
  * @return
  */
-PdbAtomInfoContainer& PdbParser::getadditionalAtomData(atom *_atom)
+PdbAtomInfoContainer& FormatParser< pdb >::getadditionalAtomData(atom *_atom)
 {
   if (additionalAtomData.find(_atom->getId()) != additionalAtomData.end()) {
@@ -362 +370 @@
  * \param ResidueNo number of residue
  */
-void PdbParser::saveLine(
+void FormatParser< pdb >::saveLine(
     ostream* file,
     const PdbAtomInfoContainer &atomInfo)
@@ -423 +431 @@
  * \param *currentAtom to the atom of which to take the neighbor information
  */
-void PdbParser::writeNeighbors(ostream* file, int MaxnumberOfNeighbors, atom* currentAtom) {
+void FormatParser< pdb >::writeNeighbors(ostream* file, int MaxnumberOfNeighbors, atom* currentAtom) {
   int MaxNo = MaxnumberOfNeighbors;
   int charsleft = 80;
@@ -452 +460 @@
 }
 
-/** Retrieves a value from PdbParser::atomIdMap.
+/** Retrieves a value from  FormatParser< pdb >::atomIdMap.
  * \param atomid key
  * \return value
  */
-size_t PdbParser::getSerial(const size_t atomid) const
-{
-  ASSERT(atomIdMap.find(atomid) != atomIdMap.end(),
-      "PdbParser::getSerial() - atomid "+toString(atomid)+" not present in Map.");
+size_t FormatParser< pdb >::getSerial(const size_t atomid) const
+{
+  ASSERT(atomIdMap.find(atomid) != atomIdMap.end(), 
+      "FormatParser< pdb >::getAtomId: atomid "+toString(atomid)+" not present in Map.");
   return (atomIdMap.find(atomid)->second);
 }
 
-/** Sets an entry in PdbParser::atomIdMap.
+/** Sets an entry in  FormatParser< pdb >::atomIdMap.
  * \param localatomid key
  * \param atomid value
  * \return true - key not present, false - value present
  */
-void PdbParser::setSerial(const size_t localatomid, const size_t atomid)
+void FormatParser< pdb >::setSerial(const size_t localatomid, const size_t atomid)
 {
   pair<std::map<size_t,size_t>::iterator, bool > inserter;
-//  DoLog(1) && (Log() << Verbose(1) << "PdbParser::setAtomId() - Inserting ("
+//  DoLog(1) && (Log() << Verbose(1) << "FormatParser< pdb >::setAtomId() - Inserting ("
 //      << localatomid << " -> " << atomid << ")." << std::endl);
   inserter = atomIdMap.insert( make_pair(localatomid, atomid) );
-  ASSERT(inserter.second, "PdbParser::setAtomId: atomId already present in Map.");
+  ASSERT(inserter.second, "FormatParser< pdb >::setAtomId: atomId already present in Map.");
 }
 
@@ -482 +490 @@
  * @return
  */
-atom* PdbParser::getAtomToParse(std::string id_string) const
+atom* FormatParser< pdb >::getAtomToParse(std::string id_string) const
 {
   // get the local ID
@@ -517 +525 @@
  * @param line line containing key ATOM
  */
-void PdbParser::readPdbAtomInfoContainer(PdbAtomInfoContainer &atomInfo, std::string &line) const
+void FormatParser< pdb >::readPdbAtomInfoContainer(PdbAtomInfoContainer &atomInfo, std::string &line) const
 {
   const size_t length = line.length();
   if (length < 80)
-    ELOG(2, "PdbParser::readPdbAtomInfoContainer() - pdb is mal-formed, containing less than 80 chars!");
+    ELOG(2, "FormatParser< pdb >::readPdbAtomInfoContainer() - pdb is mal-formed, containing less than 80 chars!");
   if (length >= 6) {
     LOG(4,"INFO: Parsing token from "+line.substr(0,6)+".");
@@ -530 +538 @@
     atomInfo.set(PdbKey::serial, line.substr(6,5));
     ASSERT(atomInfo.get<int>(PdbKey::serial) != 0,
-        "PdbParser::readPdbAtomInfoContainer() - serial 0 is invalid (filler id for conect entries).");
+        "FormatParser< pdb >::readPdbAtomInfoContainer() - serial 0 is invalid (filler id for conect entries).");
   }
 
@@ -591 +599 @@
  * \param newmol molecule to add parsed atoms to
  */
-void PdbParser::readAtomDataLine(const unsigned int _step, std::string &line, molecule *newmol = NULL) {
+void FormatParser< pdb >::readAtomDataLine(const unsigned int _step, std::string &line, molecule *newmol = NULL) {
   vector<string>::iterator it;
 
@@ -598 +606 @@
   bool FirstTimestep = isPresentadditionalAtomData(newAtom->getId()) ? false : true;
   ASSERT((FirstTimestep && (_step == 0)) || (!FirstTimestep && (_step !=0)),
-      "PdbParser::readAtomDataLine() - additionalAtomData present though atom is newly parsed.");
+      "FormatParser< pdb >::readAtomDataLine() - additionalAtomData present though atom is newly parsed.");
   if (FirstTimestep) {
     LOG(3,"INFO: Parsing new atom.");
@@ -646 +654 @@
       SerialSet.insert(toSize_t(atomInfo.get<std::string>(PdbKey::serial)));
     ASSERT(Inserter.second,
-        "PdbParser::readAtomDataLine() - ATOM contains entry with serial "
+        "FormatParser< pdb >::readAtomDataLine() - ATOM contains entry with serial "
         +atomInfo.get<std::string>(PdbKey::serial)+" already present!");
     setSerial(toSize_t(atomInfo.get<std::string>(PdbKey::serial)), newAtom->getId());
@@ -667 +675 @@
         ->FindElement(value);
     ASSERT(elem != NULL,
-        "PdbParser::readAtomDataLine() - element "+atomInfo.get<std::string>(PdbKey::element)+" is unknown!");
+        "FormatParser< pdb >::readAtomDataLine() - element "+atomInfo.get<std::string>(PdbKey::element)+" is unknown!");
     newAtom->setType(elem);
 
@@ -679 +687 @@
     // then check additional info for consistency
     ASSERT(atomInfo.get<std::string>(PdbKey::token) == consistencyInfo.get<std::string>(PdbKey::token),
-        "PdbParser::readAtomDataLine() - difference in token on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in token on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::name) == consistencyInfo.get<std::string>(PdbKey::name),
-        "PdbParser::readAtomDataLine() - difference in name on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in name on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+":"
         +atomInfo.get<std::string>(PdbKey::name)+"!="
         +consistencyInfo.get<std::string>(PdbKey::name)+".");
     ASSERT(atomInfo.get<std::string>(PdbKey::altLoc) == consistencyInfo.get<std::string>(PdbKey::altLoc),
-        "PdbParser::readAtomDataLine() - difference in altLoc on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in altLoc on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::resName) == consistencyInfo.get<std::string>(PdbKey::resName),
-        "PdbParser::readAtomDataLine() - difference in resName on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in resName on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::chainID) == consistencyInfo.get<std::string>(PdbKey::chainID),
-        "PdbParser::readAtomDataLine() - difference in chainID on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in chainID on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::resSeq) == consistencyInfo.get<std::string>(PdbKey::resSeq),
-        "PdbParser::readAtomDataLine() - difference in resSeq on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in resSeq on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::iCode) == consistencyInfo.get<std::string>(PdbKey::iCode),
-        "PdbParser::readAtomDataLine() - difference in iCode on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in iCode on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::occupancy) == consistencyInfo.get<std::string>(PdbKey::occupancy),
-        "PdbParser::readAtomDataLine() - difference in occupancy on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in occupancy on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::tempFactor) == consistencyInfo.get<std::string>(PdbKey::tempFactor),
-        "PdbParser::readAtomDataLine() - difference in tempFactor on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in tempFactor on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::charge) == consistencyInfo.get<std::string>(PdbKey::charge),
-        "PdbParser::readAtomDataLine() - difference in charge on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in charge on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     ASSERT(atomInfo.get<std::string>(PdbKey::element) == consistencyInfo.get<std::string>(PdbKey::element),
-        "PdbParser::readAtomDataLine() - difference in element on multiple time step for atom with id "
+        "FormatParser< pdb >::readAtomDataLine() - difference in element on multiple time step for atom with id "
         +atomInfo.get<std::string>(PdbKey::serial)+"!");
     // and parse in trajectory
@@ -734 +742 @@
  *
  */
-void PdbParser::printAtomInfo(const atom * const newAtom) const
+void FormatParser< pdb >::printAtomInfo(const atom * const newAtom) const
 {
   const PdbAtomInfoContainer &atomInfo = additionalAtomData.at(newAtom->getId()); // operator[] const does not exist
@@ -762 +770 @@
  * \param line to parse as an atom
  */
-void PdbParser::readNeighbors(const unsigned int _step, std::string &line)
+void FormatParser< pdb >::readNeighbors(const unsigned int _step, std::string &line)
 {
   const size_t length = line.length();
@@ -772 +780 @@
   string output;
   ASSERT(length >=16,
-      "PdbParser::readNeighbors() - CONECT entry has not enough entries: "+line+"!");
-  output = "Split line:|";
-  output += line.substr(6,5) + "|";
+      "FormatParser< pdb >::readNeighbors() - CONECT entry has not enough entries: "+line+"!");
+//  output = "Split line:|";
+//  output += line.substr(6,5) + "|";
   const size_t id = toSize_t(line.substr(6,5));
   for (size_t index = 11; index <= 26; index+=5) {
@@ -785 +793 @@
         ListOfNeighbors.push_back(otherid);
       else
-        ELOG(2, "PdbParser::readNeighbors() - discarding conect entry with id 0.");
+        ELOG(2, "FormatParser< pdb >::readNeighbors() - discarding conect entry with id 0.");
     } else  {
       break;
@@ -813 +821 @@
  * \return input string with modified atom IDs
  */
-//string PdbParser::adaptIdDependentDataString(string data) {
+//string  FormatParser< pdb >::adaptIdDependentDataString(string data) {
 //  // there might be no IDs
 //  if (data == "-") {
@@ -836 +844 @@
 
 
-bool PdbParser::operator==(const PdbParser& b) const
+bool FormatParser< pdb >::operator==(const FormatParser< pdb >& b) const
 {
   bool status = true;

src/Parser/PdbParser.hpp

@@ -14 +14 @@
 #endif
 
+#include <string>
 
-#include <string>
 #include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+
 #include "PdbAtomInfoContainer.hpp"
 #include "PdbKey.hpp"
+
+class molecule;
+
+// declaration of specialized FormatParserTrait
+template<>
+struct FormatParserTrait<pdb>
+{
+  //!> Name of the parser
+  static const std::string name;
+  //!> suffix of the files the parser understands to read and write
+  static const std::string suffix;
+  //!> ParserTypes enumeration for the parser
+  static const enum ParserTypes type;
+};
 
 /**
  * Loads a PDB format 3.2 file into the World and saves the World as a PDB file.
  */
-class PdbParser : public FormatParser
+template <>
+class FormatParser< pdb >  : virtual public FormatParserInterface, public FormatParser_common
 {
 public:
-  PdbParser();
-  virtual ~PdbParser();
+  FormatParser();
+  virtual ~FormatParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);
 
-  bool operator==(const PdbParser& b) const;
+  bool operator==(const FormatParser< pdb>& b) const;
   void printAtomInfo(const atom *newAtom) const;
 
@@ -91 +111 @@
    */
   std::set<size_t> SerialSet;
-
 };
 

src/Parser/TremoloParser.cpp

@@ -42 +42 @@
 using namespace std;
 
+// declare specialized static variables
+const std::string FormatParserTrait<tremolo>::name = "tremolo";
+const std::string FormatParserTrait<tremolo>::suffix = "data";
+const ParserTypes FormatParserTrait<tremolo>::type = tremolo;
+
 /**
  * Constructor.
  */
-TremoloParser::TremoloParser() {
+FormatParser< tremolo >::FormatParser()  :
+  FormatParser_common(NULL)
+{
   knownKeys["x"] = TremoloKey::x;
   knownKeys["u"] = TremoloKey::u;
@@ -87 +94 @@
  * Destructor.
  */
-TremoloParser::~TremoloParser() {
-        std::cerr << "Clearing usedFields." << std::endl;
+FormatParser< tremolo >::~FormatParser() 
+{
+  std::cerr << "Clearing usedFields." << std::endl;
   usedFields.clear();
   additionalAtomData.clear();
@@ -100 +108 @@
  * \param tremolo file
  */
-void TremoloParser::load(istream* file) {
+void FormatParser< tremolo >::load(istream* file) {
   string line;
   string::size_type location;
@@ -141 +149 @@
  * \param atoms atoms to store
  */
-void TremoloParser::save(ostream* file, const std::vector<atom *> &AtomList) {
+void FormatParser< tremolo >::save(ostream* file, const std::vector<atom *> &AtomList) {
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to tremolo." << std::endl);
 
@@ -169 +177 @@
  * @param id of atom
  */
-void TremoloParser::AtomInserted(atomId_t id)
+void FormatParser< tremolo >::AtomInserted(atomId_t id)
 {
   std::map<int, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
   ASSERT(iter == additionalAtomData.end(),
-      "TremoloParser::AtomInserted() - additionalAtomData already present for newly added atom "
+      "FormatParser< tremolo >::AtomInserted() - additionalAtomData already present for newly added atom "
       +toString(id)+".");
   // don't add entry, as this gives a default resSeq of 0 not the molecule id
@@ -183 +191 @@
  * @param id of atom
  */
-void TremoloParser::AtomRemoved(atomId_t id)
+void FormatParser< tremolo >::AtomRemoved(atomId_t id)
 {
   std::map<int, TremoloAtomInfoContainer>::iterator iter = additionalAtomData.find(id);
   // as we do not insert AtomData on AtomInserted, we cannot be assured of its presence
 //  ASSERT(iter != additionalAtomData.end(),
-//      "TremoloParser::AtomRemoved() - additionalAtomData is not present for atom "
+//      "FormatParser< tremolo >::AtomRemoved() - additionalAtomData is not present for atom "
 //      +toString(id)+" to remove.");
   if (iter != additionalAtomData.end())
@@ -201 +209 @@
  *        but without the prexix "ATOMDATA"
  */
-void TremoloParser::setFieldsForSave(std::string atomDataLine) {
+void FormatParser< tremolo >::setFieldsForSave(std::string atomDataLine) {
   parseAtomDataKeysLine(atomDataLine, 0);
 }
@@ -212 +220 @@
  * \param reference to the atom of which information should be written
  */
-void TremoloParser::saveLine(ostream* file, atom* currentAtom) {
- /* vector<string>::iterator it;*/
-        vector<string>::iterator it = unique(usedFields.begin(), usedFields.end()); // skips all duplicates in the vector
+void FormatParser< tremolo >::saveLine(ostream* file, atom* currentAtom) {
+  //vector<string>::iterator it;
+  // TODO: Is unique for FormatParser< tremolo >::usedFields still required?
+  vector<string>::iterator it = unique(usedFields.begin(), usedFields.end()); // skips all duplicates in the vector
 
   TremoloKey::atomDataKey currentField;
@@ -308 +317 @@
  * \param reference to the atom of which to take the neighbor information
  */
-void TremoloParser::writeNeighbors(ostream* file, int numberOfNeighbors, atom* currentAtom) {
+void FormatParser< tremolo >::writeNeighbors(ostream* file, int numberOfNeighbors, atom* currentAtom) {
   const BondList& ListOfBonds = currentAtom->getListOfBonds();
   // sort bonded indices
@@ -331 +340 @@
  * \param with which offset the keys begin within the line
  */
-void TremoloParser::parseAtomDataKeysLine(string line, int offset) {
+void FormatParser< tremolo >::parseAtomDataKeysLine(string line, int offset) {
   string keyword;
   stringstream lineStream;
@@ -353 +362 @@
  *  \a atomdata_string.
  *
- *  We just call \sa TremoloParser::parseAtomDataKeysLine() which is left
+ *  We just call \sa  FormatParser< tremolo >::parseAtomDataKeysLine() which is left
  *  private.,
  *
  * @param atomdata_string line to parse with space-separated values
  */
-void TremoloParser::setAtomData(const std::string &atomdata_string)
+void FormatParser< tremolo >::setAtomData(const std::string &atomdata_string)
 {
   parseAtomDataKeysLine(atomdata_string, 0);
@@ -371 +380 @@
  * \param *newmol molecule to add atom to
  */
-void TremoloParser::readAtomDataLine(string line, molecule *newmol = NULL) {
+void FormatParser< tremolo >::readAtomDataLine(string line, molecule *newmol = NULL) {
   vector<string>::iterator it;
   stringstream lineStream;
@@ -389 +398 @@
   tokenizer tokens(line, whitespacesep);
   ASSERT(tokens.begin() != tokens.end(),
-      "TremoloParser::readAtomDataLine - empty string, need at least ' '!");
+      "FormatParser< tremolo >::readAtomDataLine - empty string, need at least ' '!");
   tokenizer::iterator tok_iter = tokens.begin();
   // then associate each token to each file
@@ -401 +410 @@
         // for the moment, assume there are always three dimensions
         for (int i=0;i<NDIM;i++) {
-          ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for x["+toString(i)+"]!");
+          ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for x["+toString(i)+"]!");
           DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
           newAtom->set(i, toDouble(*tok_iter));
@@ -410 +419 @@
         // for the moment, assume there are always three dimensions
         for (int i=0;i<NDIM;i++) {
-          ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for u["+toString(i)+"]!");
+          ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for u["+toString(i)+"]!");
           DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
           tempVector[i] = toDouble(*tok_iter);
@@ -419 +428 @@
       case TremoloKey::type :
       {
-        ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
+        ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
         DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
         std::string element(knownTypes[(*tok_iter)]);
@@ -431 +440 @@
       }
       case TremoloKey::Id :
-        ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
+        ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
         DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
         atomIdMap[toInt(*tok_iter)] = newAtom->getId();
@@ -438 +447 @@
       case TremoloKey::neighbors :
         for (int i=0;i<atoi(it->substr(it->find("=") + 1, 1).c_str());i++) {
-          ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
+          ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
           DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
           lineStream << *tok_iter << "\t";
@@ -447 +456 @@
         break;
       default :
-        ASSERT(tok_iter != tokens.end(), "TremoloParser::readAtomDataLine() - no value for "+keyName+"!");
+        ASSERT(tok_iter != tokens.end(), "FormatParser< tremolo >::readAtomDataLine() - no value for "+keyName+"!");
         DoLog(4) && (Log() << Verbose(4) << "INFO: Parsing key " << keyName << " with next token " << *tok_iter << std::endl);
         atomInfo->set(currentField, *tok_iter);
@@ -467 +476 @@
  * \param atomid world id of the atom the information belongs to
  */
-void TremoloParser::readNeighbors(stringstream* line, int numberOfNeighbors, int atomId) {
+void FormatParser< tremolo >::readNeighbors(stringstream* line, int numberOfNeighbors, int atomId) {
   int neighborId = 0;
   for (int i = 0; i < numberOfNeighbors; i++) {
@@ -489 +498 @@
  * \return true if the field name is used
  */
-bool TremoloParser::isUsedField(string fieldName) {
+bool FormatParser< tremolo >::isUsedField(string fieldName) {
   bool fieldNameExists = false;
   for (vector<string>::iterator usedField = usedFields.begin(); usedField != usedFields.end(); usedField++) {
@@ -505 +514 @@
  * Id found in the parsed file.
  */
-void TremoloParser::processNeighborInformation() {
+void FormatParser< tremolo >::processNeighborInformation() {
   if (!isUsedField("neighbors")) {
     return;
@@ -538 +547 @@
  * \return input string with modified atom IDs
  */
-string TremoloParser::adaptIdDependentDataString(string data) {
+std::string FormatParser< tremolo >::adaptIdDependentDataString(string data) {
   // there might be no IDs
   if (data == "-") {
@@ -563 +572 @@
  * as they might differ from the originally read IDs.
  */
-void TremoloParser::adaptImprData() {
+void FormatParser< tremolo >::adaptImprData() {
   if (!isUsedField("imprData")) {
     return;
@@ -579 +588 @@
  * as they might differ from the originally read IDs.
  */
-void TremoloParser::adaptTorsion() {
+void FormatParser< tremolo >::adaptTorsion() {
   if (!isUsedField("torsion")) {
     return;
@@ -594 +603 @@
  *
  */
-void TremoloParser::createKnownTypesByIdentity()
+void FormatParser< tremolo >::createKnownTypesByIdentity()
 {
   // remove old mapping
@@ -611 +620 @@
  * @param file input stream of .potentials file
  */
-void TremoloParser::parseKnownTypes(std::istream &file)
+void FormatParser< tremolo >::parseKnownTypes(std::istream &file)
 {
   const periodentafel *periode = World::getInstance().getPeriode();
@@ -632 +641 @@
       tokenizer tokens(line, tokensep);
       ASSERT(tokens.begin() != tokens.end(),
-          "TremoloParser::parseKnownTypes() - line with 'particle:' but no particles separated by comma.");
+          "FormatParser< tremolo >::parseKnownTypes() - line with 'particle:' but no particles separated by comma.");
       // look for particle_type
       std::string particle_type("NULL");
@@ -643 +652 @@
           tokenizer token((*tok_iter), equalitysep);
           ASSERT(token.begin() != token.end(),
-                    "TremoloParser::parseKnownTypes() - could not split particle_type by equality sign");
+                    "FormatParser< tremolo >::parseKnownTypes() - could not split particle_type by equality sign");
           tokenizer::iterator particle_iter = token.begin();
           particle_iter++;
@@ -652 +661 @@
           tokenizer token((*tok_iter), equalitysep);
           ASSERT(token.begin() != token.end(),
-                    "TremoloParser::parseKnownTypes() - could not split particle_type by equality sign");
+                    "FormatParser< tremolo >::parseKnownTypes() - could not split particle_type by equality sign");
           tokenizer::iterator element_iter = token.begin();
           element_iter++;

src/Parser/TremoloParser.hpp

@@ -14 +14 @@
 #endif
 
+#include <string>
 
-#include <string>
-#include "Parser/FormatParser.hpp"
+#include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
 
 #include "TremoloKey.hpp"
@@ -23 +27 @@
 class molecule;
 
+// declaration of specialized FormatParserTrait
+template<>
+struct FormatParserTrait<tremolo>
+{
+  //!> Name of the parser
+  static const std::string name;
+  //!> suffix of the files the parser understands to read and write
+  static const std::string suffix;
+  //!> ParserTypes enumeration for the parser
+  static const enum ParserTypes type;
+};
+
 /**
  * Loads a tremolo file into the World and saves the World as a tremolo file.
  */
-class TremoloParser : public FormatParser
+template <>
+class FormatParser< tremolo >  : virtual public FormatParserInterface, public FormatParser_common
 {
 public:
-  TremoloParser();
-  virtual ~TremoloParser();
+  FormatParser();
+  virtual ~FormatParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);
@@ -44 +61 @@
 
 private:
-  void readAtomDataLine(string line);
-  void readAtomDataLine(string line, molecule *newmol);
-  void parseAtomDataKeysLine(string line, int offset);
+  void readAtomDataLine(std::string line);
+  void readAtomDataLine(std::string line, molecule *newmol);
+  void parseAtomDataKeysLine(std::string line, int offset);
   void readNeighbors(std::stringstream* line, int numberOfNeighbors, int atomId);
   void processNeighborInformation();

src/Parser/XyzParser.cpp

@@ -33 +33 @@
 using namespace std;
 
+// declare specialized static variables
+const std::string FormatParserTrait<xyz>::name = "xyz";
+const std::string FormatParserTrait<xyz>::suffix = "xyz";
+const ParserTypes FormatParserTrait<xyz>::type = xyz;
+
 /**
  * Constructor.
  */
-XyzParser::XyzParser() :
+FormatParser< xyz >::FormatParser() :
+  FormatParser_common(NULL),
   comment("")
 {}
@@ -43 +49 @@
  * Destructor.
  */
-XyzParser::~XyzParser() {
-}
+FormatParser< xyz >::~FormatParser() 
+{}
 
 /**
@@ -51 +57 @@
  * \param XYZ file
  */
-void XyzParser::load(istream* file)
+void FormatParser< xyz >::load(istream* file)
 {
   atom* newAtom = NULL;
@@ -99 +105 @@
         LOG(5, "INFO: Using present atom " << *newAtom << " from " << i << " th component of AddedAtoms.");
         ASSERT(newAtom->getType() == World::getInstance().getPeriode()->FindElement(type),
-            "XyzParser::load() - atom has different type "+newAtom->getType()->getSymbol()+" than parsed now "+type+", mixed up order?");
+            "FormatParser< xyz >::load() - atom has different type "+newAtom->getType()->getSymbol()+" than parsed now "+type+", mixed up order?");
       }
       newAtom->setPositionAtStep(step, tempVector);
@@ -129 +135 @@
  * \param atoms atoms to store
  */
-void XyzParser::save(ostream* file, const std::vector<atom *> &atoms) {
+void FormatParser< xyz >::save(ostream* file, const std::vector<atom *> &atoms) {
   DoLog(0) && (Log() << Verbose(0) << "Saving changes to xyz." << std::endl);
 
@@ -145 +151 @@
   }
   ASSERT((min_trajectories == max_trajectories) || (min_trajectories == 1),
-      "XyzParser::save() - not all atoms have same number of trajectories.");
+      "FormatParser< xyz >::save() - not all atoms have same number of trajectories.");
   LOG(2, "INFO: There are " << max_trajectories << " to save.");
 

src/Parser/XyzParser.hpp

@@ -14 +14 @@
 #endif
 
+#include <string>
 
-#include <string>
-#include "Parser/FormatParser.hpp"
+
+#include "FormatParser.hpp"
+#include "FormatParserTrait.hpp"
+#include "FormatParserInterface.hpp"
+#include "FormatParser_common.hpp"
+#include "ParserTypes.hpp"
+
+// declaration of specialized FormatParserTrait
+template<>
+struct FormatParserTrait<xyz>
+{
+  //!> Name of the parser
+  static const std::string name;
+  //!> suffix of the files the parser understands to read and write
+  static const std::string suffix;
+  //!> ParserTypes enumeration for the parser
+  static const enum ParserTypes type;
+};
 
 /**
  * Parser for XYZ files.
  */
-class XyzParser : public FormatParser {
+template <>
+class FormatParser< xyz >  : virtual public FormatParserInterface, public FormatParser_common
+{
 public:
-  XyzParser();
-  virtual ~XyzParser();
+  FormatParser();
+  virtual ~FormatParser();
   void load(std::istream* file);
   void save(std::ostream* file, const std::vector<atom *> &atoms);

src/Parser/unittests/ParserMpqcUnitTest.cpp

@@ -32 +32 @@
 #include "Descriptors/AtomTypeDescriptor.hpp"
 #include "CodePatterns/Assert.hpp"
+#include "Parser/ChangeTracker.hpp"
+#include "Parser/MpqcParser.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -157 +159 @@
 
 void ParserMpqcUnitTest::setUp() {
-  mpqc = new MpqcParser();
+  parser = new FormatParser<mpqc>();
 
   World::getInstance();
@@ -169 +171 @@
 
 void ParserMpqcUnitTest::tearDown() {
-  delete mpqc;
+  delete parser;
   ChangeTracker::purgeInstance();
   World::purgeInstance();
@@ -178 +180 @@
 void ParserMpqcUnitTest::ParameterTypeTest() {
   // check types in boost::any map
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::hessianParam].type() == typeid(bool));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::hessianParam].type() != typeid(int));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::savestateParam].type() == typeid(bool));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::do_gradientParam].type() == typeid(bool));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::maxiterParam].type() == typeid(int));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::memoryParam].type() == typeid(int));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::stdapproxParam].type() == typeid(std::string));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::nfzcParam].type() == typeid(int));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::basisParam].type() == typeid(std::string));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::aux_basisParam].type() == typeid(std::string));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::integrationParam].type() == typeid(MpqcParser_Parameters::IntegralCints));
-  CPPUNIT_ASSERT(mpqc->getParams().params[MpqcParser_Parameters::theoryParam].type() == typeid(MpqcParser_Parameters::MBPT2));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::hessianParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::hessianParam].type() != typeid(int));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::savestateParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::do_gradientParam].type() == typeid(bool));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::maxiterParam].type() == typeid(int));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::memoryParam].type() == typeid(int));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::stdapproxParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::nfzcParam].type() == typeid(int));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::basisParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::aux_basisParam].type() == typeid(std::string));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::integrationParam].type() == typeid(MpqcParser_Parameters::IntegralCints));
+  CPPUNIT_ASSERT(parser->getParams().params[MpqcParser_Parameters::theoryParam].type() == typeid(MpqcParser_Parameters::MBPT2));
 }
 
 void ParserMpqcUnitTest::ParameterDefaultTest() {
   // check default values
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "no");
-  CPPUNIT_ASSERT(!mpqc->getParams().getBool(MpqcParser_Parameters::hessianParam));
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::savestateParam) == "no");
-  CPPUNIT_ASSERT(!mpqc->getParams().getBool(MpqcParser_Parameters::savestateParam));
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::do_gradientParam) == "yes");
-  CPPUNIT_ASSERT(mpqc->getParams().getBool(MpqcParser_Parameters::do_gradientParam));
-  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 1000);
-  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::memoryParam) == 16000000);
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::stdapproxParam) == "A'");
-  CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::nfzcParam) == 1);
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::basisParam) == "3-21G");
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::aux_basisParam) == "aug-cc-pVDZ");
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::integrationParam) == "IntegralCints");
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
-  CPPUNIT_ASSERT(mpqc->getParams().getTheory() == MpqcParser_Parameters::MBPT2);
-  CPPUNIT_ASSERT(mpqc->getParams().getIntegration() == MpqcParser_Parameters::IntegralCints);
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::hessianParam) == "no");
+  CPPUNIT_ASSERT(!parser->getParams().getBool(MpqcParser_Parameters::hessianParam));
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::savestateParam) == "no");
+  CPPUNIT_ASSERT(!parser->getParams().getBool(MpqcParser_Parameters::savestateParam));
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::do_gradientParam) == "yes");
+  CPPUNIT_ASSERT(parser->getParams().getBool(MpqcParser_Parameters::do_gradientParam));
+  CPPUNIT_ASSERT(parser->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 1000);
+  CPPUNIT_ASSERT(parser->getParams().getInt(MpqcParser_Parameters::memoryParam) == 16000000);
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::stdapproxParam) == "A'");
+  CPPUNIT_ASSERT(parser->getParams().getInt(MpqcParser_Parameters::nfzcParam) == 1);
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::basisParam) == "3-21G");
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::aux_basisParam) == "aug-cc-pVDZ");
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::integrationParam) == "IntegralCints");
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
+  CPPUNIT_ASSERT(parser->getParams().getTheory() == MpqcParser_Parameters::MBPT2);
+  CPPUNIT_ASSERT(parser->getParams().getIntegration() == MpqcParser_Parameters::IntegralCints);
 
   // check that values are not removed
-  CPPUNIT_ASSERT(!mpqc->getParams().params[MpqcParser_Parameters::theoryParam].empty());
+  CPPUNIT_ASSERT(!parser->getParams().params[MpqcParser_Parameters::theoryParam].empty());
 
   // check throw, for the moment aren't, are caught in getInt()
-  CPPUNIT_ASSERT_THROW(mpqc->getParams().getInt(MpqcParser_Parameters::integrationParam), boost::bad_any_cast);
-  CPPUNIT_ASSERT_THROW(mpqc->getParams().getInt(MpqcParser_Parameters::theoryParam), boost::bad_any_cast);
+  CPPUNIT_ASSERT_THROW(parser->getParams().getInt(MpqcParser_Parameters::integrationParam), boost::bad_any_cast);
+  CPPUNIT_ASSERT_THROW(parser->getParams().getInt(MpqcParser_Parameters::theoryParam), boost::bad_any_cast);
 
 }
 
 void ParserMpqcUnitTest::ParameterCloneTest() {
-  FormatParser_Parameters *clone = mpqc->getParams().clone();
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
+  FormatParser_Parameters *clone = parser->getParams().clone();
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
   std::stringstream setvalue("theory = CLHF");
-  setvalue >> mpqc->getParams();
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
-  mpqc->getParams().makeClone(*clone);
-  CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
+  setvalue >> parser->getParams();
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
+  parser->getParams().makeClone(*clone);
+  CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::theoryParam) == "MBPT2");
 }
 
@@ -234 +236 @@
   {
     std::stringstream setvalue("theory = CLHF");
-    setvalue >> mpqc->getParams();
+    setvalue >> parser->getParams();
 //    std::cout << "integration method is "
-//        << mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) << std::endl;
-    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
+//        << parser->getParams().getString(MpqcParser_Parameters::theoryParam) << std::endl;
+    CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::theoryParam) == "CLHF");
   }
   // test a bool
   {
     std::stringstream setvalue("Hessian = yes");
-    setvalue >> mpqc->getParams();
+    setvalue >> parser->getParams();
 //    std::cout << "Hessian is "
-//        << mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
-    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
+//        << parser->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
+    CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
   }
   // test int
   {
     std::stringstream setvalue("maxiter = 500");
-    setvalue >> mpqc->getParams();
+    setvalue >> parser->getParams();
 //    std::cout << "maxiter is "
-//        << mpqc->getParams().getString(MpqcParser_Parameters::maxiterParam) << std::endl;
-    CPPUNIT_ASSERT(mpqc->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 500);
+//        << parser->getParams().getString(MpqcParser_Parameters::maxiterParam) << std::endl;
+    CPPUNIT_ASSERT(parser->getParams().getInt(MpqcParser_Parameters::maxiterParam) == 500);
   }
   // test whether unknown key fails
@@ -261 +263 @@
 #ifndef NDEBUG
     ASSERT_DO(Assert::Throw);
-    CPPUNIT_ASSERT_THROW(setvalue >> mpqc->getParams(), Assert::AssertionFailure);
+    CPPUNIT_ASSERT_THROW(setvalue >> parser->getParams(), Assert::AssertionFailure);
 #else
-    setvalue >> mpqc->getParams();
+    setvalue >> parser->getParams();
 #endif
 //    std::cout << "Hessian is still "
-//        << mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
-    CPPUNIT_ASSERT(mpqc->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
+//        << parser->getParams().getString(MpqcParser_Parameters::hessianParam) << std::endl;
+    CPPUNIT_ASSERT(parser->getParams().getString(MpqcParser_Parameters::hessianParam) == "yes");
   }
 }
@@ -273 +275 @@
 void ParserMpqcUnitTest::readMpqcTest() {
   stringstream input(waterMpqc_CLHF);
-  mpqc->getParams().setTheory(MpqcParser_Parameters::CLHF);
-  mpqc->load(&input);
+  parser->getParams().setTheory(MpqcParser_Parameters::CLHF);
+  parser->load(&input);
 
   CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
@@ -301 +303 @@
     // compare both configs for CLHF
     stringstream output;
-    mpqc->getParams().setTheory(MpqcParser_Parameters::CLHF);
-    mpqc->save(&output, atoms);
+    parser->getParams().setTheory(MpqcParser_Parameters::CLHF);
+    parser->save(&output, atoms);
     stringstream input(waterMpqc_CLHF);
     for (; std::getline(input, first) && std::getline(output, second); ) {
@@ -312 +314 @@
     // compare both configs for CLKS
     stringstream output;
-    mpqc->getParams().setTheory(MpqcParser_Parameters::CLKS);
-    mpqc->save(&output, atoms);
+    parser->getParams().setTheory(MpqcParser_Parameters::CLKS);
+    parser->save(&output, atoms);
     stringstream input(waterMpqc_CLKS);
     for (; std::getline(input, first) && std::getline(output, second); ) {
@@ -323 +325 @@
     // compare both configs for MBPT2
     stringstream output;
-    mpqc->getParams().setTheory(MpqcParser_Parameters::MBPT2);
-    mpqc->save(&output, atoms);
+    parser->getParams().setTheory(MpqcParser_Parameters::MBPT2);
+    parser->save(&output, atoms);
     stringstream input(waterMpqc_MBPT2);
     for (; std::getline(input, first) && std::getline(output, second); ) {
@@ -334 +336 @@
     // compare both configs for MBPT2_R12
     stringstream output;
-    mpqc->getParams().setTheory(MpqcParser_Parameters::MBPT2_R12);
-    mpqc->save(&output, atoms);
+    parser->getParams().setTheory(MpqcParser_Parameters::MBPT2_R12);
+    parser->save(&output, atoms);
     stringstream input(waterMpqc_MBPT2_R12);
     for (; std::getline(input, first) && std::getline(output, second); ) {

src/Parser/unittests/ParserMpqcUnitTest.hpp

@@ -41 +41 @@
 
 private:
-  MpqcParser *mpqc;
+  FormatParser<mpqc> *parser;
 };
 

src/Parser/unittests/ParserPcpUnitTest.cpp

@@ -24 +24 @@
 #include <cppunit/ui/text/TestRunner.h>
 
-#include "Parser/PcpParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
@@ -31 +30 @@
 #include "CodePatterns/Log.hpp"
 #include "Descriptors/AtomTypeDescriptor.hpp"
+#include "Parser/ChangeTracker.hpp"
+#include "Parser/PcpParser.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -119 +120 @@
   World::getInstance();
 
+  parser = new FormatParser<pcp>();
+
   setVerbosity(2);
 
@@ -126 +129 @@
 }
 
-void ParserPcpUnitTest::tearDown() {
+void ParserPcpUnitTest::tearDown() 
+{
+  delete parser;
   ChangeTracker::purgeInstance();
   World::purgeInstance();
@@ -135 +140 @@
 void ParserPcpUnitTest::readwritePcpTest() {
   stringstream input(waterPcp);
-  PcpParser* testParser = new PcpParser();
-  testParser->load(&input);
+  parser->load(&input);
   input.clear();
 
@@ -142 +146 @@
 
   // check that equality function is ok
-  CPPUNIT_ASSERT(*testParser == *testParser);
+  CPPUNIT_ASSERT(*parser == *parser);
 
   stringstream output;
   std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-  testParser->save(&output, atoms);
+  parser->save(&output, atoms);
 
   input << output.str();
-  PcpParser* testParser2 = new PcpParser();
-  testParser2->load(&input);
+  FormatParser<pcp>* parser2 = new FormatParser<pcp>();
+  parser2->load(&input);
 
   CPPUNIT_ASSERT_EQUAL(6, World::getInstance().numAtoms());
 
-  CPPUNIT_ASSERT(*testParser == *testParser2);
+  CPPUNIT_ASSERT(*parser == *parser2);
+
+  delete parser2;
 }

src/Parser/unittests/ParserPcpUnitTest.hpp

@@ -13 +13 @@
 #endif
 
+#include "Parser/PcpParser.hpp"
 
 #include <cppunit/extensions/HelperMacros.h>
@@ -28 +29 @@
 
   void readwritePcpTest();
+
+private:
+  FormatParser<pcp> *parser;
 };
 

src/Parser/unittests/ParserPdbUnitTest.cpp

@@ -24 +24 @@
 #include <cppunit/ui/text/TestRunner.h>
 
-#include "Parser/PdbParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
@@ -31 +30 @@
 #include "CodePatterns/Log.hpp"
 #include "Descriptors/AtomTypeDescriptor.hpp"
+#include "Parser/ChangeTracker.hpp"
+#include "Parser/PdbParser.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -63 +64 @@
   World::getInstance();
 
+  parser = new FormatParser<pdb>();
+
   setVerbosity(2);
 
@@ -70 +73 @@
 }
 
-void ParserPdbUnitTest::tearDown() {
+void ParserPdbUnitTest::tearDown() 
+{
+  delete parser;
   ChangeTracker::purgeInstance();
   World::purgeInstance();
@@ -80 +85 @@
   stringstream input;
   input << waterPdb;
-  PdbParser* testParser = new PdbParser();
-  testParser->load(&input);
+  parser->load(&input);
   input.clear();
 
@@ -88 +92 @@
   stringstream output;
   std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-  testParser->save(&output, atoms);
+  parser->save(&output, atoms);
 
 //  std::cout << "Save PDB is:" << std::endl;
@@ -94 +98 @@
 
   input << output.str();
-  PdbParser* testParser2 = new PdbParser();
-  testParser2->load(&input);
+  FormatParser<pdb>* parser2 = new FormatParser<pdb>();
+  parser2->load(&input);
 
   CPPUNIT_ASSERT_EQUAL(12, World::getInstance().numAtoms());
+
+  delete parser2;
 }

src/Parser/unittests/ParserPdbUnitTest.hpp

@@ -13 +13 @@
 #endif
 
+#include "Parser/PdbParser.hpp"
 
 #include <cppunit/extensions/HelperMacros.h>
@@ -28 +29 @@
 
   void readwritePdbTest();
+
+private:
+  FormatParser<pdb> *parser;
 };
 

src/Parser/unittests/ParserTremoloUnitTest.cpp

@@ -27 +27 @@
 #include "Descriptors/AtomTypeDescriptor.hpp"
 #include "element.hpp"
-#include "Parser/MpqcParser.hpp"
-#include "Parser/PdbParser.hpp"
-#include "Parser/PcpParser.hpp"
 #include "Parser/TremoloParser.hpp"
-#include "Parser/XyzParser.hpp"
+#include "Parser/ChangeTracker.hpp"
 #include "periodentafel.hpp"
 #include "World.hpp"
@@ -85 +82 @@
   World::getInstance();
 
+  parser = new FormatParser<tremolo>();
+
   // we need hydrogens and oxygens in the following tests
   CPPUNIT_ASSERT(World::getInstance().getPeriode()->FindElement(1) != NULL);
@@ -90 +89 @@
 }
 
-void ParserTremoloUnitTest::tearDown() {
+void ParserTremoloUnitTest::tearDown() 
+{
+  delete parser;
   ChangeTracker::purgeInstance();
   World::purgeInstance();
@@ -99 +100 @@
 void ParserTremoloUnitTest::readTremoloPreliminaryCommentsTest() {
   cout << "Testing the tremolo parser." << endl;
-  TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
 
@@ -105 +105 @@
   {
     input << Tremolo_Atomdata1;
-    testParser->load(&input);
-    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-    testParser->save(&output, atoms);
+    parser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    parser->save(&output, atoms);
 //    std::cout << output.str() << std::endl;
 //    std::cout << Tremolo_Atomdata1 << std::endl;
@@ -118 +118 @@
   {
     input << Tremolo_Atomdata2;
-    testParser->load(&input);
-    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-    testParser->save(&output, atoms);
+    parser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    parser->save(&output, atoms);
     std::cout << output.str() << std::endl;
     CPPUNIT_ASSERT(output.str().find("hydrogen") != string::npos);
@@ -129 +129 @@
   // Invalid key in Atomdata line
   input << Tremolo_invalidkey;
-  testParser->load(&input);
+  parser->load(&input);
   //TODO: prove invalidity
   input.clear();
@@ -135 +135 @@
 
 void ParserTremoloUnitTest::readTremoloCoordinatesTest() {
-  TremoloParser* testParser = new TremoloParser();
   stringstream input;
 
   // One simple data line
   input << Tremolo_Atomdata2;
-  testParser->load(&input);
+  parser->load(&input);
   CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->at(0) == 3.0);
   input.clear();
@@ -146 +145 @@
 
 void ParserTremoloUnitTest::readTremoloVelocityTest() {
-  TremoloParser* testParser = new TremoloParser();
   stringstream input;
 
   // One simple data line
   input << Tremolo_velocity;
-  testParser->load(&input);
+  parser->load(&input);
   CPPUNIT_ASSERT(World::getInstance().getAtom(AtomByType(1))->getAtomicVelocity()[0] == 3.0);
   input.clear();
@@ -157 +155 @@
 
 void ParserTremoloUnitTest::readTremoloNeighborInformationTest() {
-  TremoloParser* testParser = new TremoloParser();
   stringstream input;
 
   // Neighbor data
   input << Tremolo_neighbours;
-  testParser->load(&input);
+  parser->load(&input);
 
   CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
@@ -171 +168 @@
 
 void ParserTremoloUnitTest::readAndWriteTremoloImprDataInformationTest() {
-  TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
 
@@ -177 +173 @@
   {
     input << Tremolo_improper;
-    testParser->load(&input);
-    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-    testParser->save(&output, atoms);
+    parser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    parser->save(&output, atoms);
     CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
     std::cout << output.str() << std::endl;
@@ -189 +185 @@
 
 void ParserTremoloUnitTest::readAndWriteTremoloTorsionInformationTest() {
-  TremoloParser* testParser = new TremoloParser();
   stringstream input, output;
 
@@ -195 +190 @@
   {
     input << Tremolo_torsion;
-    testParser->load(&input);
-    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-    testParser->save(&output, atoms);
+    parser->load(&input);
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    parser->save(&output, atoms);
     CPPUNIT_ASSERT_EQUAL(3, World::getInstance().numAtoms());
     std::cout << output.str() << std::endl;
@@ -207 +202 @@
 
 void ParserTremoloUnitTest::writeTremoloTest() {
-  TremoloParser* testParser = new TremoloParser();
   stringstream output;
 
@@ -214 +208 @@
     atom* newAtom = World::getInstance().createAtom();
     newAtom->setType(1);
-    testParser->setFieldsForSave("x=3 u=3 F stress Id neighbors=5 imprData GroupMeasureTypeNo type extType name resName chainID resSeq occupancy tempFactor segID Charge charge GrpTypeNo torsion");
-    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-    testParser->save(&output, atoms);
+    parser->setFieldsForSave("x=3 u=3 F stress Id neighbors=5 imprData GroupMeasureTypeNo type extType name resName chainID resSeq occupancy tempFactor segID Charge charge GrpTypeNo torsion");
+    std::vector<atom *> atoms = World::getInstance().getAllAtoms();
+    parser->save(&output, atoms);
     CPPUNIT_ASSERT(output.str() == Tremolo_full);
   }
@@ -222 +216 @@
   cout << "testing the tremolo parser is done" << endl;
 }
+

src/Parser/unittests/ParserTremoloUnitTest.hpp

@@ -13 +13 @@
 #endif
 
+#include "Parser/TremoloParser.hpp"
 
 #include <cppunit/extensions/HelperMacros.h>
@@ -40 +41 @@
   void readAndWriteTremoloTorsionInformationTest();
   void writeTremoloTest();
+
+private:
+  FormatParser<tremolo> *parser;
 };
 

src/Parser/unittests/ParserXyzUnitTest.cpp

@@ -24 +24 @@
 #include <cppunit/ui/text/TestRunner.h>
 
-#include "Parser/XyzParser.hpp"
 #include "World.hpp"
 #include "atom.hpp"
@@ -31 +30 @@
 #include "CodePatterns/Log.hpp"
 #include "Descriptors/AtomTypeDescriptor.hpp"
+#include "Parser/ChangeTracker.hpp"
+#include "Parser/XyzParser.hpp"
 
 #ifdef HAVE_TESTRUNNER
@@ -62 +63 @@
   World::getInstance();
 
+  parser = new FormatParser<xyz>();
+
   setVerbosity(2);
 
@@ -69 +72 @@
 }
 
-void ParserXyzUnitTest::tearDown() {
+void ParserXyzUnitTest::tearDown() 
+{
+  delete parser;
   ChangeTracker::purgeInstance();
   World::purgeInstance();
@@ -78 +83 @@
 void ParserXyzUnitTest::rewriteAnXyzTest() {
   cout << "Testing the XYZ parser." << endl;
-  XyzParser* testParser = new XyzParser();
   stringstream input;
   input << waterXyz;
-  testParser->load(&input);
+  parser->load(&input);
   input.clear();
 
@@ -90 +94 @@
     stringstream output;
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-    testParser->save(&output, atoms);
+    parser->save(&output, atoms);
     input << output.str();
-    testParser->load(&input);
+    parser->load(&input);
   }
 
@@ -115 +119 @@
 void ParserXyzUnitTest::readMultiXyzTest() {
   cout << "Testing the multi time step XYZ parser." << endl;
-  XyzParser* testParser = new XyzParser();
   stringstream input;
   input << waterMultiXyz;
-  testParser->load(&input);
+  parser->load(&input);
   input.clear();
 
@@ -130 +133 @@
 
 void ParserXyzUnitTest::writeMultiXyzTest() {
-  XyzParser* testParser = new XyzParser();
   stringstream input;
   input << waterMultiXyz;
-  testParser->load(&input);
+  parser->load(&input);
   input.clear();
 
@@ -143 +145 @@
     stringstream output;
     std::vector<atom *> atoms = World::getInstance().getAllAtoms();
-    testParser->save(&output, atoms);
+    parser->save(&output, atoms);
     input << output.str();
-    testParser->load(&input);
+    parser->load(&input);
   }
 

src/Parser/unittests/ParserXyzUnitTest.hpp

@@ -13 +13 @@
 #endif
 
+#include "Parser/XyzParser.hpp"
 
 #include <cppunit/extensions/HelperMacros.h>
@@ -32 +33 @@
   void readMultiXyzTest();
   void writeMultiXyzTest();
+
+private:
+  FormatParser<xyz> *parser;
 };
 

src/moleculelist.cpp

@@ -626 +626 @@
 //      atoms.resize((*ListRunner)->getAtomCount());
 //      std::copy((*ListRunner)->begin(), (*ListRunner)->end(), atoms.begin());
-      FormatParserStorage::getInstance().getParser<MpqcParser>().save(&outfile, atoms);
+      FormatParserStorage::getInstance().get(mpqc).save(&outfile, atoms);
 //      if ((intermediateResult = World::getInstance().getConfig()->SaveMPQC(FragmentName.c_str(), (*ListRunner))))
         output << " done.";