Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/SuperOrxoBros_HS18/src/libraries/util/mbool.h @ 12227

Last change on this file since 12227 was 12177, checked in by siramesh, 6 years ago

Super Orxo Bros Final (Sidharth Ramesh, Nisa Balta, Jeff Ren)

File size: 5.3 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30    @file
31    @ingroup Util
32    @brief Declaration and implementation of the @ref orxonox::mbool class.
33*/
34
35#ifndef _mbool_H__
36#define _mbool_H__
37
38#include "UtilPrereqs.h"
39
40namespace orxonox
41{
42    /**
43        @brief mbool is a small helper class that acts like a bool, but keeps track of the number of its state changes.
44
45        The mbool class acts like a bool, but it has an internal counter that counts
46        the number state changes (i.e. when the bool changes from true to false or
47        back). This is used in the network if a boolean value is synchronized, because
48        if a value changes quickly from false to true and back in the same tick, the
49        clients will never be notified of this action. By using mbool however this
50        behaviour is fixed, which is important for triggers and other objects.
51
52        @note This is efficiently solved by using a union that combines a counter and a
53        boolean bitfield of size 1. The boolean value corresponds always to the first
54        bit of the counter - this means, if the counter is incremented, the boolean state
55        changes. On the other hand, if you want to change the state, you can simply increase
56        the counter.
57    */
58    struct mbool
59    {
60        public:
61            /// Constructor: Creates the mbool and initializes the boolean value (default to false).
62            constexpr mbool(bool value = false) : value_{ static_cast<unsigned char>(value ? 1 : 0) }
63                {}
64            /// Copy-constructor, copies state and memory.
65            constexpr mbool(const mbool& value) : value_{ value.value_.memory_ }
66                {}
67            /// Destructor does nothing but not defining it might create a symbol (class is header only)
68            inline ~mbool() = default;
69
70            /// Assigns a boolean value (and increases the memory value if the value is different to the old value).
71            inline mbool& operator=(bool value)
72                { if (value != this->value_.bool_) { ++this->value_.memory_; } return (*this); }
73            /// Assigns another mbool, copies state and memory.
74            inline mbool& operator=(const mbool& value)
75                { this->value_.memory_ = value.value_.memory_; return (*this); }
76
77            /// Increases the memory which also inverts it's state (++mbool).
78            inline mbool& operator++()
79                { ++this->value_.memory_; return (*this); }
80            /// Increases the memory which also inverts it's state (mbool++).
81            inline mbool operator++(int)
82                { mbool temp = (*this); ++this->value_.memory_; return temp; }
83
84            /// Implicitly converts the mbool to a bool.
85            constexpr operator bool() const
86                { return this->value_.bool_; }
87
88            /// Compares the mbool to a bool, returns true if the bool has the same value as the state of the mbool.
89            constexpr bool operator==(bool other) const
90                { return this->value_.bool_ == other; }
91            /// Compares the mbool to a bool, returns true if the bool has a different value than the state of the mbool.
92            constexpr bool operator!=(bool other) const
93                { return this->value_.bool_ != other; }
94
95            /// Compares two mbools, returns true if their memory matches.
96            constexpr bool operator==(const mbool& other) const
97                { return this->value_.memory_ == other.value_.memory_; }
98            /// Compares two mbools, returns true if they have a different memory value.
99            constexpr bool operator!=(const mbool& other) const
100                { return this->value_.memory_ != other.value_.memory_; }
101
102            /// Returns the inverted state of the bool (doesn't change the internal state).
103            constexpr bool operator!() const
104                { return (!this->value_.bool_); }
105
106            /// Returns the memory value.
107            inline unsigned char& getMemory(){ return value_.memory_; }
108
109        private:
110            union
111            {
112                unsigned char memory_;  ///< The memory of the mbool, counts the state-changes (and the first bit represents also the boolean value)
113                bool bool_ : 1;         ///< The boolean state of the mbool, is located on the first bit of the memory variable
114            } value_;                   ///< A union containing the state and the memory of the mbool
115    };
116}
117
118#endif /* _mbool_H__ */
Note: See TracBrowser for help on using the repository browser.