VariableReference.h

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: VariableReference
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/Vector.h>
#include <NDEVR/ObjectInfo.h>
#include <NDEVR/TypeInfo.h>
#include <NDEVR/Angle.h>
namespace NDEVR
{
    template<class t_type_a, class t_type_b>
    void assign(t_type_a& a, const t_type_b& b)
    {
        a = cast<t_type_a>(b);
    }
    template<class t_type_a>
    void assign(t_type_a& a, const t_type_a& b)
    {
        a = b;
    }
    template<uint01 t_dim_a, class t_type_a, uint01 t_dim_b, class t_type_b>
    void assign(Vector<t_dim_a, t_type_a>& a, const Vector<t_dim_b, t_type_b>& b)
    {
        a = b.template as<t_dim_a, t_type_a>();
    }
    template<class t_type_a, uint01 t_dim_b, class t_type_b>
    void assign(t_type_a& a, const Vector<t_dim_b, t_type_b>& b)
    {
        a = b[0];
    }
    template<class t_type_a>
    void assign(t_type_a& a, const char* b)
    {
        a = assign<t_type_a>(b);
    }
 
    template<uint01 t_dim_a, class t_type_a, uint01 t_dim_b, class t_type_b>
    void assign(Vector<t_dim_a, t_type_a>& a, const Vector<t_dim_b, t_type_b>& b, uint01 dim)
    {
        a[dim] = b[dim];
    }
 
    template<class t_type_a, uint01 t_dim_b, class t_type_b>
    void assign(t_type_a& a, const Vector<t_dim_b, t_type_b>& b, uint01 dim)
    {
        a = b[dim];
    }
    /**--------------------------------------------------------------------------------------------------
    \brief An optimized class for storing a reference to a variable of some type up to 8 bytes in size
        without ownership or allocations on the stack.
    **/
    class VariableReference
    {
    private:
        union t_pointer
        {
            uint01* _uint01;
            uint02* _uint02;
            uint04* _uint04;
            uint08* _uint08;
 
            sint01* _sint01;
            sint02* _sint02;
            sint04* _sint04;
            sint08* _sint08;
 
            fltp04* _fltp04;
            fltp08* _fltp08;
 
            Angle<sint04>* _angles8;
            Angle<fltp08>* _anglef8;
            char* _char;
        };
    public:
        template<class t_type>
        constexpr VariableReference(t_type& value)
            : m_pointer(reinterpret_cast<t_pointer*>(&value))
        {
            fillInfoTable(ObjectInfo<t_type>(), 0);
        }
        template<class t_object_type>
        void fillInfoTable(const ObjectInfo<t_object_type>&, uint01 level)
        {
            m_bits[level] = GetTypeInfo<t_object_type>();
            if (ObjectInfo<t_object_type>::Vector)
            {
                fillInfoTable(ObjectInfo<t_object_type>::VectorSub(), level + 1);
            }
        }
        VariableReference(const VariableReference& reference)
            : m_pointer(reference.m_pointer)
        {
            memcpy(m_bits, reference.m_bits, sizeof(m_bits));
        }
        
        template<class t_type>
        constexpr void set(const t_type& value)
        {
            m_flag(m_bits, value);
        }
        template<class t_type>
        constexpr VariableReference& operator=(const t_type& b)
        {
            m_flag(m_bits, b);
            return *this;
        };
        constexpr VariableReference& operator=(const VariableReference&)
        {
            return *this;
        };
        template<class t_type>
        constexpr bool operator==(const t_type& b) const
        {
            return get<t_type>() == b;
        };
        template<class t_type>
        constexpr bool operator!=(const t_type& b) const
        {
            return get<t_type>() != b;
        };
        template<class t_type>
        constexpr operator t_type() const
        {
            return get<t_type>();
        }
        template<class t_type>
        t_type get() const
        {
            t_type value;
            get<t_type>(value, 0, 0);
            return value;
        }
        template<class t_type>
        void get(t_type& value, uint04 level, uint04 index) const
        {
            lib_assert(m_bits->vector_size != 0, "Not yet ready");
            getSingle(value, level, index);
        }
 
        
        template<class t_type>
        void getSingle(t_type& value, uint04 level, uint04 index) const
        {
            if (m_bits[level].is_number)
            {
                if (m_bits[level].is_unsigned)
                {
                    switch (m_bits[level].byte_size)
                    {
                    case 1: assign(value, *(m_pointer->_uint01 + index)); break;
                    case 2: assign(value, *(m_pointer->_uint02 + index)); break;
                    case 4: assign(value, *(m_pointer->_uint04 + index)); break;
                    case 8: assign(value, *(m_pointer->_uint08 + index)); break;
                    }
                }
                else
                {
                    if (m_bits[level].is_float)
                    {
                        switch (m_bits[level].byte_size)
                        {
                        case 4: assign(value, *(m_pointer->_fltp04 + index)); break;
                        case 8: assign(value, *(m_pointer->_fltp08 + index)); break;
                        }
                    }
                    else
                    {
                        switch (m_bits[level].byte_size)
                        {
                        case 1: assign(value, *(m_pointer->_sint01 + index)); break;
                        case 2: assign(value, *(m_pointer->_sint02 + index)); break;
                        case 4: assign(value, *(m_pointer->_sint04 + index)); break;
                        case 8: assign(value, *(m_pointer->_sint08 + index)); break;
                        }
                    }
                }
            }
            else if (m_bits[level].is_string)
            {
                assign(value, (m_pointer->_char + index));
            }
        }
        
    private:
        TypeInfo m_bits[8];
        t_pointer* const m_pointer;
    };
};