Decimal.Operations.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <OnixS/ICE/BOE/ABI.h>
 
#include <OnixS/ICE/BOE/messaging/Decimal.h>
#include <OnixS/ICE/BOE/messaging/Composites.h>
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_BEGIN
 
 
[[noreturn]] ONIXS_ICEBOE_EXPORTED void throwCannotQuantizeOrConvert();

typedef FloatingPointDecimal<Int64, Int32> Decimal;
//
 
 
constexpr
inline bool isNull(const Decimal&) noexcept
{
    return false;
}

ONIXS_ICEBOE_EXPORTED
bool
quantize(
    const Decimal& operand,
    Int32 exponent,
    Decimal& quantized);

ONIXS_ICEBOE_EXPORTED
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
Decimal quantize(const Decimal& operand, Int32 exponent);

template <class MantissaType>
ONIXS_ICEBOE_NODISCARD
MantissaType quantizedMantissa(const Decimal& operand, Int32 exponent)
{
    const Decimal::Mantissa res =
        quantize(
            operand, exponent)
                .mantissa();
 
    if(static_cast<MantissaType>(
        (std::numeric_limits<MantissaType>::max)()) >= res)
    {
        return static_cast<MantissaType>(res);
    }
 
    throwCannotQuantizeOrConvert();
}
 
template
<
    class MantissaType,
    class ExponentType
>
void convert(
    FixedPointDecimal<MantissaType, ExponentType>& res,
    const Decimal& number)
{
    res =
        FixedPointDecimal<MantissaType, ExponentType>(
            quantizedMantissa<MantissaType>(number, ExponentType()));
}
 
template
    <
        class MantissaType,
        class ExponentType
    >
void convert(
    FloatingPointDecimal<MantissaType, ExponentType>& res,
    const Decimal& number)
{
    if(static_cast<MantissaType>(
           (std::numeric_limits<MantissaType>::max)()) < number.mantissa())
    {
        throwCannotQuantizeOrConvert();
    }
 
    res =
        FloatingPointDecimal<MantissaType, ExponentType>(
            static_cast<MantissaType>(number.mantissa()),
            number.exponent());
}

template
<
    class DecimalT
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
typename std::enable_if<details::IsDecimal<DecimalT>::value, DecimalT>::type
    convert(const Decimal& number)
{
    DecimalT res;
    convert(res, number);
    return res;
}
 
 
ONIXS_ICEBOE_EXPORTED
ONIXS_ICEBOE_PURE
bool decimalEqual(
    const Decimal& left, const Decimal& right) noexcept;
 
 
inline bool operator ==(const Decimal& left, const Decimal& right) noexcept
{
    return ((left.exponent() == right.exponent()) ? (left.mantissa() == right.mantissa()) : decimalEqual(left, right));
}
 
 
inline bool operator!=(
    const Decimal& left, const Decimal& right)
{
    return ((left.exponent() == right.exponent()) ? (left.mantissa() != right.mantissa()) : !decimalEqual(left, right));
}
 
 
ONIXS_ICEBOE_EXPORTED
ONIXS_ICEBOE_PURE
bool decimalLess(
    const Decimal& left, const Decimal& right) noexcept;
 
 
inline bool operator <(
    const Decimal& left, const Decimal& right) noexcept
{
    return ((left.exponent() == right.exponent()) ? (left.mantissa() < right.mantissa()) : decimalLess(left, right));
}
 
 
inline bool operator<=(
    const Decimal& left, const Decimal& right)
{
    return !(right < left);
}
 
 
inline
ONIXS_ICEBOE_PURE
bool
operator >(
    const Decimal& left,
    const Decimal& right)
{
    return (right < left);
}
 
 
inline
ONIXS_ICEBOE_PURE
bool
operator >=(
    const Decimal& left,
    const Decimal& right)
{
    return (right <= left);
}
 
ONIXS_ICEBOE_EXPORTED
void
decimalToStr(
    std::string&,
    Int64,
    Int32);
 
ONIXS_ICEBOE_EXPORTED
size_t
toStr(
    const Decimal&,
    Char* buf,
    size_t size);

ONIXS_ICEBOE_EXPORTED
bool
fromStr(
    Decimal&,
    const Char*,
    size_t) noexcept;
 

inline
bool
fromStr(
    Decimal& value,
    const std::string& str) noexcept
{
    return
        fromStr(
            value,
            str.c_str(),
            str.size());
}
 
inline
void
toStr(
    std::string& str,
    const Decimal& number)
{
    decimalToStr
        (
            str,
            number.mantissa(),
            number.exponent()
        );
}

template
<
    class Mantissa,
    class Exponent
>
inline
void
toStr(
    std::string& str,
    const
    FloatingPointDecimal
        <Mantissa, Exponent>& number)
{
    if(isNull(number))
    {
        str += "[]";
        return;
    }
 
    toStr(str, Decimal(number));
}

template
<
    class Mantissa,
    class Exponent
