EnvironmentConfiguration.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2017 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__ENVIRONMENT_CONFIGURATION
#define COM_BORA_SOFTWARE__BALAU_APPLICATION__ENVIRONMENT_CONFIGURATION

#include <Balau/Application/BindingBuilder.hpp>
#include <Balau/Application/InjectorConfiguration.hpp>
#include <Balau/Application/Impl/EnvironmentConfigurationBuilder.hpp>
#include <Balau/Lang/Property/PropertyParserService.hpp>
#include <Balau/Resource/StringUri.hpp>
#include <Balau/Util/Streams.hpp>
#include <Balau/Util/Vectors.hpp>

// Avoid false positives.
#pragma clang diagnostic push
#pragma ide diagnostic ignored "OCUnusedGlobalDeclarationInspection"

namespace Balau {

class EnvironmentConfiguration : public InjectorConfiguration {

    public: template <typename ValueT>
    static void registerValueType(const std::string & typeString) {
        Impl::registerEnvironmentPropertyValueType<ValueT>(typeString);
    }

    public: template <typename BaseT>
    static void registerUniqueType(const std::string & typeString, const UniquePropertyCloner<BaseT> & cloner) {
        Impl::registerEnvironmentPropertyUniqueType<BaseT>(typeString, cloner);
    }

    public: static void registerUnsignedTypes() {
        Impl::registerEnvironmentPropertyUnsignedTypes();
    }


    public: EnvironmentConfiguration(const std::vector<std::shared_ptr<Resource::Uri>> & inputs,
                                     const std::vector<std::shared_ptr<Resource::Uri>> & specs = {})
        : propertyStringsHierarchy(Impl::EnvironmentConfigurationBuilderUtils::createPropertyStrings(inputs))
        , typeSpecificationsUris(specs) {}

    public: EnvironmentConfiguration(const std::vector<Resource::File> & inputs,
                                     const std::vector<Resource::File> & specs = {})
        : EnvironmentConfiguration(
            Util::Vectors::map<std::shared_ptr<Resource::Uri>, Resource::File>(
                inputs, [] (const auto & file) { return std::shared_ptr<Resource::Uri>(new Resource::File(file)); }
            )
            , Util::Vectors::map<std::shared_ptr<Resource::Uri>, Resource::File>(
                specs, [] (const auto & file) { return std::shared_ptr<Resource::Uri>(new Resource::File(file)); }
            )
        ) {}

    public: template <typename ... UriT>
    EnvironmentConfiguration(const Resource::Uri & input,
                             const Resource::Uri & firstTypeSpecifications,
                             const UriT & ... moreTypeSpecifications)
        : propertyStringsHierarchy(Impl::EnvironmentConfigurationBuilderUtils::createPropertyStrings({ input.clone() }))
        , typeSpecificationsUris(
            Util::Vectors::pushBack(
                  std::shared_ptr<Resource::Uri>(firstTypeSpecifications.clone())
                , std::shared_ptr<Resource::Uri>(moreTypeSpecifications.clone()) ...
            )
        ) {}

    public: template <typename ... UriT>
    EnvironmentConfiguration(const std::shared_ptr<Resource::Uri> & input,
                             const std::shared_ptr<Resource::Uri> & firstTypeSpecifications,
                             const UriT & ... moreTypeSpecifications)
        : propertyStringsHierarchy(Impl::EnvironmentConfigurationBuilderUtils::createPropertyStrings({ input }))
        , typeSpecificationsUris(Util::Vectors::pushBack(firstTypeSpecifications, moreTypeSpecifications ...)) {}

    public: EnvironmentConfiguration(const std::string & input, const std::string & typeSpecifications_)
        : propertyStringsHierarchy(Impl::EnvironmentConfigurationBuilderUtils::createPropertyStrings({ std::shared_ptr<Resource::Uri>(new Resource::StringUri(input)) }))
        , typeSpecificationsUris(Util::Vectors::pushBack(std::shared_ptr<Resource::Uri>(new Resource::StringUri(input)))) {}

    public: EnvironmentConfiguration(const Resource::Uri & input)
        : propertyStringsHierarchy(Impl::EnvironmentConfigurationBuilderUtils::createPropertyStrings({ input.clone() })) {}

