ie_rettype.hpp

Go to the documentation of this file.

// Inference Engine Return Type implementation -*- C++ -*-

// $Id: ie_rettype.hpp 601 2008-04-29 23:18:57Z herman $
// 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 __IE_RETTYPE_HPP__
#define __IE_RETTYPE_HPP__

namespace coco {

inline const info_contents& ie_return_type::get_info() const
{
   return info;
}

inline void ie_return_type::set_termination_reason(const termination_reason& __t)
{
  termr = __t;
}

inline const termination_reason& ie_return_type::term_reason() const
{
  return termr;
}

inline ie_return_type ie_return_type::operator+(
    const std::pair<delta_base*,double>& __d)
{
  ie_return_type __tmp(*this);
  __tmp.deltas.push_back(__d.first->new_copy());
  __tmp.weights.push_back(__d.second);
  __tmp.certs.push_back(certificate(no_certificate()));
  return __tmp;
}

inline ie_return_type& ie_return_type::operator+=(
    const std::pair<delta_base*,double>& __d)
{
  no_certificate ncrt;

  deltas.push_back(__d.first->new_copy());
  weights.push_back(__d.second);
  certs.push_back(ncrt.new_copy());
  return *this;
}

inline ie_return_type ie_return_type::operator+(
    const std::triple<delta_base*,double,certificate_base*>& __d)
{
  ie_return_type __tmp(*this);
  __tmp.deltas.push_back(__d.first->new_copy());
  __tmp.weights.push_back(__d.second);
  __tmp.certs.push_back(__d.third->new_copy());
  return __tmp;
}

inline ie_return_type& ie_return_type::operator+=(
    const std::triple<delta_base*,double,certificate_base*>& __d)
{
  deltas.push_back(__d.first->new_copy());
  weights.push_back(__d.second);
  certs.push_back(__d.third->new_copy());
  return *this;
}

#if 0
inline ie_return_type ie_return_type::operator+(const std::pair<delta,double>& __d)
{
  ie_return_type __tmp(*this);
  __tmp.deltas.push_back(__d.first);
  __tmp.weights.push_back(__d.second);
  return __tmp;
}

inline ie_return_type& ie_return_type::operator+=(const std::pair<delta,double>& __d)
{
  deltas.push_back(__d.first);
  weights.push_back(__d.second);
  return *this;
}
#endif

inline ie_return_type& ie_return_type::operator=(const ie_return_type& __d)
{
  if (this != & __d) {
     termr = __d.termr;
     deltas = __d.deltas;
     weights = __d.weights;
     certs = __d.certs;
     _d = __d._d;
     info = __d.info;
  }
  return *this;
}

inline bool ie_return_type::set_information(const std::string& iname,
                                const basic_alltype& a, bool force)
{
  return info.sinsert(iname, a, force);
}

inline bool ie_return_type::set_information(const char* iname,
                                const basic_alltype& a, bool force)
{
  return set_information(std::string(iname), a, force);
}

inline bool ie_return_type::set_information_i(const std::string& iname, int i,
                                const basic_alltype& a, bool force)
{
  return info.sinsert(iname, i, a, force);
}

inline bool ie_return_type::set_information_i(const char *iname, int i,
                                const basic_alltype& a, bool force)
{
  return set_information_i(std::string(iname), i, a, force);
}

inline const basic_alltype& ie_return_type::information(
                                const std::string& iname) const
{
  return info.sfind(iname);
}

inline const basic_alltype& ie_return_type::information(const char* iname)
                                                                        const
{
  return information(std::string(iname));
}

inline const basic_alltype& ie_return_type::information(
                                        const std::string& iname, int i) const
{
  return info.sfind(iname, i);
}

inline const basic_alltype& ie_return_type::information(const char* iname,
                                                            int i) const
{
  return information(std::string(iname), i);
}

inline bool ie_return_type::has_information(const std::string& __s) const
{
  return info.defd(__s);
}

inline bool ie_return_type::has_information(const char* __cp) const
{
  return has_information(std::string(__cp));
}

inline bool ie_return_type::has_information(const std::string& __s, int i) const
{
  return info.defd(__s, i);
}

inline bool ie_return_type::has_information(const char* __cp, int i) const
{
  return has_information(std::string(__cp), i);
}

inline bool ie_return_type::information_indices_set(const std::string& __s,
                               std::vector<int>& __idx) const
{
  return info.which(__s, __idx);
}

inline bool ie_return_type::information_indices_set(const char* __cp,
                               std::vector<int>& __idx) const
{
  return information_indices_set(std::string(__cp), __idx);
}

inline void ie_return_type::unset_information(const std::string& __s)
{
  info.remove(__s);
}

inline void ie_return_type::unset_information(const char* __cp)
{
  unset_information(std::string(__cp));
}

inline void ie_return_type::unset_information(const std::string& __s, int i)
{
  info.remove(__s, i);
}

inline void ie_return_type::unset_information(const char* __cp, int i)
{
  unset_information(std::string(__cp), i);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const std::string& __s,
                        const std::vector<_TS>*& __b) const
{
  return info.retrieve(__s, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const std::string& __s,
                        const linalg::matrix<_TS>*& __b) const
{
  return info.retrieve(__s, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const std::string& __s, _TS& __b)
                                                                        const
{
  return info.retrieve(__s, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const std::string& __s,
        const std::vector<_TS>*& __b, const std::vector<_TS>* __def) const
{
  return info.retrieve(__s, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const std::string& __s,
        const linalg::matrix<_TS>*& __b, const linalg::matrix<_TS>* __def) const
{
  return info.retrieve(__s, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const std::string& __s, _TS& __b,
                        const _TS& __def) const
{
  return info.retrieve(__s, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const char* __s,
                        const std::vector<_TS>*& __b) const
{
  return retrieve_from_info(std::string(__s), __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const char* __s,
                        const linalg::matrix<_TS>*& __b) const
{
  return retrieve_from_info(std::string(__s), __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const char* __s, _TS& __b) const
{
  return retrieve_from_info(std::string(__s), __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const char* __s,
        const std::vector<_TS>*& __b, const std::vector<_TS>* __def) const
{
  return retrieve_from_info(std::string(__s), __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const char* __s,
        const linalg::matrix<_TS>*& __b, const linalg::matrix<_TS>* __def) const
{
  return retrieve_from_info(std::string(__s), __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info(const char* __s, _TS& __b,
                        const _TS& __def) const
{
  return retrieve_from_info(std::string(__s), __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const std::string& __s, int i,
                        const std::vector<_TS>*& __b) const
{
  return info.retrieve_i(__s, i, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const std::string& __s, int i,
                        const linalg::matrix<_TS>*& __b) const
{
  return info.retrieve_i(__s, i, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const std::string& __s, int i,
                        _TS& __b) const
{
  return info.retrieve_i(__s, i, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const std::string& __s, int i,
        const std::vector<_TS>*& __b, const std::vector<_TS>* __def) const
{
  return info.retrieve(__s, i, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const std::string& __s, int i,
                const linalg::matrix<_TS>*& __b, const linalg::matrix<_TS>* __def) const
{
  return info.retrieve(__s, i, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const std::string& __s, int i,
                _TS& __b, const _TS& __def) const
{
  return info.retrieve(__s, i, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const char* __s, int i,
                          const std::vector<_TS>*& __b) const
{
  return retrieve_from_info(std::string(__s), i, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const char* __s, int i,
                          const linalg::matrix<_TS>*& __b) const
{
  return retrieve_from_info(std::string(__s), i, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const char* __s, int i,
                        _TS& __b) const
{
  return retrieve_from_info(std::string(__s), i, __b);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const char* __s, int i,
        const std::vector<_TS>*& __b, const std::vector<_TS>* __def) const
{
  return retrieve_from_info(std::string(__s), i, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const char* __s, int i,
        const linalg::matrix<_TS>*& __b, const linalg::matrix<_TS>* __def) const
{
  return retrieve_from_info(std::string(__s), i, __b, __def);
}

template <class _TS>
inline bool ie_return_type::retrieve_from_info_i(const char* __s, int i,
                                _TS& __b, const _TS& __def) const
{
  return retrieve_from_info(std::string(__s), i, __b, __def);
}
  

} // namespace coco

#endif /* __IE_RETTYPE_HPP__ */

---