~njansson/dolfin/hpc

« back to all changes in this revision

Viewing changes to src/pydolfin/dolfin_wrap.h

  • Committer: Anders Logg
  • Date: 2007-01-10 09:04:44 UTC
  • mfrom: (1689.1.221 trunk)
  • Revision ID: logg@simula.no-20070110090444-ecyux3n1qnei4i8h
RemoveĀ oldĀ head

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
/* ----------------------------------------------------------------------------
2
 
 * This file was automatically generated by SWIG (http://www.swig.org).
3
 
 * Version 1.3.25
4
 
 * 
5
 
 * This file is not intended to be easily readable and contains a number of 
6
 
 * coding conventions designed to improve portability and efficiency. Do not make
7
 
 * changes to this file unless you know what you are doing--modify the SWIG 
8
 
 * interface file instead. 
9
 
 * ----------------------------------------------------------------------------- */
10
 
 
11
 
#ifndef SWIG_dolfin_WRAP_H_
12
 
#define SWIG_dolfin_WRAP_H_
13
 
 
14
 
#include <map>
15
 
#include <string>
16
 
 
17
 
#ifndef SWIG_DIRECTOR_PYTHON_HEADER_
18
 
#define SWIG_DIRECTOR_PYTHON_HEADER_
19
 
/***********************************************************************
20
 
 * director_h.swg
21
 
 *
22
 
 *     This file contains support for director classes that proxy
23
 
 *     method calls from C++ to Python extensions.
24
 
 *
25
 
 * Author : Mark Rose (mrose@stm.lbl.gov)
26
 
 ************************************************************************/
27
 
 
28
 
#ifdef __cplusplus
29
 
 
30
 
#include <string>
31
 
#include <iostream>
32
 
#include <exception>
33
 
 
34
 
 
35
 
/*
36
 
  Use -DSWIG_DIRECTOR_NOUEH if you prefer to avoid the use of the
37
 
  Undefined Exception Handler provided by swift
38
 
*/
39
 
#ifndef SWIG_DIRECTOR_NOUEH
40
 
#ifndef SWIG_DIRECTOR_UEH
41
 
#define SWIG_DIRECTOR_UEH
42
 
#endif
43
 
#endif
44
 
 
45
 
 
46
 
/*
47
 
  Use -DSWIG_DIRECTOR_STATIC if you prefer to avoid the use of the
48
 
  'Swig' namespace. This could be usefull for multi-modules projects.
49
 
*/
50
 
#ifdef SWIG_DIRECTOR_STATIC
51
 
/* Force anonymous (static) namespace */
52
 
#define Swig
53
 
#endif
54
 
 
55
 
 
56
 
/*
57
 
  Use -DSWIG_DIRECTOR_NORTTI if you prefer to avoid the use of the
58
 
  native C++ RTTI and dynamic_cast<>. But be aware that directors
59
 
  could stop working when using this option.
60
 
*/
61
 
#ifdef SWIG_DIRECTOR_NORTTI
62
 
/* 
63
 
   When we don't use the native C++ RTTI, we implement a minimal one
64
 
   only for Directors.
65
 
*/
66
 
# ifndef SWIG_DIRECTOR_RTDIR
67
 
# define SWIG_DIRECTOR_RTDIR
68
 
#include <map>
69
 
namespace Swig {
70
 
  class Director;
71
 
  SWIGINTERN std::map<void*,Director*>& get_rtdir_map() {
72
 
    static std::map<void*,Director*> rtdir_map;
73
 
    return rtdir_map;
74
 
  }
75
 
 
76
 
  SWIGINTERNINLINE void set_rtdir(void *vptr, Director *rtdir) {
77
 
    get_rtdir_map()[vptr] = rtdir;
78
 
  }
79
 
 
80
 
  SWIGINTERNINLINE Director *get_rtdir(void *vptr) {
81
 
    std::map<void*,Director*>::const_iterator pos = get_rtdir_map().find(vptr);
82
 
    Director *rtdir = (pos != get_rtdir_map().end()) ? pos->second : 0;
83
 
    return rtdir;
84
 
  }
85
 
}
86
 
# endif /* SWIG_DIRECTOR_RTDIR */
87
 
 
88
 
# define SWIG_DIRECTOR_CAST(Arg) Swig::get_rtdir(static_cast<void*>(Arg))
89
 
# define SWIG_DIRECTOR_RGTR(Arg1, Arg2) Swig::set_rtdir(static_cast<void*>(Arg1), Arg2)
90
 
 
91
 
