service.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 "numeric.h"
 
// External Includes
#include <utility/dllexport.h>
#include <utility/errorstate.h>
#include <rtti/object.h>
#include <rtti/factory.h>
#include <set>
 
namespace nap
{
 
    // Forward Declares
    class Core;
    class Module;
    class ServiceObjectGraphItem;
 
    class NAPAPI ServiceConfiguration : public rtti::Object
    {
        RTTI_ENABLE(rtti::Object)
    public:
        virtual rtti::TypeInfo getServiceType() const = 0;
    };
 
 
    class NAPAPI Service
    {
        RTTI_ENABLE()
        friend class Core;
        friend class ServiceObjectGraphItem;
    public:
        Service(ServiceConfiguration* configuration);
 
        // Virtual destructor because of virtual methods!
        virtual ~Service();
 
        Core& getCore();
 
        const Core& getCore() const;
 
        std::string getTypeName() const;
 
        const Module& getModule() const;
 
        Service(Service&) = delete;
 
        Service& operator=(const Service&) = delete;
 
        Service(Service&&) = delete;
 
        Service& operator=(Service&&) = delete;
 
    protected:
        virtual void registerObjectCreators(rtti::Factory& factory)                     { }
 
        virtual void getDependentServices(std::vector<rtti::TypeInfo>& dependencies)            { }
 
        virtual void created()                                                          {}
 
        virtual bool init(utility::ErrorState& error)                                   { return true; }
 
        virtual void preUpdate(double deltaTime)                                        { }
 
        virtual void update(double deltaTime)                                           { }
 
        virtual void postUpdate(double deltaTime)                                       { }
 
        virtual void preShutdown()                                                      { }
 
        virtual void shutdown()                                                         { }
 
        virtual void preResourcesLoaded()                                               { }
 
        virtual void postResourcesLoaded()                                              { }
 
        template<typename SERVICE_CONFIG>
        SERVICE_CONFIG* getConfiguration()
        {
            return rtti_cast<SERVICE_CONFIG>(mConfiguration);
        }
 
        template<typename SERVICE_CONFIG>
        const SERVICE_CONFIG* getConfiguration() const
        {
            return rtti_cast<SERVICE_CONFIG>(mConfiguration);
        }
 
        std::string getIniFilePath() const;
 
        std::string getIniFilePath(const std::string& appendix) const;
 
    private:
        // this variable will be set by the core when the service is added
        Core*                                   mCore = nullptr;
        ServiceConfiguration*                   mConfiguration;
    };
}