path.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "typeinfo.h"
 
// External Includes
#include <utility/dllexport.h>
#include <string>
#include <assert.h>
 
namespace nap
{
    namespace rtti
    {
        class Object;
        class ResolvedPath;
 
        class NAPAPI PathElement
        {
        public:
            enum class Type
            {
                INVALID,        // Not a valid element
                ATTRIBUTE,      // Attribute
                ARRAY_ELEMENT   // Array index (element)
            };
 
            bool operator==(const PathElement& lhs) const
            {
                // Check type first
                if (mType != lhs.mType)
                    return false;
 
                // Compare properties
                if (mType == Type::ATTRIBUTE)
                    return strcmp(Attribute.Name, lhs.Attribute.Name) == 0;
                else if (mType == Type::ARRAY_ELEMENT)
                    return ArrayElement.Index == lhs.ArrayElement.Index;
 
                assert(false);
                return false;
            }
 
            bool operator!=(const PathElement& lhs) const
            {
                return !(*this == lhs);
            }
 
            Type mType = Type::INVALID;     // The type of this element
            union
            {
                struct
                {
                    const char* Name;       // The name of the attribute we're representing
                } Attribute;
 
                struct
                {
                    int Index;              // The index of the array element we're representing
                } ArrayElement;
            };
 
        private:
            friend class Path;
 
            PathElement() :
                mType(Type::INVALID)
            {
            }
 
            PathElement(const char* attributeName) :
                mType(Type::ATTRIBUTE)
            {
                Attribute.Name = attributeName;
            }
 
            PathElement(const std::string& attributeName) :
                mType(Type::ATTRIBUTE)
            {
                mAttributeNameStorage = std::make_unique<std::string>(attributeName);
                Attribute.Name = mAttributeNameStorage->data();
            }
 
            PathElement(int arrayIndex) :
                mType(Type::ARRAY_ELEMENT)
            {
                ArrayElement.Index = arrayIndex;
            }
 
            PathElement(const PathElement& other)
            {
                copyFrom(other);
            }
 
            PathElement& operator=(const PathElement& other)
            {
                // Prevent self-assignment
                if (&other == this)
                    return *this;
 
                // Destroy current value and copy over new data
                copyFrom(other);
 
                return *this;
            }
 
            inline void copyFrom(const PathElement& other)
            {
                mType = other.mType;
                if (mType == Type::ATTRIBUTE)
                {
                    if (other.mAttributeNameStorage == nullptr)
                    {
                        Attribute.Name = other.Attribute.Name;
                    }
                    else
                    {
                        mAttributeNameStorage = std::make_unique<std::string>(*other.mAttributeNameStorage);
                        Attribute.Name = mAttributeNameStorage->data();
                    }
                }
                else if (mType == Type::ARRAY_ELEMENT)
                {
                    ArrayElement.Index = other.ArrayElement.Index;
                }
            }
 
        private:
            std::unique_ptr<std::string> mAttributeNameStorage;
        };
 
        class NAPAPI ResolvedRTTIPathElement
        {
        private:
            friend class ResolvedPath;
            enum class Type
            {
                INVALID,        // Invalid type
                ROOT,           // Root
                ATTRIBUTE,      // Attribute
                ARRAY_ELEMENT   // Array index
            };
 
            ResolvedRTTIPathElement() :
                mType(Type::INVALID)
            {
            }
 
            ResolvedRTTIPathElement(const rtti::Instance& instance, const rtti::Property& property) :
                mType(Type::ROOT)
            {
                initNonPOD(Root.Instance, instance);
                initNonPOD(Root.Property, property);
            }
 
            ResolvedRTTIPathElement(const rtti::Variant& variant, const rtti::Property& property) :
                mType(Type::ATTRIBUTE)
            {
                initNonPOD(Attribute.Variant, variant);
                initNonPOD(Attribute.Property, property);
            }
 
            ResolvedRTTIPathElement(const rtti::Variant& array, int index) :
                mType(Type::ARRAY_ELEMENT)
            {
                initNonPOD(ArrayElement.Array, array);
                ArrayElement.Index = index;
            }
 
            ResolvedRTTIPathElement(const ResolvedRTTIPathElement& other)
            {
                copyFrom(other);
            }
 
            ~ResolvedRTTIPathElement()
            {
                destroy();
            }
 
            ResolvedRTTIPathElement& operator=(const ResolvedRTTIPathElement& other)
            {
                if (&other == this)
                    return *this;
 
                destroy();
                copyFrom(other);
 
                return *this;
            }
 
            template <typename T>
            inline void initNonPOD(T& member, const T& val)
            {
                new (&member) T(val);
            }
 
