tb_dynamic_structure.h

#ifndef _TurtleBrains_DynamicStructure_h_
#define _TurtleBrains_DynamicStructure_h_

#include "tb_string.h"
#include "tb_types.h"

#include <cmath>
#include <vector>
#include <map>
#include <string>
#include <limits>

namespace TurtleBrains
{
    //This is here to get around an issue where max is preprocessor defined in WinDef.h as comparing two value and returning
    //the greater of the two, which prevented the call to numeric_limits<type>::max(). Calling maximum_value as a work-around.
#if defined(min)
    #define tb_min_was_defined
    #undef min
#endif /* min */
#if defined(max)
    #define tb_max_was_defined
    #undef max
#endif /* max */

    template <typename Type> Type MinimumValue(void)
    {
        return std::numeric_limits<Type>::min();
    }
    template <typename Type> Type MaximumValue(void)
    {
        return std::numeric_limits<Type>::max();
    }

#if defined(tb_min_was_defined)
    #define min(a,b) ((a) < (b)) ? (a) : (b)
#endif /* tb_min_was_defined */
#if defined(tb_max_was_defined)
    #define max(a, b) ((a) < (b)) ? (b) : (a)
#endif /* tb_max_was_defined */

    namespace Core
    {

        class DynamicStructure
        {
        public:
            typedef std::vector<DynamicStructure> ArrayContainer;

            typedef std::map<tbCore::tbString, DynamicStructure> StructureContainer;

            DynamicStructure(void);

            DynamicStructure(const int& integerValue);
            DynamicStructure(const tbCore::int64& integerValue);

            DynamicStructure(const float& floatValue);

            DynamicStructure(const bool& booleanValue);

            DynamicStructure(const tbCore::tbString& stringValue);

            DynamicStructure(const DynamicStructure& other);

            DynamicStructure& operator=(const DynamicStructure& other);

            ~DynamicStructure(void);


            bool IsNil(void) const;

            bool IsArray(void) const;

            bool IsStructure(void) const;

            bool IsInteger(void) const;

            bool IsFloat(void) const;

            bool IsBoolean(void) const;

            bool IsString(void) const;


            tbCore::int64 AsInteger(bool implicitConversion = kImplicitConversions) const;

            // template <typename Type> typename std::enable_if<std::is_unsigned<Type>::value, Type>::type          
            // AsRangedInteger(const tbCore::tbString& errorMessage,
            //  const Type minimumValue = MinimumValue<Type>(), const Type maximumValue = MaximumValue<Type>(),
            //  bool implicitConversion = kImplicitConversions) const
            // {
            //  const tbCore::int64 intValue = AsInteger(implicitConversion);

            //  tb_error_if(std::is_unsigned<Type>::value && intValue < 0, "%s (Expected _value(%d) to be greater than 0 for unsigned ranges.",
            //      errorMessage.c_str(), intValue);

            //  //int32 intValue = -1   :  0x0001FFFF  //131k

            //  //uint16  min 0         :  0x00000000
            //  //uint16  max 65        :  0x0000FFFF


            //  //int64 value  0x00000000-FFFFFFFF
            //  //int64 min    0x00000000-00000000
            //  //int64 max    0x00000000-FFFFFFFF

            //  //int32 to uint32 65xxx :  0xFFFFFFFF
                

            //  tb_error_if(static_cast<Type>(intValue) < (minimumValue) || static_cast<Type>(intValue) > (maximumValue),
            //      "%s (Expected: %d <= _value(%d)_ <= %d", errorMessage.c_str(), minimumValue, intValue, maximumValue);
            //  return static_cast<Type>(intValue);
            // }
            template <typename Type> Type AsRangedInteger(const tbCore::tbString& errorMessage,
                const Type minimumValue = MinimumValue<Type>(), const Type maximumValue = MaximumValue<Type>(),
                bool implicitConversion = kImplicitConversions) const
            {
                const tbCore::int64 intValue = AsInteger(implicitConversion);

                if (std::is_unsigned<Type>::value)
                {   //If type is unsigned, ensure it is not less than 0, then cast to an unsigned to compare vs other unsigned values.
                    tb_error_if(std::is_unsigned<Type>::value && intValue < 0, "%s (Expected _value(%d) to be greater than 0 for unsigned ranges.",
                        errorMessage.c_str(), intValue);
                    tb_error_if(static_cast<uint64>(intValue) < minimumValue || static_cast<uint64>(intValue) > maximumValue,
                        "%s (Expected: %d <= _value(%d)_ <= %d", errorMessage.c_str(), minimumValue, intValue, maximumValue);
                }
                else
                {
                    tb_error_if(intValue < static_cast<int64>(minimumValue) ||intValue > static_cast<int64>(maximumValue),
                        "%s (Expected: %d <= _value(%d)_ <= %d", errorMessage.c_str(), minimumValue, intValue, maximumValue);
                }

                return static_cast<Type>(intValue);
            }

            float AsFloat(bool implicitConversion = kImplicitConversions) const;

            bool AsBoolean(bool implicitConversion = kImplicitConversions) const;

