COCONUT API: datamap.hpp Source File

00001 // Data map implementation -*- C++ -*-
00002 
00003 // $Id: datamap.hpp 347 2008-02-06 15:20:01Z schilly $
00004 // Copyright (C) 2001-2003 Hermann Schichl
00005 //
00006 // This file is part of the COCONUT API.  This library
00007 // is free software; you can redistribute it and/or modify it under the
00008 // terms of the Library GNU General Public License as published by the
00009 // Free Software Foundation; either version 2, or (at your option)
00010 // any later version.
00011 
00012 // This library is distributed in the hope that it will be useful,
00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00015 // Library GNU General Public License for more details.
00016 
00017 // As a special exception, you may use this file as part of a free software
00018 // library without restriction.  Specifically, if other files instantiate
00019 // templates or use macros or inline functions from this file, or you compile
00020 // this file and link it with other files to produce an executable, this
00021 // file does not by itself cause the resulting executable to be covered by
00022 // the Library GNU General Public License.  This exception does not however
00023 // invalidate any other reasons why the executable file might be covered by
00024 // the Library GNU General Public License.
00025 
00028 #ifndef __DATAMAP_HPP__
00029 #define __DATAMAP_HPP__
00030 
00031 namespace coco {
00032 
00033 #define __DATAMAP_SEPARATOR  "%"
00034 #define __DATAMAP_IDXSPEC    "IDX"
00035 
00036 inline bool datamap::sinsert(const char* __cp, const basic_alltype& __h,
00037                              bool remove)
00038 {
00039   return sinsert(std::string(__cp), __h, remove);
00040 }
00041 
00042 inline bool datamap::sinsert(const std::string& __s, int i,
00043                              const basic_alltype& __h,
00044                              bool remove)
00045 {
00046   update_index(__s, i, true);
00047   return sinsert(encode(__s, i), __h, remove);
00048 }
00049 
00050 inline bool datamap::sinsert(const char* __cp, int i,
00051                              const basic_alltype& __h,
00052                              bool remove)
00053 {
00054   return sinsert(std::string(__cp), i, __h, remove);
00055 }
00056 
00057 inline void datamap::remove(const std::string& __s)
00058 {
00059   _Base::iterator __b = find(__s);
00060 
00061   if(__b != end())
00062     erase(__b);
00063 }
00064 
00065 inline void datamap::remove(const char* __cp)
00066 {
00067   remove(std::string(__cp));
00068 }
00069 
00070 inline void datamap::remove(const std::string& __s, int i)
00071 {
00072   update_index(__s, i, false);
00073   remove(encode(__s, i));
00074 }
00075 
00076 inline void datamap::remove(const char* __cp, int i)
00077 {
00078   remove(std::string(__cp), i);
00079 }
00080 
00081 inline const basic_alltype& datamap::sfind(const std::string& __s) const
00082 {
00083   _Base::const_iterator __b = find(__s);
00084   if(__b == end())
00085         return basic_alltype_empty();
00086   else
00087     return __b->second;
00088 }
00089 
00090 inline const basic_alltype& datamap::sfind(const char* __cp) const
00091 {
00092   return sfind(std::string(__cp));
00093 }
00094 
00095 inline const basic_alltype& datamap::sfind(const std::string& __s,
00096                                                   int i) const
00097 {
00098   if(check_index(__s, i))
00099     return sfind(encode(__s, i));
00100   else
00101     return basic_alltype_empty();
00102 }
00103 
00104 inline const basic_alltype& datamap::sfind(const char* __cp, int i) const
00105 {
00106   return sfind(std::string(__cp), i);
00107 }
00108 
00109 inline bool datamap::defd(const std::string& __s) const
00110 {
00111   return find(__s) != end();
00112 }
00113 
00114 inline bool datamap::defd(const char* __cp) const
00115 {
00116   return defd(std::string(__cp));
00117 }
00118 
00119 inline bool datamap::defd(const std::string& __s, int i) const
00120 {
00121   return check_index(__s, i);
00122 }
00123 
00124 inline bool datamap::defd(const char* __cp, int i) const
00125 {
00126   return defd(std::string(__cp), i);
00127 }
00128 
00129 inline bool datamap::which(const std::string& __s,
00130                                     std::vector<int>& __idx) const
00131 {
00132   _Base::const_iterator __b = find(__s + __DATAMAP_SEPARATOR+__DATAMAP_IDXSPEC);
00133   if(__b != end())
00134   {
00135     __idx = __b->second.n();
00136     return true;
00137   }
00138   else if(!__idx.empty())
00139     __idx.erase(__idx.begin(), __idx.end());
00140   return false;
00141 }
00142 
00143 inline bool datamap::which(const char* __cp, 
00144                                     std::vector<int>& __idx) const
00145 {
00146   return which(std::string(__cp), __idx);
00147 }
00148 
00149 inline bool datamap::retrieve(const std::string& __s, bool& __b) const
00150 {
00151   const basic_alltype& __a(sfind(__s));
00152   if(__a.empty())
00153     return false;
00154   else
00155     __b = __a.nb();
00156   return true;
00157 }
00158 
00159 inline bool datamap::retrieve(const std::string& __s, bool& __b, bool __def) const
00160 {
00161   const basic_alltype& __a(sfind(__s));
00162   if(__a.empty())
00163     __b = __def;
00164   else
00165     __b = __a.nb();
00166   return true;
00167 }
00168 
00169 inline bool datamap::retrieve(const std::string& __s, int& __d) const
00170 {
00171   const basic_alltype& __a(sfind(__s));
00172   if(__a.empty())
00173   {
00174     return false;
00175   }
00176   else
00177     __d = __a.nn();
00178   return true;
00179 }
00180 
00181 inline bool datamap::retrieve(const std::string& __s, int& __d, int __def) const
00182 {
00183   const basic_alltype& __a(sfind(__s));
00184   if(__a.empty())
00185     __d = __def;
00186   else
00187     __d = __a.nn();
00188   return true;
00189 }
00190 
00191 inline bool datamap::retrieve(const std::string& __s, unsigned int& __d) const
00192 {
00193   const basic_alltype& __a(sfind(__s));
00194   if(__a.empty())
00195   {
00196     return false;
00197   }
00198   else
00199     __d = __a.nu();
00200   return true;
00201 }
00202 
00203 inline bool datamap::retrieve(const std::string& __s, unsigned int& __d, unsigned int __def) const
00204 {
00205   const basic_alltype& __a(sfind(__s));
00206   if(__a.empty())
00207     __d = __def;
00208   else
00209     __d = __a.nu();
00210   return true;
00211 }
00212 
00213 inline bool datamap::retrieve(const std::string& __s, double& __d) const
00214 {
00215   const basic_alltype& __a(sfind(__s));
00216   if(__a.empty())
00217   {
00218     return false;
00219   }
00220   else
00221     __d = __a.nd();
00222   return true;
00223 }
00224 
00225 inline bool datamap::retrieve(const std::string& __s, double& __d, double __def) const
00226 {
00227   const basic_alltype& __a(sfind(__s));
00228   if(__a.empty())
00229     __d = __def;
00230   else
00231     __d = __a.nd();
00232   return true;
00233 }
00234 
00235 inline bool datamap::retrieve(const std::string& __s, interval& __b) const
00236 {
00237   const basic_alltype& __a(sfind(__s));
00238   if(__a.empty())
00239   {
00240     return false;
00241   }
00242   else
00243     __b = __a.ni();
00244   return true;
00245 }
00246 
00247 inline bool datamap::retrieve(const std::string& __s, interval& __b, const interval& __def) const
00248 {
00249   const basic_alltype& __a(sfind(__s));
00250   if(__a.empty())
00251     __b = __def;
00252   else
00253     __b = __a.ni();
00254   return true;
00255 }
00256 
00257 inline bool datamap::retrieve(const std::string& __s, std::string& __is) const
00258 {
00259   const basic_alltype& __a(sfind(__s));
00260   if(__a.empty())
00261   {
00262     return false;
00263   }
00264   else
00265     __is = __a.s();
00266   return true;
00267 }
00268 
00269 inline bool datamap::retrieve(const std::string& __s, std::string& __is, const std::string& __def) const
00270 {
00271   const basic_alltype& __a(sfind(__s));
00272   if(__a.empty())
00273     __is = __def;
00274   else
00275     __is = __a.s();
00276   return true;
00277 }
00278 
00279 inline bool datamap::retrieve(const std::string& __s, const std::vector<bool>*& __b) const
00280 {
00281   const basic_alltype& __a(sfind(__s));
00282   if(__a.empty())
00283   {
00284     return false;
00285   }
00286   else
00287     __b = &__a.b();
00288   return true;
00289 }
00290 
00291 inline bool datamap::retrieve(const std::string& __s, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
00292 {
00293   const basic_alltype& __a(sfind(__s));
00294   if(__a.empty())
00295     __b = __def;
00296   else
00297     __b = &__a.b();
00298   return true;
00299 }
00300 
00301 inline bool datamap::retrieve(const std::string& __s, const std::vector<int>*& __b) const
00302 {
00303   const basic_alltype& __a(sfind(__s));
00304   if(__a.empty())
00305   {
00306     return false;
00307   }
00308   else
00309     __b = &__a.n();
00310   return true;
00311 }
00312 
00313 inline bool datamap::retrieve(const std::string& __s, const std::vector<int>*& __b, const std::vector<int>* __def) const
00314 {
00315   const basic_alltype& __a(sfind(__s));
00316   if(__a.empty())
00317     __b = __def;
00318   else
00319     __b = &__a.n();
00320   return true;
00321 }
00322 
00323 inline bool datamap::retrieve(const std::string& __s, const std::vector<unsigned int>*& __b) const
00324 {
00325   const basic_alltype& __a(sfind(__s));
00326   if(__a.empty())
00327   {
00328     return false;
00329   }
00330   else
00331     __b = &__a.u();
00332   return true;
00333 }
00334 
00335 inline bool datamap::retrieve(const std::string& __s, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
00336 {
00337   const basic_alltype& __a(sfind(__s));
00338   if(__a.empty())
00339     __b = __def;
00340   else
00341     __b = &__a.u();
00342   return true;
00343 }
00344 
00345 inline bool datamap::retrieve(const std::string& __s, const std::vector<double>*& __b) const
00346 {
00347   const basic_alltype& __a(sfind(__s));
00348   if(__a.empty())
00349   {
00350     return false;
00351   }
00352   else
00353     __b = &__a.d();
00354   return true;
00355 }
00356 
00357 inline bool datamap::retrieve(const std::string& __s, const std::vector<double>*& __b, const std::vector<double>* __def) const
00358 {
00359   const basic_alltype& __a(sfind(__s));
00360   if(__a.empty())
00361     __b = __def;
00362   else
00363     __b = &__a.d();
00364   return true;
00365 }
00366 
00367 inline bool datamap::retrieve(const std::string& __s, const std::vector<interval>*& __b) const
00368 {
00369   const basic_alltype& __a(sfind(__s));
00370   if(__a.empty())
00371   {
00372     return false;
00373   }
00374   else
00375     __b = &__a.i();
00376   return true;
00377 }
00378 
00379 inline bool datamap::retrieve(const std::string& __s, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
00380 {
00381   const basic_alltype& __a(sfind(__s));
00382   if(__a.empty())
00383     __b = __def;
00384   else
00385     __b = &__a.i();
00386   return true;
00387 }
00388 
00389 inline bool datamap::retrieve(const std::string& __s, const std::vector<std::string>*& __b) const
00390 {
00391   const basic_alltype& __a(sfind(__s));
00392   if(__a.empty())
00393   {
00394     return false;
00395   }
00396   else
00397     __b = &__a.sv();
00398   return true;
00399 }
00400 
00401 inline bool datamap::retrieve(const std::string& __s, const std::vector<std::string>*& __b, const std::vector<std::string>* __def) const
00402 {
00403   const basic_alltype& __a(sfind(__s));
00404   if(__a.empty())
00405     __b = __def;
00406   else
00407     __b = &__a.sv();
00408   return true;
00409 }
00410 
00411 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<double>*& __b) const
00412 {
00413   const basic_alltype& __a(sfind(__s));
00414   if(__a.empty())
00415   {
00416     return false;
00417   }
00418   else
00419     __b = &__a.m();
00420   return true;
00421 }
00422 
00423 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<double>*& __b, const linalg::matrix<double>* __def) const
00424 {
00425   const basic_alltype& __a(sfind(__s));
00426   if(__a.empty())
00427     __b = __def;
00428   else
00429     __b = &__a.m();
00430   return true;
00431 }
00432 
00433 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<int>*& __b) const
00434 {
00435   const basic_alltype& __a(sfind(__s));
00436   if(__a.empty())
00437   {
00438     return false;
00439   }
00440   else
00441     __b = &__a.nm();
00442   return true;
00443 }
00444 
00445 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<int>*& __b, const linalg::matrix<int>* __def) const
00446 {
00447   const basic_alltype& __a(sfind(__s));
00448   if(__a.empty())
00449     __b = __def;
00450   else
00451     __b = &__a.nm();
00452   return true;
00453 }
00454 
00455 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<interval>*& __b) const
00456 {
00457   const basic_alltype& __a(sfind(__s));
00458   if(__a.empty())
00459   {
00460     return false;
00461   }
00462   else
00463     __b = &__a.im();
00464   return true;
00465 }
00466 
00467 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<interval>*& __b, const linalg::matrix<interval>* __def) const
00468 {
00469   const basic_alltype& __a(sfind(__s));
00470   if(__a.empty())
00471     __b = __def;
00472   else
00473     __b = &__a.im();
00474   return true;
00475 }
00476 
00477 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<std::string>*& __b) const
00478 {
00479   const basic_alltype& __a(sfind(__s));
00480   if(__a.empty())
00481   {
00482     return false;
00483   }
00484   else
00485     __b = &__a.sm();
00486   return true;
00487 }
00488 
00489 inline bool datamap::retrieve(const std::string& __s, const linalg::matrix<std::string>*& __b, const linalg::matrix<std::string>* __def) const
00490 {
00491   const basic_alltype& __a(sfind(__s));
00492   if(__a.empty())
00493     __b = __def;
00494   else
00495     __b = &__a.sm();
00496   return true;
00497 }
00498 
00499 
00500 inline bool datamap::retrieve(const char* __s, bool& __b) const
00501 {
00502   return(retrieve(std::string(__s), __b));
00503 }
00504 
00505 inline bool datamap::retrieve(const char* __s, bool& __b, bool __def) const
00506 {
00507   return(retrieve(std::string(__s), __b, __def));
00508 }
00509 
00510 inline bool datamap::retrieve(const char* __s, int& __d) const
00511 {
00512   return(retrieve(std::string(__s), __d));
00513 }
00514 
00515 inline bool datamap::retrieve(const char* __s, int& __d, int __def) const
00516 {
00517   return(retrieve(std::string(__s), __d, __def));
00518 }
00519 
00520 inline bool datamap::retrieve(const char* __s, unsigned int& __d) const
00521 {
00522   return(retrieve(std::string(__s), __d));
00523 }
00524 
00525 inline bool datamap::retrieve(const char* __s, unsigned int& __d, unsigned int __def) const
00526 {
00527   return(retrieve(std::string(__s), __d, __def));
00528 }
00529 
00530 inline bool datamap::retrieve(const char* __s, double& __d) const
00531 {
00532   return(retrieve(std::string(__s), __d));
00533 }
00534 
00535 inline bool datamap::retrieve(const char* __s, double& __d, double __def) const
00536 {
00537   return(retrieve(std::string(__s), __d, __def));
00538 }
00539 
00540 inline bool datamap::retrieve(const char* __s, interval& __b) const
00541 {
00542   return(retrieve(std::string(__s), __b));
00543 }
00544 
00545 inline bool datamap::retrieve(const char* __s, interval& __b, const interval& __def) const
00546 {
00547   return(retrieve(std::string(__s), __b, __def));
00548 }
00549 
00550 inline bool datamap::retrieve(const char* __s, std::string& __is) const
00551 {
00552   return(retrieve(std::string(__s), __is));
00553 }
00554 
00555 inline bool datamap::retrieve(const char* __s, std::string& __b, const std::string& __def) const
00556 {
00557   return(retrieve(std::string(__s), __b, __def));
00558 }
00559 
00560 inline bool datamap::retrieve(const char* __s, const std::vector<bool>*& __b) const
00561 {
00562   return(retrieve(std::string(__s), __b));
00563 }
00564 
00565 inline bool datamap::retrieve(const char* __s, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
00566 {
00567   return(retrieve(std::string(__s), __b, __def));
00568 }
00569 
00570 inline bool datamap::retrieve(const char* __s, const std::vector<int>*& __b) const
00571 {
00572   return(retrieve(std::string(__s), __b));
00573 }
00574 
00575 inline bool datamap::retrieve(const char* __s, const std::vector<int>*& __b, const std::vector<int>* __def) const
00576 {
00577   return(retrieve(std::string(__s), __b, __def));
00578 }
00579 
00580 inline bool datamap::retrieve(const char* __s, const std::vector<unsigned int>*& __b) const
00581 {
00582   return(retrieve(std::string(__s), __b));
00583 }
00584 
00585 inline bool datamap::retrieve(const char* __s, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
00586 {
00587   return(retrieve(std::string(__s), __b, __def));
00588 }
00589 
00590 inline bool datamap::retrieve(const char* __s, const std::vector<double>*& __b) const
00591 {
00592   return(retrieve(std::string(__s), __b));
00593 }
00594 
00595 inline bool datamap::retrieve(const char* __s, const std::vector<double>*& __b, const std::vector<double>* __def) const
00596 {
00597   return(retrieve(std::string(__s), __b, __def));
00598 }
00599 
00600 inline bool datamap::retrieve(const char* __s, const std::vector<interval>*& __b) const
00601 {
00602   return(retrieve(std::string(__s), __b));
00603 }
00604 
00605 inline bool datamap::retrieve(const char* __s, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
00606 {
00607   return(retrieve(std::string(__s), __b, __def));
00608 }
00609 
00610 inline bool datamap::retrieve(const char* __s, const std::vector<std::string>*& __b) const
00611 {
00612   return(retrieve(std::string(__s), __b));
00613 }
00614 
00615 inline bool datamap::retrieve(const char* __s, const std::vector<std::string>*& __b, const std::vector<std::string>* __def) const
00616 {
00617   return(retrieve(std::string(__s), __b, __def));
00618 }
00619 
00620 inline bool datamap::retrieve(const char* __s, const linalg::matrix<double>*& __b) const
00621 {
00622   return(retrieve(std::string(__s), __b));
00623 }
00624 
00625 inline bool datamap::retrieve(const char* __s, const linalg::matrix<double>*& __b,
00626       const linalg::matrix<double>* __def) const
00627 {
00628   return(retrieve(std::string(__s), __b, __def));
00629 }
00630 
00631 inline bool datamap::retrieve(const char* __s, const linalg::matrix<int>*& __b) const
00632 {
00633   return(retrieve(std::string(__s), __b));
00634 }
00635 
00636 inline bool datamap::retrieve(const char* __s, const linalg::matrix<int>*& __b,
00637       const linalg::matrix<int>* __def) const
00638 {
00639   return(retrieve(std::string(__s), __b, __def));
00640 }
00641 
00642 inline bool datamap::retrieve(const char* __s, const linalg::matrix<interval>*& __b) const
00643 {
00644   return(retrieve(std::string(__s), __b));
00645 }
00646 
00647 inline bool datamap::retrieve(const char* __s, const linalg::matrix<interval>*& __b,
00648       const linalg::matrix<interval>* __def) const
00649 {
00650   return(retrieve(std::string(__s), __b, __def));
00651 }
00652 
00653 inline bool datamap::retrieve(const char* __s, const linalg::matrix<std::string>*& __b) const
00654 {
00655   return(retrieve(std::string(__s), __b));
00656 }
00657 
00658 inline bool datamap::retrieve(const char* __s, const linalg::matrix<std::string>*& __b,
00659       const linalg::matrix<std::string>* __def) const
00660 {
00661   return(retrieve(std::string(__s), __b, __def));
00662 }
00663 
00664 inline bool datamap::retrieve_i(const std::string& __s, int i, bool& __b) const
00665 {
00666   if(check_index(__s, i))
00667     return retrieve(encode(__s, i), __b);
00668   else
00669   {
00670     return false;
00671   }
00672   return true;
00673 }
00674 
00675 inline bool datamap::retrieve_i(const std::string& __s, int i, bool& __b, bool __def) const
00676 {
00677   if(check_index(__s, i))
00678     return retrieve(encode(__s, i), __b);
00679   else
00680     __b = __def;
00681   return true;
00682 }
00683 
00684 inline bool datamap::retrieve_i(const std::string& __s, int i, int& __d) const
00685 {
00686   if(check_index(__s, i))
00687     return retrieve(encode(__s, i), __d);
00688   else
00689   {
00690     return false;
00691   }
00692   return true;
00693 }
00694 
00695 inline bool datamap::retrieve_i(const std::string& __s, int i, int& __d, int __def) const
00696 {
00697   if(check_index(__s, i))
00698     return retrieve(encode(__s, i), __d);
00699   else
00700     __d = __def;
00701   return true;
00702 }
00703 
00704 inline bool datamap::retrieve_i(const std::string& __s, int i, unsigned int& __d) const
00705 {
00706   if(check_index(__s, i))
00707     return retrieve(encode(__s, i), __d);
00708   else
00709   {
00710     return false;
00711   }
00712   return true;
00713 }
00714 
00715 inline bool datamap::retrieve_i(const std::string& __s, int i, unsigned int& __d, unsigned int __def) const
00716 {
00717   if(check_index(__s, i))
00718     return retrieve(encode(__s, i), __d);
00719   else
00720     __d = __def;
00721   return true;
00722 }
00723 
00724 inline bool datamap::retrieve_i(const std::string& __s, int i, double& __d) const
00725 {
00726   if(check_index(__s, i))
00727     return retrieve(encode(__s, i), __d);
00728   else
00729   {
00730     return false;
00731   }
00732   return true;
00733 }
00734 
00735 inline bool datamap::retrieve_i(const std::string& __s, int i, double& __d, double __def) const
00736 {
00737   if(check_index(__s, i))
00738     return retrieve(encode(__s, i), __d);
00739   else
00740     __d = __def;
00741   return true;
00742 }
00743 
00744 inline bool datamap::retrieve_i(const std::string& __s, int i, interval& __b) const
00745 {
00746   if(check_index(__s, i))
00747     return retrieve(encode(__s, i), __b);
00748   else
00749   {
00750     return false;
00751   }
00752   return true;
00753 }
00754 
00755 inline bool datamap::retrieve_i(const std::string& __s, int i, interval& __b, const interval& __def) const
00756 {
00757   if(check_index(__s, i))
00758     return retrieve(encode(__s, i), __b);
00759   else
00760     __b = __def;
00761   return true;
00762 }
00763 
00764 inline bool datamap::retrieve_i(const std::string& __s, int i, std::string& __is) const
00765 {
00766   if(check_index(__s, i))
00767     return retrieve(encode(__s, i), __is);
00768   else
00769   {
00770     return false;
00771   }
00772   return true;
00773 }
00774 
00775 inline bool datamap::retrieve_i(const std::string& __s, int i, std::string& __is, const std::string& __def) const
00776 {
00777   if(check_index(__s, i))
00778     return retrieve(encode(__s, i), __is);
00779   else
00780     __is = __def;
00781   return true;
00782 }
00783 
00784 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<bool>*& __b) const
00785 {
00786   if(check_index(__s, i))
00787     return retrieve(encode(__s, i), __b);
00788   else
00789   {
00790     return false;
00791   }
00792   return true;
00793 }
00794 
00795 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
00796 {
00797   if(check_index(__s, i))
00798     return retrieve(encode(__s, i), __b);
00799   else
00800     __b = __def;
00801   return true;
00802 }
00803 
00804 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<int>*& __b) const
00805 {
00806   if(check_index(__s, i))
00807     return retrieve(encode(__s, i), __b);
00808   else
00809   {
00810     return false;
00811   }
00812   return true;
00813 }
00814 
00815 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<int>*& __b, const std::vector<int>* __def) const
00816 {
00817   if(check_index(__s, i))
00818     return retrieve(encode(__s, i), __b);
00819   else
00820     __b = __def;
00821   return true;
00822 }
00823 
00824 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<unsigned int>*& __b) const
00825 {
00826   if(check_index(__s, i))
00827     return retrieve(encode(__s, i), __b);
00828   else
00829   {
00830     return false;
00831   }
00832   return true;
00833 }
00834 
00835 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
00836 {
00837   if(check_index(__s, i))
00838     return retrieve(encode(__s, i), __b);
00839   else
00840     __b = __def;
00841   return true;
00842 }
00843 
00844 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<double>*& __b) const
00845 {
00846   if(check_index(__s, i))
00847     return retrieve(encode(__s, i), __b);
00848   else
00849   {
00850     return false;
00851   }
00852   return true;
00853 }
00854 
00855 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<double>*& __b, const std::vector<double>* __def) const
00856 {
00857   if(check_index(__s, i))
00858     return retrieve(encode(__s, i), __b);
00859   else
00860     __b = __def;
00861   return true;
00862 }
00863 
00864 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<interval>*& __b) const
00865 {
00866   if(check_index(__s, i))
00867     return retrieve(encode(__s, i), __b);
00868   else
00869   {
00870     return false;
00871   }
00872   return true;
00873 }
00874 
00875 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
00876 {
00877   if(check_index(__s, i))
00878     return retrieve(encode(__s, i), __b);
00879   else
00880     __b = __def;
00881   return true;
00882 }
00883 
00884 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<std::string>*& __b) const
00885 {
00886   if(check_index(__s, i))
00887     return retrieve(encode(__s, i), __b);
00888   else
00889   {
00890     return false;
00891   }
00892   return true;
00893 }
00894 
00895 inline bool datamap::retrieve_i(const std::string& __s, int i, const std::vector<std::string>*& __b, const std::vector<std::string>* __def) const
00896 {
00897   if(check_index(__s, i))
00898     return retrieve(encode(__s, i), __b);
00899   else
00900     __b = __def;
00901   return true;
00902 }
00903 
00904 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<double>*& __b) const
00905 {
00906   if(check_index(__s, i))
00907     return retrieve(encode(__s, i), __b);
00908   else
00909   {
00910     return false;
00911   }
00912   return true;
00913 }
00914 
00915 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<double>*& __b, const linalg::matrix<double>* __def) const
00916 {
00917   if(check_index(__s, i))
00918     return retrieve(encode(__s, i), __b);
00919   else
00920     __b = __def;
00921   return true;
00922 }
00923 
00924 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<int>*& __b) const
00925 {
00926   if(check_index(__s, i))
00927     return retrieve(encode(__s, i), __b);
00928   else
00929   {
00930     return false;
00931   }
00932   return true;
00933 }
00934 
00935 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<int>*& __b, const linalg::matrix<int>* __def) const
00936 {
00937   if(check_index(__s, i))
00938     return retrieve(encode(__s, i), __b);
00939   else
00940     __b = __def;
00941   return true;
00942 }
00943 
00944 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<interval>*& __b) const
00945 {
00946   if(check_index(__s, i))
00947     return retrieve(encode(__s, i), __b);
00948   else
00949   {
00950     return false;
00951   }
00952   return true;
00953 }
00954 
00955 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<interval>*& __b, const linalg::matrix<interval>* __def) const
00956 {
00957   if(check_index(__s, i))
00958     return retrieve(encode(__s, i), __b);
00959   else
00960     __b = __def;
00961   return true;
00962 }
00963 
00964 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<std::string>*& __b) const
00965 {
00966   if(check_index(__s, i))
00967     return retrieve(encode(__s, i), __b);
00968   else
00969   {
00970     return false;
00971   }
00972   return true;
00973 }
00974 
00975 inline bool datamap::retrieve_i(const std::string& __s, int i, const linalg::matrix<std::string>*& __b, const linalg::matrix<std::string>* __def) const
00976 {
00977   if(check_index(__s, i))
00978     return retrieve(encode(__s, i), __b);
00979   else
00980     __b = __def;
00981   return true;
00982 }
00983 
00984 
00985 inline bool datamap::retrieve_i(const char* __s, int i, bool& __b) const
00986 {
00987   return(retrieve_i(std::string(__s), i, __b));
00988 }
00989 
00990 inline bool datamap::retrieve_i(const char* __s, int i, bool& __b, bool __def) const
00991 {
00992   return(retrieve_i(std::string(__s), i, __b, __def));
00993 }
00994 
00995 inline bool datamap::retrieve_i(const char* __s, int i, int& __d) const
00996 {
00997   return(retrieve_i(std::string(__s), i, __d));
00998 }
00999 
01000 inline bool datamap::retrieve_i(const char* __s, int i, int& __d, int __def) const
01001 {
01002   return(retrieve_i(std::string(__s), i, __d, __def));
01003 }
01004 
01005 inline bool datamap::retrieve_i(const char* __s, int i, unsigned int& __d) const
01006 {
01007   return(retrieve_i(std::string(__s), i, __d));
01008 }
01009 
01010 inline bool datamap::retrieve_i(const char* __s, int i, unsigned int& __d, unsigned int __def) const
01011 {
01012   return(retrieve_i(std::string(__s), i, __d, __def));
01013 }
01014 
01015 inline bool datamap::retrieve_i(const char* __s, int i, double& __d) const
01016 {
01017   return(retrieve_i(std::string(__s), i, __d));
01018 }
01019 
01020 inline bool datamap::retrieve_i(const char* __s, int i, double& __d, double __def) const
01021 {
01022   return(retrieve_i(std::string(__s), i, __d, __def));
01023 }
01024 
01025 inline bool datamap::retrieve_i(const char* __s, int i, interval& __b) const
01026 {
01027   return(retrieve_i(std::string(__s), i, __b));
01028 }
01029 
01030 inline bool datamap::retrieve_i(const char* __s, int i, interval& __b, const interval& __def) const
01031 {
01032   return(retrieve_i(std::string(__s), i, __b, __def));
01033 }
01034 
01035 inline bool datamap::retrieve_i(const char* __s, int i, std::string& __is) const
01036 {
01037   return(retrieve_i(std::string(__s), i, __is));
01038 }
01039 
01040 inline bool datamap::retrieve_i(const char* __s, int i, std::string& __b, const std::string& __def) const
01041 {
01042   return(retrieve_i(std::string(__s), i, __b, __def));
01043 }
01044 
01045 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<bool>*& __b) const
01046 {
01047   return(retrieve_i(std::string(__s), i, __b));
01048 }
01049 
01050 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<bool>*& __b, const std::vector<bool>* __def) const
01051 {
01052   return(retrieve_i(std::string(__s), i, __b, __def));
01053 }
01054 
01055 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<int>*& __b) const
01056 {
01057   return(retrieve_i(std::string(__s), i, __b));
01058 }
01059 
01060 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<int>*& __b, const std::vector<int>* __def) const
01061 {
01062   return(retrieve_i(std::string(__s), i, __b, __def));
01063 }
01064 
01065 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<unsigned int>*& __b) const
01066 {
01067   return(retrieve_i(std::string(__s), i, __b));
01068 }
01069 
01070 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<unsigned int>*& __b, const std::vector<unsigned int>* __def) const
01071 {
01072   return(retrieve_i(std::string(__s), i, __b, __def));
01073 }
01074 
01075 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<double>*& __b) const
01076 {
01077   return(retrieve_i(std::string(__s), i, __b));
01078 }
01079 
01080 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<double>*& __b, const std::vector<double>* __def) const
01081 {
01082   return(retrieve_i(std::string(__s), i, __b, __def));
01083 }
01084 
01085 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<interval>*& __b) const
01086 {
01087   return(retrieve_i(std::string(__s), i, __b));
01088 }
01089 
01090 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<interval>*& __b, const std::vector<interval>* __def) const
01091 {
01092   return(retrieve_i(std::string(__s), i, __b, __def));
01093 }
01094 
01095 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<std::string>*& __b) const
01096 {
01097   return(retrieve_i(std::string(__s), i, __b));
01098 }
01099 
01100 inline bool datamap::retrieve_i(const char* __s, int i, const std::vector<std::string>*& __b, const std::vector<std::string>* __def) const
01101 {
01102   return(retrieve_i(std::string(__s), i, __b, __def));
01103 }
01104 
01105 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<double>*& __b) const
01106 {
01107   return(retrieve_i(std::string(__s), i, __b));
01108 }
01109 
01110 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<double>*& __b,
01111       const linalg::matrix<double>* __def) const
01112 {
01113   return(retrieve_i(std::string(__s), i, __b, __def));
01114 }
01115 
01116 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<int>*& __b) const
01117 {
01118   return(retrieve_i(std::string(__s), i, __b));
01119 }
01120 
01121 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<int>*& __b,
01122       const linalg::matrix<int>* __def) const
01123 {
01124   return(retrieve_i(std::string(__s), i, __b, __def));
01125 }
01126 
01127 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<interval>*& __b) const
01128 {
01129   return(retrieve_i(std::string(__s), i, __b));
01130 }
01131 
01132 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<interval>*& __b,
01133       const linalg::matrix<interval>* __def) const
01134 {
01135   return(retrieve_i(std::string(__s), i, __b, __def));
01136 }
01137 
01138 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<std::string>*& __b) const
01139 {
01140   return(retrieve_i(std::string(__s), i, __b));
01141 }
01142 
01143 inline bool datamap::retrieve_i(const char* __s, int i, const linalg::matrix<std::string>*& __b,
01144       const linalg::matrix<std::string>* __def) const
01145 {
01146   return(retrieve_i(std::string(__s), i, __b, __def));
01147 }
01148 
01149 } // namespace coco
01150 
01151 #endif /* __DATAMAP_HPP__ */