#else
92
 
 
93
 
# define SWIG_DIRECTOR_CAST(Arg) dynamic_cast<Swig::Director*>(Arg)
94
 
# define SWIG_DIRECTOR_RGTR(Arg1, Arg2)
95
 
 
96
 
#endif /* SWIG_DIRECTOR_NORTTI */
97
 
 
98
 
extern "C" {
99
 
  struct swig_type_info;
100
 
}
101
 
 
102
 
namespace Swig {  
103
 
 
104
 
  /* base class for director exceptions */
105
 
  class DirectorException {
106
 
  protected:
107
 
    std::string swig_msg;
108
 
  public:
109
 
    DirectorException(const char* hdr ="", const char* msg ="") 
110
 
    : swig_msg(hdr) {
111
 
      swig_msg += msg;
112
 
      if (!PyErr_Occurred()) {
113
 
        PyErr_SetString(PyExc_TypeError, getMessage());
114
 
      } else {
115
 
        SWIG_Python_AddErrMesg(getMessage(), 1);
116
 
      }
117
 
    }
118
 
 
119
 
    const char *getMessage() const { 
120
 
      return swig_msg.c_str(); 
121
 
    }
122
 
 
123
 
    static void raise(const char* msg = "") 
124
 
    {
125
 
      throw DirectorException(msg);
126
 
    }
127
 
  };
128
 
 
129
 
  class UnknownExceptionHandler 
130
 
  {
131
 
    static void handler();
132
 
    
133
 
  public:
134
 
    
135
 
#ifdef SWIG_DIRECTOR_UEH
136
 
    std::unexpected_handler old;
137
 
    UnknownExceptionHandler(std::unexpected_handler nh = handler)
138
 
    {
139
 
      old = std::set_unexpected(nh);
140
 
    }
141
 
 
142
 
    ~UnknownExceptionHandler()
143
 
    {
144
 
      std::set_unexpected(old);
145
 
    }
146
 
#endif
147
 
  };
148
 
 
149
 
  /* type mismatch in the return value from a python method call */
150
 
  class DirectorTypeMismatchException : public Swig::DirectorException {
151
 
  public:
152
 
    DirectorTypeMismatchException(const char* msg="") 
153
 
      : Swig::DirectorException("Swig director type mismatch: ", msg) {
154
 
    }
155
 
 
156
 
    static void raise(const char* msg = "") 
157
 
    {
158
 
      throw DirectorTypeMismatchException(msg);
159
 
    }
160
 
  };
161
 
 
162
 
  /* any python exception that occurs during a director method call */
163
 
  class DirectorMethodException : public Swig::DirectorException {
164
 
  public:
165
 
    DirectorMethodException(const char* msg = "") 
166
 
      : DirectorException("Swig director python method error: ", msg)
167
 
    {
168
 
    }    
169
 
 
170
 
    static void raise(const char* msg = "") 
171
 
    {
172
 
      throw DirectorMethodException(msg);
173
 
    }
174
 
  };
175
 
 
176
 
  /* attempt to call a pure virtual method via a director method */
177
 
  class DirectorPureVirtualException : public Swig::DirectorException
178
 
  {
179
 
  public:
180
 
    DirectorPureVirtualException(const char* msg = "") 
181
 
      : DirectorException("Swig director pure virtal method called: ", msg)
182
 
    { 
183
 
    }
184
 
 
185
 
    static void raise(const char* msg = "") 
186
 
    {
187
 
      throw DirectorPureVirtualException(msg);
188
 
    }
189
 
  };
190
 
 
191
 
 
192
 
  /* simple thread abstraction for pthreads on win32 */
193
 
#ifdef __THREAD__
194
 
#define __PTHREAD__
195
 
#if defined(_WIN32) || defined(__WIN32__)
196
 
#define pthread_mutex_lock EnterCriticalSection
197
 
#define pthread_mutex_unlock LeaveCriticalSection
198
 
#define pthread_mutex_t CRITICAL_SECTION
199
 
#define MUTEX_INIT(var) CRITICAL_SECTION var
200
 
#else
201
 
#include <pthread.h>
202
 
#define MUTEX_INIT(var) pthread_mutex_t var = PTHREAD_MUTEX_INITIALIZER 
203
 
#endif
204
 
#endif
205
 
 
206
 
 
207
 
  /* director base class */
208
 
  class Director {
209
 
  private:
210
 
    /* pointer to the wrapped python object */
211
 
