Changeset 1676 for code/branches/core3/src/orxonox

Timestamp:

Aug 28, 2008, 11:50:53 PM (16 years ago)

Author:

landauf

Message:

a first test-version of my super-macro
tested with a testfunction in Projectile, just shoot to test
no idea if this works on other compilers (namely MSVC)

Location:

code/branches/core3/src/orxonox/objects

Files:

• BillboardProjectile.cc (modified) (2 diffs)
• BillboardProjectile.h (modified) (1 diff)
• ParticleProjectile.cc (modified) (3 diffs)
• ParticleProjectile.h (modified) (1 diff)
• Projectile.cc (modified) (1 diff)
• Projectile.h (modified) (3 diffs)

code/branches/core3/src/orxonox/objects/BillboardProjectile.cc

@@ -48 +48 @@
             this->scale(0.5);
         }
+
+        std::cout << "a:\n";
+        SUPER(BillboardProjectile, testfunction);
+        std::cout << "b:\n";
     }
 
@@ -66 +70 @@
         this->billboard_.setVisible(this->isVisible());
     }
+
+    void BillboardProjectile::testfunction() { SUPER(BillboardProjectile, testfunction); std::cout << "2 -> " << std::endl; }
 }

code/branches/core3/src/orxonox/objects/BillboardProjectile.h

@@ -46 +46 @@
             virtual void setColour(const ColourValue& colour);
             virtual void changedVisibility();
+            virtual void testfunction();
 
         private:

code/branches/core3/src/orxonox/objects/ParticleProjectile.cc

@@ -33 +33 @@
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+//#include "util/FastDelegate.h"
+//using namespace fastdelegate;
+
 namespace orxonox
 {
     CreateFactory(ParticleProjectile);
+
+    struct FunctionPointerViewer
+    {
+        void* ptr1_;
+        void* ptr2_;
+
+        void view()
+        {
+            std::cout << ptr1_ << "." << ptr2_ << std::endl;
+        }
+    };
+
+    union FunctionPointerViewer1
+    {
+        FunctionPointerViewer viewer_;
+        void (Projectile::*function_) ();
+    };
+
+    union FunctionPointerViewer2
+    {
+        FunctionPointerViewer viewer_;
+        void (BillboardProjectile::*function_) ();
+    };
+
+    union FunctionPointerViewer3
+    {
+        FunctionPointerViewer viewer_;
+        void (ParticleProjectile::*function_) ();
+    };
 
     ParticleProjectile::ParticleProjectile(SpaceShip* owner) : BillboardProjectile(owner)
@@ -54 +86 @@
 
         this->setConfigValues();
+/*
+        FunctionPointerViewer1 fpw1;
+        fpw1.function_ = &Projectile::testfunction;
+        FunctionPointerViewer2 fpw2;
+        fpw2.function_ = &BillboardProjectile::testfunction;
+        FunctionPointerViewer3 fpw3;
+        fpw3.function_ = &ParticleProjectile::testfunction;
+
+        std::cout << sizeof(void (Projectile::*) ()) << std::endl;
+        fpw1.viewer_.view();
+        fpw2.viewer_.view();
+        fpw3.viewer_.view();
+
+        {
+            std::cout << "1:" << std::endl;
+            FastDelegate0<> delegate1(this, &ParticleProjectile::testfunction);
+            delegate1();
+            FastDelegate0<> delegate2((BillboardProjectile*)this, &BillboardProjectile::testfunction);
+            delegate2();
+            FastDelegate0<> delegate3(this, &Projectile::testfunction);
+            delegate3();
+        }
+        {
+            std::cout << "2:" << std::endl;
+            BillboardProjectile temp;
+//            FastDelegate0<> delegate1(&temp, &ParticleProjectile::testfunction);
+//            delegate1();
+            FastDelegate0<> delegate2(&temp, &BillboardProjectile::testfunction);
+            delegate2();
+            FastDelegate0<> delegate3(&temp, &Projectile::testfunction);
+            delegate3();
+        }
+        std::cout << "done" << std::endl;
+
+        std::cout << "0:" << std::endl;
+        this->Projectile::testfunction();
+        this->BillboardProjectile::testfunction();
+        this->ParticleProjectile::testfunction();
+        this->testfunction();
+
+        std::cout << "1:" << std::endl;
+        (this->*fpw1.function_)();
+        std::cout << "2:" << std::endl;
+        (this->*fpw2.function_)();
+        std::cout << "3:" << std::endl;
+        (this->*fpw3.function_)();
+        std::cout << "done" << std::endl;
+*/
+        std::cout << "c:\n";
+        SUPER(ParticleProjectile, testfunction);
+        std::cout << "d:\n";
+
+        std::cout << "e:\n";
+        this->testfunction();
+        std::cout << "f:\n";
+
+//        (*((ClassIdentifier<SuperDummy>*)this->getIdentifier())->superFunctionCaller_testfunction_)(this);
     }
 