>
inline
std::ostream&
operator<<(
    std::ostream& stream,
    const
    FloatingPointDecimal
        <Mantissa, Exponent>& value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

template
<
    class Mantissa,
    class Exponent
>
inline
void
toStr(
    std::string& str,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& number)
{
    if(isNull(number))
    {
        str += "[]";
        return;
    }
 
    toStr(str, Decimal(number));
}

template
<
    class Mantissa,
    class Exponent
>
inline ONIXS_ICEBOE_NODISCARD
std::string toStr(const FloatingPointDecimal<Mantissa, Exponent>& number)
{
    std::string str;
 
    toStr(str, number);
 
    return str;
}

template
<
    class Mantissa,
    class Exponent
>
inline
ONIXS_ICEBOE_NODISCARD
std::string
toStr(
    const
    FixedPointDecimal
        <
            Mantissa,
            Exponent
        >& number)
{
    std::string str;
 
    toStr(str, number);
 
    return str;
}

inline
std::ostream& operator << (std::ostream& stream, const Decimal& value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

template
    <
        class Mantissa,
        class Exponent
    >
inline
std::ostream&
operator<<(
    std::ostream& stream,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& value)
{
    std::string str;
 
    toStr(str, value);
 
    return stream << str;
}

template
<
    class Decimal1,
    class Decimal2
>
void checkAgsValid(
    const Decimal1& arg1, const Decimal2& arg2)
{
    if(isNull(arg1) || isNull(arg2))
        throw std::invalid_argument("Provided argument is Null.");
}

template
<
    class Mantissa,
    class Exponent
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
bool
operator ==(
    const
    FixedPointDecimal
        <Mantissa, Exponent>& left,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& right)
{
    if(isNull(left) && isNull(right))
        return true;
 
    return left.mantissa() == right.mantissa();
}

template
<
    class Mantissa,
    class Exponent
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
bool
operator !=(
    const
    FixedPointDecimal
        <Mantissa, Exponent>& left,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& right)
{
    return !(left == right);
}

template
<
    class Mantissa,
    class Exponent
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
bool
operator <(
    const
    FixedPointDecimal
        <Mantissa, Exponent>& left,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& right)
{
    checkAgsValid(left, right);
 
    return left.mantissa() < right.mantissa();
}

template
<
    class Mantissa,
    class Exponent
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
bool
operator >(
    const
    FixedPointDecimal
        <Mantissa, Exponent>& left,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& right)
{
    checkAgsValid(left, right);
 
    return left.mantissa() > right.mantissa();
}

template
<
    class Mantissa,
    class Exponent
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
bool
operator <=(
    const
    FixedPointDecimal
        <Mantissa, Exponent>& left,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& right)
{
    checkAgsValid(left, right);
 
    return left.mantissa() <= right.mantissa();
}

template
<
    class Mantissa,
    class Exponent
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
bool
operator >=(
    const
    FixedPointDecimal
        <Mantissa, Exponent>& left,
    const
    FixedPointDecimal
        <Mantissa, Exponent>& right)
{
    checkAgsValid(left, right);
 
    return left.mantissa() >= right.mantissa();
}

template
<
    class Decimal1,
    class Decimal2
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
typename std::enable_if<details::AreBothDecimals<Decimal1, Decimal2>::value, bool>::type
operator==(
    const Decimal1& left, const Decimal2& right)
{
    if(isNull(left) && isNull(right))
        return true;
 
    return Decimal(left) == Decimal(right);
}

template
<
    class Decimal1,
    class Decimal2
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
typename std::enable_if<details::AreBothDecimals<Decimal1, Decimal2>::value, bool>::type
operator!=(
    const Decimal1& left, const Decimal2& right)
{
    return !(left == right);
}

template
<
    class Decimal1,
    class Decimal2
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
typename std::enable_if<details::AreBothDecimals<Decimal1, Decimal2>::value, bool>::type
operator>(
    const Decimal1& left, const Decimal2& right)
{
    checkAgsValid(left, right);
 
    return Decimal(left) > Decimal(right);
}

template
<
    class Decimal1,
    class Decimal2
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
typename std::enable_if<details::AreBothDecimals<Decimal1, Decimal2>::value, bool>::type
operator>=(
    const Decimal1& left, const Decimal2& right)
{
    checkAgsValid(left, right);
 
    return Decimal(left) >= Decimal(right);
}

template
<
    class Decimal1,
    class Decimal2
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
typename std::enable_if<details::AreBothDecimals<Decimal1, Decimal2>::value, bool>::type
operator<(
    const Decimal1& left, const Decimal2& right)
{
    checkAgsValid(left, right);
 
    return Decimal(left) < Decimal(right);
}

template
<
    class Decimal1,
    class Decimal2
>
ONIXS_ICEBOE_NODISCARD
ONIXS_ICEBOE_PURE
typename std::enable_if<details::AreBothDecimals<Decimal1, Decimal2>::value, bool>::type
operator<=(
    const Decimal1& left, const Decimal2& right)
{
    checkAgsValid(left, right);
 
    return Decimal(left) <= Decimal(right);
}
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_END