ksApplication.h

/*
 *  Copyright (c) 2021-2023, Krzysztof Strehlau
 *
 *  This file is a part of the ksIotFramework library.
 *  All licensing information can be found inside LICENSE.md file.
 *
 *  https://github.com/cziter15/ksIotFrameworkLib/blob/master/LICENSE
 */
 
#pragma once
 
#include <memory>
#include <list>
#include <string>
#include <functional>
 
#include "ksComponent.h"
 
#if APP_LOG_ENABLED
typedef std::function<void(std::string&)> AppLogProviderFunc_t;
typedef std::function<void(std::string&&)> AppLogCallbackFunc_t;
#endif
 
namespace ksf 
{
    class ksComponent;
 
    class ksApplication
    {
        protected:
            std::list<std::shared_ptr<ksComponent>> components;     
 
#if APP_LOG_ENABLED
             AppLogCallbackFunc_t appLogCallback;                   
#endif
        public:
            virtual ~ksApplication();
 
            template <class TComponentType, class... TParams>
            std::weak_ptr<TComponentType> addComponent(TParams... arg)
            {
                static_assert(!std::is_same_v<decltype(&ksComponent::getInstanceType), decltype(&TComponentType::getInstanceType)>, 
                    "You're calling addComponent, but provided type lacks RTTI implementation. Did you miss KSF_RTTI_DECLARATIONS?"
                );
 
                auto componentSp{std::make_shared<TComponentType>(arg...)};
                auto componentWp{std::weak_ptr<TComponentType>(componentSp)};
                components.push_front(std::move(componentSp));
                return componentWp;
            }
 
            template <class TComponentType>
            void findComponents(std::vector<std::weak_ptr<TComponentType>>& outComponents)
            {
                static_assert(!std::is_same_v<decltype(&ksComponent::getInstanceType), decltype(&TComponentType::getInstanceType)>, 
                    "You're calling findComponents, but provided type lacks RTTI implementation. Did you miss KSF_RTTI_DECLARATIONS?"
                );
 
                outComponents.clear();
 
                for (const auto& comp : components)
                {
                    if (comp->isA(TComponentType::getClassType()))
                    {
                        std::weak_ptr<TComponentType> castedCompWp{std::static_pointer_cast<TComponentType>(comp)};
                        if (!castedCompWp.expired())
                            outComponents.push_back(std::move(castedCompWp));
                    }
                }
            }
 
            template <class TComponentType>
            std::weak_ptr<TComponentType> findComponent()
            {
                static_assert(!std::is_same_v<decltype(&ksComponent::getInstanceType), decltype(&TComponentType::getInstanceType)>, 
                    "You're calling findComponent, but provided type lacks RTTI implementation. Did you miss KSF_RTTI_DECLARATIONS?"
                );
 
                for (const auto& comp : components)
                    if (comp->isA(TComponentType::getClassType()))
                        return std::static_pointer_cast<TComponentType>(comp);
 
                return std::weak_ptr<TComponentType>();
            }
 
            virtual bool init() = 0;
 
            virtual bool loop();
 
#if APP_LOG_ENABLED
            void log(AppLogProviderFunc_t provideLogFn) const;
 
            void setLogCallback(AppLogCallbackFunc_t logCallback);
#endif
    };
}