status.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <cstdint>
#include <optional>
#include <string>
#include <string_view>
 
namespace kcenon::network::protocols::grpc
{
    enum class status_code : uint32_t
    {
        ok = 0,                  
        cancelled = 1,           
        unknown = 2,             
        invalid_argument = 3,    
        deadline_exceeded = 4,   
        not_found = 5,           
        already_exists = 6,      
        permission_denied = 7,   
        resource_exhausted = 8,  
        failed_precondition = 9, 
        aborted = 10,            
        out_of_range = 11,       
        unimplemented = 12,      
        internal = 13,           
        unavailable = 14,        
        data_loss = 15,          
        unauthenticated = 16     
    };
 
    constexpr auto status_code_to_string(status_code code) -> std::string_view
    {
        switch (code)
        {
            case status_code::ok:                  return "OK";
            case status_code::cancelled:           return "CANCELLED";
            case status_code::unknown:             return "UNKNOWN";
            case status_code::invalid_argument:    return "INVALID_ARGUMENT";
            case status_code::deadline_exceeded:   return "DEADLINE_EXCEEDED";
            case status_code::not_found:           return "NOT_FOUND";
            case status_code::already_exists:      return "ALREADY_EXISTS";
            case status_code::permission_denied:   return "PERMISSION_DENIED";
            case status_code::resource_exhausted:  return "RESOURCE_EXHAUSTED";
            case status_code::failed_precondition: return "FAILED_PRECONDITION";
            case status_code::aborted:             return "ABORTED";
            case status_code::out_of_range:        return "OUT_OF_RANGE";
            case status_code::unimplemented:       return "UNIMPLEMENTED";
            case status_code::internal:            return "INTERNAL";
            case status_code::unavailable:         return "UNAVAILABLE";
            case status_code::data_loss:           return "DATA_LOSS";
            case status_code::unauthenticated:     return "UNAUTHENTICATED";
            default:                               return "UNKNOWN";
        }
    }
 
    struct grpc_status
    {
        status_code code = status_code::ok;
        std::string message;
        std::optional<std::string> details;
 
        grpc_status() = default;
 
        explicit grpc_status(status_code c)
            : code(c) {}
 
        grpc_status(status_code c, std::string msg)
            : code(c), message(std::move(msg)) {}
 
        grpc_status(status_code c, std::string msg, std::string det)
            : code(c), message(std::move(msg)), details(std::move(det)) {}
 
        auto is_ok() const -> bool { return code == status_code::ok; }
 
        auto is_error() const -> bool { return code != status_code::ok; }
 
        auto code_string() const -> std::string_view
        {
            return status_code_to_string(code);
        }
 
        static auto ok_status() -> grpc_status
        {
            return grpc_status{status_code::ok};
        }
 
        static auto error_status(status_code c, std::string msg) -> grpc_status
        {
            return grpc_status{c, std::move(msg)};
        }
    };
 
    struct grpc_trailers
    {
        status_code status = status_code::ok;
        std::string status_message;
        std::optional<std::string> status_details;
 
        auto to_status() const -> grpc_status
        {
            if (status_details.has_value())
            {
                return grpc_status{status, status_message, status_details.value()};
            }
            return grpc_status{status, status_message};
        }
    };
 
} // namespace kcenon::network::protocols::grpc