Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 10765


Ignore:
Timestamp:
Nov 4, 2015, 10:25:42 PM (9 years ago)
Author:
landauf
Message:

replace 'NULL' by 'nullptr'

Location:
code/branches/cpp11_v2
Files:
238 edited

Legend:

Unmodified
Added
Removed

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

    r10624 r10765  
    8484        // get executable module
    8585        TCHAR buffer[1024];
    86         if (GetModuleFileName(NULL, buffer, 1024) == 0)
     86        if (GetModuleFileName(nullptr, buffer, 1024) == 0)
    8787            ThrowException(General, "Could not retrieve executable path.");
    8888

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

    r10624 r10765  
    205205            Template* link;
    206206            assert(!(link = Template::getTemplate(temp->getLink())) || !link->isLink());
    207             link = NULL;
     207            link = nullptr;
    208208        }
    209209        else

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

    r10624 r10765  
    265265            return this->weakPtr_;
    266266        else
    267             return NULL;
     267            return nullptr;
    268268    }
    269269

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

    r10624 r10765  
    122122            char* userDataPathPtr(getenv("APPDATA"));
    123123#endif
    124             if (userDataPathPtr == NULL)
     124            if (userDataPathPtr == nullptr)
    125125                ThrowException(General, "Could not retrieve user data path.");
    126126            bf::path userDataPath(userDataPathPtr);

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

    r10624 r10765  
    9595
    9696    Core::Core(const std::string& cmdLine)
    97         : applicationPaths_(NULL)
    98         , configurablePaths_(NULL)
    99         , dynLibManager_(NULL)
    100         , signalHandler_(NULL)
    101         , configFileManager_(NULL)
    102         , languageInstance_(NULL)
    103         , loaderInstance_(NULL)
    104         , ioConsole_(NULL)
    105         , tclBind_(NULL)
    106         , tclThreadManager_(NULL)
    107         , rootScope_(NULL)
    108         , graphicsManager_(NULL)
    109         , inputManager_(NULL)
    110         , guiManager_(NULL)
    111         , graphicsScope_(NULL)
     97        : applicationPaths_(nullptr)
     98        , configurablePaths_(nullptr)
     99        , dynLibManager_(nullptr)
     100        , signalHandler_(nullptr)
     101        , configFileManager_(nullptr)
     102        , languageInstance_(nullptr)
     103        , loaderInstance_(nullptr)
     104        , ioConsole_(nullptr)
     105        , tclBind_(nullptr)
     106        , tclThreadManager_(nullptr)
     107        , rootScope_(nullptr)
     108        , graphicsManager_(nullptr)
     109        , inputManager_(nullptr)
     110        , guiManager_(nullptr)
     111        , graphicsScope_(nullptr)
    112112        , bGraphicsLoaded_(false)
    113         , staticInitHandler_(NULL)
    114         , pluginManager_(NULL)
    115         , rootModule_(NULL)
    116         , config_(NULL)
     113        , staticInitHandler_(nullptr)
     114        , pluginManager_(nullptr)
     115        , rootModule_(nullptr)
     116        , config_(nullptr)
    117117        , destructionHelper_(this)
    118118    {
    … …  
    176176
    177177        // initialize root context
    178         Context::setRootContext(new Context(NULL));
     178        Context::setRootContext(new Context(nullptr));
    179179
    180180        // Do this soon after the ConfigFileManager has been created to open up the
    … …  
    326326        module->deleteAllStaticallyInitializedInstances();
    327327        this->dynLibManager_->unload(module->getDynLib());
    328         module->setDynLib(NULL);
     328        module->setDynLib(nullptr);
    329329    }
    330330
    … …  
    471471        }
    472472        // Process console events and status line
    473         if (this->ioConsole_ != NULL)
     473        if (this->ioConsole_ != nullptr)
    474474            this->ioConsole_->preUpdate(time);
    475475        // Process thread commands

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

    r10624 r10765  
    137137    void CoreConfig::updateLastLevelTimestamp()
    138138    {
    139         ModifyConfigValue(lastLevelTimestamp_, set, static_cast<long long>(time(NULL)));
     139        ModifyConfigValue(lastLevelTimestamp_, set, static_cast<long long>(time(nullptr)));
    140140    }
    141141
    142142    void CoreConfig::updateOgreConfigTimestamp()
    143143    {
    144         ModifyConfigValue(ogreConfigTimestamp_, set, static_cast<long long>(time(NULL)));
     144        ModifyConfigValue(ogreConfigTimestamp_, set, static_cast<long long>(time(nullptr)));
    145145    }
    146146

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

    r10624 r10765  
    120120*/
    121121#define RegisterAbstractClass(ClassName) \
    122     RegisterClassWithFactory(ClassName, static_cast<ClassFactory<ClassName>*>(NULL), false)
     122    RegisterClassWithFactory(ClassName, static_cast<ClassFactory<ClassName>*>(nullptr), false)
    123123
    124124/**

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

    r10624 r10765  
    268268    */
    269269    GUIManager::GUIManager(const std::pair<int, int>& mousePosition)
    270         : guiRenderer_(NULL)
    271         , resourceProvider_(NULL)
     270        : guiRenderer_(nullptr)
     271        , resourceProvider_(nullptr)
    272272#ifndef ORXONOX_OLD_CEGUI
    273         , rqListener_(NULL)
    274         , imageCodec_(NULL)
    275 #endif
    276         , luaState_(NULL)
    277         , scriptModule_(NULL)
    278         , guiSystem_(NULL)
    279         , ceguiLogger_(NULL)
    280         , rootWindow_(NULL)
    281         , hudRootWindow_(NULL)
    282         , menuRootWindow_(NULL)
    283         , camera_(NULL)
     273        , rqListener_(nullptr)
     274        , imageCodec_(nullptr)
     275#endif
     276        , luaState_(nullptr)
     277        , scriptModule_(nullptr)
     278        , guiSystem_(nullptr)
     279        , ceguiLogger_(nullptr)
     280        , rootWindow_(nullptr)
     281        , hudRootWindow_(nullptr)
     282        , menuRootWindow_(nullptr)
     283        , camera_(nullptr)
    284284        , destructionHelper_(this)
    285285    {
    … …  
    467467    {
    468468#ifdef ORXONOX_OLD_CEGUI
    469         if (camera == NULL)
     469        if (camera == nullptr)
    470470            this->guiRenderer_->setTargetSceneManager(0);
    471471        else
    472472            this->guiRenderer_->setTargetSceneManager(camera->getSceneManager());
    473473#else
    474         if (camera_ != NULL && camera_->getSceneManager() != NULL)
     474        if (camera_ != nullptr && camera_->getSceneManager() != nullptr)
    475475            camera_->getSceneManager()->removeRenderQueueListener(rqListener_);
    476         if (camera != NULL && camera->getSceneManager() != NULL)
     476        if (camera != nullptr && camera->getSceneManager() != nullptr)
    477477            camera->getSceneManager()->addRenderQueueListener(rqListener_);
    478478#endif
    … …  
    876876            return;
    877877
    878         CEGUI::Font* font = NULL;
     878        CEGUI::Font* font = nullptr;
    879879        CEGUI::XMLAttributes xmlAttributes;
    880880
    … …  
    892892
    893893        font = CEGUI::FontManager::getSingleton().createFont("FreeType", xmlAttributes);
    894         if(font != NULL)
     894        if(font != nullptr)
    895895            font->load();
    896896#else

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

    r10624 r10765  
    7777
    7878    Game::Game(const std::string& cmdLine)
    79         : gameClock_(NULL)
    80         , core_(NULL)
     79        : gameClock_(nullptr)
     80        , core_(nullptr)
    8181        , bChangingState_(false)
    8282        , bAbort_(false)
    83         , config_(NULL)
     83        , config_(nullptr)
    8484        , destructionHelper_(this)
    8585    {
    … …  
    398398            // Check parent and all its grand parents
    399399            shared_ptr<GameStateTreeNode> currentNode = lastRequestedNode;
    400             while (currentNode != NULL)
     400            while (currentNode != nullptr)
    401401            {
    402402                if (currentNode->name_ == name)
    … …  
    405405                requestedNodes.push_back(currentNode);
    406406            }
    407             if (currentNode == NULL)
     407            if (currentNode == nullptr)
    408408                requestedNodes.clear();
    409409        }

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

    r10624 r10765  
    178178    void GraphicsManager::upgradeToGraphics()
    179179    {
    180         if (renderWindow_ != NULL)
     180        if (renderWindow_ != nullptr)
    181181            return;
    182182

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

    r10624 r10765  
    9696        void loadDebugOverlay();
    9797        void unloadDebugOverlay();
    98         bool rendererLoaded() const { return renderWindow_ != NULL; }
     98        bool rendererLoaded() const { return renderWindow_ != nullptr; }
    9999
    100100        void setCamera(Ogre::Camera* camera);

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

    r10624 r10765  
    8989        {
    9090            shared_ptr<ResourceInfo> info = Resource::getInfo(file->getFilename());
    91             if (info == NULL)
     91            if (info == nullptr)
    9292            {
    9393                orxout(user_error, context::loader) << "Could not find XML file '" << file->getFilename() << "'." << endl;

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

    r10265 r10765  
    4848    LuaState::LuaState()
    4949        : bIsRunning_(false)
    50         , includeParseFunction_(NULL)
     50        , includeParseFunction_(nullptr)
    5151    {
    5252        // Create new lua state and configure it
    … …  
    8484        shared_ptr<ResourceInfo> sourceInfo = Resource::getInfo(sourceFileInfo_->path + filename);
    8585        // Continue search in root directories
    86         if (sourceInfo == NULL && !sourceFileInfo_->path.empty())
     86        if (sourceInfo == nullptr && !sourceFileInfo_->path.empty())
    8787            sourceInfo = Resource::getInfo(filename);
    8888        return sourceInfo;
    … …  
    9292    {
    9393        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
    94         if (sourceInfo != NULL)
     94        if (sourceInfo != nullptr)
    9595            return this->includeString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
    9696        else
    … …  
    105105        // Parse string with provided include parser (otherwise don't preparse at all)
    106106        std::string luaInput;
    107         if (includeParseFunction_ != NULL)
     107        if (includeParseFunction_ != nullptr)
    108108            luaInput = (*includeParseFunction_)(code);
    109109        else
    110110            luaInput = code;
    111111
    112         if (sourceFileInfo != NULL)
     112        if (sourceFileInfo != nullptr)
    113113        {
    114114            // Also fill a map with the actual source code. This is just for the include* commands
    … …  
    119119        bool returnValue = this->doString(luaInput, sourceFileInfo);
    120120
    121         if (sourceFileInfo != NULL)
     121        if (sourceFileInfo != nullptr)
    122122        {
    123123            // Delete source code entry
    124             if (sourceFileInfo != NULL)
     124            if (sourceFileInfo != nullptr)
    125125                this->sourceCodeMap_.erase(sourceFileInfo->filename);
    126126        }
    … …  
    132132    {
    133133        shared_ptr<ResourceInfo> sourceInfo = this->getFileInfo(filename);
    134         if (sourceInfo != NULL)
     134        if (sourceInfo != nullptr)
    135135            return this->doString(Resource::open(sourceInfo)->getAsString(), sourceInfo);
    136136        else
    … …  
    146146        shared_ptr<ResourceInfo> oldSourceFileInfo = sourceFileInfo_;
    147147        // Only override if sourceFileInfo provides useful information
    148         if (sourceFileInfo != NULL)
     148        if (sourceFileInfo != nullptr)
    149149            sourceFileInfo_ = sourceFileInfo;
    150150
    151151        std::string chunkname;
    152         if (sourceFileInfo != NULL)
     152        if (sourceFileInfo != nullptr)
    153153        {
    154154            // Provide lua_load with the filename for debug purposes
    … …  
    286286    {
    287287        shared_ptr<ResourceInfo> info = this->getFileInfo(filename);
    288         if (info == NULL)
     288        if (info == nullptr)
    289289            return false;
    290290        else
    … …  
    301301            return it->second;
    302302        shared_ptr<ResourceInfo> info = Resource::getInfo(filename);
    303         if (info == NULL)
     303        if (info == nullptr)
    304304            return "";
    305305        else

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

    r9675 r10765  
    102102                ptr->size = it->uncompressedSize;
    103103#if OGRE_VERSION >= 0x010800
    104                 if (dynamic_cast<const Ogre::FileSystemArchive*>(it->archive) != NULL)
     104                if (dynamic_cast<const Ogre::FileSystemArchive*>(it->archive) != nullptr)
    105105#else
    106                 if (dynamic_cast<Ogre::FileSystemArchive*>(it->archive) != NULL)
     106                if (dynamic_cast<Ogre::FileSystemArchive*>(it->archive) != nullptr)
    107107#endif
    108108                {

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

    r9667 r10765  
    9898                registered in the class hierarchy.
    9999            @return
    100                 Returns NULL if the no pointer was found.
     100                Returns nullptr if the no pointer was found.
    101101            */
    102102            ORX_FORCEINLINE void* getDerivedPointer(unsigned int classID)
    … …  
    107107                        return this->objectPointers_[i].second;
    108108                }
    109                 return NULL;
     109                return nullptr;
    110110            }
    111111

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

    r10624 r10765  
    279279            ClassIdentifier(const std::string& name, Factory* factory, bool bLoadable) : Identifier(name, factory, bLoadable)
    280280            {
    281                 OrxVerify(ClassIdentifier<T>::classIdentifier_s == NULL, "Assertion failed in ClassIdentifier of type " << typeid(T).name());
     281                OrxVerify(ClassIdentifier<T>::classIdentifier_s == nullptr, "Assertion failed in ClassIdentifier of type " << typeid(T).name());
    282282                ClassIdentifier<T>::classIdentifier_s = this;
    283283
    … …  
    334334    /*static*/ inline ClassIdentifier<T>* ClassIdentifier<T>::getIdentifier()
    335335    {
    336         if (ClassIdentifier<T>::classIdentifier_s == NULL)
     336        if (ClassIdentifier<T>::classIdentifier_s == nullptr)
    337337            ClassIdentifier<T>::classIdentifier_s = (ClassIdentifier<T>*) IdentifierManager::getInstance().getIdentifierByTypeInfo(typeid(T));
    338338
    339         OrxVerify(ClassIdentifier<T>::classIdentifier_s != NULL, "Did you forget to register the class of type " << typeid(T).name() << "?");
     339        OrxVerify(ClassIdentifier<T>::classIdentifier_s != nullptr, "Did you forget to register the class of type " << typeid(T).name() << "?");
    340340        return ClassIdentifier<T>::classIdentifier_s;
    341341    }
    … …  
    451451    void ClassIdentifier<T>::updateConfigValues(bool updateChildren) const
    452452    {
    453         this->updateConfigValues(updateChildren, static_cast<T*>(NULL));
     453        this->updateConfigValues(updateChildren, static_cast<T*>(nullptr));
    454454    }
    455455
    … …  
    483483        registered in the class hierarchy.
    484484    @return
    485         Returns NULL if the cast is not possible
     485        Returns nullptr if the cast is not possible
    486486    @note
    487         In case of NULL return (and using MSVC), a dynamic_cast might still be possible if
     487        In case of nullptr return (and using MSVC), a dynamic_cast might still be possible if
    488488        a class forgot to register its objects.
    489489        Also note that the function is implemented differently for GCC/MSVC.
    … …  
    494494#ifdef ORXONOX_COMPILER_MSVC
    495495        typedef Loki::TypeTraits<typename Loki::TypeTraits<T>::PointeeType>::NonConstType ClassType;
    496         if (source != NULL)
     496        if (source != nullptr)
    497497            return source->template getDerivedPointer<ClassType>(ClassIdentifier<ClassType>::getIdentifier()->getClassID());
    498498        else
    499             return NULL;
     499            return nullptr;
    500500#else
    501501        return dynamic_cast<T>(source);

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

    r10624 r10765  
    4949    {
    5050        this->hierarchyCreatingCounter_s = 0;
    51         this->recordTraceForIdentifier_ = NULL;
     51        this->recordTraceForIdentifier_ = nullptr;
    5252    }
    5353
    … …  
    9292        // iterate over all identifiers, create one instance of each class and initialize the identifiers
    9393        {
    94             Context temporaryContext(NULL);
     94            Context temporaryContext(nullptr);
    9595            for (std::set<Identifier*>::const_iterator it = this->identifiers_.begin(); it != this->identifiers_.end(); ++it)
    9696            {
    … …  
    108108                    Identifiable* temp = identifier->fabricate(&temporaryContext);
    109109
    110                     this->recordTraceForIdentifier_ = NULL;
     110                    this->recordTraceForIdentifier_ = nullptr;
    111111
    112112                    if (temp->getIdentifier() != identifier)
    … …  
    149149
    150150        // for all initialized identifiers, check if a sample instance behaves as expected according to the class hierarchy
    151         Context temporaryContext(NULL);
     151        Context temporaryContext(nullptr);
    152152        for (std::set<Identifier*>::const_iterator it1 = initializedIdentifiers.begin(); it1 != initializedIdentifiers.end(); ++it1)
    153153        {

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

    r9667 r10765  
    127127                    else
    128128                    {
    129                         orxout(internal_error) << "Can't assign NULL identifier" << endl;
     129                        orxout(internal_error) << "Can't assign nullptr identifier" << endl;
    130130                    }
    131131                }

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

    r10624 r10765  
    119119    /**
    120120        @brief Executes the command which was evaluated by this object and returns its return-value.
    121         @param error A pointer to an integer (or NULL) which will be used to write error codes to (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
     121        @param error A pointer to an integer (or nullptr) which will be used to write error codes to (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
    122122        @return Returns the result of the command (or MultiType::Null if there is no return value)
    123123    */

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

    r8079 r10765  
    137137            static std::string getCommonBegin(const ArgumentCompletionList& list);
    138138
    139             const ConsoleCommand* execCommand_;             ///< The command that will be executed (can be NULL if the command is not valid)
     139            const ConsoleCommand* execCommand_;             ///< The command that will be executed (can be nullptr if the command is not valid)
    140140            const ConsoleCommand* hintCommand_;             ///< The command that is used to display hints and argument lists (can be different to execCommand_ in some cases)
    141141            SubString tokens_;                              ///< The single words of the command string, split into tokens

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

    r10624 r10765  
    8181        @brief Executes a command and returns its return-value.
    8282        @param command A string containing the command
    83         @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
     83        @param error A pointer to a value (or nullptr) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
    8484        @param useTcl If true, the command is passed to tcl (see TclBind)
    8585        @return Returns the return-value of the command (if any - MultiType::Null otherwise)
    … …  
    127127        @brief Executes a command and returns its return-value as string.
    128128        @param command A string containing the command
    129         @param error A pointer to a value (or NULL) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
     129        @param error A pointer to a value (or nullptr) where the error-code should be written to (see @ref CommandExecutorErrorCodes "error codes")
    130130        @param useTcl If true, the command is passed to tcl (see TclBind)
    131131        @return Returns the return-value of the command converted to a string (or "" if there's no return value)

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

    r10624 r10765  
    348348
    349349    /**
    350         @brief Sets the functor to NULL (which also deactivates the command).
     350        @brief Sets the functor to nullptr (which also deactivates the command).
    351351    */
    352352    void ConsoleCommand::resetFunction()

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

    r10624 r10765  
    195195                        { if (this->command_) { this->command_->popFunction(); } return *this; }
    196196
    197                     /// Sets the current function-pointer to NULL, which also deactivates the command.
     197                    /// Sets the current function-pointer to nullptr, which also deactivates the command.
    198198                    inline ConsoleCommandManipulator& resetFunction()
    199199                        { if (this->command_) { this->command_->resetFunction(); } return *this; }
    … …  
    205205                    inline ConsoleCommandManipulator& pushObject(void* object)
    206206                        { if (this->command_) { this->command_->pushObject(object); } return *this; }
    207                     /// Removes the current object from the object-stack and restores the old object (or NULL if there's no object left on the stack).
     207                    /// Removes the current object from the object-stack and restores the old object (or nullptr if there's no object left on the stack).
    208208                    inline ConsoleCommandManipulator& popObject()
    209209                        { if (this->command_) { this->command_->popObject(); } return *this; }

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

    r10624 r10765  
    331331        @brief Returns a manipulator for a command with the given name.
    332332
    333         @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
     333        @note If the command doesn't exist, the manipulator contains a nullptr to the command,
    334334        but it can still be used without checks, because all functions of ConsoleCommandManipulator
    335335        check internally if the command exists.
    … …  
    340340        @brief Returns a manipulator for a command with the given group and name.
    341341
    342         @note If the command doesn't exist, the manipulator contains a NULL pointer to the command,
     342        @note If the command doesn't exist, the manipulator contains a nullptr to the command,
    343343        but it can still be used without checks, because all functions of ConsoleCommandManipulator
    344344        check internally if the command exists.

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

    r9550 r10765  
    7676        @brief Calls the wrapped function with arguments that are passed in a string.
    7777        @param arguments The arguments that should be passed to the function, separated by @a delimiter
    78         @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
     78        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
    7979        @param delimiter The delimiter that is used to separate the arguments in the string @a arguments
    8080        @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
    … …  
    8989        @brief Calls the wrapped function with arguments that are passed as tokens in a SubString
    9090        @param arguments The arguments that should be passed to the function
    91         @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
     91        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
    9292        @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
    9393        @param bPrintError If true, errors are printed to the console if the function couldn't be executed with the given arguments
    … …  
    127127        @param arguments The arguments that should be converted
    128128        @param arg An array of MultiType where the converted arguments will be stored
    129         @param error A pointer to a variable (or NULL) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
     129        @param error A pointer to a variable (or nullptr) that is used to store the error code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
    130130        @param delimiter The delimiter that was used to separate the arguments in the SubString @a arguments (used to join the surplus arguments)
    131131        @return Returns the number of evaluated arguments

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

    r9667 r10765  
    215215            virtual void* getRawObjectPointer() const = 0;
    216216
    217             /// Enables or disables the safe mode which causes the functor to change the object pointer to NULL if the object is deleted (only member functors).
     217            /// Enables or disables the safe mode which causes the functor to change the object pointer to nullptr if the object is deleted (only member functors).
    218218            virtual void setSafeMode(bool bSafeMode) = 0;
    219219
    … …  
    245245            virtual ~FunctorMember() { if (this->bSafeMode_) { this->unregisterObject(this->object_); } }
    246246
    247             /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
     247            /// 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)
    248248            virtual MultiType operator()(O* object, 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) = 0;
    249249
    … …  
    312312                { this->object_ = 0; }
    313313
    314             O* object_;     ///< The stored object-pointer, used to execute a member-function (or NULL for static functions)
    315             bool bSafeMode_; ///< If true, the functor is in safe mode and registers itself as listener at the object and changes the pointer to NULL if the object is deleted
     314            O* object_;     ///< The stored object-pointer, used to execute a member-function (or nullptr for static functions)
     315            bool bSafeMode_; ///< If true, the functor is in safe mode and registers itself as listener at the object and changes the pointer to nullptr if the object is deleted
    316316    };
    317317
    … …  
    324324            FunctorMember(void* object = 0) {}
    325325
    326             /// Calls the function-pointer with up to five arguments and an object. In case of a static-function, the object can be NULL. @return Returns the return-value of the function (if any; MultiType::Null otherwise)
     326            /// 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)
    327327            virtual MultiType operator()(void* object, 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) = 0;
    328328

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

    r9667 r10765  
    4444namespace orxonox
    4545{
    46     IOConsole* IOConsole::singletonPtr_s = NULL;
     46    IOConsole* IOConsole::singletonPtr_s = nullptr;
    4747
    4848    namespace EscapeMode
    … …  
    353353        const char* s;
    354354        if (!this->terminalWidth_ && (s = getenv("COLUMNS")))
    355             this->terminalWidth_  = strtol(s, NULL, 10);
     355            this->terminalWidth_  = strtol(s, nullptr, 10);
    356356        if (!this->terminalWidth_)
    357357            this->terminalWidth_ = 80;
    358358        if (!this->terminalHeight_ && (s = getenv("LINES")))
    359             this->terminalHeight_ = strtol(s, NULL, 10);
     359            this->terminalHeight_ = strtol(s, nullptr, 10);
    360360        if (!this->terminalHeight_)
    361361            this->terminalHeight_ = 24;

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

    r9676 r10765  
    4141namespace orxonox
    4242{
    43     IOConsole* IOConsole::singletonPtr_s = NULL;
     43    IOConsole* IOConsole::singletonPtr_s = nullptr;
    4444
    4545    //! Redirects std::cout, creates the corresponding Shell and changes the terminal mode
    … …  
    300300                this->terminalWidth_ - 1, this->inputLineRow_ + this->inputLineHeight_ + this->statusLines_ - 1);
    301301            this->inputLineRow_ += linesDown;
    302             ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, this->inputLineRow_), &fillChar);
     302            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, nullptr, makeCOORD(0, this->inputLineRow_), &fillChar);
    303303            // Move cursor down to the new bottom so the user can see the status lines
    304304            COORD pos = makeCOORD(0, this->inputLineRow_ + this->inputLineHeight_ - 1 + this->statusLines_);
    … …  
    312312            // Scroll output up
    313313            SMALL_RECT oldRect = makeSMALL_RECT(0, lines - linesDown, this->terminalWidth_ - 1, this->inputLineRow_ - 1);
    314             ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, 0), &fillChar);
     314            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, nullptr, makeCOORD(0, 0), &fillChar);
    315315        }
    316316    }
    … …  
    360360            SMALL_RECT oldRect = makeSMALL_RECT(0, statusLineRow, this->terminalWidth_ - 1, statusLineRow + this->statusLines_);
    361361            CHAR_INFO fillChar = {{' '}, FOREGROUND_BLUE | FOREGROUND_GREEN | FOREGROUND_RED};
    362             ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, NULL, makeCOORD(0, statusLineRow + newLines), &fillChar);
     362            ScrollConsoleScreenBuffer(stdOutHandle_, &oldRect, nullptr, makeCOORD(0, statusLineRow + newLines), &fillChar);
    363363            // Clear potential leftovers
    364364            if (-newLines - this->statusLines_ > 0)

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

    r10624 r10765  
    228228        @brief Executes Tcl-code and returns the return-value.
    229229        @param tclcode A string that contains Tcl-code
    230         @param error A pointer to an integer (or NULL) that is used to write an error-code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
     230        @param error A pointer to an integer (or nullptr) that is used to write an error-code (see @ref CommandExecutorErrorCodes "CommandExecutor error codes")
    231231        @return Returns the return-value of the executed code (or an empty string if there's no return-value)
    232232    */

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

    r10733 r10765  
    275275
    276276    /**
    277         @brief Returns a pointer to the section with given name (or NULL if the section doesn't exist).
     277        @brief Returns a pointer to the section with given name (or nullptr if the section doesn't exist).
    278278    */
    279279    ConfigFileSection* ConfigFile::getSection(const std::string& section) const
    … …  
    282282            if ((*it)->getName() == section)
    283283                return (*it);
    284         return NULL;
     284        return nullptr;
    285285    }
    286286

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

    r9559 r10765  
    4444    ConfigFileManager* ConfigFileManager::singletonPtr_s = 0;
    4545
    46     /// Constructor: Initializes the array of config files with NULL.
     46    /// Constructor: Initializes the array of config files with nullptr.
    4747    ConfigFileManager::ConfigFileManager()
    4848    {
    49         this->configFiles_.assign(NULL);
     49        this->configFiles_.assign(nullptr);
    5050    }
    5151

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

    r9559 r10765  
    9999
    100100    /**
    101         @brief Returns the entry with given name (or NULL if it doesn't exist).
     101        @brief Returns the entry with given name (or nullptr if it doesn't exist).
    102102
    103103        @param name     The name of the entry
    … …  
    110110                return *it;
    111111        }
    112         return NULL;
     112        return nullptr;
    113113    }
    114114
    115115    /**
    116         @brief Returns the entry of a vector element with given name and index (or NULL if it doesn't exist).
     116        @brief Returns the entry of a vector element with given name and index (or nullptr if it doesn't exist).
    117117
    118118        @param name     The name of the vector
    … …  
    126126                return *it;
    127127        }
    128         return NULL;
     128        return nullptr;
    129129    }
    130130

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

    r9667 r10765  
    223223            inline const std::string& getSectionName() const
    224224                { return this->sectionname_; }
    225             /// Returns the associated identifier (can be NULL).
     225            /// Returns the associated identifier (can be nullptr).
    226226            inline Identifier* getIdentifier() const
    227227                { return this->identifier_; }

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

    r10624 r10765  
    106106    void SettingsConfigFile::addConfigValueContainer(ConfigValueContainer* container)
    107107    {
    108         if (container == NULL)
     108        if (container == nullptr)
    109109            return;
    110110        std::pair<std::string, ConfigValueContainer*> second(getLowercase(container->getName()), container);
    … …  
    118118    void SettingsConfigFile::removeConfigValueContainer(ConfigValueContainer* container)
    119119    {
    120         if (container == NULL)
     120        if (container == nullptr)
    121121            return;
    122122        const std::string& sectionLC = getLowercase(container->getSectionName());
    … …  
    269269            {
    270270                std::string value;
    271                 it->second.second->getValue<std::string, void>(&value, NULL);
     271                it->second.second->getValue<std::string, void>(&value, nullptr);
    272272                return value;
    273273            }

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

    r10624 r10765  
    210210        catch (const std::exception& ex)
    211211        {
    212             oisInputManager_ = NULL;
     212            oisInputManager_ = nullptr;
    213213            internalState_ |= Bad;
    214214            ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
    … …  
    312312        BOOST_FOREACH(InputDevice*& device, devices_)
    313313        {
    314             if (device == NULL)
     314            if (device == nullptr)
    315315                continue;
    316316            const std::string& className = device->getClassName();
    … …  
    321321        devices_.resize(InputDeviceEnumerator::FirstJoyStick);
    322322
    323         assert(oisInputManager_ != NULL);
     323        assert(oisInputManager_ != nullptr);
    324324        try
    325325        {
    … …  
    331331                                                   << "Potential resource leak!" << endl;
    332332        }
    333         oisInputManager_ = NULL;
     333        oisInputManager_ = nullptr;
    334334
    335335        internalState_ |= Bad;
    … …  
    388388        // No event gets triggered here yet!
    389389        BOOST_FOREACH(InputDevice* device, devices_)
    390             if (device != NULL)
     390            if (device != nullptr)
    391391                device->update(time);
    392392
    … …  
    419419        for (unsigned int i = 0; i < devices_.size(); ++i)
    420420        {
    421             if (devices_[i] == NULL)
     421            if (devices_[i] == nullptr)
    422422                continue;
    423423            std::vector<InputState*>& states = devices_[i]->getStateListRef();
    … …  
    439439        std::set<InputState*> tempSet;
    440440        for (unsigned int i = 0; i < devices_.size(); ++i)
    441             if (devices_[i] != NULL)
     441            if (devices_[i] != nullptr)
    442442                for (unsigned int iState = 0; iState < devices_[i]->getStateListRef().size(); ++iState)
    443443                    tempSet.insert(devices_[i]->getStateListRef()[iState]);
    … …  
    467467    {
    468468        BOOST_FOREACH(InputDevice* device, devices_)
    469             if (device != NULL)
     469            if (device != nullptr)
    470470                device->clearBuffers();
    471471    }
    … …  
    477477
    478478        BOOST_FOREACH(InputDevice* device, devices_)
    479             if (device != NULL)
     479            if (device != nullptr)
    480480                device->startCalibration();
    481481
    … …  
    488488    {
    489489        BOOST_FOREACH(InputDevice* device, devices_)
    490             if (device != NULL)
     490            if (device != nullptr)
    491491                device->stopCalibration();
    492492
    … …  
    509509    {
    510510        Mouse* mouse = static_cast<Mouse*>(devices_[InputDeviceEnumerator::Mouse]);
    511         if (mouse != NULL)
     511        if (mouse != nullptr)
    512512        {
    513513            const OIS::MouseState state = mouse->getOISDevice()->getMouseState();

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

    r8729 r10765  
    134134            Returns a pointer to a InputState referenced by name.
    135135        @return
    136             Returns NULL if state was not found.
     136            Returns nullptr if state was not found.
    137137        */
    138138        InputState* getState(const std::string& name);

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

    r8729 r10765  
    4949            priority_ = 0;
    5050
    51         handlers_.resize(InputDeviceEnumerator::FirstJoyStick + this->getJoyStickList().size(), NULL);
     51        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + this->getJoyStickList().size(), nullptr);
    5252    }
    5353
    … …  
    5555    {
    5656        if (device < handlers_.size())
    57             return handlers_[device] != NULL;
     57            return handlers_[device] != nullptr;
    5858        else
    5959            return false;
    … …  
    6464    {
    6565        unsigned int oldSize = handlers_.size();
    66         handlers_.resize(InputDeviceEnumerator::FirstJoyStick + joyStickList.size(), NULL);
     66        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + joyStickList.size(), nullptr);
    6767
    6868        for (unsigned int i = oldSize; i < handlers_.size(); ++i)

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

    r8729 r10765  
    179179    {
    180180        for (unsigned int i = 0; i < handlers_.size(); ++i)
    181             if (handlers_[i] != NULL)
     181            if (handlers_[i] != nullptr)
    182182                INPUT_STATE_PUSH_CALL(i, allDevicesUpdated, dt);
    183183    }
    … …  
    188188        {
    189189        case InputDeviceEnumerator::Keyboard:
    190             if (handlers_[keyboardIndex_s] != NULL)
     190            if (handlers_[keyboardIndex_s] != nullptr)
    191191                INPUT_STATE_PUSH_CALL(keyboardIndex_s, keyboardUpdated, dt);
    192192            break;
    193193
    194194        case InputDeviceEnumerator::Mouse:
    195             if (handlers_[mouseIndex_s] != NULL)
     195            if (handlers_[mouseIndex_s] != nullptr)
    196196                INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseUpdated, dt);
    197197            break;
    198198
    199199        default: // joy sticks
    200             if (handlers_[device] != NULL)
     200            if (handlers_[device] != nullptr)
    201201                INPUT_STATE_PUSH_CALL(device, joyStickUpdated, device - firstJoyStickIndex_s, dt);
    202202            break;
    … …  
    208208    {
    209209        assert(device < handlers_.size());
    210         if (handlers_[device] != NULL)
     210        if (handlers_[device] != nullptr)
    211211        {
    212212            // We have to store the function pointer to tell the compiler about its actual type because of overloading
    … …  
    218218    ORX_FORCEINLINE void InputState::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
    219219    {
    220         if (handlers_[mouseIndex_s] != NULL)
     220        if (handlers_[mouseIndex_s] != nullptr)
    221221            INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseMoved, abs, rel, clippingSize);
    222222    }
    … …  
    224224    ORX_FORCEINLINE void InputState::mouseScrolled(int abs, int rel)
    225225    {
    226         if (handlers_[mouseIndex_s] != NULL)
     226        if (handlers_[mouseIndex_s] != nullptr)
    227227            INPUT_STATE_PUSH_CALL(mouseIndex_s, mouseScrolled, abs, rel);
    228228    }
    … …  
    231231    {
    232232        assert(device < handlers_.size());
    233         if (handlers_[device] != NULL)
     233        if (handlers_[device] != nullptr)
    234234            INPUT_STATE_PUSH_CALL(device, axisMoved, device - firstJoyStickIndex_s, axis, value);
    235235    }

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

    r10624 r10765  
    5353        : deriveTime_(0.0f)
    5454        , filename_(filename)
    55         , configFile_(NULL)
    56         , fallbackConfigFile_(NULL)
     55        , configFile_(nullptr)
     56        , fallbackConfigFile_(nullptr)
    5757    {
    5858        mouseRelative_[0] = 0;
    … …  
    170170
    171171        // load the bindings if required
    172         if (configFile_ != NULL)
     172        if (configFile_ != nullptr)
    173173        {
    174174            for (unsigned int iDev = oldValue; iDev < joySticks_.size(); ++iDev)

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

    r9978 r10765  
    159159        //! Name of the file used in this KeyBinder (constant!)
    160160        const std::string filename_;
    161         //! Config file used. NULL in case of KeyDetector. Also indicates whether we've already loaded.
     161        //! Config file used. nullptr in case of KeyDetector. Also indicates whether we've already loaded.
    162162        ConfigFile* configFile_;
    163163        //! Config file from the data directory that only serves as fallback

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

    r10624 r10765  
    5656
    5757    KeyBinderManager::KeyBinderManager()
    58         : currentBinder_(NULL)
     58        : currentBinder_(nullptr)
    5959        , bDefaultFileLoaded_(true)
    6060        , bBinding_(false)

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

    r9667 r10765  
    107107
    108108        // KeyBinder management
    109         KeyBinder* currentBinder_;                   //! Currently selected KeyBinder (never NULL!)
     109        KeyBinder* currentBinder_;                   //! Currently selected KeyBinder (never nullptr!)
    110110        std::map<std::string, KeyBinder*> binders_;  //! All loaded KeyBinders
    111111        bool bDefaultFileLoaded_;                    //! Tells whether the default one is loaded

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

    r10624 r10765  
    6262    KeyDetector::~KeyDetector()
    6363    {
    64         inputState_->setHandler(NULL);
     64        inputState_->setHandler(nullptr);
    6565        InputManager::getInstance().destroyState("detector");
    6666        ModifyConsoleCommand(__CC_KeyDetector_callback_name).resetFunction();

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

    r10540 r10765  
    5656    {
    5757        mName = name;
    58         m_hInst = NULL;
     58        m_hInst = nullptr;
    5959    }
    6060
    … …  
    127127            FORMAT_MESSAGE_FROM_SYSTEM |
    128128            FORMAT_MESSAGE_IGNORE_INSERTS,
    129             NULL,
     129            nullptr,
    130130            GetLastError(),
    131131            MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
    132132            (LPTSTR) &lpMsgBuf,
    133133            0,
    134             NULL
     134            nullptr
    135135            );
    136136        std::string ret = (char*)lpMsgBuf;

  • code/branches/cpp11_v2/src/libraries/core/module/DynLib.h

    r10541 r10765  
    4545#if defined(ORXONOX_PLATFORM_WINDOWS)
    4646#    define DYNLIB_HANDLE hInstance
    47 #    define DYNLIB_LOAD( a ) LoadLibraryEx( a, NULL, LOAD_WITH_ALTERED_SEARCH_PATH )
     47#    define DYNLIB_LOAD( a ) LoadLibraryEx( a, nullptr, LOAD_WITH_ALTERED_SEARCH_PATH )
    4848#    define DYNLIB_GETSYM( a, b ) GetProcAddress( a, b )
    4949#    define DYNLIB_UNLOAD( a ) !FreeLibrary( a )
    … …  
    104104                the symbol.
    105105            @par
    106                 If the function fails, the returned value is <b>NULL</b>.
     106                If the function fails, the returned value is <b>nullptr</b>.
    107107
    108108        */

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

    r10549 r10765  
    3333namespace orxonox
    3434{
    35     ModuleInstance* ModuleInstance::currentModuleInstance_s = NULL;
     35    ModuleInstance* ModuleInstance::currentModuleInstance_s = nullptr;
    3636
    3737    ModuleInstance::ModuleInstance(const std::string& libraryName)
    3838        : libraryName_(libraryName)
    39         , dynLib_(NULL)
     39        , dynLib_(nullptr)
    4040    {
    4141    }

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

    r10553 r10765  
    3838    {
    3939        this->referenceCounter_ = 0;
    40         this->moduleInstance_ = NULL;
     40        this->moduleInstance_ = nullptr;
    4141    }
    4242
    4343    Plugin::~Plugin()
    4444    {
    45         if (this->moduleInstance_ != NULL)
     45        if (this->moduleInstance_ != nullptr)
    4646        {
    4747            this->referenceCounter_ = 1; // force unloading
    … …  
    7777            Core::getInstance().unloadModule(this->moduleInstance_);
    7878            delete this->moduleInstance_;
    79             this->moduleInstance_ = NULL;
     79            this->moduleInstance_ = nullptr;
    8080        }
    8181        else

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

    r10580 r10765  
    5656    PluginManager::~PluginManager()
    5757    {
    58         ModifyConsoleCommand("PluginManager", __CC_PluginManager_load_name).setObject(NULL);
    59         ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(NULL);
     58        ModifyConsoleCommand("PluginManager", __CC_PluginManager_load_name).setObject(nullptr);
     59        ModifyConsoleCommand("PluginManager", __CC_PluginManager_unload_name).setObject(nullptr);
    6060
    6161        for (std::map<std::string, PluginReference*>::iterator it = this->references_.begin(); it != this->references_.end(); ++it)
    … …  
    8989    {
    9090        Plugin* plugin = this->plugins_[name];
    91         if (plugin != NULL)
     91        if (plugin != nullptr)
    9292            plugin->load();
    9393        else
    … …  
    9898    {
    9999        Plugin* plugin = this->plugins_[name];
    100         if (plugin != NULL)
     100        if (plugin != nullptr)
    101101            plugin->unload();
    102102        else
    … …  
    109109    void PluginManager::loadPlugin(const std::string& name)
    110110    {
    111         if (this->references_[name] == NULL)
     111        if (this->references_[name] == nullptr)
    112112        {
    113113            this->references_[name] = new PluginReference(name);
    … …  
    124124    {
    125125        PluginReference* reference = this->references_[name];
    126         if (reference != NULL)
     126        if (reference != nullptr)
    127127        {
    128             this->references_[name] = NULL;
     128            this->references_[name] = nullptr;
    129129            delete reference;
    130130        }

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

    r10624 r10765  
    4646        static size_t count = 0;
    4747        // the first time this is called, ++count returns 1 and the context is created
    48         // the second time this is called, ++count returns 2 and NULL is returned because we're in the constructor of the context itself
     48        // the second time this is called, ++count returns 2 and nullptr is returned because we're in the constructor of the context itself
    4949        // for each future call the context (now completely created) is returned
    5050        if (++count == 2)
    51             return NULL;
     51            return nullptr;
    5252        else
    5353        {
    54             static Context context(NULL);
     54            static Context context(nullptr);
    5555            return &context;
    5656        }
    … …  
    8282    {
    8383        delete Context::rootContext_s;
    84         Context::rootContext_s = NULL;
     84        Context::rootContext_s = nullptr;
    8585    }
    8686
    8787    /*static*/ Context* Context::getRootContext()
    8888    {
    89         OrxVerify(Context::rootContext_s != NULL, "Root Context is undefined");
     89        OrxVerify(Context::rootContext_s != nullptr, "Root Context is undefined");
    9090        return Context::rootContext_s;
    9191    }
    … …  
    105105        ObjectListBase* objectList = this->getObjectList(identifier);
    106106        delete objectList;
    107         this->objectLists_[identifier->getClassID()] = NULL;
     107        this->objectLists_[identifier->getClassID()] = nullptr;
    108108    }
    109109}

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

    r10624 r10765  
    6666    void Destroyable::destroy()
    6767    {
    68         assert(this); // Just in case someone tries to delete a NULL pointer
     68        assert(this); // Just in case someone tries to delete a nullptr
    6969        this->requestedDestruction_ = true;
    7070        if (this->referenceCount_ == 0)

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

    r10736 r10765  
    5858                @brief Constructor: Sets the element, whereon the iterator points, to the given element.
    5959            */
    60             inline IteratorBase(ObjectListElement<T>* element = NULL)
     60            inline IteratorBase(ObjectListElement<T>* element = nullptr)
    6161            {
    6262                this->element_ = element;
    … …  
    151151            inline operator bool() const
    152152            {
    153                 return (this->element_ != NULL);
     153                return (this->element_ != nullptr);
    154154            }
    155155
    … …  
    208208                }
    209209                else
    210                     this->list_ = NULL;
     210                    this->list_ = nullptr;
    211211            }
    212212

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

    r10745 r10765  
    248248            }
    249249
    250             /// Returns true if the wrapped pointer is NULL.
     250            /// Returns true if the wrapped pointer is nullptr.
    251251            inline bool operator!() const
    252252            {
    … …  
    269269            }
    270270
    271             /// Resets the strong pointer (equivalent to assigning a NULL pointer).
     271            /// Resets the strong pointer (equivalent to assigning a nullptr).
    272272            inline void reset()
    273273            {

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

    r10745 r10765  
    3737
    3838    A WeakPtr wraps a pointer to an object. If the object gets deleted, the WeakPtr becomes
    39     NULL. This can be used to store pointers to objects without knowing when they will be
     39    nullptr. This can be used to store pointers to objects without knowing when they will be
    4040    destroyed.
    4141
    … …  
    5050    WeakPtr<MyClass> pointer = object;                  // create a WeakPtr and assign the object
    5151
    52     if (pointer)                                        // checks if pointer is not NULL (which is true)
     52    if (pointer)                                        // checks if pointer is not nullptr (which is true)
    5353        pointer->someFunction();                        // calls MyClass::someFunction()
    5454
    5555    object->destroy();                                  // calls destroy() which deletes the object
    5656
    57     if (pointer)                                        // checks if pointer is not NULL (which is now false)
     57    if (pointer)                                        // checks if pointer is not nullptr (which is now false)
    5858        pointer->someFunction();                        // this will not be executed
    5959    @endcode
    … …  
    9191{
    9292    /**
    93         @brief WeakPtr wraps a pointer to an object, which becomes NULL if the object is deleted.
     93        @brief WeakPtr wraps a pointer to an object, which becomes nullptr if the object is deleted.
    9494
    9595        @see See @ref WeakPtrExample "this description" for more information and an example.
    … …  
    183183            }
    184184
    185             /// Returns true if the wrapped pointer is NULL.
     185            /// Returns true if the wrapped pointer is nullptr.
    186186            inline bool operator!() const
    187187            {
    … …  
    210210            }
    211211
    212             /// Resets the weak pointer (equivalent to assigning a NULL pointer).
     212            /// Resets the weak pointer (equivalent to assigning a nullptr).
    213213            inline void reset()
    214214            {

  • code/branches/cpp11_v2/src/libraries/core/singleton/ScopedSingletonIncludes.h

    r10535 r10765  
    7171*/
    7272#define ManageScopedSingleton(className, scope, allowedToFail) \
    73     className* className::singletonPtr_s = NULL; \
     73    className* className::singletonPtr_s = nullptr; \
    7474    static ScopedSingletonWrapper& className##ScopedSingletonWrapper \
    7575        = (new orxonox::SI_SSW(new ClassScopedSingletonWrapper<className, allowedToFail>(#className), scope))->getWrapper()

  • code/branches/cpp11_v2/src/libraries/core/singleton/ScopedSingletonWrapper.h

    r10528 r10765  
    9191        ClassScopedSingletonWrapper(const std::string& className)
    9292            : ScopedSingletonWrapper(className)
    93             , singletonPtr_(NULL)
     93            , singletonPtr_(nullptr)
    9494        {
    9595        }
    … …  
    104104        void activated()
    105105        {
    106             assert(singletonPtr_ == NULL);
     106            assert(singletonPtr_ == nullptr);
    107107            singletonPtr_ = new T();
    108108        }
    … …  
    111111        void deactivated()
    112112        {
    113             assert(singletonPtr_ != NULL);
     113            assert(singletonPtr_ != nullptr);
    114114            this->destroy(singletonPtr_);
    115             singletonPtr_ = NULL;
     115            singletonPtr_ = nullptr;
    116116        }
    117117
    … …  
    146146        ClassScopedSingletonWrapper(const std::string& className)
    147147            : ScopedSingletonWrapper(className)
    148             , singletonPtr_(NULL)
     148            , singletonPtr_(nullptr)
    149149        {
    150150        }
    … …  
    159159        void activated()
    160160        {
    161             assert(singletonPtr_ == NULL);
     161            assert(singletonPtr_ == nullptr);
    162162            try
    163163                { singletonPtr_ = new T(); }
    … …  
    171171        void deactivated()
    172172        {
    173             if (singletonPtr_ != NULL)
     173            if (singletonPtr_ != nullptr)
    174174            {
    175175                this->destroy(singletonPtr_);
    176                 singletonPtr_ = NULL;
     176                singletonPtr_ = nullptr;
    177177            }
    178178        }

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

    r8858 r10765  
    4444    Connection(NETWORK_PEER_ID_SERVER),
    4545    established_(false),
    46     server_(NULL)
     46    server_(nullptr)
    4747  {
    4848    this->serverAddress_ = new ENetAddress();
    … …  
    7272
    7373    // create host
    74     this->host_ = enet_host_create(NULL, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
     74    this->host_ = enet_host_create(nullptr, NETWORK_CLIENT_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
    7575   
    76     if ( this->host_ == NULL )
     76    if ( this->host_ == nullptr )
    7777    {
    78       orxout(internal_error, context::network) << "ClientConnection: host_ == NULL" << endl;
     78      orxout(internal_error, context::network) << "ClientConnection: host_ == nullptr" << endl;
    7979      // error handling
    8080      return false;
    … …  
    9393
    9494    this->server_ = enet_host_connect(this->host_, serverAddress_, NETWORK_CHANNEL_COUNT, 0);
    95     if ( this->server_==NULL )
     95    if ( this->server_==nullptr )
    9696    {
    97       orxout(internal_error, context::network) << "ClientConnection: server_ == NULL" << endl;
     97      orxout(internal_error, context::network) << "ClientConnection: server_ == nullptr" << endl;
    9898      // error handling
    9999      return false;

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

    r10624 r10765  
    4848bool FunctionCall::execute(){
    4949  NetworkFunctionBase* fct = NetworkFunctionManager::getInstance().getFunctionByNetworkId( this->functionID_ );
    50   assert( fct != NULL );
     50  assert( fct != nullptr );
    5151  assert( this->nrOfArguments_==this->arguments_.size() );
    5252  switch(this->nrOfArguments_)

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

    r10622 r10765  
    8585      assert( this->host_ == 0 );
    8686      this->host_ = enet_host_create( &bindAddress, 10, 0, 0, 0 );
    87       if ( this->host_ == NULL )
    88           orxout(internal_error, context::network) << "LANDiscoverable: host_ == NULL" << endl;
     87      if ( this->host_ == nullptr )
     88          orxout(internal_error, context::network) << "LANDiscoverable: host_ == nullptr" << endl;
    8989    }
    9090    else

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

    r10624 r10765  
    4242  LANDiscovery::LANDiscovery()
    4343  {
    44     this->host_ = enet_host_create(NULL, 10, 0, 0, 0 );
    45     if ( this->host_ == NULL )
    46         orxout(internal_error, context::network) << "LANDiscovery: host_ == NULL" << endl;
     44    this->host_ = enet_host_create(nullptr, 10, 0, 0, 0 );
     45    if ( this->host_ == nullptr )
     46        orxout(internal_error, context::network) << "LANDiscovery: host_ == nullptr" << endl;
    4747  }
    4848
    4949  LANDiscovery::~LANDiscovery()
    5050  {
    51     if (this->host_ != NULL)
     51    if (this->host_ != nullptr)
    5252      enet_host_destroy(this->host_);
    5353  }
    … …  
    6565    address.host = ENET_HOST_BROADCAST;
    6666    peer = enet_host_connect(this->host_, &address, 0, 0);
    67     if (peer == NULL)
     67    if (peer == nullptr)
    6868        orxout(internal_error, context::network) << "Could not send LAN discovery to IPv4 Broadcast." << endl;
    6969
    … …  
    7171    enet_address_set_host(&address, "ff02::1"); // TODO: use a multicast group
    7272    peer = enet_host_connect(this->host_, &address, 0, 0);
    73     if (peer == NULL)
     73    if (peer == nullptr)
    7474        orxout(internal_error, context::network) << "Could not send LAN discovery to IPv6 Multicast." << endl;
    7575

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

    r10624 r10765  
    4343
    4444  /* forward declaration so the linker doesn't complain */
    45   MasterServer *MasterServer::instance = NULL;
     45  MasterServer *MasterServer::instance = nullptr;
    4646
    4747  /* command: list servers */
    … …  
    345345    /***** ENTER MAIN LOOP *****/
    346346    ENetEvent *event = (ENetEvent *)calloc(sizeof(ENetEvent), sizeof(char));
    347     if( event == NULL )
     347    if( event == nullptr )
    348348    {
    349349      orxout(user_error, context::master_server) << "Could not create ENetEvent structure, exiting." << endl;

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

    r8858 r10765  
    5454
    5555    /* initiate the client */
    56     this->client = enet_host_create( NULL /* create a client host */,
     56    this->client = enet_host_create( nullptr /* create a client host */,
    5757        1,
    5858        2, /* allow up 2 channels to be used, 0 and 1 */
    … …  
    6161
    6262    /* see if it worked */
    63     if (this->client == NULL)
     63    if (this->client == nullptr)
    6464    { orxout(internal_error, context::master_server) << "An error occurred while trying to create an "
    6565        << "ENet client host." << endl;
    … …  
    8585    this->peer = enet_host_connect(this->client, &this->address, 2, 0);   
    8686
    87     if( this->peer == NULL )
     87    if( this->peer == nullptr )
    8888    { orxout(internal_error, context::master_server) << "No available peers for initiating an ENet"
    8989        << " connection." << endl;
    … …  
    157157
    158158    /* address buffer */
    159     char *addrconv = NULL;
     159    char *addrconv = nullptr;
    160160    int retval = 0;
    161161
    … …  
    193193
    194194          /* call the supplied callback, if any. */
    195           if( listener != NULL )
     195          if( listener != nullptr )
    196196            retval = listener->rhandler( addrconv, &(this->event) );
    197197

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

    r10624 r10765  
    7171            return it->second;
    7272        else
    73             return NULL;
     73            return nullptr;
    7474    }
    7575

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

    r10622 r10765  
    4141  PeerList::addPeer( ENetPeer *toadd )
    4242  { /* error correction */
    43     if( toadd == NULL )
     43    if( toadd == nullptr )
    4444    { orxout(internal_error, context::master_server) << "PeerList::addPeer: empty peer given." << endl;
    4545      return -1;
    … …  
    9292
    9393    /* not found */
    94     return NULL;
     94    return nullptr;
    9595  }
    9696

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

    r10622 r10765  
    244244  {
    245245//     ClientInformation *temp = ClientInformation::getBegin();
    246 //     if( temp == NULL )
     246//     if( temp == nullptr )
    247247      //no client connected
    248248    if( this->clientIDs_.size()==0 )
    … …  
    255255    }
    256256//     orxout(verbose, context::network) << "sending DeleteObjects" << endl;
    257 //     while(temp != NULL){
     257//     while(temp != nullptr){
    258258//       if( !(temp->getSynched()) )
    259259//       {

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

    r8858 r10765  
    7373    this->host_ = enet_host_create(this->bindAddress_, NETWORK_MAX_CONNECTIONS, NETWORK_CHANNEL_COUNT, 0, 0);
    7474   
    75     if ( this->host_ == NULL )
     75    if ( this->host_ == nullptr )
    7676    {
    77         orxout(internal_error, context::network) << "ServerConnection: host_ == NULL" << endl;
     77        orxout(internal_error, context::network) << "ServerConnection: host_ == nullptr" << endl;
    7878        return false;
    7979    }

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

    r9667 r10765  
    5858  for(;it != IdentifierManager::getInstance().getIdentifierByStringMap().end();++it){
    5959    id = it->second;
    60     if(id == NULL || !id->hasFactory())
     60    if(id == nullptr || !id->hasFactory())
    6161      continue;
    6262    const std::string& classname = id->getName();
    … …  
    144144    id=ClassByString( std::string((const char*)classname) );
    145145    orxout(internal_info, context::packets) << "processing classid: " << networkID << " name: " << classname << " id: " << id << endl;
    146     if(id==NULL){
     146    if(id==nullptr){
    147147      orxout(user_error, context::packets) << "Received a bad classname" << endl;
    148148      abort();

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

    r9667 r10765  
    608608
    609609  if(dest_length==0)
    610     return NULL;
     610    return nullptr;
    611611
    612612  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];
    … …  
    645645
    646646  if(dest_length==0)
    647     return NULL;
     647    return nullptr;
    648648
    649649  uint8_t *ndata = new uint8_t[dest_length*sizeof(uint8_t)+GamestateHeader::getSize()];

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

    r8858 r10765  
    122122  // Destroy the ENetPacket if necessary.
    123123  // Note: For the case ENet used the callback to destroy the packet, we have already set
    124   // enetPacket_ to NULL to avoid destroying it again.
     124  // enetPacket_ to nullptr to avoid destroying it again.
    125125  if (this->enetPacket_)
    126126  {

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

    r10624 r10765  
    105105  uint32_t Synchronisable::findContextID(Context* context)
    106106  {
    107       if (context == NULL)
     107      if (context == nullptr)
    108108          return OBJECTID_UNKNOWN;
    109109
    110110      Synchronisable* synchronisableContext = orxonox_cast<Synchronisable*>(context);
    111       if (synchronisableContext != NULL)
     111      if (synchronisableContext != nullptr)
    112112          return synchronisableContext->getObjectID();
    113113      else
    … …  
    226226      return it1->second;
    227227    // if the objects not in the map it should'nt exist at all anymore
    228     return NULL;
     228    return nullptr;
    229229  }
    230230

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

    r9667 r10765  
    9393    {
    9494        if (index >= resourceLocations_.size())
    95             return NULL;
     95            return nullptr;
    9696        else
    9797            return resourceLocations_[index];

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

    r10727 r10765  
    109109    {
    110110        // For the moment, we get the viewport always from the graphics manager
    111         // TODO: Try to support multiple viewports - note however that scenemanager_->getCurrentViewport() returns NULL
     111        // TODO: Try to support multiple viewports - note however that scenemanager_->getCurrentViewport() returns nullptr
    112112        //       after switching to a camera in a different scene (only for the first time this scene is displayed though)
    113113        this->changedCompositorName(GraphicsManager::getInstance().getViewport());

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

    r8858 r10765  
    9393            {
    9494                HANDLE hData = GetClipboardData(CF_TEXT);
    95                 if (hData == NULL)
     95                if (hData == nullptr)
    9696                    return "";
    9797                std::string output(static_cast<char*>(GlobalLock(hData)));

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

    r8423 r10765  
    3636    /** Deletes an object and resets the pointer
    3737    @param object
    38         Pointer to an object. Handing over NULL is safe.
     38        Pointer to an object. Handing over nullptr is safe.
    3939    */
    4040    template <class T>
    … …  
    4242    {
    4343        delete *object;
    44         *object = NULL;
     44        *object = nullptr;
    4545    }
    4646

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

    r10745 r10765  
    215215
    216216        public:
    217             /// Default constructor, the pointer is set to NULL.
     217            /// Default constructor, the pointer is set to nullptr.
    218218            inline SharedPtr() : pointer_(0), counter_(0)
    219219            {
    … …  
    310310            }
    311311
    312             /// Returns true if the pointer is not NULL.
     312            /// Returns true if the pointer is not nullptr.
    313313            inline operator bool() const
    314314            {

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

    r9682 r10765  
    4444namespace orxonox
    4545{
    46     SignalHandler* SignalHandler::singletonPtr_s = NULL;
     46    SignalHandler* SignalHandler::singletonPtr_s = nullptr;
    4747}
    4848
    … …  
    175175        dup2( gdbErr[1], STDERR_FILENO );
    176176
    177         execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(NULL));
     177        execlp( "sh", "sh", "-c", "gdb", static_cast<void*>(nullptr));
    178178      }
    179179
    … …  
    186186        perror("pipe failed!\n");
    187187        kill( gdbPid, SIGTERM );
    188         waitpid( gdbPid, NULL, 0 );
     188        waitpid( gdbPid, nullptr, 0 );
    189189        exit(EXIT_FAILURE);
    190190      }
    … …  
    196196        perror("fork failed!\n");
    197197        kill( gdbPid, SIGTERM );
    198         waitpid( gdbPid, NULL, 0 );
     198        waitpid( gdbPid, nullptr, 0 );
    199199        exit(EXIT_FAILURE);
    200200      }
    … …  
    297297
    298298
    299       waitpid( sigPid, NULL, 0 );
    300       waitpid( gdbPid, NULL, 0 );
     299      waitpid( sigPid, nullptr, 0 );
     300      waitpid( gdbPid, nullptr, 0 );
    301301
    302302      int wsRemoved = 0;
    … …  
    312312        bt.erase(0, 1);
    313313
    314       time_t now = time(NULL);
     314      time_t now = time(nullptr);
    315315
    316316      std::string timeString =
    … …  
    388388    SignalHandler::SignalHandler()
    389389    {
    390         this->prevExceptionFilter_ = NULL;
     390        this->prevExceptionFilter_ = nullptr;
    391391    }
    392392
    … …  
    394394    SignalHandler::~SignalHandler()
    395395    {
    396         if (this->prevExceptionFilter_ != NULL)
     396        if (this->prevExceptionFilter_ != nullptr)
    397397        {
    398398            // Remove the unhandled exception filter function
    399399            SetUnhandledExceptionFilter(this->prevExceptionFilter_);
    400             this->prevExceptionFilter_ = NULL;
     400            this->prevExceptionFilter_ = nullptr;
    401401        }
    402402    }
    … …  
    408408
    409409        // don't register twice
    410         assert(this->prevExceptionFilter_ == NULL);
    411 
    412         if (this->prevExceptionFilter_ == NULL)
     410        assert(this->prevExceptionFilter_ == nullptr);
     411
     412        if (this->prevExceptionFilter_ == nullptr)
    413413        {
    414414            // Install the unhandled exception filter function
    … …  
    441441            std::ofstream crashlog(SignalHandler::getInstance().filename_.c_str());
    442442
    443             time_t now = time(NULL);
     443            time_t now = time(nullptr);
    444444
    445445            crashlog << "=======================================================" << endl;
    … …  
    480480    }
    481481
    482     /// Returns the stack trace for either the current function, or, if @a pExceptionInfo is not NULL, for the given exception context.
     482    /// Returns the stack trace for either the current function, or, if @a pExceptionInfo is not nullptr, for the given exception context.
    483483    /* static */ std::string SignalHandler::getStackTrace(PEXCEPTION_POINTERS pExceptionInfo)
    484484    {
    … …  
    625625#ifdef ORXONOX_COMPILER_GCC
    626626                int status;
    627                 char* demangled = __cxxabiv1::__cxa_demangle(symbol->Name, NULL, NULL, &status);
     627                char* demangled = __cxxabiv1::__cxa_demangle(symbol->Name, nullptr, nullptr, &status);
    628628                if (demangled)
    629629                {
    … …  
    684684        HMODULE hModule;
    685685
    686         std::string output = (GetModuleFileName(NULL, szModule, MAX_PATH) ? SignalHandler::getModuleName(szModule) : "Application");
     686        std::string output = (GetModuleFileName(nullptr, szModule, MAX_PATH) ? SignalHandler::getModuleName(szModule) : "Application");
    687687        output += " caused ";
    688688

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

    r9550 r10765  
    113113            void doCatch(const std::string& appName, const std::string& filename);
    114114
    115             static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = NULL);
     115            static std::string getStackTrace(PEXCEPTION_POINTERS pExceptionInfo = nullptr);
    116116            static std::string getExceptionType(PEXCEPTION_POINTERS pExceptionInfo);
    117117

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

    r10624 r10765  
    6666    And don't forget to initialize the static singleton pointer in the source (*.cc) %file:
    6767    @code
    68     TestSingleton* TestSingleton::singletonPtr_s = NULL;
     68    TestSingleton* TestSingleton::singletonPtr_s = nullptr;
    6969    @endcode
    7070
    … …  
    118118        static T& getInstance()
    119119        {
    120             OrxVerify(T::singletonPtr_s != NULL, "T=" << typeid(T).name());
     120            OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
    121121            return *T::singletonPtr_s;
    122122        }
    … …  
    125125        static bool exists()
    126126        {
    127             return (T::singletonPtr_s != NULL);
     127            return (T::singletonPtr_s != nullptr);
    128128        }
    129129
    … …  
    132132        Singleton()
    133133        {
    134             OrxVerify(T::singletonPtr_s == NULL, "T=" << typeid(T).name());
     134            OrxVerify(T::singletonPtr_s == nullptr, "T=" << typeid(T).name());
    135135            T::singletonPtr_s = static_cast<T*>(this);
    136136        }
    … …  
    139139        virtual ~Singleton()
    140140        {
    141             OrxVerify(T::singletonPtr_s != NULL, "T=" << typeid(T).name());
    142             T::singletonPtr_s = NULL;
     141            OrxVerify(T::singletonPtr_s != nullptr, "T=" << typeid(T).name());
     142            T::singletonPtr_s = nullptr;
    143143        }
    144144

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

    r7401 r10765  
    9797                setNext(block + i * this->chunkSize_, block + (i + 1) * this->chunkSize_);
    9898
    99             // the next_ pointer of the last chunk must point to NULL
     99            // the next_ pointer of the last chunk must point to nullptr
    100100            setNext(block + (this->numChunksPerBlock_ - 1) * this->chunkSize_, 0);
    101101

  • code/branches/cpp11_v2/src/modules/designtools/ScreenshotManager.cc

    r10624 r10765  
    6969        Constructor.
    7070    */
    71     ScreenshotManager::ScreenshotManager() : finalPicturePB_(NULL), data_(NULL)
     71    ScreenshotManager::ScreenshotManager() : finalPicturePB_(nullptr), data_(nullptr)
    7272    {
    7373        RegisterObject(ScreenshotManager);
    … …  
    9090    void ScreenshotManager::cleanup(void)
    9191    {
    92         if(this->finalPicturePB_ != NULL)
     92        if(this->finalPicturePB_ != nullptr)
    9393        {
    9494            delete this->finalPicturePB_;
    95             this->finalPicturePB_ = NULL;
    96         }
    97         if(this->data_ != NULL)
     95            this->finalPicturePB_ = nullptr;
     96        }
     97        if(this->data_ != nullptr)
    9898        {
    9999            delete this->data_;
    100             this->data_ = NULL;
     100            this->data_ = nullptr;
    101101        }
    102102        if(!this->tempTexture_.isNull())
    … …  
    151151        // Get the screenshot.
    152152        Ogre::Image* finalImage = getScreenshot();
    153         if(finalImage != NULL)
     153        if(finalImage != nullptr)
    154154        {
    155155            // Save it.
    … …  
    173173    Ogre::Image* ScreenshotManager::getScreenshot()
    174174    {
    175         if(CameraManager::getInstance().getActiveCamera() == NULL )
    176             return NULL;
     175        if(CameraManager::getInstance().getActiveCamera() == nullptr )
     176            return nullptr;
    177177        return this->getScreenshot(CameraManager::getInstance().getActiveCamera()->getOgreCamera());
    178178    }
    … …  
    189189    Ogre::Image* ScreenshotManager::getScreenshot(Ogre::Camera* camera)
    190190    {
    191         if(camera == NULL)
    192             return NULL;
     191        if(camera == nullptr)
     192            return nullptr;
    193193       
    194194        // Update the internal parameters.

  • code/branches/cpp11_v2/src/modules/designtools/SkyboxGenerator.cc

    r10624 r10765  
    146146            }
    147147
    148             ControllableEntity* entity = NULL;
    149             if(HumanController::getLocalControllerSingleton() != NULL && HumanController::getLocalControllerSingleton()->getControllableEntity() != NULL)
     148            ControllableEntity* entity = nullptr;
     149            if(HumanController::getLocalControllerSingleton() != nullptr && HumanController::getLocalControllerSingleton()->getControllableEntity() != nullptr)
    150150                entity = HumanController::getLocalControllerSingleton()->getControllableEntity();
    151151            else

  • code/branches/cpp11_v2/src/modules/docking/Dock.cc

    r10624 r10765  
    8787
    8888        PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
    89         PlayerInfo* player = NULL;
     89        PlayerInfo* player = nullptr;
    9090
    9191        // Check whether it is a player trigger and extract pawn from it
    92         if(pTrigger != NULL)
     92        if(pTrigger != nullptr)
    9393        {
    9494            if(!pTrigger->isForPlayer()) {  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
    … …  
    103103            return false;
    104104        }
    105         if(player == NULL)
     105        if(player == nullptr)
    106106        {
    107107            orxout(verbose, context::docking) << "Docking::execute Can't retrieve PlayerInfo from Trigger. (" << trigger->getIdentifier()->getName() << ")" << endl;
    … …  
    131131    {
    132132        PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
    133         PlayerInfo* player = NULL;
     133        PlayerInfo* player = nullptr;
    134134
    135135        // Check whether it is a player trigger and extract pawn from it
    136         if(pTrigger != NULL)
     136        if(pTrigger != nullptr)
    137137        {
    138138            if(!pTrigger->isForPlayer()) {  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
    … …  
    147147            return false;
    148148        }
    149         if(player == NULL)
     149        if(player == nullptr)
    150150        {
    151151            orxout(verbose, context::docking) << "Docking::execute Can't retrieve PlayerInfo from Trigger. (" << trigger->getIdentifier()->getName() << ")" << endl;
    … …  
    315315            }
    316316        }
    317         return NULL;
     317        return nullptr;
    318318    }
    319319
    … …  
    333333            i--;
    334334        }
    335         return NULL;
     335        return nullptr;
    336336    }
    337337
    … …  
    352352            i--;
    353353        }
    354         return NULL;
     354        return nullptr;
    355355    }
    356356}

  • code/branches/cpp11_v2/src/modules/docking/DockToShip.cc

    r9974 r10765  
    7272
    7373        DockingTarget *target = DockingEffect::findTarget(this->target_);
    74         if (target == NULL) {
     74        if (target == nullptr) {
    7575            orxout(internal_warning, context::docking) << "Can't retrieve target for '" << this->target_ << "'.." << endl;
    7676            return false;
    … …  
    7878
    7979        ControllableEntity *dockTo = (ControllableEntity*) target->getParent();
    80         if (dockTo == NULL) {
     80        if (dockTo == nullptr) {
    8181            orxout(internal_warning, context::docking) << "Parent is not a ControllableEntity.." << endl;
    8282            return false;

  • code/branches/cpp11_v2/src/modules/docking/DockingAnimation.cc

    r10624 r10765  
    4545        RegisterObject(DockingAnimation);
    4646
    47         this->parent_ = NULL;
     47        this->parent_ = nullptr;
    4848    }
    4949

  • code/branches/cpp11_v2/src/modules/docking/DockingController.cc

    r9667 r10765  
    4444        RegisterObject(DockingController);
    4545
    46         this->dock_ = NULL;
    47         this->player_ = NULL;
    48         this->entity_ = NULL;
     46        this->dock_ = nullptr;
     47        this->player_ = nullptr;
     48        this->entity_ = nullptr;
    4949    }
    5050
    … …  
    122122        this->player_->startControl(this->entity_);
    123123        this->setActive(false);
    124         this->controllableEntity_ = NULL;
     124        this->controllableEntity_ = nullptr;
    125125
    126126        if (this->docking_)

  • code/branches/cpp11_v2/src/modules/docking/DockingEffect.cc

    r10624 r10765  
    7070                return (*it);
    7171        }
    72         return NULL;
     72        return nullptr;
    7373    }
    7474}

  • code/branches/cpp11_v2/src/modules/dodgerace/DodgeRace.cc

    r10624 r10765  
    6767    {
    6868        level++;
    69         if (getPlayer() != NULL)
     69        if (getPlayer() != nullptr)
    7070        {
    7171            for (int i = 0; i < 7; i++)
    … …  
    8585    void DodgeRace::tick(float dt)
    8686    {
    87         if (getPlayer() != NULL)
     87        if (getPlayer() != nullptr)
    8888        {
    8989            currentPosition = getPlayer()->getWorldPosition().x;
    … …  
    134134    DodgeRaceShip* DodgeRace::getPlayer()
    135135    {
    136         if (player == NULL)
     136        if (player == nullptr)
    137137        {
    138138            for (ObjectList<DodgeRaceShip>::iterator it = ObjectList<DodgeRaceShip>::begin(); it != ObjectList<DodgeRaceShip>::end(); ++it)
    … …  
    173173        this->bForceSpawn_ = false;
    174174
    175         if (this->center_ == NULL)  // abandon mission!
     175        if (this->center_ == nullptr)  // abandon mission!
    176176        {
    177177            orxout(internal_error) << "DodgeRace: No Centerpoint specified." << endl;

  • code/branches/cpp11_v2/src/modules/dodgerace/DodgeRaceCenterPoint.cc

    r10624 r10765  
    5656    void DodgeRaceCenterPoint::checkGametype()
    5757    {
    58         if (this->getGametype() != NULL && this->getGametype()->isA(Class(DodgeRace)))
     58        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(DodgeRace)))
    5959        {
    6060            DodgeRace* DodgeRaceGametype = orxonox_cast<DodgeRace*>(this->getGametype());

  • code/branches/cpp11_v2/src/modules/dodgerace/DodgeRaceShip.cc

    r10624 r10765  
    9191        // Camera
    9292        Camera* camera = this->getCamera();
    93         if (camera != NULL)
     93        if (camera != nullptr)
    9494        {
    9595            // camera->setPosition(Vector3(-pos.z, -posforeward, 0));
    … …  
    152152    DodgeRace* DodgeRaceShip::getGame()
    153153    {
    154         if (game == NULL)
     154        if (game == nullptr)
    155155        {
    156156            for (ObjectList<DodgeRace>::iterator it = ObjectList<DodgeRace>::begin(); it != ObjectList<DodgeRace>::end(); ++it)

  • code/branches/cpp11_v2/src/modules/gametypes/RaceCheckPoint.cc

    r9973 r10765  
    125125            }
    126126        }
    127         return NULL;
     127        return nullptr;
    128128    }
    129129

  • code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceController.cc

    r10318 r10765  
    9898                    RaceCheckPoint* point2 = findCheckpoint((*numb));
    9999
    100                     //if(point2 != NULL)
     100                    //if(point2 != nullptr)
    101101                    //placeVirtualCheckpoints((*it), point2);
    102102                }
    … …  
    126126        staticRacePoints_ = findStaticCheckpoints(nextRaceCheckpoint_, checkpoints);
    127127        // initialisation of currentRaceCheckpoint_
    128         currentRaceCheckpoint_ = NULL;
     128        currentRaceCheckpoint_ = nullptr;
    129129
    130130        int i;
    131         for (i = -2; findCheckpoint(i) != NULL; i--)
     131        for (i = -2; findCheckpoint(i) != nullptr; i--)
    132132        {
    133133            continue;
    … …  
    194194                    continue;
    195195                }
    196                 if (findCheckpoint(*it) == NULL)
     196                if (findCheckpoint(*it) == nullptr)
    197197                    orxout(internal_warning) << "Problematic Point: " << (*it) << endl;
    198198                else
    … …  
    209209    float SpaceRaceController::distanceSpaceshipToCheckPoint(RaceCheckPoint* CheckPoint)
    210210    {
    211         if (this->getControllableEntity() != NULL)
     211        if (this->getControllableEntity() != nullptr)
    212212        {
    213213            return (CheckPoint->getPosition()- this->getControllableEntity()->getPosition()).length();
    … …  
    223223    {
    224224        float minDistance = 0;
    225         RaceCheckPoint* minNextRaceCheckPoint = NULL;
     225        RaceCheckPoint* minNextRaceCheckPoint = nullptr;
    226226
    227227        // find the next checkpoint with the minimal distance
    … …  
    231231            float distance = recCalculateDistance(nextRaceCheckPoint, this->getControllableEntity()->getPosition());
    232232
    233             if (distance < minDistance || minNextRaceCheckPoint == NULL)
     233            if (distance < minDistance || minNextRaceCheckPoint == nullptr)
    234234            {
    235235                minDistance = distance;
    … …  
    271271    RaceCheckPoint* SpaceRaceController::adjustNextPoint()
    272272    {
    273         if (currentRaceCheckpoint_ == NULL) // no Adjust possible
     273        if (currentRaceCheckpoint_ == nullptr) // no Adjust possible
    274274
    275275        {
    … …  
    292292            if (this->checkpoints_[i]->getCheckpointIndex() == index)
    293293                return this->checkpoints_[i];
    294         return NULL;
     294        return nullptr;
    295295    }
    296296
    … …  
    347347    void SpaceRaceController::tick(float dt)
    348348    {
    349         if (this->getControllableEntity() == NULL || this->getControllableEntity()->getPlayer() == NULL )
     349        if (this->getControllableEntity() == nullptr || this->getControllableEntity()->getPlayer() == nullptr )
    350350        {
    351351            //orxout()<< this->getControllableEntity() << " in tick"<<endl;
    … …  
    419419            {
    420420                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
    421                 if(currentShape == NULL)
     421                if(currentShape == nullptr)
    422422                continue;
    423423
    … …  
    447447            {
    448448                btCollisionShape* currentShape = (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape();
    449                 if(currentShape == NULL)
     449                if(currentShape == nullptr)
    450450                continue;
    451451
    … …  
    491491        {
    492492
    493             if (dynamic_cast<RaceCheckPoint*>(*it) != NULL)
     493            if (dynamic_cast<RaceCheckPoint*>(*it) != nullptr)
    494494            {
    495495                continue;
    … …  
    537537        //                    btVector3 positionObject;
    538538        //                    btScalar radiusObject;
    539         //                    if((*it)==NULL)
     539        //                    if((*it)==nullptr)
    540540        //                    {   orxout()<<"Problempoint 1.1"<<endl; continue;}
    541541        //                    //TODO: Probably it points on a wrong object
    542542        //                    for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
    543543        //                    {
    544         //                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
     544        //                        if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
    545545        //                        {    continue;}
    546546        //
    … …  
    570570        //                        btVector3 positionObject;
    571571        //                        btScalar radiusObject;
    572         //                        if((*it)==NULL)
     572        //                        if((*it)==nullptr)
    573573        //                        {   orxout()<<"Problempoint 1"<<endl; continue;}
    574574        //                        for (int everyShape=0; (*it)->getAttachedCollisionShape(everyShape)!=0; everyShape++)
    575575        //                        {
    576         //                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==NULL)
     576        //                            if((*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()==nullptr)
    577577        //                            {   orxout()<<"Problempoint 2.2"<<endl; continue;}
    578578        //                            (*it)->getAttachedCollisionShape(everyShape)->getCollisionShape()->getBoundingSphere(positionObject,radiusObject);

  • code/branches/cpp11_v2/src/modules/gametypes/SpaceRaceManager.cc

    r10624 r10765  
    7171        this->players_ = this->race_->getPlayers();
    7272
    73         if (this->checkpoints_[0] != NULL && !this->firstcheckpointvisible_)
     73        if (this->checkpoints_[0] != nullptr && !this->firstcheckpointvisible_)
    7474        {
    7575            this->checkpoints_[0]->setRadarVisibility(true);
    … …  
    121121    bool SpaceRaceManager::reachedValidCheckpoint(RaceCheckPoint* oldCheckpoint, RaceCheckPoint* newCheckpoint, PlayerInfo* player) const
    122122    {
    123         if (oldCheckpoint != NULL)
     123        if (oldCheckpoint != nullptr)
    124124        {
    125125            // the player already visited an old checkpoint; see which checkpoints are possible now

  • code/branches/cpp11_v2/src/modules/invader/Invader.cc

    r10733 r10765  
    7878    {
    7979        level++;
    80         if (getPlayer() != NULL)
     80        if (getPlayer() != nullptr)
    8181        {
    8282            for (int i = 0; i < 7; i++)
    … …  
    9696    InvaderShip* Invader::getPlayer()
    9797    {
    98         if (player == NULL)
     98        if (player == nullptr)
    9999        {
    100100            for (ObjectList<InvaderShip>::iterator it = ObjectList<InvaderShip>::begin(); it != ObjectList<InvaderShip>::end(); ++it)
    … …  
    106106    void Invader::spawnEnemy()
    107107    {
    108         if (getPlayer() == NULL)
     108        if (getPlayer() == nullptr)
    109109            return;
    110110
    … …  
    158158        this->bForceSpawn_ = true;
    159159
    160         if (this->center_ == NULL)  // abandon mission!
     160        if (this->center_ == nullptr)  // abandon mission!
    161161        {
    162162            orxout(internal_error) << "Invader: No Centerpoint specified." << endl;

  • code/branches/cpp11_v2/src/modules/invader/InvaderCenterPoint.cc

    r10624 r10765  
    5656    void InvaderCenterPoint::checkGametype()
    5757    {
    58         if (this->getGametype() != NULL && this->getGametype()->isA(Class(Invader)))
     58        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(Invader)))
    5959        {
    6060            Invader* InvaderGametype = orxonox_cast<Invader*>(this->getGametype());

  • code/branches/cpp11_v2/src/modules/invader/InvaderEnemy.cc

    r10733 r10765  
    5656            removeHealth(2000);
    5757
    58         if (player != NULL)
     58        if (player != nullptr)
    5959        {
    6060            float newZ = 2/(pow(abs(getPosition().x - player->getPosition().x) * 0.01f, 2) + 1) * (player->getPosition().z - getPosition().z);
    … …  
    7373    Invader* InvaderEnemy::getGame()
    7474    {
    75         if (game == NULL)
     75        if (game == nullptr)
    7676        {
    7777            for (ObjectList<Invader>::iterator it = ObjectList<Invader>::begin(); it != ObjectList<Invader>::end(); ++it)
    … …  
    8484    {
    8585        Pawn::damage(damage, healthdamage, shielddamage, originator, cs);
    86         if (getGame() && orxonox_cast<InvaderShip*>(originator) != NULL && getHealth() <= 0)
     86        if (getGame() && orxonox_cast<InvaderShip*>(originator) != nullptr && getHealth() <= 0)
    8787            getGame()->addPoints(42);
    8888    }

  • code/branches/cpp11_v2/src/modules/invader/InvaderEnemyShooter.cc

    r10733 r10765  
    5959            removeHealth(2000);
    6060
    61         if (player != NULL)
     61        if (player != nullptr)
    6262        {
    6363            float distPlayer = player->getPosition().z - getPosition().z;
    … …  
    7777    {
    7878        Pawn::damage(damage, healthdamage, shielddamage, originator, cs);
    79         if (getGame() && orxonox_cast<InvaderShip*>(originator) != NULL && getHealth() <= 0)
     79        if (getGame() && orxonox_cast<InvaderShip*>(originator) != nullptr && getHealth() <= 0)
    8080            getGame()->addPoints(3*42);
    8181    }

  • code/branches/cpp11_v2/src/modules/invader/InvaderShip.cc

    r10733 r10765  
    9595        // Camera
    9696        Camera* camera = this->getCamera();
    97         if (camera != NULL)
     97        if (camera != nullptr)
    9898        {
    9999            camera->setPosition(Vector3(-pos.z, -posforeward, 0));
    … …  
    154154        Projectile* shot = orxonox_cast<Projectile*>(otherObject);
    155155        // ensure that this gets only called once per enemy.
    156         if (enemy != NULL && lastEnemy != enemy)
     156        if (enemy != nullptr && lastEnemy != enemy)
    157157        {
    158158            lastEnemy = enemy;
    … …  
    165165        }
    166166        // was shot, decrease multiplier
    167         else if (shot != NULL  && lastShot != shot)
     167        else if (shot != nullptr  && lastShot != shot)
    168168        {
    169             if (getGame() && orxonox_cast<InvaderEnemy*>(shot->getShooter()) != NULL)
     169            if (getGame() && orxonox_cast<InvaderEnemy*>(shot->getShooter()) != nullptr)
    170170            {
    171171                if (getGame()->multiplier > 1)
    … …  
    182182    Invader* InvaderShip::getGame()
    183183    {
    184         if (game == NULL)
     184        if (game == nullptr)
    185185        {
    186186            for (ObjectList<Invader>::iterator it = ObjectList<Invader>::begin(); it != ObjectList<Invader>::end(); ++it)

  • code/branches/cpp11_v2/src/modules/jump/Jump.cc

    r10733 r10765  
    8383        SUPER(Jump, tick, dt);
    8484
    85         if (figure_ != NULL)
     85        if (figure_ != nullptr)
    8686        {
    8787            Vector3 figurePosition = figure_->getPosition();
    … …  
    130130
    131131
    132             if (camera != NULL)
     132            if (camera != nullptr)
    133133            {
    134134                Vector3 cameraPosition = Vector3(0, totalScreenShift_, 0);
    … …  
    275275    void Jump::start()
    276276    {
    277         if (center_ != NULL) // There needs to be a JumpCenterpoint, i.e. the area the game takes place.
    278         {
    279             if (figure_ == NULL)
     277        if (center_ != nullptr) // There needs to be a JumpCenterpoint, i.e. the area the game takes place.
     278        {
     279            if (figure_ == nullptr)
    280280            {
    281281                figure_ = new JumpFigure(center_->getContext());
    … …  
    298298        Deathmatch::start();
    299299
    300         if (figure_ != NULL)
     300        if (figure_ != nullptr)
    301301        {
    302302            camera = figure_->getCamera();
    … …  
    325325        assert(player);
    326326
    327         if (figure_->getPlayer() == NULL)
     327        if (figure_->getPlayer() == nullptr)
    328328        {
    329329            player->startControl(figure_);
    … …  
    334334    PlayerInfo* Jump::getPlayer() const
    335335    {
    336         if (this->figure_ != NULL)
     336        if (this->figure_ != nullptr)
    337337        {
    338338            return this->figure_->getPlayer();
    … …  
    346346    void Jump::addPlatform(JumpPlatform* newPlatform, std::string platformTemplate, float xPosition, float zPosition)
    347347    {
    348         if (newPlatform != NULL && center_ != NULL)
     348        if (newPlatform != nullptr && center_ != nullptr)
    349349        {
    350350            newPlatform->addTemplate(platformTemplate);
    … …  
    414414    {
    415415        JumpProjectile* newProjectile = new JumpProjectile(center_->getContext());
    416         if (newProjectile != NULL && center_ != NULL)
     416        if (newProjectile != nullptr && center_ != nullptr)
    417417        {
    418418            newProjectile->addTemplate(center_->getProjectileTemplate());
    … …  
    427427    {
    428428        JumpSpring* newSpring = new JumpSpring(center_->getContext());
    429         if (newSpring != NULL && center_ != NULL)
     429        if (newSpring != nullptr && center_ != nullptr)
    430430        {
    431431            newSpring->addTemplate(center_->getSpringTemplate());
    … …  
    440440    {
    441441        JumpSpring* newSpring = new JumpSpring(center_->getContext());
    442         if (newSpring != NULL && center_ != NULL)
     442        if (newSpring != nullptr && center_ != nullptr)
    443443        {
    444444            newSpring->addTemplate(center_->getSpringTemplate());
    … …  
    453453    {
    454454        JumpRocket* newRocket = new JumpRocket(center_->getContext());
    455         if (newRocket != NULL && center_ != NULL)
     455        if (newRocket != nullptr && center_ != nullptr)
    456456        {
    457457            newRocket->addTemplate(center_->getRocketTemplate());
    … …  
    466466    {
    467467        JumpRocket* newRocket = new JumpRocket(center_->getContext());
    468         if (newRocket != NULL && center_ != NULL)
     468        if (newRocket != nullptr && center_ != nullptr)
    469469        {
    470470            newRocket->addTemplate(center_->getRocketTemplate());
    … …  
    479479    {
    480480        JumpPropeller* newPropeller = new JumpPropeller(center_->getContext());
    481         if (newPropeller != NULL && center_ != NULL)
     481        if (newPropeller != nullptr && center_ != nullptr)
    482482        {
    483483            newPropeller->addTemplate(center_->getPropellerTemplate());
    … …  
    492492    {
    493493        JumpPropeller* newPropeller = new JumpPropeller(center_->getContext());
    494         if (newPropeller != NULL && center_ != NULL)
     494        if (newPropeller != nullptr && center_ != nullptr)
    495495        {
    496496            newPropeller->addTemplate(center_->getPropellerTemplate());
    … …  
    505505    {
    506506        JumpBoots* newBoots = new JumpBoots(center_->getContext());
    507         if (newBoots != NULL && center_ != NULL)
     507        if (newBoots != nullptr && center_ != nullptr)
    508508        {
    509509            newBoots->addTemplate(center_->getBootsTemplate());
    … …  
    518518    {
    519519        JumpBoots* newBoots = new JumpBoots(center_->getContext());
    520         if (newBoots != NULL && center_ != NULL)
     520        if (newBoots != nullptr && center_ != nullptr)
    521521        {
    522522            newBoots->addTemplate(center_->getBootsTemplate());
    … …  
    531531    {
    532532        JumpShield* newShield = new JumpShield(center_->getContext());
    533         if (newShield != NULL && center_ != NULL)
     533        if (newShield != nullptr && center_ != nullptr)
    534534        {
    535535            newShield->addTemplate(center_->getShieldTemplate());
    … …  
    544544    {
    545545        JumpShield* newShield = new JumpShield(center_->getContext());
    546         if (newShield != NULL && center_ != NULL)
     546        if (newShield != nullptr && center_ != nullptr)
    547547        {
    548548            newShield->addTemplate(center_->getShieldTemplate());
    … …  
    557557    {
    558558        JumpEnemy* newEnemy = new JumpEnemy(center_->getContext());
    559         if (newEnemy != NULL && center_ != NULL)
     559        if (newEnemy != nullptr && center_ != nullptr)
    560560        {
    561561            switch (type)
    … …  
    12701270    float Jump::getFuel() const
    12711271    {
    1272         if (this->figure_ != NULL)
    1273         {
    1274             if (this->figure_->rocketActive_ != NULL)
     1272        if (this->figure_ != nullptr)
     1273        {
     1274            if (this->figure_->rocketActive_ != nullptr)
    12751275            {
    12761276                return this->figure_->rocketActive_->getFuelState();
    12771277            }
    1278             else if (this->figure_->propellerActive_ != NULL)
     1278            else if (this->figure_->propellerActive_ != nullptr)
    12791279            {
    12801280                return this->figure_->propellerActive_->getFuelState();
    12811281            }
    1282             else if (this->figure_->shieldActive_ != NULL)
     1282            else if (this->figure_->shieldActive_ != nullptr)
    12831283            {
    12841284                return this->figure_->shieldActive_->getFuelState();
    12851285            }
    1286             else if (this->figure_->bootsActive_ != NULL)
     1286            else if (this->figure_->bootsActive_ != nullptr)
    12871287            {
    12881288                return this->figure_->bootsActive_->getFuelState();

  • code/branches/cpp11_v2/src/modules/jump/JumpBoots.cc

    r10733 r10765  
    7272        Vector3 rocketPosition = getWorldPosition();
    7373
    74         if (attachedToFigure_ == false && figure_ != NULL)
     74        if (attachedToFigure_ == false && figure_ != nullptr)
    7575        {
    7676            Vector3 figurePosition = figure_->getWorldPosition();

  • code/branches/cpp11_v2/src/modules/jump/JumpCenterpoint.cc

    r10733 r10765  
    8383    void JumpCenterpoint::checkGametype()
    8484    {
    85         if (getGametype() != NULL && this->getGametype()->isA(Class(Jump)))
     85        if (getGametype() != nullptr && this->getGametype()->isA(Class(Jump)))
    8686        {
    8787            Jump* jumpGametype = orxonox_cast<Jump*>(this->getGametype());

  • code/branches/cpp11_v2/src/modules/jump/JumpEnemy.cc

    r10733 r10765  
    119119        Vector3 enemyPosition = getPosition();
    120120
    121         if (figure_ != NULL)
     121        if (figure_ != nullptr)
    122122        {
    123123            Vector3 figurePosition = figure_->getPosition();

  • code/branches/cpp11_v2/src/modules/jump/JumpFigure.cc

    r10733 r10765  
    5151
    5252        // initialize variables
    53         leftHand_ = NULL;
    54         rightHand_ = NULL;
     53        leftHand_ = nullptr;
     54        rightHand_ = nullptr;
    5555        fieldHeight_ = 0;
    5656        fieldWidth_ = 0;
    … …  
    7575        animateHands_ = false;
    7676        turnUp_ = false;
    77         rocketActive_ = NULL;
    78         propellerActive_ = NULL;
    79         bootsActive_ = NULL;
    80         shieldActive_ = NULL;
     77        rocketActive_ = nullptr;
     78        propellerActive_ = nullptr;
     79        bootsActive_ = nullptr;
     80        shieldActive_ = nullptr;
    8181        rocketSpeed_ = 0.0;
    8282        propellerSpeed_ = 0.0;
    … …  
    111111            // Move up/down
    112112            Vector3 velocity = getVelocity();
    113             if (rocketActive_ != NULL)
     113            if (rocketActive_ != nullptr)
    114114            {
    115115                velocity.z = rocketSpeed_;
    116116            }
    117             else if (propellerActive_ != NULL)
     117            else if (propellerActive_ != nullptr)
    118118            {
    119119                velocity.z = propellerSpeed_;
    … …  
    144144                }
    145145
    146                 if (leftHand_ != NULL)
     146                if (leftHand_ != nullptr)
    147147                {
    148148                    leftHand_->setOrientation(Vector3(0.0, 1.0, 0.0), Degree(-handAngle_));
    149149                }
    150                 if (rightHand_ != NULL)
     150                if (rightHand_ != nullptr)
    151151                {
    152152                    rightHand_->setOrientation(Vector3(0.0, 1.0, 0.0), Degree(handAngle_));
    … …  
    212212        {
    213213            Vector3 velocity = getVelocity();
    214             if (bootsActive_ == NULL)
     214            if (bootsActive_ == nullptr)
    215215            {
    216216                velocity.z = 1.2f*jumpSpeed_;
    … …  
    239239    void JumpFigure::CollisionWithEnemy(JumpEnemy* enemy)
    240240    {
    241         if (rocketActive_ == NULL && propellerActive_ == NULL && shieldActive_ == NULL)
     241        if (rocketActive_ == nullptr && propellerActive_ == nullptr && shieldActive_ == nullptr)
    242242        {
    243243            dead_ = true;
    … …  
    247247    bool JumpFigure::StartRocket(JumpRocket* rocket)
    248248    {
    249         if (rocketActive_ == NULL && propellerActive_ == NULL && bootsActive_ == NULL)
     249        if (rocketActive_ == nullptr && propellerActive_ == nullptr && bootsActive_ == nullptr)
    250250        {
    251251            attach(rocket);
    … …  
    266266        detach(rocket);
    267267        rocket->destroy();
    268         rocketActive_ = NULL;
     268        rocketActive_ = nullptr;
    269269    }
    270270
    271271    bool JumpFigure::StartPropeller(JumpPropeller* propeller)
    272272    {
    273         if (rocketActive_ == NULL && propellerActive_ == NULL && bootsActive_ == NULL)
     273        if (rocketActive_ == nullptr && propellerActive_ == nullptr && bootsActive_ == nullptr)
    274274        {
    275275            attach(propeller);
    … …  
    290290        detach(propeller);
    291291        propeller->destroy();
    292         propellerActive_ = NULL;
     292        propellerActive_ = nullptr;
    293293    }
    294294
    295295    bool JumpFigure::StartBoots(JumpBoots* boots)
    296296    {
    297         if (rocketActive_ == NULL && propellerActive_ == NULL && bootsActive_ == NULL)
     297        if (rocketActive_ == nullptr && propellerActive_ == nullptr && bootsActive_ == nullptr)
    298298        {
    299299            attach(boots);
    … …  
    314314        detach(boots);
    315315        boots->destroy();
    316         bootsActive_ = NULL;
     316        bootsActive_ = nullptr;
    317317    }
    318318
    … …  
    338338        detach(shield);
    339339        shield->destroy();
    340         shieldActive_ = NULL;
     340        shieldActive_ = nullptr;
    341341    }
    342342

  • code/branches/cpp11_v2/src/modules/jump/JumpPlatform.cc

    r10733 r10765  
    8686        Vector3 platformPosition = this->getPosition();
    8787
    88         if (figure_ != NULL)
     88        if (figure_ != nullptr)
    8989        {
    9090            Vector3 figurePosition = figure_->getPosition();

  • code/branches/cpp11_v2/src/modules/jump/JumpPlatformTimer.cc

    r10733 r10765  
    4747        RegisterObject(JumpPlatformTimer);
    4848
    49         particleSpawner_ = NULL;
     49        particleSpawner_ = nullptr;
    5050
    5151        setProperties(3.0);
    … …  
    7171
    7272        time_ -= dt;
    73         if (time_ < effectStartTime_ && particleSpawner_ == NULL)
     73        if (time_ < effectStartTime_ && particleSpawner_ == nullptr)
    7474        {
    7575

  • code/branches/cpp11_v2/src/modules/jump/JumpPropeller.cc

    r10733 r10765  
    7272        Vector3 PropellerPosition = getWorldPosition();
    7373
    74         if (attachedToFigure_ == false && figure_ != NULL)
     74        if (attachedToFigure_ == false && figure_ != nullptr)
    7575        {
    7676            Vector3 figurePosition = figure_->getWorldPosition();

  • code/branches/cpp11_v2/src/modules/jump/JumpRocket.cc

    r10733 r10765  
    7272        Vector3 rocketPosition = getWorldPosition();
    7373
    74         if (attachedToFigure_ == false && figure_ != NULL)
     74        if (attachedToFigure_ == false && figure_ != nullptr)
    7575        {
    7676            Vector3 figurePosition = figure_->getWorldPosition();

  • code/branches/cpp11_v2/src/modules/jump/JumpScore.cc

    r10733 r10765  
    4848        RegisterObject(JumpScore);
    4949
    50         owner_ = NULL;
     50        owner_ = nullptr;
    5151        showScore_ = false;
    5252        showFuel_ = false;
    … …  
    7373        SUPER(JumpScore, tick, dt);
    7474
    75         if (owner_ != NULL)
     75        if (owner_ != nullptr)
    7676        {
    7777            if (!owner_->hasEnded())
    … …  
    7979                player_ = owner_->getPlayer();
    8080
    81                 if (player_ != NULL)
     81                if (player_ != nullptr)
    8282                {
    8383                    if (showScore_ == true)
    … …  
    116116        SUPER(JumpScore, changedOwner);
    117117
    118         if (this->getOwner() != NULL && this->getOwner()->getGametype())
     118        if (this->getOwner() != nullptr && this->getOwner()->getGametype())
    119119        {
    120120            this->owner_ = orxonox_cast<Jump*>(this->getOwner()->getGametype());
    … …  
    122122        else
    123123        {
    124             this->owner_ = NULL;
     124            this->owner_ = nullptr;
    125125        }
    126126    }

  • code/branches/cpp11_v2/src/modules/jump/JumpShield.cc

    r10733 r10765  
    7272        Vector3 shieldPosition = getWorldPosition();
    7373
    74         if (attachedToFigure_ == false && figure_ != NULL)
     74        if (attachedToFigure_ == false && figure_ != nullptr)
    7575        {
    7676            Vector3 figurePosition = figure_->getWorldPosition();

  • code/branches/cpp11_v2/src/modules/jump/JumpSpring.cc

    r10733 r10765  
    7777        Vector3 springPosition = getWorldPosition();
    7878
    79         if (figure_ != NULL)
     79        if (figure_ != nullptr)
    8080        {
    8181            Vector3 figurePosition = figure_->getWorldPosition();

  • code/branches/cpp11_v2/src/modules/mini4dgame/Mini4Dgame.cc

    r10624 r10765  
    8888    void Mini4Dgame::cleanup()
    8989    {
    90         if(this->board_ != NULL)// Destroy the board, if present.
     90        if(this->board_ != nullptr)// Destroy the board, if present.
    9191        {
    9292            //this->board_->destroy();
    … …  
    101101    void Mini4Dgame::start()
    102102    {
    103         if (this->board_ != NULL) // There needs to be a Mini4DgameCenterpoint, i.e. the area the game takes place.
     103        if (this->board_ != nullptr) // There needs to be a Mini4DgameCenterpoint, i.e. the area the game takes place.
    104104        {
    105105            /*
    106             if (this->board_ == NULL)
     106            if (this->board_ == nullptr)
    107107            {
    108108                this->board_ = new Mini4DgameBoard(this->board_->getContext());
    … …  
    174174        assert(player);
    175175
    176         if(false)//this->player_ == NULL)
     176        if(false)//this->player_ == nullptr)
    177177        {
    178178            //this->player_ = player;

  • code/branches/cpp11_v2/src/modules/mini4dgame/Mini4DgameBoard.cc

    r10624 r10765  
    905905    void Mini4DgameBoard::checkGametype()
    906906    {
    907         if (this->getGametype() != NULL && this->getGametype()->isA(Class(Mini4Dgame)))
     907        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(Mini4Dgame)))
    908908        {
    909909            Mini4Dgame* Mini4DgameGametype = orxonox_cast<Mini4Dgame*>(this->getGametype());

  • code/branches/cpp11_v2/src/modules/notifications/NotificationDispatcher.cc

    r10624 r10765  
    177177
    178178        PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
    179         PlayerInfo* player = NULL;
     179        PlayerInfo* player = nullptr;
    180180
    181181        // If the trigger is a PlayerTrigger.
    182         if(pTrigger != NULL)
     182        if(pTrigger != nullptr)
    183183        {
    184184            if(!pTrigger->isForPlayer())  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
    … …  
    190190            return false;
    191191
    192         if(player == NULL)
     192        if(player == nullptr)
    193193        {
    194194            orxout(verbose, context::notifications) << "The NotificationDispatcher was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << endl;

  • code/branches/cpp11_v2/src/modules/notifications/NotificationManager.cc

    r10624 r10765  
    334334        // If all senders are the target of the NotificationQueue, then the list of Notifications for that specific NotificationQueue is the same as the list of all Notifications.
    335335        bool bAll = set.find(NotificationListener::ALL) != set.end();
    336         std::multimap<std::time_t, Notification*>* map = NULL;
     336        std::multimap<std::time_t, Notification*>* map = nullptr;
    337337        if(bAll)
    338338            this->notificationLists_[queue->getName()] = &this->allNotificationsList_;
    … …  
    395395        The name of the NotificationQueue.
    396396    @return
    397         Returns a pointer to the NotificationQueue with the input name. Returns NULL if no NotificationQueue with such a name exists.
     397        Returns a pointer to the NotificationQueue with the input name. Returns nullptr if no NotificationQueue with such a name exists.
    398398    */
    399399    NotificationQueue* NotificationManager::getQueue(const std::string & name)
    400400    {
    401401        std::map<const std::string, NotificationQueue*>::iterator it = this->queues_.find(name);
    402         // Returns NULL if no such NotificationQueue exists.
     402        // Returns nullptr if no such NotificationQueue exists.
    403403        if(it == this->queues_.end())
    404             return NULL;
     404            return nullptr;
    405405
    406406        return (*it).second;

  • code/branches/cpp11_v2/src/modules/notifications/NotificationQueueCEGUI.cc

    r10258 r10765  
    290290        The name of the NotificationQueueCEGUI to be got.
    291291    @return
    292         Returns a pointer to the NotificationQueueCEGUI, or NULL if it doesn't exist.
     292        Returns a pointer to the NotificationQueueCEGUI, or nullptr if it doesn't exist.
    293293    */
    294294    /*static*/ NotificationQueueCEGUI* NotificationQueueCEGUI::getQueue(const std::string& name)
    295295    {
    296296        NotificationQueue* queue = NotificationManager::getInstance().getQueue(name);
    297         if(queue == NULL || !queue->isA(Class(NotificationQueueCEGUI)))
    298             return NULL;
     297        if(queue == nullptr || !queue->isA(Class(NotificationQueueCEGUI)))
     298            return nullptr;
    299299        return static_cast<NotificationQueueCEGUI*>(queue);
    300300    }

  • code/branches/cpp11_v2/src/modules/objects/Script.cc

    r10624 r10765  
    140140
    141141        PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
    142         PlayerInfo* player = NULL;
     142        PlayerInfo* player = nullptr;
    143143
    144144        // If the trigger is a PlayerTrigger.
    145         if(pTrigger != NULL)
     145        if(pTrigger != nullptr)
    146146        {
    147147            if(!pTrigger->isForPlayer())  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
    … …  
    153153            return false;
    154154
    155         if(player == NULL)  //TODO: Will this ever happen? If not, change in NotificationDispatcher as well.
     155        if(player == nullptr)  //TODO: Will this ever happen? If not, change in NotificationDispatcher as well.
    156156        {
    157157            orxout(internal_warning) << "The Script was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << endl;

  • code/branches/cpp11_v2/src/modules/objects/SpaceBoundaries.cc

    r10624 r10765  
    6161            for( std::vector<BillboardAdministration>::iterator current = this->billboards_.begin(); current != this->billboards_.end(); current++)
    6262            {
    63                 if( current->billy != NULL)
     63                if( current->billy != nullptr)
    6464                {
    6565                    delete current->billy;
    … …  
    127127    void SpaceBoundaries::setBillboardOptions(Billboard *billy)
    128128    {
    129         if(billy != NULL)
     129        if(billy != nullptr)
    130130        {
    131131            billy->setMaterial("Grid");
    … …  
    250250    float SpaceBoundaries::computeDistance(WorldEntity *item)
    251251    {
    252         if(item != NULL)
     252        if(item != nullptr)
    253253        {
    254254            Vector3 itemPosition = item->getWorldPosition();
    … …  
    310310    bool SpaceBoundaries::isHumanPlayer(Pawn *item)
    311311    {
    312         if(item != NULL)
     312        if(item != nullptr)
    313313        {
    314314            if(item->getPlayer())

  • code/branches/cpp11_v2/src/modules/objects/triggers/DistanceMultiTrigger.cc

    r10624 r10765  
    9797    {
    9898
    99         std::queue<MultiTriggerState*>* queue = NULL;
     99        std::queue<MultiTriggerState*>* queue = nullptr;
    100100
    101101        // Check for objects that were in range but no longer are. Iterate through all objects, that are in range.
    … …  
    105105
    106106            // If the entity no longer exists.
    107             if(entity == NULL)
     107            if(entity == nullptr)
    108108            {
    109109                this->range_.erase(it++);
    … …  
    118118
    119119                // If no queue has been created, yet.
    120                 if(queue == NULL)
     120                if(queue == nullptr)
    121121                    queue = new std::queue<MultiTriggerState*>();
    122122
    … …  
    186186
    187187                // If no queue has been created, yet.
    188                 if(queue == NULL)
     188                if(queue == nullptr)
    189189                    queue = new std::queue<MultiTriggerState*>();
    190190

  • code/branches/cpp11_v2/src/modules/objects/triggers/DistanceTrigger.cc

    r10624 r10765  
    106106            this->setForPlayer(true);
    107107
    108         if (targetId == NULL)
     108        if (targetId == nullptr)
    109109        {
    110110            orxout(internal_error, context::triggers) << "\"" << targetStr << "\" is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ')' << endl;
    … …  
    147147    {
    148148        // Check whether there is a cached object, it still exists and whether it is still in range, if so nothing further needs to be done.
    149         if(this->cache_ != NULL)
     149        if(this->cache_ != nullptr)
    150150        {
    151151            if((this->cache_->getWorldPosition() - this->getWorldPosition()).length() < this->distance_)
    … …  
    206206
    207207                    Pawn* pawn = orxonox_cast<Pawn*>(entity);
    208                     if(pawn != NULL)
     208                    if(pawn != nullptr)
    209209                        this->setTriggeringPawn(pawn);
    210210                    else
    211                         orxout(internal_warning, context::triggers) << "Pawn was NULL." << endl;
     211                        orxout(internal_warning, context::triggers) << "Pawn was nullptr." << endl;
    212212                }
    213213               

  • code/branches/cpp11_v2/src/modules/objects/triggers/EventMultiTrigger.cc

    r9667 r10765  
    9696    {
    9797        // If the originator is a MultiTriggerContainer, the event originates from a MultiTrigger and thus the event only triggers the EventMultiTrigger for the originator that caused the MultiTrigger to trigger.
    98         if(originator != NULL && originator->isA(ClassIdentifier<MultiTriggerContainer>::getIdentifier()))
     98        if(originator != nullptr && originator->isA(ClassIdentifier<MultiTriggerContainer>::getIdentifier()))
    9999        {
    100100            MultiTriggerContainer* container = static_cast<MultiTriggerContainer*>(originator);

  • code/branches/cpp11_v2/src/modules/objects/triggers/MultiTrigger.cc

    r9667 r10765  
    124124        // Let the MultiTrigger return the states that trigger and process the new states if there are any.
    125125        std::queue<MultiTriggerState*>* queue  = this->letTrigger();
    126         if(queue != NULL)
     126        if(queue != nullptr)
    127127        {
    128128            while(queue->size() > 0)
    129129            {
    130130                MultiTriggerState* state = queue->front();
    131                 // If the state is NULL. (This really shouldn't happen)
    132                 if(state == NULL)
     131                // If the state is nullptr. (This really shouldn't happen)
     132                if(state == nullptr)
    133133                {
    134                     orxout(internal_error, context::triggers) << "In MultiTrigger '" << this->getName() << "' (&" << this << "), Error: State of new states queue was NULL. State ignored." << endl;
     134                    orxout(internal_error, context::triggers) << "In MultiTrigger '" << this->getName() << "' (&" << this << "), Error: State of new states queue was nullptr. State ignored." << endl;
    135135                    queue->pop();
    136136                    continue;
    … …  
    227227                            {
    228228                                // If the MultiTrigger is set to broadcast and has no originator a boradcast is fired.
    229                                 if(this->getBroadcast() && state->originator == NULL)
     229                                if(this->getBroadcast() && state->originator == nullptr)
    230230                                    this->broadcast(bActive);
    231231                                // Else a normal event is fired.
    … …  
    240240                        {
    241241                            // Print some debug output if the state has changed.
    242                             if(state->originator != NULL)
     242                            if(state->originator != nullptr)
    243243                                orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << ") changed state. originator: " << state->originator->getIdentifier()->getName() << " (&" << state->originator << "), active: " << bActive << ", triggered: " << state->bTriggered << "." << endl;
    244244                            else
    245                                 orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << ") changed state. originator: NULL, active: " << bActive << ", triggered: " << state->bTriggered << "." << endl;
     245                                orxout(verbose, context::triggers) << "MultiTrigger '" << this->getName() << "' (&" << this << ") changed state. originator: nullptr, active: " << bActive << ", triggered: " << state->bTriggered << "." << endl;
    246246
    247247                            // If the MultiTrigger has a parent trigger, that is itself a MultiTrigger, it needs to call a method to notify him, that its activity has changed.
    248                             if(this->parent_ != NULL && this->parent_->isMultiTrigger())
     248                            if(this->parent_ != nullptr && this->parent_->isMultiTrigger())
    249249                                static_cast<MultiTrigger*>(this->parent_)->childActivityChanged(state->originator);
    250250                        }
    … …  
    299299
    300300        // If the target is not a valid class name display an error.
    301         if (target == NULL)
     301        if (target == nullptr)
    302302        {
    303303            orxout(internal_error, context::triggers) << "'" << targetStr << "' is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ")" << endl;
    … …  
    327327
    328328        // If the target is not a valid class name display an error.
    329         if (target == NULL)
     329        if (target == nullptr)
    330330        {
    331331            orxout(internal_error, context::triggers) << "'" << targetStr << "' is not a valid class name to include in ClassTreeMask (in " << this->getName() << ", class " << this->getIdentifier()->getName() << ")" << endl;
    … …  
    346346    std::queue<MultiTriggerState*>* MultiTrigger::letTrigger(void)
    347347    {
    348         return NULL;
     348        return nullptr;
    349349    }
    350350
    … …  
    443443    void MultiTrigger::fire(bool status, BaseObject* originator)
    444444    {
    445         // If the originator is NULL, a normal event without MultiTriggerContainer is sent.
    446         if(originator == NULL)
     445        // If the originator is nullptr, a normal event without MultiTriggerContainer is sent.
     446        if(originator == nullptr)
    447447        {
    448448            this->fireEvent(status);
    … …  
    479479    bool MultiTrigger::addState(MultiTriggerState* state)
    480480    {
    481         assert(state); // The state really shouldn't be NULL.
     481        assert(state); // The state really shouldn't be nullptr.
    482482
    483483        // If the originator is no target of this MultiTrigger.

  • code/branches/cpp11_v2/src/modules/objects/triggers/MultiTrigger.h

    r9667 r10765  
    7676        - @b simultaneousTriggerers The number of simultaneous triggerers limits the number of objects that are allowed to trigger the MultiTrigger at the same time. Or more precisely, the number of distinct objects the MultiTrigger has <em>triggered</em> states for, at each point in time. The default is <code>-1</code>, which denotes infinity.
    7777        - @b mode The mode describes how the MultiTrigger acts in relation to all the triggers, that are appended to it. There are 3 modes: <em>and</em>, meaning that the MultiTrigger can only be triggered if all the appended triggers are active. <em>or</em>, meaning that the MultiTrigger can only triggered if at least one of the appended triggers is active. And <em>xor</em>, meaning that the MultiTrigger can only be triggered if one and only one appended trigger is active. Note, that I wrote <em>can only be active</em>, that implies, that there is an additional condition to the <em>activity</em> of the MultiTrigger and that is the fulfillment of the triggering condition (the MultiTrigger itself doesn't have one, but all derived classes should). Also bear in mind, that the <em>activity</em> of a MultiTrigger is still coupled to the object that triggered it. The default is <em>and</em>.
    78         - @b broadcast Broadcast is a boolean, if true the MutliTrigger is in <em>broadcast-mode</em>, meaning, that all trigger events that are caused by no originator (originator is NULL) are broadcast as having come from every possible originator, or more precisely as having come from all objects that are specified targets of this MultiTrigger. The default is false.
     78        - @b broadcast Broadcast is a boolean, if true the MutliTrigger is in <em>broadcast-mode</em>, meaning, that all trigger events that are caused by no originator (originator is nullptr) are broadcast as having come from every possible originator, or more precisely as having come from all objects that are specified targets of this MultiTrigger. The default is false.
    7979        - @b target The target describes the kind of objects that are allowed to trigger this MultiTrigger. The default is @ref orxonox::Pawn "Pawn".
    8080        - Also there is the possibility of appending triggers (as long as they inherit from TriggerBase) to the MultiTrigger just by adding them as children in the XML description of your MultiTrigger.
    … …  
    110110            */
    111111            inline bool isActive(void) const
    112                 { return this->isActive(NULL); }
    113             bool isActive(BaseObject* triggerer = NULL) const; //!< Check whether the MultiTrigger is active for a given object.
     112                { return this->isActive(nullptr); }
     113            bool isActive(BaseObject* triggerer = nullptr) const; //!< Check whether the MultiTrigger is active for a given object.
    114114
    115115            /**
    … …  
    145145            */
    146146            inline bool isTarget(BaseObject* target)
    147                 { if(target == NULL) return true; else return targetMask_.isIncluded(target->getIdentifier()); }
     147                { if(target == nullptr) return true; else return targetMask_.isIncluded(target->getIdentifier()); }
    148148               
    149149            void addTarget(const std::string& targets); //!< Add some target to the MultiTrigger.
    … …  
    152152            virtual std::queue<MultiTriggerState*>* letTrigger(void); //!< This method is called by the MultiTrigger to get information about new trigger events that need to be looked at.
    153153
    154             void changeTriggered(BaseObject* originator = NULL); //!< This method can be called by any class inheriting from MultiTrigger to change it's triggered status for a specified originator.
    155 
    156             bool isModeTriggered(BaseObject* triggerer = NULL); //!< Checks whether the MultiTrigger is triggered concerning it's children.
    157             bool isTriggered(BaseObject* triggerer = NULL); //!< Get whether the MultiTrigger is triggered for a given object.
    158 
    159             virtual void fire(bool status, BaseObject* originator = NULL);  //!< Helper method. Creates an Event for the given status and originator and fires it.
     154            void changeTriggered(BaseObject* originator = nullptr); //!< This method can be called by any class inheriting from MultiTrigger to change it's triggered status for a specified originator.
     155
     156            bool isModeTriggered(BaseObject* triggerer = nullptr); //!< Checks whether the MultiTrigger is triggered concerning it's children.
     157            bool isTriggered(BaseObject* triggerer = nullptr); //!< Get whether the MultiTrigger is triggered for a given object.
     158
     159            virtual void fire(bool status, BaseObject* originator = nullptr);  //!< Helper method. Creates an Event for the given status and originator and fires it.
    160160            void broadcast(bool status); //!< Helper method. Broadcasts an Event for every object that is a target.
    161161

  • code/branches/cpp11_v2/src/modules/objects/triggers/MultiTriggerContainer.cc

    r9667 r10765  
    5050        The creator.
    5151    */
    52     MultiTriggerContainer::MultiTriggerContainer(Context* context) : BaseObject(context), originator_(NULL), data_(NULL)
     52    MultiTriggerContainer::MultiTriggerContainer(Context* context) : BaseObject(context), originator_(nullptr), data_(nullptr)
    5353    {
    5454        RegisterObject(MultiTriggerContainer);
    … …  
    7070
    7171        Pawn* pawn = orxonox_cast<Pawn*>(data);
    72         if(pawn != NULL)
     72        if(pawn != nullptr)
    7373        {
    7474            this->setForPlayer(true);

  • code/branches/cpp11_v2/src/modules/objects/triggers/TriggerBase.cc

    r9667 r10765  
    6767        this->mode_ = TriggerMode::EventTriggerAND;
    6868
    69         this->parent_ = NULL;
     69        this->parent_ = nullptr;
    7070
    7171        this->bMultiTrigger_ = false;
    … …  
    170170        The index.
    171171    @return
    172         Returns a pointer ot the trigger. NULL if no such trigger exists.
     172        Returns a pointer ot the trigger. nullptr if no such trigger exists.
    173173    */
    174174    const TriggerBase* TriggerBase::getTrigger(unsigned int index) const
    … …  
    176176        // If the index is greater than the number of children.
    177177        if (this->children_.size() <= index)
    178             return NULL;
     178            return nullptr;
    179179
    180180        std::set<TriggerBase*>::const_iterator it;

  • code/branches/cpp11_v2/src/modules/overlays/GUIOverlay.cc

    r9667 r10765  
    9292            ControllableEntity* entity = orxonox_cast<ControllableEntity*>(this->getOwner());
    9393            if (entity)
    94                 GUIManager::getInstance().setPlayer(name, entity->getPlayer()); //Set Player is going to be NULL, so it needs to be set in changedVisibility() as well.
     94                GUIManager::getInstance().setPlayer(name, entity->getPlayer()); //Set Player is going to be nullptr, so it needs to be set in changedVisibility() as well.
    9595        }
    9696    }

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDEnemyHealthBar.cc

    r9667 r10765  
    6262    void HUDEnemyHealthBar::updateTarget()
    6363    {
    64         Pawn* pawn = NULL;
     64        Pawn* pawn = nullptr;
    6565        if (this->owner_ && this->useEnemyBar_)
    6666        {
    … …  
    7373            // Don't show the HealthBar if the pawn is invisible
    7474            if (pawn && !pawn->isVisible())
    75                 pawn = NULL;
     75                pawn = nullptr;
    7676        }
    7777        // Set the pawn as owner of the HealthBar
    7878        this->setHealthBarOwner(pawn);
    79         this->setVisible(pawn != NULL);
     79        this->setVisible(pawn != nullptr);
    8080    }
    8181

  • code/branches/cpp11_v2/src/modules/overlays/hud/HUDNavigation.cc

    r10624 r10765  
    134134        for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it != this->activeObjectList_.end(); ++it)
    135135        {
    136             if (it->second.text_ != NULL)
     136            if (it->second.text_ != nullptr)
    137137                it->second.text_->setFontName(this->fontName_);
    138138        }
    … …  
    183183
    184184        Camera* cam = CameraManager::getInstance().getActiveCamera();
    185         if (cam == NULL)
     185        if (cam == nullptr)
    186186        return;
    187187        const Matrix4& camTransform = cam->getOgreCamera()->getProjectionMatrix() * cam->getOgreCamera()->getViewMatrix();
    … …  
    476476                    if(!it->second.selected_
    477477                            || it->first->getRVVelocity().squaredLength() == 0
    478                             || pawn == NULL
     478                            || pawn == nullptr
    479479                            /* TODO : improve getTeam in such a way that it works
    480                              * || humanPawn == NULL
     480                             * || humanPawn == nullptr
    481481                             * || pawn->getTeam() == humanPawn->getTeam()*/)
    482482                    {
    … …  
    534534        for (std::map<RadarViewable*, ObjectInfo>::iterator it = this->activeObjectList_.begin(); it != this->activeObjectList_.end(); ++it)
    535535        {
    536             if (it->second.health_ != NULL)
     536            if (it->second.health_ != nullptr)
    537537                it->second.health_->setDimensions(this->healthMarkerSize_ * xScale, this->healthMarkerSize_ * yScale);
    538             if (it->second.healthLevel_ != NULL)
     538            if (it->second.healthLevel_ != nullptr)
    539539                it->second.healthLevel_->setDimensions(this->healthLevelMarkerSize_ * xScale, this->healthLevelMarkerSize_ * yScale);
    540             if (it->second.panel_ != NULL)
     540            if (it->second.panel_ != nullptr)
    541541                it->second.panel_->setDimensions(this->navMarkerSize_ * xScale, this->navMarkerSize_ * yScale);
    542             if (it->second.text_ != NULL)
     542            if (it->second.text_ != nullptr)
    543543                it->second.text_->setCharHeight(this->textSize_ * yScale);
    544             if (it->second.target_ != NULL)
     544            if (it->second.target_ != nullptr)
    545545                it->second.target_->setDimensions(this->aimMarkerSize_ * xScale, this->aimMarkerSize_ * yScale);
    546546        }
    … …  
    553553
    554554        if (this->activeObjectList_.size() >= this->markerLimit_)
    555         if (object == NULL)
     555        if (object == nullptr)
    556556        return;
    557557

  • code/branches/cpp11_v2/src/modules/pickup/CollectiblePickup.cc

    r10624 r10765  
    4747        Registers the object and initializes variables.
    4848    */
    49     CollectiblePickup::CollectiblePickup() : collection_(NULL)
     49    CollectiblePickup::CollectiblePickup() : collection_(nullptr)
    5050    {
    5151        RegisterObject(CollectiblePickup);
    … …  
    103103    void CollectiblePickup::wasRemovedFromCollection(void)
    104104    {
    105         this->collection_ = NULL;
     105        this->collection_ = nullptr;
    106106    }
    107107}

  • code/branches/cpp11_v2/src/modules/pickup/CollectiblePickup.h

    r9348 r10765  
    6969            */
    7070            bool isInCollection(void) const
    71                 { return this->collection_ != NULL; }
     71                { return this->collection_ != nullptr; }
    7272
    7373        private:

  • code/branches/cpp11_v2/src/modules/pickup/PickupCollection.cc

    r9667 r10765  
    148148        for(std::list<CollectiblePickup*>::iterator it = this->pickups_.begin(); it != this->pickups_.end(); ++it)
    149149        {
    150             if(this->getCarrier() == NULL)
    151                 (*it)->setCarrier(NULL);
     150            if(this->getCarrier() == nullptr)
     151                (*it)->setCarrier(nullptr);
    152152            else
    153153                (*it)->setCarrier(this->getCarrier()->getTarget(*it));
    … …  
    227227    bool PickupCollection::addPickupable(CollectiblePickup* pickup)
    228228    {
    229         if(pickup == NULL)
     229        if(pickup == nullptr)
    230230            return false;
    231231
    … …  
    247247    {
    248248        if(this->pickups_.size() >= index)
    249             return NULL;
     249            return nullptr;
    250250
    251251        std::list<CollectiblePickup*>::const_iterator it = this->pickups_.begin();

  • code/branches/cpp11_v2/src/modules/pickup/PickupManager.cc

    r10624 r10765  
    6868        Constructor. Registers the PickupManager and creates the default PickupRepresentation.
    6969    */
    70     PickupManager::PickupManager() : guiLoaded_(false), pickupHighestIndex_(0), defaultRepresentation_(NULL)
     70    PickupManager::PickupManager() : guiLoaded_(false), pickupHighestIndex_(0), defaultRepresentation_(nullptr)
    7171    {
    7272        RegisterObject(PickupManager);
    … …  
    8585    {
    8686        // Destroying the default representation.
    87         if(this->defaultRepresentation_ != NULL)
     87        if(this->defaultRepresentation_ != nullptr)
    8888            this->defaultRepresentation_->destroy();
    8989
    … …  
    184184        CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
    185185        // If the Pickupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
    186         if(collectible != NULL && collectible->isInCollection())
     186        if(collectible != nullptr && collectible->isInCollection())
    187187            return;
    188188
    189189        // Getting clientId of the host this change of the pickup's used status concerns.
    190190        PickupCarrier* carrier = pickup->getCarrier();
    191         while(carrier->getCarrierParent() != NULL)
     191        while(carrier->getCarrierParent() != nullptr)
    192192            carrier = carrier->getCarrierParent();
    193193        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
    194         if(pawn == NULL)
     194        if(pawn == nullptr)
    195195            return;
    196196        PlayerInfo* info = pawn->getPlayer();
    197         if(info == NULL)
     197        if(info == nullptr)
    198198            return;
    199199        unsigned int clientId = info->getClientID();
    … …  
    265265        CollectiblePickup* collectible = orxonox_cast<CollectiblePickup*>(pickup);
    266266        // If the Pickupable is part of a PickupCollection it isn't displayed in the PickupInventory, just the PickupCollection is.
    267         if(collectible != NULL && collectible->isInCollection())
     267        if(collectible != nullptr && collectible->isInCollection())
    268268            return;
    269269
    270270        // Getting clientId of the host this change of the pickup's pickedUp status concerns.
    271271        PickupCarrier* carrier = pickup->getCarrier();
    272         while(carrier->getCarrierParent() != NULL)
     272        while(carrier->getCarrierParent() != nullptr)
    273273            carrier = carrier->getCarrierParent();
    274274        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
    275         if(pawn == NULL)
     275        if(pawn == nullptr)
    276276            return;
    277277        PlayerInfo* info = pawn->getFormerPlayer();
    278         if(info == NULL)
     278        if(info == nullptr)
    279279            return;
    280280        unsigned int clientId = info->getClientID();
    … …  
    399399                return;
    400400            Pickupable* pickupable = this->pickups_.find(pickup)->second;
    401             if(pickupable != NULL)
     401            if(pickupable != nullptr)
    402402                pickupable->drop();
    403403        }
    … …  
    442442                return;
    443443            Pickupable* pickupable = this->pickups_.find(pickup)->second;
    444             if(pickupable != NULL)
     444            if(pickupable != nullptr)
    445445                pickupable->setUsed(use);
    446446        }

  • code/branches/cpp11_v2/src/modules/pickup/PickupRepresentation.cc

    r9667 r10765  
    5252        This is primarily for use of the PickupManager in creating a default PickupRepresentation.
    5353    */
    54     PickupRepresentation::PickupRepresentation() : BaseObject(NULL), Synchronisable(NULL), spawnerRepresentation_(NULL)
     54    PickupRepresentation::PickupRepresentation() : BaseObject(nullptr), Synchronisable(nullptr), spawnerRepresentation_(nullptr)
    5555    {
    5656        RegisterObject(PickupRepresentation);
    … …  
    6464        Default Constructor. Registers the object and initializes its member variables.
    6565    */
    66     PickupRepresentation::PickupRepresentation(Context* context) : BaseObject(context), Synchronisable(context), spawnerRepresentation_(NULL)
     66    PickupRepresentation::PickupRepresentation(Context* context) : BaseObject(context), Synchronisable(context), spawnerRepresentation_(nullptr)
    6767    {
    6868        RegisterObject(PickupRepresentation);
    … …  
    7878    PickupRepresentation::~PickupRepresentation()
    7979    {
    80         if(this->spawnerRepresentation_ != NULL)
     80        if(this->spawnerRepresentation_ != nullptr)
    8181            this->spawnerRepresentation_->destroy();
    8282
    … …  
    135135    StaticEntity* PickupRepresentation::createSpawnerRepresentation(PickupSpawner* spawner)
    136136    {
    137         if(this->spawnerRepresentation_ == NULL)
     137        if(this->spawnerRepresentation_ == nullptr)
    138138        {
    139139            orxout(verbose, context::pickups) << "PickupRepresentation: No spawner representation found." << endl;
    … …  
    149149        this->spawnerRepresentation_->setVisible(true);
    150150        StaticEntity* temp = this->spawnerRepresentation_;
    151         this->spawnerRepresentation_ = NULL;
     151        this->spawnerRepresentation_ = nullptr;
    152152
    153153        return temp;
    … …  
    164164    {
    165165        this->spawnerRepresentation_ = representation;
    166         if(this->spawnerRepresentation_ != NULL)
     166        if(this->spawnerRepresentation_ != nullptr)
    167167            this->spawnerRepresentation_->setVisible(false);
    168168    }

  • code/branches/cpp11_v2/src/modules/pickup/PickupRepresentation.h

    r9667 r10765  
    119119            @brief Get the StaticEntity that defines how the PickupSpawner of the Pickupable represented by this PickupRepresentation looks like.
    120120            @param index The index.
    121             @return Returns (for index = 0) a pointer to the StaticEntity. For index > 0 it returns NULL.
     121            @return Returns (for index = 0) a pointer to the StaticEntity. For index > 0 it returns nullptr.
    122122            */
    123123            inline const StaticEntity* getSpawnerRepresentationIndex(unsigned int index) const
    124                 { if(index == 0) return this->spawnerRepresentation_; return NULL; }
     124                { if(index == 0) return this->spawnerRepresentation_; return nullptr; }
    125125            /**
    126126            @brief Get the name of the image representing the pickup in the PickupInventory.

  • code/branches/cpp11_v2/src/modules/pickup/PickupSpawner.cc

    r10624 r10765  
    5555        Pointer to the object which created this item.
    5656    */
    57     PickupSpawner::PickupSpawner(Context* context) : StaticEntity(context), pickup_(NULL), representation_(NULL), pickupTemplate_(NULL)
     57    PickupSpawner::PickupSpawner(Context* context) : StaticEntity(context), pickup_(nullptr), representation_(nullptr), pickupTemplate_(nullptr)
    5858    {
    5959        RegisterObject(PickupSpawner);
    … …  
    7474        this->selfDestruct_ = false;
    7575
    76         this->setPickupable(NULL);
     76        this->setPickupable(nullptr);
    7777    }
    7878
    … …  
    8383    PickupSpawner::~PickupSpawner()
    8484    {
    85         if(this->isInitialized() && this->selfDestruct_ && this->pickup_ != NULL)
     85        if(this->isInitialized() && this->selfDestruct_ && this->pickup_ != nullptr)
    8686            this->pickup_->destroy();
    8787    }
    … …  
    160160            for(ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it != ObjectList<Pawn>::end(); ++it)
    161161            {
    162                 if(spawner == NULL) // Stop if the PickupSpawner has been deleted (e.g. because it has run out of pickups to distribute).
     162                if(spawner == nullptr) // Stop if the PickupSpawner has been deleted (e.g. because it has run out of pickups to distribute).
    163163                    break;
    164164
    … …  
    166166                PickupCarrier* carrier = static_cast<PickupCarrier*>(*it);
    167167                // If a PickupCarrier, that fits the target-range of the Pickupable spawned by this PickupSpawner, is in trigger-distance and the carrier is not blocked.
    168                 if(distance.length() < this->triggerDistance_ && carrier != NULL && this->blocked_.find(carrier) == this->blocked_.end())
     168                if(distance.length() < this->triggerDistance_ && carrier != nullptr && this->blocked_.find(carrier) == this->blocked_.end())
    169169                {
    170170                    if(carrier->isTarget(this->pickup_))
    … …  
    195195        pickedUp = false; // To avoid compiler warning.
    196196
    197         this->setPickupable(NULL);
     197        this->setPickupable(nullptr);
    198198        this->decrementSpawnsRemaining();
    199199    }
    … …  
    282282        {
    283283            orxout(internal_error, context::pickups) << "Massive Error: PickupSpawner still alive until having spawned last item." << endl;
    284             return NULL;
    285         }
    286 
    287         if (this->pickupTemplate_ != NULL)
     284            return nullptr;
     285        }
     286
     287        if (this->pickupTemplate_ != nullptr)
    288288        {
    289289            Identifier* identifier = this->pickupTemplate_->getBaseclassIdentifier();
    290             if (identifier != NULL)
     290            if (identifier != nullptr)
    291291            {
    292292                Pickupable* pickup = orxonox_cast<Pickupable*>(identifier->fabricate(this->getContext()));
    … …  
    298298        }
    299299
    300         return NULL;
     300        return nullptr;
    301301    }
    302302
    … …  
    309309    void PickupSpawner::setPickupable(Pickupable* pickup)
    310310    {
    311         if (this->representation_ != NULL)
     311        if (this->representation_ != nullptr)
    312312        {
    313313            this->representation_->destroy();
    314             this->representation_ = NULL;
    315         }
    316 
    317         if (pickup != NULL)
    318         {
    319             if (this->pickup_ != NULL)
     314            this->representation_ = nullptr;
     315        }
     316
     317        if (pickup != nullptr)
     318        {
     319            if (this->pickup_ != nullptr)
    320320                this->pickup_->destroy();
    321321

  • code/branches/cpp11_v2/src/modules/pickup/items/DamageBoostPickup.cc

    r9667 r10765  
    106106
    107107        SpaceShip* ship = this->carrierToSpaceShipHelper();
    108         if(ship == NULL) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
     108        if(ship == nullptr) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
    109109            this->Pickupable::destroy();
    110110
    … …  
    152152        Helper to transform the PickupCarrier to a SpaceShip, and throw an error message if the conversion fails.
    153153    @return
    154         A pointer to the SpaceShip, or NULL if the conversion failed.
     154        A pointer to the SpaceShip, or nullptr if the conversion failed.
    155155    */
    156156    SpaceShip* DamageBoostPickup::carrierToSpaceShipHelper(void)
    … …  
    159159        SpaceShip* ship = orxonox_cast<SpaceShip*>(carrier);
    160160
    161         if(ship == NULL)
     161        if(ship == nullptr)
    162162        {
    163163            orxout(internal_error, context::pickups) << "Invalid PickupCarrier in DamageBoostPickup." << endl;

  • code/branches/cpp11_v2/src/modules/pickup/items/DronePickup.cc

    r9667 r10765  
    122122
    123123                Pawn* pawn = this->carrierToPawnHelper();
    124                 if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     124                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    125125                    this->Pickupable::destroy();
    126126
    … …  
    131131                Controller* controller = drone->getController();
    132132                DroneController* droneController = orxonox_cast<DroneController*>(controller);
    133                 if(droneController != NULL)
     133                if(droneController != nullptr)
    134134                {
    135135                    droneController->setOwner(pawn);
    … …  
    156156        Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
    157157    @return
    158         A pointer to the Pawn, or NULL if the conversion failed.
     158        A pointer to the Pawn, or nullptr if the conversion failed.
    159159    */
    160160    Pawn* DronePickup::carrierToPawnHelper(void)
    … …  
    163163        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
    164164
    165         if(pawn == NULL)
     165        if(pawn == nullptr)
    166166        {
    167167            orxout(internal_error, context::pickups) << "Invalid PickupCarrier in DronePickup." << endl;

  • code/branches/cpp11_v2/src/modules/pickup/items/HealthPickup.cc

    r9667 r10765  
    114114        {
    115115            Pawn* pawn = this->carrierToPawnHelper();
    116             if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     116            if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    117117                this->Pickupable::destroy();
    118118
    … …  
    168168            {
    169169                Pawn* pawn = this->carrierToPawnHelper();
    170                 if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     170                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    171171                    this->Pickupable::destroy();
    172172
    … …  
    206206                Pawn* pawn = orxonox_cast<Pawn*>(carrier);
    207207
    208                 if(pawn == NULL)
     208                if(pawn == nullptr)
    209209                {
    210210                    orxout(internal_error, context::pickups) << "Something went horribly wrong in Health Pickup. PickupCarrier is '" << carrier->getIdentifier()->getName() << "' instead of Pawn." << endl;
    … …  
    233233        Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
    234234    @return
    235         A pointer to the Pawn, or NULL if the conversion failed.
     235        A pointer to the Pawn, or nullptr if the conversion failed.
    236236    */
    237237    Pawn* HealthPickup::carrierToPawnHelper(void)
    … …  
    240240        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
    241241
    242         if(pawn == NULL)
     242        if(pawn == nullptr)
    243243            orxout(internal_error, context::pickups) << "Invalid PickupCarrier in HealthPickup." << endl;
    244244

  • code/branches/cpp11_v2/src/modules/pickup/items/InvisiblePickup.cc

    r9667 r10765  
    139139    {
    140140        Pawn* pawn = this->carrierToPawnHelper();
    141         if(pawn == NULL)
     141        if(pawn == nullptr)
    142142            return false;
    143143
    … …  
    163163        Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
    164164    @return
    165         A pointer to the Pawn, or NULL if the conversion failed.
     165        A pointer to the Pawn, or nullptr if the conversion failed.
    166166    */
    167167    Pawn* InvisiblePickup::carrierToPawnHelper(void)
    … …  
    170170        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
    171171
    172         if(pawn == NULL)
     172        if(pawn == nullptr)
    173173        {
    174174            orxout(internal_error, context::pickups) << "Invalid PickupCarrier in InvisiblePickup." << endl;

  • code/branches/cpp11_v2/src/modules/pickup/items/MetaPickup.cc

    r9667 r10765  
    107107        {
    108108            PickupCarrier* carrier = this->getCarrier();
    109             if(this->getMetaType() != pickupMetaType::none && carrier != NULL)
     109            if(this->getMetaType() != pickupMetaType::none && carrier != nullptr)
    110110            {
    111111                // If the metaType is destroyCarrier, then the PickupCarrier is destroyed.
    … …  
    121121                {
    122122                    Pickupable* pickup = (*it);
    123                     if(pickup == NULL || pickup == this)
     123                    if(pickup == nullptr || pickup == this)
    124124                        continue;
    125125

  • code/branches/cpp11_v2/src/modules/pickup/items/ShieldPickup.cc

    r9667 r10765  
    9999
    100100        Pawn* pawn = this->carrierToPawnHelper();
    101         if(pawn == NULL)
     101        if(pawn == nullptr)
    102102            this->Pickupable::destroy();
    103103
    … …  
    143143    Helper to transform the PickupCarrier to a Pawn, and throw an error message if the conversion fails.
    144144    @return
    145     A pointer to the Pawn, or NULL if the conversion failed.
     145    A pointer to the Pawn, or nullptr if the conversion failed.
    146146    */
    147147    Pawn* ShieldPickup::carrierToPawnHelper(void)
    … …  
    150150        Pawn* pawn = orxonox_cast<Pawn*>(carrier);
    151151
    152         if(pawn == NULL)
     152        if(pawn == nullptr)
    153153        {
    154154            orxout(internal_error, context::pickups) << "Invalid PickupCarrier in ShieldPickup." << endl;

  • code/branches/cpp11_v2/src/modules/pickup/items/ShrinkPickup.cc

    r10624 r10765  
    146146        {
    147147            Pawn* pawn = this->carrierToPawnHelper();
    148             if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     148            if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    149149            {
    150150                this->Pickupable::destroy();
    … …  
    173173                //TODO: Deploy particle effect.
    174174                Pawn* pawn = this->carrierToPawnHelper();
    175                 if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     175                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    176176                    return;
    177177
    … …  
    187187                {
    188188                    CameraPosition* cameraPos = pawn->getCameraPosition(index);
    189                     if(cameraPos == NULL)
     189                    if(cameraPos == nullptr)
    190190                        continue;
    191191                    cameraPos->setPosition(cameraPos->getPosition()/factor);
    … …  
    201201                //TODO: Deploy particle effect.
    202202                Pawn* pawn = this->carrierToPawnHelper();
    203                 if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     203                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    204204                    return;
    205205
    … …  
    213213                {
    214214                    CameraPosition* cameraPos = pawn->getCameraPosition(index);
    215                     if(cameraPos == NULL)
     215                    if(cameraPos == nullptr)
    216216                        continue;
    217217                    cameraPos->setPosition(cameraPos->getPosition()/this->shrinkFactor_);
    … …  
    237237            {
    238238                Pawn* pawn = this->carrierToPawnHelper();
    239                 if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     239                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    240240                {
    241241                    this->Pickupable::destroy();
    … …  
    268268                {
    269269                    CameraPosition* cameraPos = pawn->getCameraPosition(index);
    270                     if(cameraPos == NULL)
     270                    if(cameraPos == nullptr)
    271271                        continue;
    272272                    cameraPos->setPosition(cameraPos->getPosition()/factor);
    … …  
    277277            {
    278278                Pawn* pawn = this->carrierToPawnHelper();
    279                 if(pawn == NULL) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
     279                if(pawn == nullptr) // If the PickupCarrier is no Pawn, then this pickup is useless and therefore is destroyed.
    280280                    this->Pickupable::destroy();
    281281
    … …  
    309309                {
    310310                    CameraPosition* cameraPos = pawn->getCameraPosition(index);
    311                     if(cameraPos == NULL)
     311                    if(cameraPos == nullptr)
    312312                        continue;
    313313                    cameraPos->setPosition(cameraPos->getPosition()/factor);

  • code/branches/cpp11_v2/src/modules/pickup/items/SpeedPickup.cc

    r9667 r10765  
    9999
    100100        SpaceShip* ship = this->carrierToSpaceShipHelper();
    101         if(ship == NULL) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
     101        if(ship == nullptr) // If the PickupCarrier is no SpaceShip, then this pickup is useless and therefore is destroyed.
    102102            this->Pickupable::destroy();
    103103
    … …  
    143143        Helper to transform the PickupCarrier to a SpaceShip, and throw an error message if the conversion fails.
    144144    @return
    145         A pointer to the SpaceShip, or NULL if the conversion failed.
     145        A pointer to the SpaceShip, or nullptr if the conversion failed.
    146146    */
    147147    SpaceShip* SpeedPickup::carrierToSpaceShipHelper(void)
    … …  
    150150        SpaceShip* ship = orxonox_cast<SpaceShip*>(carrier);
    151151
    152         if(ship == NULL)
     152        if(ship == nullptr)
    153153        {
    154154            orxout(internal_error, context::pickups) << "Invalid PickupCarrier in SpeedPickup." << endl;

  • code/branches/cpp11_v2/src/modules/pong/Pong.cc

    r9939 r10765  
    103103    void Pong::cleanup()
    104104    {
    105         if (this->ball_ != NULL) // Destroy the ball, if present.
     105        if (this->ball_ != nullptr) // Destroy the ball, if present.
    106106        {
    107107            this->ball_->destroy();
    … …  
    112112        for (size_t i = 0; i < 2; ++i)
    113113        {
    114             if (this->bat_[0] != NULL)
     114            if (this->bat_[0] != nullptr)
    115115            {
    116116                this->bat_[0]->destroy();
    … …  
    127127    void Pong::start()
    128128    {
    129         if (this->center_ != NULL) // There needs to be a PongCenterpoint, i.e. the area the game takes place.
    130         {
    131             if (this->ball_ == NULL) // If there is no ball, create a new ball.
     129        if (this->center_ != nullptr) // There needs to be a PongCenterpoint, i.e. the area the game takes place.
     130        {
     131            if (this->ball_ == nullptr) // If there is no ball, create a new ball.
    132132            {
    133133                this->ball_ = new PongBall(this->center_->getContext());
    … …  
    147147            for (size_t i = 0; i < 2; ++i)
    148148            {
    149                 if (this->bat_[i] == NULL)
     149                if (this->bat_[i] == nullptr)
    150150                {
    151151                    this->bat_[i] = new PongBat(this->center_->getContext());
    … …  
    231231
    232232        // If the first (left) bat has no player.
    233         if (this->bat_[0]->getPlayer() == NULL)
     233        if (this->bat_[0]->getPlayer() == nullptr)
    234234        {
    235235            player->startControl(this->bat_[0]);
    … …  
    237237        }
    238238        // If the second (right) bat has no player.
    239         else if (this->bat_[1]->getPlayer() == NULL)
     239        else if (this->bat_[1]->getPlayer() == nullptr)
    240240        {
    241241            player->startControl(this->bat_[1]);
    … …  
    247247
    248248        // If the player is an AI, it receives a pointer to the ball.
    249         if (player->getController() != NULL && player->getController()->isA(Class(PongAI)))
     249        if (player->getController() != nullptr && player->getController()->isA(Class(PongAI)))
    250250        {
    251251            PongAI* ai = orxonox_cast<PongAI*>(player->getController());
    … …  
    262262        Deathmatch::playerScored(player, score);
    263263
    264         if (this->center_ != NULL) // If there is a centerpoint.
     264        if (this->center_ != nullptr) // If there is a centerpoint.
    265265        {
    266266            // Fire an event for the player that has scored, to be able to react to it in the level, e.g. by displaying fireworks.
    … …  
    271271
    272272            // Also announce, that the player has scored.
    273             if (player != NULL)
     273            if (player != nullptr)
    274274                this->gtinfo_->sendAnnounceMessage(player->getName() + " scored");
    275275        }
    276276
    277277        // If there is a ball present, reset its position, velocity and acceleration.
    278         if (this->ball_ != NULL)
     278        if (this->ball_ != nullptr)
    279279        {
    280280            this->ball_->setPosition(Vector3::ZERO);
    … …  
    285285
    286286        // If there are bats reset them to the middle position.
    287         if (this->bat_[0] != NULL && this->bat_[1] != NULL)
     287        if (this->bat_[0] != nullptr && this->bat_[1] != nullptr)
    288288        {
    289289            this->bat_[0]->setPosition(-this->center_->getFieldDimension().x / 2, 0, 0);
    … …  
    292292
    293293        // If a player gets enough points, he won the game -> end of game
    294         PlayerInfo* winningPlayer = NULL;
     294        PlayerInfo* winningPlayer = nullptr;
    295295        if (this->getLeftPlayer() && this->getScore(this->getLeftPlayer()) >= scoreLimit_)
    296296            winningPlayer = this->getLeftPlayer();
    … …  
    314314    void Pong::startBall()
    315315    {
    316         if (this->ball_ != NULL && this->center_ != NULL)
     316        if (this->ball_ != nullptr && this->center_ != nullptr)
    317317            this->ball_->setSpeed(this->center_->getBallSpeed());
    318318    }
    … …  
    322322        Get the left player.
    323323    @return
    324         Returns a pointer to the player playing on the left. If there is no left player, NULL is returned.
     324        Returns a pointer to the player playing on the left. If there is no left player, nullptr is returned.
    325325    */
    326326    PlayerInfo* Pong::getLeftPlayer() const
    327327    {
    328         if (this->bat_ != NULL && this->bat_[0] != NULL)
     328        if (this->bat_ != nullptr && this->bat_[0] != nullptr)
    329329            return this->bat_[0]->getPlayer();
    330330        else
    … …  
    336336        Get the right player.
    337337    @return
    338         Returns a pointer to the player playing on the right. If there is no right player, NULL is returned.
     338        Returns a pointer to the player playing on the right. If there is no right player, nullptr is returned.
    339339    */
    340340    PlayerInfo* Pong::getRightPlayer() const
    341341    {
    342         if (this->bat_ != NULL && this->bat_[1] != NULL)
     342        if (this->bat_ != nullptr && this->bat_[1] != nullptr)
    343343            return this->bat_[1]->getPlayer();
    344344        else

  • code/branches/cpp11_v2/src/modules/pong/PongAI.cc

    r10727 r10765  
    101101    {
    102102        // If either the ball, or the controllable entity (i.e. the bat) don't exist (or aren't set).
    103         if (this->ball_  == NULL || this->getControllableEntity() == NULL)
     103        if (this->ball_  == nullptr || this->getControllableEntity() == nullptr)
    104104            return;
    105105

  • code/branches/cpp11_v2/src/modules/pong/PongBall.cc

    r9945 r10765  
    163163            float distance = 0;
    164164
    165             if (this->bat_ != NULL) // If there are bats.
     165            if (this->bat_ != nullptr) // If there are bats.
    166166            {
    167167                // If the right boundary has been crossed.
    168                 if (position.x > this->fieldWidth_ / 2 && this->bat_[1] != NULL)
     168                if (position.x > this->fieldWidth_ / 2 && this->bat_[1] != nullptr)
    169169                {
    170170                    // Calculate the distance (in z-direction) between the ball and the center of the bat, weighted by half of the effective length of the bat (with additional 10%)
    … …  
    195195                }
    196196                // If the left boundary has been crossed.
    197                 else if (position.x < -this->fieldWidth_ / 2 && this->bat_[0] != NULL)
     197                else if (position.x < -this->fieldWidth_ / 2 && this->bat_[0] != nullptr)
    198198                {
    199199                    // Calculate the distance (in z-direction) between the ball and the center of the bat, weighted by half of the effective length of the bat (with additional 10%)
    … …  
    285285    {
    286286        // Make space for the bats, if they don't exist, yet.
    287         if (this->bat_ == NULL)
     287        if (this->bat_ == nullptr)
    288288        {
    289289            this->bat_ = new WeakPtr<PongBat>[2];

  • code/branches/cpp11_v2/src/modules/pong/PongCenterpoint.cc

    r10624 r10765  
    8484    void PongCenterpoint::checkGametype()
    8585    {
    86         if (this->getGametype() != NULL && this->getGametype()->isA(Class(Pong)))
     86        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(Pong)))
    8787        {
    8888            Pong* pongGametype = orxonox_cast<Pong*>(this->getGametype());

  • code/branches/cpp11_v2/src/modules/pong/PongScore.cc

    r10624 r10765  
    9797
    9898        // If the owner is set. The owner being a Pong game.
    99         if (this->owner_ != NULL)
     99        if (this->owner_ != nullptr)
    100100        {
    101101            if (!this->owner_->hasEnded())
    … …  
    113113
    114114            // Save the name and score of each player as a string.
    115             if (player1_ != NULL)
     115            if (player1_ != nullptr)
    116116            {
    117117                name1 = player1_->getName();
    118118                score1 = multi_cast<std::string>(this->owner_->getScore(player1_));
    119119            }
    120             if (player2_ != NULL)
     120            if (player2_ != nullptr)
    121121            {
    122122                name2 = player2_->getName();
    … …  
    128128            if (this->bShowLeftPlayer_)
    129129            {
    130                 if (this->bShowName_ && this->bShowScore_ && player1_ != NULL)
     130                if (this->bShowName_ && this->bShowScore_ && player1_ != nullptr)
    131131                    output1 = name1 + " - " + score1;
    132132                else if (this->bShowScore_)
    … …  
    139139            if (this->bShowRightPlayer_)
    140140            {
    141                 if (this->bShowName_ && this->bShowScore_ && player2_ != NULL)
     141                if (this->bShowName_ && this->bShowScore_ && player2_ != nullptr)
    142142                    output2 = score2 + " - " + name2;
    143143                else if (this->bShowScore_)
    … …  
    163163    @brief
    164164        Is called when the owner changes.
    165         Sets the owner to NULL, if it is not a pointer to a Pong game.
     165        Sets the owner to nullptr, if it is not a pointer to a Pong game.
    166166    */
    167167    void PongScore::changedOwner()
    … …  
    169169        SUPER(PongScore, changedOwner);
    170170
    171         if (this->getOwner() != NULL && this->getOwner()->getGametype())
     171        if (this->getOwner() != nullptr && this->getOwner()->getGametype())
    172172            this->owner_ = orxonox_cast<Pong*>(this->getOwner()->getGametype());
    173173        else

  • code/branches/cpp11_v2/src/modules/portals/PortalEndPoint.cc

    r9667 r10765  
    4848    std::map<unsigned int, PortalEndPoint *> PortalEndPoint::idMap_s;
    4949
    50     PortalEndPoint::PortalEndPoint(Context* context) : StaticEntity(context), RadarViewable(this, static_cast<WorldEntity*>(this)), id_(0), trigger_(NULL), reenterDelay_(0)
     50    PortalEndPoint::PortalEndPoint(Context* context) : StaticEntity(context), RadarViewable(this, static_cast<WorldEntity*>(this)), id_(0), trigger_(nullptr), reenterDelay_(0)
    5151    {
    5252        RegisterObject(PortalEndPoint);
    … …  
    7070    PortalEndPoint::~PortalEndPoint()
    7171    {
    72         if(this->isInitialized() && this->trigger_ != NULL)
     72        if(this->isInitialized() && this->trigger_ != nullptr)
    7373            delete this->trigger_;
    7474    }

  • code/branches/cpp11_v2/src/modules/questsystem/GlobalQuest.cc

    r9667 r10765  
    138138    bool GlobalQuest::isStartable(const PlayerInfo* player) const
    139139    {
    140         if(!(this->getParentQuest() == NULL || this->getParentQuest()->isActive(player)))
     140        if(!(this->getParentQuest() == nullptr || this->getParentQuest()->isActive(player)))
    141141            return false;
    142142
    … …  
    198198        The status to be set.
    199199    @return
    200         Returns false if player is NULL.
     200        Returns false if player is nullptr.
    201201    */
    202202    bool GlobalQuest::setStatus(PlayerInfo* player, const QuestStatus::Value & status)
    … …  
    249249            i--;
    250250        }
    251         return NULL;
     251        return nullptr;
    252252    }
    253253

  • code/branches/cpp11_v2/src/modules/questsystem/LocalQuest.cc

    r9667 r10765  
    128128    bool LocalQuest::isStartable(const PlayerInfo* player) const
    129129    {
    130         if(!(this->getParentQuest() == NULL || this->getParentQuest()->isActive(player)))
     130        if(!(this->getParentQuest() == nullptr || this->getParentQuest()->isActive(player)))
    131131            return false;
    132132
    … …  
    188188        The status to be set.
    189189    @return
    190         Returns false if player is NULL.
     190        Returns false if player is nullptr.
    191191    */
    192192    bool LocalQuest::setStatus(PlayerInfo* player, const QuestStatus::Value & status)

  • code/branches/cpp11_v2/src/modules/questsystem/Quest.cc

    r10624 r10765  
    5555        RegisterObject(Quest);
    5656
    57         this->parentQuest_ = NULL;
     57        this->parentQuest_ = nullptr;
    5858    }
    5959
    … …  
    183183        The index.
    184184    @return
    185         Returns a pointer to the sub-quest at the given index. NULL if there is no element at the given index.
     185        Returns a pointer to the sub-quest at the given index. nullptr if there is no element at the given index.
    186186    */
    187187    const Quest* Quest::getSubQuest(unsigned int index) const
    … …  
    198198        }
    199199
    200         return NULL; // If the index is greater than the number of elements in the list.
     200        return nullptr; // If the index is greater than the number of elements in the list.
    201201    }
    202202
    … …  
    207207        The index.
    208208    @return
    209         Returns a pointer to the QuestHint at the given index. NULL if there is no element at the given index.
     209        Returns a pointer to the QuestHint at the given index. nullptr if there is no element at the given index.
    210210    */
    211211    const QuestHint* Quest::getHint(unsigned int index) const
    … …  
    221221            i--;
    222222        }
    223         return NULL; // If the index is greater than the number of elements in the list.
     223        return nullptr; // If the index is greater than the number of elements in the list.
    224224    }
    225225
    … …  
    230230        The index.
    231231    @return
    232         Returns a pointer to the fail QuestEffect at the given index. NULL if there is no element at the given index.
     232        Returns a pointer to the fail QuestEffect at the given index. nullptr if there is no element at the given index.
    233233    */
    234234    const QuestEffect* Quest::getFailEffect(unsigned int index) const
    … …  
    244244            i--;
    245245        }
    246         return NULL; // If the index is greater than the number of elements in the list.
     246        return nullptr; // If the index is greater than the number of elements in the list.
    247247    }
    248248
    … …  
    253253        The index.
    254254    @return
    255         Returns a pointer to the complete QuestEffect at the given index. NULL if there is no element at the given index.
     255        Returns a pointer to the complete QuestEffect at the given index. nullptr if there is no element at the given index.
    256256    */
    257257    const QuestEffect* Quest::getCompleteEffect(unsigned int index) const
    … …  
    267267            i--;
    268268        }
    269         return NULL; // If the index is greater than the number of elements in the list.
     269        return nullptr; // If the index is greater than the number of elements in the list.
    270270    }
    271271
    … …  
    280280    bool Quest::isInactive(const PlayerInfo* player) const
    281281    {
    282         if(player == NULL)
     282        if(player == nullptr)
    283283            return true;
    284284        return this->getStatus(player) == QuestStatus::Inactive;
    … …  
    295295    bool Quest::isActive(const PlayerInfo* player) const
    296296    {
    297         if(player == NULL)
     297        if(player == nullptr)
    298298            return false;
    299299        return this->getStatus(player) == QuestStatus::Active;
    … …  
    310310    bool Quest::isFailed(const PlayerInfo* player) const
    311311    {
    312         if(player == NULL)
     312        if(player == nullptr)
    313313            return false;
    314314        return this->getStatus(player) == QuestStatus::Failed;
    … …  
    325325    bool Quest::isCompleted(const PlayerInfo* player) const
    326326    {
    327         if(player == NULL)
     327        if(player == nullptr)
    328328            return false;
    329329        return this->getStatus(player) == QuestStatus::Completed;

  • code/branches/cpp11_v2/src/modules/questsystem/QuestEffectBeacon.cc

    r9667 r10765  
    113113
    114114        PlayerTrigger* pTrigger = orxonox_cast<PlayerTrigger*>(trigger);
    115         PlayerInfo* player = NULL;
     115        PlayerInfo* player = nullptr;
    116116
    117117        // If the trigger is a PlayerTrigger.
    118         if(pTrigger != NULL)
     118        if(pTrigger != nullptr)
    119119        {
    120120            if(!pTrigger->isForPlayer())  // The PlayerTrigger is not exclusively for Pawns which means we cannot extract one.
    … …  
    126126            return false;
    127127
    128         if(player == NULL)
     128        if(player == nullptr)
    129129        {
    130130            orxout(verbose, context::quests) << "The QuestEffectBeacon was triggered by an entity other than a Pawn. (" << trigger->getIdentifier()->getName() << ")" << endl;
    … …  
    243243            i--;
    244244        }
    245         return NULL;
     245        return nullptr;
    246246    }
    247247

  • code/branches/cpp11_v2/src/modules/questsystem/QuestHint.cc

    r9667 r10765  
    8888    bool QuestHint::isActive(const PlayerInfo* player) const
    8989    {
    90         if(player == NULL) // If the player is NULL, the Quest obviously can't be active.
     90        if(player == nullptr) // If the player is nullptr, the Quest obviously can't be active.
    9191            return false;
    9292

  • code/branches/cpp11_v2/src/modules/questsystem/QuestListener.cc

    r9667 r10765  
    5959
    6060        this->mode_ = QuestListenerMode::All;
    61         this->quest_ = NULL;
     61        this->quest_ = nullptr;
    6262    }
    6363
    … …  
    8181        XMLPortParam(QuestListener, "mode", setMode, getMode, xmlelement, mode);
    8282
    83         if(this->quest_ != NULL)
     83        if(this->quest_ != nullptr)
    8484            this->quest_->addListener(this); // Adds the QuestListener to the Quests list of listeners.
    8585
    … …  
    117117        this->quest_ = QuestManager::getInstance().findQuest(id); // Find the Quest corresponding to the given questId.
    118118
    119         if(this->quest_ == NULL) // If there is no such Quest.
     119        if(this->quest_ == nullptr) // If there is no such Quest.
    120120        {
    121121            ThrowException(Argument, "This is bad! The QuestListener has not found a Quest with a corresponding id..");

  • code/branches/cpp11_v2/src/modules/questsystem/QuestManager.cc

    r10624 r10765  
    9393    bool QuestManager::registerQuest(Quest* quest)
    9494    {
    95         if(quest == NULL)
    96         {
    97             orxout(internal_error, context::quests) << "Quest pointer is NULL." << endl;
     95        if(quest == nullptr)
     96        {
     97            orxout(internal_error, context::quests) << "Quest pointer is nullptr." << endl;
    9898            return false;
    9999        }
    … …  
    135135    bool QuestManager::registerHint(QuestHint* hint)
    136136    {
    137         if(hint == NULL)
    138         {
    139             orxout(internal_error, context::quests) << "Quest pointer is NULL." << endl;
     137        if(hint == nullptr)
     138        {
     139            orxout(internal_error, context::quests) << "Quest pointer is nullptr." << endl;
    140140            return false;
    141141        }
    … …  
    173173    @return
    174174        Returns a pointer to the Quest with the input id.
    175         Returns NULL if there is no Quest with the given questId.
     175        Returns nullptr if there is no Quest with the given questId.
    176176    @throws
    177177        Throws an exception if the given questId is invalid.
    … …  
    188188        else
    189189        {
    190            quest = NULL;
     190           quest = nullptr;
    191191           orxout(internal_warning, context::quests) << "The quest with id {" << questId << "} is nowhere to be found." << endl;
    192192        }
    … …  
    202202    @return
    203203        Returns a pointer to the QuestHint with the input id.
    204         Returns NULL if there is no QuestHint with the given hintId.
     204        Returns nullptr if there is no QuestHint with the given hintId.
    205205    @throws
    206206        Throws an exception if the given hintId is invalid.
    … …  
    217217        else
    218218        {
    219            hint = NULL;
     219           hint = nullptr;
    220220           orxout(internal_warning, context::quests) << "The hint with id {" << hintId << "} is nowhere to be found." << endl;
    221221        }
    … …  
    237237        for(std::map<std::string, Quest*>::iterator it = this->questMap_.begin(); it != this->questMap_.end(); it++)
    238238        {
    239             if(it->second->getParentQuest() == NULL && !it->second->isInactive(player))
     239            if(it->second->getParentQuest() == nullptr && !it->second->isInactive(player))
    240240                numQuests++;
    241241        }
    … …  
    257257        for(std::map<std::string, Quest*>::iterator it = this->questMap_.begin(); it != this->questMap_.end(); it++)
    258258        {
    259             if(it->second->getParentQuest() == NULL && !it->second->isInactive(player) && index-- == 0)
     259            if(it->second->getParentQuest() == nullptr && !it->second->isInactive(player) && index-- == 0)
    260260                return it->second;
    261261        }
    262         return NULL;
     262        return nullptr;
    263263    }
    264264
    … …  
    275275    int QuestManager::getNumSubQuests(Quest* quest, PlayerInfo* player)
    276276    {
    277         if(quest == NULL)
     277        if(quest == nullptr)
    278278            return this->getNumRootQuests(player);
    279279
    … …  
    300300    Quest* QuestManager::getSubQuest(Quest* quest, PlayerInfo* player, int index)
    301301    {
    302         if(quest == NULL)
     302        if(quest == nullptr)
    303303            return this->getRootQuest(player, index);
    304304
    … …  
    309309                return *it;
    310310        }
    311         return NULL;
     311        return nullptr;
    312312    }
    313313
    … …  
    354354                return *it;
    355355        }
    356         return NULL;
     356        return nullptr;
    357357    }
    358358
    … …  
    367367    Quest* QuestManager::getParentQuest(Quest* quest)
    368368    {
    369         OrxAssert(quest, "The input Quest is NULL.");
     369        OrxAssert(quest, "The input Quest is nullptr.");
    370370        return quest->getParentQuest();
    371371    }
    … …  
    381381    QuestDescription* QuestManager::getDescription(Quest* item)
    382382    {
    383         OrxAssert(item, "The input Quest is NULL.");
     383        OrxAssert(item, "The input Quest is nullptr.");
    384384        return item->getDescription();
    385385    }
    … …  
    395395    QuestDescription* QuestManager::getDescription(QuestHint* item)
    396396    {
    397         OrxAssert(item, "The input QuestHint is NULL.");
     397        OrxAssert(item, "The input QuestHint is nullptr.");
    398398        return item->getDescription();
    399399    }
    … …  
    409409    const std::string QuestManager::getId(Quest* item) const
    410410    {
    411         OrxAssert(item, "The input Quest is NULL.");
     411        OrxAssert(item, "The input Quest is nullptr.");
    412412        return item->getId();
    413413    }
    … …  
    423423    const std::string QuestManager::getId(QuestHint* item) const
    424424    {
    425         OrxAssert(item, "The input QuestHint is NULL.");
     425        OrxAssert(item, "The input QuestHint is nullptr.");
    426426        return item->getId();
    427427    }
    … …  
    440440    {
    441441        PlayerInfo* player = GUIManager::getInstance().getPlayer(guiName);
    442         if(player == NULL)
     442        if(player == nullptr)
    443443        {
    444444            orxout(internal_error, context::quests) << "GUIOverlay with name '" << guiName << "' has no player." << endl;
    445             return NULL;
     445            return nullptr;
    446446        }
    447447

  • code/branches/cpp11_v2/src/modules/questsystem/effects/AddQuest.cc

    r9667 r10765  
    9090        {
    9191            Quest* quest = QuestManager::getInstance().findQuest(this->getQuestId());
    92             if(quest == NULL || !quest->start(player))
     92            if(quest == nullptr || !quest->start(player))
    9393               return false;
    9494        }

  • code/branches/cpp11_v2/src/modules/questsystem/effects/AddQuestHint.cc

    r9667 r10765  
    113113        {
    114114            QuestHint* hint = QuestManager::getInstance().findHint(this->hintId_);
    115             if(hint == NULL || !hint->setActive(player))
     115            if(hint == nullptr || !hint->setActive(player))
    116116                return false;
    117117        }

  • code/branches/cpp11_v2/src/modules/questsystem/effects/AddReward.cc

    r9667 r10765  
    9090            i--;
    9191        }
    92         return NULL;
     92        return nullptr;
    9393    }
    9494

  • code/branches/cpp11_v2/src/modules/questsystem/effects/CompleteQuest.cc

    r9667 r10765  
    9292        {
    9393            quest = QuestManager::getInstance().findQuest(this->getQuestId());
    94             if(quest == NULL || !quest->complete(player))
     94            if(quest == nullptr || !quest->complete(player))
    9595               return false;
    9696        }

  • code/branches/cpp11_v2/src/modules/questsystem/effects/FailQuest.cc

    r9667 r10765  
    9191        {
    9292            quest = QuestManager::getInstance().findQuest(this->getQuestId());
    93             if(quest == NULL || !quest->fail(player))
     93            if(quest == nullptr || !quest->fail(player))
    9494               return false;
    9595        }

  • code/branches/cpp11_v2/src/modules/tetris/Tetris.cc

    r10624 r10765  
    7272        this->starttimer_.stopTimer();
    7373
    74         this->player_ = NULL;
     74        this->player_ = nullptr;
    7575        this->setHUDTemplate("TetrisHUD");
    7676        this->futureBrick_ = 0;
    … …  
    113113        SUPER(Tetris, tick, dt);
    114114
    115         if((this->activeBrick_ != NULL)&&(!this->hasEnded()))
     115        if((this->activeBrick_ != nullptr)&&(!this->hasEnded()))
    116116        {
    117117            if(!this->isValidBrickPosition(this->activeBrick_))
    … …  
    290290    void Tetris::start()
    291291    {
    292         if (this->center_ != NULL) // There needs to be a TetrisCenterpoint, i.e. the area the game takes place.
     292        if (this->center_ != nullptr) // There needs to be a TetrisCenterpoint, i.e. the area the game takes place.
    293293        {
    294294            // Create the first brick.
    … …  
    323323    {
    324324        this->activeBrick_->setVelocity(Vector3::ZERO);
    325         if(this->activeBrick_ != NULL)
     325        if(this->activeBrick_ != nullptr)
    326326        {
    327327            this->player_->stopControl();
    … …  
    351351        if(player && player->isHumanPlayer())
    352352        {
    353             if(this->activeBrick_ != NULL)
     353            if(this->activeBrick_ != nullptr)
    354354            {
    355355                this->player_->stopControl();
    … …  
    370370        assert(player);
    371371
    372         if(this->player_ == NULL)
     372        if(this->player_ == nullptr)
    373373        {
    374374            this->player_ = player;
    … …  
    381381    void Tetris::startBrick(void)
    382382    {
    383         if(this->player_ == NULL)
     383        if(this->player_ == nullptr)
    384384            return;
    385385
    386386        unsigned int cameraIndex = 0;
    387         if(this->activeBrick_ != NULL)
     387        if(this->activeBrick_ != nullptr)
    388388        {
    389389            // Get camera settings
    … …  
    437437        Get the player.
    438438    @return
    439         Returns a pointer to the player. If there is no player, NULL is returned.
     439        Returns a pointer to the player. If there is no player, nullptr is returned.
    440440    */
    441441    PlayerInfo* Tetris::getPlayer(void) const

  • code/branches/cpp11_v2/src/modules/tetris/TetrisBrick.cc

    r10624 r10765  
    8181            this->attach(stone);
    8282            this->formBrick(stone, i);
    83             if(this->tetris_ != NULL)
     83            if(this->tetris_ != nullptr)
    8484            {
    8585                stone->setGame(this->tetris_);
    86                 if(this->tetris_->getCenterpoint() != NULL)
     86                if(this->tetris_->getCenterpoint() != nullptr)
    8787                    stone->addTemplate(this->tetris_->getCenterpoint()->getStoneTemplate());
    8888                else
    89                     orxout()<< "tetris_->getCenterpoint == NULL in TetrisBrick.cc"<< endl;
     89                    orxout()<< "tetris_->getCenterpoint == nullptr in TetrisBrick.cc"<< endl;
    9090            }
    9191            else
    92                 orxout()<< "tetris_ == NULL in TetrisBrick.cc"<< endl;
     92                orxout()<< "tetris_ == nullptr in TetrisBrick.cc"<< endl;
    9393        }
    9494    }
    … …  
    161161        if(i < this->brickStones_.size())
    162162            return this->brickStones_[i];
    163         else return NULL;
     163        else return nullptr;
    164164    }
    165165
    … …  
    167167    Tetris* TetrisBrick::getTetris()
    168168    {
    169         if (this->getGametype() != NULL && this->getGametype()->isA(Class(Tetris)))
     169        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(Tetris)))
    170170        {
    171171            Tetris* tetrisGametype = orxonox_cast<Tetris*>(this->getGametype());
    172172            return tetrisGametype;
    173173        }
    174         return NULL;
     174        return nullptr;
    175175    }
    176176

  • code/branches/cpp11_v2/src/modules/tetris/TetrisCenterpoint.cc

    r10624 r10765  
    8484    void TetrisCenterpoint::checkGametype()
    8585    {
    86         if (this->getGametype() != NULL && this->getGametype()->isA(Class(Tetris)))
     86        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(Tetris)))
    8787        {
    8888            Tetris* tetrisGametype = orxonox_cast<Tetris*>(this->getGametype());

  • code/branches/cpp11_v2/src/modules/tetris/TetrisScore.cc

    r10624 r10765  
    5757
    5858        this->owner_ = 0;
    59         this->player_ = NULL;
     59        this->player_ = nullptr;
    6060    }
    6161
    … …  
    8989
    9090        // If the owner is set. The owner being a Tetris game.
    91         if (this->owner_ != NULL)
     91        if (this->owner_ != nullptr)
    9292        {
    9393            std::string score("0");
    … …  
    101101            {
    102102                // Save the name and score of each player as a string.
    103                 if (player_ != NULL)
     103                if (player_ != nullptr)
    104104                    score = multi_cast<std::string>(this->owner_->getScore(player_));
    105105            }
    … …  
    111111    @brief
    112112        Is called when the owner changes.
    113         Sets the owner to NULL, if it is not a pointer to a Tetris game.
     113        Sets the owner to nullptr, if it is not a pointer to a Tetris game.
    114114    */
    115115    void TetrisScore::changedOwner()
    … …  
    117117        SUPER(TetrisScore, changedOwner);
    118118
    119         if (this->getOwner() != NULL && this->getOwner()->getGametype())
     119        if (this->getOwner() != nullptr && this->getOwner()->getGametype())
    120120            this->owner_ = orxonox_cast<Tetris*>(this->getOwner()->getGametype());
    121121        else

  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefense.cc

    r10727 r10765  
    9090        RegisterObject(TowerDefense);
    9191
    92         selecter = NULL;
    93         this->player_ = NULL;       
     92        selecter = nullptr;
     93        this->player_ = nullptr;
    9494        this->setHUDTemplate("TowerDefenseHUD");
    9595        this->waveNumber_ = 0;
    … …  
    117117    void TowerDefense::start()
    118118    {       
    119         if (center_ != NULL) // There needs to be a TowerDefenseCenterpoint, i.e. the area the game takes place.
    120         {
    121             if (selecter == NULL)
     119        if (center_ != nullptr) // There needs to be a TowerDefenseCenterpoint, i.e. the area the game takes place.
     120        {
     121            if (selecter == nullptr)
    122122            {
    123123                selecter = new TowerDefenseSelecter(this->center_->getContext());               
    … …  
    176176        WaypointController* controller = (WaypointController*)(en1->getXMLController());
    177177
    178         if (controller != NULL && waypoints_.size() > 1)
     178        if (controller != nullptr && waypoints_.size() > 1)
    179179        {
    180180            en1->setPosition(waypoints_.at(0)->getPosition() + offset_);
    … …  
    208208        player_ = player;
    209209
    210         if (selecter->getPlayer() == NULL)
     210        if (selecter->getPlayer() == nullptr)
    211211        {
    212212            player_->startControl(selecter);
    … …  
    219219        Get the player.
    220220    @return
    221         Returns a pointer to the player. If there is no player, NULL is returned.
     221        Returns a pointer to the player. If there is no player, nullptr is returned.
    222222    */
    223223    PlayerInfo* TowerDefense::getPlayer(void) const
    … …  
    265265        SUPER(TowerDefense, tick, dt);
    266266
    267         if (hasStarted() == false || player_ == NULL)
     267        if (hasStarted() == false || player_ == nullptr)
    268268        {
    269269            return;
    … …  
    273273
    274274        //build/upgrade tower at selecter position
    275         if (selecter != NULL && selecter->buildTower_ == true)
     275        if (selecter != nullptr && selecter->buildTower_ == true)
    276276        {
    277277            selecter->buildTower_ = false;
    … …  
    289289        for (std::list<WeakPtr<TowerDefenseEnemy> >::iterator it = enemies_.begin(); it != enemies_.end(); )
    290290        {
    291             if (*it == NULL)
     291            if (*it == nullptr)
    292292            {
    293293                // the enemy was destroyed by a tower - remove it from the list
    … …  
    365365        TDCoordinate* thisCoord = &startCoord;
    366366        TDCoordinate* nextCoord;
    367         while ((nextCoord = getNextStreetCoord(thisCoord)) != NULL)
     367        while ((nextCoord = getNextStreetCoord(thisCoord)) != nullptr)
    368368        {
    369369            waypoints_.push_back(fields_[nextCoord->GetX()][nextCoord->GetY()]);           
    … …  
    381381        if (thisField->getType() != STREET && thisField->getType() != START)
    382382        {
    383             return NULL;
     383            return nullptr;
    384384        }
    385385
    … …  
    406406        }
    407407
    408         return NULL;
     408        return nullptr;
    409409    }
    410410}

  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseCenterpoint.cc

    r10629 r10765  
    9292    void TowerDefenseCenterpoint::checkGametype()
    9393    {
    94         if (this->getGametype() != NULL && this->getGametype()->isA(Class(TowerDefense)))
     94        if (this->getGametype() != nullptr && this->getGametype()->isA(Class(TowerDefense)))
    9595        {
    9696            // Sets the centerpoint of the gametype. The gametype uses this to later spawn in towers, he needs the tower template stored in the center point

  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseEnemy.cc

    r10629 r10765  
    4747    WeakPtr<TowerDefense> TowerDefenseEnemy::getGame()
    4848    {
    49         if (game == NULL)
     49        if (game == nullptr)
    5050        {
    5151            for (ObjectList<TowerDefense>::iterator it = ObjectList<TowerDefense>::begin(); it != ObjectList<TowerDefense>::end(); ++it)

  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseField.cc

    r10629 r10765  
    4949        RegisterObject(TowerDefenseField);
    5050
    51         tower_ = NULL;
     51        tower_ = nullptr;
    5252        type_ = FREE;
    53         center_ = NULL;
     53        center_ = nullptr;
    5454        upgrade_ = 0;
    5555        setPosition(0,0,0);                           
    … …  
    119119    bool TowerDefenseField::canUpgrade()
    120120    {
    121         if (tower_ != NULL && upgrade_ < 5)
     121        if (tower_ != nullptr && upgrade_ < 5)
    122122        {
    123123            return true;
    … …  
    129129    void TowerDefenseField::setAngle(int newAngle)
    130130    {
    131         if (modelGround_ != NULL)
     131        if (modelGround_ != nullptr)
    132132        {
    133133            switch (newAngle)
    … …  
    152152        }
    153153
    154         if (modelObject_ != NULL)
     154        if (modelObject_ != nullptr)
    155155        {
    156156            switch (newAngle)
    … …  
    185185    {           
    186186        modelGround_->setMeshSource("TD_F1.mesh");
    187         tower_ = NULL;
     187        tower_ = nullptr;
    188188        type_ = FREE;
    189189        setUpgrade(0);
    … …  
    194194    {     
    195195        modelGround_->setMeshSource("TD_S5.mesh");
    196         tower_ = NULL;
     196        tower_ = nullptr;
    197197        type_ = START;
    198198        setUpgrade(0);
    … …  
    204204    {     
    205205        modelGround_->setMeshSource("TD_S4.mesh");
    206         tower_ = NULL;
     206        tower_ = nullptr;
    207207        type_ = END;
    208208        setUpgrade(0);
    … …  
    213213    {     
    214214        modelGround_->setMeshSource("TD_S1.mesh");
    215         tower_ = NULL;
     215        tower_ = nullptr;
    216216        type_ = STREET;
    217217        setUpgrade(0);
    … …  
    222222    {     
    223223        modelGround_->setMeshSource("TD_S2.mesh");
    224         tower_ = NULL;
     224        tower_ = nullptr;
    225225        type_ = STREET;
    226226        setUpgrade(0);
    … …  
    231231    {   
    232232        modelGround_->setMeshSource("TD_S3.mesh");
    233         tower_ = NULL;
     233        tower_ = nullptr;
    234234        type_ = STREET;
    235235        setUpgrade(0);
    … …  
    241241        modelGround_->setMeshSource("TD_F1.mesh");
    242242        modelObject_->setMeshSource("TD_O1.mesh");
    243         tower_ = NULL;
     243        tower_ = nullptr;
    244244        type_ = OBSTACLE;
    245245        setUpgrade(0);
    … …  
    249249    void TowerDefenseField::createTower(int upgrade)
    250250    {       
    251         if (tower_ == NULL)
     251        if (tower_ == nullptr)
    252252        {
    253253            modelGround_->setMeshSource("TD_F1.mesh");
    … …  
    256256            type_ = TOWER;
    257257            setUpgrade(upgrade);
    258             if (upgrade_ > 0 && modelObject_ != NULL)
     258            if (upgrade_ > 0 && modelObject_ != nullptr)
    259259            {
    260260                switch (upgrade_)
    … …  
    287287    void TowerDefenseField::destroyTower()
    288288    {
    289         if (tower_ != NULL)
     289        if (tower_ != nullptr)
    290290        {
    291291            tower_->destroy();
    292             tower_ = NULL;
     292            tower_ = nullptr;
    293293        }
    294294    }

  • code/branches/cpp11_v2/src/modules/towerdefense/TowerDefenseTower.cc

    r10727 r10765  
    2525    {
    2626        RegisterObject(TowerDefenseTower);
    27         game_ =NULL;
     27        game_ =nullptr;
    2828        this->setCollisionType(WorldEntity::None);
    2929        upgrade = 1;

  • code/branches/cpp11_v2/src/modules/weapons/IceGunFreezer.cc

    r10629 r10765  
    101101
    102102        // Check if the freezer is attached to a parent and check if the parent is a SpaceShip
    103         if (parent != NULL && parent->isA(Class(SpaceShip)))
     103        if (parent != nullptr && parent->isA(Class(SpaceShip)))
    104104        {
    105105            freezedSpaceShip_ = orxonox_cast<SpaceShip*>(parent);
    … …  
    118118    void IceGunFreezer::stopFreezing()
    119119    {
    120         if (freezedSpaceShip_ != NULL && freezeFactor_ != 0.0)
     120        if (freezedSpaceShip_ != nullptr && freezeFactor_ != 0.0)
    121121        {
    122122            freezedSpaceShip_->addSpeedFactor(1/freezeFactor_);

  • code/branches/cpp11_v2/src/modules/weapons/projectiles/BasicProjectile.cc

    r10293 r10765  
    8888                                    // The projectile is destroyed by its tick()-function (in the following tick).
    8989
    90             Pawn* victim = orxonox_cast<Pawn*>(otherObject); // If otherObject isn't a Pawn, then victim is NULL
     90            Pawn* victim = orxonox_cast<Pawn*>(otherObject); // If otherObject isn't a Pawn, then victim is nullptr
    9191
    9292            WorldEntity* entity = orxonox_cast<WorldEntity*>(this);
    … …  
    146146    bool BasicProjectile::isObjectRelatedToShooter(WorldEntity* otherObject)
    147147    {
    148         for (WorldEntity* shooter = this->getShooter(); shooter != NULL; shooter = shooter->getParent())
     148        for (WorldEntity* shooter = this->getShooter(); shooter != nullptr; shooter = shooter->getParent())
    149149            if (otherObject == shooter)
    150150                return true;
    151         for (WorldEntity* object = otherObject; object != NULL; object = object->getParent())
     151        for (WorldEntity* object = otherObject; object != nullptr; object = object->getParent())
    152152            if (otherObject == this->getShooter())
    153153                return true;

  • code/branches/cpp11_v2/src/modules/weapons/projectiles/GravityBombField.cc

    r10622 r10765  
    137137                        float damage = FORCE_FIELD_EXPLOSION_DAMMAGE*(1-distanceVector.length()/EXPLOSION_RADIUS);
    138138                        //orxout(debug_output) << "Damage: " << damage << endl;
    139                         it->hit(shooter_, it->getWorldPosition(), NULL, damage, 0,0);
     139                        it->hit(shooter_, it->getWorldPosition(), nullptr, damage, 0,0);
    140140                        victimsAlreadyDamaged_.push_back(*it);
    141141                    }

  • code/branches/cpp11_v2/src/modules/weapons/projectiles/Projectile.cc

    r10629 r10765  
    9494    void Projectile::setCollisionShapeRadius(float radius)
    9595    {
    96         if (collisionShape_ != NULL && radius > 0)
     96        if (collisionShape_ != nullptr && radius > 0)
    9797        {
    9898            collisionShape_->setRadius(radius);

  • code/branches/cpp11_v2/src/orxonox/CameraManager.cc

    r10624 r10765  
    9393                this->cameraList_.front()->setFocus();
    9494            else
    95                 this->useCamera(NULL);
     95                this->useCamera(nullptr);
    9696        }
    9797        else

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

    r10624 r10765  
    154154        Get the currently active Level.
    155155    @return
    156         Returns a pointer to the currently active level or NULL if there currently are no active Levels.
     156        Returns a pointer to the currently active level or nullptr if there currently are no active Levels.
    157157    */
    158158    Level* LevelManager::getActiveLevel()
    … …  
    218218    {
    219219        if(index >= this->availableLevels_.size())
    220             return NULL;
     220            return nullptr;
    221221
    222222        // If this index directly follows the last we can optimize a lot.
    … …  
    272272            if (it->find("old/") != 0)
    273273            {
    274                 LevelInfoItem* info = NULL;
     274                LevelInfoItem* info = nullptr;
    275275
    276276                // Load the LevelInfo object from the level file.
    … …  
    286286                Loader::getInstance().unload(&file);
    287287
    288                 if(info == NULL)
     288                if(info == nullptr)
    289289                {
    290290                    // Create a default LevelInfoItem object that merely contains the name

  • code/branches/cpp11_v2/src/orxonox/Scene.cc

    r10727 r10765  
    6666        this->bShadows_ = true;
    6767        this->bDebugDrawPhysics_ = false;
    68         this->debugDrawer_ = NULL;
     68        this->debugDrawer_ = nullptr;
    6969        this->soundReferenceDistance_ = 20.0;
    7070        this->bIsUpdatingPhysics_ = false;

  • code/branches/cpp11_v2/src/orxonox/chat/ChatInputHandler.cc

    r10624 r10765  
    7979    this->inpbuf = new InputBuffer();
    8080    this->disp_offset = 0;
    81     assert( this->inpbuf != NULL );
     81    assert( this->inpbuf != nullptr );
    8282
    8383    /* generate chatbox ui and chatbox-inputonly ui */

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/CollisionShape.h

    r9667 r10765  
    181181
    182182            btCollisionShape*       collisionShape_; //!< The bullet collision shape of this CollisionShape.
    183             CompoundCollisionShape* parent_; //!< The CompoundCollisionShape this CollisionShape belongs to, NULL if it doesn't belong to one.
     183            CompoundCollisionShape* parent_; //!< The CompoundCollisionShape this CollisionShape belongs to, nullptr if it doesn't belong to one.
    184184            unsigned int            parentID_; //!< The objectID of the parent of this CollisionShape, which can either be a CompoundCollisionShape or a WorldEntity.
    185185

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/CompoundCollisionShape.cc

    r10624 r10765  
    7272                it->first->destroy();
    7373                if (this->collisionShape_ == it->second)
    74                     this->collisionShape_ = NULL; // don't destroy it twice
     74                    this->collisionShape_ = nullptr; // don't destroy it twice
    7575            }
    7676
    7777            delete this->compoundShape_;
    7878            if (this->collisionShape_ == this->compoundShape_)
    79                 this->collisionShape_ = NULL; // don't destroy it twice
     79                this->collisionShape_ = nullptr; // don't destroy it twice
    8080        }
    8181    }
    … …  
    9696    void CompoundCollisionShape::attach(CollisionShape* shape)
    9797    {
    98         // If either the input shape is NULL or we try to attach the CollisionShape to itself.
     98        // If either the input shape is nullptr or we try to attach the CollisionShape to itself.
    9999        if (!shape || static_cast<CollisionShape*>(this) == shape)
    100100            return;

  • code/branches/cpp11_v2/src/orxonox/collisionshapes/WorldEntityCollisionShape.cc

    r10624 r10765  
    4343        RegisterObject(WorldEntityCollisionShape);
    4444
    45         this->worldEntityOwner_ = NULL;
     45        this->worldEntityOwner_ = nullptr;
    4646        // suppress synchronisation
    4747        this->setSyncMode(ObjectDirection::None);

  • code/branches/cpp11_v2/src/orxonox/controllers/AIController.cc

    r9667 r10765  
    249249            }
    250250            else
    251                 this->setPreviousMode();//If bot dies -> getControllableEntity == NULL -> get out of ROCKET mode
     251                this->setPreviousMode();//If bot dies -> getControllableEntity == nullptr -> get out of ROCKET mode
    252252        }//END_OF ROCKET MODE
    253253

  • code/branches/cpp11_v2/src/orxonox/controllers/ArtificialController.cc

    r10733 r10765  
    5656        this->currentWaypoint_ = 0;
    5757        this->setAccuracy(5);
    58         this->defaultWaypoint_ = NULL;
     58        this->defaultWaypoint_ = nullptr;
    5959        this->mode_ = DEFAULT;//Vector-implementation: mode_.push_back(DEFAULT);
    6060    }
    … …  
    222222    {
    223223        SpaceShip* ship = orxonox_cast<SpaceShip*>(this->getControllableEntity());
    224         if(ship == NULL) return;
     224        if(ship == nullptr) return;
    225225        if(ship->getBoostPower()*1.5f > ship->getInitialBoostPower() ) //upper limit ->boost
    226226            this->getControllableEntity()->boost(true);
    … …  
    258258    void ArtificialController::updatePointsOfInterest(std::string name, float searchDistance)
    259259    {
    260         WorldEntity* waypoint = NULL;
     260        WorldEntity* waypoint = nullptr;
    261261        for (WorldEntity* we : ObjectList<WorldEntity>())
    262262        {

  • code/branches/cpp11_v2/src/orxonox/controllers/ControllerDirector.cc

    r10622 r10765  
    3232
    3333        // Initialize member variables
    34         this->player_ = NULL;
    35         this->entity_ = NULL;
    36         this->pTrigger_ = NULL;
     34        this->player_ = nullptr;
     35        this->entity_ = nullptr;
     36        this->pTrigger_ = nullptr;
    3737        this->context_ = context;
    3838    }
    … …  
    110110    {
    111111        this->pTrigger_ = orxonox_cast<PlayerTrigger*>(trigger);
    112         this->player_ = NULL;
     112        this->player_ = nullptr;
    113113
    114114        orxout(verbose) << "Preparation to take Control!" << endl;
    115115
    116116        // Check whether it is a player trigger and extract pawn from it
    117         if(this->pTrigger_ != NULL)
     117        if(this->pTrigger_ != nullptr)
    118118        {
    119119            // Get the object which triggered the event.
    … …  
    121121
    122122            // Check if there actually was a player returned.
    123             if( this->player_ == NULL) return false;
     123            if( this->player_ == nullptr) return false;
    124124        }
    125125        else

  • code/branches/cpp11_v2/src/orxonox/controllers/FormationController.cc

    r10631 r10765  
    773773    {
    774774
    775         Pawn *humanPawn = NULL;
    776         NewHumanController *currentHumanController = NULL;
     775        Pawn *humanPawn = nullptr;
     776        NewHumanController *currentHumanController = nullptr;
    777777        std::vector<FormationController*> allMasters;
    778778
    … …  
    800800        }
    801801
    802         if((humanPawn != NULL) && (allMasters.size() != 0))
     802        if((humanPawn != nullptr) && (allMasters.size() != 0))
    803803        {
    804804            float posHuman = humanPawn->getPosition().length();
    … …  
    826826    void FormationController::followInit(Pawn* pawn, const bool always, const int secondsToFollow)
    827827    {
    828         if (pawn == NULL || this->state_ != MASTER)
     828        if (pawn == nullptr || this->state_ != MASTER)
    829829            return;
    830830        this->specificMasterAction_  =  FOLLOW;
    … …  
    844844    {
    845845
    846         Pawn *humanPawn = NULL;
    847         NewHumanController *currentHumanController = NULL;
     846        Pawn *humanPawn = nullptr;
     847        NewHumanController *currentHumanController = nullptr;
    848848
    849849        for (ObjectList<Pawn>::iterator it = ObjectList<Pawn>::begin(); it; ++it)
    … …  
    861861        }
    862862
    863         if((humanPawn != NULL))
     863        if((humanPawn != nullptr))
    864864                this->followInit(humanPawn);
    865865    }

  • code/branches/cpp11_v2/src/orxonox/controllers/HumanController.cc

    r10624 r10765  
    321321            return orxonox_cast<Pawn*>(HumanController::localController_s->getControllableEntity());
    322322        else
    323             return NULL;
     323            return nullptr;
    324324    }
    325325

  • code/branches/cpp11_v2/src/orxonox/controllers/NewHumanController.cc

    r10631 r10765  
    6262    NewHumanController::NewHumanController(Context* context)
    6363        : HumanController(context)
    64         , crossHairOverlay_(NULL)
    65         , centerOverlay_(NULL)
    66         , damageOverlayTop_(NULL)
    67         , damageOverlayRight_(NULL)
    68         , damageOverlayBottom_(NULL)
    69         , damageOverlayLeft_(NULL)
     64        , crossHairOverlay_(nullptr)
     65        , centerOverlay_(nullptr)
     66        , damageOverlayTop_(nullptr)
     67        , damageOverlayRight_(nullptr)
     68        , damageOverlayBottom_(nullptr)
     69        , damageOverlayLeft_(nullptr)
    7070        , damageOverlayTT_(0)
    7171        , damageOverlayTR_(0)
    7272        , damageOverlayTB_(0)
    7373        , damageOverlayTL_(0)
    74         , arrowsOverlay1_(NULL)
    75         , arrowsOverlay2_(NULL)
    76         , arrowsOverlay3_(NULL)
    77         , arrowsOverlay4_(NULL)
     74        , arrowsOverlay1_(nullptr)
     75        , arrowsOverlay2_(nullptr)
     76        , arrowsOverlay3_(nullptr)
     77        , arrowsOverlay4_(nullptr)
    7878    {
    7979        RegisterObject(NewHumanController);

  • code/branches/cpp11_v2/src/orxonox/controllers/ScriptController.cc

    r10622 r10765  
    6464        /* Set default values for all variables */
    6565        /* - pointers to zero */
    66         this->player_ = NULL;
    67         this->entity_ = NULL;
     66        this->player_ = nullptr;
     67        this->entity_ = nullptr;
    6868
    6969        /* - times */
    … …  
    138138     
    139139      }
    140       return NULL;
     140      return nullptr;
    141141    }
    142142

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

    r10624 r10765  
    156156        {
    157157            ModifyConsoleCommand(__CC_changeGame_name).deactivate();
    158             ModifyConsoleCommand(__CC_reloadLevel_name).setObject(NULL).deactivate();
     158            ModifyConsoleCommand(__CC_reloadLevel_name).setObject(nullptr).deactivate();
    159159        }
    160160    }

  • code/branches/cpp11_v2/src/orxonox/gamestates/GSLevelMemento.h

    r10281 r10765  
    4848        protected:
    4949            /**
    50              * Returns the state of this memento. Returns NULL if no state needed to persist.
     50             * Returns the state of this memento. Returns nullptr if no state needed to persist.
    5151             */
    5252            virtual GSLevelMementoState* exportMementoState() = 0;

  • code/branches/cpp11_v2/src/orxonox/gamestates/GSMainMenu.cc

    r10624 r10765  
    7373
    7474        // create an empty Scene
    75         this->scene_ = new Scene(NULL);
     75        this->scene_ = new Scene(nullptr);
    7676        this->scene_->setSyncMode( 0x0 );
    7777        // and a Camera

  • code/branches/cpp11_v2/src/orxonox/gametypes/Gametype.cc

    r10624 r10765  
    9292                this->gtinfo_->destroy();
    9393
    94             ModifyConsoleCommand(__CC_addBots_name).setObject(NULL);
    95             ModifyConsoleCommand(__CC_killBots_name).setObject(NULL);
     94            ModifyConsoleCommand(__CC_addBots_name).setObject(nullptr);
     95            ModifyConsoleCommand(__CC_killBots_name).setObject(nullptr);
    9696        }
    9797    }
    … …  
    337337        {
    338338            // Fallback spawn point if there is no active one, choose a random one.
    339             SpawnPoint* fallbackSpawnPoint = NULL;
     339            SpawnPoint* fallbackSpawnPoint = nullptr;
    340340            unsigned int randomspawn = static_cast<unsigned int>(rnd(static_cast<float>(this->spawnpoints_.size())));
    341341            unsigned int index = 0;
    … …  
    346346                    fallbackSpawnPoint = (*it);
    347347
    348                 if (*it != NULL && (*it)->isActive())
     348                if (*it != nullptr && (*it)->isActive())
    349349                    activeSpawnPoints.push_back(*it);
    350350
    … …  
    552552        }
    553553
    554         return NULL;
     554        return nullptr;
    555555    }
    556556
    … …  
    558558    {
    559559        // find correct memento state
    560         GametypeMementoState* state = NULL;
     560        GametypeMementoState* state = nullptr;
    561561        for (size_t i = 0; i < states.size(); ++i)
    562562        {
    … …  
    570570
    571571        // find correct scene
    572         Scene* scene = NULL;
     572        Scene* scene = nullptr;
    573573        for (ObjectList<Scene>::iterator it = ObjectList<Scene>::begin(); it != ObjectList<Scene>::end(); ++it)
    574574        {

  • code/branches/cpp11_v2/src/orxonox/gametypes/TeamGametype.cc

    r9941 r10765  
    7575    void TeamGametype::playerEntered(PlayerInfo* player)
    7676    {
    77         if(player == NULL) return; // catch null pointers
     77        if(player == nullptr) return; // catch null pointers
    7878        Gametype::playerEntered(player);
    7979        this->findAndSetTeam(player);
    … …  
    9696    void TeamGametype::findAndSetTeam(PlayerInfo* player)
    9797    {
    98         if(player == NULL) return; // catch null pointers
     98        if(player == nullptr) return; // catch null pointers
    9999        std::vector<unsigned int> playersperteam(this->teams_, 0);
    100100
    … …  
    235235        }
    236236
    237         SpawnPoint* fallbackSpawnPoint = NULL;
     237        SpawnPoint* fallbackSpawnPoint = nullptr;
    238238        if (teamSpawnPoints.size() > 0)
    239239        {
    … …  
    328328    void TeamGametype::setDefaultObjectColour(Pawn* pawn)
    329329    {
    330         if(pawn == NULL)
     330        if(pawn == nullptr)
    331331            return;
    332332
    … …  
    350350        ArtificialController* artificial =  orxonox_cast<ArtificialController*>(controller);
    351351        //get Teamnumber - get the data
    352         if(artificial == NULL)
     352        if(artificial == nullptr)
    353353            return;
    354354        teamnumber= artificial->getTeam();
    … …  
    360360    void TeamGametype::colourPawn(Pawn* pawn, int teamNr)
    361361    {// catch: no-colouring-case and wrong input
    362         if(teamNr < 0 || teamNr+1 > int(this->teamcolours_.size()) ||pawn == NULL) return;
     362        if(teamNr < 0 || teamNr+1 > int(this->teamcolours_.size()) ||pawn == nullptr) return;
    363363        pawn->setRadarObjectColour(this->teamcolours_[teamNr]);
    364364

  • code/branches/cpp11_v2/src/orxonox/graphics/Billboard.cc

    r9667 r10765  
    139139    {
    140140        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
    141         if( bSet != NULL )
     141        if( bSet != nullptr )
    142142        {
    143143            bSet->setBillboardType(bbt);
    … …  
    148148    {
    149149        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
    150         if( bSet != NULL )
     150        if( bSet != nullptr )
    151151        {
    152152            bSet->setCommonDirection( vec );
    … …  
    157157    {
    158158        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
    159         if( bSet != NULL )
     159        if( bSet != nullptr )
    160160        {
    161161            bSet->setCommonUpVector( vec );
    … …  
    166166    {
    167167        Ogre::BillboardSet* bSet = this->billboard_.getBillboardSet();
    168         if( bSet != NULL )
     168        if( bSet != nullptr )
    169169        {
    170170            bSet->setDefaultDimensions(width, height);

  • code/branches/cpp11_v2/src/orxonox/graphics/Model.cc

    r10728 r10765  
    157157                BaseObject* creatorPtr = this;
    158158
    159                 while(creatorPtr!=NULL&&orxonox_cast<WorldEntity*>(creatorPtr))
     159                while(creatorPtr!=nullptr&&orxonox_cast<WorldEntity*>(creatorPtr))
    160160                {
    161161                    scaleFactor *= getBiggestScale(((WorldEntity*) creatorPtr)->getScale3D());

  • code/branches/cpp11_v2/src/orxonox/infos/PlayerInfo.cc

    r10624 r10765  
    181181
    182182        RadarViewable* radarviewable = orxonox_cast<RadarViewable*>(entity);
    183         if (radarviewable != NULL)
     183        if (radarviewable != nullptr)
    184184            radarviewable->setRadarName(this->getName());
    185185    }
    … …  
    235235
    236236        Controller* tmp =this->controllableEntity_->getController();
    237         if (tmp == NULL)
    238         {
    239             orxout(verbose) <<  "PlayerInfo: pauseControl, Controller is NULL " << endl;
     237        if (tmp == nullptr)
     238        {
     239            orxout(verbose) <<  "PlayerInfo: pauseControl, Controller is nullptr " << endl;
    240240            return;
    241241        }
    242242        tmp->setActive(false);
    243         //this->controllableEntity_->getController()->setControllableEntity(NULL);
     243        //this->controllableEntity_->getController()->setControllableEntity(nullptr);
    244244        this->controllableEntity_->setController(0);
    245245    }
    … …  
    249249        ControllableEntity* entity = this->controllableEntity_;
    250250
    251         assert(this->controllableEntity_ != NULL);
     251        assert(this->controllableEntity_ != nullptr);
    252252        if( !entity || this->previousControllableEntity_.size() == 0 )
    253253            return;
    … …  
    260260        do {
    261261            this->controllableEntity_ = this->previousControllableEntity_.back();
    262         } while(this->controllableEntity_ == NULL && this->previousControllableEntity_.size() > 0);
     262        } while(this->controllableEntity_ == nullptr && this->previousControllableEntity_.size() > 0);
    263263        this->controllableEntityID_ = this->controllableEntity_->getObjectID();
    264264        this->previousControllableEntity_.pop_back();
    265265
    266         if ( this->controllableEntity_ != NULL && this->controller_ != NULL)
     266        if ( this->controllableEntity_ != nullptr && this->controller_ != nullptr)
    267267            this->controller_->setControllableEntity(this->controllableEntity_);
    268268
    269269         // HACK-ish
    270         if(this->controllableEntity_ != NULL && this->isHumanPlayer())
     270        if(this->controllableEntity_ != nullptr && this->isHumanPlayer())
    271271            this->controllableEntity_->createHud();
    272272

  • code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.cc

    r10624 r10765  
    127127    {
    128128        if(!this->isTarget(pickup))
    129             return NULL;
     129            return nullptr;
    130130
    131131        if(pickup->isTarget(this)) // If the PickupCarrier itself is a target.
    132132            return this;
    133133
    134         PickupCarrier* target = NULL;
     134        PickupCarrier* target = nullptr;
    135135        // Go recursively through all children to check whether they are the target.
    136136        std::vector<PickupCarrier*>* children = this->getCarrierChildren();

  • code/branches/cpp11_v2/src/orxonox/interfaces/PickupCarrier.h

    r9667 r10765  
    5959        But this structure has to be established first.
    6060        - <b>getCarrierChildren()</b> To this end a PickupCarrier needs to implement getCarrierChildren() which returns a list of its direct PickupCarrier children. If you need an example, have a look at @ref orxonox::Pawn "Pawn" and @ref orxonox::Engine "Engine".
    61         - <b>getCarrierParent()</b> This is the method in the other direction. It returns the parent of this PickupCarrier, or NULL if the PickupCarrier is a root node in this hierarchy.
     61        - <b>getCarrierParent()</b> This is the method in the other direction. It returns the parent of this PickupCarrier, or nullptr if the PickupCarrier is a root node in this hierarchy.
    6262
    6363    @author

  • code/branches/cpp11_v2/src/orxonox/interfaces/Pickupable.cc

    r10624 r10765  
    5656        RegisterObject(Pickupable);
    5757
    58         this->carrier_ = NULL;
     58        this->carrier_ = nullptr;
    5959
    6060        this->beingDestroyed_ = false;
    … …  
    143143    bool Pickupable::isTarget(const PickupCarrier* carrier) const
    144144    {
    145         if(carrier == NULL)
     145        if(carrier == nullptr)
    146146            return false;
    147147
    … …  
    210210    bool Pickupable::pickup(PickupCarrier* carrier)
    211211    {
    212         if(carrier == NULL || this->isPickedUp()) // If carrier is NULL or the Pickupable is already picked up.
     212        if(carrier == nullptr || this->isPickedUp()) // If carrier is nullptr or the Pickupable is already picked up.
    213213            return false;
    214214
    … …  
    237237            return false;
    238238
    239         assert(this->getCarrier()); // The Carrier cannot be NULL at this point.
     239        assert(this->getCarrier()); // The Carrier cannot be nullptr at this point.
    240240        if(!this->getCarrier()->removePickup(this)) //TODO Shouldn't this be a little later?
    241241            orxout(internal_warning, context::pickups) << "Pickupable (&" << this << ", " << this->getIdentifier()->getName() << ") is being dropped, but it was not present in the PickupCarriers list of pickups." << endl;
    … …  
    249249            created = this->createSpawner();
    250250
    251         this->setCarrier(NULL);
     251        this->setCarrier(nullptr);
    252252
    253253        if(!created && createSpawner) // If a PickupSpawner should have been created but wasn't.
    … …  
    301301        orxout(verbose, context::pickups) << "Pickupable (&" << this << ") changed Carrier (& " << carrier << ")." << endl;
    302302
    303         if(carrier != NULL && tell)
     303        if(carrier != nullptr && tell)
    304304        {
    305305            if(!carrier->addPickup(this))

  • code/branches/cpp11_v2/src/orxonox/items/Engine.cc

    r9667 r10765  
    155155    void Engine::run(float dt)
    156156    {
    157         if (this->ship_ == NULL)
     157        if (this->ship_ == nullptr)
    158158        {
    159159            if (this->shipID_ != 0)
    … …  
    161161                this->networkcallback_shipID();
    162162
    163                 if (this->ship_ == NULL)
     163                if (this->ship_ == nullptr)
    164164                    return;
    165165            }

  • code/branches/cpp11_v2/src/orxonox/items/Engine.h

    r9667 r10765  
    6767            /**
    6868            @brief Get the SpaceShip this Engine is mounted on.
    69             @return Returns a pointer to the SpaceShip. NULL if it isn't mounted on any ship.
     69            @return Returns a pointer to the SpaceShip. nullptr if it isn't mounted on any ship.
    7070            */
    7171            inline SpaceShip* getShip() const

  • code/branches/cpp11_v2/src/orxonox/items/MultiStateEngine.cc

    r9939 r10765  
    205205    void MultiStateEngine::addEffectContainer(EffectContainer* effect)
    206206    {
    207         if (effect == NULL)
     207        if (effect == nullptr)
    208208            return;
    209209        effect->setLuaState(this->lua_, 'f' + multi_cast<std::string>(this->effectContainers_.size()));
    … …  
    224224                return (*it);
    225225        }
    226         return NULL;
     226        return nullptr;
    227227    }
    228228

  • code/branches/cpp11_v2/src/orxonox/items/ShipPart.cc

    r10624 r10765  
    5050
    5151    ShipPart::ShipPart(Context* context)
    52         : Item(context), parent_(NULL)
     52        : Item(context), parent_(nullptr)
    5353    {
    5454        RegisterObject(ShipPart);
    … …  
    122122    void ShipPart::addEntity(StaticEntity* entity)
    123123    {
    124         OrxAssert(entity != NULL, "The Entity cannot be NULL.");
     124        OrxAssert(entity != nullptr, "The Entity cannot be nullptr.");
    125125        this->entityList_.push_back(entity);
    126126    }
    … …  
    130130        Get the i-th StaticEntity of the ShipPart.
    131131    @return
    132         Returns a pointer to the i-the StaticEntity. NULL if there is no StaticEntity with that index.
     132        Returns a pointer to the i-the StaticEntity. nullptr if there is no StaticEntity with that index.
    133133    */
    134134    StaticEntity* ShipPart::getEntity(unsigned int index)
    135135    {
    136136        if(this->entityList_.size() >= index)
    137             return NULL;
     137            return nullptr;
    138138        else
    139139            return this->entityList_[index];
    … …  
    164164    void ShipPart::addDestructionEvent(PartDestructionEvent* event)
    165165    {
    166         OrxAssert(event != NULL, "The PartDestructionEvent cannot be NULL.");
     166        OrxAssert(event != nullptr, "The PartDestructionEvent cannot be nullptr.");
    167167        event->setParent(this);
    168168        this->eventList_.push_back(event);
    … …  
    173173        Get the i-th PartDestructionEvent of the ShipPart.
    174174    @return
    175         Returns a pointer to the i-the PartDestructionEvent. NULL if there is no PartDestructionEvent with that index.
     175        Returns a pointer to the i-the PartDestructionEvent. nullptr if there is no PartDestructionEvent with that index.
    176176    */
    177177    PartDestructionEvent* ShipPart::getDestructionEvent(unsigned int index)
    178178    {
    179179        if(this->eventList_.size() <= index)
    180             return NULL;
     180            return nullptr;
    181181        else
    182182            return this->eventList_[index];

  • code/branches/cpp11_v2/src/orxonox/sound/AmbientSound.cc

    r10624 r10765  
    9393            const std::string& path = "ambient/" + mood + '/' + this->ambientSource_;
    9494            shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(path);
    95             if (fileInfo != NULL)
     95            if (fileInfo != nullptr)
    9696            {
    9797                orxout(user_info) << "Loading ambient sound " << path << "..." << endl; // TODO: make this output internal if we implement sound streaming

  • code/branches/cpp11_v2/src/orxonox/sound/BaseSound.cc

    r10624 r10765  
    6666            this->stop();
    6767        // Release buffer
    68         if (this->soundBuffer_ != NULL)
     68        if (this->soundBuffer_ != nullptr)
    6969        {
    7070            assert(GameMode::playsSound());
    … …  
    8484    {
    8585        this->state_ = Playing;
    86         if (GameMode::playsSound() && this->getSourceState() != AL_PLAYING && this->soundBuffer_ != NULL)
     86        if (GameMode::playsSound() && this->getSourceState() != AL_PLAYING && this->soundBuffer_ != nullptr)
    8787        {
    8888            if (!alIsSource(this->audioSource_))
    … …  
    151151            orxout(internal_warning, context::sound) << "Setting source parameters to 0 failed: "
    152152                                                     << SoundManager::getALErrorString(error) << endl;
    153         assert(this->soundBuffer_ != NULL);
     153        assert(this->soundBuffer_ != nullptr);
    154154        alSourcei(this->audioSource_, AL_BUFFER, this->soundBuffer_->getBuffer());
    155155        if (ALuint error = alGetError())
    … …  
    209209        }
    210210
    211         if (this->soundBuffer_ != NULL)
     211        if (this->soundBuffer_ != nullptr)
    212212        {
    213213            if (this->soundBuffer_->getFilename() == source)
    … …  
    233233        // Get new sound buffer
    234234        this->soundBuffer_ = SoundManager::getInstance().getSoundBuffer(this->source_);
    235         if (this->soundBuffer_ == NULL)
     235        if (this->soundBuffer_ == nullptr)
    236236            return;
    237237

  • code/branches/cpp11_v2/src/orxonox/sound/SoundBuffer.cc

    r8858 r10765  
    4545    {
    4646        if (this->filename_.empty())
    47             ThrowException(General, "SoundBuffer construction: fileInfo was NULL");
     47            ThrowException(General, "SoundBuffer construction: fileInfo was nullptr");
    4848
    4949        // Get resource info
    5050        shared_ptr<ResourceInfo> fileInfo = Resource::getInfo(filename);
    51         if (fileInfo == NULL)
     51        if (fileInfo == nullptr)
    5252        {
    5353            orxout(internal_error, context::sound) << "Sound file '" << filename << "' not found" << endl;
    … …  
    138138        vorbisCallbacks.seek_func  = &seekVorbis;
    139139        vorbisCallbacks.tell_func  = &tellVorbis;
    140         vorbisCallbacks.close_func = NULL;
     140        vorbisCallbacks.close_func = nullptr;
    141141
    142142        OggVorbis_File vf;
    143         int ret = ov_open_callbacks(dataStream.get(), &vf, NULL, 0, vorbisCallbacks);
     143        int ret = ov_open_callbacks(dataStream.get(), &vf, nullptr, 0, vorbisCallbacks);
    144144        if (ret < 0)
    145145        {

  • code/branches/cpp11_v2/src/orxonox/sound/SoundManager.cc

    r10624 r10765  
    8383            ThrowException(InitialisationAborted, "Sound: Not loading at all");
    8484#if !defined(ORXONOX_PLATFORM_APPLE)
    85         if (!alutInitWithoutContext(NULL, NULL))
     85        if (!alutInitWithoutContext(nullptr, nullptr))
    8686            ThrowException(InitialisationFailed, "Sound Error: ALUT initialisation failed: " << alutGetErrorString(alutGetError()));
    8787        Loki::ScopeGuard alutExitGuard = Loki::MakeGuard(&alutExit);
    … …  
    9090/*
    9191        // Get list of available sound devices and display them
    92         const char* devices = alcGetString(NULL, ALC_DEVICE_SPECIFIER);
     92        const char* devices = alcGetString(nullptr, ALC_DEVICE_SPECIFIER);
    9393        char* device = new char[strlen(devices)+1];
    9494        strcpy(device, devices);
    … …  
    110110        this->device_ = alcOpenDevice(renderDevice.c_str());
    111111*/
    112         this->device_ = alcOpenDevice(NULL);
    113         if (this->device_ == NULL)
     112        this->device_ = alcOpenDevice(nullptr);
     113        if (this->device_ == nullptr)
    114114            ThrowException(InitialisationFailed, "Sound Error: Could not open sound device.");
    115115        Loki::ScopeGuard closeDeviceGuard = Loki::MakeGuard(&alcCloseDevice, this->device_);
    116116
    117117        // Create sound context and make it the currently used one
    118         this->context_ = alcCreateContext(this->device_, NULL);
    119         if (this->context_ == NULL)
     118        this->context_ = alcCreateContext(this->device_, nullptr);
     119        if (this->context_ == nullptr)
    120120            ThrowException(InitialisationFailed, "Sound Error: Could not create ALC context");
    121121        Loki::ScopeGuard desroyContextGuard = Loki::MakeGuard(&alcDestroyContext, this->context_);
    … …  
    189189
    190190        // Relieve context to destroy it
    191         if (!alcMakeContextCurrent(NULL))
     191        if (!alcMakeContextCurrent(nullptr))
    192192            orxout(internal_error, context::sound) << "Could not unset ALC context" << endl;
    193193        alcDestroyContext(this->context_);
    … …  
    350350    void SoundManager::registerAmbientSound(AmbientSound* newAmbient)
    351351    {
    352         if (newAmbient != NULL && !this->bDestructorCalled_)
     352        if (newAmbient != nullptr && !this->bDestructorCalled_)
    353353        {
    354354            for (AmbientList::const_iterator it = this->ambientSounds_.begin(); it != this->ambientSounds_.end(); ++it)
    … …  
    373373    void SoundManager::unregisterAmbientSound(AmbientSound* oldAmbient)
    374374    {
    375         if (oldAmbient == NULL || ambientSounds_.empty() || this->bDestructorCalled_)
     375        if (oldAmbient == nullptr || ambientSounds_.empty() || this->bDestructorCalled_)
    376376            return;
    377377
    … …  
    405405    void SoundManager::pauseAmbientSound(AmbientSound* ambient)
    406406    {
    407         if (ambient != NULL)
     407        if (ambient != nullptr)
    408408        {
    409409            for (AmbientList::iterator it = this->ambientSounds_.begin(); it != this->ambientSounds_.end(); ++it)

  • code/branches/cpp11_v2/src/orxonox/sound/SoundStreamer.cc

    r8858 r10765  
    4545        vorbisCallbacks.seek_func  = &seekVorbis;
    4646        vorbisCallbacks.tell_func  = &tellVorbis;
    47         vorbisCallbacks.close_func = NULL;
     47        vorbisCallbacks.close_func = nullptr;
    4848
    4949        OggVorbis_File vf;
    50         int ret = ov_open_callbacks(dataStream.get(), &vf, NULL, 0, vorbisCallbacks);
     50        int ret = ov_open_callbacks(dataStream.get(), &vf, nullptr, 0, vorbisCallbacks);
    5151        if (ret < 0)
    5252        {

  • code/branches/cpp11_v2/src/orxonox/worldentities/ControllableEntity.cc

    r10624 r10765  
    6262        this->client_overwrite_ = 0;
    6363        this->player_ = 0;
    64         this->formerPlayer_ = NULL;
     64        this->formerPlayer_ = nullptr;
    6565        this->playerID_ = OBJECTID_UNKNOWN;
    6666        this->hud_ = 0;
    … …  
    194194    bool ControllableEntity::setCameraPosition(unsigned int index)
    195195    {
    196         if(this->camera_ != NULL && this->cameraPositions_.size() > 0)
     196        if(this->camera_ != nullptr && this->cameraPositions_.size() > 0)
    197197        {
    198198            if(index >= this->cameraPositions_.size())
    … …  
    350350        this->bHasLocalController_ = player->isLocalPlayer();
    351351        this->bHasHumanController_ = player->isHumanPlayer();
    352         if(controller_ != NULL)
     352        if(controller_ != nullptr)
    353353            this->team_ = controller_->getTeam(); // forward controller team number
    354354
    … …  
    434434    void ControllableEntity::destroyHud(void)
    435435    {
    436         if (this->hud_ != NULL)
     436        if (this->hud_ != nullptr)
    437437        {
    438438            this->hud_->destroy();
    439             this->hud_ = NULL;
     439            this->hud_ = nullptr;
    440440        }
    441441    }

  • code/branches/cpp11_v2/src/orxonox/worldentities/EffectContainer.cc

    r9667 r10765  
    4444    EffectContainer::EffectContainer(Context* context)
    4545        : BaseObject(context)
    46         , lua_(NULL)
     46        , lua_(nullptr)
    4747    {
    4848        RegisterObject(EffectContainer);
    … …  
    9292            if (i == index)
    9393                return (*it);
    94         return NULL;
     94        return nullptr;
    9595    }
    9696

  • code/branches/cpp11_v2/src/orxonox/worldentities/WorldEntity.cc

    r10624 r10765  
    563563    void WorldEntity::detachOgreObject(Ogre::MovableObject* object)
    564564    {
    565         object->setUserAny(Ogre::Any(static_cast<OrxonoxClass*>(NULL)));
     565        object->setUserAny(Ogre::Any(static_cast<OrxonoxClass*>(nullptr)));
    566566        this->node_->detachObject(object);
    567567    }
    … …  
    660660    {
    661661        // If physics is enabled scale the attached CollisionShape.
    662         /*if (this->hasPhysics() && this->collisionShape_ != NULL)
     662        /*if (this->hasPhysics() && this->collisionShape_ != nullptr)
    663663        {
    664664            this->collisionShape_->setScale3D(scale);

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.cc

    r10624 r10765  
    9494        for (unsigned int i=0; i < this->getAttachedObjects().size(); i++)
    9595        {
    96             if (this->getAttachedObject(i) == NULL)
     96            if (this->getAttachedObject(i) == nullptr)
    9797            {
    9898                break;
    … …  
    151151                return it->second;
    152152        }
    153         return NULL;
     153        return nullptr;
    154154    }
    155155
    … …  
    160160    void ModularSpaceShip::damage(float damage, float healthdamage, float shielddamage, Pawn* originator, const btCollisionShape* cs)
    161161    {
    162         if (cs != NULL && this->getPartOfEntity((StaticEntity*)(cs->getUserPointer())) != NULL)
     162        if (cs != nullptr && this->getPartOfEntity((StaticEntity*)(cs->getUserPointer())) != nullptr)
    163163            this->getPartOfEntity((StaticEntity*)(cs->getUserPointer()))->handleHit(damage, healthdamage, shielddamage, originator);
    164164        else
    … …  
    212212    void ModularSpaceShip::addShipPart(ShipPart* part)
    213213    {
    214         OrxAssert(part != NULL, "The ShipPart cannot be NULL.");
     214        OrxAssert(part != nullptr, "The ShipPart cannot be nullptr.");
    215215        this->partList_.push_back(part);
    216216        part->setParent(this);
    … …  
    222222        Get the i-th ShipPart of the SpaceShip.
    223223    @return
    224         Returns a pointer to the i-the ShipPart. NULL if there is no ShipPart with that index.
     224        Returns a pointer to the i-the ShipPart. nullptr if there is no ShipPart with that index.
    225225    */
    226226    ShipPart* ModularSpaceShip::getShipPart(unsigned int index)
    227227    {
    228228        if(this->partList_.size() <= index)
    229             return NULL;
     229            return nullptr;
    230230        else
    231231            return this->partList_[index];
    … …  
    238238        The name of the ShipPart to be returned.
    239239    @return
    240         Pointer to the ShipPart with the given name, or NULL if not found.
     240        Pointer to the ShipPart with the given name, or nullptr if not found.
    241241    */
    242242    ShipPart* ModularSpaceShip::getShipPartByName(std::string name)
    … …  
    250250        }
    251251        orxout(internal_warning) << "Couldn't find ShipPart with name \"" << name << "\"." << endl;
    252         return NULL;
     252        return nullptr;
    253253    }
    254254

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/ModularSpaceShip.h

    r10262 r10765  
    109109            ShipPart* getPartOfEntity(StaticEntity* entity) const;
    110110
    111             virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
     111            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = nullptr, const btCollisionShape* cs = nullptr);
    112112
    113113            static void killShipPartStatic(std::string name);

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/Pawn.h

    r10437 r10765  
    208208
    209209            //virtual void damage(float damage, Pawn* originator = 0);
    210             virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = NULL, const btCollisionShape* cs = NULL);
     210            virtual void damage(float damage, float healthdamage = 0.0f, float shielddamage = 0.0f, Pawn* originator = nullptr, const btCollisionShape* cs = nullptr);
    211211
    212212            bool bAlive_;
    … …  
    215215                { return new std::vector<PickupCarrier*>(); }
    216216            virtual PickupCarrier* getCarrierParent(void) const
    217                 { return NULL; }
     217                { return nullptr; }
    218218
    219219

  • code/branches/cpp11_v2/src/orxonox/worldentities/pawns/SpaceShip.cc

    r10216 r10765  
    4848    RegisterClass(SpaceShip);
    4949
    50     SpaceShip::SpaceShip(Context* context) : Pawn(context), boostBlur_(NULL)
     50    SpaceShip::SpaceShip(Context* context) : Pawn(context), boostBlur_(nullptr)
    5151    {
    5252        RegisterObject(SpaceShip);
    … …  
    196196            if(this->bEnableMotionBlur_)
    197197            {
    198                 if (this->boostBlur_ == NULL && this->hasLocalController() && this->hasHumanController())
     198                if (this->boostBlur_ == nullptr && this->hasLocalController() && this->hasHumanController())
    199199                {
    200200                    this->boostBlur_ = new Shader(this->getScene()->getSceneManager());
    … …  
    305305    void SpaceShip::addEngine(orxonox::Engine* engine)
    306306    {
    307         OrxAssert(engine != NULL, "The engine cannot be NULL.");
     307        OrxAssert(engine != nullptr, "The engine cannot be nullptr.");
    308308        this->engineList_.push_back(engine);
    309309        engine->addToSpaceShip(this);
    … …  
    330330        Get the i-th Engine of the SpaceShip.
    331331    @return
    332         Returns a pointer to the i-the Engine. NULL if there is no Engine with that index.
     332        Returns a pointer to the i-the Engine. nullptr if there is no Engine with that index.
    333333    */
    334334    Engine* SpaceShip::getEngine(unsigned int i)
    335335    {
    336336        if(this->engineList_.size() >= i)
    337             return NULL;
     337            return nullptr;
    338338        else
    339339            return this->engineList_[i];
    … …  
    346346        The name of the engine to be returned.
    347347    @return
    348         Pointer to the engine with the given name, or NULL if not found.
     348        Pointer to the engine with the given name, or nullptr if not found.
    349349    */
    350350    Engine* SpaceShip::getEngineByName(const std::string& name)
    … …  
    355355
    356356        orxout(internal_warning) << "Couldn't find Engine with name \"" << name << "\"." << endl;
    357         return NULL;
     357        return nullptr;
    358358    }
    359359
    … …  
    465465    void SpaceShip::changedEnableMotionBlur()
    466466    {
    467         if (!this->bEnableMotionBlur_ && this->boostBlur_ != NULL)
     467        if (!this->bEnableMotionBlur_ && this->boostBlur_ != nullptr)
    468468        {
    469469            delete this->boostBlur_;
    470             this->boostBlur_ = NULL;
     470            this->boostBlur_ = nullptr;
    471471        }
    472472    }
    … …  
    510510    {
    511511        Camera* camera = CameraManager::getInstance().getActiveCamera();
    512         if(camera != NULL)
     512        if(camera != nullptr)
    513513        {
    514514            this->cameraOriginalPosition_ = camera->getPosition();

  • code/branches/cpp11_v2/test/core/class/IdentifiableTest.cc

    r10624 r10765  
    3737    {
    3838        IdentifiableClass* test = new IdentifiableClass();
    39         ASSERT_TRUE(test != NULL);
     39        ASSERT_TRUE(test != nullptr);
    4040        delete test;
    4141    }

  • code/branches/cpp11_v2/test/core/class/IdentifierClassHierarchyTest.cc

    r10624 r10765  
    144144                    new IdentifierManager();
    145145                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    146                     Context::setRootContext(new Context(NULL));
     146                    Context::setRootContext(new Context(nullptr));
    147147                    Identifier::initConfigValues_s = false; // TODO: hack!
    148148                    IdentifierManager::getInstance().createClassHierarchy();

  • code/branches/cpp11_v2/test/core/class/IdentifierExternalClassHierarchyTest.cc

    r10624 r10765  
    5151                    new IdentifierManager();
    5252                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    53                     Context::setRootContext(new Context(NULL));
     53                    Context::setRootContext(new Context(nullptr));
    5454                    Identifier::initConfigValues_s = false; // TODO: hack!
    5555                    IdentifierManager::getInstance().createClassHierarchy();

  • code/branches/cpp11_v2/test/core/class/IdentifierNestedClassHierarchyTest.cc

    r10624 r10765  
    111111                    new IdentifierManager();
    112112                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    113                     Context::setRootContext(new Context(NULL));
     113                    Context::setRootContext(new Context(nullptr));
    114114                    Identifier::initConfigValues_s = false; // TODO: hack!
    115115                    IdentifierManager::getInstance().createClassHierarchy();

  • code/branches/cpp11_v2/test/core/class/IdentifierSimpleClassHierarchyTest.cc

    r10624 r10765  
    5353                    new IdentifierManager();
    5454                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    55                     Context::setRootContext(new Context(NULL));
     55                    Context::setRootContext(new Context(nullptr));
    5656                    Identifier::initConfigValues_s = false; // TODO: hack!
    5757                    IdentifierManager::getInstance().createClassHierarchy();

  • code/branches/cpp11_v2/test/core/class/IdentifierTest.cc

    r10624 r10765  
    4646
    4747        Identifier* identifier = Class(TestClass);
    48         EXPECT_TRUE(identifier != NULL);
     48        EXPECT_TRUE(identifier != nullptr);
    4949    }
    5050
    … …  
    5454
    5555        Identifier* identifier = Class(TestSubclass);
    56         EXPECT_TRUE(identifier != NULL);
     56        EXPECT_TRUE(identifier != nullptr);
    5757    }
    5858

  • code/branches/cpp11_v2/test/core/class/OrxonoxClassTest.cc

    r10624 r10765  
    1919                {
    2020                    new IdentifierManager();
    21                     Context::setRootContext(new Context(NULL));
     21                    Context::setRootContext(new Context(nullptr));
    2222                }
    2323
    … …  
    3333    {
    3434        TestClass* test = new TestClass();
    35         ASSERT_TRUE(test != NULL);
     35        ASSERT_TRUE(test != nullptr);
    3636        delete test;
    3737    }

  • code/branches/cpp11_v2/test/core/class/OrxonoxInterfaceTest.cc

    r10624 r10765  
    3434                {
    3535                    new IdentifierManager();
    36                     Context::setRootContext(new Context(NULL));
     36                    Context::setRootContext(new Context(nullptr));
    3737                }
    3838
    … …  
    4848    {
    4949        TestClass1* test = new TestClass1();
    50         ASSERT_TRUE(test != NULL);
     50        ASSERT_TRUE(test != nullptr);
    5151        delete test;
    5252    }
    … …  
    5555    {
    5656        TestClass2* test = new TestClass2();
    57         ASSERT_TRUE(test != NULL);
     57        ASSERT_TRUE(test != nullptr);
    5858        delete test;
    5959    }

  • code/branches/cpp11_v2/test/core/class/SubclassIdentifierTest.cc

    r10624 r10765  
    1313        {
    1414            public:
    15                 TestClass(Context* context = NULL) { RegisterObject(TestClass); }
     15                TestClass(Context* context = nullptr) { RegisterObject(TestClass); }
    1616        };
    1717
    … …  
    1919        {
    2020            public:
    21                 TestSubclass(Context* context = NULL) { RegisterObject(TestSubclass); }
     21                TestSubclass(Context* context = nullptr) { RegisterObject(TestSubclass); }
    2222        };
    2323
    … …  
    3333                    new IdentifierManager();
    3434                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    35                     Context::setRootContext(new Context(NULL));
     35                    Context::setRootContext(new Context(nullptr));
    3636                    Identifier::initConfigValues_s = false; // TODO: hack!
    3737                    IdentifierManager::getInstance().createClassHierarchy();
    … …  
    7777        subclassIdentifier = Class(TestSubclass);
    7878
    79         TestClass* instance = subclassIdentifier.fabricate(NULL);
    80         ASSERT_TRUE(instance != NULL);
     79        TestClass* instance = subclassIdentifier.fabricate(nullptr);
     80        ASSERT_TRUE(instance != nullptr);
    8181        EXPECT_EQ(Class(TestSubclass), instance->getIdentifier());
    8282        delete instance;

  • code/branches/cpp11_v2/test/core/class/SuperTest.cc

    r10624 r10765  
    1414        {
    1515            public:
    16                 TestClass(Context* context = NULL) : BaseObject(context), changedNameBase_(false), xmlPortBase_(false), modeBase_(XMLPort::NOP)
     16                TestClass(Context* context = nullptr) : BaseObject(context), changedNameBase_(false), xmlPortBase_(false), modeBase_(XMLPort::NOP)
    1717                {
    1818                    RegisterObject(TestClass);
    … …  
    3838        {
    3939            public:
    40                 TestSubclass(Context* context = NULL) : TestClass(context), changedNameSubclass_(false), xmlPortSubclass_(false), modeSubclass_(XMLPort::NOP)
     40                TestSubclass(Context* context = nullptr) : TestClass(context), changedNameSubclass_(false), xmlPortSubclass_(false), modeSubclass_(XMLPort::NOP)
    4141                {
    4242                    RegisterObject(TestSubclass);
    … …  
    7474                    new IdentifierManager();
    7575                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    76                     Context::setRootContext(new Context(NULL));
     76                    Context::setRootContext(new Context(nullptr));
    7777                    Identifier::initConfigValues_s = false; // TODO: hack!
    7878                    IdentifierManager::getInstance().createClassHierarchy();
    … …  
    132132        EXPECT_EQ(XMLPort::NOP, test.modeSubclass_);
    133133
    134         Element* element = NULL;
     134        Element* element = nullptr;
    135135        test.XMLPort(*element, XMLPort::SaveObject);
    136136

  • code/branches/cpp11_v2/test/core/command/CommandTest.cc

    r10624 r10765  
    143143                    new ConsoleCommandManager();
    144144                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::CONSOLE_COMMAND);
    145                     Context::setRootContext(new Context(NULL));
     145                    Context::setRootContext(new Context(nullptr));
    146146                    Identifier::initConfigValues_s = false; // TODO: hack!
    147147                    IdentifierManager::getInstance().createClassHierarchy();

  • code/branches/cpp11_v2/test/core/object/ClassFactoryTest.cc

    r10624 r10765  
    1818                    new IdentifierManager();
    1919                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    20                     Context::setRootContext(new Context(NULL));
     20                    Context::setRootContext(new Context(nullptr));
    2121                }
    2222
    … …  
    3333    {
    3434        Factory* factory = new ClassFactoryWithContext<BaseObject>();
    35         Identifiable* object = factory->fabricate(NULL);
    36         ASSERT_TRUE(object != NULL);
     35        Identifiable* object = factory->fabricate(nullptr);
     36        ASSERT_TRUE(object != nullptr);
    3737        BaseObject* baseObject = dynamic_cast<BaseObject*>(object);
    38         EXPECT_TRUE(baseObject != NULL);
     38        EXPECT_TRUE(baseObject != nullptr);
    3939        delete object;
    4040        // don't delete factory - it remains in the identifier

  • code/branches/cpp11_v2/test/core/object/ContextTest.cc

    r10624 r10765  
    1212        {
    1313            public:
    14                 SubclassContext() : Context(NULL) { RegisterObject(SubclassContext); }
     14                SubclassContext() : Context(nullptr) { RegisterObject(SubclassContext); }
    1515        };
    1616
    … …  
    2525                    new IdentifierManager();
    2626                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    27                     Context::setRootContext(new Context(NULL));
     27                    Context::setRootContext(new Context(nullptr));
    2828                }
    2929
    … …  
    3939    TEST_F(ContextTest, CanCreateContext)
    4040    {
    41         Context context(NULL);
     41        Context context(nullptr);
    4242    }
    4343
    … …  
    4949    TEST_F(ContextTest, ContextIsItsOwnContext)
    5050    {
    51         Context context(NULL);
     51        Context context(nullptr);
    5252        EXPECT_EQ(&context, context.getContext());
    5353    }
    … …  
    6868    TEST_F(ContextTest, ContextIsAddedToItsOwnObjectList)
    6969    {
    70         Context context(NULL);
     70        Context context(nullptr);
    7171        ASSERT_EQ(1u, context.getObjectList<Context>()->size());
    7272        EXPECT_TRUE(context.getObjectList<Context>()->begin()->objectBase_ == static_cast<Listable*>(&context));
    … …  
    7575    TEST_F(ContextTest, ContextIsAddedToObjectListOfBaseContext)
    7676    {
    77         Context baseContext(NULL);
     77        Context baseContext(nullptr);
    7878        Context subContext(&baseContext);
    7979

  • code/branches/cpp11_v2/test/core/object/DestroyableTest.cc

    r9603 r10765  
    3232        DestroyableTest* test = new DestroyableTest(destroyed);
    3333        EXPECT_FALSE(destroyed);
    34         EXPECT_TRUE(test != NULL);
     34        EXPECT_TRUE(test != nullptr);
    3535        test->destroy();
    3636        EXPECT_TRUE(destroyed);

  • code/branches/cpp11_v2/test/core/object/IteratorTest.cc

    r10736 r10765  
    3636                    new IdentifierManager();
    3737                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    38                     Context::setRootContext(new Context(NULL));
     38                    Context::setRootContext(new Context(nullptr));
    3939                }
    4040
    … …  
    120120            ++i;
    121121            if (i == 1u) EXPECT_EQ(&testClass, *it);
    122             if (i == 2u) EXPECT_EQ(NULL, *it);
     122            if (i == 2u) EXPECT_EQ(nullptr, *it);
    123123        }
    124124        EXPECT_EQ(2u, i);

  • code/branches/cpp11_v2/test/core/object/ListableTest.cc

    r10624 r10765  
    4141                    new IdentifierManager();
    4242                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    43                     Context::setRootContext(new Context(NULL));
     43                    Context::setRootContext(new Context(nullptr));
    4444                }
    4545
    … …  
    5656    {
    5757        ListableClassTest* test = new ListableClassTest();
    58         ASSERT_TRUE(test != NULL);
     58        ASSERT_TRUE(test != nullptr);
    5959        delete test;
    6060    }
    … …  
    104104    TEST_F(ListableTest, CanAddObjectToContext)
    105105    {
    106         Context context(NULL);
     106        Context context(nullptr);
    107107        ListableSubclassTest test;
    108108
    … …  
    118118    TEST_F(ListableTest, CanAddObjectToSubContext)
    119119    {
    120         Context baseContext(NULL);
     120        Context baseContext(nullptr);
    121121        Context subContext(&baseContext);
    122122        ListableSubclassTest test;
    … …  
    139139    {
    140140        Context* rootContext = Context::getRootContext();
    141         Context newContext(NULL);
     141        Context newContext(nullptr);
    142142        ListableSubclassTest test;
    143143

  • code/branches/cpp11_v2/test/core/object/ObjectListBaseTest.cc

    r9661 r10765  
    2424    {
    2525        ObjectListBase list;
    26         ObjectListBaseElement* element = new ObjectListElement<Listable>(NULL);
     26        ObjectListBaseElement* element = new ObjectListElement<Listable>(nullptr);
    2727        list.addElement(element);
    2828        EXPECT_EQ(1u, list.size());
    … …  
    3232    {
    3333        ObjectListBase list;
    34         ObjectListBaseElement* element = new ObjectListElement<Listable>(NULL);
     34        ObjectListBaseElement* element = new ObjectListElement<Listable>(nullptr);
    3535        list.addElement(element);
    3636        EXPECT_EQ(1u, list.size());
    … …  
    4343    {
    4444        ObjectListBase list;
    45         list.addElement(new ObjectListElement<Listable>(NULL));
     45        list.addElement(new ObjectListElement<Listable>(nullptr));
    4646        EXPECT_EQ(1u, list.size());
    4747    }
    … …  
    5252        EXPECT_EQ(0u, list.size());
    5353        {
    54             ObjectListElement<Listable> element1(NULL);
     54            ObjectListElement<Listable> element1(nullptr);
    5555            list.addElement(&element1);
    5656            EXPECT_EQ(1u, list.size());
    5757            {
    58                 ObjectListElement<Listable> element1(NULL);
     58                ObjectListElement<Listable> element1(nullptr);
    5959                list.addElement(&element1);
    6060                EXPECT_EQ(2u, list.size());
    6161                {
    62                     ObjectListElement<Listable> element1(NULL);
     62                    ObjectListElement<Listable> element1(nullptr);
    6363                    list.addElement(&element1);
    6464                    EXPECT_EQ(3u, list.size());
    … …  
    7676        ObjectListElementRemovalListenerMock listener;
    7777        list.registerRemovalListener(&listener);
    78         ObjectListBaseElement* element = new ObjectListElement<Listable>(NULL);
     78        ObjectListBaseElement* element = new ObjectListElement<Listable>(nullptr);
    7979        list.addElement(element);
    8080        EXPECT_CALL(listener, removedElement(element));

  • code/branches/cpp11_v2/test/core/object/ObjectListIteratorTest.cc

    r10736 r10765  
    3636                    new IdentifierManager();
    3737                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    38                     Context::setRootContext(new Context(NULL));
     38                    Context::setRootContext(new Context(nullptr));
    3939                }
    4040

  • code/branches/cpp11_v2/test/core/object/ObjectListTest.cc

    r10736 r10765  
    2828                    new IdentifierManager();
    2929                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    30                     Context::setRootContext(new Context(NULL));
     30                    Context::setRootContext(new Context(nullptr));
    3131                }
    3232

  • code/branches/cpp11_v2/test/core/object/StrongPtrTest.cc

    r10744 r10765  
    111111    void isNull(const StrongPtr<DestroyableTest> strongPtr)
    112112    {
    113         EXPECT_TRUE(strongPtr == NULL);
     113        EXPECT_TRUE(strongPtr == nullptr);
    114114        EXPECT_TRUE(strongPtr == 0);
    115115        EXPECT_TRUE(!strongPtr);
    116         EXPECT_FALSE(strongPtr != NULL);
     116        EXPECT_FALSE(strongPtr != nullptr);
    117117        EXPECT_FALSE(strongPtr != 0);
    118118        EXPECT_FALSE(strongPtr);
    … …  
    126126        }
    127127        {
    128             StrongPtr<DestroyableTest> strongPtr = NULL;
     128            StrongPtr<DestroyableTest> strongPtr = nullptr;
    129129            isNull(strongPtr);
    130130        }
    131131        {
    132132            StrongPtr<DestroyableTest> strongPtr;
    133             strongPtr = NULL;
     133            strongPtr = nullptr;
    134134            isNull(strongPtr);
    135135        }
    … …  
    150150        DestroyableTest* test = new DestroyableTest(destroyed);
    151151        StrongPtr<DestroyableTest> strongPtr = test;
    152         EXPECT_FALSE(strongPtr == NULL);
     152        EXPECT_FALSE(strongPtr == nullptr);
    153153        EXPECT_FALSE(strongPtr == 0);
    154154        EXPECT_FALSE(!strongPtr);
    155         EXPECT_TRUE(strongPtr != NULL);
     155        EXPECT_TRUE(strongPtr != nullptr);
    156156        EXPECT_TRUE(strongPtr != 0);
    157157        EXPECT_TRUE(strongPtr);
    … …  
    166166        // default
    167167        StrongPtr<DestroyableTest> strongPtr1;
    168         EXPECT_EQ(NULL, strongPtr1.get());
     168        EXPECT_EQ(nullptr, strongPtr1.get());
    169169
    170170        // pointer
    … …  
    277277        EXPECT_EQ(1u, test->getReferenceCount());
    278278        strongPtr.reset();
    279         EXPECT_EQ(NULL, strongPtr.get());
     279        EXPECT_EQ(nullptr, strongPtr.get());
    280280        EXPECT_EQ(0u, test->getReferenceCount());
    281281

  • code/branches/cpp11_v2/test/core/object/WeakPtrTest.cc

    r10744 r10765  
    3636        EXPECT_EQ(test, weakPtr.get());
    3737        test->destroy();
    38         EXPECT_EQ(NULL, weakPtr.get());
     38        EXPECT_EQ(nullptr, weakPtr.get());
    3939    }
    4040
    … …  
    4949        EXPECT_EQ(test, weakPtr3.get());
    5050        test->destroy();
    51         EXPECT_EQ(NULL, weakPtr1.get());
    52         EXPECT_EQ(NULL, weakPtr2.get());
    53         EXPECT_EQ(NULL, weakPtr3.get());
     51        EXPECT_EQ(nullptr, weakPtr1.get());
     52        EXPECT_EQ(nullptr, weakPtr2.get());
     53        EXPECT_EQ(nullptr, weakPtr3.get());
    5454    }
    5555
    … …  
    6666    void isNull(const WeakPtr<DestroyableTest> weakPtr)
    6767    {
    68         EXPECT_TRUE(weakPtr == NULL);
     68        EXPECT_TRUE(weakPtr == nullptr);
    6969        EXPECT_TRUE(weakPtr == 0);
    7070        EXPECT_TRUE(!weakPtr);
    71         EXPECT_FALSE(weakPtr != NULL);
     71        EXPECT_FALSE(weakPtr != nullptr);
    7272        EXPECT_FALSE(weakPtr != 0);
    7373        EXPECT_FALSE(weakPtr);
    … …  
    8181        }
    8282        {
    83             WeakPtr<DestroyableTest> weakPtr = NULL;
     83            WeakPtr<DestroyableTest> weakPtr = nullptr;
    8484            isNull(weakPtr);
    8585        }
    8686        {
    8787            WeakPtr<DestroyableTest> weakPtr;
    88             weakPtr = NULL;
     88            weakPtr = nullptr;
    8989            isNull(weakPtr);
    9090        }
    … …  
    104104        DestroyableTest* test = new DestroyableTest();
    105105        WeakPtr<DestroyableTest> weakPtr = test;
    106         EXPECT_FALSE(weakPtr == NULL);
     106        EXPECT_FALSE(weakPtr == nullptr);
    107107        EXPECT_FALSE(weakPtr == 0);
    108108        EXPECT_FALSE(!weakPtr);
    109         EXPECT_TRUE(weakPtr != NULL);
     109        EXPECT_TRUE(weakPtr != nullptr);
    110110        EXPECT_TRUE(weakPtr != 0);
    111111        EXPECT_TRUE(weakPtr);
    … …  
    119119        // default
    120120        WeakPtr<DestroyableTest> weakPtr1;
    121         EXPECT_EQ(NULL, weakPtr1.get());
     121        EXPECT_EQ(nullptr, weakPtr1.get());
    122122
    123123        // pointer
    … …  
    191191        test->destroy();
    192192
    193         EXPECT_EQ(NULL, vector[0].get());
    194         EXPECT_EQ(NULL, vector[1].get());
    195         EXPECT_EQ(NULL, vector[2].get());
     193        EXPECT_EQ(nullptr, vector[0].get());
     194        EXPECT_EQ(nullptr, vector[1].get());
     195        EXPECT_EQ(nullptr, vector[2].get());
    196196    }
    197197
    … …  
    202202        EXPECT_EQ(test, weakPtr.get());
    203203        weakPtr.reset();
    204         EXPECT_EQ(NULL, weakPtr.get());
     204        EXPECT_EQ(nullptr, weakPtr.get());
    205205
    206206        test->destroy();

  • code/branches/cpp11_v2/test/core/singleton/ScopeTest.cc

    r10544 r10765  
    3232                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::IDENTIFIER);
    3333                    ModuleInstance::getCurrentModuleInstance()->loadAllStaticallyInitializedInstances(StaticInitialization::SCOPED_SINGLETON_WRAPPER);
    34                     Context::setRootContext(new Context(NULL));
     34                    Context::setRootContext(new Context(nullptr));
    3535                }
    3636

  • code/branches/cpp11_v2/test/util/SharedPtrTest.cc

    r10744 r10765  
    192192        // default
    193193        SharedPtr<TestChildClass> sharedPtr1;
    194         EXPECT_EQ(NULL, sharedPtr1.get());
     194        EXPECT_EQ(nullptr, sharedPtr1.get());
    195195
    196196        // pointer
    … …  
    221221        // default
    222222        SharedPtr<TestChildClass> sharedPtr1;
    223         EXPECT_EQ(NULL, sharedPtr1.get());
     223        EXPECT_EQ(nullptr, sharedPtr1.get());
    224224
    225225        // pointer

  • code/branches/cpp11_v2/test/util/SingletonTest.cc

    r9114 r10765  
    2323        };
    2424
    25         TestSingleton* TestSingleton::singletonPtr_s = NULL;
     25        TestSingleton* TestSingleton::singletonPtr_s = nullptr;
    2626        const size_t TestSingleton::MAGIC_VALUE = 0xCAFEBABE;
    2727    }

  • code/branches/cpp11_v2/test/util/output/ConsoleWriterTest.cc

    r10712 r10765  
    2727    TEST_F(ConsoleWriterTest, Disable)
    2828    {
    29         std::ostream stream(NULL);
     29        std::ostream stream(nullptr);
    3030        EXPECT_EQ(0U, OutputManager::getInstance().getListeners().size());
    3131        ConsoleWriter writer(stream);
    … …  
    3737    TEST_F(ConsoleWriterTest, Enable)
    3838    {
    39         std::ostream stream(NULL);
     39        std::ostream stream(nullptr);
    4040        ConsoleWriter writer(stream);
    4141        writer.disable();

  • code/branches/cpp11_v2/test/util/output/OutputManagerTest.cc

    r10624 r10765  
    5454    TEST(OutputManagerTest, GetInstanceDoesNotCreateDefaultListeners)
    5555    {
    56         EXPECT_TRUE(NULL == OutputManager::getInstance().getMemoryWriter());
    57         EXPECT_TRUE(NULL == OutputManager::getInstance().getConsoleWriter());
    58         EXPECT_TRUE(NULL == OutputManager::getInstance().getLogWriter());
     56        EXPECT_TRUE(nullptr == OutputManager::getInstance().getMemoryWriter());
     57        EXPECT_TRUE(nullptr == OutputManager::getInstance().getConsoleWriter());
     58        EXPECT_TRUE(nullptr == OutputManager::getInstance().getLogWriter());
    5959    }
    6060
    … …  
    6262    TEST(OutputManagerTest, GetInstanceAndCreateListenersCreatesDefaultListeners)
    6363    {
    64         EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
    65         EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
    66         EXPECT_TRUE(NULL != OutputManager::getInstanceAndCreateListeners().getLogWriter());
     64        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getMemoryWriter());
     65        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getConsoleWriter());
     66        EXPECT_TRUE(nullptr != OutputManager::getInstanceAndCreateListeners().getLogWriter());
    6767    }
    6868
Note: See TracChangeset for help on using the changeset viewer.