ICU4XFixedDecimal.hpp

Go to the documentation of this file.

#ifndef ICU4XFixedDecimal_HPP
#define ICU4XFixedDecimal_HPP
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include <algorithm>
#include <memory>
#include <variant>
#include <optional>
#include "diplomat_runtime.hpp"
 
#include "ICU4XFixedDecimal.h"
 
class ICU4XFixedDecimal;
#include "ICU4XError.hpp"
#include "ICU4XFixedDecimalSign.hpp"
#include "ICU4XFixedDecimalSignDisplay.hpp"
#include "ICU4XRoundingIncrement.hpp"

struct ICU4XFixedDecimalDeleter {
  void operator()(capi::ICU4XFixedDecimal* l) const noexcept {
    capi::ICU4XFixedDecimal_destroy(l);
  }
};

class ICU4XFixedDecimal {
 public:

  static ICU4XFixedDecimal create_from_i32(int32_t v);

  static ICU4XFixedDecimal create_from_u32(uint32_t v);

  static ICU4XFixedDecimal create_from_i64(int64_t v);

  static ICU4XFixedDecimal create_from_u64(uint64_t v);

  static diplomat::result<ICU4XFixedDecimal, ICU4XError> create_from_f64_with_integer_precision(double f);

  static diplomat::result<ICU4XFixedDecimal, ICU4XError> create_from_f64_with_lower_magnitude(double f, int16_t magnitude);

  static diplomat::result<ICU4XFixedDecimal, ICU4XError> create_from_f64_with_significant_digits(double f, uint8_t digits);

  static diplomat::result<ICU4XFixedDecimal, ICU4XError> create_from_f64_with_floating_precision(double f);

  static diplomat::result<ICU4XFixedDecimal, ICU4XError> create_from_string(const std::string_view v);

  uint8_t digit_at(int16_t magnitude) const;

  int16_t magnitude_start() const;

  int16_t magnitude_end() const;

  int16_t nonzero_magnitude_start() const;

  int16_t nonzero_magnitude_end() const;

  bool is_zero() const;

  void multiply_pow10(int16_t power);

  ICU4XFixedDecimalSign sign() const;

  void set_sign(ICU4XFixedDecimalSign sign);

  void apply_sign_display(ICU4XFixedDecimalSignDisplay sign_display);

  void trim_start();

  void trim_end();

  void pad_start(int16_t position);

  void pad_end(int16_t position);

  void set_max_position(int16_t position);

  void trunc(int16_t position);

  void trunc_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void half_trunc(int16_t position);

  void half_trunc_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void expand(int16_t position);

  void expand_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void half_expand(int16_t position);

  void half_expand_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void ceil(int16_t position);

  void ceil_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void half_ceil(int16_t position);

  void half_ceil_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void floor(int16_t position);

  void floor_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void half_floor(int16_t position);

  void half_floor_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  void half_even(int16_t position);

  void half_even_to_increment(int16_t position, ICU4XRoundingIncrement increment);

  diplomat::result<std::monostate, std::monostate> concatenate_end(ICU4XFixedDecimal& other);

  template<typename W> void to_string_to_writeable(W& to) const;

