DependencyInjector.h

#pragma once

#include <map>

#include <Poco/Exception.h>
#include <Poco/AutoPtr.h>
#include <Poco/SharedPtr.h>
#include <Poco/SharedLibrary.h>
#include <Poco/Logger.h>
#include <Poco/Util/AbstractConfiguration.h>

#include "di/DIFactory.h"
#include "di/DIWrapper.h"
#include "util/Loggable.h"

namespace BeeeOn {

class InstanceInfo;

class DependencyInjector : public DIFactory, protected Loggable {
public:
        typedef std::map<std::string, DIWrapper *> WrapperMap;
        typedef std::vector<DIWrapper *> WrapperVector;

        DependencyInjector(
                Poco::AutoPtr<Poco::Util::AbstractConfiguration> conf,
                const std::vector<std::string> &libraryPaths = {},
                bool avoidEarly = false);

        ~DependencyInjector();

private:
        DIWrapper *findImpl(const std::string &name) override;

        DIWrapper *createImpl(
                const std::string &name,
                bool detach) override;

        void castImpl(
                const std::type_info &type,
                const DIWrapper &wrapper,
                void *target) override;

        void computeConstants();

        void createEarly();

        void destroyOne(DIWrapper *one) const;
        void cleanup(const WrapperVector vec) const;
        WrapperVector tryDestroy(const WrapperVector vec) const;
        void destroyRest(const WrapperVector vec) const;

        void destroyAll();

        DIWrapper *resolveAndCreate(
                        const std::string &name,
                        bool disown);

        DIWrapper *createNoAlias(
                        const InstanceInfo &info,
                        bool disown = false);

        void loadLibrary(Poco::SharedLibrary &library, const std::string &name) const;

        DIWrapper *createNew(const InstanceInfo &info);

        DIWrapper *injectDependencies(
                        const InstanceInfo &info,
                        DIWrapper *target);
        void injectValue(const InstanceInfo &info,
                        DIWrapper *target,
                        const std::string &key,
                        const std::string &name);

        void createAndInjectRef(
                        const std::string &targetName,
                        DIWrapper *target,
                        const std::string &name,
                        const std::string &value);
        bool tryInjectRef(const InstanceInfo &info,
                        DIWrapper *target,
                        const std::string &key,
                        const std::string &name);

        void evalAndInjectNumber(
                        const std::string &targetName,
                        DIWrapper *target,
                        const std::string &name,
                        const std::string &value);
        bool tryInjectNumber(const InstanceInfo &info,
                        DIWrapper *target,
                        const std::string &key,
                        const std::string &name);
        bool tryInjectText(const InstanceInfo &info,
                        DIWrapper *target,
                        const std::string &key,
                        const std::string &name);
        bool tryInjectTime(const InstanceInfo &info,
                        DIWrapper *target,
                        const std::string &key,
                        const std::string &name);
        bool tryInjectList(const InstanceInfo &info,
                        DIWrapper *target,
                        const std::string &key,
                        const std::string &name);
        bool tryInjectMap(const InstanceInfo &info,
                        DIWrapper *target,
                        const std::string &key,
                        const std::string &name);

private:
        WrapperMap m_set;
        WrapperVector m_free;
        Poco::AutoPtr<Poco::Util::AbstractConfiguration> m_conf;
        std::vector<std::string> m_librariesPaths;
        std::map<std::string, Poco::SharedLibrary> m_libraries;
};

}