BindingBuilder.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_APPLICATION__BINDING_BUILDER
#define COM_BORA_SOFTWARE__BALAU_APPLICATION__BINDING_BUILDER

#include <Balau/Application/Impl/Binding.hpp>
#include <Balau/Application/Impl/InjectorLogger.hpp>

namespace Balau {

namespace Impl {

template <typename ValueT> class ValuePropertyBindingBuilderFactory;
template <typename ValueT> class UniquePropertyBindingBuilderFactory;

} // namespace Impl

template <typename BaseT>
using UniquePropertyCloner = std::function<std::unique_ptr<BaseT> (const std::unique_ptr<const BaseT> &)>;

template <typename BaseT, typename DeleterT>
class BindingBuilder final : public Impl::BindingBuilderBase {
    private: using UniquePtrProviderFunction = std::function<std::unique_ptr<BaseT> ()>;

    public: void toValue() {
        warnInvalidConstQualifier(Impl::BindingMetaType::Value);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Value, U>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new InstantiatingValueBindingSupplier());
    }

    public: template <typename ValueT = BaseT> void toValue(ValueT prototype) {
        warnInvalidConstQualifier(Impl::BindingMetaType::Value);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Value, U>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new PrototypeBindingSupplier(prototype));
    }

    public: template <typename ProviderFunctionT> void toValueProvider(ProviderFunctionT provider) {
        warnInvalidConstQualifier(Impl::BindingMetaType::Value);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Value, U>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingFunctionValueBindingSupplier<ProviderFunctionT>(provider));
    }

    public: template <typename ProviderT> void toValueProvider() {
        warnInvalidConstQualifier(Impl::BindingMetaType::Value);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Value, U>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingClassValueBindingSupplier<ProviderT>());
    }

    public: template <typename ProviderT> void toValueProvider(std::shared_ptr<ProviderT> provider) {
        warnInvalidConstQualifier(Impl::BindingMetaType::Value);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Value, U>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingClassInstanceValueBindingSupplier<ProviderT>(std::move(provider)));
    }

    public: template <typename DerivedT> void toUnique() {
        warnInvalidConstQualifier(Impl::BindingMetaType::Unique);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Unique, U, DeleterT>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new InstantiatingUniquePtrBindingSupplier<DerivedT>());
    }

    public: void toUniqueProvider(UniquePtrProviderFunction provider) {
        warnInvalidConstQualifier(Impl::BindingMetaType::Unique);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Unique, U, DeleterT>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingFunctionUniquePtrBindingSupplier(provider));
    }

    public: template <typename ProviderT> void toUniqueProvider() {
        warnInvalidConstQualifier(Impl::BindingMetaType::Unique);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Unique, U, DeleterT>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingClassUniquePtrBindingSupplier<ProviderT>());
    }

    public: template <typename ProviderT> void toUniqueProvider(std::shared_ptr<ProviderT> provider) {
        warnInvalidConstQualifier(Impl::BindingMetaType::Unique);
        using U = typename std::remove_const<BaseT>::type;
        using T = Impl::BindingKeyType<Impl::BindingMetaType::Unique, U, DeleterT>;
        setKeyType<T>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingClassInstanceUniquePtrBindingSupplier<ProviderT>(std::move(provider)));
    }

    public: void toReference(BaseT & reference) {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Reference, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ReferenceBindingSupplier(reference));
    }

    public: template <typename DerivedT> void toThreadLocal() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ThreadLocalSingletonBindingSupplier<DerivedT>());
    }

    public: template <typename DerivedT, typename SharedDeleterT> void toThreadLocal() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ThreadLocalSingletonBindingSupplier<DerivedT, SharedDeleterT>());
    }

    public: void toThreadLocal() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ThreadLocalSingletonBindingSupplier<BaseT>());
    }

    public: template <typename DerivedT> void toSingleton() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new LazySingletonBindingSupplier<DerivedT>());
    }

    public: template <typename DerivedT, typename SharedDeleterT> void toSingleton() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new LazySingletonBindingSupplier<DerivedT, SharedDeleterT>());
    }

    public: void toSingleton() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new LazySingletonBindingSupplier<BaseT>());
    }

    public: void toSingleton(std::shared_ptr<BaseT> instance) {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidedSingletonBindingSupplier(instance));
    }

    public: void toSingleton(BaseT * instance) {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        toSingleton(std::shared_ptr<BaseT>(instance));
    }

    public: template <typename SharedDeleterT> void toSingleton(BaseT * instance) {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        toSingleton(std::shared_ptr<BaseT>(instance, SharedDeleterT()));
    }

    public: template <typename ProviderT> void toSingletonProvider() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingClassSingletonBindingSupplier<ProviderT>());
    }

    public: template <typename ProviderT> void toSingletonProvider(std::shared_ptr<ProviderT> provider) {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingClassInstanceSingletonBindingSupplier<ProviderT>(std::move(provider)));
    }

    public: void toSingletonProvider(const std::function<std::shared_ptr<BaseT> ()> & provider) {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new ProvidingFunctionSingletonBindingSupplier(provider));
    }

    public: template <typename DerivedT> void toEagerSingleton() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new EagerSingletonBindingSupplier<DerivedT>());
    }

    public: template <typename DerivedT, typename SharedDeleterT> void toEagerSingleton() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new EagerSingletonBindingSupplier<DerivedT, SharedDeleterT>());
    }

    public: void toEagerSingleton() {
        setKeyType<Impl::BindingKeyType<Impl::BindingMetaType::Shared, BaseT>>();
        supplier = std::unique_ptr<BindingSupplier>(new EagerSingletonBindingSupplier<BaseT>());
    }


    public: BindingBuilder(const BindingBuilder & rhs) = delete;
    public: BindingBuilder & operator = (const BindingBuilder & rhs) = delete;

    // Binding suppliers use candidate information to create bindings.
    private: class BindingSupplier {
        public: virtual ~BindingSupplier() = default;

        public: virtual std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const = 0;
    };

    private: class InstantiatingValueBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(new Impl::InstantiatingValueBinding<BaseT>(std::move(key)));
        }
    };

    private: class PrototypeBindingSupplier : public BindingSupplier {
        private: const BaseT prototype;

        public: explicit PrototypeBindingSupplier(const BaseT & prototype_)
            : prototype(prototype_) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(new Impl::PrototypeBinding<BaseT>(std::move(key), prototype));
        }
    };

    private: template <typename ProviderFunctionT>
    class ProvidingFunctionValueBindingSupplier : public BindingSupplier {
        private: const ProviderFunctionT provide;

        public: explicit ProvidingFunctionValueBindingSupplier(ProviderFunctionT provide_)
            : provide(provide_) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingFunctionValueBinding<BaseT, ProviderFunctionT>(std::move(key), provide)
            );
        }
    };

    private: template <typename ProviderT> class ProvidingClassValueBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingClassValueBinding<BaseT, ProviderT>(std::move(key))
            );
        }
    };

    private: template <typename ProviderT> class ProvidingClassInstanceValueBindingSupplier : public BindingSupplier {
        public: explicit ProvidingClassInstanceValueBindingSupplier(std::shared_ptr<ProviderT> && provider_) noexcept
            : provider(std::move(provider_)) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingClassInstanceValueBinding<BaseT, ProviderT>(std::move(key), provider)
            );
        }

        std::shared_ptr<ProviderT> provider;
    };

    private: class ReferenceBindingSupplier : public BindingSupplier {
        private: BaseT & reference;

        public: explicit ReferenceBindingSupplier(BaseT & reference_)
            : reference(reference_) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::StandardReferenceBinding<BaseT>(std::move(key), reference)
            );
        }
    };

    private: template <typename DerivedT> class InstantiatingUniquePtrBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::InstantiatingUniquePtrBinding<BaseT, DerivedT, DeleterT>(std::move(key))
            );
        }
    };

    private: class ProvidingFunctionUniquePtrBindingSupplier : public BindingSupplier {
        private: const UniquePtrProviderFunction provide;

        public: explicit ProvidingFunctionUniquePtrBindingSupplier(UniquePtrProviderFunction provide_)
            : provide(provide_) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingFunctionUniquePtrBinding<BaseT, DeleterT>(std::move(key), provide)
            );
        }
    };

    private: template <typename ProviderT> class ProvidingClassUniquePtrBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingClassUniquePtrBinding<BaseT, ProviderT, DeleterT>(std::move(key))
            );
        }
    };

    private: template <typename ProviderT> class ProvidingClassInstanceUniquePtrBindingSupplier : public BindingSupplier {
        public: explicit ProvidingClassInstanceUniquePtrBindingSupplier(std::shared_ptr<ProviderT> && provider_) noexcept
            : provider(std::move(provider_)) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingClassInstanceUniquePtrBinding<BaseT, ProviderT, DeleterT>(std::move(key), provider)
            );
        }

        private: std::shared_ptr<ProviderT> provider;
    };

    private: template <typename DerivedT, typename ThreadLocalDeleterT = std::default_delete<BaseT>> class ThreadLocalSingletonBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ThreadLocalSingletonBinding<BaseT, DerivedT, ThreadLocalDeleterT>(std::move(key))
            );
        }
    };

    private: class ProvidedSingletonBindingSupplier : public BindingSupplier {
        private: const std::shared_ptr<BaseT> instance;

        public: explicit ProvidedSingletonBindingSupplier(std::shared_ptr<BaseT> instance_)
            : instance(std::move(instance_)) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidedSingletonBinding<BaseT>(std::move(key), instance)
            );
        }
    };

    private: template <typename ProviderT> class ProvidingClassSingletonBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingClassSingletonBinding<BaseT, ProviderT>(std::move(key))
            );
        }
    };

    private: template <typename ProviderT> class ProvidingClassInstanceSingletonBindingSupplier : public BindingSupplier {
        public: explicit ProvidingClassInstanceSingletonBindingSupplier(std::shared_ptr<ProviderT> && provider_) noexcept
            : provider(std::move(provider_)) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingClassInstanceSingletonBinding<BaseT, ProviderT>(std::move(key), provider)
            );
        }

        private: std::shared_ptr<ProviderT> provider;
    };

    private: class ProvidingFunctionSingletonBindingSupplier : public BindingSupplier {
        public: explicit ProvidingFunctionSingletonBindingSupplier(const std::function<std::shared_ptr<BaseT> ()> & provider_) noexcept
            : provider(provider_) {}

        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::ProvidingFunctionSingletonBinding<BaseT>(std::move(key), provider)
            );
        }

        private: const std::function<std::shared_ptr<BaseT> ()> provider;
    };

    private: template <typename DerivedT, typename SharedDeleterT = std::default_delete<BaseT>> class LazySingletonBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::LazySingletonBinding<BaseT, DerivedT, SharedDeleterT>(std::move(key))
            );
        }
    };

    private: template <typename DerivedT, typename SharedDeleterT = std::default_delete<BaseT>> class EagerSingletonBindingSupplier : public BindingSupplier {
        public: std::unique_ptr<Impl::AbstractBinding> build(Impl::BindingKey && key) const override {
            return std::unique_ptr<Impl::AbstractBinding>(
                new Impl::EagerSingletonBinding<BaseT, DerivedT, SharedDeleterT>(std::move(key))
            );
        }
    };

    private: void warnInvalidConstQualifier(Impl::BindingMetaType metaType) {
        if (!std::is_same<BaseT, typename std::remove_const<BaseT>::type>::value) {
            Impl::InjectorLogger::log().warn(
                  "{} binding key {} has been defined with a const type. This "
                  "qualifier will be removed from the key because {} types cannot "
                  "be const qualified. This will not affect binding semantics."
                , metaType
                , key
                , metaType
            );
        }
    }

    friend class ApplicationConfiguration;
    friend class EnvironmentConfiguration;
    template <typename ValueT> friend class Impl::ValuePropertyBindingBuilderFactory;
    template <typename ValueT> friend class Impl::UniquePropertyBindingBuilderFactory;

    private: explicit BindingBuilder(std::string && name)
        : Impl::BindingBuilderBase(std::move(name)) {}

    private: std::unique_ptr<Impl::AbstractBinding> build() override {
        return supplier->build(std::move(key));
    }

    private: std::unique_ptr<BindingSupplier> supplier;
};

} // namespace Balau

#endif // COM_BORA_SOFTWARE__BALAU_APPLICATION__BINDING_BUILDER