dynamic_cased_name.hpp

Go to the documentation of this file.

#pragma once
 
#include <compare>
#include <format>
#include <ostream>
#include <string>
#include <vector>
 
namespace porytiles {
 
class DynamicCasedName {
  public:
    DynamicCasedName() = default;
 
    explicit DynamicCasedName(const std::string &input);
 
    [[nodiscard]] static DynamicCasedName from_snake_case(const std::string &input);
 
    [[nodiscard]] static DynamicCasedName from_pascal_case(const std::string &input);
 
    [[nodiscard]] static DynamicCasedName from_c_identifier(const std::string &input);
 
    [[nodiscard]] static DynamicCasedName from_flat_case(const std::string &input);
 
    [[nodiscard]] std::string to_snake_case() const;
 
    [[nodiscard]] std::string to_pascal_case() const;
 
    [[nodiscard]] std::string to_c_identifier() const;
 
    [[nodiscard]] std::string to_flat_case() const;
 
    [[nodiscard]] const std::string &canonical() const
    {
        return canonical_;
    }
 
    [[nodiscard]] bool empty() const
    {
        return segments_.empty();
    }
 
    [[nodiscard]] const std::vector<std::vector<std::string>> &segments() const
    {
        return segments_;
    }
 
    [[nodiscard]] bool operator==(const DynamicCasedName &other) const
    {
        return canonical_ == other.canonical_;
    }
 
    [[nodiscard]] auto operator<=>(const DynamicCasedName &other) const
    {
        return canonical_ <=> other.canonical_;
    }
 
  private:
    std::vector<std::vector<std::string>> segments_;
    std::string canonical_;
 
    explicit DynamicCasedName(std::vector<std::vector<std::string>> segments);
    void compute_canonical();
};
 
[[nodiscard]] std::string to_string(const DynamicCasedName &value);
 
inline std::ostream &operator<<(std::ostream &os, const DynamicCasedName &value)
{
    os << to_string(value);
    return os;
}
 
} // namespace porytiles
 
template <>
struct std::hash<porytiles::DynamicCasedName> {
    std::size_t operator()(const porytiles::DynamicCasedName &name) const noexcept
    {
        return std::hash<std::string>{}(name.canonical());
    }
};
 
template <>
struct std::formatter<porytiles::DynamicCasedName> {
    constexpr auto parse(std::format_parse_context &ctx)
    {
        return ctx.begin();
    }
 
    auto format(const porytiles::DynamicCasedName &value, auto &ctx) const
    {
        return std::format_to(ctx.out(), "{}", porytiles::to_string(value));
    }
};