Changes in src/Parser/MpqcParser_Parameters.hpp [7f570c:c1db05]

File:

• src/Parser/MpqcParser_Parameters.hpp (modified) (4 diffs)

src/Parser/MpqcParser_Parameters.hpp

@@ -14 +14 @@
 #endif
 
+#include <iosfwd>
 #include <list>
-#include <map>
+#include <typeinfo>
 #include <vector>
 
 #include "CodePatterns/Clone.hpp"
 #include "CodePatterns/Log.hpp"
+#include "CodePatterns/Verbose.hpp"
+
+#include <boost/any.hpp>
 
 #include "Parser/FormatParser_Parameters.hpp"
-
-#include "Parser/Parameters/ContinuousParameter.hpp"
-
-// specialization for bool (we want "yes/no" not "1/0")
-template <> const std::string ContinuousValue<bool>::get() const;
-template <> void ContinuousValue<bool>::set(const std::string _value);
 
 class MpqcParser;
@@ -44 +42 @@
   MpqcParser_Parameters();
 
+  /** Copy Constructor of MpqcParser_Parameters.
+   *
+   * @param state ref to instance to copy
+   */
+  MpqcParser_Parameters(const MpqcParser_Parameters & state);
+
   /** Destructor of MpqcParser_Parameters.
    *
    */
   virtual ~MpqcParser_Parameters();
+
+  /** Enumeration of all known theories.
+   *
+   */
+  enum Theory {
+    CLHF,       //!< Closed Shell Hartree-Fock equations
+    CLKS,       //!< Closed Shell Kohn-Sham equations
+    MBPT2,      //!< Moeller Plesset Perturbation Theory second order
+    MBPT2_R12,  //!< Moeller Plesset Perturbation Theory second order with R12 integral
+    unknownTheory //!< designates an unknown theory
+  };
+
+  /** Enumeration of all known integration methods
+   *
+   */
+  enum IntegrationMethod {
+    IntegralCints,  //!< Integration method Cints in MBPT2 R12?
+    unknownIntegration //!< designates unknown integration method
+  };
 
   /** Enumeration of all known Parameters to allow placing them in vectors, maps.
@@ -66 +89 @@
     unknownParam};   //!< unknownParam, designates an unknown parameter
 
-  /** Enumeration of all known theories.
-   *
-   */
-  enum Theory {
-    CLHF,       //!< Closed Shell Hartree-Fock equations
-    CLKS,       //!< Closed Shell Kohn-Sham equations
-    MBPT2,      //!< Moeller Plesset Perturbation Theory second order
-    MBPT2_R12,  //!< Moeller Plesset Perturbation Theory second order with R12 integral
-    unknownTheory //!< designates an unknown theory
-  };
-
-  /** Enumeration of all known integration methods
-   *
-   */
-  enum IntegrationMethod {
-    IntegralCints,  //!< Integration method Cints in MBPT2 R12?
-    unknownIntegration //!< designates unknown integration method
-  };
-
-  // enum to string getters
-  const std::string getParameter(const enum Parameters param) const;
-  void setParameter(const enum Parameters param, const std::string &);
-  const std::string &getParameterName(const enum Parameters param) const;
-  const std::string &getTheoryName(const enum Theory theory) const;
-  const std::string &getIntegrationMethodName(const enum IntegrationMethod integration) const;
+  bool checkWorldElementsAgainstCurrentBasis() const;
+
+  /** Sets the desired level of solving theory to use.
+   *
+   * \param _theory shorthand of the theory
+   */
+  void setTheory(enum Theory _theory);
+
+  /** Sets the desired level of solving integration to use.
+   *
+   * \param _integration shorthand of the integration
+   */
+  void setIntegration(enum IntegrationMethod _integration);
+
+  /** Getter for integration method in params.
+   *
+   * @return enumeration index of IntegrationMethod.
+   */
+  enum IntegrationMethod getIntegration() const;
+
+  /** Getter for current Theory in params.
+   *
+   * @return enumeration index of Theory
+   */
+  enum Theory getTheory() const;
+
+  /** Getter for a parameter in params as a string.
+   *
+   * @param _param enumeration index of desired Parameter
+   * @return string value
+   */
+  std::string getString(enum Parameters _param) const;
+
+  /** Getter for integer value of desired Parameter in params.
+   *
+   * Only if type in params matches int!
+   *
+   * @param _param enumeration index in Parameter
+   * @return integer value of parameter
+   */
+  int getInt(enum Parameters _param) const;
+
+  /** Getter for double value of desired Parameter in params.
+   *
+   * Only if type in params matches double!
+   *
+   * @param _param enumeration index in Parameter
+   * @return double value of parameter
+   */
+  double getDouble(enum Parameters _param) const;
+
+  /** Getter for bool value of desired Parameter in params.
+   *
+   * Only if type in params matches bool!
+   *
+   * @param _param enumeration index in Parameter
+   * @return bool value of parameter
+   */
+  bool getBool(enum Parameters _param) const;
+
+  /** Setter for a desired value of its type is known.
+   *
+   * We check whether given type matches present type in params.
+   *
+   * @param _param enumeration index of Parameter
+   * @param _desired desired value to set to
+   * @return true - type match, value set, false - type mismatch
+   */
+  template <class T> bool setter(enum Parameters _param, T _desired) {
+    if (typeid(T) == params[_param].type()) {
+      params[_param] = _desired;
+      return true;
+    } else
+      return false;
+  }
+
+  /** Sets a desired value in the params from a string.
+   *
+   * This is due to strict typing of C++ very ugly and boost::any does not make
+   * it any better because it offers to functions to use values directly from
+   * stringstream. Probably, because value is unknown to is as well and hence
+   * the author could not implement it beautifully, so he dropped it altogether.
+   * Grrr ....
+   *
+   * @param _param param to set
+   * @param _desired stringstream containing value as next argument
+   * @return true - type ok, false - unknown type in params.
+   */
+  bool setter(enum Parameters _param, std::stringstream& _desired);
+
+  /** Grants access to ParamLookup.
+   *
+   *  Does not check for unknown parameter.
+   *
+   * @param _name name of parameter
+   * @return enumeration index of Parameters
+   */
+  enum Parameters getParam(std::string _name) const;
+
+  /** Checker whether parameter with name is known.
+   *
+   * @param _name
+   * @return true - parameter known, false - parameter unknown
+   */
+  bool haveParam(std::string _name) const;
+
+  /** Creates a clone of the class.
+   *
+   * @return
+   */
+  FormatParser_Parameters* clone() const;
+
+  /** Applies a before returned undo state.
+   *
+   * @param undo state to set
+   */
+  void makeClone(const FormatParser_Parameters & _state);
+
+  /** Set the internal parameters to the one's from the given \a state.
+   *
+   * @param state set of parameters
+   */
+  void copyParameters(const MpqcParser_Parameters & state);
 
 private:
