← Back to branch summary

~ubuntu-branches/ubuntu/quantal/mysql-workbench/quantal

« back to all changes in this revision

Viewing changes to library/grt/src/grtpp_module_cpp.h

  • Committer: Package Import Robot
  • Author(s): Dmitry Smirnov
  • Date: 2012-03-01 21:57:30 UTC
  • Revision ID: package-import@ubuntu.com-20120301215730-o7y8av8y38n162ro
Tags: upstream-5.2.38+dfsg
Import upstream version 5.2.38+dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
library/grt/src/grtpp_module_cpp.h
 
1
/* 
 
2
 * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
 
3
 *
 
4
 * This program is free software; you can redistribute it and/or
 
5
 * modify it under the terms of the GNU General Public License as
 
6
 * published by the Free Software Foundation; version 2 of the
 
7
 * License.
 
8
 * 
 
9
 * This program is distributed in the hope that it will be useful,
 
10
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
11
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 
12
 * GNU General Public License for more details.
 
13
 * 
 
14
 * You should have received a copy of the GNU General Public License
 
15
 * along with this program; if not, write to the Free Software
 
16
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 
17
 * 02110-1301  USA
 
18
 */
 
19
 
 
20
#ifndef _GRTPP_MODULE_CPP_H_
 
21
#define _GRTPP_MODULE_CPP_H_
 
22
 
 
23
#include "base/trackable.h"
 
24
#include <cstring>
 
25
#include <grtpp.h>
 
26
#include <typeinfo>
 
27
 
 
28
#include <gmodule.h>
 
