BoolVector.hpp

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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
{
    /**--------------------------------------------------------------------------------------------------
    Class: Vector<t_dims, bool>
    \brief An boolean specifc Vector which stores vectors of bools in optimal space. 
 
    t_dims: The number of dimensions used in a vector.
 
    Author: Tyler Parke
 
    Date: 2017-09-13
    *-----------------------------------------------------------------------------------------------**/
    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];
        }
        /**--------------------------------------------------------------------------------------------------
                Copy constructor.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        vector -  The vector to copy to this vector.
        *-----------------------------------------------------------------------------------------------**/
        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]);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the value in the passed in scaler
 
        Author: Tyler Parke
 
        Date: 2017-09-13
 
        Parameters:
        scaler -  The bool to set all dimensions to.
        *-----------------------------------------------------------------------------------------------**/
 
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the respective value in the passed in scaler. Note the Vector must
        be 2 dimensions to use this function.
 
        Author: Tyler Parke
 
        Date: 2017-09-13
 
        Parameters:
        x -  The bool to set the 0th or X dimension to
        y -  The bool to set the 1st or Y dimension to
        *-----------------------------------------------------------------------------------------------**/
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the respective value in the passed in scaler. Note the Vector must
        be 3 dimensions to use this function.
 
        Author: Tyler Parke
 
        Date: 2017-09-13
 
        Parameters:
        x -  The bool to set the 0th or X dimension to
        y -  The bool to set the 1st or Y dimension to
        z -  The bool to set the 2nd or Z dimension to
        *-----------------------------------------------------------------------------------------------**/
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets values in each dimension to the respective value in the passed in scaler. Note the Vector must
        be 4 dimensions to use this function.
 
        Author: Tyler Parke
 
        Date: 2017-09-13
 
        Parameters:
        x -  The bool to set the 0th or X dimension to
        y -  The bool to set the 1st or Y dimension to
        z -  The bool to set the 2nd or Z dimension to
        w -  The bool to set the 3rd or W dimension to
        *-----------------------------------------------------------------------------------------------**/
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Given a container of statically determined array, transforms it to a vector
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        vector -  The vector container object.
        *-----------------------------------------------------------------------------------------------**/
        constexpr explicit Vector(const bool(&vector)[t_dims])
        {
            for (uint01 dim = 0; dim < t_dims; dim++)
                m_values[dim / 8](dim % 8, vector[dim]);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Vectors.  Creates a vector where the prefix vector is combined with the suffix scalers.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        vector -    The vector.
        postfix -   The postfix.
        *-----------------------------------------------------------------------------------------------**/
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
        
        Vectors. Creates a vector where the prefix vector is combined with the suffix scalers.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        vector -     The vector.
        postfix_a -  The postfix a.
        postfix_b -  The postfix b.
        *-----------------------------------------------------------------------------------------------**/
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Vectors. Creates a vector where the prefix scaler is combined with the suffix vector.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        prefix -    The prefix.
        vector -    The vector.
        *-----------------------------------------------------------------------------------------------**/
        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]);
        }
        /**--------------------------------------------------------------------------------------------------
                Vectors. Creates a vector where the prefix scaler values are combined with the suffix vector.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        prefix_a -    The first prefix.
        prefix_b -    The second prefix.
        vector -    The vector.
        *-----------------------------------------------------------------------------------------------**/
        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];
        }
 
        /**--------------------------------------------------------------------------------------------------
                As the given extra fill value.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        extra_fill_value -  (Optional) The extra fill value, or value to set dimensions extra that may be
        created when t_new_dim > t_dim.
 
        Returns: A Vector&lt;t_new_dim,t_new_type&gt;
        *-----------------------------------------------------------------------------------------------**/
        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;
        }
 
 
 
        /**--------------------------------------------------------------------------------------------------
                For Single dimensional objects, they may also be considered a scaler, thus allow implicit conversion
        from a vector to a scaler when the dimension of the vector is 1.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Returns: The result of the operation.
        *-----------------------------------------------------------------------------------------------**/
        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];
        }
 
 
 
        /**--------------------------------------------------------------------------------------------------
                Accesses the value of a certain dimension.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        dimension_index -  The dimensional index of the the value we wish to retrieve.
 
        Returns: The value at the given dimension_index.
        *-----------------------------------------------------------------------------------------------**/
 
        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];
        }
 
 
        /**--------------------------------------------------------------------------------------------------
                Assignment operator.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        vector -  The vector to set this vector to.
 
        Returns: A reference of this object (Useful for chaining '=' together).
        *-----------------------------------------------------------------------------------------------**/
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Assignment operator. Setes all values to the value provided in scaler argument.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Parameters:
        scaler -  The scaler to set each dimension to.
 
        Returns: A reference of this object (Useful for chaining '=' together).
        *-----------------------------------------------------------------------------------------------**/
 
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Number of dimensions in this vector class.
 
        Author: Tyler Parke
 
        Date: 2017-11-13
 
        Returns: The total number of dimensions in this vector space.
        *-----------------------------------------------------------------------------------------------**/
 
        static constexpr uint01 NumberOfDimensions() { return t_dims; }
 
        /**--------------------------------------------------------------------------------------------------
                Returns the type of this class. Useful for using decltype to instantiate a member of this class in a
        static environment.
 
        Author: Tyler Parke
 
        Date: 2020-05-03
 
        Returns: The type of this class. Object is inavlid outside of decl.
        *-----------------------------------------------------------------------------------------------**/
        constexpr static bool Type() { return bool(); }
 
        static constexpr uint04 ByteCount()
        {
            return (t_dims / 8) + (t_dims % 8 == 0 ? 0 : 1);
        }
    protected:
        /** The values[t dims]. */
        BitFlag m_values[(t_dims / 8) + (t_dims % 8 == 0 ? 0 : 1)];
    };
};