    public: EnvironmentConfiguration(const std::shared_ptr<Resource::Uri> & input)
        : propertyStringsHierarchy(Impl::EnvironmentConfigurationBuilderUtils::createPropertyStrings({ input })) {}

    public: EnvironmentConfiguration(const std::string & input)
        : propertyStringsHierarchy(Impl::EnvironmentConfigurationBuilderUtils::createPropertyStrings({ std::shared_ptr<Resource::Uri>(new Resource::StringUri(input)) })) {}


    protected: template <typename ... FactoryPtrT>
    Impl::PropertyBindingBuilderFactoryPtr group(std::string name, FactoryPtrT ... tokens) const {
        auto factory = Impl::PropertyBindingBuilderFactoryPtr(
            new Impl::CompositePropertyBindingBuilderFactory(std::move(name))
        );

        allBindingBuilderFactories.emplace_back(factory);

        auto composite = std::static_pointer_cast<Impl::CompositePropertyBindingBuilderFactory>(factory);
        Impl::EnvironmentConfigurationBuilderUtils::addToComposite(*composite, tokens ...);
        Impl::EnvironmentConfigurationBuilderUtils::incrementLevel(tokens ...);

        return factory;
    }

    protected: template <typename ValueT = std::string>
    Impl::PropertyBindingBuilderFactoryPtr value(std::string name) const {
        auto factory = Impl::PropertyBindingBuilderFactoryPtr(
            new Impl::ValuePropertyBindingBuilderFactory<ValueT>(std::move(name))
        );

        allBindingBuilderFactories.emplace_back(factory);
        return factory;
    }

    protected: template <typename ValueT = std::string>
    Impl::PropertyBindingBuilderFactoryPtr value(std::string name, ValueT defaultValue) const {
        auto factory = Impl::PropertyBindingBuilderFactoryPtr(
            new Impl::ValuePropertyBindingBuilderFactory<ValueT>(std::move(name), defaultValue)
        );

        allBindingBuilderFactories.emplace_back(factory);
        return factory;
    }

    protected: template <typename BaseT>
    Impl::PropertyBindingBuilderFactoryPtr unique(std::string name) const {
        Impl::PropertyBindingBuilderFactoryPtr factory = Impl::getBindingBuilderFactory(typeid(BaseT), name, "");
        allBindingBuilderFactories.emplace_back(factory);
        return factory;
    }

    protected: template <typename BaseT>
    Impl::PropertyBindingBuilderFactoryPtr unique(std::string name, std::unique_ptr<BaseT> && defaultValue) const {
        Impl::PropertyBindingBuilderFactoryPtr factory = Impl::getBindingBuilderFactory(typeid(BaseT), name, "");
        auto f = factory->clone(name, defaultValue);
        allBindingBuilderFactories.emplace_back(f);
        return f;
    }

    protected: template <typename BaseT>
    Impl::PropertyBindingBuilderFactoryPtr unique(std::string name, const UniquePropertyCloner<BaseT> & cloner) const {
        auto factory = Impl::PropertyBindingBuilderFactoryPtr(
            new Impl::UniquePropertyBindingBuilderFactory<BaseT>(std::move(name), cloner)
        );

        allBindingBuilderFactories.emplace_back(factory);
        return factory;
    }

    protected: template <typename BaseT>
    Impl::PropertyBindingBuilderFactoryPtr unique(std::string name,
                                                  const UniquePropertyCloner<BaseT> & cloner,
                                                  std::unique_ptr<BaseT> && defaultValue) const {
        auto factory = Impl::PropertyBindingBuilderFactoryPtr(
            new Impl::UniquePropertyBindingBuilderFactory<BaseT>(std::move(name), cloner, std::move(defaultValue))
        );

        allBindingBuilderFactories.emplace_back(factory);
        return factory;
    }


    //
    // Empty configure() implementation. Called when a non-derived EnvironmentConfiguration
    // instance is created by specifying one or more type specification URIs.
    //
    public: void configure() const override {}

