EnvironmentProperties.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_PROPERTIES
#define COM_BORA_SOFTWARE__BALAU_APPLICATION__ENVIRONMENT_PROPERTIES

#include <Balau/Dev/Assert.hpp>
#include <Balau/Application/BindingBuilder.hpp>
#include <Balau/Application/Impl/BindingMap.hpp>
#include <Balau/Exception/InjectorExceptions.hpp>
#include <Balau/Resource/File.hpp>
#include <Balau/Type/FromString.hpp>
#include <Balau/Util/Files.hpp>
#include <Balau/Util/Streams.hpp>

namespace Balau {

namespace Impl {

class EnvironmentConfigurationBuilder;

} // namespace Impl

class EnvironmentProperties {
    public: class Item {
        public: std::string_view getName() const {
            return key.name;
        }

        public: Impl::BindingKey getKey() const {
            return key.toKey();
        }

        public: template <typename ValueT> bool isValue() const {
            return key == Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, ValueT>), key.name);
        }

        public: template <typename BaseT> bool isUnique() const {
            return key == Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, std::default_delete<BaseT>>), key.name);
        }

        public: bool isComposite() const {
            return key == Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, EnvironmentProperties>), key.name);
        }

        public: template <typename ValueT> ValueT getValue() const {
            return owner.getValue<ValueT>(
                Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, ValueT>), key.name)
            );
        }

        public: template <typename ValueT> ValueT getValue(const ValueT & defaultValue) const {
            return owner.getValue<ValueT>(
                Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, ValueT>), key.name), defaultValue
            );
        }

        public: template <typename BaseT> std::unique_ptr<BaseT> getUnique() const {
            return owner.getUnique<BaseT>(
                Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, std::default_delete<BaseT>>), key.name)
            );
        }

        public: template <typename BaseT> std::unique_ptr<BaseT> getUnique(std::unique_ptr<BaseT> && defaultValue) const {
            return owner.getUnique<BaseT>(
                  Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, std::default_delete<BaseT>>), key.name)
                , std::move(defaultValue)
            );
        }

        public: std::shared_ptr<EnvironmentProperties> getComposite() const {
            return owner.getComposite(
                Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, EnvironmentProperties>), key.name)
            );
        }

        public: std::shared_ptr<EnvironmentProperties> getCompositeOrNull() const {
            return owner.getCompositeOrNull(
                Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, EnvironmentProperties>), key.name)
            );
        }

        friend class EnvironmentProperties;

        private: Item(const EnvironmentProperties & owner_, const Impl::BindingKeyView & key_)
            : owner(owner_)
            , key(key_) {}

        private: const EnvironmentProperties & owner;
        private: const Impl::BindingKeyView key;
    };

    public: class iterator {
        public: iterator(const iterator & copy)
            : owner(copy.owner)
            , mapIterator(copy.mapIterator) {}

        public: iterator & operator = (const iterator & copy) {
            mapIterator = copy.mapIterator;
            return *this;
        }

        public: iterator operator ++ (int) {
            iterator ret = *this;
            ++mapIterator;
            return ret;
        }

        public: iterator & operator ++ () {
            ++mapIterator;
            return *this;
        }

        public: Item operator * () const {
            return Item(owner, Impl::BindingKeyView(mapIterator->key));
        }

        public: bool operator == (const iterator & rhs) const {
            return mapIterator == rhs.mapIterator;
        }

        public: bool operator != (const iterator & rhs) const {
            return mapIterator != rhs.mapIterator;
        }

        friend class EnvironmentProperties;

        private: explicit iterator(const EnvironmentProperties & owner_, Impl::BindingMap::ConstIterator mapIterator_)
            : owner(owner_)
            , mapIterator(mapIterator_) {}

        private: const EnvironmentProperties & owner;
        private: Impl::BindingMap::ConstIterator mapIterator;
    };

    public: typedef iterator const_iterator;


    public: template <typename ValueT>
    bool hasValue(std::string_view name) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, ValueT>), name);
        return bindings->hasBinding(keyView);
    }

    public: template <typename BaseT>
    bool hasUnique(std::string_view name) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, std::default_delete<BaseT>>), name);
        return bindings->hasBinding(keyView);
    }

    public: bool hasComposite(std::string_view name) const {
        const Impl::BindingKeyView keyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, EnvironmentProperties>), name);
        return bindings->hasBinding(keyView);
    }

    public: template <typename ValueT> ValueT getValue(std::string_view name) const {
        return getValue<ValueT>(
            Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, ValueT>), name)
        );
    }

    public: template <typename ValueT> ValueT getValue(std::string_view name, const ValueT & defaultValue) const {
        return getValue<ValueT>(
            Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Value, ValueT>), name), defaultValue
        );
    }

    public: template <typename BaseT> std::unique_ptr<BaseT> getUnique(std::string_view name) const {
        return getUnique<BaseT>(
            Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, std::default_delete<BaseT>>), name)
        );
    }

    public: template <typename BaseT> std::unique_ptr<BaseT> getUnique(std::string_view name, std::unique_ptr<BaseT> && defaultValue) const {
        return getUnique<BaseT>(
            Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Unique, BaseT, std::default_delete<BaseT>>), name), defaultValue
        );
    }

    public: std::shared_ptr<EnvironmentProperties> getComposite(std::string_view name) const {
        return getComposite(
            Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, EnvironmentProperties>), name)
        );
    }

    public: std::shared_ptr<EnvironmentProperties> getCompositeOrNull(std::string_view name) const {
        return getCompositeOrNull(
            Impl::BindingKeyView(typeid(Impl::BindingKeyType<Impl::BindingMetaType::Shared, EnvironmentProperties>), name)
        );
    }

    public: iterator begin() {
        return iterator(*this, bindings->begin());
    }

    public: iterator end() {
        return iterator(*this, bindings->end());
    }

    public: const_iterator begin() const {
        return const_iterator(*this, bindings->begin());
    }

    public: const_iterator end() const {
        return const_iterator(*this, bindings->end());
    }

    public: bool empty() const {
        return bindings->begin() == bindings->end();
    }

    public: EnvironmentProperties(std::unique_ptr<const Impl::BindingMap> && bindings_)
        : bindings(std::move(bindings_)) {}

    public: EnvironmentProperties()
        : bindings(new Impl::BindingMap()) {}


    friend class EnvironmentConfiguration;
    friend class Impl::EnvironmentConfigurationBuilder;

    private: template <typename ValueT> ValueT getValue(const Impl::BindingKeyView & keyView) const {
        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return static_cast<const Impl::AbstractValueBinding<ValueT> *>(binding->get())->get(nullptr);
        } else {
            ThrowBalauException(Exception::NoBindingException, keyView.toKey());
        }
    }

    private: template <typename ValueT> ValueT getValue(const Impl::BindingKeyView & keyView, const ValueT & defaultValue) const {
        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return static_cast<const Impl::AbstractValueBinding<ValueT> *>(binding->get())->get(nullptr);
        } else {
            return defaultValue;
        }
    }

    private: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>> std::unique_ptr<BaseT> getUnique(const Impl::BindingKeyView & keyView) const {
        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return static_cast<const Impl::AbstractUniquePtrBinding<BaseT, DeleterT> *>(binding->get())->get(nullptr);
        } else {
            ThrowBalauException(Exception::NoBindingException, keyView.toKey());
        }
    }

    private: template <typename BaseT, typename DeleterT = std::default_delete<BaseT>> std::unique_ptr<BaseT> getUnique(const Impl::BindingKeyView & keyView, std::unique_ptr<BaseT> && defaultValue) const {
        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            return static_cast<const Impl::AbstractUniquePtrBinding<BaseT, DeleterT> *>(binding->get())->get(nullptr);
        } else {
            return std::move(defaultValue);
        }
    }

    private: std::shared_ptr<EnvironmentProperties> getComposite(const Impl::BindingKeyView & keyView) const {
        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            // Environment properties shared bindings are always of type ProvidedSingletonBinding.
            // These do not use the injector instance, thus nullptr can be passed without any issues.
            return static_cast<const Impl::AbstractSharedPtrBinding<EnvironmentProperties> *>(binding->get())->get(nullptr);
        } else {
            ThrowBalauException(Exception::NoBindingException, keyView.toKey());
        }
    }

    private: std::shared_ptr<EnvironmentProperties> getCompositeOrNull(const Impl::BindingKeyView & keyView) const {
        const auto * binding = bindings->find(keyView);

        if (binding != nullptr) {
            // Environment properties shared bindings are always of type ProvidedSingletonBinding.
            // These do not use the injector instance, thus nullptr can be passed without any issues.
            return static_cast<const Impl::AbstractSharedPtrBinding<EnvironmentProperties> *>(binding->get())->get(nullptr);
        } else {
            return std::shared_ptr<EnvironmentProperties>();
        }
    }

    private: const std::unique_ptr<const Impl::BindingMap> bindings;
};

} // namespace Balau

#endif // COM_BORA_SOFTWARE__BALAU_APPLICATION__ENVIRONMENT_PROPERTIES