parameter_value.h

Go to the documentation of this file.

/*
 * Copyright 2021 MusicScience37 (Kenta Kabashima)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#pragma once
 
#include <cstddef>
#include <cstdint>
#include <functional>
#include <memory>
#include <string>
#include <type_traits>
#include <typeindex>
#include <typeinfo>
#include <utility>
#include <variant>
 
#include <fmt/format.h>
 
#include "stat_bench/stat_bench_exception.h"
#include "stat_bench/util/utf8_string.h"
 
namespace stat_bench {
namespace param {

using ParameterValueVariant =
    std::variant<bool, std::intmax_t, std::uintmax_t, long double, std::string>;

template <typename T>
struct ParameterValueTraits {
    [[nodiscard]] static auto get_type() -> const std::type_info& {
        return typeid(T);
    }

    [[nodiscard]] static auto to_string(const std::shared_ptr<void>& data)
        -> util::Utf8String {
        return util::Utf8String(
            fmt::format("{}", *static_cast<const T*>(data.get())));
    }

    [[nodiscard]] static auto to_double(const std::shared_ptr<void>& data)
        -> double {
        if constexpr (std::is_convertible_v<T, double>) {
            return static_cast<double>(*static_cast<const T*>(data.get()));
        } else {
            throw StatBenchException(
                fmt::format("Cannot convert {} to double.", typeid(T).name()));
        }
    }

    [[nodiscard]] static auto to_variant(const std::shared_ptr<void>& data)
        -> ParameterValueVariant {
        if constexpr (std::is_same_v<T, bool>) {
            return *static_cast<const bool*>(data.get());
        } else if constexpr (std::is_integral_v<T> && std::is_signed_v<T>) {
            return static_cast<std::intmax_t>(
                *static_cast<const T*>(data.get()));
        } else if constexpr (std::is_integral_v<T> && std::is_unsigned_v<T>) {
            return static_cast<std::uintmax_t>(
                *static_cast<const T*>(data.get()));
        } else if constexpr (std::is_floating_point_v<T>) {
            return static_cast<long double>(*static_cast<const T*>(data.get()));
        } else if constexpr (std::is_same_v<T, std::string>) {
            return *static_cast<const std::string*>(data.get());
        } else {
            return fmt::format("{}", *static_cast<const T*>(data.get()));
        }
    }

    [[nodiscard]] static auto calculate_hash(const std::shared_ptr<void>& data)
        -> std::size_t {
        return std::hash<std::type_index>{}(std::type_index(typeid(T))) ^
            std::hash<T>{}(*static_cast<const T*>(data.get()));
    }

    [[nodiscard]] static auto equal(const std::shared_ptr<void>& data1,
        const std::shared_ptr<void>& data2) -> bool {
        return *static_cast<const T*>(data1.get()) ==
            *static_cast<const T*>(data2.get());
    }
};

class ParameterValue {
public:
    ParameterValue() noexcept = default;

    template <typename T, typename... Args>
    auto emplace(Args&&... args) -> ParameterValue& {
        data_ = std::make_shared<T>(std::forward<Args>(args)...);
        get_type_ = &ParameterValueTraits<T>::get_type;
        to_string_ = &ParameterValueTraits<T>::to_string;
        to_double_ = &ParameterValueTraits<T>::to_double;
        to_variant_ = &ParameterValueTraits<T>::to_variant;
        calculate_hash_ = &ParameterValueTraits<T>::calculate_hash;
        equal_ = &ParameterValueTraits<T>::equal;
        return *this;
    }

    void clear() noexcept { data_.reset(); }

    template <typename T>
    [[nodiscard]] auto is_type_of() const -> bool {
        if (!data_) {
            return false;
        }
        return get_type_() == typeid(T);
    }

    template <typename T>
    [[nodiscard]] auto as() const -> const T& {
        if (!data_) {
            throw StatBenchException(
                "Tried to get value from empty ParameterValue object.");
        }
        if (!is_type_of<T>()) {
            throw StatBenchException(fmt::format(
                "Wrong type of parameter value (expected: {}, actual: {}).",
                typeid(T).name(), get_type_().name()));
        }
        return *static_cast<const T*>(data_.get());
    }

    [[nodiscard]] auto to_string() const -> util::Utf8String {
        if (!data_) {
            return util::Utf8String("null");
        }
        return to_string_(data_);
    }

    [[nodiscard]] auto to_double() const -> double {
        if (!data_) {
            throw StatBenchException(
                "Tried to convert an empty ParameterValue object to double.");
        }
        return to_double_(data_);
    }

    [[nodiscard]] auto to_variant() const -> ParameterValueVariant {
        if (!data_) {
            throw StatBenchException(
                "Tried to convert an empty ParameterValue object to a variant "
                "object.");
        }
        return to_variant_(data_);
    }

    [[nodiscard]] auto calculate_hash() const -> std::size_t {
        if (!data_) {
            return 0;
        }
        return calculate_hash_(data_);
    }

    [[nodiscard]] auto operator==(const ParameterValue& rhs) const -> bool {
        if (!data_ && !rhs.data_) {
            return true;
        }
        if (!data_ || !rhs.data_) {
            return false;
        }
        if (get_type_() != rhs.get_type_()) {
            return false;
        }
        return equal_(data_, rhs.data_);
    }

    [[nodiscard]] auto operator!=(const ParameterValue& rhs) const -> bool {
        return !(*this == rhs);
    }
 
private:
    using GetTypeSignature = const std::type_info&();

    using ToStringSignature = util::Utf8String(const std::shared_ptr<void>&);

    using ToDoubleSignature = double(const std::shared_ptr<void>&);

    using ToVariantSignature = ParameterValueVariant(
        const std::shared_ptr<void>&);

    using CalculateHashSignature = std::size_t(const std::shared_ptr<void>&);

    using EqualSignature = bool(
        const std::shared_ptr<void>&, const std::shared_ptr<void>&);

    std::shared_ptr<void> data_{};

    GetTypeSignature* get_type_{nullptr};

    ToStringSignature* to_string_{nullptr};

    ToDoubleSignature* to_double_{nullptr};

    ToVariantSignature* to_variant_{nullptr};

    CalculateHashSignature* calculate_hash_{nullptr};

    EqualSignature* equal_{nullptr};
};
 
}  // namespace param
}  // namespace stat_bench
 
namespace std {

template <>
class hash<stat_bench::param::ParameterValue> {
public:
    auto operator()(const stat_bench::param::ParameterValue& val) const
        -> std::size_t {
        return val.calculate_hash();
    }
};
 
}  // namespace std