Taggable.hpp

#pragma once
 
#include "util/Assert.hpp"
#include "util/config/ConfigDefinition.hpp"
 
#include <boost/algorithm/string/predicate.hpp>
#include <boost/json.hpp>
#include <boost/json/conversion.hpp>
#include <boost/json/value.hpp>
#include <boost/uuid/uuid.hpp>
#include <boost/uuid/uuid_io.hpp>
 
#include <atomic>
#include <functional>
#include <memory>
#include <optional>
#include <ostream>
#include <string>
#include <string_view>
#include <utility>
 
namespace util {
namespace impl {

struct NullTagGenerator final {};

struct UIntTagGenerator final {
    using TagType = std::atomic_uint64_t;
 
    static TagType
    next();
};

struct UUIDTagGenerator final {
    using TagType = boost::uuids::uuid;
 
    static TagType
    next();
};
 
}  // namespace impl

class BaseTagDecorator {
public:
    virtual ~BaseTagDecorator() = default;

    virtual void
    decorate(std::ostream& os) const = 0;

    friend std::ostream&
    operator<<(std::ostream& os, BaseTagDecorator const& decorator)
    {
        decorator.decorate(os);
        return os;
    }

    std::string
    toString() const
    {
        std::ostringstream oss;
        decorate(oss);
        return std::move(oss).str();
    }
};

template <typename Generator>
class TagDecorator final : public BaseTagDecorator {
    using ParentType = std::optional<std::reference_wrapper<BaseTagDecorator const>>;
    using TagType = typename Generator::TagType;
 
    ParentType parent_ = std::nullopt;
    TagType tag_ = Generator::next();
 
public:
    explicit TagDecorator(ParentType parent = std::nullopt) : parent_{parent}
    {
    }

    void
    decorate(std::ostream& os) const override
    {
        os << "[";
 
        if (parent_.has_value())
            (*parent_).get().decorate(os);
 
        os << tag_ << "] ";
    }
};

template <>
class TagDecorator<impl::NullTagGenerator> final : public BaseTagDecorator {
public:
    void
    decorate([[maybe_unused]] std::ostream& os) const override
    {
        // nop
    }
};

class TagDecoratorFactory final {
    using ParentType = std::optional<std::reference_wrapper<BaseTagDecorator const>>;

    enum class Type {
        NONE, 
        UUID, 
        UINT  
    };
 
    Type type_;                        /*< The type of TagDecorator this factory produces */
    ParentType parent_ = std::nullopt; /*< The parent tag decorator to bind */
 
    static Type
    getLogTagType(std::string_view style)
    {
        if (boost::iequals(style, "int") || boost::iequals(style, "uint"))
            return TagDecoratorFactory::Type::UINT;
 
        if (boost::iequals(style, "null") || boost::iequals(style, "none"))
            return TagDecoratorFactory::Type::NONE;
 
        if (boost::iequals(style, "uuid"))
            return TagDecoratorFactory::Type::UUID;
 
        ASSERT(false, "log.tag_style does not have valid value");
        std::unreachable();
    }
 
public:
    ~TagDecoratorFactory() = default;

    explicit TagDecoratorFactory(util::config::ClioConfigDefinition const& config)
        : type_{getLogTagType(config.get<std::string>("log.tag_style"))}
    {
    }
 
private:
    TagDecoratorFactory(Type type, ParentType parent) noexcept : type_{type}, parent_{parent}
    {
    }
 
public:
    std::unique_ptr<BaseTagDecorator>
    make() const;

    TagDecoratorFactory
    with(ParentType parent) const noexcept;
};

class Taggable {
    using DecoratorType = std::unique_ptr<BaseTagDecorator>;
    DecoratorType tagDecorator_;
 
protected:
    explicit Taggable(util::TagDecoratorFactory const& tagFactory)
        : tagDecorator_{tagFactory.make()}
    {
    }
 
public:
    virtual ~Taggable() = default;
    Taggable(Taggable&&) = default;
 
    Taggable&
    operator=(Taggable&&) = default;

    BaseTagDecorator const&
    tag() const
    {
        return *tagDecorator_;
    }
};
 
}  // namespace util