8

私はstd::error_codeを使用しており、（列挙型クラスを使用して）多数のエラーが定義され、登録されています。

my_error :: validateという非常に一般的なエラーが発生しましたが、ライブラリでより具体的なバージョンを提供したいと考えています。一般的に人々は使用したいと思うでしょう：

if (ec == bc::error::validate)
    // ...

ただし、そのstd :: error_codeに関連する特定のエラーを確認したり、エラーメッセージを出力したりする場合があります。

// ec.message() says "check_block() failed to do XYZ"
assert(ec == bc::error::check_block);

次のようなものを有効にできるようにしたい：

if (ec == bc::error::validate)
{
    if (ec == bc::error::check_block)
        // bc::error::check_block is a more specific case of bc::error::validate
}

どういうわけかカテゴリや条件を使用できるようですか？たくさんの新しいエラー列挙型を定義する必要なしに、どうすればそれを行うことができますか？これはライブラリ用であるため、そのライブラリのユーザーがbc :: generic_error::validateとbc::error::check_blockを使用しなければならないのは面倒です。

コードは以下のとおりです。

#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 {};
}

そして、TUソースファイル：

#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
4

2 に答える 2

11

OK私はboost::asioとstd::error_codeの作成者から助けを得て、自分自身をマスターしました：ChrisKohlhoff。

ADLを使用する場合、経験則として、修飾子（私の場合はerror :: error_code_t）は必要なく、スコープが間違っていました。

#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;
}
于 2012-03-19T22:44:05.303 に答える
0

この「error_code」、「error_condition」トピックに興味があるかもしれない人には、私が今まで見た中で最高かもしれないこれらの2つのturtorialsを強くお勧めします： エラーコード、エラー条件。

于 2018-03-26T03:05:21.273 に答える