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
{
    /**
    \brief An boolean specifc Vector which stores vectors of bools in optimal space.
    t_dims: The number of dimensions used in a vector.
    **/
    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];
        }
        constexpr Vector(const Vector<t_dims, bool>& vector) {…}
        /**
        \brief 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]);
        }
        constexpr Vector(const Vector<t_dims, t_vec_type>& vector) {…}
 
        /**
        \brief 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);
        }
        constexpr explicit Vector(const bool& value) {…}
 
 
        Vector(std::initializer_list<bool> active_list)
        {
            uint04 i = 0;
            for (auto val : active_list)
                (*this)(i++, val);
        }
        Vector(std::initializer_list<bool> active_list) {…}
 
        template<class t_type>
        Vector(std::initializer_list<t_type> active_list)
        {
            for (auto i : active_list)
                (*this)(cast<uint01>(i), true);
        }
        Vector(std::initializer_list<t_type> active_list) {…}
 
        constexpr void operator()(const uint01 dim, bool value)
        {
            m_values[dim / 8](dim % 8, value);
        }
        constexpr void operator()(const uint01 dim, bool value) {…}
 
        /**
        \brief 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);
        }
        constexpr Vector(const bool& x, const bool& y) {…}
 
        /**
        \brief 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.
        \param[in] x -  The bool to set the 0th or X dimension to
        \param[in] y -  The bool to set the 1st or Y dimension to
        \param[in] 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);
        }
        constexpr Vector(const bool& x, const bool& y, const bool& z) {…}
 
        /**
        \brief 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.
        \param[in] x -  The bool to set the 0th or X dimension to
        \param[in] y -  The bool to set the 1st or Y dimension to
        \param[in] z -  The bool to set the 2nd or Z dimension to
        \param[in] 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);
        }
        constexpr Vector(const bool& x, const bool& y, const bool& z, const bool& w) {…}
 
        /**
        \brief Given a container of statically determined array, transforms it to a vector
        \param[in] 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]);
        }
        constexpr explicit Vector(const bool(&vector)[t_dims]) {…}
 
        /**
        \brief Vectors.  Creates a vector where the prefix vector is combined with the suffix boolean.
        \param[in] vector -    The vector.
        \param[in] suffix A boolean to append to the given vector
        **/
        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<t_dims - 1, bool>& vector, const bool& suffix) {…}
 
        /**
        \brief  Creates a vector where the prefix vector is combined with the suffix scalers.
        \param[in] vector -     The vector.
        \param[in] postfix_a -  The postfix a.
        \param[in] 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);
        }
        constexpr Vector(const Vector<getMax(t_dims - 2, 0), bool>& vector, const bool& suffix_a, const bool& suffix_b) {…}
 
        /**
        \brief  Creates a vector where the prefix scaler is combined with the suffix vector.
        \param[in] prefix The prefix.
        \param[in] 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]);
        }
        constexpr Vector(const bool& prefix, const Vector<t_dims - 1, bool>& vector) {…}
        /**
        \brief Vectors. Creates a vector where the prefix scaler values are combined with the suffix vector.
        \param[in] prefix_a -    The first prefix.
        \param[in] prefix_b -    The second prefix.
        \param[in] 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];
        }
        constexpr Vector(const bool& prefix_a, const bool& prefix_b, const Vector<t_dims - 1, bool>& vector) {…}
 
        /**
        \brief As the given extra fill value.
        \param[in] 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;
        }
        constexpr Vector<t_new_dim, t_new_type> as(t_new_type extra_fill_value = 0) const {…}
 
 
 
        /**
        \brief 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.
        \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];
        }
        constexpr operator bool() const {…}
 
 
 
        /**
        \brief Accesses the value of a certain dimension.
        \param[in] 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 BitReference operator[](uint01 dimension_index) {…}
 
 
 
        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 bool operator[](const uint01 dimension_index) const {…}
 
 
        /**
        \brief Assignment operator.
        \param[in] 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;
        }
        constexpr Vector<t_dims, bool>& operator=(const Vector<t_dims, bool>& vector) {…}
 
        /**
        \brief Assignment operator. Setes all values to the value provided in scaler argument.
        \param[in] 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 bool& scaler) {…}
 
        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) {…}
 
        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) {…}
 
        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 {…}
 
        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 {…}
 
        /**
        \brief Number of dimensions in this vector class.
        \returns The total number of dimensions in this vector space.
        **/
 
        static constexpr uint01 NumberOfDimensions() { return t_dims; }
 
        /**
        \brief Returns the type of this class. Useful for using decltype to instantiate a member of this class in a
            static environment.
        \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);
        }
        static constexpr uint04 ByteCount() {…}
    protected:
        /** The values[t dims]. */
        BitFlag m_values[(t_dims / 8) + (t_dims % 8 == 0 ? 0 : 1)];
    };
    class Vector<t_dims, bool> {…};
};