BoolVector.hpp

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: BoolVector
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/LibAssert.h>
#include <NDEVR/Vector.h>
#include <NDEVR/BitReference.h>
namespace NDEVR
{
    template<uint01 t_dims>
    class Vector<t_dims, bool>
    {
    public:
        constexpr Vector() = default;
        constexpr Vector(const Vector<t_dims, bool>& vector)
        {
            for (uint01 dim = 0; dim < sizeof(Vector<t_dims, bool>); ++dim)
                m_values[dim] = vector.m_values[dim];
        }
        template<class t_vec_type>
        constexpr Vector(const Vector<t_dims, t_vec_type>& vector)
        {
            for (uint01 dim = 0; dim < t_dims; ++dim)
                m_values[dim] = cast<bool>(vector[dim]);
        }

 
        constexpr explicit Vector(const bool& value)
        {
            for (uint01 dim = 0; dim < ByteCount(); ++dim)
                m_values[dim] = BitFlag(value);
        }
 
 
        Vector(std::initializer_list<bool> active_list)
        {
            uint04 i = 0;
            for (auto val : active_list)
                (*this)(i++, val);
        }
 
        template<class t_type>
        Vector(std::initializer_list<t_type> active_list)
        {
            for (auto i : active_list)
                (*this)(cast<uint01>(i), true);
        }
 
        constexpr void operator()(const uint01 dim, bool value)
        {
            m_values[dim / 8](dim % 8, value);
        }

        constexpr Vector(const bool& x, const bool& y)
        {
            static_assert(t_dims == 2, "Unexpected Number of Dimensions. Vector Size Required: 2");
            m_values[0](X, x);
            m_values[0](Y, y);
        }

        constexpr Vector(const bool& x, const bool& y, const bool& z)
        {
            static_assert(t_dims == 3, "Unexpected Number of Dimensions. Vector Size Required: 3");
            m_values[0](X, x);
            m_values[0](Y, y);
            m_values[0](Z, z);
        }

        constexpr Vector(const bool& x, const bool& y, const bool& z, const bool& w)
        {
            static_assert(t_dims == 4, "Unexpected Number of Dimensions. Vector Size Required: 4");
            m_values[0](X, x);
            m_values[0](Y, y);
            m_values[0](Z, z);
            m_values[0](W, w);
        }

        constexpr explicit Vector(const bool(&vector)[t_dims])
        {
            for (uint01 dim = 0; dim < t_dims; dim++)
                m_values[dim / 8](dim % 8, vector[dim]);
        }

        constexpr Vector(const Vector<t_dims - 1, bool>& vector, const bool& suffix)
        {
            static_assert(t_dims >= 2, "Unexpected Number of Dimensions. Vector Size Required: >= 2");
            for (uint01 dim = 0; dim < t_dims - 1; ++dim)
                m_values[dim / 8](dim % 8, vector[dim]);
            m_values[(t_dims - 1) / 8]((t_dims - 1) % 8, suffix);
        }

        constexpr Vector(const Vector<getMax(t_dims - 2, 0), bool>& vector, const bool& suffix_a, const bool& suffix_b)
        {
            static_assert(t_dims >= 3, "Unexpected Number of Dimensions. Vector Size Required: >= 3");
            for (uint01 dim = 0; dim < t_dims - 2; ++dim)
                m_values[dim / 8](dim % 8, vector[dim]);
            m_values[(t_dims - 2) / 8]((t_dims - 2) % 8, suffix_a);
            m_values[(t_dims - 1) / 8]((t_dims - 1) % 8, suffix_b);
        }

        constexpr Vector(const bool& prefix, const Vector<t_dims - 1, bool>& vector)
        {
            static_assert(t_dims >= 2, "Unexpected Number of Dimensions. Vector Size Required: >= 2");
            m_values[0](0, prefix);
            for (uint01 dim = 1; dim < t_dims; ++dim)
                m_values[dim / 8](dim % 8, vector[dim - 1]);
        }

