parameter_dict.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
 
// IWYU pragma: no_include <string>
 
#include <cstddef>
#include <functional>
#include <unordered_map>
#include <utility>
 
#include <fmt/base.h>
#include <fmt/format.h>
 
#include "stat_bench/param/parameter_name.h"
#include "stat_bench/param/parameter_value.h"
#include "stat_bench/stat_bench_exception.h"
#include "stat_bench/util/ordered_map.h"
#include "stat_bench/util/utf8_string.h"
 
namespace stat_bench {
namespace param {

class ParameterDict {
public:
    explicit ParameterDict(
        util::OrderedMap<ParameterName, ParameterValue> data);

    [[nodiscard]] auto empty() const noexcept -> bool;

    [[nodiscard]] auto has(const ParameterName& param_name) const -> bool;

    template <typename T>
    [[nodiscard]] auto get(const ParameterName& param_name) const -> const T& {
        const auto iter = data_.find(param_name);
        if (iter == data_.end()) {
            throw StatBenchException(
                fmt::format("Parameter {} not found.", param_name));
        }
        return iter->second.as<T>();
    }

    [[nodiscard]] auto get_as_double(const ParameterName& param_name) const
        -> double;

    [[nodiscard]] auto get_as_variant(const ParameterName& param_name) const
        -> ParameterValueVariant;

    [[nodiscard]] auto format_to(fmt::format_context::iterator out) const
        -> fmt::format_context::iterator;

    [[nodiscard]] auto as_string_dict() const
        -> std::unordered_map<util::Utf8String, util::Utf8String>;

    [[nodiscard]] auto clone_without(const ParameterName& param_name) const
        -> ParameterDict;

    [[nodiscard]] auto calculate_hash() const -> std::size_t;

    [[nodiscard]] auto operator==(const ParameterDict& rhs) const -> bool;

    [[nodiscard]] auto operator!=(const ParameterDict& rhs) const -> bool;
 
private:
    util::OrderedMap<ParameterName, ParameterValue> data_;
};
 
}  // namespace param
}  // namespace stat_bench
 
namespace fmt {

template <>
struct formatter<stat_bench::param::ParameterDict>
    : public formatter<string_view> {
    auto format(const stat_bench::param::ParameterDict& val,
        format_context& context) const -> typename format_context::iterator;
};
 
}  // namespace fmt
 
namespace std {

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