Changes in src/Actions/ValueStorage.cpp [bcf653:e4afb4]

File:

• src/Actions/ValueStorage.cpp (modified) (1 diff)

src/Actions/ValueStorage.cpp

@@ -20 +20 @@
 #include "Helpers/MemDebug.hpp"
 
-#include "ValueStorage.hpp"
 #include "Patterns/Singleton_impl.hpp"
 
+#include "Actions/OptionTrait.hpp"
+#include "Actions/OptionRegistry.hpp"
+#include "Actions/Values.hpp"
+#include "Actions/ValueStorage.hpp"
+#include "Descriptors/AtomIdDescriptor.hpp"
+#include "Descriptors/MoleculeIdDescriptor.hpp"
+#include "Helpers/Log.hpp"
+#include "Helpers/Verbose.hpp"
+#include "LinearAlgebra/BoxVector.hpp"
+#include "LinearAlgebra/Matrix.hpp"
+#include "LinearAlgebra/Vector.hpp"
+#include "atom.hpp"
+#include "Box.hpp"
+#include "element.hpp"
+#include "molecule.hpp"
+#include "periodentafel.hpp"
+#include "World.hpp"
+
 ValueStorage::ValueStorage() :
-  MapOfActions_instance(MapOfActions::getInstance())
+OptionRegistry_instance(OptionRegistry::getInstance())
 {};
 
 ValueStorage::~ValueStorage() {};
 
