Changeset 11096 for code/trunk

Timestamp:

Jan 25, 2016, 9:33:11 PM (8 years ago)

Author:

muemart

Message:

Constexpr for some util things

Location:

code/trunk/src/libraries/util

Files:

• OrxEnum.h (modified) (2 diffs)
• mbool.h (modified) (3 diffs)
• tribool.h (modified) (11 diffs)

code/trunk/src/libraries/util/OrxEnum.h

@@ -61 +61 @@
     {
         public:
-            OrxEnum() { }
-            OrxEnum(int type)            { type_ = type; }
-            OrxEnum(const T& instance)   { type_ = instance.type_; }
+            constexpr OrxEnum()                   : type_()                {}
+            constexpr OrxEnum(int type)           : type_(type)            {}
+            constexpr OrxEnum(const T& instance)  : type_(instance.type_)  {}
+            constexpr OrxEnum(const OrxEnum& instance) = delete;
 
-            operator int()               { return type_; }
-            T& operator =(int type)      { type_ = type; return *this; }
-            bool operator <(const T& right) const { return (type_ < right.type_); }
-            bool operator >(const T& right) const { return (type_ > right.type_); }
+            constexpr operator int() const                  { return type_; }
+            T& operator =(int type)                         { type_ = type; return *this; }
+            constexpr bool operator <(const T& right) const { return (type_ < right.type_); }
+            constexpr bool operator >(const T& right) const { return (type_ > right.type_); }
 
         private:
-            OrxEnum(const OrxEnum& instance);
             int type_;
     };
@@ -77 +77 @@
 
 /// See orxonox::OrxEnum for more info
-#define OrxEnumConstructors(enumName)                        \
-enumName() { }                                               \
-enumName(int type) : OrxEnum<enumName>(type)             { } \
-enumName(const enumName& inst) : OrxEnum<enumName>(inst) { } \
+#define OrxEnumConstructors(enumName)                                  \
+constexpr enumName() { }                                               \
+constexpr enumName(int type) : OrxEnum<enumName>(type)             { } \
+constexpr enumName(const enumName& inst) : OrxEnum<enumName>(inst) { } \
 void dummyFunction()
 

code/trunk/src/libraries/util/mbool.h

@@ -60 +60 @@
         public:
             /// Constructor: Creates the mbool and initializes the boolean value (default to false).
-            inline mbool(bool value = false)
-                { this->value_.memory_ = 0; this->value_.bool_ = value; }
+            constexpr mbool(bool value = false) : value_{ static_cast<unsigned char>(value ? 1 : 0) }
+                {}
             /// Copy-constructor, copies state and memory.
-            inline mbool(const mbool& value)
-                { this->value_.memory_ = value.value_.memory_; }
+            constexpr mbool(const mbool& value) : value_{ value.value_.memory_ }
+                {}
             /// Destructor does nothing but not defining it might create a symbol (class is header only)
-            inline ~mbool()
-                { }
+            inline ~mbool() = default;
 
             /// Assigns a boolean value (and increases the memory value if the value is different to the old value).
@@ -84 +83 @@
 
             /// Implicitly converts the mbool to a bool.
-            inline operator bool() const
+            constexpr operator bool() const
                 { return this->value_.bool_; }
 
             /// Compares the mbool to a bool, returns true if the bool has the same value as the state of the mbool.
-            inline bool operator==(bool other) const
+            constexpr bool operator==(bool other) const
                 { return this->value_.bool_ == other; }
             /// Compares the mbool to a bool, returns true if the bool has a different value than the state of the mbool.
-            inline bool operator!=(bool other) const
+            constexpr bool operator!=(bool other) const
                 { return this->value_.bool_ != other; }
 
             /// Compares two mbools, returns true if their memory matches.
-            inline bool operator==(const mbool& other) const
+            constexpr bool operator==(const mbool& other) const
                 { return this->value_.memory_ == other.value_.memory_; }
             /// Compares two mbools, returns true if they have a different memory value.