@@ -72 +161 @@
         this->particles_->setEnabled(this->isVisible());
     }
+
+    void ParticleProjectile::testfunction() { SUPER(ParticleProjectile, testfunction); std::cout << "3 -> " << std::endl; }
 }

code/branches/core3/src/orxonox/objects/ParticleProjectile.h

@@ -44 +44 @@
             virtual ~ParticleProjectile();
             virtual void changedVisibility();
+            virtual void testfunction();
             void setConfigValues();
 

code/branches/core3/src/orxonox/objects/Projectile.cc

@@ -121 +121 @@
         delete this;
     }
+
+    void Projectile::testfunction() { std::cout << "1 -> " << std::endl; }
 }

code/branches/core3/src/orxonox/objects/Projectile.h

@@ -34 +34 @@
 #include "WorldEntity.h"
 #include "tools/Timer.h"
+#undef SUPER_INTRUSIVE
+#include "core/Super.h"
 
 namespace orxonox
@@ -45 +47 @@
             void destroyObject();
             virtual void tick(float dt);
+            virtual void testfunction();
 
             static float getSpeed()
@@ -64 +67 @@
             Timer<Projectile> destroyTimer_;
     };
+
+    // Partially specialized template (templatehack is now specialized too)
+    template <class T>
+    struct SuperFunctionCondition<0, 0, T>
+    {
+        // Checks if class U isA baseclass and sets the functionpointer if the check returned true
+        static void check()
+        {
+            std::cout << "check superfunction \"testfunction\" in " << ClassIdentifier<T>::getIdentifier()->getName() << std::endl;
+
+            T* temp;
+            SuperFunctionCondition<0, 0, T>::apply(temp);
+
+            std::cout << "done" << std::endl;
+
+            // Calls the condition of the next super-function
+            SuperFunctionCondition<0 + 1, 0, T>::check();
+        }
+
+        static void apply(void* temp)
+        {
+            std::cout << ClassIdentifier<T>::getIdentifier()->getName() << " is not a Projectile" << std::endl;
+            // nop
+        }
+
+        static void apply(Projectile* temp)
+        {
+            std::cout << ClassIdentifier<T>::getIdentifier()->getName() << " is a Projectile" << std::endl;
+            ClassIdentifier<T>* identifier = ClassIdentifier<T>::getIdentifier();
+
+            SuperFunctionCaller_testfunction* superFunctionCaller = 0;
+            // Search for an existing caller within all direct children
+            for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it)
+                if (((ClassIdentifier<T>*)(*it))->superFunctionCaller_testfunction_)
+                    superFunctionCaller = ((ClassIdentifier<T>*)(*it))->superFunctionCaller_testfunction_;
+            // Check if we've found an existing caller - if not, create a new one
+            if (!superFunctionCaller)
+                superFunctionCaller = new SuperFunctionClassCaller_testfunction<T>;
+            // Iterate through all children and assign the caller
+            for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it)
+            {
+                if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_testfunction_)
+                {
+                    std::cout << "adding functionpointer to " << ((ClassIdentifier<T>*)(*it))->getName() << std::endl;
+                    ((ClassIdentifier<T>*)(*it))->superFunctionCaller_testfunction_ = superFunctionCaller;
+                }
+            }
+        }
+    };
 }