-std::string ValueStorage::getDescription(std::string actionname) {
-  return MapOfActions::getInstance().getDescription(actionname);
+
+bool ValueStorage::isCurrentValuePresent(const char *name) const
+{
+  return (CurrentValueMap.find(name) != CurrentValueMap.end());
+}
+
+void ValueStorage::queryCurrentValue(const char * name, const atom * &_T)
+{
+  int atomID = -1;
+  if (typeid( atom *) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    atomID = lexical_cast<int>(CurrentValueMap[name].c_str());
+    CurrentValueMap.erase(name);
+  } else if (typeid( const atom *) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    atomID = lexical_cast<int>(CurrentValueMap[name].c_str());
+    CurrentValueMap.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getAtom(AtomById(atomID));
+}
+
+void ValueStorage::queryCurrentValue(const char * name, const element * &_T)  {
+  int Z = -1;
+  if (typeid(const element *) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    Z = lexical_cast<int>(CurrentValueMap[name].c_str());
+    CurrentValueMap.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getPeriode()->FindElement(Z);
+}
+
+void ValueStorage::queryCurrentValue(const char * name, const molecule * &_T) {
+  int molID = -1;
+  if (typeid( const molecule *) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    molID = lexical_cast<int>(CurrentValueMap[name].c_str());
+    CurrentValueMap.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+  _T = World::getInstance().getMolecule(MoleculeById(molID));
+}
+
+void ValueStorage::queryCurrentValue(const char * name, class Box &_T) {
+  Matrix M;
+  double tmp;
+  if (typeid( Box ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValueMap[name]);
+    stream >> tmp;
+    M.set(0,0,tmp);
+    stream >> tmp;
+    M.set(0,1,tmp);
+    M.set(1,0,tmp);
+    stream >> tmp;
+    M.set(0,2,tmp);
+    M.set(2,0,tmp);
+    stream >> tmp;
+    M.set(1,1,tmp);
+    stream >> tmp;
+    M.set(1,2,tmp);
+    M.set(2,1,tmp);
+    stream >> tmp;
+    M.set(2,2,tmp);
+    _T = M;
+    CurrentValueMap.erase(name);
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::queryCurrentValue(const char * name, class Vector &_T) {
+  if (typeid( Vector ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::istringstream stream(CurrentValueMap[name]);
+    CurrentValueMap.erase(name);
+    stream >> _T[0];
+    stream >> _T[1];
+    stream >> _T[2];
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::queryCurrentValue(const char * name, class BoxVector &_T) {
+  if (typeid( BoxVector ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::istringstream stream(CurrentValueMap[name]);
+    CurrentValueMap.erase(name);
+    stream >> _T[0];
+    stream >> _T[1];
+    stream >> _T[2];
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::queryCurrentValue(const char * name, std::vector<const atom *>&_T)
+{
+  int atomID = -1;
+  atom *Walker = NULL;
+  if (typeid( std::vector<const atom *> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValueMap[name]);
+    CurrentValueMap.erase(name);
+    while (!stream.fail()) {
+      stream >> atomID >> ws;
+      Walker = World::getInstance().getAtom(AtomById(atomID));
+      if (Walker != NULL)
+        _T.push_back(Walker);
+      atomID = -1;
+      Walker = NULL;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::queryCurrentValue(const char * name, std::vector<const element *>&_T)
+{
+  int Z = -1;
+  const element *elemental = NULL;
+  if (typeid( std::vector<const element *> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValueMap[name]);
+    CurrentValueMap.erase(name);
+    while (!stream.fail()) {
+      stream >> Z >> ws;
+      elemental = World::getInstance().getPeriode()->FindElement(Z);
+      if (elemental != NULL)
+        _T.push_back(elemental);
+      Z = -1;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::queryCurrentValue(const char * name, std::vector<const molecule *>&_T)
+{
+  int molID = -1;
+  molecule *mol = NULL;
+  if (typeid( std::vector<const molecule *> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValueMap[name]);
+    CurrentValueMap.erase(name);
+    while (!stream.fail()) {
+      stream >> molID >> ws;
+      mol = World::getInstance().getMolecule(MoleculeById(molID));
+      if (mol != NULL)
+        _T.push_back(mol);
+      molID = -1;
+      mol = NULL;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::queryCurrentValue(const char * name, boost::filesystem::path&_T)
+{
+  std::string tmp;
+  if (typeid( boost::filesystem::path ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    if (CurrentValueMap.find(name) == CurrentValueMap.end())
+      throw MissingValueException(__FILE__, __LINE__);
+    std::istringstream stream(CurrentValueMap[name]);
+    CurrentValueMap.erase(name);
+    if (!stream.fail()) {
+      stream >> tmp >> ws;
+      _T = tmp;
+    }
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, const atom * &_T)
+{
+  if (typeid( const atom *) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    stream << _T->getId();
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, const element * &_T)
+{
+  if (typeid( const element *) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    stream << _T->getAtomicNumber();
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, const molecule * &_T)
+{
+  if (typeid( const molecule *) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    stream << _T->getId();
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, class Box &_T)
+{
+  const Matrix &M = _T.getM();
+  if (typeid( Box ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    stream << M.at(0,0) << " ";
+    stream << M.at(0,1) << " ";
+    stream << M.at(0,2) << " ";
+    stream << M.at(1,1) << " ";
+    stream << M.at(1,2) << " ";
+    stream << M.at(2,2) << " ";
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, class Vector &_T)
+{
+  if (typeid( Vector ) == *(OptionRegistry_instance.getOptionByName(name)->getType())){
+    std::ostringstream stream;
+    stream << _T[0] << " ";
+    stream << _T[1] << " ";
+    stream << _T[2] << " ";
+    CurrentValueMap[name] = stream.str();
+  } else  if (typeid( BoxVector ) == *(OptionRegistry_instance.getOptionByName(name)->getType())){
+    std::ostringstream stream;
+    stream << _T[0] << " ";
+    stream << _T[1] << " ";
+    stream << _T[2] << " ";
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, std::vector<const atom *>&_T)
+{
+  if (typeid( std::vector<const atom *> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    for (std::vector<const atom *>::const_iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getId() << " ";
+    }
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, std::vector<const element *>&_T)
+{
+  if (typeid( std::vector<const element *> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    for (std::vector<const element *>::const_iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getAtomicNumber() << " ";
+    }
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, std::vector<const molecule *>&_T)
+{
+  if (typeid( std::vector<const molecule *> ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    for (std::vector<const molecule *>::const_iterator iter = _T.begin(); iter != _T.end(); ++iter) {
+      stream << (*iter)->getId() << " ";
+    }
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+void ValueStorage::setCurrentValue(const char * name, boost::filesystem::path &_T)
+{
+  if (typeid( boost::filesystem::path ) == *(OptionRegistry_instance.getOptionByName(name)->getType())) {
+    std::ostringstream stream;
+    stream << _T.string();
+    CurrentValueMap[name] = stream.str();
+  } else
+    throw IllegalTypeException(__FILE__,__LINE__);
+}
+
+const std::string ValueStorage::getCurrentValue(std::string actionname) {
+  return CurrentValueMap[actionname];
 }