-            inline bool operator!=(const mbool& other) const
+            constexpr bool operator!=(const mbool& other) const
                 { return this->value_.memory_ != other.value_.memory_; }
 
             /// Returns the inverted state of the bool (doesn't change the internal state).
-            inline bool operator!() const
+            constexpr bool operator!() const
                 { return (!this->value_.bool_); }
 
@@ -111 +110 @@
             union
             {
+                unsigned char memory_;  ///< The memory of the mbool, counts the state-changes (and the first bit represents also the boolean value)
                 bool bool_ : 1;         ///< The boolean state of the mbool, is located on the first bit of the memory variable
-                unsigned char memory_;  ///< The memory of the mbool, counts the state-changes (and the first bit represents also the boolean value)
             } value_;                   ///< A union containing the state and the memory of the mbool
     };

code/trunk/src/libraries/util/tribool.h

@@ -10 +10 @@
 // so that (dontcare == dontcare).
 // Also removed all logic operators except for == and !=
+// Added C++11 constexpr
 
 
@@ -22 +23 @@
  * The type of the 'dontcare' keyword.
  */
-struct dontcare_keyword_t { };
+struct dontcare_keyword_t {};
 
 /**
  * \brief Keyword for the dontcare tribool value
  */
-const dontcare_keyword_t dontcare = dontcare_keyword_t();
+constexpr dontcare_keyword_t dontcare = dontcare_keyword_t();
 
 /**
@@ -43 +44 @@
    * \throws nothrow
    */
-  tribool() : value(false_value) {}
+  constexpr tribool() : value(false_value) {}
 
   /**
@@ -51 +52 @@
    * \throws nothrow
    */
-  tribool(bool value) : value(value? true_value : false_value) {}
+  constexpr tribool(bool value) : value(value? true_value : false_value) {}
 
   /**
@@ -58 +59 @@
    * \throws nothrow
    */
-  tribool(dontcare_keyword_t) : value(dontcare_value) {}
+  constexpr tribool(dontcare_keyword_t) : value(dontcare_value) {}
 
   /**
@@ -66 +67 @@
    * \throws nothrow
    */
-  inline bool operator==(tribool y)
+  constexpr bool operator==(tribool y) const
   {
     return (this->value == y.value);
@@ -74 +75 @@
    * \overload
    */
-  inline bool operator==(bool y) { return (*this) == tribool(y); }
+  constexpr bool operator==(bool y) const { return (*this) == tribool(y); }
 
   /**
    * \overload
    */
-  inline bool operator==(dontcare_keyword_t)
+  constexpr bool operator==(dontcare_keyword_t) const
   { return tribool(dontcare) == (*this); }
 
@@ -88 +89 @@
    * \throws nothrow
    */
-  inline bool operator!=(tribool y)
+  constexpr bool operator!=(tribool y) const
   {
     return !((*this) == y);
@@ -96 +97 @@
    * \overload
    */
-  inline bool operator!=(bool y) { return (*this) != tribool(y); }
+  constexpr bool operator!=(bool y) const { return (*this) != tribool(y); }
 
   /**
    * \overload
    */
-  inline bool operator!=(dontcare_keyword_t)
+  constexpr bool operator!=(dontcare_keyword_t) const
   { return (*this) != tribool(dontcare); }
 
@@ -114 +115 @@
  * \overload
  */
-inline bool operator==(bool x, tribool y) { return tribool(x) == y; }
+constexpr bool operator==(bool x, tribool y) { return tribool(x) == y; }
 
 /**
  * \overload
  */
-inline bool operator==(dontcare_keyword_t, tribool x)
+constexpr bool operator==(dontcare_keyword_t, tribool x)
 { return tribool(dontcare) == x; }
 
@@ -125 +126 @@
  * \overload
  */
-inline bool operator!=(bool x, tribool y) { return tribool(x) != y; }
+constexpr bool operator!=(bool x, tribool y) { return tribool(x) != y; }
 
 /**
  * \overload
  */
-inline bool operator!=(dontcare_keyword_t, tribool x)
+constexpr bool operator!=(dontcare_keyword_t, tribool x)
 { return tribool(dontcare) != x; }