---

datamap-inline.h

Go to the documentation of this file.

// Data map 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 __DATAMAP_INLINE_H__
#define __DATAMAP_INLINE_H__

#define __DATAMAP_SEPARATOR  "%"
#define __DATAMAP_IDXSPEC    "IDX"

inline bool datamap::sinsert(const char* __cp, const additional_info_u& __h,
                             bool remove)
{
  return sinsert(std::string(__cp), __h, remove);
}

inline bool datamap::sinsert(const std::string& __s, int i,
                             const additional_info_u& __h,
                             bool remove)
{
  update_index(__s, i, true);
  return sinsert(encode(__s, i), __h, remove);
}

inline bool datamap::sinsert(const char* __cp, int i,
                             const additional_info_u& __h,
                             bool remove)
{
  return sinsert(std::string(__cp), i, __h, remove);
}

inline void datamap::remove(const std::string& __s)
{
  _Base::iterator __b = find(__s);

  if(__b != end())
    erase(__b);
}

inline void datamap::remove(const char* __cp)
{
  remove(std::string(__cp));
}

inline void datamap::remove(const std::string& __s, int i)
{
  update_index(__s, i, false);
  remove(encode(__s, i));
}

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

inline const additional_info_u& datamap::sfind(const std::string& __s) const
{
  _Base::const_iterator __b = find(__s);
  if(__b == end())
    return __empty;
  else
    return __b->second;
}

inline const additional_info_u& datamap::sfind(const char* __cp) const
{
  return sfind(std::string(__cp));
}

inline const additional_info_u& datamap::sfind(const std::string& __s,
                                                  int i) const
{
  if(check_index(__s, i))
    return sfind(encode(__s, i));
  else
    return __empty;
}

inline const additional_info_u& datamap::sfind(const char* __cp, int i) const
{
  return sfind(std::string(__cp), i);
}

inline bool datamap::defd(const std::string& __s) const
{
  return find(__s) != end();
}

inline bool datamap::defd(const char* __cp) const
{
  return defd(std::string(__cp));
}

inline bool datamap::defd(const std::string& __s, int i) const
{
  return check_index(__s, i);
}

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

inline bool datamap::which(const std::string& __s,
                                    std::vector<int>& __idx) const
{
  _Base::const_iterator __b = find(__s + __DATAMAP_SEPARATOR+__DATAMAP_IDXSPEC);
  if(__b != end())
  {
    __idx = __b->second.n();
    return true;
  }
  else if(!__idx.empty())
    __idx.erase(__idx.begin(), __idx.end());
  return false;
}

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

inline bool datamap::retrieve(const std::string& __s, bool& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
#if 0
    std::cerr << "required control data entry '" << __s
         << "' is missing" << std::endl;
    throw "Programming error";
#endif
    return false;
  }
  else
    __b = __a.nb();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, bool& __b, bool __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = __a.nb();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, int& __d) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __d = __a.nn();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, int& __d, int __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __d = __def;
  else
    __d = __a.nn();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, unsigned int& __d) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __d = __a.nu();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, unsigned int& __d, unsigned int __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __d = __def;
  else
    __d = __a.nu();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, double& __d) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __d = __a.nd();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, double& __d, double __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __d = __def;
  else
    __d = __a.nd();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, interval& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = __a.ni();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, interval& __b, const interval& __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = __a.ni();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, std::string& __is) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __is = __a.s();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, std::string& __is, const std::string& __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __is = __def;
  else
    __is = __a.s();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<bool>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.b();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.b();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<int>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.n();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<int>*& __b, const std::vector<int>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.n();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<unsigned int>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.u();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.u();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<double>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.d();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<double>*& __b, const std::vector<double>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.d();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<interval>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.i();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.i();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const matrix<double>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.m();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const matrix<double>*& __b, const matrix<double>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.m();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const matrix<int>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.nm();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const matrix<int>*& __b, const matrix<int>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.nm();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const matrix<interval>*& __b) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
  {
    return false;
  }
  else
    __b = &__a.im();
  return true;
}

inline bool datamap::retrieve(const std::string& __s, const matrix<interval>*& __b, const matrix<interval>* __def) const
{
  const additional_info_u& __a(sfind(__s));
  if(__a.empty())
    __b = __def;
  else
    __b = &__a.im();
  return true;
}


inline bool datamap::retrieve(const char* __s, bool& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, bool& __b, bool __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, int& __d) const
{
  return(retrieve(std::string(__s), __d));
}

inline bool datamap::retrieve(const char* __s, int& __d, int __def) const
{
  return(retrieve(std::string(__s), __d, __def));
}

