VariableName.h

Go to the documentation of this file.

 
// SPDX-License-Identifier: LGPL-2.1-or-later
 
#ifndef TASKOLIB_VARIABLENAME_H_
#define TASKOLIB_VARIABLENAME_H_
 
#include <functional>
#include <string>
#include <string_view>
 
#include <gul17/cat.h>
 
namespace task {
 
class VariableName
{
public:
    using SizeType = std::string::size_type;
    using size_type = std::string::size_type;
 
    VariableName(const char* name);
 
    explicit VariableName(const std::string& name);
    explicit VariableName(std::string&& name);
 
    SizeType length() const noexcept { return name_.size(); }
 
    friend bool operator==(const VariableName& a, const VariableName& b) noexcept
    {
        return a.string() == b.string();
    }
 
    friend bool operator!=(const VariableName& a, const VariableName& b) noexcept
    {
        return a.string() != b.string();
    }
 
    friend bool operator<(const VariableName& a, const VariableName& b) noexcept
    {
        return a.string() < b.string();
    }
 
    friend bool operator>(const VariableName& a, const VariableName& b) noexcept
    {
        return a.string() > b.string();
    }
 
    friend bool operator<=(const VariableName& a, const VariableName& b) noexcept
    {
        return a.string() <= b.string();
    }
 
    friend bool operator>=(const VariableName& a, const VariableName& b) noexcept
    {
        return a.string() >= b.string();
    }
 
    VariableName& operator+=(std::string_view suffix);
 
    friend std::string& operator+=(std::string& lhs, const VariableName& rhs)
    {
        lhs += rhs.string();
        return lhs;
    }
 
    friend std::string operator+(const VariableName& lhs, std::string_view rhs)
    {
        return gul17::cat(lhs.string(), rhs);
    }
 
    friend std::string operator+(std::string_view lhs, const VariableName& rhs)
    {
        return gul17::cat(lhs, rhs.string());
    }
 
    explicit operator const std::string&() const { return name_; }
 
    SizeType size() const noexcept { return name_.size(); }
 
    const std::string& string() const noexcept { return name_; }
 
private:
    std::string name_;
};
 
} // namespace task
 
 
namespace std {
 
template<>
struct hash<task::VariableName>
{
    std::size_t operator()(const task::VariableName& name) const noexcept
    {
        return std::hash<std::string>{}(name.string());
    }
};
 
} // namespace std
 
#endif