DIFactory.h

#pragma once

#include <string>
#include <typeinfo>

#include <Poco/SharedPtr.h>

namespace BeeeOn {

class DIWrapper;
class DIWCast;

class DIFactory {
public:
        typedef Poco::SharedPtr<DIFactory> Ptr;

        virtual ~DIFactory();

        DIWrapper *create(
                const std::string &name,
                bool detach = false)
        {
                return createImpl(name, detach);
        }

        template <typename T>
        Poco::SharedPtr<T> create(
                const std::string &name,
                bool detach = false)
        {
                auto wrapper = create(name, detach);
                if (wrapper == nullptr)
                        return {};

                return cast<T>(*wrapper);
        }

        DIWrapper *find(const std::string &name)
        {
                return findImpl(name);
        }

        template <typename T>
        Poco::SharedPtr<T> find(const std::string &name)
        {
                auto wrapper = findImpl(name);
                if (wrapper == nullptr)
                        return {};

                return cast<T>(*wrapper);
        }

protected:
        template <typename T>
        Poco::SharedPtr<T> cast(DIWrapper &wrapper)
        {
                Poco::SharedPtr<T> instance;
                castImpl(typeid(T), wrapper, reinterpret_cast<void *>(&instance));

                return instance;
        }

        virtual DIWrapper *findImpl(const std::string &name) = 0;

        virtual DIWrapper *createImpl(
                const std::string &name,
                bool detach) = 0;

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

};

}