Person.h

// SPDX-License-Identifier: GPL-2.0-only
 
#pragma once
 
#include <optional>
#include <string>
 
#include "../helpers/Enum.h"
 
namespace SlKernCVS {

enum class RoleType {
    Author,     First = Author,
    SignedOffBy,    FirstRole = SignedOffBy,
    CoDevelopedBy,
    SuggestedBy,
    ReviewedBy,
    AckedBy,    LastRole = AckedBy,
    TestedBy,
    ReportedBy,
    Maintainer,
    Upstream,   Last = Upstream,
};

class Role {
private:
    static constexpr const std::string_view roleNames[] = {
        "Author",
        "Signed-off-by",
        "Co-developed-by",
        "Suggested-by",
        "Reviewed-by",
        "Acked-by",
        "Tested-by",
        "Reported-by",
        "Maintainer",
        "Upstream"
    };
    static_assert(static_cast<size_t>(RoleType::Last) + 1 == std::size(roleNames));
public:
    Role() = delete;
    Role(size_t index) : m_role(static_cast<RoleType>(index)) {}
    Role(RoleType role) : m_role(role) {}

    RoleType role() const { return m_role; }

    static constexpr auto index(RoleType role) {
        return static_cast<std::size_t>(role);
    }

    static constexpr auto toString(RoleType role) {
        return roleNames[index(role)];
    }

    constexpr auto index() const { return index(m_role); }
    constexpr auto toString() const { return toString(m_role); }
private:
    RoleType m_role;
};

class Person {
public:
    Person() = delete;

    Person(Role r, std::string name, std::string email, unsigned count = 0) :
        m_role(std::move(r)), m_name(std::move(name)), m_email(std::move(email)),
        m_count(count) {}

    const Role &role() const { return m_role; }
    const std::string &name() const { return m_name; }
    const std::string &email() const { return m_email; }
    std::string userName() const { return m_email.substr(0, m_email.find("@")); }

    auto count() const { return m_count; }

    std::string pretty(bool includeName = true) const {
        if (includeName && !name().empty())
            return name() + " <" + email() + ">";
        return email();
    }

    template <typename T>
    requires requires (T t, std::string s) { { t(s) } -> std::convertible_to<std::string>; }
    std::string pretty(const T &translate, bool includeName = true) const {
        if (includeName && !name().empty())
            return name() + " <" + translate(email()) + ">";
        return translate(email());
    }

    void setEmail(const std::string &email) { m_email = email; }

    static std::optional<Person> parsePerson(std::string_view src, Role role);

    static std::optional<Person> parse(std::string_view src)
    {
        SlHelpers::EnumRange<RoleType> range{RoleType::FirstRole, RoleType::LastRole};
        for (auto I: range) {
            Role r(I);
            if (src.starts_with(r.toString()))
                if (auto p = parsePerson(src, std::move(r)))
                    return p;
        }
        return std::nullopt;
    }
private:
    Role m_role;
    std::string m_name;
    std::string m_email;
    unsigned m_count;
 
};
 
} // namespace