source: src/Actions/ValueStorage.cpp@ 0bbfa1

/*
 * Project: MoleCuilder
 * Description: creates and alters molecular systems
 * Copyright (C)  2010 University of Bonn. All rights reserved.
 * Please see the LICENSE file or "Copyright notice" in builder.cpp for details.
 */

/*
 * ValueStorage.cpp
 *
 *  Created on: Jul 22, 2010
 *      Author: heber
 */

// include config.h
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include "Helpers/MemDebug.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/RealSpaceMatrix.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() :
OptionRegistry_instance(OptionRegistry::getInstance())
{};

ValueStorage::~ValueStorage() {};


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) {
  RealSpaceMatrix 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 RealSpaceMatrix &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];
}

CONSTRUCT_SINGLETON(ValueStorage)