---

cdat-inline.h

Go to the documentation of this file.

// Control data implementation -*- C++ -*-

// Copyright (C) 2001-2003 Hermann Schichl
//
// This file is part of the COCONUT API.  This library
// is free software; you can redistribute it and/or modify it under the
// terms of the Library GNU General Public License as published by the
// Free Software Foundation; either version 2, or (at your option)
// any later version.

// This library 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
// Library GNU General Public License for more details.

// As a special exception, you may use this file as part of a free software
// library without restriction.  Specifically, if other files instantiate
// templates or use macros or inline functions from this file, or you compile
// this file and link it with other files to produce an executable, this
// file does not by itself cause the resulting executable to be covered by
// the Library GNU General Public License.  This exception does not however
// invalidate any other reasons why the executable file might be covered by
// the Library GNU General Public License.

#ifndef __CDAT_INLINE_H__
#define __CDAT_INLINE_H__

inline void control_data::service(const std::string& __s) { _service = __s; }

inline void control_data::service(const char* __s)
{
  service(std::string(__s));
}

inline const std::string& control_data::service() const
{
  if(_service == std::string())
  {
    std::cerr << "no service defined for this call!" << std::endl;
    throw "Programming error";
  }
  return _service;
}

inline bool control_data::check_service(const std::string& __n) const
{
  return _service == __n;
}

inline bool control_data::check_service(const char* __n) const
{
  return check_service(std::string(__n));
}

template <class _S>
inline void control_data::assign(const std::string& __s,
                                 const std::vector<_S>*& __b) const
{
  if(!retrieve(__s, __b))
  {
    std::cerr << "required control data entry '" << __s
              << "' is missing" << std::endl;
    throw "Programming error";
  }
}

template <class _S>
inline void control_data::assign(const std::string& __s,
                                 const matrix<_S>*& __b) const
{
  if(!retrieve(__s, __b))
  {
    std::cerr << "required control data entry '" << __s
              << "' is missing" << std::endl;
    throw "Programming error";
  }
}

template <class _S>
inline void control_data::assign(const std::string& __s, _S& __b) const
{
  if(!retrieve(__s, __b))
  {
    std::cerr << "required control data entry '" << __s
              << "' is missing" << std::endl;
    throw "Programming error";
  }
}

inline void control_data::assign(const std::string& __s, std::string& __b,
                                 const char* __def) const
{
  retrieve(__s, __b, std::string(__def));
}

template <class _S>
inline void control_data::assign(const std::string& __s,
                                 const std::vector<_S>*& __b,
                                 const std::vector<_S>* __def) const
{
  retrieve(__s, __b, __def);
}

template <class _S>
inline void control_data::assign(const std::string& __s, const matrix<_S>*& __b,
                                 const matrix<_S>* __def) const
{
  retrieve(__s, __b, __def);
}

template <class _S>
inline void control_data::assign(const std::string& __s, _S& __b,
                                 _S __def) const
{
  retrieve(__s, __b, __def);
}

template <class _S>
inline void control_data::assign(const char* __s,
                                 const std::vector<_S>*& __b) const
{
  assign(std::string(__s), __b);
}

template <class _S>
inline void control_data::assign(const char* __s, const matrix<_S>*& __b) const
{
  assign(std::string(__s), __b);
}

template <class _S>
inline void control_data::assign(const char* __s, _S& __b) const
{
  assign(std::string(__s), __b);
}

inline void control_data::assign(const char* __s, std::string& __b,
                                 const char* __def) const
{
  assign(std::string(__s), __b, __def);
}

template <class _S>
inline void control_data::assign(const char* __s, const std::vector<_S>*& __b,
                                 const std::vector<_S>* __def) const
{
  assign(std::string(__s), __b, __def);
}

template <class _S>
inline void control_data::assign(const char* __s, const matrix<_S>*& __b,
                                 const matrix<_S>* __def) const
{
  assign(std::string(__s), __b, __def);
}

template <class _S>
inline void control_data::assign(const char* __s, _S& __b,
                                 _S __def) const
{
  assign(std::string(__s), __b, __def);
}

template <class _S>
inline void control_data::assign_i(const std::string& __s, int i,
                                   const std::vector<_S>*& __b) const
{
  if(!retrieve_i(__s, i, __b))
  {
    std::cerr << "required control data entry '" << __s
              << "' is missing" << std::endl;
    throw "Programming error";
  }
}

template <class _S>
inline void control_data::assign_i(const std::string& __s, int i,
                                   const matrix<_S>*& __b) const
{
  if(!retrieve_i(__s, i, __b))
  {
    std::cerr << "required control data entry '" << __s
              << "' is missing" << std::endl;
    throw "Programming error";
  }
}

template <class _S>
inline void control_data::assign_i(const std::string& __s, int i, _S& __b) const
{
  if(!retrieve_i(__s, i, __b))
  {
    std::cerr << "required control data entry '" << __s
              << "' is missing" << std::endl;
    throw "Programming error";
  }
}

inline void control_data::assign_i(const std::string& __s, int i,
                                   std::string& __b, const char* __def) const
{
  retrieve_i(__s, i, __b, std::string(__def));
}

template <class _S>
inline void control_data::assign_i(const std::string& __s, int i,
                                   const std::vector<_S>*& __b,
                                   const std::vector<_S>* __def) const
{
  retrieve_i(__s, i, __b, __def);
}

template <class _S>
inline void control_data::assign_i(const std::string& __s, int i,
                                   const matrix<_S>*& __b,
                                   const matrix<_S>* __def) const
{
  retrieve_i(__s, i, __b, __def);
}

template <class _S>
inline void control_data::assign_i(const std::string& __s, int i, _S& __b,
                                   _S __def) const
{
  retrieve_i(__s, i, __b, __def);
}

template <class _S>
inline void control_data::assign_i(const char* __s, int i,
                                   const std::vector<_S>*& __b) const
{
  assign_i(std::string(__s), i, __b);
}

template <class _S>
inline void control_data::assign_i(const char* __s, int i,
                                   const matrix<_S>*& __b) const
{
  assign_i(std::string(__s), i, __b);
}

template <class _S>
inline void control_data::assign_i(const char* __s, int i, _S& __b) const
{
  assign_i(std::string(__s), i, __b);
}

inline void control_data::assign_i(const char* __s, int i, std::string& __b,
                                   const char* __def) const
{
  assign_i(std::string(__s), i, __b, __def);
}

template <class _S>
inline void control_data::assign_i(const char* __s, int i,
                                   const std::vector<_S>*& __b,
                                   const std::vector<_S>* __def) const
{
  assign_i(std::string(__s), i, __b, __def);
}

template <class _S>
inline void control_data::assign_i(const char* __s, int i,
                                   const matrix<_S>*& __b,
                                   const matrix<_S>* __def) const
{
  assign_i(std::string(__s), i, __b, __def);
}

template <class _S>
inline void control_data::assign_i(const char* __s, int i, _S& __b,
                                   _S __def) const
{
  assign_i(std::string(__s), i, __b, __def);
}

#endif /* __CDAT_INLINE_H__ */

---