Line data Source code
1 : /*
2 : * Copyright (c) 2010-2015: G-CSC, Goethe University Frankfurt
3 : * Author: Sebastian Reiter, Andreas Vogel
4 : *
5 : * This file is part of UG4.
6 : *
7 : * UG4 is free software: you can redistribute it and/or modify it under the
8 : * terms of the GNU Lesser General Public License version 3 (as published by the
9 : * Free Software Foundation) with the following additional attribution
10 : * requirements (according to LGPL/GPL v3 §7):
11 : *
12 : * (1) The following notice must be displayed in the Appropriate Legal Notices
13 : * of covered and combined works: "Based on UG4 (www.ug4.org/license)".
14 : *
15 : * (2) The following notice must be displayed at a prominent place in the
16 : * terminal output of covered works: "Based on UG4 (www.ug4.org/license)".
17 : *
18 : * (3) The following bibliography is recommended for citation and must be
19 : * preserved in all covered files:
20 : * "Reiter, S., Vogel, A., Heppner, I., Rupp, M., and Wittum, G. A massively
21 : * parallel geometric multigrid solver on hierarchically distributed grids.
22 : * Computing and visualization in science 16, 4 (2013), 151-164"
23 : * "Vogel, A., Reiter, S., Rupp, M., Nägel, A., and Wittum, G. UG4 -- a novel
24 : * flexible software system for simulating pde based models on high performance
25 : * computers. Computing and visualization in science 16, 4 (2013), 165-179"
26 : *
27 : * This program is distributed in the hope that it will be useful,
28 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
29 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
30 : * GNU Lesser General Public License for more details.
31 : */
32 :
33 : #include <iostream>
34 : #include <sstream>
35 : #include <boost/bind.hpp>
36 : #include "registry/registry.h"
37 : #include "bridge/bridge.h"
38 : #include "bridge/util.h"
39 : #include "common/util/message_hub.h"
40 :
41 : #ifdef UG_FOR_LUA
42 : #include "bindings/lua/lua_function_handle.h"
43 : #endif
44 :
45 : // temporary include
46 : #include "lib_grid/attachments/page_container.h"
47 :
48 : using namespace std;
49 :
50 : namespace ug
51 : {
52 : namespace bridge
53 : {
54 :
55 : /// \defgroup test_bridge Test Bridge
56 : /// \ingroup misc_bridge
57 : /// \{
58 :
59 : // prints "Hello World"
60 0 : void PrintHelloWorldToScreen()
61 : {
62 : UG_LOG("Hello World !\n");
63 0 : }
64 :
65 0 : int Add(int a, int b)
66 : {
67 0 : return a + b;
68 : }
69 :
70 0 : int Add(int a, int b, int c)
71 : {
72 0 : return a + b + c;
73 : }
74 :
75 0 : string Add(const char* a, const char* b)
76 : {
77 0 : string str = a;
78 0 : str.append(b);
79 0 : return str;
80 : }
81 :
82 : class Test
83 : {
84 : public:
85 0 : Test() { UG_LOG("Test::Test() constructor used.\n")}
86 0 : Test(const char* msg)
87 : {
88 : UG_LOG("Test::Test(const char*) constructor used.\n")
89 0 : UG_LOG("Message is: '"<<msg<<"'.\n");
90 0 : }
91 :
92 0 : int add(int a, int b)
93 : {
94 0 : return a+b;
95 : }
96 :
97 0 : int add(int a, int b, int c){
98 0 : return a + b + c;
99 : }
100 :
101 0 : string add(const char* a, const char* b){
102 0 : string str = a;
103 0 : str.append(b);
104 0 : return str;
105 : }
106 :
107 0 : int print_name()
108 : {
109 : UG_LOG("Name is Test\n");
110 0 : return 1;
111 : }
112 :
113 0 : int print() {UG_LOG("Test::print()\n"); return 0;}
114 0 : int print() const {UG_LOG("Test::print() const\n"); return 1;}
115 : };
116 :
117 :
118 : /// calls non-const print on non-const object of class Test
119 0 : int TestFunc(Test& t)
120 : {
121 0 : return t.print();
122 : }
123 :
124 : /// calls const print on const object of class Test
125 0 : int ConstTestFunc(const Test& t)
126 : {
127 0 : return t.print();
128 : }
129 :
130 : /// returns a const reference to a non-const object of class Test
131 0 : const Test& ToConst(Test& test)
132 : {
133 0 : return test;
134 : }
135 :
136 0 : SmartPtr<Test> SmartTestImpl(){
137 0 : return SmartPtr<Test>(new Test());
138 : }
139 :
140 0 : ConstSmartPtr<Test> ConstSmartTestImpl(){
141 0 : return ConstSmartPtr<Test>(new Test());
142 : }
143 :
144 0 : int SmartTestFunc(SmartPtr<Test> test)
145 : {
146 : UG_LOG("SmartTestFunc: ");
147 0 : return test->print();
148 : }
149 :
150 0 : int ConstSmartTestFunc(ConstSmartPtr<Test> test)
151 : {
152 : UG_LOG("ConstSmartTestFunc: ");
153 0 : return test->print();
154 : }
155 :
156 : /// SmartTest is a test-class which shall only be used encapsulated in a smart-pointer
157 : class SmartTest{
158 : public:
159 0 : SmartTest() {}
160 0 : virtual ~SmartTest() {UG_LOG("SmartTest destroyed...\n");}
161 0 : virtual void say_hello() {UG_LOG("Hello, I'm SmartTest\n");}
162 : };
163 :
164 : class SmartTestDerived : public SmartTest
165 : {
166 : public:
167 0 : SmartTestDerived() {}
168 0 : virtual ~SmartTestDerived() {UG_LOG("SmartTestDerived destroyed...\n");}
169 0 : virtual void say_hello() {UG_LOG("Hello, I'm SmartTestDerived\n");}
170 : };
171 :
172 : typedef SmartPtr<SmartTest> SPSmartTest;
173 : typedef SmartPtr<SmartTestDerived> SPSmartTestDerived;
174 :
175 0 : void SmartTestArrived(SPSmartTest test)
176 : {
177 : UG_LOG("HE, SMART TEST ARRIVED. HI SMART TEST.\n");
178 : UG_LOG("smart test answers: ");
179 0 : test->say_hello();
180 0 : }
181 :
182 :
183 :
184 : class Piece
185 : {
186 : public:
187 0 : Piece() : m_size(0) {}
188 0 : Piece(int size) : m_size(size) {}
189 :
190 0 : int size()
191 : {
192 0 : return m_size;
193 : }
194 :
195 : protected:
196 : int m_size;
197 : };
198 :
199 : class Cake
200 : {
201 : public:
202 0 : Cake() : m_numPieces(16) {}
203 :
204 0 : Piece& take_pieces(int size)
205 : {
206 0 : if(size > m_numPieces)
207 : size = m_numPieces;
208 0 : m_numPieces -= size;
209 0 : return *(new Piece(size));
210 : }
211 :
212 0 : int add_pieces(Piece& piece)
213 : {
214 0 : m_numPieces += piece.size();
215 0 : return m_numPieces;
216 : }
217 :
218 0 : int pieces_left() {return m_numPieces;}
219 :
220 : protected:
221 : int m_numPieces;
222 : };
223 :
224 : // Some Base class
225 0 : class Base
226 : {
227 : public:
228 0 : virtual ~Base() {}
229 0 : virtual void print() const
230 : {
231 : UG_LOG("Base::print() called\n");
232 0 : }
233 : };
234 :
235 : // Some Derived class
236 0 : class Derived : public Base
237 : {
238 : public:
239 0 : virtual ~Derived() {}
240 0 : virtual void print() const
241 : {
242 : UG_LOG("Derived::print() called.\n");
243 0 : }
244 : };
245 :
246 : // Some Derived class
247 0 : class FurtherDerived : public Derived
248 : {
249 : public:
250 0 : virtual ~FurtherDerived() {}
251 0 : virtual void print() const
252 : {
253 : UG_LOG("FurtherDerived::print() called.\n");
254 0 : }
255 : };
256 :
257 0 : const FurtherDerived* CreateConstFurtherDerived()
258 : {
259 0 : return new FurtherDerived();
260 : }
261 :
262 : class Base0
263 : {
264 : public:
265 : virtual ~Base0() {}
266 : virtual void virt_print_base0() const = 0;
267 0 : void print_base0() const {UG_LOG("Base0::print_base0() called.\n");}
268 : };
269 :
270 : class Base1
271 : {
272 : public:
273 : virtual ~Base1() {}
274 : virtual void virt_print_base1() const = 0;
275 0 : void print_base1() const {UG_LOG("Base1::print_base1() called.\n");}
276 : };
277 :
278 : class Base2
279 : {
280 : public:
281 : virtual ~Base2() {}
282 : virtual void virt_print_base2() const = 0;
283 0 : void print_base2() const {UG_LOG("Base2::print_base2() called.\n");}
284 : };
285 :
286 : class Base3
287 : {
288 : public:
289 : virtual ~Base3() {}
290 : virtual void virt_print_base3() const = 0;
291 0 : void print_base3() const {UG_LOG("Base3::print_base3() called.\n");}
292 : };
293 :
294 : class Intermediate0 : public Base0, public Base1
295 : {
296 : public:
297 : virtual ~Intermediate0() {}
298 : virtual void virt_print_intermediate0() const = 0;
299 0 : void print_intermediate0() const {UG_LOG("Intermediate0::print_intermediate0() called.\n");}
300 : };
301 :
302 : class Intermediate1 : public Base2, public Base3
303 : {
304 : public:
305 : virtual ~Intermediate1() {}
306 : virtual void virt_print_intermediate1() const = 0;
307 0 : void print_intermediate1() const {UG_LOG("Intermediate1::print_intermediate1() called.\n");}
308 : };
309 :
310 0 : class MultipleDerived : public Intermediate0, public Intermediate1
311 : {
312 : public:
313 0 : virtual ~MultipleDerived() {}
314 0 : void print_mulitple_derived(){UG_LOG("MultipleDerived::print() called\n");}
315 :
316 0 : virtual void virt_print_intermediate0() const {UG_LOG("MultipleDerived::virt_print_intermediate0() called\n");}
317 0 : virtual void virt_print_intermediate1() const {UG_LOG("MultipleDerived::virt_print_intermediate1() called\n");}
318 :
319 0 : virtual void virt_print_base0() const {UG_LOG("MultipleDerived::virt_print_base0() called\n");}
320 0 : virtual void virt_print_base1() const {UG_LOG("MultipleDerived::virt_print_base1() called\n");}
321 0 : virtual void virt_print_base2() const {UG_LOG("MultipleDerived::virt_print_base2() called\n");}
322 0 : virtual void virt_print_base3() const {UG_LOG("MultipleDerived::virt_print_base3() called\n");}
323 : };
324 :
325 0 : SmartPtr<MultipleDerived> SmartMultipleDerivedImpl(){
326 0 : return SmartPtr<MultipleDerived>(new MultipleDerived());
327 : }
328 :
329 0 : void PrintFunction(SmartPtr<Base3> b)
330 : {
331 0 : b->virt_print_base3();
332 0 : b->print_base3();
333 0 : }
334 :
335 0 : void PrintFunction(SmartPtr<Base2> b)
336 : {
337 0 : b->virt_print_base2();
338 0 : b->print_base2();
339 0 : }
340 :
341 0 : void PrintFunctionIntermediate(SmartPtr<Intermediate1> b)
342 : {
343 0 : b->virt_print_intermediate1();
344 0 : b->print_intermediate1();
345 0 : }
346 :
347 : class ConstClass
348 : {
349 : public:
350 0 : string const_method() const
351 : {
352 0 : return "const_method_called";
353 : }
354 : };
355 :
356 0 : void PrintFunctionIntermediate(Intermediate0& b)
357 : {
358 0 : b.virt_print_intermediate0();
359 0 : b.print_intermediate0();
360 0 : }
361 :
362 0 : void PrintFunction(Base3& b)
363 : {
364 0 : b.virt_print_base3();
365 0 : b.print_base3();
366 0 : }
367 :
368 0 : void PrintFunction(Base& b)
369 : {
370 0 : b.print();
371 0 : }
372 :
373 0 : const char* StringTest()
374 : {
375 0 : return "Jooik";
376 : }
377 :
378 0 : string StdStringTest()
379 : {
380 0 : return string("stdJooik");
381 : }
382 :
383 0 : void PrintStringTest(const std::string& str)
384 : {
385 : UG_LOG("PrintStringTest recieved: " << str << endl);
386 0 : }
387 :
388 :
389 0 : void TestPageContainer()
390 : {
391 : UG_LOG("Testing page container whith default maxPageSize.\n");
392 :
393 : typedef PageContainer<double> PageCon;
394 0 : PageCon* ppc = new PageCon;
395 : PageCon& pc = *ppc;
396 :
397 : size_t testSize = 10000;
398 :
399 : UG_LOG("resizing...\n");
400 0 : pc.resize(testSize);
401 :
402 : UG_LOG("pushing doubles...\n");
403 0 : for(size_t i = 0; i < testSize; ++i){
404 0 : pc[i] = 3300. + (double)i;
405 : }
406 :
407 : UG_LOG("PageContainer content:");
408 0 : for(size_t i = testSize - 10; i < testSize; ++i){
409 0 : UG_LOG(" " << pc[i]);
410 : }
411 : UG_LOG(endl);
412 : UG_LOG("Releasing PageContainer...\n");
413 0 : delete ppc;
414 : UG_LOG("done.\n");
415 0 : }
416 :
417 0 : void PostRegisteredFunction()
418 : {
419 : UG_LOG("PostRegisteredFunction successfully executed.\n");
420 0 : }
421 :
422 0 : void PostRegisterTest()
423 : {
424 0 : bridge::Registry& reg = bridge::GetUGRegistry();
425 0 : reg.add_function("PostRegisteredFunction", &PostRegisteredFunction);
426 0 : reg.registry_changed();
427 0 : }
428 :
429 :
430 : class Unregistered{
431 : private:
432 : string m_emptyString;
433 : };
434 :
435 0 : Unregistered* UnregisteredParameterTest(Unregistered& unregistered)
436 : {
437 0 : return &unregistered;
438 : }
439 :
440 : class NonAllowedName1 {};
441 : class NonAllowedName2 {};
442 : class NonAllowedName3 {};
443 : class NonAllowedName4 {};
444 : class AllowName{public: void non_allowed_method(){};};
445 :
446 0 : void NonAllowedFct1() {};
447 0 : void NonAllowedFct2() {};
448 0 : void NonAllowedFct3() {};
449 :
450 :
451 : const char* REFINEMENT_MESSAGE_NAME = "MSG_GRID_ADAPTION";
452 :
453 : class Message{
454 : //int msgType;
455 : };
456 :
457 :
458 :
459 : ////////////////////////////////////////////////////////////////////////////////
460 : // The following test-case is used to check the MessageHub class
461 0 : class TestMessage : public MessageHub::IMessage
462 : {
463 : public:
464 : string m_strMsg;
465 : };
466 :
467 0 : void TestMsgCallback(const TestMessage& msg){
468 : UG_LOG("Callback func received message: " << msg.m_strMsg << "\n");
469 0 : }
470 :
471 :
472 0 : class MessageHubTest
473 : {
474 : public:
475 0 : MessageHubTest(){
476 0 : m_msgHub = SPMessageHub(new MessageHub());
477 0 : m_callbackId = m_msgHub->register_class_callback(this,
478 0 : &ug::bridge::MessageHubTest::callback);
479 :
480 0 : m_msgHub->register_function_callback(&ug::bridge::TestMsgCallback);
481 0 : }
482 :
483 0 : void callback(const TestMessage& msg){
484 : UG_LOG("Received message: " << msg.m_strMsg << "\n");
485 0 : }
486 :
487 0 : void post_message(const char* message){
488 0 : if(m_msgHub.valid()){
489 : TestMessage msg;
490 : msg.m_strMsg = message;
491 0 : m_msgHub->post_message(msg);
492 : }
493 0 : }
494 :
495 : protected:
496 : SPMessageHub m_msgHub;
497 : MessageHub::SPCallbackId m_callbackId;
498 : };
499 :
500 :
501 : template <typename T>
502 0 : void PrintStdVector(std::vector<T> vec)
503 : {
504 : UG_LOG("std::vector<T> passed: Size is: "<<vec.size()<<"\n");
505 0 : for(size_t i = 0; i < vec.size(); ++i)
506 0 : UG_LOG(i<<": "<<vec[i]<<"\n");
507 0 : }
508 :
509 : template <typename T>
510 0 : void PrintConstStdVectorRef(const std::vector<T>& vec)
511 : {
512 : UG_LOG("const std::vector<T>& passed: Size is: "<<vec.size()<<"\n");
513 0 : for(size_t i = 0; i < vec.size(); ++i)
514 0 : UG_LOG(i<<": "<<vec[i]<<"\n");
515 0 : }
516 :
517 : template <typename T>
518 0 : void PrintStdVectorOfClass(std::vector<T> vec)
519 : {
520 : UG_LOG("std::vector<T> passed: Size is: "<<vec.size()<<"\n");
521 0 : for(size_t i = 0; i < vec.size(); ++i)
522 0 : vec[i]->print();
523 0 : }
524 :
525 : template <typename T>
526 0 : void ConstStdVectorRefOfClass(const std::vector<T>& vec)
527 : {
528 : UG_LOG("const std::vector<T>& passed: Size is: "<<vec.size()<<"\n");
529 0 : for(size_t i = 0; i < vec.size(); ++i)
530 0 : vec[i]->print();
531 0 : }
532 :
533 0 : std::vector<std::string> ReturnStdVector_String(){
534 : std::vector<std::string> vec;
535 0 : vec.push_back("Entry1");
536 0 : vec.push_back("Entry2");
537 0 : vec.push_back("Entry3");
538 0 : return vec;
539 0 : }
540 :
541 0 : const std::vector<std::string>& ReturnConstStdVectorRef_String(){
542 0 : static std::vector<std::string> vec;
543 0 : vec.push_back("Entry1");
544 0 : vec.push_back("Entry2");
545 0 : vec.push_back("Entry3");
546 0 : return vec;
547 : }
548 :
549 : template <typename T>
550 0 : std::vector<T> ReturnStdVector_Number(){
551 : std::vector<T> vec;
552 0 : vec.push_back((T)1.56);
553 0 : vec.push_back((T)144.87);
554 0 : vec.push_back((T)99.3);
555 0 : return vec;
556 0 : }
557 :
558 : template <typename T>
559 0 : const std::vector<T>& ReturnConstStdVectorRef_Number(){
560 0 : static std::vector<T> vec;
561 0 : vec.push_back((T)1.56);
562 0 : vec.push_back((T)144.87);
563 0 : vec.push_back((T)99.3);
564 0 : return vec;
565 : }
566 :
567 : template <typename T>
568 0 : std::vector<T> ReturnStdVectorOfClass(){
569 : std::vector<T> vec;
570 0 : vec.push_back(T(new Derived()));
571 0 : vec.push_back(T(new Base()));
572 0 : vec.push_back(T(new FurtherDerived()));
573 0 : return vec;
574 0 : }
575 :
576 : template <typename T>
577 0 : const std::vector<T>& ReturnConstStdVectorRefOfClass(){
578 0 : static std::vector<T> vec;
579 0 : vec.push_back(new Derived());
580 0 : vec.push_back(new Base());
581 0 : vec.push_back(new FurtherDerived());
582 0 : return vec;
583 : }
584 :
585 : template <typename T>
586 0 : const std::vector<T>& ReturnConstStdVectorRefOfClassSP(){
587 0 : static std::vector<T> vec;
588 0 : vec.push_back(make_sp(new Derived()));
589 0 : vec.push_back(make_sp(new Base()));
590 0 : vec.push_back(make_sp(new FurtherDerived()));
591 0 : return vec;
592 : }
593 :
594 0 : void NotAllowedParamPerValue(Piece P){}
595 :
596 : #ifdef UG_FOR_LUA
597 0 : void FunctionWithFunctionArgument(LuaFunctionHandle handle)
598 : {
599 0 : UG_LOG("Test LuaFunctionHandle: handle.ref=" << handle.ref << std::endl);
600 0 : return;
601 : }
602 : #endif
603 :
604 0 : void RegisterBridge_Test(Registry& reg, string parentGroup)
605 : {
606 : // get group string
607 0 : stringstream groupString; groupString << parentGroup << "/Test";
608 : string grp = groupString.str();
609 :
610 : try
611 : {
612 : // registering hello world
613 0 : reg.add_function("PrintHelloWorld", &PrintHelloWorldToScreen, grp);
614 :
615 : #ifdef UG_FOR_LUA
616 : // registering LuaFunctionHandle
617 0 : reg.add_function("FunctionWithFunctionArgument", &FunctionWithFunctionArgument, grp);
618 : #endif
619 :
620 : // registering add
621 0 : reg.add_function("add", static_cast<int (*)(int, int)>(
622 : &Add), grp, "c", "a#b");
623 0 : reg.add_function("add", static_cast<int (*)(int, int, int)>(
624 : &Add), grp, "d", "a#b#c");
625 0 : reg.add_function("add", static_cast<string (*)(const char*, const char*)>(
626 : &Add), grp, "c", "a#b");
627 :
628 : // register class "Test"
629 0 : reg.add_class_<Test>("Test", grp)
630 0 : .add_constructor()
631 0 : .add_constructor<void (*)(const char*)>()
632 0 : .add_method("add", static_cast<int (Test::*)(int, int)>(&Test::add), "c", "a#b")
633 0 : .add_method("add", static_cast<int (Test::*)(int, int, int)>(&Test::add), "d", "a#b#c")
634 0 : .add_method("add", static_cast<string (Test::*)(const char*, const char*)>(&Test::add), "d", "a#b#c")
635 0 : .add_method("print_name", &Test::print_name)
636 0 : .add_method("print", static_cast<int(Test::*)()>(&Test::print))
637 0 : .add_method("print", static_cast<int(Test::*)() const>(&Test::print))
638 0 : .set_construct_as_smart_pointer(true);
639 :
640 : // registering base class (without constructor)
641 0 : reg.add_class_<Base>("Base", grp)
642 0 : .add_constructor()
643 0 : .add_method("print", &Base::print)
644 0 : .set_construct_as_smart_pointer(true);
645 :
646 : // registering derived class
647 0 : reg.add_class_<Derived, Base>("Derived", grp)
648 0 : .add_constructor()
649 0 : .add_method("print", &Derived::print)
650 0 : .set_construct_as_smart_pointer(true);
651 :
652 : // registering derived class
653 0 : reg.add_class_<FurtherDerived, Derived>("FurtherDerived", grp)
654 0 : .add_constructor()
655 0 : .add_method("print", &FurtherDerived::print)
656 0 : .set_construct_as_smart_pointer(true);
657 :
658 0 : reg.add_function("CreateConstFurtherDerived", &CreateConstFurtherDerived, grp);
659 :
660 0 : reg.add_class_<Base0>("Base0", grp)
661 0 : .add_method("virt_print_base0", &Base0::virt_print_base0)
662 0 : .add_method("print_base0", &Base0::print_base0);
663 :
664 0 : reg.add_class_<Base1>("Base1", grp)
665 0 : .add_method("virt_print_base1", &Base1::virt_print_base1)
666 0 : .add_method("print_base1", &Base1::print_base1);
667 :
668 0 : reg.add_class_<Base2>("Base2", grp)
669 0 : .add_method("virt_print_base2", &Base2::virt_print_base2)
670 0 : .add_method("print_base2", &Base2::print_base2);
671 :
672 0 : reg.add_class_<Base3>("Base3", grp)
673 0 : .add_method("virt_print_base3", &Base3::virt_print_base3)
674 0 : .add_method("print_base3", &Base3::print_base3);
675 :
676 0 : reg.add_class_<Intermediate0, Base1, Base0>("Intermediate0", grp)
677 0 : .add_method("virt_print_intermediate0", &Intermediate0::virt_print_intermediate0)
678 0 : .add_method("print_intermediate0", &Intermediate0::print_intermediate0);
679 :
680 0 : reg.add_class_<Intermediate1, Base2, Base3>("Intermediate1", grp)
681 0 : .add_method("virt_print_intermediate1", &Intermediate1::virt_print_intermediate1)
682 0 : .add_method("print_intermediate1", &Intermediate1::print_intermediate1);
683 :
684 0 : reg.add_class_<MultipleDerived, Intermediate0, Intermediate1>("MultipleDerived", grp)
685 0 : .add_constructor()
686 0 : .add_method("print_mulitple_derived", &MultipleDerived::print_mulitple_derived)
687 0 : .set_construct_as_smart_pointer(true);
688 :
689 0 : reg.add_function("SmartMultipleDerivedImpl", SmartMultipleDerivedImpl, grp);
690 :
691 0 : reg.add_function("PrintFunctionIntermediate", static_cast<void (*)(SmartPtr<Intermediate1>)>(&PrintFunctionIntermediate), grp);
692 : // reg.add_function("PrintFunction", (void (*)(SmartPtr<Base3>))&PrintFunction, grp); // nasty example!
693 0 : reg.add_function("PrintFunction", static_cast<void (*)(SmartPtr<Base2>)>(&PrintFunction), grp);
694 0 : reg.add_function("PrintFunction", static_cast<void (*)(Base&)>(&PrintFunction), grp);
695 : // reg.add_function("PrintFunctionIntermediate", (void (*)(Intermediate1&))&PrintFunctionIntermediate, grp); // nasty example!
696 0 : reg.add_function("PrintFunctionIntermediate", static_cast<void (*)(Intermediate0&)>(&PrintFunctionIntermediate), grp);
697 0 : reg.add_function("PrintFunction", static_cast<void (*)(Base3&)>(&PrintFunction), grp);
698 :
699 0 : reg.add_class_<ConstClass>("ConstClass", grp)
700 0 : .add_constructor()
701 0 : .add_method("const_method", &ConstClass::const_method)
702 0 : .set_construct_as_smart_pointer(true);
703 :
704 0 : reg.add_class_<Piece>("Piece", grp)
705 0 : .add_constructor()
706 0 : .add_method("size", &Piece::size)
707 0 : .set_construct_as_smart_pointer(true);
708 :
709 0 : reg.add_class_<Cake>("Cake", grp)
710 0 : .add_constructor()
711 0 : .add_method("take_pieces", &Cake::take_pieces)
712 0 : .add_method("add_pieces", &Cake::add_pieces)
713 0 : .add_method("pieces_left", &Cake::pieces_left)
714 0 : .set_construct_as_smart_pointer(true);
715 :
716 0 : reg.add_function("TestFunc", TestFunc, grp)
717 0 : .add_function("SmartTestImpl", SmartTestImpl, grp)
718 0 : .add_function("ConstSmartTestImpl", ConstSmartTestImpl, grp)
719 0 : .add_function("SmartTestFunc", SmartTestFunc, grp)
720 0 : .add_function("ConstSmartTestFunc", ConstSmartTestFunc, grp)
721 0 : .add_function("ConstTestFunc", ConstTestFunc, grp)
722 0 : .add_function("ToConst", ToConst, grp)
723 0 : .add_function("StringTest", StringTest, grp)
724 0 : .add_function("StdStringTest", StdStringTest, grp)
725 0 : .add_function("PrintStringTest", PrintStringTest, grp)
726 0 : .add_function("TestPageContainer", TestPageContainer, grp);
727 :
728 0 : reg.add_class_<SmartTest>("SmartTest", grp)
729 0 : .add_constructor()
730 0 : .add_method("say_hello", &SmartTest::say_hello)
731 0 : .set_construct_as_smart_pointer(true);// always last!
732 :
733 0 : reg.add_class_<SmartTestDerived, SmartTest>("SmartTestDerived", grp)
734 0 : .add_constructor()
735 0 : .add_method("say_hello", &SmartTestDerived::say_hello)
736 0 : .set_construct_as_smart_pointer(true);// always last!
737 :
738 0 : reg.add_function("SmartTestArrived", &SmartTestArrived, grp);
739 :
740 0 : reg.add_class_<MessageHubTest>("MessageHubTest", grp)
741 0 : .add_constructor()
742 0 : .add_method("post_message", &MessageHubTest::post_message)
743 0 : .set_construct_as_smart_pointer(true);
744 :
745 :
746 : // if the following registration is performed, the app should fail on startup,
747 : // since the registered method takes an argument of an unregistered type.
748 : //reg.add_function("UnregisteredParameterTest", UnregisteredParameterTest);
749 :
750 : // if the following registration is performed, the app should fail on startup,
751 : // since the registered class/functon is ill named (only [a-zA-Z_][a-zA-Z_0-9]* allowed).
752 : //reg.add_class_<SmartTest>("SmartTest", grp);
753 : //reg.add_class_<NonAllowedName1>("BlimBlim$tshe");
754 : //reg.add_class_<NonAllowedName2>("5BlimBlimtshe");
755 : //reg.add_class_<NonAllowedName3>("Blim::Blimtshe");
756 : //reg.add_class_<NonAllowedName4>("Blim Blimtshe");
757 : //reg.add_class_<AllowName>("AllowName").add_method("$liadsf", &AllowName::non_allowed_method);
758 : //reg.add_function("Blub%brrr", &NonAllowedFct1);
759 : //reg.add_function("5Blubbrrr", &NonAllowedFct2);
760 : //reg.add_function("Blub_brr r", &NonAllowedFct3);
761 : //reg.add_function("NotAllowedParamPerValue", &NotAllowedParamPerValue);
762 :
763 0 : reg.add_function("PrintStdVectorBool", &PrintStdVector<bool>, grp);
764 0 : reg.add_function("PrintStdVectorInteger", &PrintStdVector<int>, grp);
765 0 : reg.add_function("PrintStdVectorSize_t", &PrintStdVector<size_t>, grp);
766 0 : reg.add_function("PrintStdVectorNumber", &PrintStdVector<number>, grp);
767 0 : reg.add_function("PrintStdVectorFloat", &PrintStdVector<float>, grp);
768 0 : reg.add_function("PrintStdVectorDouble", &PrintStdVector<double>, grp);
769 0 : reg.add_function("PrintStdVectorChar", &PrintStdVector<const char*>, grp);
770 0 : reg.add_function("PrintStdVectorString", &PrintStdVector<std::string>, grp);
771 :
772 0 : reg.add_function("PrintConstStdVectorRefBool", &PrintConstStdVectorRef<bool>, grp);
773 0 : reg.add_function("PrintConstStdVectorRefInteger", &PrintConstStdVectorRef<int>, grp);
774 0 : reg.add_function("PrintConstStdVectorRefSize_t", &PrintConstStdVectorRef<size_t>, grp);
775 0 : reg.add_function("PrintConstStdVectorRefNumber", &PrintConstStdVectorRef<number>, grp);
776 0 : reg.add_function("PrintConstStdVectorRefFloat", &PrintConstStdVectorRef<float>, grp);
777 0 : reg.add_function("PrintConstStdVectorRefDouble", &PrintConstStdVectorRef<double>, grp);
778 0 : reg.add_function("PrintConstStdVectorRefChar", &PrintConstStdVectorRef<const char*>, grp);
779 0 : reg.add_function("PrintConstStdVectorRefString", &PrintConstStdVectorRef<std::string>, grp);
780 :
781 0 : reg.add_function("PrintStdVector_BasePtr", &PrintStdVectorOfClass<Base*>, grp);
782 0 : reg.add_function("PrintStdVector_BaseConstPtr", &PrintStdVectorOfClass<const Base*>, grp);
783 0 : reg.add_function("PrintStdVector_BaseSmartPtr", &PrintStdVectorOfClass<SmartPtr<Base> >, grp);
784 0 : reg.add_function("PrintStdVector_BaseConstSmartPtr", &PrintStdVectorOfClass<ConstSmartPtr<Base> >, grp);
785 :
786 0 : reg.add_function("PrintConstStdVectorRef_BasePtr", &ConstStdVectorRefOfClass<Base*>, grp);
787 0 : reg.add_function("PrintConstStdVectorRef_BaseConstPtr", &ConstStdVectorRefOfClass<const Base*>, grp);
788 0 : reg.add_function("PrintConstStdVectorRef_BaseSmartPtr", &ConstStdVectorRefOfClass<SmartPtr<Base> >, grp);
789 0 : reg.add_function("PrintConstStdVectorRef_BaseConstSmartPtr", &ConstStdVectorRefOfClass<ConstSmartPtr<Base> >, grp);
790 :
791 0 : reg.add_function("ReturnConstStdVectorRef_String", &ReturnConstStdVectorRef_String, grp);
792 0 : reg.add_function("ReturnStdVector_String", &ReturnStdVector_String, grp);
793 :
794 0 : reg.add_function("ReturnConstStdVectorRef_Int", &ReturnConstStdVectorRef_Number<int>, grp);
795 0 : reg.add_function("ReturnStdVector_Int", &ReturnStdVector_Number<int>, grp);
796 :
797 0 : reg.add_function("ReturnConstStdVectorRef_Double", &ReturnConstStdVectorRef_Number<double>, grp);
798 0 : reg.add_function("ReturnStdVector_Double", &ReturnStdVector_Number<double>, grp);
799 :
800 0 : reg.add_function("ReturnConstStdVectorRef_BasePtr", &ReturnConstStdVectorRefOfClass<Base*>, grp);
801 0 : reg.add_function("ReturnStdVector_BasePtr", &ReturnStdVectorOfClass<Base*>, grp);
802 :
803 0 : reg.add_function("ReturnConstStdVectorRef_BaseConstPtr", &ReturnConstStdVectorRefOfClass<const Base*>, grp);
804 0 : reg.add_function("ReturnStdVector_BaseConstPtr", &ReturnStdVectorOfClass<const Base*>, grp);
805 :
806 0 : reg.add_function("ReturnConstStdVectorRef_BaseSmartPtr", &ReturnConstStdVectorRefOfClassSP<SmartPtr<Base> >, grp);
807 0 : reg.add_function("ReturnStdVector_BaseSmartPtr", &ReturnStdVectorOfClass<SmartPtr<Base> >, grp);
808 :
809 0 : reg.add_function("ReturnConstStdVectorRef_BaseConstSmartPtr", &ReturnConstStdVectorRefOfClassSP<ConstSmartPtr<Base> >, grp);
810 0 : reg.add_function("ReturnStdVector_BaseConstSmartPtr", &ReturnStdVectorOfClass<ConstSmartPtr<Base> >, grp);
811 :
812 : }
813 0 : UG_REGISTRY_CATCH_THROW(grp);
814 0 : }
815 :
816 : // end group test_bridge
817 : /// \}
818 :
819 : }// end of namespace
820 : }// end of namespace
|