    PyObject* swig_self;
212
 
    /* flag indicating whether the object is owned by python or c++ */
213
 
    mutable bool swig_disown_flag;
214
 
    /* shared flag for breaking recursive director calls */
215
 
    static bool swig_up;
216
 
 
217
 
#ifdef __PTHREAD__
218
 
    /* locks for sharing the swig_up flag in a threaded environment */
219
 
    static pthread_mutex_t swig_mutex_up;
220
 
    static bool swig_mutex_active;
221
 
    static pthread_t swig_mutex_thread;
222
 
#endif
223
 
 
224
 
    /* decrement the reference count of the wrapped python object */
225
 
    void swig_decref() const { 
226
 
      if (swig_disown_flag) {
227
 
        Py_DECREF(swig_self); 
228
 
      }
229
 
    }
230
 
 
231
 
    /* reset the swig_up flag once the routing direction has been determined */
232
 
#ifdef __PTHREAD__
233
 
    void swig_clear_up() const { 
234
 
      Swig::Director::swig_up = false; 
235
 
      Swig::Director::swig_mutex_active = false;
236
 
      pthread_mutex_unlock(&swig_mutex_up);
237
 
    }
238
 
#else
239
 
    void swig_clear_up() const { 
240
 
      Swig::Director::swig_up = false; 
241
 
    }
242
 
#endif
243
 
 
244
 
  public:
245
 
    /* wrap a python object, optionally taking ownership */
246
 
    Director(PyObject* self) : swig_self(self), swig_disown_flag(false) {
247
 
      swig_incref();
248
 
    }
249
 
 
250
 
    /* discard our reference at destruction */
251
 
    virtual ~Director();
252
 
 
253
 
    /* return a pointer to the wrapped python object */
254
 
    PyObject *swig_get_self() const { 
255
 
      return swig_self; 
256
 
    }
257
 
 
258
 
    /* get the swig_up flag to determine if the method call should be routed
259
 
     * to the c++ base class or through the wrapped python object
260
 
     */
261
 
#ifdef __PTHREAD__
262
 
    bool swig_get_up() const { 
263
 
      if (Swig::Director::swig_mutex_active) {
264
 
        if (pthread_equal(Swig::Director::swig_mutex_thread, pthread_self())) {
265
 
          bool up = swig_up;
266
 
          swig_clear_up();
267
 
          return up;
268
 
        }
269
 
      }
270
 
      return 0;
271
 
    }
272
 
#else 
273
 
    bool swig_get_up() const { 
274
 
      bool up = swig_up;
275
 
      swig_up = false;
276
 
      return up;
277
 
    }
278
 
#endif
279
 
 
280
 
    /* set the swig_up flag if the next method call should be directed to
281
 
     * the c++ base class rather than the wrapped python object
282
 
     */
283
 
#ifdef __PTHREAD__
284
 
    void swig_set_up() const { 
285
 
      pthread_mutex_lock(&Swig::Director::swig_mutex_up);
286
 
      Swig::Director::swig_mutex_thread = pthread_self();
287
 
      Swig::Director::swig_mutex_active = true;
288
 
      Swig::Director::swig_up = true; 
289
 
    }
290
 
#else 
291
 
    void swig_set_up() const { 
292
 
      Swig::Director::swig_up = true; 
293
 
    }
294
 
#endif
295
 
 
296
 
    /* acquire ownership of the wrapped python object (the sense of "disown"
297
 
     * is from python) */
298
 
    void swig_disown() const { 
299
 
      if (!swig_disown_flag) { 
300
 
        swig_disown_flag=true;
301
 
        swig_incref(); 
302
 
      } 
303
 
    }
304
 
 
305
 
    /* increase the reference count of the wrapped python object */
306
 
    void swig_incref() const { 
307
 
      if (swig_disown_flag) {
308
 
        Py_INCREF(swig_self); 
309
 
      }
310
 
    }
311
 
 
312
 
    /* methods to implement pseudo protected director members */
313
 
    virtual bool swig_get_inner(const char* /* name */) const {
314
 
      return true;
315
 
    }
316
 
    
317
 
    virtual void swig_set_inner(const char* /* name */, bool /* val */) const {
318
 
    }
319
 
  };
320
 
 
321
 
}
322
 
 
323
 
#endif /* __cplusplus */
324
 
 
325
 
 
326
 
#endif
327
 
 
328
 
class SwigDirector_Function : public dolfin::Function, public Swig::Director {
329
 
 
330
 
public:
331
 