29
 
 
30
namespace grt {
 
31
 
 
32
//----------------------------------------------------------------------
 
33
// C++ Module Support
 
34
 
 
35
  template<class C> struct traits { typedef C Type; };
 
36
  template<class C> struct traits<const C&> { typedef C Type; };
 
37
  template<class C> struct traits<C&> { typedef C Type; };
 
38
 
 
39
  template<class T> struct grt_content_type { static const Type id= UnknownType; };
 
40
  template<> struct grt_content_type<ListRef<internal::Integer> > { static const Type id= IntegerType; };
 
41
  template<> struct grt_content_type<ListRef<internal::Double> > { static const Type id= DoubleType; };
 
42
  template<> struct grt_content_type<ListRef<internal::String> > { static const Type id= StringType; };
 
43
  template<class T> struct grt_content_type<ListRef<T> > { static const Type id= ObjectType; };
 
44
 
 
45
  template<class T> struct grt_content_class_name { typedef T value; };
 
46
  template<class T> struct grt_content_class_name <Ref<T> > { typedef T value; };
 
47
  template<class T> struct grt_content_class_name <ListRef<T> > { typedef T value; };
 
48
 
 
49
 
 
50
  template<class T> struct grt_type_for_native { typedef T Type; };
 
51
  template<> struct grt_type_for_native<int> { typedef IntegerRef Type; };
 
52
  template<> struct grt_type_for_native<long> { typedef IntegerRef Type; };
 
53
  template<> struct grt_type_for_native<double> { typedef DoubleRef Type; };
 
54
  template<> struct grt_type_for_native<const std::string&> { typedef StringRef Type; };
 
55
  template<> struct grt_type_for_native<std::string> { typedef StringRef Type; };
 
56
 
 
57
 
 
58
  
 
59
  template<class T> struct grt_class_name_if_object
 
60
  {
 
61
    static std::string get() { return T::static_class_name(); }
 
62
  };
 
63
 
 
64
  template<> struct grt_class_name_if_object<IntegerRef>
 
65
  {
 
66
    static std::string get() { return ""; }
 
67
  };
 
68
 
 
69
  template<> struct grt_class_name_if_object<DoubleRef>
 
70
  {
 
71
    static std::string get() { return ""; }
 
72
  };
 
73
 
 
74
  template<> struct grt_class_name_if_object<StringRef>
 
75
  {
 
76
    static std::string get() { return ""; }
 
77
  };
 
78
 
 
79
  template<> struct grt_class_name_if_object<DictRef>
 
80
  {
 
81
    static std::string get() { return ""; }
 
82
  };
 
83
 
 
84
  template<class T> struct grt_class_name_if_object<ListRef<T> >
 
85
  {
 
86
    static std::string get() { return ""; }
 
87
  };
 
88
 
 
89
 
 
90
  
 
91
  template<class T, bool B> struct grt_content_struct_name
 
92
  {
 
93
    static std::string get() { return ""; }
 
94
  };
 
95
 
 
96
  template<class T> struct grt_content_struct_name<T, true>
 
97
  {
 
98
    static std::string get() { return T::static_class_name(); }
 
99
  };
 
100
 
 
101
  template<class T> struct grt_content_struct_name<Ref<T>, true>
 
102
  {
 
103
    static std::string get() { return T::static_class_name(); }
 
104
  };
 
105
 
 
106
  template<class T> struct grt_content_struct_name<ListRef<T>, true>
 
107
  {
 
108
    static std::string get() { return T::static_class_name(); }
 
109
  };
 
110
  
 
111
  // This template checks if B is castable to A
 
112
  // boolean value Is_super_subclass<A, B>::value 
 
113
  // is available during compile time and can be used with other templates
 
114
  template<class A, class B> class Is_super_subclass
 
115
  {
 
116
    static B* makeB();
 
117
    struct CharSized { char c; };
 
118
    struct Char2Sized { char c, d; };
 
119
    static CharSized selector(...);
 
120
    static Char2Sized selector(A*);
 
121
  public:
 
122
 
 
123
    static const bool value = 
 
124
      (sizeof(selector(makeB())) == sizeof(Char2Sized));
 
125
  };
 
126
  
 
127
 
 
128
  // Allows implementation of modules in C++ by subclassing
 
129
 
 
130
  //----------------------------------------------------------------------
 
131
  // Basic definitions for modules and interfaces
 
132
  typedef std::vector<std::string> InterfaceList;
 
133
  class ModuleFunctorBase;
 
134
 
 
135
  // this base class is only used by InterfaceImplBase and ModuleImplBase
 
136
  // all other subclasses only need to inherit from one of these 2
 
137
  class InterfaceData
 
138
  {
 
139
  public:
 
140
    InterfaceList _implemented_interfaces;
 
141
    
 
142
    virtual ~InterfaceData() {};
 
143
  };
 
144
 
 
145
 
 
146
 
 
147
  class InterfaceImplBase : virtual public InterfaceData
 
148
  {
 
149
  public:
 
150
    template<class InterfaceClass> static void Register(GRT *grt)
 
151
    {
 
152
      InterfaceClass::register_interface(grt);
 
153
    }
 
154
    
 
155
    virtual ~InterfaceImplBase() {};
 
156
  };
 
157
 
 
158
 
 
159
 
 
160
 
 
161
  class ModuleFunctorBase;
 
162
  class CPPModuleLoader;
 
163
   
 
164
   
 
165
  class MYSQLGRT_PUBLIC Interface : public Module
 
166
  {
 
167
  public:
 
168
    static Interface *create(GRT *grt, const char *name, ...);
 
169
    
 
170
    bool check_conformance(const Module *module) const;
 
171
     
 
172
  private:
 
173
    Interface(CPPModuleLoader *loader);
 
174
  };
 
175
  
 
176
 
 
177
 
 
178
  class MYSQLGRT_PUBLIC CPPModule : virtual public InterfaceData, public Module, public base::trackable
 
179
  {
 
180
    friend class CPPModuleLoader;
 
181
  public:
 
182
    typedef CPPModuleLoader     Loader;
 
183
    virtual ~CPPModule();
 
184
 
 
185
    virtual std::string get_module_datadir();
 
186
 
 
187
    std::string get_resource_file_path(const std::string &file);
 
188
 
 
189
    void set_name(const std::string &name);
 
190
 
 
191
  protected:
 
192
    CPPModule(CPPModuleLoader *loader);
 
193
    
 
194
    GModule *_gmodule;
 
195
    std::list<ModuleFunctorBase*> _functors;
 
196
 
 
197
    virtual void init_module()= 0;
 
198
    virtual void initialization_done() {};
 
199
 
 
200
    void register_functions(ModuleFunctorBase *first, ...);
 
201
 
 
202
  };
 
203
 
 
204
  typedef CPPModule ModuleImplBase;
 
205
 
 
206
  class MYSQLGRT_PUBLIC CPPModuleLoader : public ModuleLoader
 
207
  {
 
208
  public:
 
209
    CPPModuleLoader(GRT *grt);
 
210
    virtual ~CPPModuleLoader();
 
211
    
 
212
    virtual bool load_library(const std::string &path) { return false; }
 
213
    virtual bool run_script_file(const std::string &path) { return false; }
 
214
    virtual bool run_script(const std::string &script) { return false; }
 
215
    virtual bool check_file_extension(const std::string &path);
 
216
    
 
217
    virtual std::string get_loader_name() { return "cpp"; }
 
218
    
 
219
    virtual Module *init_module(const std::string &path);
 
220
 
 
221
    virtual void refresh();
 
222
  };
 
223
 
 
224
 
 
225
//--------------------------------------------------------------------------------
 
226
// For Modules Implemented in C++
 
227
 
 
228
 
 
229
// this must be in interface classes to enable their registration 
 
230
#define DECLARE_REGISTER_INTERFACE(the_class, ...)\
 
231
  the_class() { std::string name= grt::get_type_name(typeid(*this)); _implemented_interfaces.push_back(name.substr(0, name.length()-4)); /* truncate Impl part*/ }\
 
232
  static void register_interface(grt::GRT *grt) {\
 
233
    std::string name= grt::get_type_name(typeid(the_class));\
 
234
    grt->register_new_interface(grt::Interface::create(grt, name.c_str(), __VA_ARGS__, NULL));\
 
235
  }
 
236
 
 
237
 
 
238
// this must be put in the public section of the modules class
 
239
#define DEFINE_INIT_MODULE(VERSION, AUTHOR, parent_class, first_function, ...)\
 
240
  virtual void init_module()\
 
241
  {\
 
242
    set_name(grt::get_type_name(typeid(*this)));\
 
243
    _meta_version= VERSION; _meta_author= AUTHOR;\
 
244
    _extends= typeid(parent_class) == typeid(grt::CPPModule) ? "" : grt::get_type_name(typeid(parent_class));\
 
245
    if (g_str_has_suffix(_extends.c_str(), "Impl"))\
 
246
      _extends= _extends.substr(0, _extends.length()-4);\
 
247
    register_functions(first_function, __VA_ARGS__, NULL);\
 
248
    initialization_done();\
 
249
  }
 
250
 
 
251
#define DEFINE_INIT_MODULE_DOC(VERSION, AUTHOR, DOC, parent_class, first_function, ...)\
 
252
  virtual void init_module()\
 
253
  {\
 
254
    set_name(grt::get_type_name(typeid(*this)));\
 
255
    _meta_version= VERSION; _meta_author= AUTHOR; _meta_description= DOC;\
 
256
    _extends= typeid(parent_class) == typeid(grt::CPPModule) ? "" : grt::get_type_name(typeid(parent_class));\
 
257
    if (g_str_has_suffix(_extends.c_str(), "Impl"))\
 
258
      _extends= _extends.substr(0, _extends.length()-4);\
 
259
    register_functions(first_function, __VA_ARGS__, NULL);\
 
260
    initialization_done();\
 
261
  }
 
262
 
 
263
 
 
264
 
 
265
template<class T_arg> ArgSpec& get_param_info(const char *argdoc = 0, int i = 0)
 
266
{
 
267
  static ArgSpec p;
 
268
 
 
269
  if (argdoc && *argdoc)
 
270
  {
 
271
    const char *line_end;
 
272
    while ((line_end = strchr(argdoc, '\n')) && i > 0)
 
273
    {
 
274
      argdoc = line_end+1;
 
275
      i--;
 
276
    }
 
277
    
 
278
    if (i == 0)
 
279
    {
 
280
      const char *s = strchr(argdoc, ' ');
 
281
      if (s && (!line_end || s < line_end))
 
282
      {
 
283
        p.name = std::string(argdoc, s-argdoc);
 
284
        p.doc = line_end ? std::string(s+1, line_end-s-1) : std::string(s+1);
 
285
      }
 
286
      else 
 
287
      {
 
288
        p.name = line_end ? std::string(argdoc, line_end-argdoc) : std::string(argdoc);
 
289
        p.doc = "";
 
290
      }
 
291
    }
 
292
    else
 
293
      throw std::logic_error("Module function argument documentation has wrong number of items");
 
294
  }
 
295
  else
 
296
  {
 
297
    p.name = "";
 
298
    p.doc = "";
 
299
  }
 
300
 
 
301
  p.type.base.type= grt_type_for_native<T_arg>::Type::RefType::static_type();
 
302
 
 
303
  if (p.type.base.type == ObjectType)
 
304
  {
 
305
    if (typeid(T_arg) != typeid(internal::Object))
 
306
    {
 
307
      const bool castable_to_object_value= 
 
308
        Is_super_subclass<internal::Object, typename grt_content_class_name<T_arg>::value>::value;
 
309
      p.type.base.object_class=
 
310
        grt_content_struct_name<typename grt_content_class_name<T_arg>::value, castable_to_object_value>::get();
 
311
    }
 
312
  } 
 
313
  else if (p.type.base.type == ListType)
 
314
  {
 
315
    p.type.content.type= grt_content_type<T_arg>::id;
 
316
    if (p.type.content.type == ObjectType)
 
317
    {
 
318
      const bool castable_to_object_value= 
 
319
        Is_super_subclass<internal::Object, typename grt_content_class_name<T_arg>::value>::value;
 
320
      p.type.content.object_class=
 
321
        grt_content_struct_name<typename grt_content_class_name<T_arg>::value, castable_to_object_value>::get();
 
322
    }
 
323
  }
 
324
  else if (p.type.base.type == DictType)
 
325
  {
 
326
    p.type.content.type= AnyType;
 
327
  }
 
328
 
 
329
  return p;
 
330
}
 
331
 
 
332
 
 
333
class ModuleFunctorBase
 
334
{
 
335
protected:
 
336
  TypeSpec _return_type;
 
337
 
 
338
public:
 
339
  typedef std::vector<ArgSpec> Function_param_list;
 
340
 
 
341
protected:
 
342
  const char* _name;
 
343
  const char* _doc;
 
344
  const char* _argdoc;
 
345
  Function_param_list _signature;
 
346
 
 
347
public:
 
348
  explicit ModuleFunctorBase(const char *name, const char *doc= "", const char *argdoc= "") 
 
349
  : _doc(doc ? doc : ""), _argdoc(argdoc ? argdoc : "")
 
350
  {
 
351
    const char *c= strrchr(name, ':');
 
352
    if (c == NULL)
 
353
      c= name;
 
354
    else
 
355
      c++;
 
356
    _name = c;
 
357
  }
 
358
 
 
359
  const char* get_name() const { return _name; }
 
360
  const char* get_doc() const { return _doc; }
 
361
  const Function_param_list& get_signature() const { return _signature; }
 
362
  const TypeSpec& get_return_type() const { return _return_type; }
 
363
 
 
364
  virtual ValueRef perform_call(const BaseListRef &arglist)= 0;
 
365
 
 
366
  /*QQQ
 
367
  MYX_GRT_ERROR call(const BaseListRef &arglist, ValueRef &result)
 
368
  {
 
369
    try
 
370
    {
 
371
      result= perform_call(arglist);
 
372
      //if (result_value) // NULL return values are valid --alfredo
 
373
      //{
 
374
        *result= myx_grt_dict_new(NULL);
 
375
        myx_grt_dict_item_set_value(*result, "value", result_value);
 
376
        if (result_value)
 
377
          myx_grt_value_release(result_value);
 
378
      //}
 
379
      return error;
 
380
    }
 
381
    catch (const grt_runtime_error &exc)
 
382
    {
 
383
      *result= make_error(NULL, exc.what(), exc.detail());
 
384
    }
 
385
    catch (const std::exception &exc)
 
386
    {
 
387
      *result= make_error(NULL, exc.what(), "");
 
388
    } 
 
389
    catch (...) 
 
390
    { 
 
391
      *result= make_error(NULL, "exception during function execution", "");
 
392
    }
 
393
    return MYX_GRT_FUNCTION_CALL_ERROR;
 
394
  }*/
 
395
};
 
396
 
 
397
/**
 
398
  grt_value_for_type is needed to ensure that the type we get
 
399
  (on it's output) is of a subclass of GenereicValue i.e.
 
400
  is a wrapped class
 
401
*/
 
402
 
 
403
template<class T> ValueRef grt_value_for_type(const T& t)
 
404
{
 
405
  return t;
 
406
}
 
407
  
 
408
inline ValueRef grt_value_for_type(bool t)
 
409
{
 
410
  return IntegerRef(t);
 
411
}
 
412
 
 
413
inline ValueRef grt_value_for_type(int t)
 
414
{
 
415
  return IntegerRef(t);
 
416
}
 
417
  
 
418
inline ValueRef grt_value_for_type(long t)
 
419
{
 
420
  return IntegerRef(t);
 
421
}
 
422
 
 
423
inline ValueRef grt_value_for_type(double t)
 
424
{
 
425
  return DoubleRef(t);
 
426
}
 
427
 
 
428
inline ValueRef grt_value_for_type(const std::string& t)
 
429
{
 
430
  return StringRef(t);
 
431
}
 
432
 
 
433
/**
 
434
  native_value_for_grt_type converts a value of ValueRef type to type T.
 
435
  T can be either a subclass of ValueRef or a simple type for with
 
436
  specialization Value<T> is available
 
437
*/
 
438
 
 
439
template<typename T> struct native_value_for_grt_type
 
440
{
 
441
  static T convert(const ValueRef& t)
 
442
  {
 
443
    return T::cast_from(t);
 
444
  }
 
445
};
 
446
 
 
447
template<> 
 
448
struct native_value_for_grt_type<IntegerRef>
 
449
{
 
450
  static long convert(const ValueRef& t)
 
451
  {
 
452
    return IntegerRef::cast_from(t).operator long();
 
453
  }
 
454
};
 
455
 
 
456
template<> 
 
457
struct native_value_for_grt_type<long>
 
458
{
 
459
  static long convert(const ValueRef& t)
 
460
  {
 
461
    return IntegerRef::cast_from(t).operator long();
 
462
  }
 
463
};
 
464
 
 
465
template<> 
 
466
struct native_value_for_grt_type<int>
 
467
{
 
468
  static int convert(const ValueRef& t)
 
469
  {
 
470
    return (int)IntegerRef::cast_from(t).operator long();
 
471
  }
 
472
};
 
473
  
 
474
template<> 
 
475
struct native_value_for_grt_type<bool>
 
476
{
 
477
  static bool convert(const ValueRef& t)
 
478
  {
 
479
    return IntegerRef::cast_from(t).operator long() != 0;
 
480
  }
 
481
};
 
482
 
 
483
template<> 
 
484
struct native_value_for_grt_type<DoubleRef>
 
485
{
 
486
  static double convert(const ValueRef& t)
 
487
  {
 
488
    return DoubleRef::cast_from(t).operator double();
 
489
  }
 
490
};
 
491
 
 
492
template<> 
 
493
struct native_value_for_grt_type<double>
 
494
{
 
495
  static double convert(const ValueRef& t)
 
496
  {
 
497
    return DoubleRef::cast_from(t).operator double();
 
498
  }
 
499
};
 
500
 
 
501
template<> 
 
502
struct native_value_for_grt_type<StringRef>
 
503
{
 
504
  static std::string convert(const ValueRef& t)
 
505
  {
 
506
    if (t.is_valid())
 
507
      return StringRef::cast_from(t).operator std::string();
 
508
    throw std::invalid_argument("invalid null argument");
 
509
    return "";
 
510
  }
 
511
};
 
512
 
 
513
template<> 
 
514
struct native_value_for_grt_type<std::string>
 
515
{
 
516
  static std::string convert(const ValueRef& t)
 
517
  {
 
518
    if (t.is_valid())
 
519
      return StringRef::cast_from(t).operator std::string();
 
520
    throw std::invalid_argument("invalid null argument");
 
521
    return "";
 
522
  }
 
523
};
 
524
 
 
525
template<class T_ret, class T_obj>
 
526
class ModuleFunctor0 : public ModuleFunctorBase
 
527
{
 
528
  typedef T_ret (T_obj::*function_type)();
 
529
  function_type _funcptr;
 
530
  T_obj *_obj;
 
531
 
 
532
protected:
 
533
 
 
534
  virtual ValueRef perform_call(const BaseListRef &arglist)
 
535
  {
 
536
    return grt_value_for_type((_obj->*_funcptr)());
 
537
  }
 
538
 
 
539
public:
 
540
 
 
541
  ModuleFunctor0(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
542
    : ModuleFunctorBase(name, doc, argdoc), _funcptr(func), _obj(obj)
 
543
  {
 
544
    _return_type= get_param_info<T_ret>().type;
 
545
  }
 
546
};
 
547
 
 
548
template<class T_ret, class T_obj, class T_arg1>
 
549
class ModuleFunctor1 : public ModuleFunctorBase
 
550
{
 
551
  typedef T_ret (T_obj::*function_type)(T_arg1);
 
552
  function_type _funcptr;
 
553
  T_obj *_obj;
 
554
 
 
555
protected:
 
556
 
 
557
  virtual ValueRef perform_call(const BaseListRef &args)
 
558
  {
 
559
//    BaseListRef args(arglist);
 
560
    T_arg1 arg1= native_value_for_grt_type<typename traits<T_arg1>::Type>::convert(args[0]);
 
561
    return grt_value_for_type((_obj->*_funcptr)(arg1));
 
562
  }
 
563
 
 
564
public:
 
565
  ModuleFunctor1(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
566
    : ModuleFunctorBase(name, doc, argdoc), _funcptr(func), _obj(obj)
 
567
  {
 
568
    _signature.push_back(get_param_info<typename traits<T_arg1>::Type>(argdoc, 0));
 
569
    _return_type= get_param_info<typename traits<T_ret>::Type>().type;
 
570
  }
 
571
};
 
572
 
 
573
template<class T_ret, class T_obj, class T_arg1, class T_arg2>
 
574
class ModuleFunctor2 : public ModuleFunctorBase
 
575
{
 
576
  typedef T_ret (T_obj::*function_type)(T_arg1, T_arg2);
 
577
  function_type _funcptr;
 
578
  T_obj *_obj;
 
579
 
 
580
protected:
 
581
 
 
582
  virtual ValueRef perform_call(const BaseListRef &args)
 
583
  {
 
584
//    BaseListRef args(arglist);
 
585
    T_arg1 arg1= native_value_for_grt_type<typename traits<T_arg1>::Type>::convert(args[0]);
 
586
    T_arg2 arg2= native_value_for_grt_type<typename traits<T_arg2>::Type>::convert(args[1]);
 
587
    return grt_value_for_type((_obj->*_funcptr)(arg1, arg2));
 
588
  }
 
589
 
 
590
public:
 
591
  ModuleFunctor2(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
592
    : ModuleFunctorBase(name, doc), _funcptr(func), _obj(obj)
 
593
  {
 
594
    _signature.push_back(get_param_info<typename traits<T_arg1>::Type>(argdoc, 0));
 
595
    _signature.push_back(get_param_info<typename traits<T_arg2>::Type>(argdoc, 1));
 
596
    _return_type= get_param_info<typename traits<T_ret>::Type>().type;
 
597
  }
 
598
};
 
599
 
 
600
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3>
 
601
class ModuleFunctor3 : public ModuleFunctorBase
 
602
{
 
603
  typedef T_ret (T_obj::*function_type)(T_arg1, T_arg2, T_arg3);
 
604
  function_type _funcptr;
 
605
  T_obj *_obj;
 
606
 
 
607
protected:
 
608
 
 
609
  virtual ValueRef perform_call(const BaseListRef &args)
 
610
  {
 
611
//    BaseListRef args(arglist);
 
612
    T_arg1 arg1= native_value_for_grt_type<typename traits<T_arg1>::Type>::convert(args[0]);
 
613
    T_arg2 arg2= native_value_for_grt_type<typename traits<T_arg2>::Type>::convert(args[1]);
 
614
    T_arg3 arg3= native_value_for_grt_type<typename traits<T_arg3>::Type>::convert(args[2]);
 
615
    return grt_value_for_type((_obj->*_funcptr)(arg1, arg2, arg3));
 
616
  }
 
617
 
 
618
public:
 
619
  ModuleFunctor3(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
620
    : ModuleFunctorBase(name, doc, argdoc), _funcptr(func), _obj(obj)
 
621
  {
 
622
    _signature.push_back(get_param_info<typename traits<T_arg1>::Type>(argdoc, 0));
 
623
    _signature.push_back(get_param_info<typename traits<T_arg2>::Type>(argdoc, 1));
 
624
    _signature.push_back(get_param_info<typename traits<T_arg3>::Type>(argdoc, 2));
 
625
    _return_type= get_param_info<typename traits<T_ret>::Type>().type;
 
626
  }
 
627
};
 
628
 
 
629
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 
630
class ModuleFunctor4 : public ModuleFunctorBase
 
631
{
 
632
  typedef T_ret (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4);
 
633
  function_type _funcptr;
 
634
  T_obj *_obj;
 
635
 
 
636
protected:
 
637
 
 
638
  virtual ValueRef perform_call(const BaseListRef &args)
 
639
  {
 
640
//    BaseListRef args(arglist);
 
641
    T_arg1 arg1= native_value_for_grt_type<typename traits<T_arg1>::Type>::convert(args[0]);
 
642
    T_arg2 arg2= native_value_for_grt_type<typename traits<T_arg2>::Type>::convert(args[1]);
 
643
    T_arg3 arg3= native_value_for_grt_type<typename traits<T_arg3>::Type>::convert(args[2]);
 
644
    T_arg4 arg4= native_value_for_grt_type<typename traits<T_arg4>::Type>::convert(args[3]);
 
645
    return grt_value_for_type((_obj->*_funcptr)(arg1, arg2, arg3, arg4));
 
646
  }
 
647
 
 
648
public:
 
649
  ModuleFunctor4(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
650
    : ModuleFunctorBase(name, doc, argdoc), _funcptr(func), _obj(obj)
 
651
  {
 
652
    _signature.push_back(get_param_info<typename traits<T_arg1>::Type>(argdoc, 0));
 
653
    _signature.push_back(get_param_info<typename traits<T_arg2>::Type>(argdoc, 1));
 
654
    _signature.push_back(get_param_info<typename traits<T_arg3>::Type>(argdoc, 2));
 
655
    _signature.push_back(get_param_info<typename traits<T_arg4>::Type>(argdoc, 3));
 
656
    _return_type= get_param_info<typename traits<T_ret>::Type>().type;
 
657
  }
 
658
};
 
659
 
 
660
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 
661
class ModuleFunctor5 : public ModuleFunctorBase
 
662
{
 
663
  typedef T_ret (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5);
 
664
  function_type _funcptr;
 
665
  T_obj *_obj;
 
666
 
 
667
protected:
 
668
 
 
669
  virtual ValueRef perform_call(const BaseListRef &args)
 
670
  {
 
671
//    BaseListRef args(arglist);
 
672
    T_arg1 arg1= native_value_for_grt_type<typename traits<T_arg1>::Type>::convert(args[0]);
 
673
    T_arg2 arg2= native_value_for_grt_type<typename traits<T_arg2>::Type>::convert(args[1]);
 
674
    T_arg3 arg3= native_value_for_grt_type<typename traits<T_arg3>::Type>::convert(args[2]);
 
675
    T_arg4 arg4= native_value_for_grt_type<typename traits<T_arg4>::Type>::convert(args[3]);
 
676
    T_arg5 arg5= native_value_for_grt_type<typename traits<T_arg5>::Type>::convert(args[4]);
 
677
    return grt_value_for_type((_obj->*_funcptr)(arg1, arg2, arg3, arg4, arg5));
 
678
  }
 
679
 
 
680
public:
 
681
  ModuleFunctor5(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
682
    : ModuleFunctorBase(name, doc, argdoc), _funcptr(func), _obj(obj)
 
683
  {
 
684
    _signature.push_back(get_param_info<typename traits<T_arg1>::Type>(argdoc, 0));
 
685
    _signature.push_back(get_param_info<typename traits<T_arg2>::Type>(argdoc, 1));
 
686
    _signature.push_back(get_param_info<typename traits<T_arg3>::Type>(argdoc, 2));
 
687
    _signature.push_back(get_param_info<typename traits<T_arg4>::Type>(argdoc, 3));
 
688
    _signature.push_back(get_param_info<typename traits<T_arg5>::Type>(argdoc, 4));
 
689
    _return_type= get_param_info<typename traits<T_ret>::Type>().type;
 
690
  }
 
691
};
 
692
 
 
693
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 
694
class ModuleFunctor6 : public ModuleFunctorBase
 
695
{
 
696
  typedef T_ret (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6);
 
697
  function_type _funcptr;
 
698
  T_obj *_obj;
 
699
 
 
700
protected:
 
701
 
 
702
  virtual ValueRef perform_call(const BaseListRef &args)
 
703
  {
 
704
//    BaseListRef args(arglist);
 
705
    T_arg1 arg1= native_value_for_grt_type<typename traits<T_arg1>::Type>::convert(args[0]);
 
706
    T_arg2 arg2= native_value_for_grt_type<typename traits<T_arg2>::Type>::convert(args[1]);
 
707
    T_arg3 arg3= native_value_for_grt_type<typename traits<T_arg3>::Type>::convert(args[2]);
 
708
    T_arg4 arg4= native_value_for_grt_type<typename traits<T_arg4>::Type>::convert(args[3]);
 
709
    T_arg5 arg5= native_value_for_grt_type<typename traits<T_arg5>::Type>::convert(args[4]);
 
710
    T_arg6 arg6= native_value_for_grt_type<typename traits<T_arg6>::Type>::convert(args[5]);
 
711
    return grt_value_for_type((_obj->*_funcptr)(arg1, arg2, arg3, arg4, arg5, arg6));
 
712
  }
 
713
 
 
714
public:
 
715
  ModuleFunctor6(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
716
    : ModuleFunctorBase(name, doc, argdoc), _funcptr(func), _obj(obj)
 
717
  {
 
718
    _signature.push_back(get_param_info<typename traits<T_arg1>::Type>(argdoc, 0));
 
719
    _signature.push_back(get_param_info<typename traits<T_arg2>::Type>(argdoc, 1));
 
720
    _signature.push_back(get_param_info<typename traits<T_arg3>::Type>(argdoc, 2));
 
721
    _signature.push_back(get_param_info<typename traits<T_arg4>::Type>(argdoc, 3));
 
722
    _signature.push_back(get_param_info<typename traits<T_arg5>::Type>(argdoc, 4));
 
723
    _signature.push_back(get_param_info<typename traits<T_arg6>::Type>(argdoc, 5));
 
724
    _return_type= get_param_info<typename traits<T_ret>::Type>().type;
 
725
  }
 
726
};
 
727
 
 
728
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 
729
class ModuleFunctor7 : public ModuleFunctorBase
 
730
{
 
731
  typedef T_ret (T_obj::*function_type)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7);
 
732
  function_type _funcptr;
 
733
  T_obj *_obj;
 
734
 
 
735
protected:
 
736
 
 
737
  virtual ValueRef perform_call(const BaseListRef &args)
 
738
  {
 
739
//    BaseListRef args(arglist);
 
740
    T_arg1 arg1= native_value_for_grt_type<typename traits<T_arg1>::Type>::convert(args[0]);
 
741
    T_arg2 arg2= native_value_for_grt_type<typename traits<T_arg2>::Type>::convert(args[1]);
 
742
    T_arg3 arg3= native_value_for_grt_type<typename traits<T_arg3>::Type>::convert(args[2]);
 
743
    T_arg4 arg4= native_value_for_grt_type<typename traits<T_arg4>::Type>::convert(args[3]);
 
744
    T_arg5 arg5= native_value_for_grt_type<typename traits<T_arg5>::Type>::convert(args[4]);
 
745
    T_arg6 arg6= native_value_for_grt_type<typename traits<T_arg6>::Type>::convert(args[5]);
 
746
    T_arg7 arg7= native_value_for_grt_type<typename traits<T_arg7>::Type>::convert(args[6]);
 
747
    return grt_value_for_type((_obj->*_funcptr)(arg1, arg2, arg3, arg4, arg5, arg6, arg7));
 
748
  }
 
749
 
 
750
public:
 
751
  ModuleFunctor7(const char *name, T_obj *obj, function_type func, const char *doc= "", const char *argdoc= "")
 
752
    : ModuleFunctorBase(name, doc, argdoc), _funcptr(func), _obj(obj)
 
753
  {
 
754
    _signature.push_back(get_param_info<typename traits<T_arg1>::Type>(argdoc, 0));
 
755
    _signature.push_back(get_param_info<typename traits<T_arg2>::Type>(argdoc, 1));
 
756
    _signature.push_back(get_param_info<typename traits<T_arg3>::Type>(argdoc, 2));
 
757
    _signature.push_back(get_param_info<typename traits<T_arg4>::Type>(argdoc, 3));
 
758
    _signature.push_back(get_param_info<typename traits<T_arg5>::Type>(argdoc, 4));
 
759
    _signature.push_back(get_param_info<typename traits<T_arg6>::Type>(argdoc, 5));
 
760
    _signature.push_back(get_param_info<typename traits<T_arg7>::Type>(argdoc, 6));
 
761
    _return_type= get_param_info<typename traits<T_ret>::Type>().type;
 
762
  }
 
763
};
 
764
 
 
765
// module functor wrappers (0 - 7 args)
 
766
 
 
767
template<class T_ret, class T_obj>
 
768
ModuleFunctor0<T_ret, T_obj> 
 
769
*module_fun(T_obj *obj, T_ret (T_obj::*func)(), const char *name, const char *doc= "", const char *argdoc= "")
 
770
{
 
771
  return new ModuleFunctor0<T_ret, T_obj>(name, obj, func, doc, argdoc);
 
772
}
 
773
 
 
774
template<class T_ret, class T_obj, class T_arg1>
 
775
ModuleFunctor1<T_ret, T_obj, T_arg1> 
 
776
*module_fun(T_obj *obj, T_ret (T_obj::*func)(T_arg1), const char *name, const char *doc= "", const char *argdoc= "")
 
777
{
 
778
  return new ModuleFunctor1<T_ret, T_obj, T_arg1>(name, obj, func, doc, argdoc);
 
779
}
 
780
 
 
781
template<class T_ret, class T_obj, class T_arg1, class T_arg2>
 
782
ModuleFunctor2<T_ret, T_obj, T_arg1, T_arg2> 
 
783
*module_fun(T_obj *obj, T_ret (T_obj::*func)(T_arg1, T_arg2), const char *name, const char *doc= "", const char *argdoc= "")
 
784
{
 
785
  return new ModuleFunctor2<T_ret, T_obj, T_arg1, T_arg2>(name, obj, func, doc, argdoc);
 
786
}
 
787
 
 
788
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3>
 
789
ModuleFunctor3<T_ret, T_obj, T_arg1, T_arg2, T_arg3> 
 
790
*module_fun(T_obj *obj, T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3), const char *name, const char *doc= "", const char *argdoc= "")
 
791
{
 
792
  return new ModuleFunctor3<T_ret, T_obj, T_arg1, T_arg2, T_arg3>(name, obj, func, doc, argdoc);
 
793
}
 
794
 
 
795
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 
796
ModuleFunctor4<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> 
 
797
*module_fun(T_obj *obj, T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4), const char *name, const char *doc= "", const char *argdoc= "")
 
798
{
 
799
  return new ModuleFunctor4<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(name, obj, func, doc, argdoc);
 
800
}
 
801
 
 
802
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 
803
ModuleFunctor5<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>
 
804
*module_fun(T_obj *obj, T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), const char *name, const char *doc= "", const char *argdoc= "")
 
805
{
 
806
  return new ModuleFunctor5<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(name, obj, func, doc, argdoc);
 
807
}
 
808
 
 
809
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 
810
ModuleFunctor6<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>
 
811
*module_fun(T_obj *obj, T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), const char *name, const char *doc= "", const char *argdoc= "")
 
812
{
 
813
  return new ModuleFunctor6<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(name, obj, func, doc, argdoc);
 
814
}
 
815
 
 
816
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 
817
ModuleFunctor7<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>
 
818
*module_fun(T_obj *obj, T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), const char *name, const char *doc= "", const char *argdoc= "")
 
819
{
 
820
  return new ModuleFunctor7<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(name, obj, func, doc, argdoc);
 
821
}
 
822
 
 
823
// interface functor wrappers (0 - 7 args)
 
824
 
 
825
template<class T_ret, class T_obj>
 
826
ModuleFunctor0<T_ret, T_obj> 
 
827
*interface_fun(T_ret (T_obj::*func)(), const char *name)
 
828
{
 
829
  return new ModuleFunctor0<T_ret, T_obj>(name, NULL, func);
 
830
}
 
831
 
 
832
template<class T_ret, class T_obj, class T_arg1>
 
833
ModuleFunctor1<T_ret, T_obj, T_arg1> 
 
834
*interface_fun(T_ret (T_obj::*func)(T_arg1), const char *name)
 
835
{
 
836
  return new ModuleFunctor1<T_ret, T_obj, T_arg1>(name, NULL, func);
 
837
}
 
838
 
 
839
template<class T_ret, class T_obj, class T_arg1, class T_arg2>
 
840
ModuleFunctor2<T_ret, T_obj, T_arg1, T_arg2> 
 
841
*interface_fun(T_ret (T_obj::*func)(T_arg1, T_arg2), const char *name)
 
842
{
 
843
  return new ModuleFunctor2<T_ret, T_obj, T_arg1, T_arg2>(name, NULL, func);
 
844
}
 
845
 
 
846
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3>
 
847
ModuleFunctor3<T_ret, T_obj, T_arg1, T_arg2, T_arg3> 
 
848
*interface_fun(T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3), const char *name)
 
849
{
 
850
  return new ModuleFunctor3<T_ret, T_obj, T_arg1, T_arg2, T_arg3>(name, NULL, func);
 
851
}
 
852
 
 
853
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4>
 
854
ModuleFunctor4<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4> 
 
855
*interface_fun(T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4), const char *name)
 
