source: nrEngine/include/Priority.h @ 1

Revision 1, 8.1 KB checked in by art, 13 years ago (diff)
Line 
1/***************************************************************************
2 *                                                                         *
3 *   (c) Art Tevs, MPI Informatik Saarbruecken                             *
4 *       mailto: <tevs@mpi-sb.mpg.de>                                      *
5 *                                                                         *
6 *   This program is free software; you can redistribute it and/or modify  *
7 *   it under the terms of the GNU General Public License as published by  *
8 *   the Free Software Foundation; either version 2 of the License, or     *
9 *   (at your option) any later version.                                   *
10 *                                                                         *
11 ***************************************************************************/
12
13
14#ifndef _NR_C_PRIORITY__H_
15#define _NR_C_PRIORITY__H_
16
17       
18//----------------------------------------------------------------------------------
19// Includes
20//----------------------------------------------------------------------------------
21#include "Prerequisities.h"
22
23
24namespace nrEngine{
25       
26               
27        //! Priorities class definition
28        /**
29        * Priorities definition.
30        * Priorities are used very often to determine for example which object should be removed
31        * first or which one has to get access to some resources.
32        *
33        * In our engine we understand under priority numbers some numbers that handles like
34        * integers. You have two operations defined on the priorities: addidition and substraction.
35        * You can add integers to priority numbers to increase or decrease the meaning of such a priority.
36        *
37        * The class which use such priorities should know how to handle with them. That means it
38        * has to know if the priority numbers are in increasing or decreasing order. Increasing order
39        * means that the element with the lowest priority is coming at last and with the highest as first.
40        * So to say colloquially, lower priority is better than higher. There can also be another
41        * way: decreasing order. Which is converse to increasing order.
42        *
43        * All default priority numbers are stored in decreasing order. That means the best priority is
44        * the priority with the smallest number. So you are welcome to use this definition or just
45        * write you classes according to increasing definition.
46        *
47        * You can also create priority numbers from strings. The given string will first be scanned
48        * for known names like "PRIORITY_FIRST" or "NR_PRIORITY_FIRST" and so on. If such known string
49        * was found, so the value according to such a string will be assigned. If no such name found,
50        * so standard boost's lexical cast will be used to cast for the value. So this can also fail
51        * if the given string could not been casted. (e.g. "5bla" -> not castable)
52        * \ingroup gp
53        **/
54        class _NRExport CPriority{
55        public:
56       
57                /**
58                * Couple of pririoty default definitions. Can be used to specify a priority of
59                * any elements with CPriority-Class
60                **/
61                typedef enum _PriorityType{
62
63                        //! This number represents an immediate priority (better than first)
64                        IMMEDIATE               = 0,
65                       
66                        //! Smallest possible priority number
67                        FIRST                   = 1,
68                       
69                        //! Ultry high priority
70                        ULTRA_HIGH              = 10000,
71                       
72                        //! Next smaller priority to the ultra high value
73                        VERY_HIGH               = 20000,
74                       
75                        //! High priority
76                        HIGH                    = 30000,
77                       
78                        //! Default priority for all definitions (Center point)
79                        NORMAL                  = 40000,
80                       
81                        //! Lower priority according to the normal
82                        LOW                             = 50000,
83                       
84                        //! Very low priority in relation to normal value
85                        VERY_LOW                = 60000,
86                       
87                        //! Ultra low priority by comparison to the normal value
88                        ULTRA_LOW               = 70000,
89                       
90                        //! Greatest possible priority number
91                        LAST                    = 0x8FFFFFFE
92                       
93                }PriorityType;
94                       
95                //! Normal constructor
96                CPriority():    mPriority(NORMAL){}
97               
98                //! non-virtual destructor to prevent deriving of classes
99                ~CPriority()                            {}
100               
101                //! Copy constructor for priorities
102                CPriority(const CPriority& p){
103                        mPriority = p.get();   
104                }
105               
106                //! Create priority object from a number
107                CPriority(const int32& n): mPriority(n) {}
108                       
109                /**
110                * Create the priority from a string. String can contain either a number or
111                * a character array with priority names e.g. "PRIORITY_LAST"
112                **/
113                CPriority(const std::string& str){
114                       
115                        if (str.length() == 0){ mPriority = NORMAL;}
116                        #define _PRIORITY_(name)        else if (str == #name){ mPriority = name;}
117                        _PRIORITY_(FIRST)
118                        _PRIORITY_(ULTRA_HIGH)
119                        _PRIORITY_(VERY_HIGH)
120                        _PRIORITY_(HIGH)
121                        _PRIORITY_(NORMAL)
122                        _PRIORITY_(LOW)
123                        _PRIORITY_(VERY_LOW)
124                        _PRIORITY_(ULTRA_LOW)
125                        _PRIORITY_(LAST)
126                        #undef _PRIORITY_
127                        else{
128                                mPriority = boost::lexical_cast<uint32>(str);
129                        }
130                }
131               
132                //! Get the priority as an integer number, Number will be saturated
133                operator        int32() const { return u2i(mPriority);}
134               
135                //! Get the priority number
136                operator        uint32() const { return mPriority;}
137               
138                //! add new value to the priority number
139                CPriority&      operator        += (const CPriority& p) {mPriority += p.get(); return *this;}
140                CPriority&      operator        += (const uint32& p)            {mPriority += p; return *this;}
141               
142                //! Add an integer value can produce negative values
143                CPriority&      operator        += (const int32& p)                     {mPriority = i2u(u2i(mPriority) + p); return *this;}
144               
145                //! Substract a value from the priority by appropriate conversion between these types
146                CPriority&      operator        -= (const CPriority& p) {mPriority = i2u(u2i(mPriority) - u2i(p.get())); return *this;}
147                CPriority&      operator        -= (const int32& p)                     {mPriority = i2u(u2i(mPriority) - p); return *this;}
148                CPriority&      operator        -= (const uint32& p)            {mPriority = i2u(u2i(mPriority) - u2i(p)); return *this;}
149       
150                //! Check the priority eqiuvalence and order to other values
151                bool    operator        < (const CPriority& p)  const{return mPriority < p.get();}
152                bool    operator        > (const CPriority& p)  const{return mPriority > p.get();}
153                bool    operator        ==(const CPriority& p)  const{return mPriority == p.get();}
154                bool    operator        !=(const CPriority& p)  const{return mPriority != p.get();}
155                bool    operator        <=(const CPriority& p)  const{return mPriority <= p.get();}
156                bool    operator        >=(const CPriority& p)  const{return mPriority >= p.get();}
157       
158                //! Check the priority eqiuvalence and order to other integer values
159                bool    operator        < (const int32& p)      const{return mPriority < i2u(p);}
160                bool    operator        > (const int32& p)      const{return mPriority > i2u(p);}
161                bool    operator        ==(const int32& p)      const{return mPriority == i2u(p);}
162                bool    operator        !=(const int32& p)      const{return mPriority != i2u(p);}
163                bool    operator        <=(const int32& p)      const{return mPriority <= i2u(p);}
164                bool    operator        >=(const int32& p)      const{return mPriority >= i2u(p);}
165
166                //! Check to PriorityType
167                bool    operator        < (PriorityType p)      const{return mPriority < (uint32)p;}
168                bool    operator        > (PriorityType p)      const{return mPriority > (uint32)p;}
169                bool    operator        ==(PriorityType p)      const{return mPriority == (uint32)p;}
170                bool    operator        !=(PriorityType p)      const{return mPriority != (uint32)p;}
171                bool    operator        <=(PriorityType p)      const{return mPriority <= (uint32)p;}
172                bool    operator        >=(PriorityType p)      const{return mPriority >= (uint32)p;}
173               
174                //! Convert to a string
175                operator std::string(){
176                        if (false){}
177                        #define _PRIORITY_(name)        else if (mPriority == name){ return std::string(#name);}
178                        _PRIORITY_(IMMEDIATE)
179                        _PRIORITY_(FIRST)
180                        _PRIORITY_(ULTRA_HIGH)
181                        _PRIORITY_(VERY_HIGH)
182                        _PRIORITY_(HIGH)
183                        _PRIORITY_(NORMAL)
184                        _PRIORITY_(LOW)
185                        _PRIORITY_(VERY_LOW)
186                        _PRIORITY_(ULTRA_LOW)
187                        _PRIORITY_(LAST)
188                        #undef _PRIORITY_
189                        else{
190                                return boost::lexical_cast<std::string>(mPriority);
191                        }
192                }
193               
194                private:
195                        //! priority number
196                        uint32  mPriority;
197               
198                        //! Get the priority number
199                        const uint32& get()const        {return mPriority;}
200               
201                        //! Saturate an integer value to unsigned integer
202                        uint32  i2u(const int32& i) const{
203                                if (i >= 0) return static_cast<uint32>(i);
204                                else            return 0;
205                        }
206               
207                        //! Saturate an unsigned integer signed integer
208                        int32   u2i(const uint32& i) const {
209                                if (i < 0x8FFFFFFF) return static_cast<uint32>(i);
210                                else                            return 0x8FFFFFFE;
211                        }
212
213        };
214       
215        //! Write the priority without C prefix, to define it like normal type. \ingroup gp
216        typedef         CPriority               Priority;
217       
218}; // end namespace
219
220#endif
221 
Note: See TracBrowser for help on using the repository browser.