Numeric.hpp

Go to the documentation of this file.

 
#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