id_pair.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2006-2025, Knut Reinert & Freie Universität Berlin
// SPDX-FileCopyrightText: 2016-2025, Knut Reinert & MPI für molekulare Genetik
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <algorithm>
#include <string>
#include <unordered_set>
 
#include <sharg/platform.hpp>
 
namespace sharg::detail
{
 
struct id_pair
{
    char short_id{};       
    std::string long_id{}; 
 
    id_pair() = default;                            
    id_pair(id_pair const &) = default;             
    id_pair & operator=(id_pair const &) = default; 
    id_pair(id_pair &&) = default;                  
    id_pair & operator=(id_pair &&) = default;      
    ~id_pair() = default;                           
 
    id_pair(char const short_id) : short_id{short_id}
    {}
 
    id_pair(std::string long_id) : long_id{std::move(long_id)}
    {}
 
    id_pair(char const short_id, std::string long_id) : short_id{short_id}, long_id{std::move(long_id)}
    {}
 
    friend bool operator==(id_pair const & lhs, id_pair const & rhs)
    {
        return (!lhs.empty_short_id() && lhs.short_id == rhs.short_id)
            || (!lhs.empty_long_id() && lhs.long_id == rhs.long_id);
    }
 
    friend bool operator==(id_pair const & lhs, char const & rhs)
    {
        return !lhs.empty_short_id() && lhs.short_id == rhs;
    }
 
    friend bool operator==(id_pair const & lhs, std::string const & rhs)
    {
        return !lhs.empty_long_id() && lhs.long_id == rhs;
    }
 
    bool empty_short_id() const noexcept
    {
        return empty(short_id);
    }
 
    bool empty_long_id() const noexcept
    {
        return empty(long_id);
    }
 
    bool empty() const noexcept
    {
        return empty_short_id() && empty_long_id();
    }
 
    template <typename id_type>
    static bool empty(id_type const & id) noexcept;
 
    // Note: The following two functions are declared, but not defined.
    // We first need to specialise std::hash<id_pair> in the std namespace.
    // After that, we can define the functions.
    // Defining them here would generate std::hash<id_pair> before the specialisation.
    // 1.) Now there are two specialisations for std::hash<id_pair> (error)
    // 2.) The default-generated std::hash<id_pair> does actually not work
 
    template <typename id_type>
    static auto find(std::unordered_set<id_pair> const & used_ids, id_type const & id);
 
    template <typename id_type>
    static bool contains(std::unordered_set<id_pair> const & used_ids, id_type const & id);
};
 
} // namespace sharg::detail
 
namespace std
{
 
template <>
struct hash<sharg::detail::id_pair>
{
    size_t operator()(sharg::detail::id_pair const & value) const noexcept
    {
        size_t const h1 = std::hash<char>{}(value.short_id);
        size_t const h2 = std::hash<std::string>{}(value.long_id);
        return h1 ^ (h2 << 1);
    }
};
 
} // namespace std
 
namespace sharg::detail
{
 
template <typename id_type>
inline bool id_pair::empty(id_type const & id) noexcept
{
    if constexpr (std::same_as<id_type, id_pair>)
        return id.empty();
    else if constexpr (std::same_as<id_type, char>)
        return id == '\0';
    else
        return id.empty();
}
 
template <typename id_type>
inline auto id_pair::find(std::unordered_set<id_pair> const & used_ids, id_type const & id)
{
    if (empty(id))
        return used_ids.end();
 
    return std::ranges::find_if(used_ids,
                                [&id](id_pair const & pair)
                                {
                                    return pair == id;
                                });
}
 
template <typename id_type>
inline bool id_pair::contains(std::unordered_set<id_pair> const & used_ids, id_type const & id)
{
    return find(used_ids, id) != used_ids.end();
}
 
} // namespace sharg::detail