src/libengrid/containertricks.h

   1 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
   2 // +                                                                      +
   3 // + This file is part of enGrid.                                         +
   4 // +                                                                      +
   5 // + Copyright 2008-2014 enGits GmbH                                      +
   6 // +                                                                      +
   7 // + enGrid is free software: you can redistribute it and/or modify       +
   8 // + it under the terms of the GNU General Public License as published by +
   9 // + the Free Software Foundation, either version 3 of the License, or    +
  10 // + (at your option) any later version.                                  +
  11 // +                                                                      +
  12 // + enGrid is distributed in the hope that it will be useful,            +
  13 // + but WITHOUT ANY WARRANTY; without even the implied warranty of       +
  14 // + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        +
  15 // + GNU General Public License for more details.                         +
  16 // +                                                                      +
  17 // + You should have received a copy of the GNU General Public License    +
  18 // + along with enGrid. If not, see <http://www.gnu.org/licenses/>.       +
  19 // +                                                                      +
  20 // ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  21 #ifndef containertricks_h
  22 #define containertricks_h
  23
  24 #include <iostream>
  25 #include <fstream>
  26 #include <string>
  27 #include <vector>
  28 #include <stdarg.h>
  29
  30 // vlinit
  31 // ======
  32
  33 template <class C>
  34 class vlinit_t
  35 {
  36   C *c;
  37
  38 public:
  39   vlinit_t(C &a_c);
  40   vlinit_t(const vlinit_t<C> &ci);
  41   vlinit_t<C> add(typename C::value_type v);
  42   vlinit_t<C> operator=(typename C::value_type v) { return add(v); };
  43   vlinit_t<C> operator,(typename C::value_type v) { return add(v); };
  44 };
  45
  46 template <class C>
  47 inline vlinit_t<C>::vlinit_t(const vlinit_t<C> &ci)
  48 {
  49   c = ci.c;
  50 };
  51
  52 template <class C>
  53 inline vlinit_t<C>::vlinit_t(C &a_c)
  54 {
  55   c = &a_c;
  56 };
  57
  58 template <class C>
  59 inline vlinit_t<C> vlinit_t<C>::add(typename C::value_type v)
  60 {
  61   c->push_back(v);
  62   return *this;
  63 };
  64
  65 template <class C> inline vlinit_t<C> vlinit(C &c) { return vlinit_t<C>(c); };
  66
  67
  68 // clinit
  69 // ======
  70
  71 template <class C>
  72 class clinit_t
  73 {
  74   C *c;
  75   typename C::iterator i;
  76
  77 public:
  78   clinit_t(C &a_c);
  79   clinit_t(const clinit_t<C> &ci);
  80   clinit_t<C> add(typename C::value_type v);
  81   clinit_t<C> operator=(typename C::value_type v) { return add(v); };
  82   clinit_t<C> operator,(typename C::value_type v) { return add(v); };
  83 };
  84
  85 template <class C>
  86 inline clinit_t<C>::clinit_t(const clinit_t<C> &ci)
  87 {
  88   c = ci.c;
  89   i = ci.i;
  90 };
  91
  92 template <class C>
  93 inline clinit_t<C>::clinit_t(C &a_c)
  94 {
  95   c = &a_c;
  96   i = c->begin();
  97 };
  98
  99 template <class C>
 100 inline clinit_t<C> clinit_t<C>::add(typename C::value_type v)
 101 {
 102   if (i == c->end()) {
 103     cerr << "array bounds exceeded" << endl;
 104     exit(EXIT_FAILURE);
 105   };
 106   *i = v;
 107   i++;
 108   return *this;
 109 };
 110
 111 template <class C> inline clinit_t<C> clinit(C &c) { return clinit_t<C>(c); };
 112
 113 template <class C>
 114 inline void clinit(C &c, typename C::value_type v, ...)
 115 {
 116   if (c.size() == 0) return;
 117   typename C::iterator i = c.begin();
 118   *i = v;
 119   ++i;
 120   va_list vl;
 121   va_start(vl,v);
 122   cout << v << ' ';
 123   while ((v = va_arg(vl,typename C::value_type))) {
 124     if (i == c.end()) {
 125       cerr << "array bounds exceeded" << endl;
 126       exit(EXIT_FAILURE);
 127     };
 128     *i = v;
 129     cout << v << ' ';
 130     ++i;
 131   };
 132   cout << endl;
 133 };
 134
 135
 136 // output tools
 137 // ============
 138
 139 template <class C>
 140 inline void simple_print(const C &c, ostream &s)
 141 {
 142   typename C::const_iterator i = c.begin();
 143   s << '[';
 144   while (i != c.end()) {
 145     s << *i;
 146     i++;
 147     if (i != c.end()) s << ", ";
 148   };
 149   s << ']';
 150 };
 151
 152
 153 inline void print_table(vector<vector<double> > f, ostream &s)
 154 {
 155   size_t Nj = f[0].size();
 156   for (size_t j = 0; j < Nj; j++) {
 157     for (size_t i = 0; i < f.size(); i++) {
 158       s.setf(iostream::scientific, iostream::floatfield);
 159       s.precision(4);
 160       s.width(11);
 161       s << f[i][j] << ' ';
 162     };
 163     s << endl;
 164   };
 165 };
 166
 167 inline void print_table(vector<vector<double> > f, string file_name)
 168 {
 169   file_name += ".dat";
 170   ofstream s(file_name.c_str());
 171   print_table(f, s);
 172 };
 173
 174 #endif