            tbCore::tbString AsString(bool implicitConversion = kImplicitConversions) const;

            //
            //  TODO: TIM: Planning: Do we want to support this?  If so implement and document.
            //  @note Cannot implicitly convert to a string, will assert if type is not a string.
            //
            //const tbCore::tbString& AsStringRef(void) const;


            tbCore::int64 AsIntegerWithDefault(const tbCore::int64& defaultValue, bool implicitConversion = true) const;

            template <typename Type> Type AsRangedIntegerWithDefault(const Type& defaultValue, const tbCore::tbString& errorMessage,
                const Type minimumValue = MinimumValue<Type>(), const Type maximumValue = MaximumValue<Type>()) const
            {
                const tbCore::int64 intValue = AsIntegerWithDefault(defaultValue);

                if (std::is_unsigned<Type>::value)
                {   //If type is unsigned, ensure it is not less than 0, then cast to an unsigned to compare vs other unsigned values.
                    tb_error_if(std::is_unsigned<Type>::value && intValue < 0, "%s (Expected _value(%d) to be greater than 0 for unsigned ranges.",
                        errorMessage.c_str(), intValue);
                    tb_error_if(static_cast<uint64>(intValue) < minimumValue || static_cast<uint64>(intValue) > maximumValue,
                        "%s (Expected: %d <= _value(%d)_ <= %d", errorMessage.c_str(), minimumValue, intValue, maximumValue);
                }
                else
                {
                    tb_error_if(intValue < static_cast<int64>(minimumValue) ||intValue > static_cast<int64>(maximumValue),
                        "%s (Expected: %d <= _value(%d)_ <= %d", errorMessage.c_str(), minimumValue, intValue, maximumValue);
                }

                return static_cast<Type>(intValue);
            }

            float AsFloatWithDefault(const float defaultValue, bool implicitConversion = true) const;

            bool AsBooleanWithDefault(const bool defaultValue, bool implicitConversion = true) const;

            tbCore::tbString AsStringWithDefault(const tbCore::tbString& defaultValue, bool implicitConversion = true) const;


            void SetValue(const int& integerValue, bool implicitTypeChange = kImplicitTypeChange);
            void SetValue(const tbCore::int64& integerValue, bool implicitTypeChange = kImplicitTypeChange);

            void SetValue(const float& floatValue, bool implicitTypeChange = kImplicitTypeChange);

            void SetValue(const bool& booleanValue, bool implicitTypeChange = kImplicitTypeChange);

            void SetValue(const tbCore::tbString& stringValue, bool implicitTypeChange = kImplicitTypeChange);

            //-------------------------------------------------------------------------------------------------------//
            //    Used ONLY for Array Values.  Type must be kArrayType or kNilType to PushValue
            //-------------------------------------------------------------------------------------------------------//

            DynamicStructure& PushValue(const DynamicStructure& value);

            const DynamicStructure& GetValue(const size_t& arrayIndex) const;

            DynamicStructure& GetValue(const size_t& arrayIndex);

            const DynamicStructure& operator[](const size_t& arrayIndex) const;

            DynamicStructure& operator[](const size_t& arrayIndex);

            //
            // TODO: TIM: Planning: Do we need to support int too? Teach the user how to use this.
            //
            //const DynamicStructure& operator[](const int& arrayIndex) const;

            //
            // TODO: TIM: Planning: Do wee need to support int too? Teach the user how to use this.
            //
            //DynamicStructure& operator[](const int& arrayIndex);


            //-------------------------------------------------------------------------------------------------------//
            //    Used ONLY for Structure Values.  Type must be kStructureType or kNilType to AddMember
            //-------------------------------------------------------------------------------------------------------//

            DynamicStructure& AddMember(const tbCore::tbString& memberName, const DynamicStructure& memberValue);

            DynamicStructure& SetMember(const tbCore::tbString& memberName, const DynamicStructure& memberValue);

            const DynamicStructure& GetMember(const tbCore::tbString& memberName) const;

            DynamicStructure& GetMember(const tbCore::tbString& memberName);

            const DynamicStructure& operator[](const tbCore::tbString& memberName) const;

            DynamicStructure& operator[](const tbCore::tbString& memberName);

            const DynamicStructure& operator[](const char* const memberName) const;

            DynamicStructure& operator[](const char* const memberName);

            StructureContainer::const_iterator BeginStructure(void) const;

            StructureContainer::const_iterator EndStructure(void) const;

            StructureContainer::iterator BeginStructure(void);

            StructureContainer::iterator EndStructure(void);

            //TODO: TIM: Implementation: (Test) Add a way to iterate over all Members in a structure.

            //-------------------------------------------------------------------------------------------------------//
            //    Used ONLY for Structure or Array Values.
            //-------------------------------------------------------------------------------------------------------//

            size_t size(void) const;

            //Acceptable Inputs:
            //  "engine.pistons[0].isDamaged"
            //const DynamicStructure& FromPath(const tbCore::tbString& path) const;

            operator tbCore::int64() const { return AsInteger(true); }

            operator float() const { return AsFloat(true); }

            operator bool() const { return AsBoolean(true); }

