问题
I'm using std::error_code and have a bunch of error's defined (using enum class) and registered.
I have a very generic error now called my_error::validate, but want to provide more specific versions in my library. Generally people will want to use:
if (ec == bc::error::validate)
// ...
However sometimes they may wish to see the specific error associated with that std::error_code or print the error message.
// ec.message() says "check_block() failed to do XYZ"
assert(ec == bc::error::check_block);
I want to be able to enable something like:
if (ec == bc::error::validate)
{
if (ec == bc::error::check_block)
// bc::error::check_block is a more specific case of bc::error::validate
}
It seems I can somehow use categories or conditions? How can I do that without needing to define a whole bunch of new error enums? It's for a library so it would be a pain for the user of that library to have to use bc::generic_error::validate and bc::error::check_block.
Code is below:
#include <system_error>
namespace bc {
enum class error
{
// storage errors
missing_object = 1,
object_already_exists,
unspent_output,
// transaction_pool errors
bad_transaction,
// network errors
resolve_failed,
network_unreachable,
address_in_use,
listen_failed,
accept_failed,
bad_stream,
channel_stopped,
channel_timeout,
// validate
validate_failed,
check_block,
accept_block,
connect_block
};
class error_category_impl
: public std::error_category
{
public:
virtual const char* name() const;
virtual std::string message(int ev) const;
virtual std::error_condition default_error_condition(int ev) const;
};
const std::error_category& error_category();
std::error_code make_error_code(error e);
std::error_condition make_error_condition(error e);
} // bc
namespace std
{
template <>
struct is_error_code_enum<libbitcoin::error>
: public true_type {};
}
And the TU source file:
#include <bc/error.hpp>
namespace bc {
const char* error_category_impl::name() const
{
return "bitcoin";
}
std::string error_category_impl::message(int ev) const
{
error ec = static_cast<error>(ev);
switch (ec)
{
case error::missing_object:
return "Object does not exist";
case error::object_already_exists:
return "Matching previous object found";
case error::unspent_output:
return "Unspent output";
case error::bad_transaction:
return "Transaction failed to validate";
case error::resolve_failed:
return "Resolving hostname failed";
case error::network_unreachable:
return "Unable to reach remote network";
case error::address_in_use:
return "Address already in use";
case error::listen_failed:
return "Listen incoming connections failed";
case error::accept_failed:
return "Accept connection failed";
case error::bad_stream:
return "Bad stream";
case error::channel_stopped:
return "Channel stopped";
case error::channel_timeout:
return "Channel timed out";
default:
return "Unknown error";
}
}
std::error_condition
error_category_impl::default_error_condition(int ev) const
{
error ec = static_cast<error>(ev);
switch (ec)
{
case error::check_block:
case error::accept_block:
case error::connect_block:
//return error::validate_failed;
return std::errc::permission_denied;
default:
return std::error_condition(ev, *this);
}
}
const std::error_category& error_category()
{
static error_category_impl instance;
return instance;
}
std::error_code make_error_code(error e)
{
return std::error_code(static_cast<int>(e), error_category());
}
std::error_condition make_error_condition(error e)
{
return std::error_condition(static_cast<int>(e), error_category());
}
} // bc
回答1:
OK I got help from the boost::asio and std::error_code creator and master himself: Chris Kohlhoff.
When using ADL, a good rule of thumb is that it should not need any qualifier (error::error_code_t in my case), and I was in the wrong scope.
#include <iostream>
#include <system_error>
namespace libbitcoin {
namespace error
{
// Specific errors
enum error_code_t
{
// storage errors
missing_object = 1,
object_already_exists,
unspent_output,
// transaction_pool errors
bad_transaction,
// network errors
resolve_failed,
network_unreachable,
address_in_use,
listen_failed,
accept_failed,
bad_stream,
channel_stopped,
channel_timeout,
// validate
check_block,
accept_block,
connect_block
};
// error_condition
enum error_condition_t
{
// validate
validate_failed = 1
};
std::error_code make_error_code(error_code_t e);
std::error_condition make_error_condition(error_condition_t e);
}
class error_category_impl
: public std::error_category
{
public:
virtual const char* name() const;
virtual std::string message(int ev) const;
virtual std::error_condition default_error_condition(int ev) const;
};
const std::error_category& error_category();
} // libbitcoin
namespace std
{
template <>
struct is_error_code_enum<libbitcoin::error::error_code_t>
: public true_type {};
template <>
struct is_error_condition_enum<libbitcoin::error::error_condition_t>
: public true_type {};
}
// -------------------------------------------------------------------
namespace libbitcoin {
namespace error {
std::error_code make_error_code(error_code_t e)
{
return std::error_code(static_cast<int>(e), error_category());
}
std::error_condition make_error_condition(error_condition_t e)
{
return std::error_condition(static_cast<int>(e), error_category());
}
}
const char* error_category_impl::name() const
{
return "bitcoin";
}
std::string error_category_impl::message(int ev) const
{
//error ec = static_cast<error>(ev);
switch (ev)
{
case error::missing_object:
return "Object does not exist";
case error::object_already_exists:
return "Matching previous object found";
case error::unspent_output:
return "Unspent output";
case error::bad_transaction:
return "Transaction failed to validate";
case error::resolve_failed:
return "Resolving hostname failed";
case error::network_unreachable:
return "Unable to reach remote network";
case error::address_in_use:
return "Address already in use";
case error::listen_failed:
return "Listen incoming connections failed";
case error::accept_failed:
return "Accept connection failed";
case error::bad_stream:
return "Bad stream";
case error::channel_stopped:
return "Channel stopped";
case error::channel_timeout:
return "Channel timed out";
case error::check_block:
return "Checkblk";
default:
return "Unknown error";
}
}
std::error_condition
error_category_impl::default_error_condition(int ev) const
{
//error ec = static_cast<error>(ev);
switch (ev)
{
case error::check_block:
case error::accept_block:
case error::connect_block:
return std::error_condition(error::validate_failed, *this);
default:
return std::error_condition(ev, *this);
}
}
const std::error_category& error_category()
{
static error_category_impl instance;
return instance;
}
} // libbitcoin
using namespace libbitcoin;
#include <assert.h>
int main()
{
std::error_code ec = error::check_block;
assert(ec == error::validate_failed);
assert(ec == error::check_block);
std::cout << ec.message() << std::endl;
//ec = error::missing_object;
return 0;
}
回答2:
For anyone who may be interested in this "error_code", "error_condition" topic, I strongly recommend these 2 turtorials which may be the best I've ever seen: Error Code, Error Condition.
来源：https://stackoverflow.com/questions/9760851/stderror-code-my-errorcheck-block-my-errorvalidate-my-erroraccept