Index: code/trunk/src/libraries/util/OrxEnum.h
===================================================================
--- code/trunk/src/libraries/util/OrxEnum.h	(revision 11083)
+++ code/trunk/src/libraries/util/OrxEnum.h	(revision 11096)
@@ -61,15 +61,15 @@
     {
         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,8 +77,8 @@
 
 /// 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()
 
Index: code/trunk/src/libraries/util/mbool.h
===================================================================
--- code/trunk/src/libraries/util/mbool.h	(revision 11083)
+++ code/trunk/src/libraries/util/mbool.h	(revision 11096)
@@ -60,12 +60,11 @@
         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,23 +83,23 @@
 
             /// 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,6 +110,6 @@
             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
     };
Index: code/trunk/src/libraries/util/tribool.h
===================================================================
--- code/trunk/src/libraries/util/tribool.h	(revision 11083)
+++ code/trunk/src/libraries/util/tribool.h	(revision 11096)
@@ -10,4 +10,5 @@
 // so that (dontcare == dontcare).
 // Also removed all logic operators except for == and !=
+// Added C++11 constexpr
 
 
@@ -22,10 +23,10 @@
  * 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,5 +44,5 @@
    * \throws nothrow
    */
-  tribool() : value(false_value) {}
+  constexpr tribool() : value(false_value) {}
 
   /**
@@ -51,5 +52,5 @@
    * \throws nothrow
    */
-  tribool(bool value) : value(value? true_value : false_value) {}
+  constexpr tribool(bool value) : value(value? true_value : false_value) {}
 
   /**
@@ -58,5 +59,5 @@
    * \throws nothrow
    */
-  tribool(dontcare_keyword_t) : value(dontcare_value) {}
+  constexpr tribool(dontcare_keyword_t) : value(dontcare_value) {}
 
   /**
@@ -66,5 +67,5 @@
    * \throws nothrow
    */
-  inline bool operator==(tribool y)
+  constexpr bool operator==(tribool y) const
   {
     return (this->value == y.value);
@@ -74,10 +75,10 @@
    * \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,5 +89,5 @@
    * \throws nothrow
    */
-  inline bool operator!=(tribool y)
+  constexpr bool operator!=(tribool y) const
   {
     return !((*this) == y);
@@ -96,10 +97,10 @@
    * \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,10 +115,10 @@
  * \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,10 +126,10 @@
  * \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; }
 