            operator tbCore::tbString() const { return AsString(true); }

            bool operator==(const DynamicStructure& rightSide) const;

            bool operator!=(const DynamicStructure& rightSide) const;

        private:
            void SetToNil(void);

            tbCore::int64 ConvertToInteger(void) const;

            float ConvertToFloat(void) const;

            bool ConvertToBoolean(void) const;

            tbCore::tbString ConvertToString(void) const;

            enum DynamicStructureValueType
            {
                kNilType,       

                kIntegerType,   
                kFloatType,     
                kBooleanType,   
                kStringType,    

                kArrayType,     
                kStructureType, 
            };

//          ///
//          /// TODO: TIM: InternalDoc: This is a TurtleBrains implementation detail, and should be documented as such.
//          ///
//          typedef std::vector<DynamicStructure> ArrayContainer;
//
//          ///
//          /// TODO: TIM: InternalDoc: This is a TurtleBrains implementation detail, and should be documented as such.
//          ///
//          typedef std::map<tbCore::tbString, DynamicStructure> StructureContainer;

            DynamicStructureValueType mValueType;

            union
            {   //Unnamed anonymous union so DynamicStrucure contains the contents as its own members, "this->mRawBytes".
                char mRawBytes[8];     //Reserve 64-bits for whatever types follow.
                tbCore::int64 mInteger;
                bool mBoolean;
                float mFloat;

                tbCore::tbString* mString;
                ArrayContainer* mArray;
                StructureContainer* mStructure;
            };

        public:
            static const DynamicStructure kNullValue;    
            static const tbCore::tbString kNullAsString; 
            static const tbCore::tbString kTrueAsString; 
            static const tbCore::tbString kFalseAsString;
            static const unsigned int kInvalidSize;      
            static const bool kImplicitConversions;      
            static const bool kImplicitTypeChange;       
            static const float kFloatElipson;            
        };


        std::ostream& operator<<(std::ostream& outputStream, const DynamicStructure& data);

        /* Overloads to make the DynamicStructure behave like a built in Integer */
        inline bool operator==(const DynamicStructure& leftSide, const int& rightSide) { return (leftSide.AsInteger() == rightSide) ? true : false; }
        inline bool operator==(const int& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsInteger() == leftSide) ? true : false; }
        inline bool operator!=(const DynamicStructure& leftSide, const int& rightSide) { return (leftSide.AsInteger() != rightSide) ? true : false; }
        inline bool operator!=(const int& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsInteger() != leftSide) ? true : false; }

        inline bool operator==(const DynamicStructure& leftSide, const tbCore::int64& rightSide) { return (leftSide.AsInteger() == rightSide) ? true : false; }
        inline bool operator==(const tbCore::int64& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsInteger() == leftSide) ? true : false; }
        inline bool operator!=(const DynamicStructure& leftSide, const tbCore::int64& rightSide) { return (leftSide.AsInteger() != rightSide) ? true : false; }
        inline bool operator!=(const tbCore::int64& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsInteger() != leftSide) ? true : false; }

        inline bool operator==(const DynamicStructure& leftSide, const float& rightSide) { return (fabs(leftSide.AsFloat() - rightSide) <= DynamicStructure::kFloatElipson)  ? true : false; }
        inline bool operator==(const float& leftSide, const DynamicStructure& rightSide) { return (fabs(rightSide.AsFloat() - leftSide) <= DynamicStructure::kFloatElipson) ? true : false; }
        inline bool operator!=(const DynamicStructure& leftSide, const float& rightSide) { return (fabs(leftSide.AsFloat() - rightSide) > DynamicStructure::kFloatElipson) ? true : false; }
        inline bool operator!=(const float& leftSide, const DynamicStructure& rightSide) { return (fabs(rightSide.AsFloat() - leftSide) > DynamicStructure::kFloatElipson) ? true : false; }

        inline bool operator==(const DynamicStructure& leftSide, const bool& rightSide) { return (leftSide.AsBoolean() == rightSide) ? true : false; }
        inline bool operator==(const bool& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsBoolean() == leftSide) ? true : false; }
        inline bool operator!=(const DynamicStructure& leftSide, const bool& rightSide) { return (leftSide.AsBoolean() != rightSide) ? true : false; }
        inline bool operator!=(const bool& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsBoolean() != leftSide) ? true : false; }

        inline bool operator==(const DynamicStructure& leftSide, const tbCore::tbString& rightSide) { return (leftSide.AsString() == rightSide) ? true : false; }
        inline bool operator==(const tbCore::tbString& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsString() == leftSide) ? true : false; }
        inline bool operator!=(const DynamicStructure& leftSide, const tbCore::tbString& rightSide) { return (leftSide.AsString() != rightSide) ? true : false; }
        inline bool operator!=(const tbCore::tbString& leftSide, const DynamicStructure& rightSide) { return (rightSide.AsString() != leftSide) ? true : false; }


    };  /* namespace Core */
};  /* namespace TurtleBrains */

namespace tbCore = TurtleBrains::Core;

#endif /* _TurtleBrains_DynamicStructure_h_ */