  std::string to_string() const;
  inline const capi::ICU4XFixedDecimal* AsFFI() const { return this->inner.get(); }
  inline capi::ICU4XFixedDecimal* AsFFIMut() { return this->inner.get(); }
  inline explicit ICU4XFixedDecimal(capi::ICU4XFixedDecimal* i) : inner(i) {}
  ICU4XFixedDecimal() = default;
  ICU4XFixedDecimal(ICU4XFixedDecimal&&) noexcept = default;
  ICU4XFixedDecimal& operator=(ICU4XFixedDecimal&& other) noexcept = default;
 private:
  std::unique_ptr<capi::ICU4XFixedDecimal, ICU4XFixedDecimalDeleter> inner;
};
 
 
inline ICU4XFixedDecimal ICU4XFixedDecimal::create_from_i32(int32_t v) {
  return ICU4XFixedDecimal(capi::ICU4XFixedDecimal_create_from_i32(v));
}
inline ICU4XFixedDecimal ICU4XFixedDecimal::create_from_u32(uint32_t v) {
  return ICU4XFixedDecimal(capi::ICU4XFixedDecimal_create_from_u32(v));
}
inline ICU4XFixedDecimal ICU4XFixedDecimal::create_from_i64(int64_t v) {
  return ICU4XFixedDecimal(capi::ICU4XFixedDecimal_create_from_i64(v));
}
inline ICU4XFixedDecimal ICU4XFixedDecimal::create_from_u64(uint64_t v) {
  return ICU4XFixedDecimal(capi::ICU4XFixedDecimal_create_from_u64(v));
}
inline diplomat::result<ICU4XFixedDecimal, ICU4XError> ICU4XFixedDecimal::create_from_f64_with_integer_precision(double f) {
  auto diplomat_result_raw_out_value = capi::ICU4XFixedDecimal_create_from_f64_with_integer_precision(f);
  diplomat::result<ICU4XFixedDecimal, ICU4XError> diplomat_result_out_value;
  if (diplomat_result_raw_out_value.is_ok) {
    diplomat_result_out_value = diplomat::Ok<ICU4XFixedDecimal>(ICU4XFixedDecimal(diplomat_result_raw_out_value.ok));
  } else {
    diplomat_result_out_value = diplomat::Err<ICU4XError>(static_cast<ICU4XError>(diplomat_result_raw_out_value.err));
  }
  return diplomat_result_out_value;
}
inline diplomat::result<ICU4XFixedDecimal, ICU4XError> ICU4XFixedDecimal::create_from_f64_with_lower_magnitude(double f, int16_t magnitude) {
  auto diplomat_result_raw_out_value = capi::ICU4XFixedDecimal_create_from_f64_with_lower_magnitude(f, magnitude);
  diplomat::result<ICU4XFixedDecimal, ICU4XError> diplomat_result_out_value;
  if (diplomat_result_raw_out_value.is_ok) {
    diplomat_result_out_value = diplomat::Ok<ICU4XFixedDecimal>(ICU4XFixedDecimal(diplomat_result_raw_out_value.ok));
  } else {
    diplomat_result_out_value = diplomat::Err<ICU4XError>(static_cast<ICU4XError>(diplomat_result_raw_out_value.err));
  }
  return diplomat_result_out_value;
}
inline diplomat::result<ICU4XFixedDecimal, ICU4XError> ICU4XFixedDecimal::create_from_f64_with_significant_digits(double f, uint8_t digits) {
  auto diplomat_result_raw_out_value = capi::ICU4XFixedDecimal_create_from_f64_with_significant_digits(f, digits);
  diplomat::result<ICU4XFixedDecimal, ICU4XError> diplomat_result_out_value;
  if (diplomat_result_raw_out_value.is_ok) {
    diplomat_result_out_value = diplomat::Ok<ICU4XFixedDecimal>(ICU4XFixedDecimal(diplomat_result_raw_out_value.ok));
  } else {
    diplomat_result_out_value = diplomat::Err<ICU4XError>(static_cast<ICU4XError>(diplomat_result_raw_out_value.err));
  }
  return diplomat_result_out_value;
}
inline diplomat::result<ICU4XFixedDecimal, ICU4XError> ICU4XFixedDecimal::create_from_f64_with_floating_precision(double f) {
  auto diplomat_result_raw_out_value = capi::ICU4XFixedDecimal_create_from_f64_with_floating_precision(f);
  diplomat::result<ICU4XFixedDecimal, ICU4XError> diplomat_result_out_value;
  if (diplomat_result_raw_out_value.is_ok) {
    diplomat_result_out_value = diplomat::Ok<ICU4XFixedDecimal>(ICU4XFixedDecimal(diplomat_result_raw_out_value.ok));
  } else {
    diplomat_result_out_value = diplomat::Err<ICU4XError>(static_cast<ICU4XError>(diplomat_result_raw_out_value.err));
  }
  return diplomat_result_out_value;
}
inline diplomat::result<ICU4XFixedDecimal, ICU4XError> ICU4XFixedDecimal::create_from_string(const std::string_view v) {
  auto diplomat_result_raw_out_value = capi::ICU4XFixedDecimal_create_from_string(v.data(), v.size());
  diplomat::result<ICU4XFixedDecimal, ICU4XError> diplomat_result_out_value;
  if (diplomat_result_raw_out_value.is_ok) {
    diplomat_result_out_value = diplomat::Ok<ICU4XFixedDecimal>(ICU4XFixedDecimal(diplomat_result_raw_out_value.ok));
  } else {
    diplomat_result_out_value = diplomat::Err<ICU4XError>(static_cast<ICU4XError>(diplomat_result_raw_out_value.err));
  }
  return diplomat_result_out_value;
}
inline uint8_t ICU4XFixedDecimal::digit_at(int16_t magnitude) const {
  return capi::ICU4XFixedDecimal_digit_at(this->inner.get(), magnitude);
}
inline int16_t ICU4XFixedDecimal::magnitude_start() const {
  return capi::ICU4XFixedDecimal_magnitude_start(this->inner.get());
}
inline int16_t ICU4XFixedDecimal::magnitude_end() const {
  return capi::ICU4XFixedDecimal_magnitude_end(this->inner.get());
}
inline int16_t ICU4XFixedDecimal::nonzero_magnitude_start() const {
  return capi::ICU4XFixedDecimal_nonzero_magnitude_start(this->inner.get());
}
inline int16_t ICU4XFixedDecimal::nonzero_magnitude_end() const {
  return capi::ICU4XFixedDecimal_nonzero_magnitude_end(this->inner.get());
}
inline bool ICU4XFixedDecimal::is_zero() const {
  return capi::ICU4XFixedDecimal_is_zero(this->inner.get());
}
inline void ICU4XFixedDecimal::multiply_pow10(int16_t power) {
  capi::ICU4XFixedDecimal_multiply_pow10(this->inner.get(), power);
}
inline ICU4XFixedDecimalSign ICU4XFixedDecimal::sign() const {
  return static_cast<ICU4XFixedDecimalSign>(capi::ICU4XFixedDecimal_sign(this->inner.get()));
}
inline void ICU4XFixedDecimal::set_sign(ICU4XFixedDecimalSign sign) {
  capi::ICU4XFixedDecimal_set_sign(this->inner.get(), static_cast<capi::ICU4XFixedDecimalSign>(sign));
}
inline void ICU4XFixedDecimal::apply_sign_display(ICU4XFixedDecimalSignDisplay sign_display) {
  capi::ICU4XFixedDecimal_apply_sign_display(this->inner.get(), static_cast<capi::ICU4XFixedDecimalSignDisplay>(sign_display));
}
inline void ICU4XFixedDecimal::trim_start() {
  capi::ICU4XFixedDecimal_trim_start(this->inner.get());
}
inline void ICU4XFixedDecimal::trim_end() {
  capi::ICU4XFixedDecimal_trim_end(this->inner.get());
}
inline void ICU4XFixedDecimal::pad_start(int16_t position) {
  capi::ICU4XFixedDecimal_pad_start(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::pad_end(int16_t position) {
  capi::ICU4XFixedDecimal_pad_end(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::set_max_position(int16_t position) {
  capi::ICU4XFixedDecimal_set_max_position(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::trunc(int16_t position) {
  capi::ICU4XFixedDecimal_trunc(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::trunc_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_trunc_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::half_trunc(int16_t position) {
  capi::ICU4XFixedDecimal_half_trunc(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::half_trunc_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_half_trunc_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::expand(int16_t position) {
  capi::ICU4XFixedDecimal_expand(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::expand_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_expand_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::half_expand(int16_t position) {
  capi::ICU4XFixedDecimal_half_expand(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::half_expand_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_half_expand_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::ceil(int16_t position) {
  capi::ICU4XFixedDecimal_ceil(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::ceil_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_ceil_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::half_ceil(int16_t position) {
  capi::ICU4XFixedDecimal_half_ceil(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::half_ceil_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_half_ceil_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::floor(int16_t position) {
  capi::ICU4XFixedDecimal_floor(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::floor_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_floor_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::half_floor(int16_t position) {
  capi::ICU4XFixedDecimal_half_floor(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::half_floor_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_half_floor_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline void ICU4XFixedDecimal::half_even(int16_t position) {
  capi::ICU4XFixedDecimal_half_even(this->inner.get(), position);
}
inline void ICU4XFixedDecimal::half_even_to_increment(int16_t position, ICU4XRoundingIncrement increment) {
  capi::ICU4XFixedDecimal_half_even_to_increment(this->inner.get(), position, static_cast<capi::ICU4XRoundingIncrement>(increment));
}
inline diplomat::result<std::monostate, std::monostate> ICU4XFixedDecimal::concatenate_end(ICU4XFixedDecimal& other) {
  auto diplomat_result_raw_out_value = capi::ICU4XFixedDecimal_concatenate_end(this->inner.get(), other.AsFFIMut());
  diplomat::result<std::monostate, std::monostate> diplomat_result_out_value;
  if (diplomat_result_raw_out_value.is_ok) {
    diplomat_result_out_value = diplomat::Ok<std::monostate>(std::monostate());
  } else {
    diplomat_result_out_value = diplomat::Err<std::monostate>(std::monostate());
  }
  return diplomat_result_out_value;
}
template<typename W> inline void ICU4XFixedDecimal::to_string_to_writeable(W& to) const {
  capi::DiplomatWriteable to_writer = diplomat::WriteableTrait<W>::Construct(to);
  capi::ICU4XFixedDecimal_to_string(this->inner.get(), &to_writer);
}
inline std::string ICU4XFixedDecimal::to_string() const {
  std::string diplomat_writeable_string;
  capi::DiplomatWriteable diplomat_writeable_out = diplomat::WriteableFromString(diplomat_writeable_string);
  capi::ICU4XFixedDecimal_to_string(this->inner.get(), &diplomat_writeable_out);
  return diplomat_writeable_string;
}
#endif