apicomponent.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 <string>
#include <vector>
#include <unordered_map>
#include <component.h>
#include <nap/signalslot.h>
 
// Local Includes
#include "apiservice.h"
#include "apievent.h"
#include "apisignature.h"
 
namespace nap
{
    class APIComponentInstance;
    class APICallBack;
 
    class NAPAPI APIComponent : public Component
    {
        RTTI_ENABLE(Component)
        DECLARE_COMPONENT(APIComponent, APIComponentInstance)
    public:
        std::vector<ResourcePtr<APISignature>> mSignatures;         
    };
 
 
    class NAPAPI APIComponentInstance : public ComponentInstance
    {
        friend class APIService;
        RTTI_ENABLE(ComponentInstance)
    public:
        APIComponentInstance(EntityInstance& entity, Component& resource) :
            ComponentInstance(entity, resource)                                 { }
 
        virtual ~APIComponentInstance() override;
 
        virtual bool init(utility::ErrorState& errorState) override;
 
        const APISignature* findSignature(const std::string& id) const;
 
        bool accepts(const APIEvent& apiEvent) const;
 
        void registerCallback(const APISignature& signature, nap::Slot<const APIEvent&>& slot);
 
        Signal<const APIEvent&> messageReceived;                
 
    private:
        // Pointer to the API service
        APIService* mAPIService = nullptr;
 
        // All accepted names of individual calls
        std::unordered_map<std::string, APISignature*> mSignatures;
 
        // All registered callbacks
        std::unordered_map<std::string, std::unique_ptr<APICallBack>> mCallbacks;
 
         void trigger(const APIEvent& apiEvent);
 
         APICallBack& getOrCreateCallback(const APISignature& signature);
    };
 
 
    // API Callback
 
    class NAPAPI APICallBack final
    {
    public:
        // No default constructor
        APICallBack() = delete;
 
        // Removes binding
        ~APICallBack();
 
        APICallBack(APICallBack&) = delete;
        APICallBack& operator=(const APICallBack&) = delete;
 
        APICallBack(APICallBack&&) = delete;
        APICallBack& operator=(APICallBack&&) = delete;
 
        APICallBack(const APISignature& signature) { }
 
        Signal<const APIEvent&> messageReceived;    
    };
}