decimal.hpp

Go to the documentation of this file.

#pragma once
// Exact decimal helpers for venue payloads (6.2). Every price/quantity string a venue sends
// is parsed with Fixed::from_decimal (integer loop, no double) and returned as a Result so
// the caller can count malformed messages instead of throwing. Timestamps arrive as
// millisecond integers (Binance `E`/`T`, Bybit `ts`/`T`) or strings (Bybit `execTime`).
#include "fastmm/core/fixed_point.hpp"
#include "fastmm/core/result.hpp"
#include "fastmm/core/time.hpp"
 
#include <cstddef>
#include <cstdint>
#include <limits>
#include <string_view>
 
namespace fastmm::venues {
 
enum class DecimalError : std::uint8_t {
  Empty = 1,
  Malformed = 2,  // non-digit, exponent, whitespace, > 8 significant fraction digits
  Overflow = 3,   // does not fit the int64 1e-8 range
};
[[nodiscard]] constexpr std::string_view to_string(DecimalError e) noexcept {
  switch (e) {
    case DecimalError::Empty:
      return "empty";
    case DecimalError::Malformed:
      return "malformed";
    case DecimalError::Overflow:
      return "overflow";
  }
  return "?";
}
 
namespace detail {
// Classifies why from_decimal rejected `s` (only called on the failure path).
[[nodiscard]] constexpr DecimalError classify(std::string_view s) noexcept {
  if (s.empty()) return DecimalError::Empty;
  std::size_t i = (s[0] == '-' || s[0] == '+') ? 1 : 0;
  std::size_t int_digits = 0;
  for (; i < s.size() && s[i] != '.'; ++i) {
    if (s[i] < '0' || s[i] > '9') return DecimalError::Malformed;
    ++int_digits;
  }
  if (i < s.size()) {
    for (++i; i < s.size(); ++i) {
      if (s[i] < '0' || s[i] > '9') return DecimalError::Malformed;
    }
  }
  // 92233720368 has 11 digits: anything longer is an overflow, anything shorter that still
  // failed must have carried too many fraction digits.
  return int_digits >= 11 ? DecimalError::Overflow : DecimalError::Malformed;
}
}  // namespace detail
 
template <class F>
[[nodiscard]] inline Result<F, DecimalError> parse_fixed(std::string_view s) noexcept {
  if (const auto v = F::from_decimal(s)) return *v;
  return fail(detail::classify(s));
}
[[nodiscard]] inline Result<Price, DecimalError> parse_price(std::string_view s) noexcept {
  return parse_fixed<Price>(s);
}
// A value the venue computed rather than one an order carries can have more fraction digits than
// 8: Binance USDⓈ-M's positionRisk and ACCOUNT_UPDATE give an entry price of "83954.61851851852",
// OKX a spot commission of "-0.00000192834" BTC (fillSz times the fee rate). Rounded half away
// from zero to 8 decimals; anything else parse_fixed refuses is refused here too.
template <class F>
[[nodiscard]] inline Result<F, DecimalError> parse_rounded(std::string_view s) noexcept {
  if (const auto v = F::from_decimal(s)) return *v;
  const std::size_t dot = s.find('.');
  constexpr auto kKeep = static_cast<std::size_t>(kFixedDecimals);
  if (dot == std::string_view::npos || s.size() - dot - 1 <= kKeep)
    return fail(detail::classify(s));
  for (std::size_t i = dot + 1; i < s.size(); ++i) {
    if (s[i] < '0' || s[i] > '9') return fail(DecimalError::Malformed);
  }
  const auto v = F::from_decimal(s.substr(0, dot + 1 + kKeep));
  if (!v) return fail(detail::classify(s));
  if (s[dot + 1 + kKeep] < '5') return *v;
  const std::int64_t up = v->raw < 0 || (v->raw == 0 && s[0] == '-') ? -1 : 1;
  if (up > 0 && v->raw == std::numeric_limits<std::int64_t>::max())
    return fail(DecimalError::Overflow);
  if (up < 0 && v->raw == std::numeric_limits<std::int64_t>::min())
    return fail(DecimalError::Overflow);
  return F::from_raw(v->raw + up);
}
// A position's entry price, an average fill price.
[[nodiscard]] inline Result<Price, DecimalError> parse_avg_price(std::string_view s) noexcept {
  return parse_rounded<Price>(s);
}
// A commission, which the venue computes from the fill.
[[nodiscard]] inline Result<Notional, DecimalError> parse_fee(std::string_view s) noexcept {
  return parse_rounded<Notional>(s);
}
[[nodiscard]] inline Result<Qty, DecimalError> parse_qty(std::string_view s) noexcept {
  return parse_fixed<Qty>(s);
}
[[nodiscard]] inline Result<Notional, DecimalError> parse_notional(std::string_view s) noexcept {
  return parse_fixed<Notional>(s);
}
 
// "[-]digits" -> int64; rejects empty, signs other than a leading '-', overflow.
[[nodiscard]] inline Result<std::int64_t, DecimalError> parse_int64(std::string_view s) noexcept {
  if (s.empty()) return fail(DecimalError::Empty);
  std::size_t i = 0;
  bool neg = false;
  if (s[0] == '-') {
    neg = true;
    i = 1;
    if (s.size() == 1) return fail(DecimalError::Malformed);
  }
  std::uint64_t v = 0;
  constexpr std::uint64_t kMax =
      static_cast<std::uint64_t>(std::numeric_limits<std::int64_t>::max());
  for (; i < s.size(); ++i) {
    const char c = s[i];
    if (c < '0' || c > '9') return fail(DecimalError::Malformed);
    const auto d = static_cast<std::uint64_t>(c - '0');
    if (v > (kMax - d) / 10) return fail(DecimalError::Overflow);
    v = v * 10 + d;
  }
  return neg ? -static_cast<std::int64_t>(v) : static_cast<std::int64_t>(v);
}
 
// Milliseconds since the Unix epoch -> Timestamp (ns).
[[nodiscard]] constexpr Timestamp ts_from_ms(std::int64_t ms) noexcept {
  return Timestamp{ms * 1'000'000};
}
[[nodiscard]] inline Result<Timestamp, DecimalError> parse_ts_ms(std::string_view s) noexcept {
  const auto v = parse_int64(s);
  if (!v) return fail(v.error());
  return ts_from_ms(*v);
}
 
// Stack formatting buffer: `DecimalText t(px); send(t.view());` - no heap, no locale.
class DecimalText {
 public:
  template <class Tag>
  explicit DecimalText(Fixed<Tag> v) noexcept : len_(v.to_decimal(buf_)) {
    buf_[len_] = '\0';
  }
  [[nodiscard]] std::string_view view() const noexcept { return {buf_, len_}; }
  [[nodiscard]] const char* c_str() const noexcept { return buf_; }
  [[nodiscard]] std::size_t size() const noexcept { return len_; }
 
 private:
  char buf_[kMaxDecimalChars + 1];
  std::size_t len_;
};
 
// Formats an int64 into a caller buffer (>= 21 chars); returns the length.
[[nodiscard]] constexpr std::size_t format_int64(std::int64_t v, char* out) noexcept {
  char tmp[20];
  std::size_t n = 0;
  std::uint64_t mag = v < 0 ? 0 - static_cast<std::uint64_t>(v) : static_cast<std::uint64_t>(v);
  do {
    tmp[n++] = static_cast<char>('0' + mag % 10);
    mag /= 10;
  } while (mag != 0);
  std::size_t w = 0;
  if (v < 0) out[w++] = '-';
  while (n > 0) out[w++] = tmp[--n];
  return w;
}
 
}  // namespace fastmm::venues