Changes in src/Actions/ValueStorage.hpp [03c902:e4afb4]

File:

• src/Actions/ValueStorage.hpp (modified) (5 diffs)

src/Actions/ValueStorage.hpp

@@ -9 +9 @@
 #define VALUESTORAGE_HPP_
 
-#include "Actions/MapOfActions.hpp"
+#include <boost/filesystem.hpp>
+#include <boost/lexical_cast.hpp>
+#include <boost/program_options.hpp>
+
+#include <map>
+#include <set>
+#include <vector>
+#include <typeinfo>
+
+#include "Actions/OptionTrait.hpp"
+#include "Actions/OptionRegistry.hpp"
+#include "Exceptions/IllegalTypeException.hpp"
+#include "Exceptions/MissingValueException.hpp"
+#include "Helpers/Assert.hpp"
+#include "Patterns/Singleton.hpp"
+
+class MapOfActionsTest;
+
+class Box;
+class atom;
+class element;
+class molecule;
+class Vector;
+
+namespace po = boost::program_options;
+
+using boost::lexical_cast;
+
 #include "Patterns/Singleton.hpp"
 
@@ -21 +48 @@
 
 public:
+
+  bool isCurrentValuePresent(const char *name) const;
+  void queryCurrentValue(const char * name, const atom * &_T);
+  void queryCurrentValue(const char * name, const element * &_T);
+  void queryCurrentValue(const char * name, const molecule * &_T);
+  void queryCurrentValue(const char * name, class Box &_T);
+  void queryCurrentValue(const char * name, class Vector &_T);
+  void queryCurrentValue(const char * name, class BoxVector &_T);
+  void queryCurrentValue(const char * name, std::vector<const atom *>&_T);
+  void queryCurrentValue(const char * name, std::vector<const element *>&_T);
+  void queryCurrentValue(const char * name, std::vector<const molecule *>&_T);
+  void queryCurrentValue(const char * name, boost::filesystem::path&_T);
+
   /** Gets a value from the storage
    * If the value is not present, an ASSERT is thrown unless optional is set to true.
@@ -27 +67 @@
    * \return true - value present, false - value not present (only given when optional set to true)
    */
-  template <typename T> bool queryCurrentValue(const char *name, T &_T, const bool optional = false) {
-    if (optional) {
-      if (!MapOfActions_instance.isCurrentValuePresent(name))
-        return false;
-    }
-    MapOfActions_instance.queryCurrentValue(name, _T);
-    return true;
+  template<typename T> void queryCurrentValue(const char * name, T &_T)
+  {
+    if (typeid( T ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) { // constructor of type_info is private, hence can only store by ref or ptr
+      if (CurrentValueMap.find(name) == CurrentValueMap.end())
+        throw MissingValueException(__FILE__, __LINE__);
+      _T = lexical_cast<T>(CurrentValueMap[name].c_str());
+      CurrentValueMap.erase(name);
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
   }
+  template<typename T> void queryCurrentValue(const char * name, std::vector<T> &_T)
+  {
+    T temp;
+    if (typeid( std::vector<T> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) { // constructor of type_info is private, hence can only store by ref or ptr
+      if (CurrentValueMap.find(name) == CurrentValueMap.end())
+        throw MissingValueException(__FILE__, __LINE__);
+      std::istringstream stream(CurrentValueMap[name]);
+      CurrentValueMap.erase(name);
+      while (!stream.fail()) {
+        stream >> temp >> std::ws;
+        _T.push_back(temp);
+      }
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+
+  void setCurrentValue(const char * name, const atom * &_T);
+  void setCurrentValue(const char * name, const element * &_T);
+  void setCurrentValue(const char * name, const molecule * &_T);
+  void setCurrentValue(const char * name, class Box &_T);
+  void setCurrentValue(const char * name, class Vector &_T);
+  void setCurrentValue(const char * name, std::vector<const atom *>&_T);
+  void setCurrentValue(const char * name, std::vector<const element *>&_T);
+  void setCurrentValue(const char * name, std::vector<const molecule *>&_T);
+  void setCurrentValue(const char * name, boost::filesystem::path&_T);
 
   /** Sets a value in the storage.
@@ -40 +107 @@
    * \param _T value
    */
-  template <typename T> void setCurrentValue(const char *name, T &_T) {
-    MapOfActions_instance.setCurrentValue(name, _T);
+  template<class T> void setCurrentValue(const char * name, T &_T)
+  {
+    std::ostringstream stream;
+    if (typeid( T ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {  // constructor of type_info is private, hence can only store by ref or ptr
+      stream << _T;
+      CurrentValueMap[name] = stream.str();
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
+  }
+  /** Sets a value in the storage.
+   * \param name key of value
+   * \param _T value
+   */
+  template<class T> void setCurrentValue(const char * name, std::vector<T> &_T)
+  {
+    std::ostringstream stream;
+    if (typeid( std::vector<T> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {  // constructor of type_info is private, hence can only store by ref or ptr
+      std::ostringstream stream;
+      for (typename std::vector<T>::const_iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+        stream << (*iter) << " ";
+      }
+      CurrentValueMap[name] = stream.str();
+    } else
+      throw IllegalTypeException(__FILE__,__LINE__);
   }
 
-  /** Obtain a descriptive text for a given key.
-   * \param actionname key
-   * \return text describing the key's contents
-   */
-  std::string getDescription(std::string actionname);
+  const std::string getCurrentValue(std::string actionname);
 
 protected:
@@ -54 +139 @@
   ~ValueStorage();
 
-  MapOfActions &MapOfActions_instance;
+  std::map<std::string, std::string> CurrentValueMap;
+
+  OptionRegistry &OptionRegistry_instance;
 };