tb_dynamic_structure.h

#ifndef _TurtleBrains_DynamicStructure_h_
#define _TurtleBrains_DynamicStructure_h_

#include "tb_string.h"

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

namespace TurtleBrains
{
    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 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;


            int AsInteger(bool implicitConversion = kImplicitConversions) const;

            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;


            int AsIntegerWithDefault(const int defaultValue) const;

            float AsFloatWithDefault(const float defaultValue) const;

            bool AsBooleanWithDefault(const bool defaultValue) const;

            tbCore::tbString AsStringWithDefault(const tbCore::tbString& defaultValue) const;


            void SetValue(const int& 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 MagicValue& FromPath(const tbCore::tbString& path) const;

            operator int() const { return AsInteger(true); }

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

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

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

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

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

        private:
            void SetToNil(void);

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

            //Unnamed anonymous union so that DynamicStrucure always starts
            union
            {
                char mRawBytes[8];  //Reserve 64-bits for whatever types follow.
                int 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 kTypeSafeArrays;          
            static const bool kImplicitConversions;     
            static const bool kImplicitTypeChange;      
            static const float kFloatElipson;           
        };


        /* 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 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_ */