856
{
 
857
  return new ModuleFunctor4<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4>(name, NULL, func);
 
858
}
 
859
 
 
860
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5>
 
861
ModuleFunctor5<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5> 
 
862
*interface_fun(T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5), const char *name)
 
863
{
 
864
  return new ModuleFunctor5<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5>(name, NULL, func);
 
865
}
 
866
 
 
867
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6>
 
868
ModuleFunctor6<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6> 
 
869
*interface_fun(T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6), const char *name)
 
870
{
 
871
  return new ModuleFunctor6<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6>(name, NULL, func);
 
872
}
 
873
 
 
874
template<class T_ret, class T_obj, class T_arg1, class T_arg2, class T_arg3, class T_arg4, class T_arg5, class T_arg6, class T_arg7>
 
875
ModuleFunctor7<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7> 
 
876
*interface_fun(T_ret (T_obj::*func)(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7), const char *name)
 
877
{
 
878
  return new ModuleFunctor7<T_ret, T_obj, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7>(name, NULL, func);
 
879
}
 
880
 
 
881
#define DECLARE_INTERFACE_FUNCTION(qualified_name) interface_fun(&qualified_name, #qualified_name)
 
882
#define DECLARE_MODULE_FUNCTION(qualified_name) module_fun(this, &qualified_name, #qualified_name)
 