    //
    // The main build method. Run after the configure() method by the base class.
    // This method delegates the building to a separate builder class.
    //
    public: std::vector<std::shared_ptr<Impl::BindingBuilderBase>> build() const override {
        if (!testing) {
            std::vector<Impl::PropertyBindingBuilderFactoryPtr> bindingBuilderFactoriesVector;

            for (auto & factory : allBindingBuilderFactories) {
                if (factory->level == 0) {
                    bindingBuilderFactoriesVector.push_back(std::move(factory));
                }
            }

            builders = Impl::EnvironmentConfigurationBuilder::build(
                typeSpecificationsUris, bindingBuilderFactoriesVector, propertyStringsHierarchy
            );
        }

        return builders;
    }

    public: std::vector<const InjectorConfiguration *> getExtraConfiguration() const override {
        return std::vector<const InjectorConfiguration *>(); // Not used.
    }

    public: std::list<std::function<void (const Injector& )>> getPostConstructionCalls() const override {
        return std::list<std::function<void (const Injector& )>>(); // Not used.
    }

    public: std::list<std::function<void ()>> getPreDestructionCalls() const override {
        return std::list<std::function<void ()>>(); // Not used.
    }

    public: std::list<std::unique_ptr<StaticSingletonRegistrationBase>> getStaticSingletonPostConstructionCalls() const override {
        return std::list<std::unique_ptr<StaticSingletonRegistrationBase>>(); // Not used.
    }

    private: static std::shared_ptr<Resource::Uri> verifyPropertyFileExists(const Resource::File & propertyFile) {
        using ::toString;

        if (!propertyFile.exists()) {
            ThrowBalauException(
                  Exception::EnvironmentConfigurationException
                , toString("The property file does not exist: ", propertyFile)
            );
        }

        if (!propertyFile.isRegularFile()) {
            ThrowBalauException(
                  Exception::EnvironmentConfigurationException
                , toString("The property file is not a regular file: ", propertyFile)
            );
        }

        return propertyFile.clone();
    }

    friend class Impl::PropertyTypeSpecificationVisitor;

    //
    // The property strings trie is built during construction, by passing the input properties file
    // to the property parser service, then running the visitor to construct the hierarchy.
    //
    private: Container::ObjectTrie<Impl::PropertyString> propertyStringsHierarchy;

    //
    // The URIs of the type specification sources that will be used
    // (used during direct usage of the EnvironmentConfiguration class).
    //
    private: std::vector<std::shared_ptr<Resource::Uri>> typeSpecificationsUris;

    //
    // Temporary data structure used to hold binding builder factories during the
    // configure() method call. The binding builder factories are kept in an
    // initially flatted structure (this vector).
    //
    // Before executing the main builder logic, the level 0 factories are extracted
    // into a new vector.
    //
    private: mutable std::vector<Impl::PropertyBindingBuilderFactoryPtr> allBindingBuilderFactories;

    //
    // The binding builders are constructed in the second part of the build() method call,
    // by iterating over the property strings hierarchy.
    //
    //  - If the property is composite, an EnvironmentProperties named binding is created.
    //
    //  - If the property is simple and a corresponding binding builder factory is found
    //    in the binding builder factory hierarchy, a typed named binding is created.
    //
    //  - If the property is simple and no corresponding binding builder factory is found
    //    in the binding builder factory hierarchy, a std::string named binding is created.
    //
    // During iteration over the property strings hierarchy, the constructed bindings are
    // placed within the current binding level. The level is either the root (injector)
    // level or is a descendant EnvironmentProperties instance.
    //
    private: mutable std::vector<std::shared_ptr<Impl::BindingBuilderBase>> builders;

    friend struct Impl::EnvironmentConfigurationBuilderTest;

    // For testing only.
    private: static EnvironmentConfiguration testInstance(std::vector<std::shared_ptr<Impl::BindingBuilderBase>> && builders_) {
        EnvironmentConfiguration conf;
        conf.builders = std::move(builders_);
        return conf;
    }

    // For testing only.
    private: EnvironmentConfiguration() : testing(true) {}

    // For testing only. Bypasses the normal binding builder creation.
    private: const bool testing = false;
};

} // namespace Balau

#pragma clang diagnostic pop

#endif // COM_BORA_SOFTWARE__BALAU_APPLICATION__ENVIRONMENT_CONFIGURATION