Changeset 30 for nrEngine


Ignore:
Timestamp:
04/09/2007 08:12:36 PM (12 years ago)
Author:
art
Message:

::std wurde durch std ueberall ersetzt!

Location:
nrEngine
Files:
1 deleted
25 edited

Legend:

Unmodified
Added
Removed
  • nrEngine/include/Clock.h

    r25 r30  
    184184                *                       - CLOCK_OBSERVER_ALREADY_ADDED if such is already added 
    185185                **/ 
    186                 Result  addObserver(const ::std::string& obsName, SharedPtr<ITimeObserver> timeObserver); 
     186                Result  addObserver(const std::string& obsName, SharedPtr<ITimeObserver> timeObserver); 
    187187         
    188188                /** 
     
    192192                *                       - CLOCK_OBSERVER_NOT_FOUND if such an observer not exists 
    193193                **/ 
    194                 Result  removeObserver(const ::std::string& obsName); 
     194                Result  removeObserver(const std::string& obsName); 
    195195                 
    196196                /** 
     
    259259 
    260260                // observers 
    261                 typedef ::std::vector< SharedPtr<ITimeObserver> > ObserverList; 
    262                 ::std::map < ::std::string, int32>      observerIDList; 
     261                typedef std::vector< SharedPtr<ITimeObserver> > ObserverList; 
     262                std::map < std::string, int32>  observerIDList; 
    263263                ObserverList                            observers; 
    264264                 
    265265                // frame filtering 
    266                 ::std::deque<float64>   frameDurationHistory; 
     266                std::deque<float64>     frameDurationHistory; 
    267267                float64                 frameDefaultTime; 
    268268                int32                   frameFilteringWindow; 
  • nrEngine/include/Exception.h

    r1 r30  
    6464                        * \param source Where was exception thrown (function name) 
    6565                        */ 
    66                         Exception( Result number, const ::std::string& description, const ::std::string& source ); 
     66                        Exception( Result number, const std::string& description, const std::string& source ); 
    6767         
    6868                        /** 
     
    7474                        * \param line Where was the exception thrown 
    7575                        */ 
    76                         Exception( Result number, const ::std::string& description, const ::std::string& source, char* file, long line ); 
     76                        Exception( Result number, const std::string& description, const std::string& source, char* file, long line ); 
    7777         
    7878                        /** 
     
    9696                private: 
    9797                        long                    lineNumber; 
    98                         ::std::string   description; 
    99                         ::std::string   source; 
    100                         ::std::string   file; 
     98                        std::string     description; 
     99                        std::string     source; 
     100                        std::string     file; 
    101101                        Result                  number; 
    102102 
  • nrEngine/include/FileStream.h

    r1 r30  
    6262                 * Open a file as a stream without using of underlying resource system. 
    6363                 **/ 
    64                 virtual Result open (const ::std::string& fileName); 
     64                virtual Result open (const std::string& fileName); 
    6565 
    6666                //------------------------------------------------------------ 
     
    7272                * as the name of the underlying resource used for the file storing. 
    7373                **/ 
    74                 const ::std::string& getName()  const { return getResName(); } 
     74                const std::string& getName()    const { return getResName(); } 
    7575 
    7676                /** 
     
    8282                * @copydoc IStream::readDelim() 
    8383                **/ 
    84                 virtual size_t readDelim(void* buf, size_t count, const ::std::string& delim = ::std::string("\n")); 
     84                virtual size_t readDelim(void* buf, size_t count, const std::string& delim = std::string("\n")); 
    8585 
    8686                /** 
     
    115115 
    116116                //! Stream used to read the file 
    117                 SharedPtr< ::std::ifstream > mStream; 
     117                SharedPtr< std::ifstream > mStream; 
    118118 
    119119                Result unloadRes(); 
     
    143143 
    144144                //! Read until we fund a delimeter 
    145                 size_t readDelim(void* buf, size_t count, const ::std::string& delim = "\n"); 
     145                size_t readDelim(void* buf, size_t count, const std::string& delim = "\n"); 
    146146 
    147147                //! What is the position of the empty file reading cursor 
  • nrEngine/include/IStream.h

    r1 r30  
    6464                * @param streamBufSize Size of the buffer for this stream. Only buffered streams. 
    6565                **/ 
    66                 IStream(const ::std::string& name, uint32 streamBufSize = STREAM_BUFFER_SIZE); 
     66                IStream(const std::string& name, uint32 streamBufSize = STREAM_BUFFER_SIZE); 
    6767 
    6868                /** 
     
    7474                * Return the name of the stream 
    7575                **/ 
    76                 virtual const ::std::string& getName()  { return mName; } 
     76                virtual const std::string& getName()    { return mName; } 
    7777 
    7878                /** 
     
    113113                * the delimiter string in the data 
    114114                **/ 
    115                 virtual size_t readDelim(void* buf, size_t count, const ::std::string& delim = ::std::string("\n")) = 0; 
     115                virtual size_t readDelim(void* buf, size_t count, const std::string& delim = std::string("\n")) = 0; 
    116116 
    117117                /** 
     
    138138                * stream content as a string 
    139139                **/ 
    140                 virtual ::std::string getAsString(); 
     140                virtual std::string getAsString(); 
    141141 
    142142                /** 
    143143                * Read a line from the stream. Only usefull for text-only-streams 
    144144                **/ 
    145                 virtual ::std::string getLine(); 
     145                virtual std::string getLine(); 
    146146 
    147147                /** 
     
    174174 
    175175                //! Name of the stream 
    176                 ::std::string   mName; 
     176                std::string     mName; 
    177177 
    178178                //! Size of the stream in bytes. If size could not be determined so 0 
  • nrEngine/include/ITask.h

    r17 r30  
    311311 
    312312                //! Setup the name of the task 
    313                 void setTaskName(const ::std::string& name); 
     313                void setTaskName(const std::string& name); 
    314314 
    315315                /** 
     
    324324                 * classes can setup their names. 
    325325                 **/ 
    326                 ITask(const ::std::string& name); 
     326                ITask(const std::string& name); 
    327327 
    328328        private: 
  • nrEngine/include/Kernel.h

    r1 r30  
    230230                 * \return smart poitner to the task or to the NULL if no such task found or task is system task 
    231231                **/ 
    232                 SharedPtr<ITask> getTaskByName(const ::std::string& name); 
     232                SharedPtr<ITask> getTaskByName(const std::string& name); 
    233233 
    234234        protected: 
    235235 
    236236                //! Here kernel does store all currently running tasks 
    237                 ::std::list< SharedPtr<ITask> > taskList; 
     237                std::list< SharedPtr<ITask> > taskList; 
    238238 
    239239                //! Here kernel store all tasks that are sleeping now. 
    240                 ::std::list< SharedPtr<ITask> > pausedTaskList; 
     240                std::list< SharedPtr<ITask> > pausedTaskList; 
    241241 
    242242                //! Get information about lock state of the kernel 
     
    276276 
    277277 
    278                 typedef ::std::list< SharedPtr<ITask> >::iterator PipelineIterator; 
     278                typedef std::list< SharedPtr<ITask> >::iterator PipelineIterator; 
    279279 
    280280                /** 
     
    298298                 * \note This Function runs in O(N) so optimize this if you know how 
    299299                 **/ 
    300                 bool _getTaskByName(const ::std::string& name, PipelineIterator& it, int32 useList = TL_RUNNING); 
     300                bool _getTaskByName(const std::string& name, PipelineIterator& it, int32 useList = TL_RUNNING); 
    301301 
    302302                /** 
     
    304304                 * execution list. 
    305305                 **/ 
    306                 const ::std::list< SharedPtr<ITask> >& getTaskList(){return taskList;} 
     306                const std::list< SharedPtr<ITask> >& getTaskList(){return taskList;} 
    307307 
    308308 
     
    311311                 * which were suspended through \a SuspendTask() method. 
    312312                 **/ 
    313                 const ::std::list< SharedPtr<ITask> >& getPausedTaskList(){return pausedTaskList;} 
     313                const std::list< SharedPtr<ITask> >& getPausedTaskList(){return pausedTaskList;} 
    314314 
    315315                /** 
     
    327327                *                       - BAD_PARAMETERS if the given pointer is null or the vector does contain data 
    328328                **/ 
    329                 //Result _solveDependencies(::std::vector<taskID>* retTasks); 
     329                //Result _solveDependencies(std::vector<taskID>* retTasks); 
    330330 
    331331                /** 
  • nrEngine/include/Log.h

    r1 r30  
    111111                        *                       - LOG_ERROR if there was an error by creating the log files 
    112112                        **/ 
    113                         Result initialize(const ::std::string& logPath); 
     113                        Result initialize(const std::string& logPath); 
    114114                         
    115115                        /** 
  • nrEngine/include/Plugin.h

    r1 r30  
    133133                 * @param name Unique name of the symbol 
    134134                 **/ 
    135                 virtual void* getSymbol(const ::std::string& name) const; 
     135                virtual void* getSymbol(const std::string& name) const; 
    136136 
    137137                //! Each method in the plugin accept parameters of this type 
     
    241241                 
    242242                //! Return always NULL 
    243                 void* getSymbol(const ::std::string& name) const; 
     243                void* getSymbol(const std::string& name) const; 
    244244                 
    245245        }; 
  • nrEngine/include/Profiler.h

    r1 r30  
    8383                         * Create an instance of this class and start profiling for this profile. 
    8484                         **/ 
    85                         Profile(const ::std::string& name, bool isSystemProfile = false); 
     85                        Profile(const std::string& name, bool isSystemProfile = false); 
    8686                         
    8787                        /** 
     
    126126                         * \param name Unique name of the profile 
    127127                         **/ 
    128                         void beginProfile(const ::std::string& name, bool isSystemProfile = false); 
     128                        void beginProfile(const std::string& name, bool isSystemProfile = false); 
    129129                          
    130130                        /** 
     
    135135                         * \param name Unique name of the profile 
    136136                         **/ 
    137                         void endProfile(const ::std::string& name, bool isSystemProfile = false); 
     137                        void endProfile(const std::string& name, bool isSystemProfile = false); 
    138138                         
    139139                        /** 
     
    210210         
    211211                                //! The name of the profile 
    212                                 ::std::string           name; 
     212                                std::string             name; 
    213213         
    214214                                //! The name of the parent, empty string if root 
    215                                 ::std::string           parent; 
     215                                std::string             parent; 
    216216 
    217217                                //! Define if the profile is a system profile 
     
    232232                                 
    233233                                //! The name of the profile 
    234                                 ::std::string   name; 
     234                                std::string     name; 
    235235                         
    236236                                //! The time this profile has taken this frame 
     
    252252         
    253253                                //! The name of the profile 
    254                                 ::std::string   name; 
     254                                std::string     name; 
    255255 
    256256                                //! is system profile 
     
    290290                                 
    291291                         
    292                         typedef ::std::list<ProfileInstance>            ProfileStack; 
    293                         typedef ::std::list<ProfileFrame>                       ProfileFrameList; 
    294                         typedef ::std::list<ProfileHistory>                     ProfileHistoryList; 
    295                         typedef ::std::map< ::std::string, ProfileHistoryList::iterator> ProfileHistoryMap; 
    296                         typedef ::std::map< ::std::string, bool>                DisabledProfileMap; 
     292                        typedef std::list<ProfileInstance>              ProfileStack; 
     293                        typedef std::list<ProfileFrame>                 ProfileFrameList; 
     294                        typedef std::list<ProfileHistory>                       ProfileHistoryList; 
     295                        typedef std::map< std::string, ProfileHistoryList::iterator> ProfileHistoryMap; 
     296                        typedef std::map< std::string, bool>            DisabledProfileMap; 
    297297 
    298298                        //! A stack for each individual profile per frame 
  • nrEngine/include/ResourceManager.h

    r16 r30  
    123123                        *                so the behavior of getting appropriate loader is undefined. 
    124124                        **/ 
    125                         Result  registerLoader  (const ::std::string& name, ResourceLoader loader); 
     125                        Result  registerLoader  (const std::string& name, ResourceLoader loader); 
    126126         
    127127         
     
    136136                        *               - RES_ERROR 
    137137                        **/ 
    138                         Result  removeLoader    (const ::std::string& name); 
     138                        Result  removeLoader    (const std::string& name); 
    139139         
    140140         
     
    144144                        * @param fileType File type for which one the loader should be found 
    145145                        **/ 
    146                         ResourceLoader getLoaderByFile  (const ::std::string& fileType); 
     146                        ResourceLoader getLoaderByFile  (const std::string& fileType); 
    147147         
    148148         
     
    152152                        * @return either NULL or resource loader 
    153153                        **/ 
    154                         ResourceLoader getLoaderByResource(const ::std::string& resType); 
     154                        ResourceLoader getLoaderByResource(const std::string& resType); 
    155155         
    156156         
     
    159159                        * exists, so NULL will be given back 
    160160                        **/ 
    161                         ResourceLoader getLoader                        (const ::std::string& name); 
     161                        ResourceLoader getLoader                        (const std::string& name); 
    162162         
    163163         
     
    442442                        ResourceHandle  mLastHandle; 
    443443         
    444                         typedef ::std::map< ::std::string, ResourceLoader> loader_map; 
     444                        typedef std::map< std::string, ResourceLoader> loader_map; 
    445445         
    446446                        loader_map      mLoader; 
    447447         
    448448         
    449                         typedef ::std::map<ResourceHandle, SharedPtr<ResourceHolder> >   res_hdl_map; 
    450                         typedef ::std::map< ::std::string, ResourceHandle>               res_str_map; 
    451                         typedef ::std::map< ::std::string, ::std::list<ResourceHandle> > res_grp_map; 
    452                         typedef ::std::map< ::std::string, SharedPtr<IResource> >        res_empty_map; 
     449                        typedef std::map<ResourceHandle, SharedPtr<ResourceHolder> >   res_hdl_map; 
     450                        typedef std::map< std::string, ResourceHandle>               res_str_map; 
     451                        typedef std::map< std::string, std::list<ResourceHandle> > res_grp_map; 
     452                        typedef std::map< std::string, SharedPtr<IResource> >        res_empty_map; 
    453453         
    454454                        res_hdl_map     mResource; 
     
    494494                        * If nothing found NULL will be returned. 
    495495                        **/ 
    496                         SharedPtr<ResourceHolder>*      getHolderByName(const ::std::string& name); 
     496                        SharedPtr<ResourceHolder>*      getHolderByName(const std::string& name); 
    497497         
    498498                        /** 
     
    502502 
    503503#if 0 
    504                         /** 
    505                         * This function should create a empty resource and give a pointer to it back. 
    506                         * This is a virtual function which returns NULL in the base class. So if you 
    507                         * want to derive other resource manager classes and you want to have very 
    508                         * special creating function you should write out this function. 
    509                         * 
    510                         * If this method is returns NULL, so we will use the resource object 
    511                         * created createEmptyResource() function. 
    512                         * @see createEmptyResource() 
    513                         **/ 
    514                         virtual IResource* createEmptyImpl(ResourceHandle hdl, 
    515                                                                                                 const ::std::string& name, 
    516                                                                                                 const ::std::string& group, 
    517                                                                                                 const ::std::string& resourceType, 
    518                                                                                                 NameValuePairs* params = NULL){return NULL;} 
    519          
    520                         /** 
    521                         * This function should load a resource from a file. This function is declared 
    522                         * as virtual so it can be overloaded through functions from dirived classes. 
    523                         * This is not needed but if you want to have your own loading functions, you 
    524                         * can do it here 
    525                         * @see loadResource() 
    526                         **/ 
    527                         virtual IResource* loadResourceImpl(ResourceHandle hdl, 
    528                                                                                                 const ::std::string& name, 
    529                                                                                                 const ::std::string& group, 
    530                                                                                                 const ::std::string& resourceType, 
    531                                                                                                 const ::std::string& fileName, 
    532                                                                                                 NameValuePairs* params = NULL, 
    533                                                                                                 ResourceLoader manualLoader = ResourceLoader()){return NULL;} 
    534          
    535          
    536504                        /** 
    537505                        * This function will check if there is already an empty resource for the given resource 
     
    541509                        * @param loader Appropritate loader for that resource type 
    542510                        **/ 
    543                         virtual Result checkEmptyResource(const ::std::string resourceType, 
     511                        virtual Result checkEmptyResource(const std::string resourceType, 
    544512                                                                                                SharedPtr<IResource>& empty, 
    545513                                                                                                ResourceLoader loader); 
  • nrEngine/include/ResourcePtr.h

    r29 r30  
    215215                        **/ 
    216216                        ResourcePtr(const IResourcePtr& res) : IResourcePtr(res){} 
    217 <<<<<<< .mine 
    218  
    219  
    220 ======= 
    221217                         
    222 >>>>>>> .r28 
    223218                        /** 
    224219                        * Access to the resource to which one this pointer points. This access need 
  • nrEngine/include/StdHelpers.h

    r1 r30  
    4545        * \ingroup helpers 
    4646        **/ 
    47         ::std::string _NRExport convertVersionToString(uint32 version); 
     47        std::string _NRExport convertVersionToString(uint32 version); 
    4848 
    4949 
  • nrEngine/src/Clock.cpp

    r28 r30  
    276276                        observers.push_back (timeObserver); 
    277277                        id = observers.size(); 
    278                         observerIDList[::std::string(DEFAULT_OBSERVER_NAME) + ::boost::lexical_cast< ::std::string >(id)] = id; 
     278                        observerIDList[std::string(DEFAULT_OBSERVER_NAME) + ::boost::lexical_cast< std::string >(id)] = id; 
    279279                        observers[observers.size()-1]->_observerID = id; 
    280280                } 
     
    288288                int32 id = observerID - 1; 
    289289                if (id <= 0 || id+1 >= static_cast<int32>(observers.size()) 
    290                                 || observerIDList.find(::std::string(DEFAULT_OBSERVER_NAME) +  
    291                                 ::boost::lexical_cast< ::std::string >(observerID)) == observerIDList.end()){ 
     290                                || observerIDList.find(std::string(DEFAULT_OBSERVER_NAME) +  
     291                                ::boost::lexical_cast< std::string >(observerID)) == observerIDList.end()){ 
    292292                        return CLOCK_OBSERVER_NOT_FOUND; 
    293293                } 
     
    297297                 
    298298                // also clean the map enty for this id 
    299                 observerIDList.erase(observerIDList.find( ::std::string(DEFAULT_OBSERVER_NAME) +  
    300                                 ::boost::lexical_cast< ::std::string >(observerID) )); 
     299                observerIDList.erase(observerIDList.find( std::string(DEFAULT_OBSERVER_NAME) +  
     300                                ::boost::lexical_cast< std::string >(observerID) )); 
    301301                                 
    302302                // OK 
     
    305305                 
    306306        //------------------------------------------------------------------------ 
    307         Result Clock::addObserver(const ::std::string& obsName,SharedPtr<ITimeObserver> timeObserver) 
     307        Result Clock::addObserver(const std::string& obsName,SharedPtr<ITimeObserver> timeObserver) 
    308308        { 
    309309         
     
    325325         
    326326        //------------------------------------------------------------------------ 
    327         Result Clock::removeObserver(const ::std::string& obsName){ 
     327        Result Clock::removeObserver(const std::string& obsName){ 
    328328         
    329329                if (observerIDList[obsName]){ 
     
    401401                float64 totalFrameTime = 0; 
    402402         
    403                 ::std::deque<float64>::const_iterator it; 
     403                std::deque<float64>::const_iterator it; 
    404404                for (it=frameDurationHistory.begin();it != frameDurationHistory.end(); ++it){ 
    405405                        totalFrameTime += *it; 
  • nrEngine/src/Exception.cpp

    r1 r30  
    2020 
    2121        //------------------------------------------------------------------------- 
    22         Exception::Exception( Result number, const ::std::string& description, const ::std::string& source ) 
     22        Exception::Exception( Result number, const std::string& description, const std::string& source ) 
    2323        { 
    2424                this->number = number; 
     
    2828 
    2929        //------------------------------------------------------------------------- 
    30         Exception::Exception( Result number, const ::std::string& description, const ::std::string& source, char* file, long line ) 
     30        Exception::Exception( Result number, const std::string& description, const std::string& source, char* file, long line ) 
    3131        { 
    3232                this->number = number; 
  • nrEngine/src/FileStream.cpp

    r21 r30  
    4040 
    4141        //---------------------------------------------------------------------------------- 
    42         Result FileStream::open (const ::std::string& fileName) 
     42        Result FileStream::open (const std::string& fileName) 
    4343        { 
    4444                // create a pointer to the stream object and open the file 
    45                 mStream.reset (new ::std::ifstream(fileName.c_str())); 
     45                mStream.reset (new std::ifstream(fileName.c_str())); 
    4646 
    4747                // check if the file could be found 
     
    5353 
    5454                // calculate the size 
    55                 mStream->seekg(0, ::std::ios_base::end); 
     55                mStream->seekg(0, std::ios_base::end); 
    5656                mSize = mStream->tellg(); 
    57                 mStream->seekg(0, ::std::ios_base::beg); 
     57                mStream->seekg(0, std::ios_base::beg); 
    5858 
    5959                return OK; 
     
    7878 
    7979        //---------------------------------------------------------------------------------- 
    80         size_t FileStream::readDelim(void* buf, size_t count, const ::std::string& delim) 
     80        size_t FileStream::readDelim(void* buf, size_t count, const std::string& delim) 
    8181        { 
    8282                if (!mStream) return 0; 
     
    197197 
    198198        //---------------------------------------------------------------------------------- 
    199         size_t EmptyFileStream::readDelim(void* buf, size_t count, const ::std::string& ) 
     199        size_t EmptyFileStream::readDelim(void* buf, size_t count, const std::string& ) 
    200200        { 
    201201                return 0; 
  • nrEngine/src/IStream.cpp

    r1 r30  
    3232 
    3333        //---------------------------------------------------------------------------------- 
    34         IStream::IStream(const ::std::string& name, uint32 streamBufSize) : mName(name), mSize(0), mStreamBufSize(streamBufSize) 
     34        IStream::IStream(const std::string& name, uint32 streamBufSize) : mName(name), mSize(0), mStreamBufSize(streamBufSize) 
    3535        { 
    3636                // check for the size. If size is smaller than 1 we want to have unbuffered data 
     
    5959 
    6060        //---------------------------------------------------------------------------------- 
    61         ::std::string IStream::getLine() 
     61        std::string IStream::getLine() 
    6262        { 
    6363 
    6464                // some variables to store the data 
    6565                size_t c = mStreamBufSize; 
    66                 ::std::string str; 
     66                std::string str; 
    6767 
    6868                // read until we reached end of file or got 
     
    8181 
    8282        //---------------------------------------------------------------------------------- 
    83         ::std::string IStream::getAsString(){ 
     83        std::string IStream::getAsString(){ 
    8484 
    8585                // create buffer to hold the whole data 
     
    9191                // setup the end characeter and create the string 
    9292                pBuf[c] = '\0'; 
    93                 ::std::string str(pBuf); 
     93                std::string str(pBuf); 
    9494 
    9595                // free data and return 
  • nrEngine/src/ITask.cpp

    r17 r30  
    2626 
    2727        //-------------------------------------------------------------------- 
    28         ITask::ITask(const ::std::string& name) : IThread(){ 
     28        ITask::ITask(const std::string& name) : IThread(){ 
    2929                init(); 
    3030                setTaskName(_taskName); 
     
    105105 
    106106        //-------------------------------------------------------------------- 
    107         void ITask::setTaskName(const ::std::string& name){ 
     107        void ITask::setTaskName(const std::string& name){ 
    108108                strncpy(_taskName, name.c_str(), 63); 
    109109        } 
  • nrEngine/src/Kernel.cpp

    r27 r30  
    644644 
    645645        //------------------------------------------------------------------------- 
    646         bool Kernel::_getTaskByName(const std::string& name, PipelineIterator& it, int32 useList){ 
     646        bool Kernel::_getTaskByName(const std::string& name, PipelineIterator& it, int32 useList) 
     647        { 
    647648 
    648649                // get std::list we want to search in 
  • nrEngine/src/Log.cpp

    r1 r30  
    3939         
    4040        //------------------------------------------------------------------------- 
    41         Result Log::initialize(const ::std::string& logPath){ 
     41        Result Log::initialize(const std::string& logPath){ 
    4242                 
    4343                this->logPath = logPath; 
    4444                 
    4545                // open log files 
    46                 _appLog.open((logPath + "/application.log").c_str(),::std::ios::out);// | ios::app); 
    47                 _kernelLog.open((logPath + "/kernel.log").c_str(), ::std::ios::out);// | ios::app); 
    48                 //_clientLog.open((logPath + "/client.log").c_str(), ::std::ios::out);// | ios::app); 
    49                 //_serverLog.open((logPath + "/server.log").c_str(), ::std::ios::out);// | ios::app); 
    50                 _engineLog.open((logPath + "/engine.log").c_str(), ::std::ios::out);// | ios::app); 
    51                 _pluginLog.open((logPath + "/plugin.log").c_str(), ::std::ios::out);// | ios::app); 
     46                _appLog.open((logPath + "/application.log").c_str(),std::ios::out);// | ios::app); 
     47                _kernelLog.open((logPath + "/kernel.log").c_str(), std::ios::out);// | ios::app); 
     48                //_clientLog.open((logPath + "/client.log").c_str(), std::ios::out);// | ios::app); 
     49                //_serverLog.open((logPath + "/server.log").c_str(), std::ios::out);// | ios::app); 
     50                _engineLog.open((logPath + "/engine.log").c_str(), std::ios::out);// | ios::app); 
     51                _pluginLog.open((logPath + "/plugin.log").c_str(), std::ios::out);// | ios::app); 
    5252                         
    5353                log (LOG_ANYTHING, LL_DEBUG, "Logging activated"); 
     
    173173         
    174174                if (target & LOG_CONSOLE){ 
    175                         ::std::cout << timeDate << ": " << szBuf << "\n"; 
    176                         ::std::cout.flush(); 
     175                        std::cout << timeDate << ": " << szBuf << "\n"; 
     176                        std::cout.flush(); 
    177177                } 
    178178                         
  • nrEngine/src/Plugin.cpp

    r1 r30  
    3535 
    3636        //---------------------------------------------------------------------------------- 
    37         void* Plugin::getSymbol(const ::std::string& name) const 
     37        void* Plugin::getSymbol(const std::string& name) const 
    3838        { 
    3939                PluginHandle hdl =  (PluginHandle)NR_PLUGIN_GETSYM(mPluginHandle, name.c_str()); 
     
    161161 
    162162        //---------------------------------------------------------------------------------- 
    163         void* EmptyPlugin::getSymbol(const ::std::string& name) const 
     163        void* EmptyPlugin::getSymbol(const std::string& name) const 
    164164        { 
    165165                return NULL; 
  • nrEngine/src/Profiler.cpp

    r1 r30  
    2323 
    2424        //-------------------------------------------------------------------- 
    25         Profile::Profile(const ::std::string& name, bool isSystemProfile) : mName(name), mSystemProfile(isSystemProfile) 
     25        Profile::Profile(const std::string& name, bool isSystemProfile) : mName(name), mSystemProfile(isSystemProfile) 
    2626        { 
    2727                Engine::sProfiler()->beginProfile(mName, isSystemProfile); 
     
    5757         
    5858        //-------------------------------------------------------------------- 
    59         void Profiler::beginProfile(const ::std::string& profileName, bool isSystemProfile) { 
     59        void Profiler::beginProfile(const std::string& profileName, bool isSystemProfile) { 
    6060         
    6161                // if the profiler is enabled 
     
    137137         
    138138                        // for quick look-ups, we'll add it to the history map as well 
    139                         mProfileHistoryMap.insert(::std::pair< ::std::string, ProfileHistoryList::iterator>(profileName, hIter)); 
     139                        mProfileHistoryMap.insert(std::pair< std::string, ProfileHistoryList::iterator>(profileName, hIter)); 
    140140                } 
    141141         
     
    153153 
    154154        //-------------------------------------------------------------------- 
    155         void Profiler::endProfile(const ::std::string& profileName, bool isSystemProfile) { 
     155        void Profiler::endProfile(const std::string& profileName, bool isSystemProfile) { 
    156156         
    157157                // if the profiler is enabled 
     
    249249                for (frameIter = mProfileFrame.begin(); frameIter != mProfileFrame.end(); frameIter++) { 
    250250         
    251                         ::std::string s = (*frameIter).name; 
     251                        std::string s = (*frameIter).name; 
    252252         
    253253                        // use our map to find the appropriate profile in the history 
  • nrEngine/src/ResourceHolder.cpp

    r1 r30  
    2323         
    2424        //---------------------------------------------------------------------------------- 
    25         ResourceHolder::~ResourceHolder(){ 
     25        ResourceHolder::~ResourceHolder() 
     26        { 
    2627                mResource = NULL; 
    2728        } 
  • nrEngine/src/ResourceManager.cpp

    r27 r30  
    145145 
    146146        //---------------------------------------------------------------------------------- 
    147         Result ResourceManager::registerLoader(const ::std::string& name, ResourceLoader loader){ 
     147        Result ResourceManager::registerLoader(const std::string& name, ResourceLoader loader){ 
    148148 
    149149                // check whenver such a loader already exists 
     
    165165                // Give some log information about supported filetypes and resource types 
    166166                try{ 
    167                         ::std::vector< ::std::string>::const_iterator it; 
    168                         ::std::string strTemp; 
    169  
    170                         const ::std::vector< ::std::string>&    fileTypes = loader->getSupportedFileTypes(); 
     167                        std::vector< std::string>::const_iterator it; 
     168                        std::string strTemp; 
     169 
     170                        const std::vector< std::string>&        fileTypes = loader->getSupportedFileTypes(); 
    171171                        for (it = fileTypes.begin(); it != fileTypes.end(); it++){ 
    172172                                strTemp += (*it) + " "; 
     
    175175                        strTemp = ""; 
    176176 
    177                         const ::std::vector< ::std::string>&    resTypes = loader->getSupportedResourceTypes(); 
     177                        const std::vector< std::string>&        resTypes = loader->getSupportedResourceTypes(); 
    178178                        for (it = resTypes.begin(); it != resTypes.end(); it++){ 
    179179                                strTemp += (*it) + " "; 
     
    188188 
    189189        //---------------------------------------------------------------------------------- 
    190         Result ResourceManager::removeLoader(const ::std::string& name){ 
     190        Result ResourceManager::removeLoader(const std::string& name){ 
    191191 
    192192                // get id of the loader 
     
    204204 
    205205        //---------------------------------------------------------------------------------- 
    206         ResourceLoader ResourceManager::getLoaderByFile(const ::std::string& fileType){ 
     206        ResourceLoader ResourceManager::getLoaderByFile(const std::string& fileType){ 
    207207 
    208208                if (fileType.length() == 0) return ResourceLoader(); 
     
    224224 
    225225        //---------------------------------------------------------------------------------- 
    226         ResourceLoader ResourceManager::getLoader(const ::std::string& name){ 
     226        ResourceLoader ResourceManager::getLoader(const std::string& name){ 
    227227 
    228228                loader_map::iterator it = mLoader.find(name); 
     
    236236 
    237237        //---------------------------------------------------------------------------------- 
    238         ResourceLoader ResourceManager::getLoaderByResource(const ::std::string& resType){ 
     238        ResourceLoader ResourceManager::getLoaderByResource(const std::string& resType){ 
    239239 
    240240                // scan through all loaders and ask them if they do support this kind of file type 
     
    340340 
    341341        //---------------------------------------------------------------------------------- 
    342         Result ResourceManager::unload(const ::std::string& name){ 
     342        Result ResourceManager::unload(const std::string& name){ 
    343343 
    344344                ResourcePtr<IResource> res = getByName(name); 
     
    391391 
    392392        //---------------------------------------------------------------------------------- 
    393         Result ResourceManager::reload(const ::std::string& name){ 
     393        Result ResourceManager::reload(const std::string& name){ 
    394394 
    395395                ResourcePtr<IResource> res = getByName(name); 
     
    452452                        ResourcePtr<IResource> ptr = resPtr; 
    453453                        ResourceHandle hdl = ptr->getResHandle(); 
    454                         ::std::string name = ptr->getResName(); 
    455                         ::std::string grp = ptr->getResGroup(); 
     454                        std::string name = ptr->getResName(); 
     455                        std::string grp = ptr->getResGroup(); 
    456456 
    457457                        if (hdl == 0){ 
     
    492492*/ 
    493493        //---------------------------------------------------------------------------------- 
    494         Result ResourceManager::remove(const ::std::string& name){ 
     494        Result ResourceManager::remove(const std::string& name){ 
    495495 
    496496                // check whenever such a resource exists 
     
    542542 
    543543        //---------------------------------------------------------------------------------- 
    544         SharedPtr<ResourceHolder>* ResourceManager::getHolderByName(const ::std::string& name) 
     544        SharedPtr<ResourceHolder>* ResourceManager::getHolderByName(const std::string& name) 
    545545        { 
    546546                // find the handle 
     
    568568 
    569569        //---------------------------------------------------------------------------------- 
    570         IResourcePtr ResourceManager::getByName(const ::std::string& name){ 
     570        IResourcePtr ResourceManager::getByName(const std::string& name){ 
    571571                SharedPtr<ResourceHolder>* holder = getHolderByName(name); 
    572572                if (holder == NULL){ 
     
    638638 
    639639        //---------------------------------------------------------------------------------- 
    640         Result ResourceManager::lockPure(const ::std::string& name){ 
     640        Result ResourceManager::lockPure(const std::string& name){ 
    641641 
    642642                // get appropriate pointer 
     
    671671 
    672672        //---------------------------------------------------------------------------------- 
    673         Result ResourceManager::unlockPure(const ::std::string& name){ 
     673        Result ResourceManager::unlockPure(const std::string& name){ 
    674674 
    675675                // get appropriate holder 
     
    719719 
    720720        //---------------------------------------------------------------------------------- 
    721         Result ResourceManager::unloadGroup(const ::std::string& group){ 
     721        Result ResourceManager::unloadGroup(const std::string& group){ 
    722722 
    723723                // check whenever such a group exists 
     
    731731 
    732732                // scan through all elements 
    733                 ::std::list<ResourceHandle>::iterator jt = mResourceGroup[group].begin(); 
     733                std::list<ResourceHandle>::iterator jt = mResourceGroup[group].begin(); 
    734734                for (; jt != mResourceGroup[group].end(); jt++){ 
    735735                        Result ret = unload(*jt); 
     
    742742 
    743743        //---------------------------------------------------------------------------------- 
    744         Result ResourceManager::reloadGroup(const ::std::string& group){ 
     744        Result ResourceManager::reloadGroup(const std::string& group){ 
    745745 
    746746                // check whenever such a group exists 
     
    754754 
    755755                // scan through all elements 
    756                 ::std::list<ResourceHandle>::iterator jt = mResourceGroup[group].begin(); 
     756                std::list<ResourceHandle>::iterator jt = mResourceGroup[group].begin(); 
    757757                for (; jt != mResourceGroup[group].end(); jt++){ 
    758758                        Result ret = reload(*jt); 
     
    766766 
    767767        //---------------------------------------------------------------------------------- 
    768         Result ResourceManager::removeGroup(const ::std::string& group){ 
     768        Result ResourceManager::removeGroup(const std::string& group){ 
    769769 
    770770                // check whenever such a group exists 
     
    778778 
    779779                // scan through all elements 
    780                 ::std::list<ResourceHandle>::iterator jt = mResourceGroup[group].begin(); 
     780                std::list<ResourceHandle>::iterator jt = mResourceGroup[group].begin(); 
    781781                for (; jt != mResourceGroup[group].end(); jt++){ 
    782782                        Result ret = remove(*jt); 
  • nrEngine/src/ScriptLoader.cpp

    r27 r30  
    9898 
    9999        //---------------------------------------------------------------------------------- 
    100         IResource* ScriptLoader::createEmptyResource(const ::std::string& resourceType) 
     100        IResource* ScriptLoader::createEmptyResource(const std::string& resourceType) 
    101101        { 
    102102                // create an instance of empty plugin 
  • nrEngine/src/StdHelpers.cpp

    r1 r30  
    5555 
    5656        //------------------------------------------------------------------------- 
    57         ::std::string convertVersionToString(uint32 version) 
     57        std::string convertVersionToString(uint32 version) 
    5858        { 
    5959                // extract patch number 
     
    7171 
    7272                // return a string 
    73                 return ::std::string(str); 
     73                return std::string(str); 
    7474        } 
    7575 
Note: See TracChangeset for help on using the changeset viewer.