    SwigDirector_Function(PyObject *self, dolfin::real value);
332
 
    SwigDirector_Function(PyObject *self, dolfin::uint vectordim = 1);
333
 
    SwigDirector_Function(PyObject *self, FunctionPointer fp, dolfin::uint vectordim = 1);
334
 
    SwigDirector_Function(PyObject *self, dolfin::Vector &x);
335
 
    SwigDirector_Function(PyObject *self, dolfin::Vector &x, dolfin::Mesh &mesh);
336
 
    SwigDirector_Function(PyObject *self, dolfin::Vector &x, dolfin::Mesh &mesh, dolfin::FiniteElement &element);
337
 
    SwigDirector_Function(PyObject *self, dolfin::Mesh &mesh, dolfin::FiniteElement &element);
338
 
    SwigDirector_Function(PyObject *self, dolfin::Function const &f);
339
 
    virtual dolfin::real eval(dolfin::Point const &p, dolfin::uint i = 0);
340
 
    virtual ~SwigDirector_Function();
341
 
 
342
 
 
343
 
/* Internal Director utilities */
344
 
public:
345
 
    bool swig_get_inner(const char* name) const {
346
 
      std::map<std::string, bool>::const_iterator iv = inner.find(name);
347
 
      return (iv != inner.end() ? iv->second : false);
348
 
    }
349
 
 
350
 
    void swig_set_inner(const char* name, bool val) const
351
 
    { inner[name] = val;}
352
 
 
353
 
private:
354
 
    mutable std::map<std::string, bool> inner;
355
 
};
356
 
 
357
 
 
358
 
class SwigDirector_BoundaryCondition : public dolfin::BoundaryCondition, public Swig::Director {
359
 
 
360
 
public:
361
 
    SwigDirector_BoundaryCondition(PyObject *self);
362
 
    virtual ~SwigDirector_BoundaryCondition();
363
 
    virtual void eval(dolfin::BoundaryValue &value, dolfin::Point const &p, dolfin::uint i);
364
 
 
365
 
 
366
 
/* Internal Director utilities */
367
 
public:
368
 
    bool swig_get_inner(const char* name) const {
369
 
      std::map<std::string, bool>::const_iterator iv = inner.find(name);
370
 
      return (iv != inner.end() ? iv->second : false);
371
 
    }
372
 
 
373
 
    void swig_set_inner(const char* name, bool val) const
374
 
    { inner[name] = val;}
375
 
 
376
 
private:
377
 
    mutable std::map<std::string, bool> inner;
378
 
};
379
 
 
380
 
 
381
 
class SwigDirector_ODE : public dolfin::ODE, public Swig::Director {
382
 
 
383
 
public:
384
 
    SwigDirector_ODE(PyObject *self, dolfin::uint N, dolfin::real T);
385
 
    virtual dolfin::real u0(dolfin::uint i);
386
 
    virtual dolfin::real f(dolfin::real const u[], dolfin::real t, dolfin::uint i);
387
 
    virtual void save(dolfin::Sample &sample);
388
 
    virtual ~SwigDirector_ODE();
389
 
    virtual void f(dolfin::real const u[], dolfin::real t, dolfin::real y[]);
390
 
    virtual dolfin::real dfdu(dolfin::real const u[], dolfin::real t, dolfin::uint i, dolfin::uint j);
391
 
    virtual dolfin::real timestep(dolfin::real t, dolfin::real k0) const;
392
 
    virtual dolfin::real timestep(dolfin::real t, dolfin::uint i, dolfin::real k0) const;
393
 
    virtual void M(dolfin::real const x[], dolfin::real y[], dolfin::real const u[], dolfin::real t);
394
 
    virtual void J(dolfin::real const x[], dolfin::real y[], dolfin::real const u[], dolfin::real t);
395
 
    virtual bool update(dolfin::real const u[], dolfin::real t, bool end);
396
 
 
397
 
 
398
 
/* Internal Director utilities */
399
 
public:
400
 
    bool swig_get_inner(const char* name) const {
401
 
      std::map<std::string, bool>::const_iterator iv = inner.find(name);
402
 
      return (iv != inner.end() ? iv->second : false);
403
 
    }
404
 
 
405
 
    void swig_set_inner(const char* name, bool val) const
406
 
    { inner[name] = val;}
407
 
 
408
 
private:
409
 
    mutable std::map<std::string, bool> inner;
410
 
};
411
 
 
412
 
 
413
 
#endif