error.cpp

#include <xrpld/conditions/detail/error.h>
 
#include <xrpl/basics/safe_cast.h>
 
#include <string>
 
namespace ripple {
namespace cryptoconditions {
namespace detail {
 
class cryptoconditions_error_category : public std::error_category
{
public:
    explicit cryptoconditions_error_category() = default;
 
    char const*
    name() const noexcept override
    {
        return "cryptoconditions";
    }
 
    std::string
    message(int ev) const override
    {
        switch (safe_cast<error>(ev))
        {
            case error::unsupported_type:
                return "Specification: Requested type not supported.";
 
            case error::unsupported_subtype:
                return "Specification: Requested subtype not supported.";
 
            case error::unknown_type:
                return "Specification: Requested type not recognized.";
 
            case error::unknown_subtype:
                return "Specification: Requested subtypes not recognized.";
 
            case error::fingerprint_size:
                return "Specification: Incorrect fingerprint size.";
 
            case error::incorrect_encoding:
                return "Specification: Incorrect encoding.";
 
            case error::trailing_garbage:
                return "Bad buffer: contains trailing garbage.";
 
            case error::buffer_empty:
                return "Bad buffer: no data.";
 
            case error::buffer_overfull:
                return "Bad buffer: overfull.";
 
            case error::buffer_underfull:
                return "Bad buffer: underfull.";
 
            case error::malformed_encoding:
                return "Malformed DER encoding.";
 
            case error::unexpected_tag:
                return "Malformed DER encoding: Unexpected tag.";
 
            case error::short_preamble:
                return "Malformed DER encoding: Short preamble.";
 
            case error::long_tag:
                return "Implementation limit: Overlong tag.";
 
            case error::large_size:
                return "Implementation limit: Large payload.";
 
            case error::preimage_too_long:
                return "Implementation limit: Specified preimage is too long.";
 
            case error::generic:
            default:
                return "generic error";
        }
    }
 
    std::error_condition
    default_error_condition(int ev) const noexcept override
    {
        return std::error_condition{ev, *this};
    }
 
    bool
    equivalent(int ev, std::error_condition const& condition)
        const noexcept override
    {
        return &condition.category() == this && condition.value() == ev;
    }
 
    bool
    equivalent(std::error_code const& error, int ev) const noexcept override
    {
        return &error.category() == this && error.value() == ev;
    }
};
 
inline std::error_category const&
get_cryptoconditions_error_category()
{
    static cryptoconditions_error_category const cat{};
    return cat;
}
 
}  // namespace detail
 
std::error_code
make_error_code(error ev)
{
    return std::error_code{
        safe_cast<std::underlying_type<error>::type>(ev),
        detail::get_cryptoconditions_error_category()};
}
 
}  // namespace cryptoconditions
}  // namespace ripple