Changeset 1676

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

Files:

• core/ConfigFileManager.cc (modified) (1 diff)
• core/Factory.cc (modified) (1 diff)
• core/Identifier.cc (modified) (1 diff)
• core/Identifier.h (modified) (6 diffs)
• orxonox/objects/BillboardProjectile.cc (modified) (2 diffs)
• orxonox/objects/BillboardProjectile.h (modified) (1 diff)
• orxonox/objects/ParticleProjectile.cc (modified) (3 diffs)
• orxonox/objects/ParticleProjectile.h (modified) (1 diff)
• orxonox/objects/Projectile.cc (modified) (1 diff)
• orxonox/objects/Projectile.h (modified) (3 diffs)

code/branches/core3/src/core/ConfigFileManager.cc

@@ -327 +327 @@
         file.close();
 
-        COUT(3) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
+        COUT(0) << "Loaded config file \"" << this->filename_ << "\"." << std::endl;
 
         // Save the file in case something changed (like stripped whitespaces)

code/branches/core3/src/core/Factory.cc

@@ -98 +98 @@
         }
         (*getFactoryPointer()->identifierStringMap_.begin()).second->stopCreatingHierarchy();
+/*
+        for (it = Identifier::getIdentifierMapIntern().begin(); it != Identifier::getIdentifierMapIntern().end(); ++it)
+            (*it).second->createSuperFunctionCaller();
+*/
         COUT(3) << "*** Factory: Finished class-hierarchy creation" << std::endl;
     }

code/branches/core3/src/core/Identifier.cc

@@ -145 +145 @@
                 // Tell the parent we're one of it's direct children
                 (*it)->getDirectChildrenIntern().insert((*it)->getDirectChildrenIntern().end(), this);
+
+                // Create the super-function dependencies
+                (*it)->createSuperFunctionCaller();
             }
         }

code/branches/core3/src/core/Identifier.h

@@ -62 +62 @@
 #include "MetaObjectList.h"
 #include "Iterator.h"
+#undef SUPER_INTRUSIVE
+#include "Super.h"
 #include "util/Debug.h"
 #include "util/String.h"
@@ -224 +226 @@
             static Identifier* getIdentifierSingleton(const std::string& name, Identifier* proposal);
 
+            virtual void createSuperFunctionCaller() const = 0;
+
             /** @brief Returns the map that stores all Identifiers. @return The map */
             static std::map<std::string, Identifier*>& getIdentifierMapIntern();
@@ -229 +233 @@
             static std::map<std::string, Identifier*>& getLowercaseIdentifierMapIntern();
 
-            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
-            ObjectListBase* objects_;                                      //!< The list of all objects of this class
-
-        private:
             /** @brief Returns the children of the class the Identifier belongs to. @return The list of all children */
             inline std::set<const Identifier*>& getChildrenIntern() const { return (*this->children_); }
@@ -238 +238 @@
             inline std::set<const Identifier*>& getDirectChildrenIntern() const { return (*this->directChildren_); }
 
+            bool bCreatedOneObject_;                                       //!< True if at least one object of the given type was created (used to determine the need of storing the parents)
+            ObjectListBase* objects_;                                      //!< The list of all objects of this class
+
+        private:
             /**
                 @brief Increases the hierarchyCreatingCounter_s variable, causing all new objects to store their parents.
@@ -295 +299 @@
     class ClassIdentifier : public Identifier
     {
+        #define SUPER_INTRUSIVE_DECLARATION
+        #include "Super.h"
+
         public:
             static ClassIdentifier<T> *getIdentifier();
@@ -311 +318 @@
 
         private:
-            ClassIdentifier() {}
+            ClassIdentifier()
+            {
+                #define SUPER_INTRUSIVE_CONSTRUCTOR
+                #include "Super.h"
+            }
             ClassIdentifier(const ClassIdentifier<T>& identifier) {}    // don't copy
             ~ClassIdentifier() {}                                       // don't delete

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;
+                }
+            }
+        }
+    };
 }