Rheolef  7.1
an efficient C++ finite element environment
iorheobase.h
Go to the documentation of this file.
1 # ifndef _IORHEOBASE_H
2 # define _IORHEOBASE_H
23 
24 #include "rheolef/compiler.h"
25 namespace rheolef {
26 
27 // --------------------------------------------------------------
28 // header macro definitions, for code reduction purpose
29 // --------------------------------------------------------------
30 
31 #define iorheobase_def_boolean_accessor_macro(ioclass,stream,name) \
32  static bool get##name (stream& s) \
33  { \
34  return ioclass::flags(s) [name]; \
35  }
36 #define iorheobase_manip_boolean_accessor_macro(ioclass,stream,name) \
37  inline stream& name (stream& s) \
38  { \
39  ioclass::setf (s, ioclass::name); \
40  return s; \
41  } \
42  inline stream& no##name (stream& s) \
43  { \
44  ioclass::unsetf (s, ioclass::name); \
45  return s; \
46  }
47  // ------------------------------------------------------
48 #define iorheobase_def_member_macro(ioclass,stream,name,groupe) \
49  iorheobase_def_boolean_accessor_macro(ioclass,stream,name)
50 
51 #define iorheobase_manip_member_macro(ioclass,stream,name,groupe) \
52  inline stream& name (stream& s) \
53  { \
54  ioclass::setf(s, ioclass::name, ioclass::groupe##_field); \
55  return s; \
56  }
57  // ------------------------------------------------------
58 #define iorheobase_def_scalar_macro(ioclass,t, a) \
59  protected: \
60  t a ## _; \
61  const t& a () const; \
62  void a (const t& x); \
63  public: \
64  static const t& get##a (std::ios& s); \
65  static std::ios& set##a (std::ios& s, const t& x);
66 
67 #define iorheobase_manip_scalar_macro(ioclass,t, a, io) \
68  inline io##rheomanip1<t> set##a (const t& x) \
69  { \
70  return io##rheomanip1<t>(&(ioclass::set##a), x); \
71  }
72 
73 // --------------------------------------------------------------
74 // body macro definitions, for code reduction purpose
75 // --------------------------------------------------------------
76 # define iorheobase_io_scalar_body_macro(ioclass,t,a) \
77 const t& \
78 ioclass::a () const \
79 { \
80  return a##_; \
81 } \
82 void \
83 ioclass::a (const t& x) \
84 { \
85  a##_ = x; \
86 } \
87 const t& \
88 ioclass::get##a (std::ios& s) \
89 { \
90  return (ioclass::get_pointer(s) -> a()); \
91 } \
92 std::ios& \
93 ioclass::set##a (std::ios& s, const t& x) \
94 { \
95  (ioclass::get_pointer(s) -> a(x)); \
96  return s; \
97 }
98 // --------------------------------------------------------------
99 // io manipulators
100 // --------------------------------------------------------------
101 template <class T>
102 class irheomanip1 {
103  protected:
104  std::ios& (*f) (std::ios&, const T&);
105  T i;
106  public:
107  irheomanip1 (std::ios& (*ff)(std::ios&, const T&), const T& ii)
108  : f(ff), i(ii) {}
109  friend std::istream& operator >> (std::istream& is, const irheomanip1& m)
110  { m.f (is, m.i); return is; }
111 };
112 template <class T>
113 class orheomanip1 {
114  protected:
115  std::ios& (*f) (std::ios&, const T&);
116  T i;
117  public:
118  orheomanip1 (std::ios& (*ff)(std::ios&, const T&), const T& ii)
119  : f(ff), i(ii) {}
120  friend std::ostream& operator << (std::ostream& os, const orheomanip1& m)
121  { m.f (os, m.i); return os; }
122 };
123 template <class T>
125  protected:
126  std::ios& (*f) (std::ios&, const T&);
127  T i;
128  public:
129  iorheomanip1 (std::ios& (*ff)(std::ios&, const T&), const T& ii)
130  : f(ff), i(ii) {}
131  friend std::istream& operator >> (std::istream& is, const iorheomanip1& m)
132  { m.f (is, m.i); return is; }
133  friend std::ostream& operator << (std::ostream& os, const iorheomanip1& m)
134  { m.f (os, m.i); return os; }
135 };
136 // ---------------------------------------------------------------------
137 // iofem trivial memory handler
138 // TODO: a global destructor that delete the list
139 // when global cstor/dstor works...
140 // ---------------------------------------------------------------------
141 
142 
143 template <class T>
145 public:
146  static std::list<T*> *pointer_list;
147  static inline T* iorheobase_alloc () {
148  static bool init = false;
149  if (!init) {
150  pointer_list = new_macro(std::list<T*>);
151  init = true;
152  }
153  T *p = new_macro(T);
154  (*pointer_list).push_back(p);
155  return p;
156  }
157  //
158  // io-manips / memory interface
159  //
160  static inline T* get_pointer (std::ios& io) {
161  static int iobaseidx = 0;
162  static bool iobaseidx_initialized = false;
163  if (!iobaseidx_initialized) {
164  iobaseidx = std::ios::xalloc();
165  iobaseidx_initialized = true;
166  }
167  T* p = (T*)io.pword(iobaseidx);
168 
169 #ifdef _RHEOLEF_HAVE_IOS_BITALLOC
170  // io.pword(iobaseidx) n'est pas forcement nul la premiere fois
171  // e.g. CRAY C++ ne l'initialise pas
172  // => peut valoir une valeur arbitraire...
173  // pas moyen de savoir quand il faut l'initialiser
174  // std::ios::bitalloc: un bit va permettre de dire
175  // si on a deja initialise'
176  // bitalloc = pas standard (e.g. pas avec KAI C++)
177  // mais permet de contourner le bug du
178  // compilateur cray c++
179  // le script configure teste si bitalloc() existe
180  static long iobase_bitidx;
181  static bool iobase_bitidx_initialized = false;
182  long bit;
183  if (!iobase_bitidx_initialized) {
184  iobase_bitidx = std::ios::bitalloc();
185  iobase_bitidx_initialized = true;
186  }
187  long bit_init;
188  if (iobase_bitidx == 0) {
189  // no bits are still available in std::ios...
190  bit_init = (p != 0);
191  } else {
192  // get iobase_bitidx flag in io.flags:
193  long io_flags = io.flags();
194  bit_init = io_flags & iobase_bitidx;
195  // set iobase_bitidx flag to true in io.flags:
196  io.flags(io_flags | iobase_bitidx);
197  }
198 #else // ! _RHEOLEF_HAVE_IOS_BITALLOC
199  long bit_init = (p != 0);
200 #endif // _RHEOLEF_HAVE_IOS_BITALLOC
201 
202  if (bit_init == 0) {
203  if (p != 0) {
204  warning_macro ("ios::pwords(int) return value not initialized (fixed)");
205  }
206  io.pword(iobaseidx) = p = iorheobase_alloc();
207  } else {
208  if (p == 0) {
209  fatal_macro ("ios::pwords(int) return null value: memory corrupted");
210  }
211  }
212  return p;
213  }
214 };
215 }// namespace rheolef
216 # endif /* _IORHEOBASE_H */
static T * get_pointer(std::ios &io)
Definition: iorheobase.h:160
static std::list< T * > * pointer_list
Definition: iorheobase.h:146
friend std::ostream & operator<<(std::ostream &os, const iorheomanip1 &m)
Definition: iorheobase.h:133
friend std::istream & operator>>(std::istream &is, const iorheomanip1 &m)
Definition: iorheobase.h:131
iorheomanip1(std::ios &(*ff)(std::ios &, const T &), const T &ii)
Definition: iorheobase.h:129
friend std::istream & operator>>(std::istream &is, const irheomanip1 &m)
Definition: iorheobase.h:109
irheomanip1(std::ios &(*ff)(std::ios &, const T &), const T &ii)
Definition: iorheobase.h:107
friend std::ostream & operator<<(std::ostream &os, const orheomanip1 &m)
Definition: iorheobase.h:120
orheomanip1(std::ios &(*ff)(std::ios &, const T &), const T &ii)
Definition: iorheobase.h:118
Expr1::float_type T
Definition: field_expr.h:261
This file is part of Rheolef.
Definition: cavity_dg.h:29
Definition: sphere.icc:25