ApplicationConfiguration.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__APPLICATION_CONFIGURATION
#define COM_BORA_SOFTWARE__BALAU_APPLICATION__APPLICATION_CONFIGURATION

#include <Balau/Application/BindingBuilder.hpp>
#include <Balau/Application/InjectorConfiguration.hpp>

namespace Balau {

class ApplicationConfiguration : public InjectorConfiguration {
    protected: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>>
    BindingBuilder<BaseT, DeleterT> & bind(std::string_view name = std::string_view()) const {
        return Bind<BaseT, DeleterT>(*this).bind(name);
    }

    protected: void addConfiguration(const ApplicationConfiguration & conf) const {
        extraConfiguration.push_back(&conf);
    }

    protected: void registerPostConstructionCall(const std::function<void (const Injector &)> & call) const {
        postConstructionCalls.push_back(call);
    }

    protected: void registerPreDestructionCall(const std::function<void ()> & call) const {
        preDestructionCalls.push_back(call);
    }

    protected: template <typename T> void registerStaticSingleton(std::shared_ptr<T> * ptrPtr, std::string_view name = std::string_view()) const {
        staticSingletonPostConstructionCalls.emplace_back(new StaticSingletonRegistration(ptrPtr, name));
        preDestructionCalls.push_back([ptrPtr] () { ptrPtr->reset(); });
    }


    private: std::vector<std::shared_ptr<Impl::BindingBuilderBase>> build() const override {
        // Move the vector because it is not used anymore after this call from the injector.
        return std::move(builders);
    }

    public: std::vector<const InjectorConfiguration *> getExtraConfiguration() const override {
        return extraConfiguration;
    }

    public: std::list<std::function<void (const Injector& )>> getPostConstructionCalls() const override {
        return postConstructionCalls;
    }

    public: std::list<std::function<void ()>> getPreDestructionCalls() const override {
        return preDestructionCalls;
    }

    public: std::list<std::unique_ptr<StaticSingletonRegistrationBase>> getStaticSingletonPostConstructionCalls() const override {
        return std::move(staticSingletonPostConstructionCalls);
    }

    private: template <typename T, typename DeleterT> struct Bind {
        static_assert(
              std::negation<typename std::is_pointer<T>::type>::value
            , "Raw pointers are not permitted in bindings. Use Unique or Shared bindings instead."
        );

        const ApplicationConfiguration & parent;

        explicit Bind(const ApplicationConfiguration & parent_) : parent(parent_) {}

        BindingBuilder<T, DeleterT> & bind(std::string_view name) const {
            parent.builders.emplace_back(
                std::shared_ptr<Impl::BindingBuilderBase>(new BindingBuilder<T, DeleterT>(std::string(name)))
            );

            return *reinterpret_cast<BindingBuilder<T, DeleterT> *>(parent.builders.back().get());
        }
    };

    private: template <typename T, typename DeleterT> struct Bind<const T, DeleterT> {
        static_assert(
              std::negation<typename std::is_pointer<T>::type>::value
            , "Raw pointers are not permitted in bindings. Use Unique or Shared bindings instead."
        );

        const ApplicationConfiguration & parent;

        explicit Bind(const ApplicationConfiguration & parent_) : parent(parent_) {}

        BindingBuilder<const T, DeleterT> & bind(std::string_view name) const {
            parent.builders.emplace_back(
                std::shared_ptr<Impl::BindingBuilderBase>(new BindingBuilder<const T, DeleterT>(std::string(name)))
            );

            return *reinterpret_cast<BindingBuilder<const T, DeleterT> *>(parent.builders.back().get());
        }
    };

    private: mutable std::vector<std::shared_ptr<Impl::BindingBuilderBase>> builders;
    private: mutable std::vector<const InjectorConfiguration *> extraConfiguration;
    private: mutable std::list<std::function<void (const Injector& )>> postConstructionCalls;
    private: mutable std::list<std::function<void ()>> preDestructionCalls;
    private: mutable std::list<std::unique_ptr<StaticSingletonRegistrationBase>> staticSingletonPostConstructionCalls;
};

} // namespace Balau

#endif // COM_BORA_SOFTWARE__BALAU_APPLICATION__APPLICATION_CONFIGURATION