Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Dec 9, 2008, 2:07:24 AM (16 years ago)
Author:
landauf
Message:
  • Fixed a problem with SUPER in combination with a pure-virtual base-function when called from a direct child of the base-class.
  • Added random number generator initialization to Core (configurable)
  • Fixed a bug in Convert.h
Location:
code/branches/objecthierarchy2/src/core
Files:
3 edited

Legend:

Unmodified
Added
Removed

  • code/branches/objecthierarchy2/src/core/Core.cc

    r2344 r2361  
    5656        RegisterRootObject(Core);
    5757
    58         assert(singletonRef_s == 0);
    59         singletonRef_s = this;
     58        assert(this->singletonRef_s == 0);
     59        this->singletonRef_s = this;
     60        this->bInitializeRandomNumberGenerator_ = false;
    6061
    6162        this->setConfigValues();
    … …  
    8081        SetConfigValue(softDebugLevelShell_, 1).description("The maximal level of debug output shown in the ingame shell").callback(this, &Core::debugLevelChanged);
    8182        SetConfigValue(language_, Language::getLanguage().defaultLanguage_).description("The language of the ingame text").callback(this, &Core::languageChanged);
     83        SetConfigValue(bInitializeRandomNumberGenerator_, true).description("If true, all random actions are different each time you start the game").callback(this, &Core::initializeRandomNumberGenerator);
    8284    }
    8385
    … …  
    174176        ResetConfigValue(language_);
    175177    }
     178
     179    void Core::initializeRandomNumberGenerator()
     180    {
     181        static bool bInitialized = false;
     182        if (!bInitialized && this->bInitializeRandomNumberGenerator_)
     183        {
     184            srand(time(0));
     185            rand();
     186            bInitialized = true;
     187        }
     188    }
    176189}

  • code/branches/objecthierarchy2/src/core/Core.h

    r2344 r2361  
    7878            Core(const Core&);
    7979            void resetLanguageIntern();
     80            void initializeRandomNumberGenerator();
    8081
    8182            int softDebugLevel_;                            //!< The debug level
    … …  
    8485            int softDebugLevelShell_;                       //!< The debug level for the ingame shell
    8586            std::string language_;                          //!< The language
     87            bool bInitializeRandomNumberGenerator_;          //!< If true, srand(time(0)) is called
    8688
    8789            static bool bShowsGraphics_s;                   //!< global variable that tells whether to show graphics

  • code/branches/objecthierarchy2/src/core/Super.h

    r2257 r2361  
    9999            \
    100100            static void apply(void* temp) {} \
     101            \
    101102            static void apply(baseclass* temp) \
    102103            { \
    … …  
    104105                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it) \
    105106                { \
     107                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
     108                    { \
     109                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_; \
     110                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0; \
     111                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
     112                    } \
     113                    \
    106114                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_) \
    107115                    { \
    … …  
    163171                for (std::set<const Identifier*>::iterator it = identifier->getDirectChildrenIntern().begin(); it != identifier->getDirectChildrenIntern().end(); ++it)
    164172                {
     173                    // Check if the caller is a fallback-caller
     174                    if (((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ && ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
     175                    {
     176                        // Delete the fallback caller an prepare to get a real caller
     177                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_;
     178                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0;
     179                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false;
     180                    }
     181
    165182                    // Check if there's not already a caller
    166183                    if (!((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_)
    … …  
    183200        struct SuperFunctionCondition<functionnumber, baseclass, 0, templatehack2> \
    184201        { \
    185             // The check function just behaves like the fallback - it advances to the check for the next super-function (functionnumber + 1)
     202            // The check function acts like the fallback - it advances to the check for the next super-function (functionnumber + 1)
    186203            static void check() \
    187204            { \
    … …  
    301318            }; \
    302319            \
     320            class _CoreExport SuperFunctionCaller_##functionname \
     321            { \
     322                public: \
     323                    virtual void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) = 0; \
     324                    virtual ~SuperFunctionCaller_##functionname () {} \
     325            }; \
     326            \
     327            template <class T> \
     328            class SuperFunctionClassCaller_purevirtualfallback_##functionname : public SuperFunctionCaller_##functionname \
     329            { \
     330                public: \
     331                    inline void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) \
     332                    { \
     333                    } \
     334            }; \
     335            \
    303336            template <class T> \
    304337            struct SuperFunctionInitialization<functionnumber, T> \
    … …  
    306339                static void initialize(ClassIdentifier<T>* identifier) \
    307340                { \
    308                     identifier->superFunctionCaller_##functionname##_ = 0; \
     341                    identifier->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_purevirtualfallback_##functionname <T>; \
     342                    identifier->bSuperFunctionCaller_##functionname##_isFallback_ = true; \
    309343                    SuperFunctionInitialization<functionnumber + 1, T>::initialize(identifier); \
    310344                } \
    … …  
    322356            }; \
    323357            \
    324             class _CoreExport SuperFunctionCaller_##functionname \
    325             { \
    326                 public: \
    327                     virtual void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) = 0; \
    328                     virtual ~SuperFunctionCaller_##functionname () {} \
    329             }; \
    330             \
    331358            template <class T> \
    332359            class SuperFunctionClassCaller_##functionname : public SuperFunctionCaller_##functionname \
    … …  
    375402        };
    376403
    377         // Initializes the SuperFunctionCaller-pointer with zero.
     404        // Baseclass of the super-function caller. The real call will be done by a
     405        // templatized subclass through the virtual () operator.
     406        class _CoreExport SuperFunctionCaller_##functionname
     407        {
     408            public:
     409                virtual void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) = 0;
     410                virtual ~SuperFunctionCaller_##functionname () {}
     411        };
     412
     413        // Fallback if the base is pure virtual
     414        template <class T>
     415        class SuperFunctionClassCaller_purevirtualfallback_##functionname : public SuperFunctionCaller_##functionname
     416        {
     417            public:
     418                // Fallback does nothing
     419                inline void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) )
     420                {
     421                }
     422        };
     423
     424        // Initializes the SuperFunctionCaller-pointer with a fallback caller in case the base function is pure virtual
    378425        template <class T>
    379426        struct SuperFunctionInitialization<functionnumber, T>
    … …  
    381428            static void initialize(ClassIdentifier<T>* identifier)
    382429            {
    383                 identifier->superFunctionCaller_##functionname##_ = 0;
     430                identifier->superFunctionCaller_##functionname##_ = new SuperFunctionClassCaller_purevirtualfallback_##functionname <T>;
     431                identifier->bSuperFunctionCaller_##functionname##_isFallback_ = true;
    384432
    385433                // Calls the initialization of the next super-function (functionnumber + 1)
    … …  
    400448                SuperFunctionDestruction<functionnumber + 1, T>::destroy(identifier);
    401449            }
    402         };
    403 
    404         // Baseclass of the super-function caller. The real call will be done by a
    405         // templatized subclass through the virtual () operator.
    406         class _CoreExport SuperFunctionCaller_##functionname
    407         {
    408             public:
    409                 virtual void operator()( SUPER_CALL_ARGUMENTS##hasarguments(__VA_ARGS__) ) = 0;
    410                 virtual ~SuperFunctionCaller_##functionname () {}
    411450        };
    412451
    … …  
    497536        #ifndef SUPER_INTRUSIVE_DECLARATION
    498537          #define SUPER_INTRUSIVE_DECLARATION(functionname) \
    499             SuperFunctionCaller_##functionname * superFunctionCaller_##functionname##_
     538            SuperFunctionCaller_##functionname * superFunctionCaller_##functionname##_; \
     539            bool bSuperFunctionCaller_##functionname##_isFallback_
    500540        #endif
    501541
Note: See TracChangeset for help on using the changeset viewer.