tokenutils.h

Go to the documentation of this file.

/*
 *  tokenutils.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 TOKENUTILS_H
#define TOKENUTILS_H

#include "token.h"
#include "sliexceptions.h"
#include "namedatum.h"
#include <string>
#include "config.h"

template <typename FT>
FT getValue(const Token &t)
{
  FT *value = dynamic_cast<FT *>(t.datum());
  if (value == NULL) 
    {
      throw TypeMismatch();
    }
  return *value;
}

template <typename FT>
void setValue(const Token &t, FT const &value)
{
  FT *old = dynamic_cast<FT *>(t.datum());
  if (old == NULL)
    { 
      throw TypeMismatch();
    }
  
  *old = value;
}

template <typename FT, class D>
Token newToken2(FT const &value)
{
  Token t(new D(value));

  // this is for typechecking reasons:
  getValue<FT>(t);

  return t;
}


template <typename FT>
Token newToken(FT const &value)
{
  return newToken2<FT,NameDatum>(value);
}

// specializations below this line: -----------------------
template<>
long getValue<long>(const Token&);
template<>
void setValue<long>(const Token&, long const &value);

template<>
Token newToken<long>(long const &value);

template<>
double getValue<double>(const Token&);

template<>
void setValue<double>(const Token&, double const &value);

template<>
float getValue<float>(const Token&);

template<>
void setValue<float>(const Token&, float const &value);


template<>
Token newToken<double>(double const &value);

template<>
bool getValue<bool>(const Token&);
template<>
void setValue<bool>(const Token&, bool const &value);

template<>
Token newToken<bool>(bool const &value);


// These will handle StringDatum, NameDatum,
// LiteralDatum and SymbolDatum tokens:
template<>
std::string getValue<std::string>(const Token&);
template<>
void setValue<std::string>(const Token&, std::string const &value);


template<>
Token newToken<std::string>(std::string const &value);


// To get NameDatum, LiteralDatum or SymbolDatum tokens from a string,
// use newToken2<FT,D> instead (e.g. newToken2<string,LiteralDatum>);


// These will convert homogeneous int arrays to vectors:
template<>
std::vector<long> getValue<std::vector<long> >(const Token&);
template<>
void setValue<std::vector<long> >(const Token&, std::vector<long> const &value);

template<>
Token newToken<std::vector<long> >(std::vector<long> const &value);


// These will convert homogeneous double arrays to vectors:
template<>
std::vector<double> getValue<std::vector<double> >(const Token&);
template<>
void setValue<std::vector<double> >(const Token&, std::vector<double> const &value);

template<>
Token newToken<std::vector<double> >(std::vector<double> const &value);



// These will convert homogeneous int arrays to valarrays:
template<>
std::valarray<long> getValue<std::valarray<long> >(const Token&);
template<>
void setValue<std::valarray<long> >(const Token&, std::valarray<long> const &value);

template<>
Token newToken<std::valarray<long> >(std::valarray<long> const &value);


// These will convert homogeneous double arrays to valarrays:
template<>
std::valarray<double> getValue<std::valarray<double> >(const Token&);
template<>
void setValue<std::valarray<double> >(const Token&, std::valarray<double> const &value);

template<>
Token newToken<std::valarray<double> >(std::valarray<double> const &value);




#endif