        constexpr Vector(const bool& prefix_a, const bool& prefix_b, const Vector<t_dims - 1, bool>& vector)
        {
            static_assert(t_dims >= 2, "Unexpected Number of Dimensions. Vector Size Required: of at least 1");
            m_values[X] = prefix_a;
            m_values[Y] = prefix_b;
            for (uint01 dim = Z; dim < t_dims; ++dim)
                m_values[dim] = vector[dim - 1];
        }

        template<uint01 t_new_dim, class t_new_type>
        constexpr Vector<t_new_dim, t_new_type> as(t_new_type extra_fill_value = 0) const
        {
            Vector<t_new_dim, t_new_type> vec;
            uint01 dim = 0;
            const uint01 min = getMin(t_new_dim, t_dims);
            for (; dim < min; dim++)
                vec[dim] = cast<t_new_type>(m_values[dim / 8][dim % 8]);
            for (; dim < t_new_dim; dim++)
                vec[dim] = extra_fill_value;
            return vec;
        }
 
 

        constexpr operator bool() const
        {
            static_assert(t_dims == 1, "Cannot auto-convert from vector to scaler unless dimension of vector is 1.");
            return m_values[0][0];
        }
 
 

 
        constexpr BitReference operator[](uint01 dimension_index)
        {
            lib_assert(dimension_index < t_dims, "Dimension requested Exceeded maximum vector dimension");
            return BitReference(m_values[dimension_index / 8], dimension_index % 8);
        }
 
 
 
        constexpr bool operator[](const uint01 dimension_index) const
        {
            lib_assert(dimension_index < t_dims, "Dimension requested Exceeded maximum vector dimension");
            return m_values[dimension_index / 8][dimension_index % 8];
        }
 

 
        constexpr Vector<t_dims, bool>& operator=(const Vector<t_dims, bool>& vector)
        {
            for (uint01 dim = 0; dim < ByteCount(); ++dim)
                m_values[dim] = vector.m_values[dim];
            return *this;
        }

        constexpr Vector<t_dims, bool>& operator=(const bool& scaler)
        {
            
            for (uint01 dim = 0; dim < ByteCount(); ++dim)
                m_values[dim] = BitFlag(scaler);
            return *this;
        }
 
        constexpr Vector<t_dims, bool>& operator&=(const Vector<t_dims, bool>& vector)
        {
            for (uint01 dim = 0; dim < ByteCount(); ++dim)
                m_values[dim] &= vector.m_values[dim];
            return *this;
        }
 
        constexpr Vector<t_dims, bool>& operator|=(const Vector<t_dims, bool>& vector)
        {
            for (uint01 dim = 0; dim < ByteCount(); ++dim)
                m_values[dim] |= vector.m_values[dim];
            return *this;
        }
 
        constexpr Vector<t_dims, bool> operator&(const Vector<t_dims, bool>& vector) const
        {
            Vector<t_dims, bool> output(0);
            for (uint01 dim = 0; dim < ByteCount(); ++dim)
                output[dim] = m_values[dim] & vector.m_values[dim];
            return output;
        }
 
        constexpr Vector<t_dims, bool> operator|(const Vector<t_dims, bool>& vector) const
        {
            Vector<t_dims, bool> output(0);
            for (uint01 dim = 0; dim < ByteCount(); ++dim)
                output[dim] = m_values[dim] | vector.m_values[dim];
            return output;
        }

 
        static constexpr uint01 NumberOfDimensions() { return t_dims; }

        constexpr static bool Type() { return bool(); }
 
        static constexpr uint04 ByteCount()
        {
            return (t_dims / 8) + (t_dims % 8 == 0 ? 0 : 1);
        }
    protected:
        BitFlag m_values[(t_dims / 8) + (t_dims % 8 == 0 ? 0 : 1)];
    };
};