tb_dynamic_structure.hpp

#ifndef TurtleBrains_DynamicStructure_hpp
#define TurtleBrains_DynamicStructure_hpp

#include <turtle_brains/core/tb_string.hpp>
#include <turtle_brains/core/tb_types.hpp>

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

namespace TurtleBrains
{
    namespace Core
    {
        class DynamicStructure;

        //Ultimately these would be in FileUtilities and specializations of the ReadBinary/WriteBinary template functions.
        //That said trying to declare a friend of a template specialization is bonkers.
        void WriteBinary(const tbCore::DynamicStructure& data, std::ostream& output);
        tbCore::DynamicStructure ReadBinary(std::istream& input);

        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 size_t& intergerValue);

            DynamicStructure(const float& floatValue);

            DynamicStructure(const bool& booleanValue);

            DynamicStructure(const tbCore::tbString& stringValue);

            DynamicStructure(const char* stringValue);

            template<typename Type> DynamicStructure(std::initializer_list<const Type> arguments) :
                mValueType(kNilType),
                mInteger(0)
            {
                for (auto value : arguments)
                {
                    PushValue(value);
                }
            }

            DynamicStructure(std::initializer_list<std::pair<const tbCore::tbString, const DynamicStructure>> arguments);

            DynamicStructure(const DynamicStructure& other);

            DynamicStructure(DynamicStructure&& other);

            DynamicStructure& operator=(const DynamicStructure& other);

            DynamicStructure& operator=(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 = "Out of Range",
                const Type minimumValue = std::numeric_limits<Type>::min(), const Type maximumValue = std::numeric_limits<Type>::max(),
                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(intValue < 0, "%s (Expected _value(%d) to be greater than 0 for unsigned ranges.",
                        errorMessage.c_str(), intValue);
                    tb_error_if(minimumValue < 0, "tbExternalError: Expected minimumValue of unsigned type to be greater than equal to 0.");
                    tb_error_if(maximumValue < 0, "tbExternalError: Expected maximumValue of unsigned type to be greater than equal to 0.");
                    tb_error_if(static_cast<uint64>(intValue) < static_cast<uint64>(minimumValue) || static_cast<uint64>(intValue) > static_cast<uint64>(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);
            }

            template <typename Type> Type AsRangedIntegerWithDefault(const tbCore::tbString& errorMessage, const Type& defaultValue,
                const Type minimumValue = std::numeric_limits<Type>::min(), const Type maximumValue = std::numeric_limits<Type>::max(),
                bool implicitConversion = kImplicitConversions) const
            {
                if (true == IsNil() || (false == implicitConversion && false == IsInteger()))
                {
                    return defaultValue;
                }

                return AsRangedInteger(errorMessage, minimumValue, maximumValue, implicitConversion);
            }

            float AsFloat(bool implicitConversion = kImplicitConversions) const;

            bool AsBoolean(bool implicitConversion = kImplicitConversions) const;

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

            //
            // TODO: TurtleBrains: 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 = std::numeric_limits<Type>::min(), const Type maximumValue = std::numeric_limits<Type>::max()) 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);

            //-------------------------------------------------------------------------------------------------------//
            //    Input and Output
            //-------------------------------------------------------------------------------------------------------//

            //void WriteBinary(std::ofstream& outputFile) const;

            //void ReadBinary(std::ifstream& inputFile);

            friend void WriteBinary(const tbCore::DynamicStructure& data, std::ostream& output);
            friend tbCore::DynamicStructure ReadBinary(std::istream& input);

            //-------------------------------------------------------------------------------------------------------//
            //  Ignore the mess of private API:
            //-------------------------------------------------------------------------------------------------------//
        private:
            const tbCore::DynamicStructure& LookupByNameOrIndex(tbCore::uint64 index) const;
            tbCore::DynamicStructure& LookupByNameOrIndex(tbCore::uint64 index);
            const tbCore::DynamicStructure& LookupByNameOrIndex(const tbCore::tbString& memberName) const;
            tbCore::DynamicStructure& LookupByNameOrIndex(const tbCore::tbString& memberName);
            const tbCore::DynamicStructure& LookupByNameOrIndex(const char* memberName) const;
            tbCore::DynamicStructure& LookupByNameOrIndex(const char* memberName);

        public:
            template<typename Type> const DynamicStructure& operator[](const Type& nameOrIndex) const { return LookupByNameOrIndex(nameOrIndex); }

            template<typename Type> DynamicStructure& operator[](const Type& nameOrIndex) { return LookupByNameOrIndex(nameOrIndex); }

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

            DynamicStructure& PushValue(const DynamicStructure& value);

            const DynamicStructure& GetValue(const tbCore::uint64& arrayIndex) const;

            DynamicStructure& GetValue(const tbCore::uint64& arrayIndex);

            size_t ArraySize(void) const;

            size_t size(void) const;

            ArrayContainer::const_iterator BeginArray(void) const;

            ArrayContainer::iterator BeginArray(void);

            ArrayContainer::const_iterator begin(void) const;

            ArrayContainer::iterator begin(void);

            ArrayContainer::const_iterator EndArray(void) const;

            ArrayContainer::iterator EndArray(void);

            ArrayContainer::const_iterator end(void) const;

            ArrayContainer::iterator end(void);

            const ArrayContainer& AsArray(void) const;

            ArrayContainer& AsArray(void);

            //-------------------------------------------------------------------------------------------------------//
            //    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);

            size_t StructureSize(void) const;

            StructureContainer::const_iterator BeginStructure(void) const;

            StructureContainer::iterator BeginStructure(void);

            StructureContainer::const_iterator EndStructure(void) const;

            StructureContainer::iterator EndStructure(void);

            const StructureContainer& AsStructure(void) const;

            StructureContainer& AsStructure(void);

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

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

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

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

            explicit operator int() const { return AsRangedInteger<int>(); }

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

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

            explicit 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 : tbCore::uint8
            {
                kNilType,       

                kIntegerType,   
                kFloatType,     
                kBooleanType,   
                kStringType,    

                kArrayType,     
                kStructureType, 
            };

            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;            
        };

        inline const tbCore::DynamicStructure& tbCore::DynamicStructure::LookupByNameOrIndex(tbCore::uint64 arrayIndex) const { return GetValue(arrayIndex); }
        inline tbCore::DynamicStructure& tbCore::DynamicStructure::LookupByNameOrIndex(tbCore::uint64 arrayIndex) { return GetValue(arrayIndex); }
        inline const tbCore::DynamicStructure& tbCore::DynamicStructure::LookupByNameOrIndex(const tbCore::tbString& memberName) const { return GetMember(memberName); }
        inline tbCore::DynamicStructure& tbCore::DynamicStructure::LookupByNameOrIndex(const tbCore::tbString& memberName) { return GetMember(memberName); }
        inline const tbCore::DynamicStructure& tbCore::DynamicStructure::LookupByNameOrIndex(const char* memberName) const { return GetMember(memberName); }
        inline tbCore::DynamicStructure& tbCore::DynamicStructure::LookupByNameOrIndex(const char* memberName) { return GetMember(memberName); }

        tbCore::tbString ToJsonString(const tbCore::DynamicStructure& data, bool prettyJson);


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

        //This is actually not _that_ trivial, at least not with how we have implemented the operator<<. So we either
        //changed that format to make this easier, or ignore doing this for now. You can always save ToJsonString and
        //then use tbCore::ParseJson() to get back.
        //std::istream& operator>>(std::istream& inputStream, 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_hpp */