dictutils.h

Go to the documentation of this file.

/*
 *  dictutils.h
 *
 *  This file is part of NEST.
 *
 *  Copyright (C) 2004 The NEST Initiative
 *
 *  NEST is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  NEST is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with NEST.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef DICTUTILS_H
#define DICTUTILS_H

#include "dictdatum.h"
#include "namedatum.h"
#include "tokenutils.h"
#include "arraydatum.h"
#include "integerdatum.h"
#include "doubledatum.h"
#include <string>
#include <algorithm>
#include <functional>

template<typename FT>
FT getValue(const DictionaryDatum &d, Name const n)
{
  // We must take a reference, so that access information can be stored in the
  // token.
  const Token& t = d->lookup2(n);
  
  /* if (!t.empty()) */
  /*   throw UndefinedName(n.toString()); */
 
  return getValue<FT>(t);
}  
   
inline
double get_double_in_range(const DictionaryDatum &d, Name const n, double min, double max, int mode=2)
{
  // We must take a reference, so that access information can be stored in the
  // token.
  const Token& t = d->lookup2(n);
  DoubleDatum *dd= dynamic_cast<DoubleDatum *>(t.datum());
  double x=0.0;

  if (dd != 0)
    {
      x = dd->get();
    } 
  else
    {
      IntegerDatum *id= dynamic_cast<IntegerDatum *>(t.datum());
      if (id == 0)
    {
      throw TypeMismatch();
    }

      x = static_cast<double>(id->get());
    }
  switch(mode)
    {
    case 0:
      if(min< x and x < max)
    return x;
      break;
    case 1:
      if (min <= x and x < max)
    return x;
      break;
    case 2:
      if (min <= x and x <= max)
    return x;
      break;
    default:
      return x;
    }
  throw RangeCheck();
}

inline
long get_long_in_range(const DictionaryDatum &d, Name const n, long min, long max, int mode=2)
{
  // We must take a reference, so that access information can be stored in the
  // token.
  const Token& t = d->lookup2(n);
  DoubleDatum *dd= dynamic_cast<DoubleDatum *>(t.datum());
  long x=0;

  if (dd != 0)
    {
      x = dd->get();
    } 
  else
    {
      IntegerDatum *id= dynamic_cast<IntegerDatum *>(t.datum());
      if (id == 0)
    {
      throw TypeMismatch();
    }

      x = static_cast<double>(id->get());
    }
  switch(mode)
    {
    case 0:
      if(min< x and x < max)
    return x;
      break;
    case 1:
      if (min <= x and x < max)
    return x;
      break;
    case 2:
      if (min <= x and x <= max)
    return x;
      break;
    default:
      return x;
    }
  throw RangeCheck();
}


 
template<typename FT, class D>
void def2(DictionaryDatum &d, Name const n, FT const &value)
{
  Token t = newToken2<FT,D>(value);
  d->insert_move(n, t);
}

template<typename FT>
void def(DictionaryDatum &d, Name const n, FT const &value)
{
  Token t(value); // we hope that we have a constructor for this.
  d->insert_move(n, t);
}

template<typename FT, typename VT>
bool updateValue(DictionaryDatum const &d, Name const n, VT &value)
{
  // We will test for the name, and do nothing if it does not exist,
  // instead of simply trying to getValue() it and catching a possible
  // exception. The latter works, however, but non-existing names are
  // the rule with updateValue(), not the exception, hence using the
  // exception mechanism would be inappropriate. (Markus pointed this
  // out, 05.02.2001, Ruediger.)

  // We must take a reference, so that access information can be stored in the
  // token.
  const Token& t = d->lookup(n);

  if (t.empty())
    return false;
  
  value = getValue<FT>(t);
  return true;
}

template<typename FT, typename VT, class C>
void updateValue2(DictionaryDatum const &d, Name const n, C &obj, void (C::* setfunc)(VT))
{
  if (d->known(n)) // Does name exist in the dictionary?
  {
    // yes, call the function for update.
    (obj.*setfunc)(getValue<FT>(d, n));
  }
}


void initialize_property_array(DictionaryDatum &d, Name propname);


void initialize_property_doublevector(DictionaryDatum &d, Name propname);


void initialize_property_intvector(DictionaryDatum &d, Name propname);


template<typename PropT>
inline
void append_property(DictionaryDatum &d, Name propname, const PropT &prop)
{
  Token t = d->lookup(propname);
  assert (!t.empty());

  ArrayDatum* arrd = dynamic_cast<ArrayDatum*>(t.datum());
  assert(arrd != 0);

  Token prop_token(prop);
  arrd->push_back_dont_clone(prop_token);
}

template<>
inline
void append_property<std::vector<double> >(DictionaryDatum &d, Name propname, const std::vector<double> &prop)
{
  Token t = d->lookup(propname);
  assert (!t.empty());

  DoubleVectorDatum* arrd = dynamic_cast<DoubleVectorDatum*>(t.datum());
  assert(arrd != 0);

  (*arrd)->insert((*arrd)->end(), prop.begin(), prop.end());
}


template<>
inline
void append_property<std::vector<long> >(DictionaryDatum &d, Name propname, const std::vector<long> &prop)
{
  Token t = d->lookup(propname);
  assert (!t.empty());

  IntVectorDatum* arrd = dynamic_cast<IntVectorDatum*>(t.datum());
  assert(arrd != 0);

  (*arrd)->insert((*arrd)->end(), prop.begin(), prop.end());
}


void provide_property(DictionaryDatum&, Name, const std::vector<double>&);

void provide_property(DictionaryDatum&, Name, const std::vector<long>&);


void accumulate_property(DictionaryDatum&, Name, const std::vector<double>&);

#endif