-
-
-  //!> vector with all available theories in same order as enum Theory.
-  std::vector<std::string> ValidTheories;
-
-  //!> vector with all available integration methods in same order as enum IntegrationMethod.
-  std::vector<std::string> ValidIntegrationMethods;
-
-  bool checkWorldElementsAgainstCurrentBasis() const;
-
   /** Global initialization in cstor.
    *
@@ -113 +224 @@
   void initBasis();
 
-  //!> vector with all parameter names in same order as enum Parameters
-  std::vector<std::string> ParamNames;
-
-  //!> typedef for the list of all available basis sets
+  /** Initializes params.
+   * Sets the type and the associated enumeration index.
+   */
+  void initParameters();
+
+  /** Internal function used by initParameters() to add parameters to params.
+   *
+   * @param _enum enumeration index to set
+   * @param _p (default) value to set with certain type
+   */
+  template <class T> void appendParameter(enum Parameters _enum, T _p) {
+    boost::any _p_value = _p;
+    params[_enum] = _p_value;
+  }
+
+  // all internal typedefs for lists below
   typedef std::map<std::string, std::list<std::string> > BasisMapType;
-
-  //!> list of all basis along with their present element parametrization
+  typedef std::map<enum Theory, std::string> TheoryNamesType;
+  typedef std::map<std::string, enum Theory> TheoryLookupType;
+  typedef std::map<enum IntegrationMethod, std::string> IntegrationNamesType;
+  typedef std::map<std::string, enum IntegrationMethod> IntegrationLookupType;
+  typedef std::map<enum Parameters, std::string> ParamNamesType;
+  typedef std::map<std::string, enum Parameters> ParamLookupType;
+  typedef std::map<enum Parameters, boost::any> parameterlist;
+
+  //!> boost::any container for all the parameters
+  parameterlist params;
+
+  // maps from names to enumerations
+
+  //!> contains basis and all elements the basis knows about
   BasisMapType BasisList;
+  //!> contains the name of a theory as string
+  TheoryNamesType TheoryNames;
+  //!> contains a lookup from theory name to enumeration index
+  TheoryLookupType TheoryLookup;
+  //!> contains the name of an integration method as string
+  IntegrationNamesType IntegrationNames;
+  //!> contains a lookup from integration method name to enumeration index
+  IntegrationLookupType IntegrationLookup;
+  //!> contains the name of a parameter
+  ParamNamesType ParamNames;
+  //!> contains a lookup from parameter name to enumeration index
+  ParamLookupType ParamLookup;
 };
 
+/** Output operator for the contents of MpqcParser_Parameters::params.
+ *
+ * @param ost output stream
+ * @param params reference to MpqcParser_Parameters containing params.
+ * @return reference to output stream for concatenation
+ */
+std::ostream & operator << (std::ostream& ost, const MpqcParser_Parameters &params);
+
+/** Input operator for a list of parameters to place into \a params.
+ *
+ * @param ist input stream
+ * @param params parameters to parse into
+ * @return input stream for concatenation
+ */
+std::istream & operator >> (std::istream& ist, MpqcParser_Parameters &params);
+
 #endif /* MPQCPARSER_PARAMETERS_HPP_ */