inline bool datamap::retrieve(const char* __s, unsigned int& __d) const
{
  return(retrieve(std::string(__s), __d));
}

inline bool datamap::retrieve(const char* __s, unsigned int& __d, unsigned int __def) const
{
  return(retrieve(std::string(__s), __d, __def));
}

inline bool datamap::retrieve(const char* __s, double& __d) const
{
  return(retrieve(std::string(__s), __d));
}

inline bool datamap::retrieve(const char* __s, double& __d, double __def) const
{
  return(retrieve(std::string(__s), __d, __def));
}

inline bool datamap::retrieve(const char* __s, interval& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, interval& __b, const interval& __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, std::string& __is) const
{
  return(retrieve(std::string(__s), __is));
}

inline bool datamap::retrieve(const char* __s, std::string& __b, const std::string& __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const std::vector<bool>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const std::vector<int>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const std::vector<int>*& __b, const std::vector<int>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const std::vector<unsigned int>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const std::vector<double>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const std::vector<double>*& __b, const std::vector<double>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const std::vector<interval>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const matrix<double>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const matrix<double>*& __b,
      const matrix<double>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const matrix<int>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const matrix<int>*& __b,
      const matrix<int>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve(const char* __s, const matrix<interval>*& __b) const
{
  return(retrieve(std::string(__s), __b));
}

inline bool datamap::retrieve(const char* __s, const matrix<interval>*& __b,
      const matrix<interval>* __def) const
{
  return(retrieve(std::string(__s), __b, __def));
}

inline bool datamap::retrieve_i(const std::string& __s, int i, bool& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, bool& __b, bool __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, int& __d) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __d);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, int& __d, int __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __d);
  else
    __d = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, unsigned int& __d) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __d);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, unsigned int& __d, unsigned int __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __d);
  else
    __d = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, double& __d) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __d);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, double& __d, double __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __d);
  else
    __d = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, interval& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, interval& __b, const interval& __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, std::string& __is) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __is);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, std::string& __is, const std::string& __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __is);
  else
    __is = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<bool>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<int>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<int>*& __b, const std::vector<int>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<unsigned int>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<double>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<double>*& __b, const std::vector<double>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<interval>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const matrix<double>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const matrix<double>*& __b, const matrix<double>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const matrix<int>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const matrix<int>*& __b, const matrix<int>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const matrix<interval>*& __b) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
  {
    return false;
  }
  return true;
}

inline bool datamap::retrieve_i(const std::string& __s, int i, const matrix<interval>*& __b, const matrix<interval>* __def) const
{
  if(check_index(__s, i))
    return retrieve(encode(__s, i), __b);
  else
    __b = __def;
  return true;
}


inline bool datamap::retrieve_i(const char* __s, int i, bool& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, bool& __b, bool __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, int& __d) const
{
  return(retrieve_i(std::string(__s), i, __d));
}

inline bool datamap::retrieve_i(const char* __s, int i, int& __d, int __def) const
{
  return(retrieve_i(std::string(__s), i, __d, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, unsigned int& __d) const
{
  return(retrieve_i(std::string(__s), i, __d));
}

inline bool datamap::retrieve_i(const char* __s, int i, unsigned int& __d, unsigned int __def) const
{
  return(retrieve_i(std::string(__s), i, __d, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, double& __d) const
{
  return(retrieve_i(std::string(__s), i, __d));
}

inline bool datamap::retrieve_i(const char* __s, int i, double& __d, double __def) const
{
  return(retrieve_i(std::string(__s), i, __d, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, interval& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, interval& __b, const interval& __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, std::string& __is) const
{
  return(retrieve_i(std::string(__s), i, __is));
}

inline bool datamap::retrieve_i(const char* __s, int i, std::string& __b, const std::string& __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<bool>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<int>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<int>*& __b, const std::vector<int>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<unsigned int>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<double>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<double>*& __b, const std::vector<double>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<interval>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const matrix<double>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const matrix<double>*& __b,
      const matrix<double>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const matrix<int>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const matrix<int>*& __b,
      const matrix<int>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

inline bool datamap::retrieve_i(const char* __s, int i, const matrix<interval>*& __b) const
{
  return(retrieve_i(std::string(__s), i, __b));
}

inline bool datamap::retrieve_i(const char* __s, int i, const matrix<interval>*& __b,
      const matrix<interval>* __def) const
{
  return(retrieve_i(std::string(__s), i, __b, __def));
}

#endif /* __DATAMAP_INLINE_H__ */

---