ValidationResult.h

Go to the documentation of this file.

 
#pragma once
#include "FacilityCode.h"
#include "catapult/utils/Casting.h"
#include "catapult/utils/Logging.h"
#include <iosfwd>
 
namespace catapult { namespace validators {
 
    enum class ResultSeverity : uint8_t {
        Success = 0,
 
        Neutral = 1,
 
        Failure = 2
    };
 
    enum class ResultFlags : uint8_t {
        None,
 
        Verbose = 1
    };
 
    enum class ValidationResult : uint32_t {
        Success = 0x00000000,
 
        Neutral = 0x40000000,
 
        Failure = 0x80000000
    };
 
    constexpr ValidationResult MakeValidationResult(ResultSeverity severity, FacilityCode facility, uint16_t code, ResultFlags flags) {
        return static_cast<ValidationResult>(
                (static_cast<uint32_t>(severity) & 0x03) << 30 | // 01..02: severity
                (static_cast<uint32_t>(flags) & 0x3F) << 24 | //    03..08: flags
                static_cast<uint32_t>(facility) << 16 | //          09..16: facility
                code); //                                           16..32: code
    }
 
#define DEFINE_VALIDATION_RESULT(SEVERITY, FACILITY, DESCRIPTION, CODE, FLAGS) \
    constexpr auto SEVERITY##_##FACILITY##_##DESCRIPTION = validators::MakeValidationResult( \
            (validators::ResultSeverity::SEVERITY), \
            (validators::FacilityCode::FACILITY), \
            CODE, \
            (validators::ResultFlags::FLAGS))
 
    constexpr ResultSeverity GetSeverity(ValidationResult result) {
        return static_cast<ResultSeverity>(utils::to_underlying_type(result) >> 30);
    }
 
    constexpr bool IsSet(ValidationResult result, ResultFlags flags) {
        return utils::to_underlying_type(flags) == (utils::to_underlying_type(flags) & (utils::to_underlying_type(result) >> 24 & 0x3F));
    }
 
    constexpr bool IsValidationResultSuccess(ValidationResult result) {
        return ResultSeverity::Success == GetSeverity(result);
    }
 
    constexpr bool IsValidationResultFailure(ValidationResult result) {
        return ResultSeverity::Failure == GetSeverity(result);
    }
 
    constexpr utils::LogLevel MapToLogLevel(ValidationResult result) {
        return IsSet(result, ResultFlags::Verbose) ? utils::LogLevel::Trace : utils::LogLevel::Warning;
    }
 
    std::ostream& operator<<(std::ostream& out, ValidationResult result);
}}