Changeset 30 for nrEngine/include


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

::std wurde durch std ueberall ersetzt!

Location:
nrEngine/include
Files:
1 deleted
12 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 
Note: See TracChangeset for help on using the changeset viewer.