Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Nov 6, 2015, 10:54:34 PM (9 years ago)
Author:
landauf
Message:

replace '0' by 'nullptr'

Location:
code/branches/cpp11_v2/src/libraries
Files:
88 edited

Legend:

Unmodified
Added
Removed

  • code/branches/cpp11_v2/src/libraries/core/ApplicationPaths.cc

    r10765 r10768  
    6868
    6969    //! Static pointer to the singleton
    70     ApplicationPaths* ApplicationPaths::singletonPtr_s  = 0;
     70    ApplicationPaths* ApplicationPaths::singletonPtr_s  = nullptr;
    7171
    7272    ApplicationPaths::ApplicationPaths()

  • code/branches/cpp11_v2/src/libraries/core/BaseObject.cc

    r10765 r10768  
    6565        this->bRegisteredEventStates_ = false;
    6666
    67         this->lastLoadedXMLElement_ = 0;
    68 
    69         this->mainStateFunctor_ = 0;
     67        this->lastLoadedXMLElement_ = nullptr;
     68
     69        this->mainStateFunctor_ = nullptr;
    7070
    7171        if (context)
    … …  
    8686        else
    8787        {
    88             this->file_ = 0;
     88            this->file_ = nullptr;
    8989            this->sceneID_ = OBJECTID_UNKNOWN;
    9090        }
    … …  
    132132        XMLPortObject(BaseObject, BaseObject, "eventlisteners", addEventListener, getEventListener, xmlelement, mode);
    133133
    134         Element* events = 0;
     134        Element* events = nullptr;
    135135        if (mode == XMLPort::LoadObject || mode == XMLPort::ExpandObject)
    136136            events = xmlelement.FirstChildElement("events", false);
    … …  
    240240            i++;
    241241        }
    242         return 0;
     242        return nullptr;
    243243    }
    244244
    … …  
    278278            ++i;
    279279        }
    280         return 0;
     280        return nullptr;
    281281    }
    282282
    … …  
    302302            ++i;
    303303        }
    304         return 0;
     304        return nullptr;
    305305    }
    306306
    … …  
    331331            return (it->second);
    332332        else
    333             return 0;
     333            return nullptr;
    334334    }
    335335
    … …  
    423423    void BaseObject::changedMainStateName()
    424424    {
    425         this->mainStateFunctor_ = 0;
     425        this->mainStateFunctor_ = nullptr;
    426426
    427427        if (!this->mainStateName_.empty())

  • code/branches/cpp11_v2/src/libraries/core/BaseObject.h

    r10765 r10768  
    218218            bool                       bInitialized_;          //!< True if the object was initialized (passed the object registration)
    219219            const XMLFile*             file_;                  //!< The XMLFile that loaded this object
    220             Element*                   lastLoadedXMLElement_;  //!< Non 0 if the TinyXML attributes have already been copied to our own lowercase map
     220            Element*                   lastLoadedXMLElement_;  //!< Non nullptr if the TinyXML attributes have already been copied to our own lowercase map
    221221            std::map<std::string, std::string> xmlAttributes_; //!< Lowercase XML attributes
    222222            std::string                loaderIndentation_;     //!< Indentation of the debug output in the Loader

  • code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.cc

    r10624 r10768  
    207207            return ((*this->nodes_.top().first) == compare);
    208208        else
    209             return (compare == 0);
     209            return (compare == nullptr);
    210210    }
    211211
    … …  
    218218            return ((*this->nodes_.top().first) != compare);
    219219        else
    220             return (compare != 0);
     220            return (compare != nullptr);
    221221    }
    222222

  • code/branches/cpp11_v2/src/libraries/core/ClassTreeMask.h

    r10693 r10768  
    211211            inline const ClassTreeMask& begin() const { return (*this); }
    212212            /// End of the ClassTreeMaskObjectIterator.
    213             inline BaseObject*          end()   const { return 0; }
     213            inline BaseObject*          end()   const { return nullptr; }
    214214
    215215            ClassTreeMask& operator=(const ClassTreeMask& other);
    … …  
    285285
    286286            /// Returns true if the ClassTreeMaskObjectIterator points at the given object.
    287             inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == 0); }
     287            inline bool operator==(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) == pointer) || (!this->objectIterator_ && pointer == nullptr); }
    288288            /// Returns true if the ClassTreeMaskObjectIterator doesn't point at the given object.
    289             inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != 0); }
     289            inline bool operator!=(BaseObject* pointer) const { return (this->objectIterator_ && (*this->objectIterator_) != pointer) || (!this->objectIterator_ && pointer != nullptr); }
    290290            /// Returns true if the ClassTreeMaskObjectIterator hasn't already reached the end.
    291291            inline operator bool() const { return (this->objectIterator_); }

  • code/branches/cpp11_v2/src/libraries/core/ConfigurablePaths.cc

    r10765 r10768  
    6767
    6868    //! Static pointer to the singleton
    69     ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = 0;
     69    ConfigurablePaths* ConfigurablePaths::singletonPtr_s  = nullptr;
    7070
    7171    SetCommandLineArgument(externalDataPath, "").information("Path to the external data files");

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

    r10765 r10768  
    8383{
    8484    //! Static pointer to the singleton
    85     Core* Core::singletonPtr_s  = 0;
     85    Core* Core::singletonPtr_s  = nullptr;
    8686
    8787    SetCommandLineArgument(settingsFile, "orxonox.ini").information("THE configuration file");

  • code/branches/cpp11_v2/src/libraries/core/GUIManager.cc

    r10765 r10768  
    248248    static CEGUI::MouseButton convertButton(MouseButtonCode::ByEnum button);
    249249
    250     GUIManager* GUIManager::singletonPtr_s = 0;
     250    GUIManager* GUIManager::singletonPtr_s = nullptr;
    251251    /*static*/ const std::string GUIManager::defaultScheme_ = "TaharezGreen"; //Alternative: Orxonox (not fully complete yet, see the graphics menu)
    252252
    … …  
    337337        // Create the CEGUI system singleton
    338338#ifdef ORXONOX_OLD_CEGUI
    339         guiSystem_ = new System(guiRenderer_, resourceProvider_, 0, scriptModule_);
     339        guiSystem_ = new System(guiRenderer_, resourceProvider_, nullptr, scriptModule_);
    340340        // Add functions that have been renamed in newer versions
    341341        luaState_->doString("CEGUI.SchemeManager.create = CEGUI.SchemeManager.loadScheme");
    … …  
    343343        luaState_->doString("CEGUI.ImagesetManager.createFromImageFile= CEGUI.ImagesetManager.createImagesetFromImageFile");
    344344#else
    345         guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, 0, imageCodec_, scriptModule_);
     345        guiSystem_ = &System::create(*guiRenderer_, resourceProvider_, nullptr, imageCodec_, scriptModule_);
    346346#endif
    347347
    … …  
    468468#ifdef ORXONOX_OLD_CEGUI
    469469        if (camera == nullptr)
    470             this->guiRenderer_->setTargetSceneManager(0);
     470            this->guiRenderer_->setTargetSceneManager(nullptr);
    471471        else
    472472            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());

  • code/branches/cpp11_v2/src/libraries/core/GUIManager.h

    r9675 r10768  
    135135        inline void setPlayer(const std::string& guiname, PlayerInfo* player)
    136136            { this->players_[guiname] = player; }
    137         inline orxonox::PlayerInfo* getPlayer(const std::string& guiname) const { std::map<std::string, PlayerInfo*>::const_iterator it = this->players_.find(guiname); return (it != this->players_.end()) ? it->second : 0; } // tolua_export
     137        inline orxonox::PlayerInfo* getPlayer(const std::string& guiname) const { std::map<std::string, PlayerInfo*>::const_iterator it = this->players_.find(guiname); return (it != this->players_.end()) ? it->second : nullptr; } // tolua_export
    138138
    139139        // TODO: Temporary hack because the tolua exported CEGUI method does not seem to work

  • code/branches/cpp11_v2/src/libraries/core/Game.cc

    r10765 r10768  
    6666
    6767    std::map<std::string, GameStateInfo> Game::gameStateDeclarations_s;
    68     Game* Game::singletonPtr_s = 0;
     68    Game* Game::singletonPtr_s = nullptr;
    6969
    7070    //! Represents one node of the game state tree.

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

    r10765 r10768  
    9393    };
    9494
    95     GraphicsManager* GraphicsManager::singletonPtr_s = 0;
     95    GraphicsManager* GraphicsManager::singletonPtr_s = nullptr;
    9696
    9797    RegisterAbstractClass(GraphicsManager).inheritsFrom<Configurable>();
    … …  
    9999    GraphicsManager::GraphicsManager(bool bLoadRenderer)
    100100        : ogreWindowEventListener_(new OgreWindowEventListener())
    101         , renderWindow_(0)
    102         , viewport_(0)
     101        , renderWindow_(nullptr)
     102        , viewport_(nullptr)
    103103        , lastFrameStartTime_(0.0f)
    104104        , lastFrameEndTime_(0.0f)
    … …  
    304304        //       But in our case we only have one viewport for now anyway, therefore
    305305        //       no ScopeGuards or anything to handle exceptions.
    306         this->viewport_ = this->renderWindow_->addViewport(0, 0);
     306        this->viewport_ = this->renderWindow_->addViewport(nullptr, 0);
    307307
    308308        Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(Ogre::MIP_UNLIMITED);
    … …  
    312312        HWND hwnd;
    313313        this->renderWindow_->getCustomAttribute("WINDOW", (void*)&hwnd);
    314         LONG iconID = (LONG)LoadIcon(GetModuleHandle(0), MAKEINTRESOURCE(101));
     314        LONG iconID = (LONG)LoadIcon(GetModuleHandle(nullptr), MAKEINTRESOURCE(101));
    315315        SetClassLong(hwnd, GCL_HICON, iconID);
    316316#endif

  • code/branches/cpp11_v2/src/libraries/core/Language.cc

    r10624 r10768  
    8888    // ###############################
    8989
    90     Language* Language::singletonPtr_s = 0;
     90    Language* Language::singletonPtr_s = nullptr;
    9191
    9292    /**

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

    r10765 r10768  
    4848namespace orxonox
    4949{
    50     Loader* Loader::singletonPtr_s = 0;
     50    Loader* Loader::singletonPtr_s = nullptr;
    5151
    5252    /**

  • code/branches/cpp11_v2/src/libraries/core/Namespace.cc

    r10624 r10768  
    109109    const BaseObject* Namespace::saveObjects(unsigned int index) const
    110110    {
    111         return 0; // todo
     111        return nullptr; // todo
    112112    }
    113113

  • code/branches/cpp11_v2/src/libraries/core/NamespaceNode.h

    r7401 r10768  
    4646    {
    4747        public:
    48             NamespaceNode(const std::string& name, NamespaceNode* parent = 0);
     48            NamespaceNode(const std::string& name, NamespaceNode* parent = nullptr);
    4949            ~NamespaceNode();
    5050

  • code/branches/cpp11_v2/src/libraries/core/Template.cc

    r9667 r10768  
    4949        this->bLoadDefaults_ = true;
    5050        this->bIsReturningXMLElement_ = false;
    51         this->baseclassIdentifier_ = 0;
     51        this->baseclassIdentifier_ = nullptr;
    5252    }
    5353
    … …  
    176176        {
    177177            orxout(internal_warning, context::templates) << "Template with name " << name << " doesn't exist." << endl;
    178             return 0;
     178            return nullptr;
    179179        }
    180180    }

  • code/branches/cpp11_v2/src/libraries/core/Thread.cc

    r8399 r10768  
    4848
    4949    Thread::Thread():
    50         executor_(0),
     50        executor_(nullptr),
    5151        isWorking_(false),
    5252        stopThread_(false)
    … …  
    102102                (*executor)();
    103103                this->executorMutex_->lock();
    104                 this->executor_ = 0;
     104                this->executor_ = nullptr;
    105105                this->executorMutex_->unlock();
    106106                this->isWorkingMutex_->lock();

  • code/branches/cpp11_v2/src/libraries/core/ThreadWin.cc

    r8706 r10768  
    4545
    4646    Thread::Thread():
    47         executor_(0),
     47        executor_(nullptr),
    4848        isWorking_(false),
    4949        stopThread_(false)
    … …  
    101101//                 (*executor)();
    102102//                 this->executorMutex_->lock();
    103 //                 this->executor_ = 0;
     103//                 this->executor_ = nullptr;
    104104//                 this->executorMutex_->unlock();
    105105//                 this->isWorkingMutex_->lock();

  • code/branches/cpp11_v2/src/libraries/core/XMLPort.h

    r9667 r10768  
    245245            return my_added_objects[index];
    246246          else
    247             return 0;
     247            return nullptr;
    248248        }
    249249      @endcode
    … …  
    399399                            // Iterate through the attributes manually in order to make them case insensitive
    400400                            ticpp::Attribute* attribute = xmlelement.FirstAttribute(false);
    401                             while (attribute != 0)
     401                            while (attribute != nullptr)
    402402                            {
    403403                                this->owner_->xmlAttributes_[getLowercase(attribute->Name())] = attribute->Value();

  • code/branches/cpp11_v2/src/libraries/core/class/Identifiable.cc

    r10624 r10768  
    4848    Identifiable::Identifiable()
    4949    {
    50         this->identifier_ = 0;
     50        this->identifier_ = nullptr;
    5151        this->objectPointers_.reserve(6); // Optimisation
    5252

  • code/branches/cpp11_v2/src/libraries/core/class/Identifier.cc

    r10624 r10768  
    117117            orxout(user_error) << "Aborting..." << endl;
    118118            abort();
    119             return 0;
     119            return nullptr;
    120120        }
    121121    }
    … …  
    393393            return it->second;
    394394        else
    395             return 0;
     395            return nullptr;
    396396    }
    397397
    … …  
    407407            return it->second;
    408408        else
    409             return 0;
     409            return nullptr;
    410410    }
    411411
    … …  
    438438            return it->second;
    439439        else
    440             return 0;
     440            return nullptr;
    441441    }
    442442

  • code/branches/cpp11_v2/src/libraries/core/class/Identifier.h

    r10765 r10768  
    5656    object->getIdentifier()->getName();                                         // returns "MyClass"
    5757
    58     Identifiable* other = object->getIdentifier()->fabricate(0);                // fabricates a new instance of MyClass
     58    Identifiable* other = object->getIdentifier()->fabricate(nullptr);                // fabricates a new instance of MyClass
    5959
    6060
    … …  
    137137
    138138            /// Returns true if the Identifier has a Factory.
    139             inline bool hasFactory() const { return (this->factory_ != 0); }
     139            inline bool hasFactory() const { return (this->factory_ != nullptr); }
    140140
    141141            Identifiable* fabricate(Context* context);
    … …  
    297297
    298298            virtual bool canDynamicCastObjectToIdentifierClass(Identifiable* object) const
    299                 { return dynamic_cast<T*>(object) != 0; }
     299                { return dynamic_cast<T*>(object) != nullptr; }
    300300
    301301            virtual void destroyObjects();
    … …  
    408408    void ClassIdentifier<T>::destroyObjects()
    409409    {
    410         this->destroyObjects((T*)0);
     410        this->destroyObjects((T*)nullptr);
    411411    }
    412412

  • code/branches/cpp11_v2/src/libraries/core/class/IdentifierManager.cc

    r10765 r10768  
    4444namespace orxonox
    4545{
    46     IdentifierManager* IdentifierManager::singletonPtr_s = 0;
     46    IdentifierManager* IdentifierManager::singletonPtr_s = nullptr;
    4747
    4848    IdentifierManager::IdentifierManager()
    … …  
    221221            return it->second;
    222222        else
    223             return 0;
     223            return nullptr;
    224224    }
    225225
    … …  
    235235            return it->second;
    236236        else
    237             return 0;
     237            return nullptr;
    238238    }
    239239
    … …  
    249249            return it->second;
    250250        else
    251             return 0;
     251            return nullptr;
    252252    }
    253253
    … …  
    263263            if ((*it)->getTypeInfo() == typeInfo)
    264264                return (*it);
    265         return 0;
     265        return nullptr;
    266266    }
    267267

  • code/branches/cpp11_v2/src/libraries/core/class/SubclassIdentifier.h

    r10765 r10768  
    189189                    orxout(user_error) << "Aborting..." << endl;
    190190                    abort();
    191                     return 0;
     191                    return nullptr;
    192192                }
    193193            }

  • code/branches/cpp11_v2/src/libraries/core/class/Super.h

    r10624 r10768  
    9494            static void superCheck() \
    9595            { \
    96                 SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0)); \
     96                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr)); \
    9797                SuperFunctionCondition<functionnumber + 1, T, 0, templatehack2>::superCheck(); \
    9898            } \
    … …  
    108108                    { \
    109109                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_; \
    110                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0; \
     110                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = nullptr; \
    111111                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false; \
    112112                    } \
    … …  
    154154                // This call to the apply-function is the whole check. By calling the function with
    155155                // a T* pointer, the right function get's called.
    156                 SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(0));
     156                SuperFunctionCondition<functionnumber, T, 0, templatehack2>::apply(static_cast<T*>(nullptr));
    157157
    158158                // Go go the superCheck for of next super-function (functionnumber + 1)
    … …  
    178178                        // Delete the fallback caller an prepare to get a real caller
    179179                        delete ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_;
    180                         ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = 0;
     180                        ((ClassIdentifier<T>*)(*it))->superFunctionCaller_##functionname##_ = nullptr;
    181181                        ((ClassIdentifier<T>*)(*it))->bSuperFunctionCaller_##functionname##_isFallback_ = false;
    182182                    }

  • code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.cc

    r10765 r10768  
    5454    void CommandEvaluation::initialize(const std::string& command)
    5555    {
    56         this->execCommand_ = 0;
    57         this->hintCommand_ = 0;
     56        this->execCommand_ = nullptr;
     57        this->hintCommand_ = nullptr;
    5858        this->string_ = command;
    5959        this->execArgumentsOffset_ = 0;

  • code/branches/cpp11_v2/src/libraries/core/command/CommandEvaluation.h

    r10765 r10768  
    8686
    8787            int execute();
    88             MultiType query(int* error = 0);
     88            MultiType query(int* error = nullptr);
    8989
    9090            std::string complete();
    … …  
    9797            /// Returns true if the command evaluation contains a valid command that can be executed.
    9898            inline bool isValid() const
    99                 { return (this->execCommand_ != 0); }
     99                { return (this->execCommand_ != nullptr); }
    100100
    101101            /// Returns the console command that was evaluated by this object.

  • code/branches/cpp11_v2/src/libraries/core/command/CommandExecutor.h

    r8858 r10768  
    113113            static int execute(const std::string& command, bool useTcl = true, bool printErrors = true); // tolua_export
    114114
    115             static MultiType queryMT(const std::string& command, int* error = 0, bool useTcl = true);
    116             static std::string query(const std::string& command, int* error = 0, bool useTcl = true); // tolua_export
     115            static MultiType queryMT(const std::string& command, int* error = nullptr, bool useTcl = true);
     116            static std::string query(const std::string& command, int* error = NULL, bool useTcl = true); // tolua_export
    117117
    118118            static CommandEvaluation evaluate(const std::string& command);

  • code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommand.cc

    r10765 r10768  
    7676
    7777        for (size_t i = 0; i < MAX_FUNCTOR_ARGUMENTS; ++i)
    78             this->argumentCompleter_[i] = 0;
     78            this->argumentCompleter_[i] = nullptr;
    7979
    8080        this->keybindMode_ = KeybindMode::OnPress;
    … …  
    353353    {
    354354        if (this->executor_)
    355             this->executor_->setFunctor(0);
     355            this->executor_->setFunctor(nullptr);
    356356        this->objectStack_.clear();
    357357    }
    … …  
    405405    void ConsoleCommand::popObject()
    406406    {
    407         void* newobject = 0;
     407        void* newobject = nullptr;
    408408        if (!this->objectStack_.empty())
    409409        {
    … …  
    422422            return this->executor_->getFunctor()->getRawObjectPointer();
    423423        else
    424             return 0;
     424            return nullptr;
    425425    }
    426426
    … …  
    528528            return this->argumentCompleter_[index];
    529529        else
    530             return 0;
     530            return nullptr;
    531531    }
    532532

  • code/branches/cpp11_v2/src/libraries/core/command/ConsoleCommandManager.cc

    r10624 r10768  
    3939namespace orxonox
    4040{
    41     ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = 0;
     41    ConsoleCommandManager* ConsoleCommandManager::singletonPtr_s = nullptr;
    4242
    4343    /**
    … …  
    6868                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
    6969        }
    70         return 0;
     70        return nullptr;
    7171    }
    7272
    … …  
    101101                orxout(internal_error, context::commands) << "Couldn't find console command with group \"" << group << "\" and name \"" << name << "\"" << endl;
    102102        }
    103         return 0;
     103        return nullptr;
    104104    }
    105105
    … …  
    125125
    126126        // check if a command with this name already exists
    127         if (this->getCommand(group, name) != 0)
     127        if (this->getCommand(group, name) != nullptr)
    128128        {
    129129            if (group == "")

  • code/branches/cpp11_v2/src/libraries/core/command/Executor.h

    r9550 r10768  
    121121                { return (*this->functor_)(arg1, arg2, arg3, arg4, arg5); }
    122122
    123             MultiType parse(const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
    124             MultiType parse(const SubString& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const;
    125 
    126             int evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error = 0, const std::string& delimiter = " ") const;
     123            MultiType parse(const std::string& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const;
     124            MultiType parse(const SubString& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const;
     125
     126            int evaluateArguments(const SubString& arguments, MultiType arg[MAX_FUNCTOR_ARGUMENTS], int* error = nullptr, const std::string& delimiter = " ") const;
    127127
    128128            /// Changes the functor.
    … …  
    249249
    250250            /// Overloads Executor::parse() with an additional object-pointer.
    251             MultiType parse(T* object, const std::string& arguments, int* error = 0, const std::string& delimiter = " ", bool bPrintError = false) const
     251            MultiType parse(T* object, const std::string& arguments, int* error = nullptr, const std::string& delimiter = " ", bool bPrintError = false) const
    252252            {
    253253                T* oldobject = this->functorMember_->getObject();

  • code/branches/cpp11_v2/src/libraries/core/command/Functor.h

    r10765 r10768  
    242242        public:
    243243            /// Constructor: Stores the object-pointer.
    244             FunctorMember(O* object = 0) : object_(object), bSafeMode_(false) {}
     244            FunctorMember(O* object = nullptr) : object_(object), bSafeMode_(false) {}
    245245            virtual ~FunctorMember() { if (this->bSafeMode_) { this->unregisterObject(this->object_); } }
    246246
    … …  
    310310            /// Will be called by Destroyable::~Destroyable() if the stored object is deleted and the Functor is in safe mode.
    311311            inline void objectDeleted()
    312                 { this->object_ = 0; }
     312                { this->object_ = nullptr; }
    313313
    314314            O* object_;     ///< The stored object-pointer, used to execute a member-function (or nullptr for static functions)
    … …  
    322322        public:
    323323            /// Constructor: Stores the object-pointer.
    324             FunctorMember(void* object = 0) {}
     324            FunctorMember(void* object = nullptr) {}
    325325
    326326            /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be nullptr. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
    … …  
    330330            MultiType operator()(const MultiType& param1 = MultiType::Null, const MultiType& param2 = MultiType::Null, const MultiType& param3 = MultiType::Null, const MultiType& param4 = MultiType::Null, const MultiType& param5 = MultiType::Null)
    331331            {
    332                 return (*this)((void*)0, param1, param2, param3, param4, param5);
     332                return (*this)((void*)nullptr, param1, param2, param3, param4, param5);
    333333            }
    334334
    … …  
    342342            // see Functor::getRawObjectPointer()
    343343            inline void* getRawObjectPointer() const
    344                 { return 0; }
     344                { return nullptr; }
    345345
    346346            // see Functor::setSafeMode()
    … …  
    369369        public:
    370370            /// Constructor: Initializes the base class and stores the function-pointer.
    371             FunctorPointer(F functionPointer, O* object = 0) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
     371            FunctorPointer(F functionPointer, O* object = nullptr) : FunctorMember<O>(object), functionPointer_(functionPointer) {}
    372372
    373373            /// Changes the function-pointer.
    … …  
    494494        public:
    495495            /// Constructor: Initializes the base class.
    496             FunctorTemplate(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object = 0) : FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>(functionPointer, object) {}
     496            FunctorTemplate(typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type functionPointer, O* object = nullptr) : FunctorPointer<typename detail::FunctionPointer<R, O, isconst, P1, P2, P3, P4, P5>::Type, O>(functionPointer, object) {}
    497497
    498498            // see FunctorMember::operator()()

  • code/branches/cpp11_v2/src/libraries/core/command/IOConsolePOSIX.cc

    r10765 r10768  
    6262        , promptString_("orxonox # ")
    6363        , bStatusPrinted_(false)
    64         , originalTerminalSettings_(0)
     64        , originalTerminalSettings_(nullptr)
    6565    {
    6666        this->setTerminalMode();
    … …  
    326326            tcsetattr(0, TCSANOW, IOConsole::singletonPtr_s->originalTerminalSettings_);
    327327            delete IOConsole::singletonPtr_s->originalTerminalSettings_;
    328             IOConsole::singletonPtr_s->originalTerminalSettings_ = 0;
     328            IOConsole::singletonPtr_s->originalTerminalSettings_ = nullptr;
    329329        }
    330330    }

  • code/branches/cpp11_v2/src/libraries/core/command/IRC.cc

    r10624 r10768  
    6666    IRC::IRC()
    6767    {
    68         this->interpreter_ = 0;
     68        this->interpreter_ = nullptr;
    6969    }
    7070

  • code/branches/cpp11_v2/src/libraries/core/command/TclBind.cc

    r10765 r10768  
    4747    SetConsoleCommand("bgerror", &TclBind::bgerror).hide();
    4848
    49     TclBind* TclBind::singletonPtr_s = 0;
     49    TclBind* TclBind::singletonPtr_s = nullptr;
    5050
    5151    /**
    … …  
    5555    TclBind::TclBind(const std::string& datapath)
    5656    {
    57         this->interpreter_ = 0;
     57        this->interpreter_ = nullptr;
    5858        this->bSetTclDataPath_ = false;
    5959        this->setDataPath(datapath);

  • code/branches/cpp11_v2/src/libraries/core/command/TclBind.h

    r8079 r10768  
    121121            static void tcl_execute(Tcl::object const &args);
    122122
    123             static std::string eval(const std::string& tclcode, int* error = 0);
     123            static std::string eval(const std::string& tclcode, int* error = nullptr);
    124124
    125125        private:

  • code/branches/cpp11_v2/src/libraries/core/command/TclThreadManager.cc

    r10624 r10768  
    8686    };
    8787
    88     TclThreadManager* TclThreadManager::singletonPtr_s = 0;
     88    TclThreadManager* TclThreadManager::singletonPtr_s = nullptr;
    8989
    9090    /**
    … …  
    289289        catch (const Tcl::tcl_error& e)
    290290        {
    291             bundle->interpreter_ = 0;
     291            bundle->interpreter_ = nullptr;
    292292            orxout(user_error, context::tcl) << "Tcl error while creating Tcl-interpreter (" << id_string << "): " << e.what() << endl;
    293293        }
    … …  
    521521        {
    522522            TclThreadManager::error("No Tcl-interpreter with ID " + multi_cast<std::string>(id) + " existing.");
    523             return 0;
     523            return nullptr;
    524524        }
    525525    }

  • code/branches/cpp11_v2/src/libraries/core/commandline/CommandLineParser.cc

    r10542 r10768  
    4040namespace orxonox
    4141{
    42     CommandLineParser* CommandLineParser::singletonPtr_s = 0;
     42    CommandLineParser* CommandLineParser::singletonPtr_s = nullptr;
    4343
    4444    /**

  • code/branches/cpp11_v2/src/libraries/core/config/ConfigFile.cc

    r10765 r10768  
    113113        if (file.is_open())
    114114        {
    115             ConfigFileSection* newsection = 0;
     115            ConfigFileSection* newsection = nullptr;
    116116
    117117            while (file.good() && !file.eof())
    … …  
    140140                }
    141141
    142                 if (newsection != 0)
     142                if (newsection != nullptr)
    143143                {
    144144                    if (isComment(line))

  • code/branches/cpp11_v2/src/libraries/core/config/ConfigFileManager.cc

    r10765 r10768  
    4242    ///////////////////////
    4343
    44     ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
     44    ConfigFileManager* ConfigFileManager::singletonPtr_s = nullptr;
    4545
    4646    /// Constructor: Initializes the array of config files with nullptr.

  • code/branches/cpp11_v2/src/libraries/core/config/ConfigValueContainer.cc

    r9559 r10768  
    5353        this->sectionname_ = sectionname;
    5454        this->varname_ = varname;
    55         this->callback_ = 0;
     55        this->callback_ = nullptr;
    5656        this->bContainerIsNew_ = true;
    5757        this->bDoInitialCallback_ = false;

  • code/branches/cpp11_v2/src/libraries/core/config/SettingsConfigFile.cc

    r10765 r10768  
    5757    SetConsoleCommand(__CC_getConfig_name,       &SettingsConfigFile::getConfig).argumentCompleter(0, autocompletion::settingssections()).argumentCompleter(1, autocompletion::settingsentries());
    5858
    59     SettingsConfigFile* SettingsConfigFile::singletonPtr_s = 0;
     59    SettingsConfigFile* SettingsConfigFile::singletonPtr_s = nullptr;
    6060
    6161    /**
    … …  
    7777    SettingsConfigFile::~SettingsConfigFile()
    7878    {
    79         ModifyConsoleCommand(__CC_load_name).setObject(0);
    80         ModifyConsoleCommand(__CC_setFilename_name).setObject(0);
    81         ModifyConsoleCommand(__CC_config_name).setObject(0);
    82         ModifyConsoleCommand(__CC_tconfig_name).setObject(0);
    83         ModifyConsoleCommand(__CC_getConfig_name).setObject(0);
     79        ModifyConsoleCommand(__CC_load_name).setObject(nullptr);
     80        ModifyConsoleCommand(__CC_setFilename_name).setObject(nullptr);
     81        ModifyConsoleCommand(__CC_config_name).setObject(nullptr);
     82        ModifyConsoleCommand(__CC_tconfig_name).setObject(nullptr);
     83        ModifyConsoleCommand(__CC_getConfig_name).setObject(nullptr);
    8484    }
    8585

  • code/branches/cpp11_v2/src/libraries/core/input/Button.cc

    r9983 r10768  
    5353    Button::Button()
    5454        : bButtonThresholdUser_(false)
    55         , paramCommandBuffer_(0)
     55        , paramCommandBuffer_(nullptr)
    5656    {
    5757        nCommands_[0]=0;
    … …  
    7575                    delete commands_[j][i];
    7676                delete[] commands_[j];
    77                 commands_[j] = 0;
     77                commands_[j] = nullptr;
    7878                nCommands_[j] = 0;
    7979            }
    … …  
    206206                        }
    207207                    }
    208                     if (cmd->paramCommand_ == 0)
     208                    if (cmd->paramCommand_ == nullptr)
    209209                    {
    210210                        cmd->paramCommand_ = new BufferedParamCommand();
    … …  
    239239            }
    240240            else
    241                 commands_[j] = 0;
     241                commands_[j] = nullptr;
    242242        }
    243243    }

  • code/branches/cpp11_v2/src/libraries/core/input/HalfAxis.h

    r7859 r10768  
    4949            : relVal_(0.0f)
    5050            , absVal_(0.0f)
    51             , paramCommands_(0)
     51            , paramCommands_(nullptr)
    5252            , nParamCommands_(0)
    5353            , pressed_(false)

  • code/branches/cpp11_v2/src/libraries/core/input/InputCommands.h

    r9978 r10768  
    103103    {
    104104    public:
    105         ParamCommand() : scale_(1.0f), paramCommand_(0) { }
     105        ParamCommand() : scale_(1.0f), paramCommand_(nullptr) { }
    106106        bool execute(float abs = 1.0f, float rel = 1.0f);
    107107        CommandEvaluation* getEvaluation();
    … …  
    118118            return &this->paramCommand_->evaluation_;
    119119        else
    120             return 0;
     120            return nullptr;
    121121    }
    122122}

  • code/branches/cpp11_v2/src/libraries/core/input/InputManager.cc

    r10765 r10768  
    7272    InputHandler InputHandler::EMPTY;
    7373
    74     InputManager* InputManager::singletonPtr_s = 0;
     74    InputManager* InputManager::singletonPtr_s = nullptr;
    7575
    7676    //! Defines the |= operator for easier use.
    … …  
    9494    InputManager::InputManager()
    9595        : internalState_(Bad)
    96         , oisInputManager_(0)
     96        , oisInputManager_(nullptr)
    9797        , devices_(2)
    9898        , exclusiveMouse_(false)
    99         , emptyState_(0)
    100         , calibratorCallbackHandler_(0)
     99        , emptyState_(nullptr)
     100        , calibratorCallbackHandler_(nullptr)
    101101    {
    102102        RegisterObject(InputManager);
    … …  
    149149        // When loading the devices they should not already be loaded
    150150        assert(internalState_ & Bad);
    151         assert(devices_[InputDeviceEnumerator::Mouse] == 0);
    152         assert(devices_[InputDeviceEnumerator::Keyboard] == 0);
     151        assert(devices_[InputDeviceEnumerator::Mouse] == nullptr);
     152        assert(devices_[InputDeviceEnumerator::Keyboard] == nullptr);
    153153        assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
    154154
    … …  
    294294
    295295        // Reset console commands
    296         ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(0);
    297         ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
     296        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(nullptr);
     297        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(nullptr);
    298298
    299299        orxout(internal_status, context::input) << "InputManager: Destruction complete." << endl;
    … …  
    316316            const std::string& className = device->getClassName();
    317317            delete device;
    318             device = 0;
     318            device = nullptr;
    319319            orxout(verbose, context::input) << className << " destroyed." << endl;
    320320        }
    … …  
    526526    {
    527527        if (name.empty())
    528             return 0;
     528            return nullptr;
    529529        if (statesByName_.find(name) == statesByName_.end())
    530530        {
    … …  
    539539                        orxout(internal_warning, context::input) << "Could not add an InputState with the same priority '"
    540540                            << static_cast<int>(priority) << "' != 0." << endl;
    541                         return 0;
     541                        return nullptr;
    542542                    }
    543543                }
    … …  
    551551        {
    552552            orxout(internal_warning, context::input) << "Could not add an InputState with the same name '" << name << "'." << endl;
    553             return 0;
     553            return nullptr;
    554554        }
    555555    }
    … …  
    561561            return it->second;
    562562        else
    563             return 0;
     563            return nullptr;
    564564    }
    565565

  • code/branches/cpp11_v2/src/libraries/core/input/InputState.cc

    r10765 r10768  
    4040        , bExpired_(true)
    4141        , handlers_(2)
    42         , joyStickHandlerAll_(0)
    43         , enterFunctor_(0)
    44         , leaveFunctor_(0)
     42        , joyStickHandlerAll_(nullptr)
     43        , enterFunctor_(nullptr)
     44        , leaveFunctor_(nullptr)
    4545    {
    4646        if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)

  • code/branches/cpp11_v2/src/libraries/core/input/KeyBinder.cc

    r10765 r10768  
    439439                        {
    440440                            delete[] button->commands_[mode_index];
    441                             button->commands_[mode_index] = 0;
     441                            button->commands_[mode_index] = nullptr;
    442442                        }
    443443

  • code/branches/cpp11_v2/src/libraries/core/input/KeyBinderManager.cc

    r10765 r10768  
    8080
    8181        // Reset console commands
    82         ModifyConsoleCommand(__CC_keybind_name ).setObject(0);
    83         ModifyConsoleCommand(__CC_tkeybind_name).setObject(0);
    84         ModifyConsoleCommand(__CC_unbind_name  ).setObject(0);
    85         ModifyConsoleCommand(__CC_tunbind_name ).setObject(0);
     82        ModifyConsoleCommand(__CC_keybind_name ).setObject(nullptr);
     83        ModifyConsoleCommand(__CC_tkeybind_name).setObject(nullptr);
     84        ModifyConsoleCommand(__CC_unbind_name  ).setObject(nullptr);
     85        ModifyConsoleCommand(__CC_tunbind_name ).setObject(nullptr);
    8686    }
    8787

  • code/branches/cpp11_v2/src/libraries/core/input/Mouse.cc

    r10624 r10768  
    6868    {
    6969#ifdef ORXONOX_PLATFORM_LINUX
    70         ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(0);
    71         ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(0);
     70        ModifyConsoleCommand(__CC_Mouse_name, __CC_grab_name).setObject(nullptr);
     71        ModifyConsoleCommand(__CC_Mouse_name, __CC_ungrab_name).setObject(nullptr);
    7272#endif
    7373    }

  • code/branches/cpp11_v2/src/libraries/core/module/DynLibManager.cc

    r10540 r10768  
    3838    //-----------------------------------------------------------------------
    3939    //! Static pointer to the singleton
    40     DynLibManager* DynLibManager::singletonPtr_s  = 0;
     40    DynLibManager* DynLibManager::singletonPtr_s  = nullptr;
    4141
    4242    //-----------------------------------------------------------------------

  • code/branches/cpp11_v2/src/libraries/core/module/PluginManager.cc

    r10765 r10768  
    4646    SetConsoleCommand("PluginManager", __CC_PluginManager_unload_name, &PluginManager::unloadPlugin);
    4747
    48     PluginManager* PluginManager::singletonPtr_s  = 0;
     48    PluginManager* PluginManager::singletonPtr_s  = nullptr;
    4949
    5050    PluginManager::PluginManager()

  • code/branches/cpp11_v2/src/libraries/core/module/StaticInitializationManager.cc

    r10542 r10768  
    3333namespace orxonox
    3434{
    35     StaticInitializationManager* StaticInitializationManager::singletonPtr_s = 0;
     35    StaticInitializationManager* StaticInitializationManager::singletonPtr_s = nullptr;
    3636
    3737    void StaticInitializationManager::addHandler(StaticInitializationHandler* handler)

  • code/branches/cpp11_v2/src/libraries/core/object/Context.cc

    r10765 r10768  
    4040    RegisterClass(Context);
    4141
    42     Context* Context::rootContext_s = 0;
     42    Context* Context::rootContext_s = nullptr;
    4343
    4444    Context* getContextForInitializationOfOtherContexts()

  • code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.cc

    r9975 r10768  
    5858    ObjectListBase::ObjectListBase()
    5959    {
    60         this->first_ = 0;
    61         this->last_ = 0;
     60        this->first_ = nullptr;
     61        this->last_ = nullptr;
    6262        this->size_ = 0;
    6363    }
    … …  
    7373            ObjectListBaseElement* next = current->next_;
    7474
    75             current->list_ = 0;
    76             current->next_ = 0;
    77             current->prev_ = 0;
     75            current->list_ = nullptr;
     76            current->next_ = nullptr;
     77            current->prev_ = nullptr;
    7878
    7979            current = next;
    … …  
    155155            this->first_ = element->next_; // If there is no prev_, we deleted the first object and have to update the first_ pointer of the list
    156156
    157         element->list_ = 0;
    158         element->next_ = 0;
    159         element->prev_ = 0;
     157        element->list_ = nullptr;
     158        element->next_ = nullptr;
     159        element->prev_ = nullptr;
    160160        --this->size_;
    161161    }

  • code/branches/cpp11_v2/src/libraries/core/object/ObjectListBase.h

    r10736 r10768  
    5757                @param objectBase The object to store
    5858            */
    59             ObjectListBaseElement(Listable* object) : next_(0), prev_(0), objectBase_(object), list_(0) {}
     59            ObjectListBaseElement(Listable* object) : next_(nullptr), prev_(nullptr), objectBase_(object), list_(nullptr) {}
    6060            virtual ~ObjectListBaseElement() { this->removeFromList(); }
    6161
    … …  
    136136            inline ObjectListBaseElement* begin() const { return this->first_; }
    137137            /// Returns a pointer to the element after the last element in the list. Works only with Iterator.
    138             inline ObjectListBaseElement* end() const { return 0; }
     138            inline ObjectListBaseElement* end() const { return nullptr; }
    139139            /// Returns a pointer to the last element in the list. Works only with Iterator.
    140140            inline ObjectListBaseElement* rbegin() const { return this->last_; }
    141141            /// Returns a pointer to the element in front of the first element in the list. Works only with Iterator.
    142             inline ObjectListBaseElement* rend() const { return 0; }
     142            inline ObjectListBaseElement* rend() const { return nullptr; }
    143143
    144144            inline void registerRemovalListener(ObjectListElementRemovalListener* listener) { this->listeners_.push_back(listener); }

  • code/branches/cpp11_v2/src/libraries/core/object/StrongPtr.h

    r10765 r10768  
    138138        public:
    139139            /// Constructor: Initializes the strong pointer with a null pointer.
    140             inline StrongPtr() : pointer_(0), base_(0)
     140            inline StrongPtr() : pointer_(nullptr), base_(nullptr)
    141141            {
    142142            }
    … …  
    237237            inline T* operator->() const
    238238            {
    239                 assert(this->pointer_ != 0);
     239                assert(this->pointer_ != nullptr);
    240240                return this->pointer_;
    241241            }
    … …  
    244244            inline T& operator*() const
    245245            {
    246                 assert(this->pointer_ != 0);
     246                assert(this->pointer_ != nullptr);
    247247                return *this->pointer_;
    248248            }
    … …  
    251251            inline bool operator!() const
    252252            {
    253                 return (this->pointer_ == 0);
     253                return (this->pointer_ == nullptr);
    254254            }
    255255

  • code/branches/cpp11_v2/src/libraries/core/object/WeakPtr.h

    r10765 r10768  
    100100        public:
    101101            /// Constructor: Initializes the weak pointer with a null pointer.
    102             inline WeakPtr() : pointer_(0), base_(0), callback_(0)
     102            inline WeakPtr() : pointer_(nullptr), base_(nullptr), callback_(nullptr)
    103103            {
    104104            }
    105105
    106106            /// Constructor: Initializes the weak pointer with a pointer to an object.
    107             inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(0)
     107            inline WeakPtr(T* pointer) : pointer_(pointer), base_(pointer), callback_(nullptr)
    108108            {
    109109                this->registerAsDestructionListener(this->base_);
    … …  
    111111
    112112            /// Copy-constructor
    113             inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(0)
     113            inline WeakPtr(const WeakPtr& other) : pointer_(other.pointer_), base_(other.base_), callback_(nullptr)
    114114            {
    115115                this->registerAsDestructionListener(this->base_);
    … …  
    118118            /// Copy-constructor for weak pointers to objects of another class.
    119119            template <class O>
    120             inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase()), callback_(0)
     120            inline WeakPtr(const WeakPtr<O>& other) : pointer_(other.get()), base_(other.getBase()), callback_(nullptr)
    121121            {
    122122                this->registerAsDestructionListener(this->base_);
    … …  
    172172            inline T* operator->() const
    173173            {
    174                 assert(this->pointer_ != 0);
     174                assert(this->pointer_ != nullptr);
    175175                return this->pointer_;
    176176            }
    … …  
    179179            inline T& operator*() const
    180180            {
    181                 assert(this->pointer_ != 0);
     181                assert(this->pointer_ != nullptr);
    182182                return *this->pointer_;
    183183            }
    … …  
    186186            inline bool operator!() const
    187187            {
    188                 return (this->pointer_ == 0);
     188                return (this->pointer_ == nullptr);
    189189            }
    190190
    … …  
    232232            inline void objectDeleted()
    233233            {
    234                 this->base_ = 0;
    235                 this->pointer_ = 0;
     234                this->base_ = nullptr;
     235                this->pointer_ = nullptr;
    236236                if (this->callback_)
    237237                    (*this->callback_)();

  • code/branches/cpp11_v2/src/libraries/core/singleton/ScopeManager.cc

    r10542 r10768  
    3838namespace orxonox
    3939{
    40     ScopeManager* ScopeManager::singletonPtr_s = 0;
     40    ScopeManager* ScopeManager::singletonPtr_s = nullptr;
    4141
    4242    void ScopeManager::addScope(ScopeID::Value scope)

  • code/branches/cpp11_v2/src/libraries/network/Connection.cc

    r8858 r10768  
    4646
    4747  Connection::Connection(uint32_t firstPeerID):
    48     host_(0), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
     48    host_(nullptr), bCommunicationThreadRunning_(false), nextPeerID_(firstPeerID)
    4949  {
    5050    enet_initialize();
    … …  
    8181  {
    8282//     this->overallMutex_->lock();
    83     outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, 0, 0 };
     83    outgoingEvent outEvent = { peerID, outgoingEventType::disconnectPeer, nullptr, 0 };
    8484   
    8585    this->outgoingEventsMutex_->lock();
    … …  
    9191  void Connection::disconnectPeers()
    9292  {
    93     outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, 0, 0 };
     93    outgoingEvent outEvent = { 0, outgoingEventType::disconnectPeers, nullptr, 0 };
    9494   
    9595    this->outgoingEventsMutex_->lock();
    … …  
    323323   
    324324    // create new peerEvent and return it
    325     incomingEvent inEvent = { peerID, incomingEventType::peerConnect, 0 };
     325    incomingEvent inEvent = { peerID, incomingEventType::peerConnect, nullptr };
    326326    return inEvent;
    327327  }
    … …  
    338338   
    339339    // create new peerEvent and return it
    340     incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, 0 };
     340    incomingEvent inEvent = { peerID, incomingEventType::peerDisconnect, nullptr };
    341341    return inEvent;
    342342  }

  • code/branches/cpp11_v2/src/libraries/network/GamestateHandler.cc

    r7801 r10768  
    3232namespace orxonox {
    3333
    34 // GamestateHandler *GamestateHandler::instance_=0;
     34// GamestateHandler *GamestateHandler::instance_=nullptr;
    3535
    3636GamestateHandler::GamestateHandler()

  • code/branches/cpp11_v2/src/libraries/network/GamestateManager.cc

    r8858 r10768  
    6060{
    6161  GamestateManager::GamestateManager() :
    62   currentGamestate_(0), id_(0)
     62  currentGamestate_(nullptr), id_(0)
    6363  {
    6464//     trafficControl_ = new TrafficControl();
    … …  
    140140
    141141  bool GamestateManager::getSnapshot(){
    142     if ( currentGamestate_ != 0 )
     142    if ( currentGamestate_ != nullptr )
    143143      delete currentGamestate_;
    144144    uint8_t gsMode;
    … …  
    165165    { //we have no data to send
    166166      delete currentGamestate_;
    167       currentGamestate_=0;
     167      currentGamestate_=nullptr;
    168168      return false;
    169169    }
    … …  
    191191      unsigned int lastAckedGamestateID = peerIt->second.lastAckedGamestateID;
    192192
    193       packet::Gamestate* baseGamestate=0;
     193      packet::Gamestate* baseGamestate=nullptr;
    194194      if(lastAckedGamestateID != GAMESTATEID_INITIAL)
    195195      {
    … …  
    200200      }
    201201
    202       peerGamestates.push_back(0);  // insert an empty gamestate* to be changed
     202      peerGamestates.push_back(nullptr);  // insert an empty gamestate* to be changed
    203203      finishGamestate( peerID, peerGamestates.back(), baseGamestate, currentGamestate_ );
    204       if( peerGamestates.back()==0 )
     204      if( peerGamestates.back()==nullptr )
    205205        // nothing to send to remove pointer from vector
    206206        peerGamestates.pop_back();
    … …  
    243243      {
    244244        delete diffed1;
    245         destgamestate = 0;
     245        destgamestate = nullptr;
    246246        return;
    247247      }

  • code/branches/cpp11_v2/src/libraries/network/Host.cc

    r10624 r10768  
    4444  SetConsoleCommand(__CC_printRTT_group, __CC_printRTT_name, &Host::printRTT);
    4545
    46   // Host*               Host::instance_=0;
     46  // Host*               Host::instance_=nullptr;
    4747  uint32_t            Host::clientID_s=0;
    4848//   uint32_t            Host::shipID_s=-1;
    … …  
    5454  Host::Host()
    5555  {
    56   //   assert(instance_==0);
     56  //   assert(instance_==nullptr);
    5757    instances_s.push_back(this);
    5858    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(this);
    … …  
    6262
    6363  /**
    64   * @brief Destructor: resets the instance pointer to 0
     64  * @brief Destructor: resets the instance pointer to nullptr
    6565  */
    6666  Host::~Host()
    … …  
    6868    assert( std::find( instances_s.begin(), instances_s.end(), this )!=instances_s.end() );
    6969    instances_s.erase(std::find( instances_s.begin(), instances_s.end(), this ));
    70     ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(0);
     70    ModifyConsoleCommand(__CC_printRTT_group, __CC_printRTT_name).setObject(nullptr);
    7171  }
    7272
    … …  
    135135        ++it;
    136136    }
    137     return 0;
     137    return nullptr;
    138138  }
    139139

  • code/branches/cpp11_v2/src/libraries/network/LANDiscoverable.cc

    r10765 r10768  
    5151    this->setConfigValues();
    5252    //     this->setActivity(true);
    53     this->host_ = 0;
     53    this->host_ = nullptr;
    5454    this->bActive_ = false;
    5555  }
    … …  
    8383      bindAddress.host = ENET_HOST_ANY;
    8484      bindAddress.port = LAN_DISCOVERY_PORT;
    85       assert( this->host_ == 0 );
     85      assert( this->host_ == nullptr );
    8686      this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
    8787      if ( this->host_ == nullptr )
    … …  
    9191    {
    9292      enet_host_destroy( this->host_ );
    93       this->host_ = 0;
     93      this->host_ = nullptr;
    9494    }
    9595      this->bActive_ = bActive;

  • code/branches/cpp11_v2/src/libraries/network/NetworkFunction.h

    r10624 r10768  
    144144    inline bool call(uint32_t objectID)
    145145    {
    146       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     146      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    147147      {
    148148        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)));
    … …  
    154154    inline bool call(uint32_t objectID, const MultiType& mt1)
    155155    {
    156       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     156      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    157157      {
    158158        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1);
    … …  
    164164    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2)
    165165    {
    166       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     166      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    167167      {
    168168        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2);
    … …  
    174174    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3)
    175175    {
    176       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     176      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    177177      {
    178178        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3);
    … …  
    184184    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4)
    185185    {
    186       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     186      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    187187      {
    188188        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4);
    … …  
    194194    inline bool call(uint32_t objectID, const MultiType& mt1, const MultiType& mt2, const MultiType& mt3, const MultiType& mt4, const MultiType& mt5)
    195195    {
    196       if ( Synchronisable::getSynchronisable(objectID)!=0 )
     196      if ( Synchronisable::getSynchronisable(objectID)!=nullptr )
    197197      {
    198198        (*this->functor_)(orxonox_cast<T*>(Synchronisable::getSynchronisable(objectID)), mt1, mt2, mt3, mt4, mt5);

  • code/branches/cpp11_v2/src/libraries/network/NetworkFunctionManager.cc

    r10765 r10768  
    3232namespace orxonox
    3333{
    34     NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = 0;
     34    NetworkFunctionManager* NetworkFunctionManager::singletonPtr_s = nullptr;
    3535
    3636    void NetworkFunctionManager::registerFunction(NetworkFunctionBase* function)

  • code/branches/cpp11_v2/src/libraries/network/Server.cc

    r10765 r10768  
    194194  void Server::printRTT()
    195195  {
    196 //     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=0; temp=temp->next() )
     196//     for( ClientInformation* temp=ClientInformation::getBegin(); temp!=nullptr; temp=temp->next() )
    197197//       orxout(message) << "Round trip time to client with ID: " << temp->getID() << " is " << temp->getRTT() << " ms" << endl;
    198198  }

  • code/branches/cpp11_v2/src/libraries/network/TrafficControl.cc

    r9667 r10768  
    6464*Initializing protected members
    6565*/
    66     TrafficControl *TrafficControl::instance_=0;
     66    TrafficControl *TrafficControl::instance_=nullptr;
    6767
    6868    /**
    … …  
    7272    {
    7373    RegisterObject(TrafficControl);
    74       assert(instance_==0);
     74      assert(instance_==nullptr);
    7575      instance_=this;
    7676    this->setConfigValues();
    … …  
    7878
    7979    /**
    80     * @brief Destructor: resets the instance pointer to 0
     80    * @brief Destructor: resets the instance pointer to nullptr
    8181    */
    8282    TrafficControl::~TrafficControl()
    8383    {
    84       instance_=0;
     84      instance_=nullptr;
    8585    }
    8686

  • code/branches/cpp11_v2/src/libraries/network/packet/Gamestate.cc

    r10765 r10768  
    106106{
    107107  uint32_t tempsize=0, currentsize=0;
    108   assert(data_==0);
     108  assert(data_==nullptr);
    109109  uint32_t size = calcGamestateSize(id, mode);
    110110

  • code/branches/cpp11_v2/src/libraries/network/packet/Gamestate.h

    r7801 r10768  
    5454{
    5555  public:
    56     GamestateHeader(){ data_=0; }
     56    GamestateHeader(){ data_=nullptr; }
    5757    GamestateHeader(uint8_t* data)
    5858      { assert(data); data_ = data; *(uint32_t*)data_ = Type::Gamestate; }

  • code/branches/cpp11_v2/src/libraries/network/packet/Packet.cc

    r10765 r10768  
    6969  packetDirection_ = Direction::Outgoing;
    7070  peerID_=0;
    71   data_=0;
    72   enetPacket_=0;
     71  data_=nullptr;
     72  enetPacket_=nullptr;
    7373  bDataENetAllocated_ = false;
    7474}
    … …  
    8080  peerID_=peerID;
    8181  data_=data;
    82   enetPacket_=0;
     82  enetPacket_=nullptr;
    8383  bDataENetAllocated_ = false;
    8484}
    … …  
    9595    memcpy(data_, p.data_, p.getSize());
    9696  }else
    97     data_=0;
     97    data_=nullptr;
    9898  bDataENetAllocated_ = p.bDataENetAllocated_;
    9999}
    … …  
    175175#endif
    176176//  ENetPacket *temp = enetPacket_;
    177 //  enetPacket_ = 0; // otherwise we have a double free because enet already handles the deallocation of the packet
     177//  enetPacket_ = nullptr; // otherwise we have a double free because enet already handles the deallocation of the packet
    178178  if( this->flags_ & PacketFlag::Reliable )
    179179    host->addPacket( enetPacket_, peerID_, NETWORK_CHANNEL_DEFAULT);
    … …  
    191191//   if( peerID==static_cast<unsigned int>(-2))
    192192//     peerID = NETWORK_PEER_ID_SERVER;
    193   Packet *p = 0;
     193  Packet *p = nullptr;
    194194//   orxout(verbose_ultra, context::packets) << "packet type: " << *(Type::Value *)&data[_PACKETID] << endl;
    195195  switch( *(Type::Value *)(data + _PACKETID) )
    … …  
    251251  assert(it != packetMap_.end());
    252252  // Make sure we don't delete it again in the destructor
    253   it->second->enetPacket_ = 0;
     253  it->second->enetPacket_ = nullptr;
    254254  delete it->second;
    255255  packetMap_.erase(it);

  • code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.cc

    r10765 r10768  
    140140    {
    141141      mem += header.getDataSize() + header.getSize();
    142       return 0;
     142      return nullptr;
    143143    }
    144144//     assert( !header.isDiffed() );
    … …  
    156156    }
    157157    assert(id);
    158     Context* context = 0;
     158    Context* context = nullptr;
    159159    if (header.getContextID() != OBJECTID_UNKNOWN)
    160160    {
    … …  
    164164        mem += header.getDataSize()+SynchronisableHeader::getSize(); //.TODO: this suckz.... remove size from header
    165165        assert(0); // TODO: uncomment this if we have a clean objecthierarchy (with destruction of children of objects) ^^
    166         return 0;
     166        return nullptr;
    167167      }
    168168      else
    … …  
    172172      context = Context::getRootContext();
    173173
    174     assert(getSynchronisable(header.getObjectID())==0);   //make sure no object with this id exists
     174    assert(getSynchronisable(header.getObjectID())==nullptr);   //make sure no object with this id exists
    175175    BaseObject *bo = orxonox_cast<BaseObject*>(id->fabricate(context));
    176176    assert(bo);

  • code/branches/cpp11_v2/src/libraries/network/synchronisable/Synchronisable.h

    r9667 r10768  
    171171  protected:
    172172    Synchronisable(Context* context);
    173     template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
    174     template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=0, bool bidirectional=false);
     173    template <class T> void registerVariable(T& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
     174    template <class T> void registerVariable(std::set<T>& variable, uint8_t mode=0x1, NetworkCallbackBase *cb=nullptr, bool bidirectional=false);
    175175    template <class T> void unregisterVariable(T& var);
    176176

  • code/branches/cpp11_v2/src/libraries/network/synchronisable/SynchronisableVariable.h

    r10624 r10768  
    7171  {
    7272    public:
    73       SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=0);
     73      SynchronisableVariable(T& variable, uint8_t syncDirection=VariableDirection::ToClient, NetworkCallbackBase *cb=nullptr);
    7474      virtual ~SynchronisableVariable();
    7575
    … …  
    8989  {
    9090    public:
    91       SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=0);
     91      SynchronisableVariableBidirectional(T& variable, uint8_t master=Bidirectionality::ServerMaster, NetworkCallbackBase *cb=nullptr);
    9292      virtual ~SynchronisableVariableBidirectional();
    9393

  • code/branches/cpp11_v2/src/libraries/tools/BillboardSet.cc

    r8858 r10768  
    4646    BillboardSet::BillboardSet()
    4747    {
    48         this->billboardSet_ = 0;
     48        this->billboardSet_ = nullptr;
    4949    }
    5050
    … …  
    8181        {
    8282            orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
    83             this->billboardSet_ = 0;
     83            this->billboardSet_ = nullptr;
    8484        }
    8585
    … …  
    104104        {
    105105            orxout(internal_error) << "Couldn't load billboard \"" << file << '"' << endl;
    106             this->billboardSet_ = 0;
     106            this->billboardSet_ = nullptr;
    107107        }
    108108
    … …  
    114114        if (this->billboardSet_ && this->scenemanager_)
    115115            this->scenemanager_->destroyBillboardSet(this->billboardSet_);
    116         this->billboardSet_ = 0;
     116        this->billboardSet_ = nullptr;
    117117    }
    118118

  • code/branches/cpp11_v2/src/libraries/tools/DebugDrawer.cc

    r10262 r10768  
    2121{
    2222    DebugDrawer::DebugDrawer(Ogre::SceneManager *_sceneManager, float _fillAlpha) :
    23             sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(0), isEnabled(true), linesIndex(0), trianglesIndex(0)
     23            sceneManager(_sceneManager), fillAlpha(_fillAlpha), manualObject(nullptr), isEnabled(true), linesIndex(0), trianglesIndex(0)
    2424    {
    2525        initialise();

  • code/branches/cpp11_v2/src/libraries/tools/Mesh.cc

    r8858 r10768  
    4444    Mesh::Mesh()
    4545    {
    46         this->entity_ = 0;
     46        this->entity_ = nullptr;
    4747        this->bCastShadows_ = true;
    4848    }
    … …  
    7373            {
    7474                orxout(internal_error) << "Couldn't load mesh \"" << meshsource << '"' << endl;
    75                 this->entity_ = 0;
     75                this->entity_ = nullptr;
    7676            }
    7777        }

  • code/branches/cpp11_v2/src/libraries/tools/ParticleInterface.cc

    r10624 r10768  
    5959
    6060        this->scenemanager_ = scenemanager;
    61         this->particleSystem_ = 0;
     61        this->particleSystem_ = nullptr;
    6262
    6363        this->bEnabled_ = true;
    … …  
    8080            {
    8181                orxout(internal_error) << "Couldn't load particle system \"" << templateName << '"' << endl;
    82                 this->particleSystem_ = 0;
     82                this->particleSystem_ = nullptr;
    8383            }
    8484        }
    … …  
    110110        }
    111111        else
    112             return 0;
     112            return nullptr;
    113113    }
    114114    Ogre::ParticleEmitter* ParticleInterface::getEmitter(unsigned int emitterNr) const
    … …  
    117117            return this->particleSystem_->getEmitter(emitterNr);
    118118        else
    119             return 0;
     119            return nullptr;
    120120    }
    121121    void ParticleInterface::removeEmitter(unsigned int emitterNr)
    … …  
    142142            return this->particleSystem_->addAffector(name);
    143143        else
    144             return 0;
     144            return nullptr;
    145145    }
    146146    Ogre::ParticleAffector* ParticleInterface::getAffector(unsigned int affectorNr)
    … …  
    149149            return this->particleSystem_->getAffector(affectorNr);
    150150        else
    151             return 0;
     151            return nullptr;
    152152    }
    153153    void ParticleInterface::removeAffector(unsigned int affectorNr)

  • code/branches/cpp11_v2/src/libraries/tools/Shader.cc

    r10765 r10768  
    4444        @brief Initializes the values and sets the scene manager.
    4545    */
    46     Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(0)
     46    Shader::Shader(Ogre::SceneManager* scenemanager) : compositorInstance_(nullptr)
    4747    {
    4848        RegisterObject(Shader);
    … …  
    127127                Ogre::CompositorManager::getSingleton().removeCompositor(viewport, this->oldcompositorName_);
    128128                this->compositorInstance_->removeListener(this);
    129                 this->compositorInstance_ = 0;
     129                this->compositorInstance_ = nullptr;
    130130            }
    131131            if (!this->compositorName_.empty())

  • code/branches/cpp11_v2/src/libraries/tools/Shader.h

    r10727 r10768  
    4848    {
    4949        public:
    50             Shader(Ogre::SceneManager* scenemanager = 0);
     50            Shader(Ogre::SceneManager* scenemanager = nullptr);
    5151            virtual ~Shader();
    5252

  • code/branches/cpp11_v2/src/libraries/tools/Timer.cc

    r10624 r10768  
    163163    void Timer::init()
    164164    {
    165         this->executor_ = 0;
     165        this->executor_ = nullptr;
    166166        this->interval_ = 0;
    167167        this->bLoop_ = false;

  • code/branches/cpp11_v2/src/libraries/util/Math.h

    r10742 r10768  
    200200    template <> inline long double          zeroise<long double>()          { return 0; }
    201201    template <> inline bool                 zeroise<bool>()                 { return 0; }
    202     template <> inline void*                zeroise<void*>()                { return 0; }
     202    template <> inline void*                zeroise<void*>()                { return nullptr; }
    203203    template <> inline std::string          zeroise<std::string>()          { return std::string(); }
    204204    template <> inline orxonox::Radian      zeroise<orxonox::Radian>()      { return orxonox::Radian(0.0f); }

  • code/branches/cpp11_v2/src/libraries/util/MultiType.h

    r10197 r10768  
    266266
    267267            /// Default constructor: Assigns no value and no type. The type will be determined by the first assignment of a value.
    268             inline MultiType()                       : value_(0) { }
     268            inline MultiType()                       : value_(nullptr) { }
    269269            /// Constructor: Assigns the given value and sets the type.
    270270            template <typename V>
    271             inline MultiType(const V& value)         : value_(0) { this->set(value); }
     271            inline MultiType(const V& value)         : value_(nullptr) { this->set(value); }
    272272            /// Copyconstructor: Assigns value and type of the other MultiType.
    273             inline MultiType(const MultiType& other) : value_(0) { this->set(other); }
     273            inline MultiType(const MultiType& other) : value_(nullptr) { this->set(other); }
    274274
    275275            /// Destructor: Deletes the MT_Value.
    … …  
    325325                if (this->value_)
    326326                    delete this->value_;
    327                 this->value_ = (other.value_) ? other.value_->clone() : 0;
     327                this->value_ = (other.value_) ? other.value_->clone() : nullptr;
    328328            }
    329329
    … …  
    332332
    333333            /// Resets value and type. Type will be void afterwards and null() returns true.
    334             inline void reset() { if (this->value_) delete this->value_; this->value_ = 0; }
     334            inline void reset() { if (this->value_) delete this->value_; this->value_ = nullptr; }
    335335            /// Resets the value and changes the internal type to T.
    336336            template <typename T> inline void reset() { this->assignValue(typename Loki::TypeTraits<T>::UnqualifiedReferredType()); }
    … …  
    486486    template <> inline long double          MultiType::get() const { return (this->value_ ? this->value_->get<long double>()          : 0); }
    487487    template <> inline bool                 MultiType::get() const { return (this->value_ ? this->value_->get<bool>()                 : 0); }
    488     template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : 0); }
     488    template <> inline void*                MultiType::get() const { return (this->value_ ? this->value_->get<void*>()                : nullptr); }
    489489    template <> inline std::string          MultiType::get() const { return (this->value_ ? this->value_->get<std::string>()          : NilValue<std::string>()); }
    490490    template <> inline orxonox::Vector2     MultiType::get() const { return (this->value_ ? this->value_->get<orxonox::Vector2>()     : NilValue<orxonox::Vector2>()); }

  • code/branches/cpp11_v2/src/libraries/util/MultiTypeValue.h

    r9550 r10768  
    7777        inline bool getValue(long double*          value) const { return convertValue<T, long double         >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    7878        inline bool getValue(bool*                 value) const { return convertValue<T, bool                >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    79         inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, 0); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
     79        inline bool getValue(void**                value) const { return convertValue<T, void*               >(value, value_, nullptr); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    8080        inline bool getValue(std::string*          value) const { return convertValue<T, std::string         >(value, value_, NilValue<std::string>         ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.
    8181        inline bool getValue(orxonox::Vector2*     value) const { return convertValue<T, orxonox::Vector2    >(value, value_, NilValue<orxonox::Vector2>    ()); } ///< Assigns the value to the given pointer. The value gets converted if the types don't match.

  • code/branches/cpp11_v2/src/libraries/util/SharedPtr.h

    r10765 r10768  
    216216        public:
    217217            /// Default constructor, the pointer is set to nullptr.
    218             inline SharedPtr() : pointer_(0), counter_(0)
     218            inline SharedPtr() : pointer_(nullptr), counter_(nullptr)
    219219            {
    220220            }
    221221
    222222            /// Constructor, creates a SharedPtr that points to @a pointer, increments the counter.
    223             inline SharedPtr(T* pointer) : pointer_(pointer), counter_(0)
     223            inline SharedPtr(T* pointer) : pointer_(pointer), counter_(nullptr)
    224224            {
    225225                if (this->pointer_)
    … …  
    293293            inline T* operator->() const
    294294            {
    295                 assert(this->pointer_ != 0);
     295                assert(this->pointer_ != nullptr);
    296296                return this->pointer_;
    297297            }
    … …  
    300300            inline T& operator*() const
    301301            {
    302                 assert(this->pointer_ != 0);
     302                assert(this->pointer_ != nullptr);
    303303                return *this->pointer_;
    304304            }
    … …  
    313313            inline operator bool() const
    314314            {
    315                 return (this->pointer_ != 0);
     315                return (this->pointer_ != nullptr);
    316316            }
    317317

  • code/branches/cpp11_v2/src/libraries/util/SignalHandler.cc

    r10765 r10768  
    127127      }
    128128      // if the signalhandler has already been destroyed then don't do anything
    129       if( SignalHandler::singletonPtr_s == 0 )
     129      if( SignalHandler::singletonPtr_s == nullptr )
    130130      {
    131131        orxout(user_error) << "Received signal " << sigName.c_str() << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;
    … …  
    430430
    431431            // if the signalhandler has already been destroyed then don't do anything
    432             if (SignalHandler::singletonPtr_s == 0)
     432            if (SignalHandler::singletonPtr_s == nullptr)
    433433            {
    434434                orxout(user_error) << "Caught an unhandled exception" << endl << "Can't write backtrace because SignalHandler is already destroyed" << endl;

  • code/branches/cpp11_v2/src/libraries/util/SmallObjectAllocator.cc

    r10765 r10768  
    4545        this->chunkSize_ = std::max(objectSize, sizeof(Chunk)); // the chunk's size will be the maximum of the object's size and the size of a Chunk object itself
    4646        this->numChunksPerBlock_ = numObjects;
    47         this->first_ = 0;
     47        this->first_ = nullptr;
    4848    }
    4949
    … …  
    9898
    9999            // the next_ pointer of the last chunk must point to nullptr
    100             setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
     100            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, nullptr);
    101101
    102102            // The second chunk in the block is assigned to the first_ pointer

  • code/branches/cpp11_v2/src/libraries/util/output/OutputManager.cc

    r9550 r10768  
    5757
    5858        this->isInitialized_ = false;
    59         this->memoryWriterInstance_ = 0;
    60         this->consoleWriterInstance_ = 0;
    61         this->logWriterInstance_ = 0;
     59        this->memoryWriterInstance_ = nullptr;
     60        this->consoleWriterInstance_ = nullptr;
     61        this->logWriterInstance_ = nullptr;
    6262
    6363        // register 'undefined' context in order to give it always the first context-ID
Note: See TracChangeset for help on using the changeset viewer.