apievent.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 "apiargument.h"
#include "apisignature.h"
 
// External Includes
#include <nap/event.h>
#include <utility/uniqueptrvectoriterator.h>
#include <mathutils.h>
 
namespace nap
{
    using APIArgumentList = std::vector<std::unique_ptr<APIArgument>>;
 
    class NAPAPI APIEvent : public Event
    {
        RTTI_ENABLE(Event)
    public:
        using ArgumentConstIterator = utility::UniquePtrConstVectorWrapper<APIArgumentList, APIArgument*>;
 
        APIEvent(const std::string& name);
 
        APIEvent(std::string&& name);
 
        APIEvent(const std::string& name, const std::string& id);
 
        APIEvent(std::string&& name, std::string&& id);
 
        const std::string& getName() const                          { return mName; }
 
        const std::string& getID() const                            { return mID; }
 
        template<typename T, typename... Args>
        APIArgument* addArgument(const std::string& name, Args&&... args);
 
        APIArgument* addArgument(std::unique_ptr<APIBaseValue> value);
 
        int getCount() const                                        { return static_cast<int>(mArguments.size()); }
 
        const ArgumentConstIterator getArguments() const            { return ArgumentConstIterator(mArguments); }
 
        const APIArgument* getArgument(int index) const;
 
        APIArgument* getArgument(int index);
 
        const APIArgument* getArgumentByName(std::string&& name) const;
 
        APIArgument* getArgumentByName(std::string&& name);
 
        bool matches(const nap::APISignature& signature) const;
 
        template<typename T>
        const T& to() const;
 
        template<typename T>
        T& to();
 
        APIArgument& operator[](std::size_t idx)                    { return *getArgument(static_cast<int>(idx)); }
 
        const APIArgument& operator[](std::size_t idx) const        { return *getArgument(static_cast<int>(idx)); }
 
    private:
        std::string mName;              
        APIArgumentList mArguments;     
        std::string mID;                
    };
 
    using APIEventPtr = std::unique_ptr<nap::APIEvent>;
 
 
    // Template definitions
 
    template<typename T, typename... Args>
    APIArgument* nap::APIEvent::addArgument(const std::string& name, Args&&... args)
    {
        assert(RTTI_OF(T).is_derived_from(RTTI_OF(nap::APIBaseValue)));
 
        // Create value
        std::unique_ptr<T> value = std::make_unique<T>(name, std::forward<Args>(args)...);
        
        // Assign unique id
        value->mID = math::generateUUID();
 
        // Create argument and move value
        std::unique_ptr<APIArgument> argument = std::make_unique<APIArgument>(std::move(value));
 
        mArguments.emplace_back(std::move(argument));
        return mArguments.back().get();
    }
 
 
    template<typename T>
    const T& nap::APIEvent::to() const
    {
        const T* return_p = nullptr;
        if (this->get_type().is_derived_from<T>())
            return_p = reinterpret_cast<const T*>(this);
        assert(return_p != nullptr);
        return *return_p;
    }
 
 
    template<typename T>
    T& nap::APIEvent::to()
    {
        T* cast_event = rtti_cast<T>(this);
        assert(cast_event != nullptr);
        return *cast_event;
    }
 
}