Introduce the JabyEngine namespace to all files

include/PSX/Auxiliary/bits.hpp

@@ -2,53 +2,55 @@
 #define __JABYENGINE_BITS_HPP__
 #include "../jabyengine_defines.h"
 
-namespace bit {
-    template<typename T>
-    static constexpr T set(T raw_value, size_t bit) {
-        return (raw_value | (1 << bit));
-    }
-
-    template<typename T>
-    static constexpr T clear(T raw_value, size_t bit) {
-        return (raw_value & ~(1 << bit));
-    }
-
-    template<typename T>
-    static constexpr bool is_set(T raw_value, size_t bit) {
-        return static_cast<bool>(raw_value & (1 << bit));
-    }
-
-    namespace value {
+namespace JabyEngine {
+    namespace bit {
         template<typename T>
-        static constexpr T crop_value(T raw_value, size_t length) {
-            return (raw_value & ((1 << length) - 1));
+        static constexpr T set(T raw_value, size_t bit) {
+            return (raw_value | (1 << bit));
         }
 
         template<typename T>
-        static constexpr T range_mask(size_t start_bit, size_t length) {
-            return (((1 << length) - 1) << start_bit);
+        static constexpr T clear(T raw_value, size_t bit) {
+            return (raw_value & ~(1 << bit));
         }
 
         template<typename T>
-        static constexpr T clear_normalized(T raw_value, size_t start_bit, size_t length) {
-            return (raw_value & ~range_mask<T>(start_bit, length));
+        static constexpr bool is_set(T raw_value, size_t bit) {
+            return static_cast<bool>(raw_value & (1 << bit));
         }
 
-        template<typename T>
-        static constexpr T set_normalized(T raw_value, T value, size_t start_bit, size_t length) {
-            return (clear_normalized(raw_value, start_bit, length) | (value << start_bit));
+        namespace value {
+            template<typename T>
+            static constexpr T crop_value(T raw_value, size_t length) {
+                return (raw_value & ((1 << length) - 1));
+            }
+
+            template<typename T>
+            static constexpr T range_mask(size_t start_bit, size_t length) {
+                return (((1 << length) - 1) << start_bit);
+            }
+
+            template<typename T>
+            static constexpr T clear_normalized(T raw_value, size_t start_bit, size_t length) {
+                return (raw_value & ~range_mask<T>(start_bit, length));
+            }
+
+            template<typename T>
+            static constexpr T set_normalized(T raw_value, T value, size_t start_bit, size_t length) {
+                return (clear_normalized(raw_value, start_bit, length) | (value << start_bit));
+            }
+
+            template<typename T>
+            static constexpr T get_normalized(T raw_value, size_t start_bit, size_t length) {
+                return (raw_value & range_mask<T>(start_bit, length)) >> start_bit;
+            }
         }
 
-        template<typename T>
-        static constexpr T get_normalized(T raw_value, size_t start_bit, size_t length) {
-            return (raw_value & range_mask<T>(start_bit, length)) >> start_bit;
+        template<typename S, typename T>
+        static constexpr S cast(T value) {
+            return *reinterpret_cast<S*>(&value);
         }
     }
-
-    template<typename S, typename T>
-    static constexpr S cast(T value) {
-        return *reinterpret_cast<S*>(&value);
-    }
 }
 
 #define __start_end_bit2_start_length(start_bit, end_bit) start_bit, (end_bit - start_bit + 1)

include/PSX/Auxiliary/complex_bitmap.hpp

@@ -2,194 +2,196 @@
 #define __JABYENGINE_COMPLEX_BITMAP_HPP__
 #include "bits.hpp"
 
-struct ClearBitValue {
-    size_t bit;
+namespace JabyEngine {
+    struct ClearBitValue {
+        size_t bit;
 
-    constexpr ClearBitValue(size_t bit) : bit(bit) {
-    }
-};
+        constexpr ClearBitValue(size_t bit) : bit(bit) {
+        }
+    };
 
-template<typename T>
-struct Bit {
-    typedef T ValueType;
+    template<typename T>
+    struct Bit {
+        typedef T ValueType;
 
-    size_t value;
+        size_t value;
 
-    constexpr Bit(size_t value) : value(value) {
+        constexpr Bit(size_t value) : value(value) {
+        }
+
+        constexpr operator size_t() const {
+            return this->value;
+        }
+
+        constexpr ClearBitValue operator!() const {
+            return ClearBitValue(this->value);
+        }
+    };
+
+    template<typename T>
+    struct BitRangeValue {
+        T      value;
+        size_t begin;
+        size_t length;
+    };
+
+    template<typename T>
+    struct BitRange {
+        typedef T ValueType;
+
+        size_t begin;
+        size_t length;
+
+        static constexpr BitRange<T> from_to(size_t start, size_t end) {
+            return {start, (end - start + 1)};
+        }
+
+        constexpr BitRangeValue<T> with(T value) const {
+            return {value, this->begin, this->length};
+        }
+    };
+
+    template<typename T>
+    static constexpr __always_inline BitRangeValue<T> operator<<(const BitRange<T>& range, T value) {
+        return BitRangeValue{value, range.begin, range.length};
     }
 
-    constexpr operator size_t() const {
-        return this->value;
-    }
+    template<typename T>
+    class ComplexBitMap {
+    public:
+        T raw;
 
-    constexpr ClearBitValue operator!() const {
-        return ClearBitValue(this->value);
-    }
-};
+    private:
+        template<typename S>
+        constexpr __always_inline ComplexBitMap<T>& set_va(const S& value) {
+            return this->set(value);
+        }
 
-template<typename T>
-struct BitRangeValue {
-    T      value;
-    size_t begin;
-    size_t length;
-};
+        template<typename S, typename...ARGS>
+        constexpr __always_inline ComplexBitMap<T>& set_va(const S& value, const ARGS&...args) {
+            return this->set_va(value).set_va(args...);
+        }
 
-template<typename T>
-struct BitRange {
-    typedef T ValueType;
+    public:
+        template<typename...ARGS>
+        static constexpr __always_inline ComplexBitMap<T> with(ARGS...args) {
+            return ComplexBitMap().set_va(args...);
+        }
 
-    size_t begin;
-    size_t length;
+        //Accesssing bits
+        template<typename S>
+        constexpr ComplexBitMap<T>& set_bit(S bit) {
+            this->raw = bit::set(this->raw, static_cast<size_t>(bit));
+            return *this;
+        }
 
-    static constexpr BitRange<T> from_to(size_t start, size_t end) {
-        return {start, (end - start + 1)};
-    }
+        template<typename S>
+        constexpr void set_bit(S bit) volatile {
+            this->raw = bit::set(this->raw, static_cast<size_t>(bit));
+        }
 
-    constexpr BitRangeValue<T> with(T value) const {
-        return {value, this->begin, this->length};
-    }
-};
+        template<typename S>
+        constexpr ComplexBitMap<T>& clear_bit(S bit) {
+            this->raw = bit::clear(this->raw, static_cast<size_t>(bit));
+            return *this;
+        }
 
-template<typename T>
-static constexpr __always_inline BitRangeValue<T> operator<<(const BitRange<T>& range, T value) {
-    return BitRangeValue{value, range.begin, range.length};
+        template<typename S>
+        constexpr void clear_bit(S bit) volatile {
+            this->raw = bit::clear(this->raw, static_cast<size_t>(bit));
+        }
+
+        template<typename S>
+        constexpr bool is_bit_set(S bit) {
+            return bit::is_set(this->raw, static_cast<size_t>(bit));
+        }
+
+        template<typename S>
+        constexpr bool is_bit_set(S bit) const volatile {
+            return bit::is_set(this->raw, static_cast<size_t>(bit));
+        }
+
+        //Accessing values
+        template<typename S>
+        constexpr ComplexBitMap<T>& set_value(S value, const BitRange<S>& range) {
+            this->raw = bit::value::set_normalized(this->raw, static_cast<T>(value), range.begin, range.length);
+            return *this;
+        }
+
+        template<typename S>
+        constexpr void set_value(S value, const BitRange<S>& range) volatile {
+            this->raw = bit::value::set_normalized(this->raw, static_cast<T>(value), range.begin, range.length);
+        }
+
+        template<typename S>
+        constexpr ComplexBitMap<T>& clear_value(const BitRange<S>& range) {
+            this->raw = bit::value::clear_normalized(this->raw, range.begin, range.length);
+            return *this;
+        }
+
+        template<typename S>
+        constexpr void clear_value(const BitRange<S>& range) volatile {
+            this->raw = bit::value::clear_normalized(this->raw, range.begin, range.length);
+        }
+
+        template<typename S>
+        constexpr S get_value(const BitRange<S>& range) const {
+            return static_cast<S>(bit::value::get_normalized(this->raw, range.begin, range.length));
+        }
+
+        template<typename S>
+        constexpr S get_value(const BitRange<S>& range) const volatile {
+            return static_cast<S>(bit::value::get_normalized(this->raw, range.begin, range.length));
+        }
+
+        //For easier checking
+        constexpr bool is(Bit<T> bit) const {
+            return ComplexBitMap::is_bit_set(bit);
+        }
+
+        constexpr bool is(Bit<T> bit) const volatile {
+            return ComplexBitMap::is_bit_set(bit);
+        }
+
+        // For easier constructing
+        template<typename S>
+        constexpr __always_inline ComplexBitMap<T>& set(const BitRange<S>& range, T value) {
+            this->set_value(value, range);
+            return *this;
+        }
+
+        template<typename S>
+        constexpr __always_inline ComplexBitMap<T>& set(const BitRangeValue<S>& value) {
+            this->set_value(value.value, {value.begin, value.length});
+            return *this;
+        }
+
+        template<typename S>
+        constexpr __always_inline ComplexBitMap<T>& set(const Bit<S>& bit) {
+            this->set_bit(bit.value);
+            return *this;
+        }
+
+        constexpr __always_inline ComplexBitMap<T>& set(const ClearBitValue& value) {
+            this->clear_bit(value.bit);
+            return *this;
+        }
+
+        constexpr __always_inline ComplexBitMap<T>& operator|(const BitRangeValue<T>& value) {
+            this->set_value(value.value, value.range);
+            return *this;
+        }
+
+        constexpr __always_inline ComplexBitMap<T>& operator|(const Bit<T>& bit) {
+            this->set_bit(bit.value);
+            return *this;
+        }
+
+        constexpr __always_inline ComplexBitMap<T>& operator|(const ClearBitValue& value) {
+            this->clear_bit(value.bit);
+            return *this;
+        }
+    };
 }
 
-template<typename T>
-class ComplexBitMap {
-public:
-    T raw;
-
-private:
-    template<typename S>
-    constexpr __always_inline ComplexBitMap<T>& set_va(const S& value) {
-        return this->set(value);
-    }
-
-    template<typename S, typename...ARGS>
-    constexpr __always_inline ComplexBitMap<T>& set_va(const S& value, const ARGS&...args) {
-        return this->set_va(value).set_va(args...);
-    }
-
-public:
-    template<typename...ARGS>
-    static constexpr __always_inline ComplexBitMap<T> with(ARGS...args) {
-        return ComplexBitMap().set_va(args...);
-    }
-
-    //Accesssing bits
-    template<typename S>
-    constexpr ComplexBitMap<T>& set_bit(S bit) {
-        this->raw = bit::set(this->raw, static_cast<size_t>(bit));
-        return *this;
-    }
-
-    template<typename S>
-    constexpr void set_bit(S bit) volatile {
-        this->raw = bit::set(this->raw, static_cast<size_t>(bit));
-    }
-
-    template<typename S>
-    constexpr ComplexBitMap<T>& clear_bit(S bit) {
-        this->raw = bit::clear(this->raw, static_cast<size_t>(bit));
-        return *this;
-    }
-
-    template<typename S>
-    constexpr void clear_bit(S bit) volatile {
-        this->raw = bit::clear(this->raw, static_cast<size_t>(bit));
-    }
-
-    template<typename S>
-    constexpr bool is_bit_set(S bit) {
-        return bit::is_set(this->raw, static_cast<size_t>(bit));
-    }
-
-    template<typename S>
-    constexpr bool is_bit_set(S bit) const volatile {
-        return bit::is_set(this->raw, static_cast<size_t>(bit));
-    }
-
-    //Accessing values
-    template<typename S>
-    constexpr ComplexBitMap<T>& set_value(S value, const BitRange<S>& range) {
-        this->raw = bit::value::set_normalized(this->raw, static_cast<T>(value), range.begin, range.length);
-        return *this;
-    }
-
-    template<typename S>
-    constexpr void set_value(S value, const BitRange<S>& range) volatile {
-        this->raw = bit::value::set_normalized(this->raw, static_cast<T>(value), range.begin, range.length);
-    }
-
-    template<typename S>
-    constexpr ComplexBitMap<T>& clear_value(const BitRange<S>& range) {
-        this->raw = bit::value::clear_normalized(this->raw, range.begin, range.length);
-        return *this;
-    }
-
-    template<typename S>
-    constexpr void clear_value(const BitRange<S>& range) volatile {
-        this->raw = bit::value::clear_normalized(this->raw, range.begin, range.length);
-    }
-
-    template<typename S>
-    constexpr S get_value(const BitRange<S>& range) const {
-        return static_cast<S>(bit::value::get_normalized(this->raw, range.begin, range.length));
-    }
-
-    template<typename S>
-    constexpr S get_value(const BitRange<S>& range) const volatile {
-        return static_cast<S>(bit::value::get_normalized(this->raw, range.begin, range.length));
-    }
-
-    //For easier checking
-    constexpr bool is(Bit<T> bit) const {
-        return ComplexBitMap::is_bit_set(bit);
-    }
-
-    constexpr bool is(Bit<T> bit) const volatile {
-        return ComplexBitMap::is_bit_set(bit);
-    }
-
-    // For easier constructing
-    template<typename S>
-    constexpr __always_inline ComplexBitMap<T>& set(const BitRange<S>& range, T value) {
-        this->set_value(value, range);
-        return *this;
-    }
-
-    template<typename S>
-    constexpr __always_inline ComplexBitMap<T>& set(const BitRangeValue<S>& value) {
-        this->set_value(value.value, {value.begin, value.length});
-        return *this;
-    }
-
-    template<typename S>
-    constexpr __always_inline ComplexBitMap<T>& set(const Bit<S>& bit) {
-        this->set_bit(bit.value);
-        return *this;
-    }
-
-    constexpr __always_inline ComplexBitMap<T>& set(const ClearBitValue& value) {
-        this->clear_bit(value.bit);
-        return *this;
-    }
-
-    constexpr __always_inline ComplexBitMap<T>& operator|(const BitRangeValue<T>& value) {
-        this->set_value(value.value, value.range);
-        return *this;
-    }
-
-    constexpr __always_inline ComplexBitMap<T>& operator|(const Bit<T>& bit) {
-        this->set_bit(bit.value);
-        return *this;
-    }
-
-    constexpr __always_inline ComplexBitMap<T>& operator|(const ClearBitValue& value) {
-        this->clear_bit(value.bit);
-        return *this;
-    }
-};
-
 #endif //!__JABYENGINE_COMPLEX_BITMAP_HPP__