sequenceeditorguiclipboard.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
 
// External Includes
#include <rtti/rtti.h>
#include <rtti/object.h>
#include <rtti/jsonreader.h>
#include <rtti/defaultlinkresolver.h>
#include <fstream>
#include <rtti/objectptr.h>
#include <nap/logger.h>
 
namespace nap
{
    namespace sequenceguiclipboard
    {
 
        class NAPAPI Clipboard
        {
        RTTI_ENABLE()
 
        public:
            explicit Clipboard(const rttr::type& trackType);
 
            virtual ~Clipboard() = default;
 
            void addObject(const rtti::Object* object, const std::string& sequenceName, utility::ErrorState& errorState);
 
            void addObject(const rtti::Object* object, utility::ErrorState& errorState);
 
            template<typename T>
            std::vector<T*> deserialize(std::vector<std::unique_ptr<rtti::Object>>& createdObjects, utility::ErrorState& errorState);
 
 
            template<typename T>
            bool isClipboard()
            {
                return this->get_type() == RTTI_OF(T);
            }
 
 
            template<typename T>
            T* getDerived()
            {
                assert(isClipboard<T>());
                return static_cast<T*>(this);
            }
 
 
            std::vector<std::string> getObjectIDs() const;
 
            bool containsObject(const std::string& objectID, const std::string& sequenceName) const;
 
            void removeObject(const std::string& objectID);
 
            int getObjectCount() const{ return mSerializedObjects.size(); }
 
            rttr::type getTrackType() const{ return mTrackType; }
 
            bool save(const std::string& filePath, utility::ErrorState& errorState);
 
            bool load(const std::string& filePath, utility::ErrorState& errorState);
 
        protected:
            // the serialized objects
            std::map<std::string, std::string> mSerializedObjects;
            rttr::type mTrackType;
            std::string mSequenceName;
        };
 
        // shortcut
        using SequenceClipboardPtr = std::unique_ptr<Clipboard>;
 
 
        // use this method to create a clipboard
        template<typename T, typename ... Args>
        static SequenceClipboardPtr createClipboard(Args &&... args)
        {
            return std::make_unique<T>(std::forward<Args>(args)...);
        }
 
 
        class NAPAPI Empty : public Clipboard
        {
        RTTI_ENABLE()
        public:
            Empty() : Clipboard(rttr::type::empty())
            {}
        };
 
 
        // Template definitions
 
        template<typename T>
        std::vector<T*> Clipboard::deserialize(std::vector<std::unique_ptr<rtti::Object>>& createdObjects, utility::ErrorState& errorState)
        {
            std::vector<T *> deserialized_objects;
 
            createdObjects.clear();
            for(auto &pair: mSerializedObjects)
            {
                // get the serialized object from the map
                std::string serialized_object = pair.second;
 
                // De-serialize
                rtti::DeserializeResult result;
                rtti::Factory factory;
                if(!rtti::deserializeJSON(serialized_object, rtti::EPropertyValidationMode::DisallowMissingProperties,
                                          rtti::EPointerPropertyMode::NoRawPointers, factory, result, errorState))
                    return std::vector<T *>();
 
                // Resolve links
                if(!rtti::DefaultLinkResolver::sResolveLinks(result.mReadObjects, result.mUnresolvedPointers, errorState))
                    return std::vector<T *>();
 
                // Make sure we deserialized something
                T *root_object = nullptr;
                if(!errorState.check(!result.mReadObjects.empty(), "No objects deserialized"))
                    return std::vector<T *>();
 
                auto *first_object = result.mReadObjects[0].get();
                if(!errorState.check(first_object->get_type() == RTTI_OF(T) ||
                                     first_object->get_type().is_derived_from<T>(), "Root object not of correct type"))
                    return std::vector<T *>();
 
                // Move ownership of read objects
                root_object = static_cast<T *>(first_object);
                for(auto &read_object: result.mReadObjects)
                {
                    createdObjects.emplace_back(std::move(read_object));
                }
 
                // init objects
                for(auto &object_ptr: createdObjects)
                {
                    if(!errorState.check(object_ptr->init(errorState), "Error initializing object : %s ", errorState.toString().c_str()))
                        return std::vector<T *>();
                }
 
                if(!errorState.check(root_object != nullptr, "return object is null"))
                    return std::vector<T *>();
 
                deserialized_objects.emplace_back(root_object);
            }
 
            return deserialized_objects;
        }
    }
}