883
#define DECLARE_MODULE_FUNCTION_DOC(qualified_name, doc, argdoc) module_fun(this, &qualified_name, #qualified_name, doc, argdoc)
 
884
 
 
885
#define DECLARE_NAMED_INTERFACE_FUNCTION(qualified_name, name) interface_fun(&qualified_name, name)
 
886
#define DECLARE_NAMED_MODULE_FUNCTION(qualified_name, name) module_fun(this, &qualified_name, name)
 
887
#define DECLARE_NAMED_MODULE_FUNCTION_DOC(qualified_name, name, doc) module_fun(this, &qualified_name, name, doc)
 
888
 
 
889
 
 
890
  
 
891
//----------------------------------------------------------------------------
 
892
 
 
893
// DLL modules must declare the following
 
894
#if 1
 
895
#if defined(__WIN__) || defined(_WIN32) || defined(_WIN64)
 
896
#define GRT_MODULE_ENTRY_POINT_PUBLIC __declspec(dllexport)
 
897
#else
 
898
#define GRT_MODULE_ENTRY_POINT_PUBLIC
 
899
#endif
 
900
 
 
901
#define GRT_MODULE_ENTRY_POINT(moduleName)\
 
902
  extern "C" {\
 
903
    GRT_MODULE_ENTRY_POINT_PUBLIC grt::Module *grt_module_init(grt::CPPModuleLoader *loader, const char* grt_version)\
 
904
    {\
 
905
      moduleName *module= new moduleName(loader);\
 
906
      module->init_module();\
 
907
      return module;\
 
908
    }\
 
909
  }
 
910
#endif
 
911
  
 
912
};
 
913
 
 
914
 
 
915
#endif