import quincy beta 17.1.0

[ceph.git] / ceph / src / boost / boost / safe_numerics / exception.hpp

#ifndef BOOST_NUMERIC_EXCEPTION
#define BOOST_NUMERIC_EXCEPTION

//  Copyright (c) 2012 Robert Ramey
//
// Distributed under the Boost Software License, Version 1.0. (See
// accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

// contains error indicators for results of doing checked
// arithmetic on native C++ types

#include <algorithm>
#include <system_error> // error_code, system_error
#include <string>
#include <cassert>
#include <cstdint> // std::uint8_t

// Using the system_error code facility.  This facility is more complex
// than meets the eye.  To fully understand what out intent here is,
// review http://blog.think-async.com/2010/04/system-error-support-in-c0x-part-5.html
// "Giving context-specific meaning to generic error codes"

namespace boost {
namespace safe_numerics {

// errors codes for safe numerics

// in spite of the similarity, this list is distinct from the exceptions
// listed in documentation for std::exception.

// note: Don't reorder these.  Code in the file checked_result_operations.hpp
// depends upon this order !!!
enum class safe_numerics_error : std::uint8_t {
    success = 0,
    positive_overflow_error,    // result is above representational maximum
    negative_overflow_error,    // result is below representational minimum
    domain_error,               // one operand is out of valid range
    range_error,                // result cannot be produced for this operation
    precision_overflow_error,   // result lost precision
    underflow_error,            // result is too small to be represented
    negative_value_shift,       // negative value in shift operator
    negative_shift,             // shift a negative value
    shift_too_large,            // l/r shift exceeds variable size
    uninitialized_value         // creating of uninitialized value
};

const char * literal_string(const safe_numerics_error & e){
    switch(e){
    case safe_numerics_error::success: return "success";
    case safe_numerics_error::positive_overflow_error: return "positive_overflow_error";
    case safe_numerics_error::negative_overflow_error: return "negative_overflow_error";
    case safe_numerics_error::domain_error: return "domain_error";
    case safe_numerics_error::range_error: return "range_error";
    case safe_numerics_error::precision_overflow_error: return "precision_overflow_error";
    case safe_numerics_error::underflow_error: return "underflow_error";
    case safe_numerics_error::negative_value_shift: return "negative_value_shift";
    case safe_numerics_error::negative_shift: return "negative_shift";
    case safe_numerics_error::shift_too_large: return "shift_too_large";
    case safe_numerics_error::uninitialized_value: return "uninitialized_value";
    default:
        assert(false); // should never arrive here
    }
}

const std::uint8_t safe_numerics_casting_error_count =
    static_cast<std::uint8_t>(safe_numerics_error::domain_error) + 1;

const std::uint8_t safe_numerics_error_count =
    static_cast<std::uint8_t>(safe_numerics_error::uninitialized_value) + 1;

} // safe_numerics
} // boost

namespace std {
    template <>
    struct is_error_code_enum<boost::safe_numerics::safe_numerics_error>
        : public true_type {};
} // std

namespace boost {
namespace safe_numerics {

const class : public std::error_category {
public:
    virtual const char* name() const noexcept{
        return "safe numerics error";
    }
    virtual std::string message(int ev) const {
        switch(static_cast<safe_numerics_error>(ev)){
        case safe_numerics_error::success:
            return "success";
        case safe_numerics_error::positive_overflow_error:
            return "positive overflow error";
        case safe_numerics_error::negative_overflow_error:
            return "negative overflow error";
        case safe_numerics_error::underflow_error:
            return "underflow error";
        case safe_numerics_error::range_error:
            return "range error";
        case safe_numerics_error::precision_overflow_error:
            return "precision_overflow_error";
        case safe_numerics_error::domain_error:
            return "domain error";
        case safe_numerics_error::negative_shift:
            return "negative shift";
        case safe_numerics_error::negative_value_shift:
            return "negative value shift";
        case safe_numerics_error::shift_too_large:
            return "shift too large";
        case safe_numerics_error::uninitialized_value:
            return "uninitialized value";
        default:
            assert(false);
        }
        return ""; // suppress bogus warning
    }
} safe_numerics_error_category {};

// constexpr - damn, can't use constexpr due to std::error_code
inline std::error_code make_error_code(const safe_numerics_error & e){
    return std::error_code(static_cast<int>(e), safe_numerics_error_category);
}

// actions for error_codes for safe numerics.  I've leveraged on
// error_condition in order to do this.  I'm not sure this is a good
// idea or not.

enum class safe_numerics_actions {
    no_action = 0,
    uninitialized_value,
    arithmetic_error,
    implementation_defined_behavior,
    undefined_behavior
};

} // safe_numerics
} // boost

namespace std {
    template <>
    struct is_error_condition_enum<boost::safe_numerics::safe_numerics_actions>
        : public true_type {};
} // std

namespace boost {
namespace safe_numerics {

const class : public std::error_category {
public:
    virtual const char* name() const noexcept {
        return "safe numerics error group";
    }
    virtual std::string message(int) const {
        return "safe numerics error group";
    }
    // return true if a given error code corresponds to a
    // given safe numeric action
    virtual bool equivalent(
        const std::error_code & code,
        int condition
    ) const noexcept {
        if(code.category() != safe_numerics_error_category)
            return false;
        switch (static_cast<safe_numerics_actions>(condition)){
        case safe_numerics_actions::no_action:
            return code == safe_numerics_error::success;
        case safe_numerics_actions::uninitialized_value:
            return code == safe_numerics_error::uninitialized_value;
        case safe_numerics_actions::arithmetic_error:
            return code == safe_numerics_error::positive_overflow_error
                || code == safe_numerics_error::negative_overflow_error
                || code == safe_numerics_error::underflow_error
                || code == safe_numerics_error::range_error
                || code == safe_numerics_error::domain_error;
        case safe_numerics_actions::implementation_defined_behavior:
            return code == safe_numerics_error::negative_value_shift
                || code == safe_numerics_error::negative_shift
                || code == safe_numerics_error::shift_too_large;
        case safe_numerics_actions::undefined_behavior:
            return false;
        default:
            ;
        }
        // should never arrive here
        assert(false);
        // suppress bogus warning
        return false; 
    }
} safe_numerics_actions_category {};

// the following function is used to "finish" implementation of conversion
// of safe_numerics_error to std::error_condition.  At least for now, this
// isn't being used and defining here it can lead duplicate symbol errors
// depending on the compiler.  So suppress it until further notice
#if 0
std::error_condition make_error_condition(const safe_numerics_error & e) {
    return std::error_condition(
        static_cast<int>(e),
        safe_numerics_error_category
    );
}
#endif

} // safe_numerics
} // boost

#endif // BOOST_NUMERIC_CHECKED_RESULT