            inline void destroy()
            {
                // Because all data is placement new'd, we have to call destructors manually
                if (mType == Type::ROOT)
                {
                    Root.Instance.~instance();
                    Root.Property.~property();
                }
                else if (mType == Type::ATTRIBUTE)
                {
                    Attribute.Variant.~variant();
                    Attribute.Property.~property();
                }
                else if (mType == Type::ARRAY_ELEMENT)
                {
                    ArrayElement.Array.~variant();
                }
            }
 
            inline void copyFrom(const ResolvedRTTIPathElement& other)
            {
                mType = other.mType;
                if (mType == Type::ROOT)
                {
                    initNonPOD(Root.Instance, other.Root.Instance);
                    initNonPOD(Root.Property, other.Root.Property);
                }
                else if (mType == Type::ATTRIBUTE)
                {
                    initNonPOD(Attribute.Variant, other.Attribute.Variant);
                    initNonPOD(Attribute.Property, other.Attribute.Property);
                }
                else if (mType == Type::ARRAY_ELEMENT)
                {
                    initNonPOD(ArrayElement.Array, other.ArrayElement.Array);
                    ArrayElement.Index = other.ArrayElement.Index;
                }
            }
 
            Type mType;                         // The type of this element
            union
            {
                struct
                {
                    rtti::Instance Instance;    // The root object (i.e. pointer) that this path was resolved against
                    rtti::Property Property;    // The property on the root object that we're setting
                } Root;
 
                struct
                {
                    rtti::Variant Variant;      // The object (can be a nested compound) that the attribute we're representing is on
                    rtti::Property Property;    // The property on the root object we're representing
                } Attribute;
 
                struct
                {
                    rtti::Variant Array;        // The array that the array element we're representing is in
                    int Index;                  // The index in the array
                } ArrayElement;
            };
        };
 
        class NAPAPI Path
        {
        public:
            inline void pushAttribute(const char* attributeName)
            {
                assert(mLength < RTTIPATH_MAX_LENGTH);
                mElements[mLength++] = PathElement(attributeName);
            }
 
            inline void pushAttribute(const std::string& attributeName)
            {
                assert(mLength < RTTIPATH_MAX_LENGTH);
                mElements[mLength++] = PathElement(attributeName);
            }
 
            inline void pushArrayElement(int index)
            {
                assert(mLength < RTTIPATH_MAX_LENGTH);
                mElements[mLength++] = PathElement(index);
            }
 
            inline void popBack()
            {
                assert(mLength > 0);
                mElements[--mLength] = PathElement();
            }
 
            inline int getLength() const
            {
                return mLength;
            }
 
            inline const PathElement& getElement(int index) const
            {
                assert(index < mLength);
                return mElements[index];
            }
 
            bool operator==(const Path& lhs) const
            {
                if (mLength != lhs.mLength)
                    return false;
 
                for (int index = 0; index < mLength; ++index)
                    if (mElements[index] != lhs.mElements[index])
                        return false;
 
                return true;
            }
 
            bool operator!=(const Path& lhs) const
            {
                return !(*this == lhs);
            }
 
            const std::string toString() const;
 
            static const Path fromString(const std::string& path);
 
            bool resolve(const rtti::Object* object, ResolvedPath& resolvedPath) const;
 
 
            int length() const { return mLength; }
 
        private:
            static const int    RTTIPATH_MAX_LENGTH = 16;           // Maximum number of elements on a Path
            PathElement         mElements[RTTIPATH_MAX_LENGTH];     // The elements on the path
            int                 mLength = 0;                        // Current length of the path
        };
 
        class NAPAPI ResolvedPath
        {
        public:
            const rtti::Variant getValue() const;
 
            bool setValue(const rtti::Variant& value);
 
            const rtti::TypeInfo getType() const;
 
            const rtti::Property& getProperty() const;
 
            bool isEmpty() const
            {
                return mLength == 0;
            }
 
            bool isValid() const { return !isEmpty(); }
 
        private:
            friend class Path;
 
            inline void pushRoot(const rtti::Instance& instance, const rtti::Property& property)
            {
                assert(mLength < RTTIPATH_MAX_LENGTH);
                mElements[mLength++] = ResolvedRTTIPathElement(instance, property);
            }
 
            inline void pushAttribute(const rtti::Variant& variant, const rtti::Property& property)
            {
                assert(mLength < RTTIPATH_MAX_LENGTH);
                mElements[mLength++] = ResolvedRTTIPathElement(variant, property);
            }
 
            inline void pushArrayElement(const rtti::Variant& array, int index)
            {
                assert(mLength < RTTIPATH_MAX_LENGTH);
                mElements[mLength++] = ResolvedRTTIPathElement(array, index);
            }
 
        private:
            static const int        RTTIPATH_MAX_LENGTH = 16;           // Maximum number of elements on a Path
            ResolvedRTTIPathElement mElements[RTTIPATH_MAX_LENGTH];     // The elements on the path
            int                     mLength = 0;                        // Current length of the path
        };
    }
}