reference/cxx/Numeric_8hpp_source.html

#ifndef TABLEAU_HYPER_NUMERIC_HPP

#define TABLEAU_HYPER_NUMERIC_HPP


#include <cstdint>

#include <hyperapi/SqlType.hpp>

#include <hyperapi/string_view.hpp>

#include <string>

#include <type_traits>

#include <hyperapi/hyperapi.h>


class BigNumeric_rawValue_Test;

class Numeric_rawValue_Test;


namespace std {

template <>

struct hash<hyper_data128_t> {

   size_t operator()(hyper_data128_t n) const noexcept {

      return hash<uint64_t>()(n.data[0]) ^ hash<uint64_t>()(n.data[1]);

   }

};

}


namespace hyperapi {

inline bool operator==(const hyper_data128_t& a, const hyper_data128_t& b) noexcept { return (a.data[0] == b.data[0]) && (a.data[1] == b.data[1]); }

inline bool operator>(const hyper_data128_t& a, const hyper_data128_t& b) noexcept {

   if (a.data[1] != b.data[1]) return (static_cast<int64_t>(a.data[1]) > static_cast<int64_t>(b.data[1]));

   if (a.data[0] != b.data[0]) return (a.data[0] > b.data[0]);

   return false;

}


template <unsigned precision_value, unsigned scale_value>

class Numeric final {

   public:

   static constexpr unsigned precision = precision_value;

   static constexpr unsigned scale = scale_value;

   static_assert(precision >= scale, "The precision of a numeric must be greater or equal than the scale");

   static_assert(precision <= 38, "Precision must be at most 38");

   using data_t = typename std::conditional<precision <= 18, int64_t, hyper_data128_t>::type;


   Numeric() noexcept {}


   Numeric(short value);

   Numeric(unsigned short value);

   Numeric(int value);

   Numeric(unsigned value);

   Numeric(long value);

   Numeric(unsigned long value);

   Numeric(long long value);

   Numeric(unsigned long long value);

   Numeric(float value);

   Numeric(double value);

   Numeric(long double value);


   template <unsigned otherPrecision, unsigned otherScale>

   explicit Numeric(hyperapi::Numeric<otherPrecision, otherScale> other);


   explicit Numeric(hyperapi::string_view value);


   std::string stringValue() const;


   int64_t intValue() const;

   operator int64_t() const { return intValue(); }


   double doubleValue() const noexcept;

   operator double() const noexcept { return doubleValue(); }


   std::string toString() const;


   friend bool operator==(const Numeric& a, const Numeric& b) noexcept { return a.m_value == b.m_value; }

   friend bool operator>(const Numeric& a, const Numeric& b) noexcept { return a.m_value > b.m_value; }

   friend bool operator!=(const Numeric& a, const Numeric& b) noexcept { return !(a == b); }

   friend bool operator<(const Numeric& a, const Numeric& b) noexcept { return (b > a); }

   friend bool operator<=(const Numeric& a, const Numeric& b) noexcept { return !(a > b); }

   friend bool operator>=(const Numeric& a, const Numeric& b) noexcept { return !(a < b); }


   friend std::ostream& operator<<(std::ostream& os, const Numeric& obj) { return os << obj.toString(); }


   private:

   friend class ::Numeric_rawValue_Test;

   friend class ::BigNumeric_rawValue_Test;

   template <unsigned otherPrecision, unsigned otherScale>

   friend class Numeric;

   friend class Inserter;

   template <typename ReturnType>

   friend struct internal::ValueAccess;

   friend struct internal::ValueInserter;

   template <typename T>

   friend struct std::hash;


   struct raw_t {};


   explicit Numeric(data_t rawNumeric, raw_t) noexcept

      : m_value(rawNumeric) {

   }


   explicit Numeric(int64_t rawNumeric, unsigned otherPrecision, unsigned otherScale, raw_t);


   explicit Numeric(hyper_data128_t rawNumeric, unsigned otherPrecision, unsigned otherScale, raw_t);


   data_t m_value{};

};

}


namespace std {

template <unsigned p, unsigned s>

struct hash<hyperapi::Numeric<p, s>> {

   size_t operator()(hyperapi::Numeric<p, s> n) const noexcept {

      return std::hash<typename hyperapi::Numeric<p, s>::data_t>()(n.m_value);

   }

};

}


#include <hyperapi/impl/Numeric.impl.hpp>


#endif