IntervalNumber.h

#ifndef MCC_INTERVAL_INTERVAL_NUMBER_H
#define MCC_INTERVAL_INTERVAL_NUMBER_H
 
#include <MCC_BuildSettings.h>
 
#include <stdint.h>
 
namespace MCC {

class IntervalNumber {
public:
    static constexpr uint16_t Maximum = 1792;

    static constexpr uint16_t InvalidValue = 0xFFFF;
 
private:
    uint16_t _value;
 
public:
    constexpr IntervalNumber() noexcept : _value(InvalidValue) {}

    constexpr explicit IntervalNumber(int32_t value) noexcept
        : _value((value >= 1 && value <= Maximum)
              ? static_cast<uint16_t>(value)
              : InvalidValue) {}

    static constexpr IntervalNumber Invalid() noexcept { return IntervalNumber(); }

    constexpr bool IsValid() const noexcept { return _value != InvalidValue; }

    constexpr uint16_t Value() const noexcept { return _value; }

    constexpr bool IsSimple() const noexcept { return IsValid() && _value <= 8; }

    constexpr bool IsCompound() const noexcept { return IsValid() && _value > 8; }

    MCC_CONSTEXPR14 IntervalNumber Simple() const noexcept {
        if (!IsValid() || _value <= 8) {
            return *this;
        }
        return IntervalNumber((_value - 2) % 7 + 2);
    }

    MCC_CONSTEXPR14 bool IsPerfectType() const noexcept {
        const uint16_t simple = Simple().Value();
        return simple == 1 || simple == 4 || simple == 5 || simple == 8;
    }

    MCC_CONSTEXPR14 IntervalNumber Inverted() const noexcept {
        if (!IsValid()) {
            return Invalid();
        }
        return IntervalNumber(9 - Simple().Value());
    }

    friend constexpr bool operator==(IntervalNumber a, IntervalNumber b) noexcept {
        return a._value == b._value;
    }
 
    friend constexpr bool operator!=(IntervalNumber a, IntervalNumber b) noexcept {
        return !(a == b);
    }

    friend constexpr bool operator<(IntervalNumber a, IntervalNumber b) noexcept {
        return a._value < b._value;
    }
};
 
} // namespace MCC
 
#endif // MCC_INTERVAL_INTERVAL_NUMBER_H