Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 10392


Ignore:
Timestamp:
Apr 23, 2015, 10:44:57 PM (10 years ago)
Author:
landauf
Message:

Loader is now a singleton instead of a static class. fixes issue with statically initialized ClassTreeMask (which again requires a BaseObject-Identifier)

Location:
code/branches/core7/src
Files:
10 edited

Legend:

Unmodified
Added
Removed

  • code/branches/core7/src/libraries/core/Core.cc

    r10362 r10392  
    7070#include "class/Identifier.h"
    7171#include "Language.h"
     72#include "Loader.h"
    7273#include "LuaState.h"
    7374#include "command/ConsoleCommandManager.h"
    … …  
    102103        , configFileManager_(NULL)
    103104        , languageInstance_(NULL)
     105        , loaderInstance_(NULL)
    104106        , ioConsole_(NULL)
    105107        , tclBind_(NULL)
    … …  
    208210        IdentifierManager::getInstance().createClassHierarchy();
    209211
     212        // Loader
     213        this->loaderInstance_ = new Loader();
     214
    210215        // Load OGRE excluding the renderer and the render window
    211216        orxout(internal_info) << "creating GraphicsManager:" << endl;
    … …  
    253258        safeObjectDelete(&tclBind_);
    254259        safeObjectDelete(&ioConsole_);
     260        safeObjectDelete(&loaderInstance_);
    255261        safeObjectDelete(&languageInstance_);
    256262        safeObjectDelete(&configFileManager_);

  • code/branches/core7/src/libraries/core/Core.h

    r9667 r10392  
    125125            ConfigFileManager*        configFileManager_;
    126126            Language*                 languageInstance_;
     127            Loader*                   loaderInstance_;
    127128            IOConsole*                ioConsole_;
    128129            TclBind*                  tclBind_;

  • code/branches/core7/src/libraries/core/CorePrereqs.h

    r10346 r10392  
    165165    class Language;
    166166    class Listable;
     167    class Loader;
    167168    class LuaFunctor;
    168169    class LuaState;

  • code/branches/core7/src/libraries/core/GraphicsManager.cc

    r10380 r10392  
    117117        resources_.reset(new XMLFile("DefaultResources.oxr"));
    118118        resources_->setLuaSupport(false);
    119         Loader::open(resources_.get(), ClassTreeMask(), false);
     119        Loader::getInstance().open(resources_.get(), ClassTreeMask(), false);
    120120
    121121        // Only for runs in the build directory (not installed)
    … …  
    125125        extResources_.reset(new XMLFile("resources.oxr"));
    126126        extResources_->setLuaSupport(false);
    127         Loader::open(extResources_.get(), ClassTreeMask(), false);
     127        Loader::getInstance().open(extResources_.get(), ClassTreeMask(), false);
    128128
    129129        if (bLoadRenderer)
    … …  
    140140        orxout(internal_status) << "destroying GraphicsManager..." << endl;
    141141
    142         Loader::unload(debugOverlay_.get());
     142        Loader::getInstance().unload(debugOverlay_.get());
    143143
    144144        Ogre::WindowEventUtilities::removeWindowEventListener(renderWindow_, ogreWindowEventListener_);
    … …  
    149149
    150150        // Undeclare the resources
    151         Loader::unload(resources_.get());
    152         Loader::unload(extResources_.get());
     151        Loader::getInstance().unload(resources_.get());
     152        Loader::getInstance().unload(extResources_.get());
    153153
    154154        safeObjectDelete(&ogreRoot_);
    … …  
    330330        orxout(internal_info) << "Loading Debug Overlay..." << endl;
    331331        debugOverlay_.reset(new XMLFile("debug.oxo"));
    332         Loader::open(debugOverlay_.get(), ClassTreeMask(), false);
     332        Loader::getInstance().open(debugOverlay_.get(), ClassTreeMask(), false);
    333333    }
    334334

  • code/branches/core7/src/libraries/core/Loader.cc

    r10278 r10392  
    4848namespace orxonox
    4949{
    50     std::vector<std::pair<const XMLFile*, ClassTreeMask> > Loader::files_s;
    51     ClassTreeMask Loader::currentMask_s;
     50    Loader* Loader::singletonPtr_s = 0;
    5251
    5352    bool Loader::open(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
    5453    {
    55         Loader::add(file, mask);
    56         return Loader::load(file, mask, bVerbose);
     54        this->add(file, mask);
     55        return this->load(file, mask, bVerbose);
    5756    }
    5857
    5958    void Loader::close()
    6059    {
    61         Loader::unload();
    62         Loader::files_s.clear();
     60        this->unload();
     61        this->files_.clear();
    6362    }
    6463
    6564    void Loader::close(const XMLFile* file)
    6665    {
    67         Loader::unload(file);
    68         Loader::remove(file);
     66        this->unload(file);
     67        this->remove(file);
    6968    }
    7069
    … …  
    7372        if (!file)
    7473            return;
    75         Loader::files_s.insert(Loader::files_s.end(), std::pair<const XMLFile*, ClassTreeMask>(file, mask));
     74        this->files_.insert(this->files_.end(), std::pair<const XMLFile*, ClassTreeMask>(file, mask));
    7675    }
    7776
    … …  
    8079        if (!file)
    8180            return;
    82         for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
     81        for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = this->files_.begin(); it != this->files_.end(); ++it)
    8382        {
    8483            if (it->first == file)
    8584            {
    86                 Loader::files_s.erase(it);
     85                this->files_.erase(it);
    8786                break;
    8887            }
    … …  
    103102    {
    104103        bool success = true;
    105         for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = Loader::files_s.begin(); it != Loader::files_s.end(); ++it)
    106             if (!Loader::load(it->first, it->second * mask, bVerbose))
     104        for (std::vector<std::pair<const XMLFile*, ClassTreeMask> >::iterator it = this->files_.begin(); it != this->files_.end(); ++it)
     105            if (!this->load(it->first, it->second * mask, bVerbose))
    107106                success = false;
    108107
    … …  
    133132    bool Loader::reload(const ClassTreeMask& mask, bool bVerbose)
    134133    {
    135         Loader::unload(mask);
    136         return Loader::load(mask, bVerbose);
     134        this->unload(mask);
     135        return this->load(mask, bVerbose);
    137136    }
    138137
    … …  
    156155            return false;
    157156
    158         Loader::currentMask_s = file->getMask() * mask;
     157        this->currentMask_ = file->getMask() * mask;
    159158
    160159        std::string xmlInput;
    … …  
    189188                // start of the program.
    190189                // Assumption: the LevelInfo tag does not use Lua scripting
    191                 xmlInput = removeLuaTags(xmlInput);
     190                xmlInput = Loader::removeLuaTags(xmlInput);
    192191            }
    193192        }
    … …  
    198197            {
    199198                orxout(user_info) << "Start loading " << file->getFilename() << "..." << endl;
    200                 orxout(internal_info, context::loader) << "Mask: " << Loader::currentMask_s << endl;
     199                orxout(internal_info, context::loader) << "Mask: " << this->currentMask_ << endl;
    201200            }
    202201            else
    203202            {
    204203                orxout(verbose, context::loader) << "Start loading " << file->getFilename() << "..." << endl;
    205                 orxout(verbose_more, context::loader) << "Mask: " << Loader::currentMask_s << endl;
     204                orxout(verbose_more, context::loader) << "Mask: " << this->currentMask_ << endl;
    206205            }
    207206
    … …  
    319318    bool Loader::reload(const XMLFile* file, const ClassTreeMask& mask, bool bVerbose)
    320319    {
    321         Loader::unload(file, mask);
    322         return Loader::load(file, mask, bVerbose);
     320        this->unload(file, mask);
     321        return this->load(file, mask, bVerbose);
    323322    }
    324323

  • code/branches/core7/src/libraries/core/Loader.h

    r8858 r10392  
    4444#include <map>
    4545#include <vector>
     46
     47#include "util/Singleton.h"
    4648#include "ClassTreeMask.h"
    4749
    4850namespace orxonox
    4951{
    50     class _CoreExport Loader
     52    class _CoreExport Loader : public Singleton<Loader>
    5153    {
     54        friend class Singleton<Loader>;
     55
    5256        public:
    53             static bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
    54             static void close();
    55             static void close(const XMLFile* file);
     57            bool open(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
     58            void close();
     59            void close(const XMLFile* file);
    5660
    57             static void add(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
    58             static void remove(const XMLFile* file);
     61            void add(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
     62            void remove(const XMLFile* file);
    5963
    60             static bool load(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
    61             static void unload(const ClassTreeMask& mask = ClassTreeMask());
    62             static bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
     64            bool load(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
     65            void unload(const ClassTreeMask& mask = ClassTreeMask());
     66            bool reload(const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
    6367
    64             static bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(),
    65                              bool bVerbose = true, bool bRemoveLuaTags = false);
    66             static void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
    67             static bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
     68            bool load(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(),
     69                      bool bVerbose = true, bool bRemoveLuaTags = false);
     70            void unload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask());
     71            bool reload(const XMLFile* file, const ClassTreeMask& mask = ClassTreeMask(), bool bVerbose = true);
    6872
    6973            static std::string replaceLuaTags(const std::string& text);
    7074            static std::string removeLuaTags(const std::string& text);
    7175
    72             static ClassTreeMask currentMask_s;
     76            ClassTreeMask currentMask_;
    7377
    7478        private:
    7579            static bool getLuaTags(const std::string& text, std::map<size_t, bool>& luaTags);
    7680
    77             static std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_s;
     81            std::vector<std::pair<const XMLFile*, ClassTreeMask> > files_;
     82
     83            static Loader* singletonPtr_s;
    7884    };
    7985}

  • code/branches/core7/src/libraries/core/XMLPort.cc

    r9667 r10392  
    4040    bool XMLPortObjectContainer::identifierIsIncludedInLoaderMask(const Identifier* identifier)
    4141    {
    42         return ((!this->bApplyLoaderMask_) || identifier->isA(ClassIdentifier<Namespace>::getIdentifier()) || Loader::currentMask_s.isIncluded(identifier));
     42        return ((!this->bApplyLoaderMask_) || identifier->isA(ClassIdentifier<Namespace>::getIdentifier()) || Loader::getInstance().currentMask_.isIncluded(identifier));
    4343    }
    4444

  • code/branches/core7/src/orxonox/Level.cc

    r9667 r10392  
    6363
    6464            if (this->xmlfile_)
    65                 Loader::unload(this->xmlfile_);
     65                Loader::getInstance().unload(this->xmlfile_);
    6666        }
    6767    }
    … …  
    9595        this->xmlfile_ = new XMLFile(mask, this->xmlfilename_);
    9696
    97         Loader::open(this->xmlfile_);
     97        Loader::getInstance().open(this->xmlfile_);
    9898    }
    9999

  • code/branches/core7/src/orxonox/LevelManager.cc

    r10380 r10392  
    276276                // Load the LevelInfo object from the level file.
    277277                XMLFile file = XMLFile(*it);
    278                 Loader::load(&file, mask, false, true);
     278                Loader::getInstance().load(&file, mask, false, true);
    279279
    280280                // Find the LevelInfo object we've just loaded (if there was one)
    … …  
    284284
    285285                // We don't need the loaded stuff anymore
    286                 Loader::unload(&file);
     286                Loader::getInstance().unload(&file);
    287287
    288288                if(info == NULL)

  • code/branches/core7/src/orxonox/gamestates/GSLevel.cc

    r10362 r10392  
    168168        // call the loader
    169169        startFile_ = new XMLFile(LevelManager::getInstance().getDefaultLevel());
    170         bool loaded = Loader::open(startFile_);
     170        bool loaded = Loader::getInstance().open(startFile_);
    171171
    172172        Core::getInstance().updateLastLevelTimestamp();
    … …  
    177177    void GSLevel::unloadLevel()
    178178    {
    179         Loader::unload(startFile_);
     179        Loader::getInstance().unload(startFile_);
    180180        delete startFile_;
    181181
Note: See TracChangeset for help on using the changeset viewer.