diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index c98278c7d..25931be2c 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -119,6 +119,8 @@ jobs: run: cargo build -p temporal_capi - name: Regen run: cargo run -p diplomat-gen + - name: Check diff + run: git diff --exit-code # Todo: eventually we should check in bindings and test them - name: Makefile tests run: cd temporal_capi/cpp_tests && make diff --git a/temporal_capi/.gitignore b/temporal_capi/.gitignore index 132bfa416..fa929750c 100644 --- a/temporal_capi/.gitignore +++ b/temporal_capi/.gitignore @@ -1,3 +1 @@ -# To be checked in later once it stabilizes a bit -bindings/ *.out \ No newline at end of file diff --git a/temporal_capi/bindings/cpp/diplomat_runtime.hpp b/temporal_capi/bindings/cpp/diplomat_runtime.hpp new file mode 100644 index 000000000..21af8be4e --- /dev/null +++ b/temporal_capi/bindings/cpp/diplomat_runtime.hpp @@ -0,0 +1,215 @@ +#ifndef DIPLOMAT_RUNTIME_CPP_H +#define DIPLOMAT_RUNTIME_CPP_H + +#include +#include +#include +#include + +#if __cplusplus >= 202002L +#include +#else +#include +#endif + +namespace diplomat { + +namespace capi { +extern "C" { + +static_assert(sizeof(char) == sizeof(uint8_t), "your architecture's `char` is not 8 bits"); +static_assert(sizeof(char16_t) == sizeof(uint16_t), "your architecture's `char16_t` is not 16 bits"); +static_assert(sizeof(char32_t) == sizeof(uint32_t), "your architecture's `char32_t` is not 32 bits"); + +typedef struct DiplomatWrite { + void* context; + char* buf; + size_t len; + size_t cap; + bool grow_failed; + void (*flush)(struct DiplomatWrite*); + bool (*grow)(struct DiplomatWrite*, size_t); +} DiplomatWrite; + +bool diplomat_is_str(const char* buf, size_t len); + +#define MAKE_SLICES(name, c_ty) \ + typedef struct Diplomat##name##View { \ + const c_ty* data; \ + size_t len; \ + } Diplomat##name##View; \ + typedef struct Diplomat##name##ViewMut { \ + c_ty* data; \ + size_t len; \ + } Diplomat##name##ViewMut; \ + typedef struct Diplomat##name##Array { \ + const c_ty* data; \ + size_t len; \ + } Diplomat##name##Array; + +#define MAKE_SLICES_AND_OPTIONS(name, c_ty) \ + MAKE_SLICES(name, c_ty) \ + typedef struct Option##name {union { c_ty ok; }; bool is_ok; } Option##name; + +MAKE_SLICES_AND_OPTIONS(I8, int8_t) +MAKE_SLICES_AND_OPTIONS(U8, uint8_t) +MAKE_SLICES_AND_OPTIONS(I16, int16_t) +MAKE_SLICES_AND_OPTIONS(U16, uint16_t) +MAKE_SLICES_AND_OPTIONS(I32, int32_t) +MAKE_SLICES_AND_OPTIONS(U32, uint32_t) +MAKE_SLICES_AND_OPTIONS(I64, int64_t) +MAKE_SLICES_AND_OPTIONS(U64, uint64_t) +MAKE_SLICES_AND_OPTIONS(Isize, intptr_t) +MAKE_SLICES_AND_OPTIONS(Usize, size_t) +MAKE_SLICES_AND_OPTIONS(F32, float) +MAKE_SLICES_AND_OPTIONS(F64, double) +MAKE_SLICES_AND_OPTIONS(Bool, bool) +MAKE_SLICES_AND_OPTIONS(Char, char32_t) +MAKE_SLICES(String, char) +MAKE_SLICES(String16, char16_t) +MAKE_SLICES(Strings, DiplomatStringView) +MAKE_SLICES(Strings16, DiplomatString16View) + +} // extern "C" +} // namespace capi + +extern "C" inline void _flush(capi::DiplomatWrite* w) { + std::string* string = reinterpret_cast(w->context); + string->resize(w->len); +}; + +extern "C" inline bool _grow(capi::DiplomatWrite* w, uintptr_t requested) { + std::string* string = reinterpret_cast(w->context); + string->resize(requested); + w->cap = string->length(); + w->buf = &(*string)[0]; + return true; +}; + +inline capi::DiplomatWrite WriteFromString(std::string& string) { + capi::DiplomatWrite w; + w.context = &string; + w.buf = &string[0]; + w.len = string.length(); + w.cap = string.length(); + // Will never become true, as _grow is infallible. + w.grow_failed = false; + w.flush = _flush; + w.grow = _grow; + return w; +}; + +template struct Ok { + T inner; + Ok(T&& i): inner(std::move(i)) {} + // We don't want to expose an lvalue-capable constructor in general + // however there is no problem doing this for trivially copyable types + template::value>::type> + Ok(T i): inner(i) {} + Ok() = default; + Ok(Ok&&) noexcept = default; + Ok(const Ok &) = default; + Ok& operator=(const Ok&) = default; + Ok& operator=(Ok&&) noexcept = default; +}; + +template struct Err { + T inner; + Err(T&& i): inner(std::move(i)) {} + // We don't want to expose an lvalue-capable constructor in general + // however there is no problem doing this for trivially copyable types + template::value>::type> + Err(T i): inner(i) {} + Err() = default; + Err(Err&&) noexcept = default; + Err(const Err &) = default; + Err& operator=(const Err&) = default; + Err& operator=(Err&&) noexcept = default; +}; + +template +class result { +private: + std::variant, Err> val; +public: + result(Ok&& v): val(std::move(v)) {} + result(Err&& v): val(std::move(v)) {} + result() = default; + result(const result &) = default; + result& operator=(const result&) = default; + result& operator=(result&&) noexcept = default; + result(result &&) noexcept = default; + ~result() = default; + bool is_ok() const { + return std::holds_alternative>(this->val); + }; + bool is_err() const { + return std::holds_alternative>(this->val); + }; + + std::optional ok() && { + if (!this->is_ok()) { + return std::nullopt; + } + return std::make_optional(std::move(std::get>(std::move(this->val)).inner)); + }; + std::optional err() && { + if (!this->is_err()) { + return std::nullopt; + } + return std::make_optional(std::move(std::get>(std::move(this->val)).inner)); + } + + void set_ok(T&& t) { + this->val = Ok(std::move(t)); + } + + void set_err(E&& e) { + this->val = Err(std::move(e)); + } + + template + result replace_ok(T2&& t) { + if (this->is_err()) { + return result(Err(std::get>(std::move(this->val)))); + } else { + return result(Ok(std::move(t))); + } + } +}; + +class Utf8Error {}; + +// Use custom std::span on C++17, otherwise use std::span +#if __cplusplus >= 202002L + +template using span = std::span; + +#else // __cplusplus < 202002L + +// C++-17-compatible std::span +template +class span { + +public: + constexpr span(T* data, size_t size) + : data_(data), size_(size) {} + template + constexpr span(std::array::type, N>& arr) + : data_(const_cast(arr.data())), size_(N) {} + constexpr T* data() const noexcept { + return this->data_; + } + constexpr size_t size() const noexcept { + return this->size_; + } +private: + T* data_; + size_t size_; +}; + +#endif // __cplusplus >= 202002L + +} // namespace diplomat + +#endif diff --git a/temporal_capi/bindings/cpp/temporal_rs/.gitkeep b/temporal_capi/bindings/cpp/temporal_rs/.gitkeep deleted file mode 100644 index e69de29bb..000000000 diff --git a/temporal_capi/bindings/cpp/temporal_rs/AnyCalendarKind.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/AnyCalendarKind.d.hpp new file mode 100644 index 000000000..00f889122 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/AnyCalendarKind.d.hpp @@ -0,0 +1,84 @@ +#ifndef temporal_rs_AnyCalendarKind_D_HPP +#define temporal_rs_AnyCalendarKind_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +class AnyCalendarKind; +} + + +namespace temporal_rs { +namespace capi { + enum AnyCalendarKind { + AnyCalendarKind_Buddhist = 0, + AnyCalendarKind_Chinese = 1, + AnyCalendarKind_Coptic = 2, + AnyCalendarKind_Dangi = 3, + AnyCalendarKind_Ethiopian = 4, + AnyCalendarKind_EthiopianAmeteAlem = 5, + AnyCalendarKind_Gregorian = 6, + AnyCalendarKind_Hebrew = 7, + AnyCalendarKind_Indian = 8, + AnyCalendarKind_IslamicCivil = 9, + AnyCalendarKind_IslamicObservational = 10, + AnyCalendarKind_IslamicTabular = 11, + AnyCalendarKind_IslamicUmmAlQura = 12, + AnyCalendarKind_Iso = 13, + AnyCalendarKind_Japanese = 14, + AnyCalendarKind_JapaneseExtended = 15, + AnyCalendarKind_Persian = 16, + AnyCalendarKind_Roc = 17, + }; + + typedef struct AnyCalendarKind_option {union { AnyCalendarKind ok; }; bool is_ok; } AnyCalendarKind_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class AnyCalendarKind { +public: + enum Value { + Buddhist = 0, + Chinese = 1, + Coptic = 2, + Dangi = 3, + Ethiopian = 4, + EthiopianAmeteAlem = 5, + Gregorian = 6, + Hebrew = 7, + Indian = 8, + IslamicCivil = 9, + IslamicObservational = 10, + IslamicTabular = 11, + IslamicUmmAlQura = 12, + Iso = 13, + Japanese = 14, + JapaneseExtended = 15, + Persian = 16, + Roc = 17, + }; + + AnyCalendarKind() = default; + // Implicit conversions between enum and ::Value + constexpr AnyCalendarKind(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline static std::optional get_for_bcp47_string(std::string_view s); + + inline temporal_rs::capi::AnyCalendarKind AsFFI() const; + inline static temporal_rs::AnyCalendarKind FromFFI(temporal_rs::capi::AnyCalendarKind c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_AnyCalendarKind_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/AnyCalendarKind.hpp b/temporal_capi/bindings/cpp/temporal_rs/AnyCalendarKind.hpp new file mode 100644 index 000000000..8d095f150 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/AnyCalendarKind.hpp @@ -0,0 +1,61 @@ +#ifndef temporal_rs_AnyCalendarKind_HPP +#define temporal_rs_AnyCalendarKind_HPP + +#include "AnyCalendarKind.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_AnyCalendarKind_get_for_bcp47_string_result {union {temporal_rs::capi::AnyCalendarKind ok; }; bool is_ok;} temporal_rs_AnyCalendarKind_get_for_bcp47_string_result; + temporal_rs_AnyCalendarKind_get_for_bcp47_string_result temporal_rs_AnyCalendarKind_get_for_bcp47_string(diplomat::capi::DiplomatStringView s); + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::AnyCalendarKind temporal_rs::AnyCalendarKind::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::AnyCalendarKind temporal_rs::AnyCalendarKind::FromFFI(temporal_rs::capi::AnyCalendarKind c_enum) { + switch (c_enum) { + case temporal_rs::capi::AnyCalendarKind_Buddhist: + case temporal_rs::capi::AnyCalendarKind_Chinese: + case temporal_rs::capi::AnyCalendarKind_Coptic: + case temporal_rs::capi::AnyCalendarKind_Dangi: + case temporal_rs::capi::AnyCalendarKind_Ethiopian: + case temporal_rs::capi::AnyCalendarKind_EthiopianAmeteAlem: + case temporal_rs::capi::AnyCalendarKind_Gregorian: + case temporal_rs::capi::AnyCalendarKind_Hebrew: + case temporal_rs::capi::AnyCalendarKind_Indian: + case temporal_rs::capi::AnyCalendarKind_IslamicCivil: + case temporal_rs::capi::AnyCalendarKind_IslamicObservational: + case temporal_rs::capi::AnyCalendarKind_IslamicTabular: + case temporal_rs::capi::AnyCalendarKind_IslamicUmmAlQura: + case temporal_rs::capi::AnyCalendarKind_Iso: + case temporal_rs::capi::AnyCalendarKind_Japanese: + case temporal_rs::capi::AnyCalendarKind_JapaneseExtended: + case temporal_rs::capi::AnyCalendarKind_Persian: + case temporal_rs::capi::AnyCalendarKind_Roc: + return static_cast(c_enum); + default: + abort(); + } +} + +inline std::optional temporal_rs::AnyCalendarKind::get_for_bcp47_string(std::string_view s) { + auto result = temporal_rs::capi::temporal_rs_AnyCalendarKind_get_for_bcp47_string({s.data(), s.size()}); + return result.is_ok ? std::optional(temporal_rs::AnyCalendarKind::FromFFI(result.ok)) : std::nullopt; +} +#endif // temporal_rs_AnyCalendarKind_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/ArithmeticOverflow.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/ArithmeticOverflow.d.hpp new file mode 100644 index 000000000..e04ff6325 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/ArithmeticOverflow.d.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_ArithmeticOverflow_D_HPP +#define temporal_rs_ArithmeticOverflow_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum ArithmeticOverflow { + ArithmeticOverflow_Constrain = 0, + ArithmeticOverflow_Reject = 1, + }; + + typedef struct ArithmeticOverflow_option {union { ArithmeticOverflow ok; }; bool is_ok; } ArithmeticOverflow_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class ArithmeticOverflow { +public: + enum Value { + Constrain = 0, + Reject = 1, + }; + + ArithmeticOverflow() = default; + // Implicit conversions between enum and ::Value + constexpr ArithmeticOverflow(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::ArithmeticOverflow AsFFI() const; + inline static temporal_rs::ArithmeticOverflow FromFFI(temporal_rs::capi::ArithmeticOverflow c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_ArithmeticOverflow_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/ArithmeticOverflow.hpp b/temporal_capi/bindings/cpp/temporal_rs/ArithmeticOverflow.hpp new file mode 100644 index 000000000..549f040d5 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/ArithmeticOverflow.hpp @@ -0,0 +1,37 @@ +#ifndef temporal_rs_ArithmeticOverflow_HPP +#define temporal_rs_ArithmeticOverflow_HPP + +#include "ArithmeticOverflow.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::ArithmeticOverflow temporal_rs::ArithmeticOverflow::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::ArithmeticOverflow temporal_rs::ArithmeticOverflow::FromFFI(temporal_rs::capi::ArithmeticOverflow c_enum) { + switch (c_enum) { + case temporal_rs::capi::ArithmeticOverflow_Constrain: + case temporal_rs::capi::ArithmeticOverflow_Reject: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_ArithmeticOverflow_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Calendar.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/Calendar.d.hpp new file mode 100644 index 000000000..70eeb8977 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Calendar.d.hpp @@ -0,0 +1,105 @@ +#ifndef temporal_rs_Calendar_D_HPP +#define temporal_rs_Calendar_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Calendar; } +class Calendar; +namespace capi { struct Duration; } +class Duration; +namespace capi { struct PlainDate; } +class PlainDate; +namespace capi { struct PlainMonthDay; } +class PlainMonthDay; +namespace capi { struct PlainYearMonth; } +class PlainYearMonth; +struct IsoDate; +struct PartialDate; +struct TemporalError; +class AnyCalendarKind; +class ArithmeticOverflow; +class TemporalUnit; +} + + +namespace temporal_rs { +namespace capi { + struct Calendar; +} // namespace capi +} // namespace + +namespace temporal_rs { +class Calendar { +public: + + inline static std::unique_ptr create(temporal_rs::AnyCalendarKind kind); + + inline static diplomat::result, temporal_rs::TemporalError> from_utf8(std::string_view s); + + inline bool is_iso() const; + + inline std::string_view identifier() const; + + inline diplomat::result, temporal_rs::TemporalError> date_from_partial(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> month_day_from_partial(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> year_month_from_partial(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> date_add(temporal_rs::IsoDate date, const temporal_rs::Duration& duration, temporal_rs::ArithmeticOverflow overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> date_until(temporal_rs::IsoDate one, temporal_rs::IsoDate two, temporal_rs::TemporalUnit largest_unit) const; + + inline diplomat::result era(temporal_rs::IsoDate date) const; + + inline diplomat::result, temporal_rs::TemporalError> era_year(temporal_rs::IsoDate date) const; + + inline diplomat::result year(temporal_rs::IsoDate date) const; + + inline diplomat::result month(temporal_rs::IsoDate date) const; + + inline diplomat::result month_code(temporal_rs::IsoDate date) const; + + inline diplomat::result day(temporal_rs::IsoDate date) const; + + inline diplomat::result day_of_week(temporal_rs::IsoDate date) const; + + inline diplomat::result day_of_year(temporal_rs::IsoDate date) const; + + inline diplomat::result, temporal_rs::TemporalError> week_of_year(temporal_rs::IsoDate date) const; + + inline diplomat::result, temporal_rs::TemporalError> year_of_week(temporal_rs::IsoDate date) const; + + inline diplomat::result days_in_week(temporal_rs::IsoDate date) const; + + inline diplomat::result days_in_month(temporal_rs::IsoDate date) const; + + inline diplomat::result days_in_year(temporal_rs::IsoDate date) const; + + inline diplomat::result months_in_year(temporal_rs::IsoDate date) const; + + inline diplomat::result in_leap_year(temporal_rs::IsoDate date) const; + + inline const temporal_rs::capi::Calendar* AsFFI() const; + inline temporal_rs::capi::Calendar* AsFFI(); + inline static const temporal_rs::Calendar* FromFFI(const temporal_rs::capi::Calendar* ptr); + inline static temporal_rs::Calendar* FromFFI(temporal_rs::capi::Calendar* ptr); + inline static void operator delete(void* ptr); +private: + Calendar() = delete; + Calendar(const temporal_rs::Calendar&) = delete; + Calendar(temporal_rs::Calendar&&) noexcept = delete; + Calendar operator=(const temporal_rs::Calendar&) = delete; + Calendar operator=(temporal_rs::Calendar&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_Calendar_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Calendar.hpp b/temporal_capi/bindings/cpp/temporal_rs/Calendar.hpp new file mode 100644 index 000000000..c647d20ce --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Calendar.hpp @@ -0,0 +1,279 @@ +#ifndef temporal_rs_Calendar_HPP +#define temporal_rs_Calendar_HPP + +#include "Calendar.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "AnyCalendarKind.hpp" +#include "ArithmeticOverflow.hpp" +#include "Duration.hpp" +#include "IsoDate.hpp" +#include "PartialDate.hpp" +#include "PlainDate.hpp" +#include "PlainMonthDay.hpp" +#include "PlainYearMonth.hpp" +#include "TemporalError.hpp" +#include "TemporalUnit.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + temporal_rs::capi::Calendar* temporal_rs_Calendar_create(temporal_rs::capi::AnyCalendarKind kind); + + typedef struct temporal_rs_Calendar_from_utf8_result {union {temporal_rs::capi::Calendar* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_from_utf8_result; + temporal_rs_Calendar_from_utf8_result temporal_rs_Calendar_from_utf8(diplomat::capi::DiplomatStringView s); + + bool temporal_rs_Calendar_is_iso(const temporal_rs::capi::Calendar* self); + + diplomat::capi::DiplomatStringView temporal_rs_Calendar_identifier(const temporal_rs::capi::Calendar* self); + + typedef struct temporal_rs_Calendar_date_from_partial_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_date_from_partial_result; + temporal_rs_Calendar_date_from_partial_result temporal_rs_Calendar_date_from_partial(const temporal_rs::capi::Calendar* self, temporal_rs::capi::PartialDate partial, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_Calendar_month_day_from_partial_result {union {temporal_rs::capi::PlainMonthDay* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_month_day_from_partial_result; + temporal_rs_Calendar_month_day_from_partial_result temporal_rs_Calendar_month_day_from_partial(const temporal_rs::capi::Calendar* self, temporal_rs::capi::PartialDate partial, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_Calendar_year_month_from_partial_result {union {temporal_rs::capi::PlainYearMonth* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_year_month_from_partial_result; + temporal_rs_Calendar_year_month_from_partial_result temporal_rs_Calendar_year_month_from_partial(const temporal_rs::capi::Calendar* self, temporal_rs::capi::PartialDate partial, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_Calendar_date_add_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_date_add_result; + temporal_rs_Calendar_date_add_result temporal_rs_Calendar_date_add(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date, const temporal_rs::capi::Duration* duration, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_Calendar_date_until_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_date_until_result; + temporal_rs_Calendar_date_until_result temporal_rs_Calendar_date_until(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate one, temporal_rs::capi::IsoDate two, temporal_rs::capi::TemporalUnit largest_unit); + + typedef struct temporal_rs_Calendar_era_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_era_result; + temporal_rs_Calendar_era_result temporal_rs_Calendar_era(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_Calendar_era_year_result {union {diplomat::capi::OptionI32 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_era_year_result; + temporal_rs_Calendar_era_year_result temporal_rs_Calendar_era_year(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_year_result {union {int32_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_year_result; + temporal_rs_Calendar_year_result temporal_rs_Calendar_year(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_month_result {union {uint8_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_month_result; + temporal_rs_Calendar_month_result temporal_rs_Calendar_month(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_month_code_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_month_code_result; + temporal_rs_Calendar_month_code_result temporal_rs_Calendar_month_code(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_Calendar_day_result {union {uint8_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_day_result; + temporal_rs_Calendar_day_result temporal_rs_Calendar_day(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_day_of_week_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_day_of_week_result; + temporal_rs_Calendar_day_of_week_result temporal_rs_Calendar_day_of_week(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_day_of_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_day_of_year_result; + temporal_rs_Calendar_day_of_year_result temporal_rs_Calendar_day_of_year(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_week_of_year_result {union {diplomat::capi::OptionU16 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_week_of_year_result; + temporal_rs_Calendar_week_of_year_result temporal_rs_Calendar_week_of_year(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_year_of_week_result {union {diplomat::capi::OptionI32 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_year_of_week_result; + temporal_rs_Calendar_year_of_week_result temporal_rs_Calendar_year_of_week(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_days_in_week_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_days_in_week_result; + temporal_rs_Calendar_days_in_week_result temporal_rs_Calendar_days_in_week(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_days_in_month_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_days_in_month_result; + temporal_rs_Calendar_days_in_month_result temporal_rs_Calendar_days_in_month(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_days_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_days_in_year_result; + temporal_rs_Calendar_days_in_year_result temporal_rs_Calendar_days_in_year(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_months_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_months_in_year_result; + temporal_rs_Calendar_months_in_year_result temporal_rs_Calendar_months_in_year(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + typedef struct temporal_rs_Calendar_in_leap_year_result {union {bool ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Calendar_in_leap_year_result; + temporal_rs_Calendar_in_leap_year_result temporal_rs_Calendar_in_leap_year(const temporal_rs::capi::Calendar* self, temporal_rs::capi::IsoDate date); + + + void temporal_rs_Calendar_destroy(Calendar* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline std::unique_ptr temporal_rs::Calendar::create(temporal_rs::AnyCalendarKind kind) { + auto result = temporal_rs::capi::temporal_rs_Calendar_create(kind.AsFFI()); + return std::unique_ptr(temporal_rs::Calendar::FromFFI(result)); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::from_utf8(std::string_view s) { + auto result = temporal_rs::capi::temporal_rs_Calendar_from_utf8({s.data(), s.size()}); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Calendar::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline bool temporal_rs::Calendar::is_iso() const { + auto result = temporal_rs::capi::temporal_rs_Calendar_is_iso(this->AsFFI()); + return result; +} + +inline std::string_view temporal_rs::Calendar::identifier() const { + auto result = temporal_rs::capi::temporal_rs_Calendar_identifier(this->AsFFI()); + return std::string_view(result.data, result.len); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::date_from_partial(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_date_from_partial(this->AsFFI(), + partial.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::month_day_from_partial(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_month_day_from_partial(this->AsFFI(), + partial.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainMonthDay::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::year_month_from_partial(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_year_month_from_partial(this->AsFFI(), + partial.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainYearMonth::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::date_add(temporal_rs::IsoDate date, const temporal_rs::Duration& duration, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_date_add(this->AsFFI(), + date.AsFFI(), + duration.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::date_until(temporal_rs::IsoDate one, temporal_rs::IsoDate two, temporal_rs::TemporalUnit largest_unit) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_date_until(this->AsFFI(), + one.AsFFI(), + two.AsFFI(), + largest_unit.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::era(temporal_rs::IsoDate date) const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_Calendar_era(this->AsFFI(), + date.AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::era_year(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_era_year(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::year(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_year(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::month(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_month(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::month_code(temporal_rs::IsoDate date) const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_Calendar_month_code(this->AsFFI(), + date.AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::day(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_day(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::day_of_week(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_day_of_week(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::day_of_year(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_day_of_year(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::week_of_year(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_week_of_year(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Calendar::year_of_week(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_year_of_week(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::days_in_week(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_days_in_week(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::days_in_month(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_days_in_month(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::days_in_year(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_days_in_year(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::months_in_year(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_months_in_year(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::Calendar::in_leap_year(temporal_rs::IsoDate date) const { + auto result = temporal_rs::capi::temporal_rs_Calendar_in_leap_year(this->AsFFI(), + date.AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline const temporal_rs::capi::Calendar* temporal_rs::Calendar::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::Calendar* temporal_rs::Calendar::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::Calendar* temporal_rs::Calendar::FromFFI(const temporal_rs::capi::Calendar* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::Calendar* temporal_rs::Calendar::FromFFI(temporal_rs::capi::Calendar* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::Calendar::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_Calendar_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_Calendar_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DateDuration.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/DateDuration.d.hpp new file mode 100644 index 000000000..8e0404830 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DateDuration.d.hpp @@ -0,0 +1,53 @@ +#ifndef temporal_rs_DateDuration_D_HPP +#define temporal_rs_DateDuration_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct DateDuration; } +class DateDuration; +struct TemporalError; +class Sign; +} + + +namespace temporal_rs { +namespace capi { + struct DateDuration; +} // namespace capi +} // namespace + +namespace temporal_rs { +class DateDuration { +public: + + inline static diplomat::result, temporal_rs::TemporalError> new_(double years, double months, double weeks, double days); + + inline std::unique_ptr abs() const; + + inline std::unique_ptr negated() const; + + inline temporal_rs::Sign sign() const; + + inline const temporal_rs::capi::DateDuration* AsFFI() const; + inline temporal_rs::capi::DateDuration* AsFFI(); + inline static const temporal_rs::DateDuration* FromFFI(const temporal_rs::capi::DateDuration* ptr); + inline static temporal_rs::DateDuration* FromFFI(temporal_rs::capi::DateDuration* ptr); + inline static void operator delete(void* ptr); +private: + DateDuration() = delete; + DateDuration(const temporal_rs::DateDuration&) = delete; + DateDuration(temporal_rs::DateDuration&&) noexcept = delete; + DateDuration operator=(const temporal_rs::DateDuration&) = delete; + DateDuration operator=(temporal_rs::DateDuration&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_DateDuration_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DateDuration.hpp b/temporal_capi/bindings/cpp/temporal_rs/DateDuration.hpp new file mode 100644 index 000000000..c10baae28 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DateDuration.hpp @@ -0,0 +1,81 @@ +#ifndef temporal_rs_DateDuration_HPP +#define temporal_rs_DateDuration_HPP + +#include "DateDuration.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "Sign.hpp" +#include "TemporalError.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_DateDuration_new_result {union {temporal_rs::capi::DateDuration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_DateDuration_new_result; + temporal_rs_DateDuration_new_result temporal_rs_DateDuration_new(double years, double months, double weeks, double days); + + temporal_rs::capi::DateDuration* temporal_rs_DateDuration_abs(const temporal_rs::capi::DateDuration* self); + + temporal_rs::capi::DateDuration* temporal_rs_DateDuration_negated(const temporal_rs::capi::DateDuration* self); + + temporal_rs::capi::Sign temporal_rs_DateDuration_sign(const temporal_rs::capi::DateDuration* self); + + + void temporal_rs_DateDuration_destroy(DateDuration* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::DateDuration::new_(double years, double months, double weeks, double days) { + auto result = temporal_rs::capi::temporal_rs_DateDuration_new(years, + months, + weeks, + days); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::DateDuration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline std::unique_ptr temporal_rs::DateDuration::abs() const { + auto result = temporal_rs::capi::temporal_rs_DateDuration_abs(this->AsFFI()); + return std::unique_ptr(temporal_rs::DateDuration::FromFFI(result)); +} + +inline std::unique_ptr temporal_rs::DateDuration::negated() const { + auto result = temporal_rs::capi::temporal_rs_DateDuration_negated(this->AsFFI()); + return std::unique_ptr(temporal_rs::DateDuration::FromFFI(result)); +} + +inline temporal_rs::Sign temporal_rs::DateDuration::sign() const { + auto result = temporal_rs::capi::temporal_rs_DateDuration_sign(this->AsFFI()); + return temporal_rs::Sign::FromFFI(result); +} + +inline const temporal_rs::capi::DateDuration* temporal_rs::DateDuration::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::DateDuration* temporal_rs::DateDuration::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::DateDuration* temporal_rs::DateDuration::FromFFI(const temporal_rs::capi::DateDuration* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::DateDuration* temporal_rs::DateDuration::FromFFI(temporal_rs::capi::DateDuration* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::DateDuration::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_DateDuration_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_DateDuration_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DifferenceSettings.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/DifferenceSettings.d.hpp new file mode 100644 index 000000000..8d5ef9549 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DifferenceSettings.d.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_DifferenceSettings_D_HPP +#define temporal_rs_DifferenceSettings_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "TemporalRoundingMode.d.hpp" +#include "TemporalUnit.d.hpp" + +namespace temporal_rs { +class TemporalRoundingMode; +class TemporalUnit; +} + + +namespace temporal_rs { +namespace capi { + struct DifferenceSettings { + temporal_rs::capi::TemporalUnit_option largest_unit; + temporal_rs::capi::TemporalUnit_option smallest_unit; + temporal_rs::capi::TemporalRoundingMode_option rounding_mode; + diplomat::capi::OptionU32 increment; + }; + + typedef struct DifferenceSettings_option {union { DifferenceSettings ok; }; bool is_ok; } DifferenceSettings_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct DifferenceSettings { + std::optional largest_unit; + std::optional smallest_unit; + std::optional rounding_mode; + std::optional increment; + + inline temporal_rs::capi::DifferenceSettings AsFFI() const; + inline static temporal_rs::DifferenceSettings FromFFI(temporal_rs::capi::DifferenceSettings c_struct); +}; + +} // namespace +#endif // temporal_rs_DifferenceSettings_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DifferenceSettings.hpp b/temporal_capi/bindings/cpp/temporal_rs/DifferenceSettings.hpp new file mode 100644 index 000000000..b950d5a16 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DifferenceSettings.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_DifferenceSettings_HPP +#define temporal_rs_DifferenceSettings_HPP + +#include "DifferenceSettings.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "TemporalRoundingMode.hpp" +#include "TemporalUnit.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::DifferenceSettings temporal_rs::DifferenceSettings::AsFFI() const { + return temporal_rs::capi::DifferenceSettings { + /* .largest_unit = */ largest_unit.has_value() ? (temporal_rs::capi::TemporalUnit_option{ { largest_unit.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalUnit_option{ {}, false }), + /* .smallest_unit = */ smallest_unit.has_value() ? (temporal_rs::capi::TemporalUnit_option{ { smallest_unit.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalUnit_option{ {}, false }), + /* .rounding_mode = */ rounding_mode.has_value() ? (temporal_rs::capi::TemporalRoundingMode_option{ { rounding_mode.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalRoundingMode_option{ {}, false }), + /* .increment = */ increment.has_value() ? (diplomat::capi::OptionU32{ { increment.value() }, true }) : (diplomat::capi::OptionU32{ {}, false }), + }; +} + +inline temporal_rs::DifferenceSettings temporal_rs::DifferenceSettings::FromFFI(temporal_rs::capi::DifferenceSettings c_struct) { + return temporal_rs::DifferenceSettings { + /* .largest_unit = */ c_struct.largest_unit.is_ok ? std::optional(temporal_rs::TemporalUnit::FromFFI(c_struct.largest_unit.ok)) : std::nullopt, + /* .smallest_unit = */ c_struct.smallest_unit.is_ok ? std::optional(temporal_rs::TemporalUnit::FromFFI(c_struct.smallest_unit.ok)) : std::nullopt, + /* .rounding_mode = */ c_struct.rounding_mode.is_ok ? std::optional(temporal_rs::TemporalRoundingMode::FromFFI(c_struct.rounding_mode.ok)) : std::nullopt, + /* .increment = */ c_struct.increment.is_ok ? std::optional(c_struct.increment.ok) : std::nullopt, + }; +} + + +#endif // temporal_rs_DifferenceSettings_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Disambiguation.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/Disambiguation.d.hpp new file mode 100644 index 000000000..b20580f7b --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Disambiguation.d.hpp @@ -0,0 +1,50 @@ +#ifndef temporal_rs_Disambiguation_D_HPP +#define temporal_rs_Disambiguation_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum Disambiguation { + Disambiguation_Compatible = 0, + Disambiguation_Earlier = 1, + Disambiguation_Later = 2, + Disambiguation_Reject = 3, + }; + + typedef struct Disambiguation_option {union { Disambiguation ok; }; bool is_ok; } Disambiguation_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class Disambiguation { +public: + enum Value { + Compatible = 0, + Earlier = 1, + Later = 2, + Reject = 3, + }; + + Disambiguation() = default; + // Implicit conversions between enum and ::Value + constexpr Disambiguation(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::Disambiguation AsFFI() const; + inline static temporal_rs::Disambiguation FromFFI(temporal_rs::capi::Disambiguation c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_Disambiguation_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Disambiguation.hpp b/temporal_capi/bindings/cpp/temporal_rs/Disambiguation.hpp new file mode 100644 index 000000000..a18dbce00 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Disambiguation.hpp @@ -0,0 +1,39 @@ +#ifndef temporal_rs_Disambiguation_HPP +#define temporal_rs_Disambiguation_HPP + +#include "Disambiguation.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::Disambiguation temporal_rs::Disambiguation::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::Disambiguation temporal_rs::Disambiguation::FromFFI(temporal_rs::capi::Disambiguation c_enum) { + switch (c_enum) { + case temporal_rs::capi::Disambiguation_Compatible: + case temporal_rs::capi::Disambiguation_Earlier: + case temporal_rs::capi::Disambiguation_Later: + case temporal_rs::capi::Disambiguation_Reject: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_Disambiguation_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DisplayCalendar.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/DisplayCalendar.d.hpp new file mode 100644 index 000000000..89360c524 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DisplayCalendar.d.hpp @@ -0,0 +1,50 @@ +#ifndef temporal_rs_DisplayCalendar_D_HPP +#define temporal_rs_DisplayCalendar_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum DisplayCalendar { + DisplayCalendar_Auto = 0, + DisplayCalendar_Always = 1, + DisplayCalendar_Never = 2, + DisplayCalendar_Critical = 3, + }; + + typedef struct DisplayCalendar_option {union { DisplayCalendar ok; }; bool is_ok; } DisplayCalendar_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class DisplayCalendar { +public: + enum Value { + Auto = 0, + Always = 1, + Never = 2, + Critical = 3, + }; + + DisplayCalendar() = default; + // Implicit conversions between enum and ::Value + constexpr DisplayCalendar(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::DisplayCalendar AsFFI() const; + inline static temporal_rs::DisplayCalendar FromFFI(temporal_rs::capi::DisplayCalendar c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_DisplayCalendar_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DisplayCalendar.hpp b/temporal_capi/bindings/cpp/temporal_rs/DisplayCalendar.hpp new file mode 100644 index 000000000..d55652c0a --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DisplayCalendar.hpp @@ -0,0 +1,39 @@ +#ifndef temporal_rs_DisplayCalendar_HPP +#define temporal_rs_DisplayCalendar_HPP + +#include "DisplayCalendar.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::DisplayCalendar temporal_rs::DisplayCalendar::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::DisplayCalendar temporal_rs::DisplayCalendar::FromFFI(temporal_rs::capi::DisplayCalendar c_enum) { + switch (c_enum) { + case temporal_rs::capi::DisplayCalendar_Auto: + case temporal_rs::capi::DisplayCalendar_Always: + case temporal_rs::capi::DisplayCalendar_Never: + case temporal_rs::capi::DisplayCalendar_Critical: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_DisplayCalendar_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DisplayOffset.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/DisplayOffset.d.hpp new file mode 100644 index 000000000..57f0aa2bb --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DisplayOffset.d.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_DisplayOffset_D_HPP +#define temporal_rs_DisplayOffset_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum DisplayOffset { + DisplayOffset_Auto = 0, + DisplayOffset_Never = 1, + }; + + typedef struct DisplayOffset_option {union { DisplayOffset ok; }; bool is_ok; } DisplayOffset_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class DisplayOffset { +public: + enum Value { + Auto = 0, + Never = 1, + }; + + DisplayOffset() = default; + // Implicit conversions between enum and ::Value + constexpr DisplayOffset(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::DisplayOffset AsFFI() const; + inline static temporal_rs::DisplayOffset FromFFI(temporal_rs::capi::DisplayOffset c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_DisplayOffset_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DisplayOffset.hpp b/temporal_capi/bindings/cpp/temporal_rs/DisplayOffset.hpp new file mode 100644 index 000000000..af263a64b --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DisplayOffset.hpp @@ -0,0 +1,37 @@ +#ifndef temporal_rs_DisplayOffset_HPP +#define temporal_rs_DisplayOffset_HPP + +#include "DisplayOffset.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::DisplayOffset temporal_rs::DisplayOffset::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::DisplayOffset temporal_rs::DisplayOffset::FromFFI(temporal_rs::capi::DisplayOffset c_enum) { + switch (c_enum) { + case temporal_rs::capi::DisplayOffset_Auto: + case temporal_rs::capi::DisplayOffset_Never: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_DisplayOffset_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DisplayTimeZone.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/DisplayTimeZone.d.hpp new file mode 100644 index 000000000..110bd351b --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DisplayTimeZone.d.hpp @@ -0,0 +1,48 @@ +#ifndef temporal_rs_DisplayTimeZone_D_HPP +#define temporal_rs_DisplayTimeZone_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum DisplayTimeZone { + DisplayTimeZone_Auto = 0, + DisplayTimeZone_Never = 1, + DisplayTimeZone_Critical = 2, + }; + + typedef struct DisplayTimeZone_option {union { DisplayTimeZone ok; }; bool is_ok; } DisplayTimeZone_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class DisplayTimeZone { +public: + enum Value { + Auto = 0, + Never = 1, + Critical = 2, + }; + + DisplayTimeZone() = default; + // Implicit conversions between enum and ::Value + constexpr DisplayTimeZone(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::DisplayTimeZone AsFFI() const; + inline static temporal_rs::DisplayTimeZone FromFFI(temporal_rs::capi::DisplayTimeZone c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_DisplayTimeZone_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DisplayTimeZone.hpp b/temporal_capi/bindings/cpp/temporal_rs/DisplayTimeZone.hpp new file mode 100644 index 000000000..a4f5e17e4 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DisplayTimeZone.hpp @@ -0,0 +1,38 @@ +#ifndef temporal_rs_DisplayTimeZone_HPP +#define temporal_rs_DisplayTimeZone_HPP + +#include "DisplayTimeZone.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::DisplayTimeZone temporal_rs::DisplayTimeZone::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::DisplayTimeZone temporal_rs::DisplayTimeZone::FromFFI(temporal_rs::capi::DisplayTimeZone c_enum) { + switch (c_enum) { + case temporal_rs::capi::DisplayTimeZone_Auto: + case temporal_rs::capi::DisplayTimeZone_Never: + case temporal_rs::capi::DisplayTimeZone_Critical: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_DisplayTimeZone_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Duration.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/Duration.d.hpp new file mode 100644 index 000000000..13f528a69 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Duration.d.hpp @@ -0,0 +1,94 @@ +#ifndef temporal_rs_Duration_D_HPP +#define temporal_rs_Duration_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct DateDuration; } +class DateDuration; +namespace capi { struct Duration; } +class Duration; +namespace capi { struct TimeDuration; } +class TimeDuration; +struct PartialDuration; +struct TemporalError; +class Sign; +} + + +namespace temporal_rs { +namespace capi { + struct Duration; +} // namespace capi +} // namespace + +namespace temporal_rs { +class Duration { +public: + + inline static diplomat::result, temporal_rs::TemporalError> create(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds); + + inline static diplomat::result, temporal_rs::TemporalError> from_day_and_time(double day, const temporal_rs::TimeDuration& time); + + inline static diplomat::result, temporal_rs::TemporalError> from_partial_duration(temporal_rs::PartialDuration partial); + + inline bool is_time_within_range() const; + + inline const temporal_rs::TimeDuration& time() const; + + inline const temporal_rs::DateDuration& date() const; + + inline double years() const; + + inline double months() const; + + inline double weeks() const; + + inline double days() const; + + inline double hours() const; + + inline double minutes() const; + + inline double seconds() const; + + inline double milliseconds() const; + + inline double microseconds() const; + + inline double nanoseconds() const; + + inline temporal_rs::Sign sign() const; + + inline bool is_zero() const; + + inline std::unique_ptr abs() const; + + inline std::unique_ptr negated() const; + + inline diplomat::result, temporal_rs::TemporalError> add(const temporal_rs::Duration& other) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract(const temporal_rs::Duration& other) const; + + inline const temporal_rs::capi::Duration* AsFFI() const; + inline temporal_rs::capi::Duration* AsFFI(); + inline static const temporal_rs::Duration* FromFFI(const temporal_rs::capi::Duration* ptr); + inline static temporal_rs::Duration* FromFFI(temporal_rs::capi::Duration* ptr); + inline static void operator delete(void* ptr); +private: + Duration() = delete; + Duration(const temporal_rs::Duration&) = delete; + Duration(temporal_rs::Duration&&) noexcept = delete; + Duration operator=(const temporal_rs::Duration&) = delete; + Duration operator=(temporal_rs::Duration&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_Duration_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Duration.hpp b/temporal_capi/bindings/cpp/temporal_rs/Duration.hpp new file mode 100644 index 000000000..8899b61c7 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Duration.hpp @@ -0,0 +1,223 @@ +#ifndef temporal_rs_Duration_HPP +#define temporal_rs_Duration_HPP + +#include "Duration.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "DateDuration.hpp" +#include "PartialDuration.hpp" +#include "Sign.hpp" +#include "TemporalError.hpp" +#include "TimeDuration.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_Duration_create_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Duration_create_result; + temporal_rs_Duration_create_result temporal_rs_Duration_create(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds); + + typedef struct temporal_rs_Duration_from_day_and_time_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Duration_from_day_and_time_result; + temporal_rs_Duration_from_day_and_time_result temporal_rs_Duration_from_day_and_time(double day, const temporal_rs::capi::TimeDuration* time); + + typedef struct temporal_rs_Duration_from_partial_duration_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Duration_from_partial_duration_result; + temporal_rs_Duration_from_partial_duration_result temporal_rs_Duration_from_partial_duration(temporal_rs::capi::PartialDuration partial); + + bool temporal_rs_Duration_is_time_within_range(const temporal_rs::capi::Duration* self); + + const temporal_rs::capi::TimeDuration* temporal_rs_Duration_time(const temporal_rs::capi::Duration* self); + + const temporal_rs::capi::DateDuration* temporal_rs_Duration_date(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_years(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_months(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_weeks(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_days(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_hours(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_minutes(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_seconds(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_milliseconds(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_microseconds(const temporal_rs::capi::Duration* self); + + double temporal_rs_Duration_nanoseconds(const temporal_rs::capi::Duration* self); + + temporal_rs::capi::Sign temporal_rs_Duration_sign(const temporal_rs::capi::Duration* self); + + bool temporal_rs_Duration_is_zero(const temporal_rs::capi::Duration* self); + + temporal_rs::capi::Duration* temporal_rs_Duration_abs(const temporal_rs::capi::Duration* self); + + temporal_rs::capi::Duration* temporal_rs_Duration_negated(const temporal_rs::capi::Duration* self); + + typedef struct temporal_rs_Duration_add_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Duration_add_result; + temporal_rs_Duration_add_result temporal_rs_Duration_add(const temporal_rs::capi::Duration* self, const temporal_rs::capi::Duration* other); + + typedef struct temporal_rs_Duration_subtract_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Duration_subtract_result; + temporal_rs_Duration_subtract_result temporal_rs_Duration_subtract(const temporal_rs::capi::Duration* self, const temporal_rs::capi::Duration* other); + + + void temporal_rs_Duration_destroy(Duration* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Duration::create(double years, double months, double weeks, double days, double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds) { + auto result = temporal_rs::capi::temporal_rs_Duration_create(years, + months, + weeks, + days, + hours, + minutes, + seconds, + milliseconds, + microseconds, + nanoseconds); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Duration::from_day_and_time(double day, const temporal_rs::TimeDuration& time) { + auto result = temporal_rs::capi::temporal_rs_Duration_from_day_and_time(day, + time.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Duration::from_partial_duration(temporal_rs::PartialDuration partial) { + auto result = temporal_rs::capi::temporal_rs_Duration_from_partial_duration(partial.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline bool temporal_rs::Duration::is_time_within_range() const { + auto result = temporal_rs::capi::temporal_rs_Duration_is_time_within_range(this->AsFFI()); + return result; +} + +inline const temporal_rs::TimeDuration& temporal_rs::Duration::time() const { + auto result = temporal_rs::capi::temporal_rs_Duration_time(this->AsFFI()); + return *temporal_rs::TimeDuration::FromFFI(result); +} + +inline const temporal_rs::DateDuration& temporal_rs::Duration::date() const { + auto result = temporal_rs::capi::temporal_rs_Duration_date(this->AsFFI()); + return *temporal_rs::DateDuration::FromFFI(result); +} + +inline double temporal_rs::Duration::years() const { + auto result = temporal_rs::capi::temporal_rs_Duration_years(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::months() const { + auto result = temporal_rs::capi::temporal_rs_Duration_months(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::weeks() const { + auto result = temporal_rs::capi::temporal_rs_Duration_weeks(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::days() const { + auto result = temporal_rs::capi::temporal_rs_Duration_days(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::hours() const { + auto result = temporal_rs::capi::temporal_rs_Duration_hours(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::minutes() const { + auto result = temporal_rs::capi::temporal_rs_Duration_minutes(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::seconds() const { + auto result = temporal_rs::capi::temporal_rs_Duration_seconds(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::milliseconds() const { + auto result = temporal_rs::capi::temporal_rs_Duration_milliseconds(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::microseconds() const { + auto result = temporal_rs::capi::temporal_rs_Duration_microseconds(this->AsFFI()); + return result; +} + +inline double temporal_rs::Duration::nanoseconds() const { + auto result = temporal_rs::capi::temporal_rs_Duration_nanoseconds(this->AsFFI()); + return result; +} + +inline temporal_rs::Sign temporal_rs::Duration::sign() const { + auto result = temporal_rs::capi::temporal_rs_Duration_sign(this->AsFFI()); + return temporal_rs::Sign::FromFFI(result); +} + +inline bool temporal_rs::Duration::is_zero() const { + auto result = temporal_rs::capi::temporal_rs_Duration_is_zero(this->AsFFI()); + return result; +} + +inline std::unique_ptr temporal_rs::Duration::abs() const { + auto result = temporal_rs::capi::temporal_rs_Duration_abs(this->AsFFI()); + return std::unique_ptr(temporal_rs::Duration::FromFFI(result)); +} + +inline std::unique_ptr temporal_rs::Duration::negated() const { + auto result = temporal_rs::capi::temporal_rs_Duration_negated(this->AsFFI()); + return std::unique_ptr(temporal_rs::Duration::FromFFI(result)); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Duration::add(const temporal_rs::Duration& other) const { + auto result = temporal_rs::capi::temporal_rs_Duration_add(this->AsFFI(), + other.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Duration::subtract(const temporal_rs::Duration& other) const { + auto result = temporal_rs::capi::temporal_rs_Duration_subtract(this->AsFFI(), + other.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline const temporal_rs::capi::Duration* temporal_rs::Duration::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::Duration* temporal_rs::Duration::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::Duration* temporal_rs::Duration::FromFFI(const temporal_rs::capi::Duration* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::Duration* temporal_rs::Duration::FromFFI(temporal_rs::capi::Duration* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::Duration::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_Duration_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_Duration_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.d.hpp new file mode 100644 index 000000000..c821516ba --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.d.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_DurationOverflow_D_HPP +#define temporal_rs_DurationOverflow_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum DurationOverflow { + DurationOverflow_Constrain = 0, + DurationOverflow_Balance = 1, + }; + + typedef struct DurationOverflow_option {union { DurationOverflow ok; }; bool is_ok; } DurationOverflow_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class DurationOverflow { +public: + enum Value { + Constrain = 0, + Balance = 1, + }; + + DurationOverflow() = default; + // Implicit conversions between enum and ::Value + constexpr DurationOverflow(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::DurationOverflow AsFFI() const; + inline static temporal_rs::DurationOverflow FromFFI(temporal_rs::capi::DurationOverflow c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_DurationOverflow_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.hpp b/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.hpp new file mode 100644 index 000000000..107feb427 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/DurationOverflow.hpp @@ -0,0 +1,37 @@ +#ifndef temporal_rs_DurationOverflow_HPP +#define temporal_rs_DurationOverflow_HPP + +#include "DurationOverflow.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::DurationOverflow temporal_rs::DurationOverflow::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::DurationOverflow temporal_rs::DurationOverflow::FromFFI(temporal_rs::capi::DurationOverflow c_enum) { + switch (c_enum) { + case temporal_rs::capi::DurationOverflow_Constrain: + case temporal_rs::capi::DurationOverflow_Balance: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_DurationOverflow_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/ErrorKind.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/ErrorKind.d.hpp new file mode 100644 index 000000000..86de2a4f6 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/ErrorKind.d.hpp @@ -0,0 +1,52 @@ +#ifndef temporal_rs_ErrorKind_D_HPP +#define temporal_rs_ErrorKind_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum ErrorKind { + ErrorKind_Generic = 0, + ErrorKind_Type = 1, + ErrorKind_Range = 2, + ErrorKind_Syntax = 3, + ErrorKind_Assert = 4, + }; + + typedef struct ErrorKind_option {union { ErrorKind ok; }; bool is_ok; } ErrorKind_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class ErrorKind { +public: + enum Value { + Generic = 0, + Type = 1, + Range = 2, + Syntax = 3, + Assert = 4, + }; + + ErrorKind() = default; + // Implicit conversions between enum and ::Value + constexpr ErrorKind(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::ErrorKind AsFFI() const; + inline static temporal_rs::ErrorKind FromFFI(temporal_rs::capi::ErrorKind c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_ErrorKind_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/ErrorKind.hpp b/temporal_capi/bindings/cpp/temporal_rs/ErrorKind.hpp new file mode 100644 index 000000000..c2bf41b27 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/ErrorKind.hpp @@ -0,0 +1,40 @@ +#ifndef temporal_rs_ErrorKind_HPP +#define temporal_rs_ErrorKind_HPP + +#include "ErrorKind.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::ErrorKind temporal_rs::ErrorKind::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::ErrorKind temporal_rs::ErrorKind::FromFFI(temporal_rs::capi::ErrorKind c_enum) { + switch (c_enum) { + case temporal_rs::capi::ErrorKind_Generic: + case temporal_rs::capi::ErrorKind_Type: + case temporal_rs::capi::ErrorKind_Range: + case temporal_rs::capi::ErrorKind_Syntax: + case temporal_rs::capi::ErrorKind_Assert: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_ErrorKind_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/I128Nanoseconds.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/I128Nanoseconds.d.hpp new file mode 100644 index 000000000..09234248c --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/I128Nanoseconds.d.hpp @@ -0,0 +1,35 @@ +#ifndef temporal_rs_I128Nanoseconds_D_HPP +#define temporal_rs_I128Nanoseconds_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + struct I128Nanoseconds { + int64_t high; + uint64_t low; + }; + + typedef struct I128Nanoseconds_option {union { I128Nanoseconds ok; }; bool is_ok; } I128Nanoseconds_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct I128Nanoseconds { + int64_t high; + uint64_t low; + + inline temporal_rs::capi::I128Nanoseconds AsFFI() const; + inline static temporal_rs::I128Nanoseconds FromFFI(temporal_rs::capi::I128Nanoseconds c_struct); +}; + +} // namespace +#endif // temporal_rs_I128Nanoseconds_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/I128Nanoseconds.hpp b/temporal_capi/bindings/cpp/temporal_rs/I128Nanoseconds.hpp new file mode 100644 index 000000000..a1390c0e7 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/I128Nanoseconds.hpp @@ -0,0 +1,40 @@ +#ifndef temporal_rs_I128Nanoseconds_HPP +#define temporal_rs_I128Nanoseconds_HPP + +#include "I128Nanoseconds.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::I128Nanoseconds temporal_rs::I128Nanoseconds::AsFFI() const { + return temporal_rs::capi::I128Nanoseconds { + /* .high = */ high, + /* .low = */ low, + }; +} + +inline temporal_rs::I128Nanoseconds temporal_rs::I128Nanoseconds::FromFFI(temporal_rs::capi::I128Nanoseconds c_struct) { + return temporal_rs::I128Nanoseconds { + /* .high = */ c_struct.high, + /* .low = */ c_struct.low, + }; +} + + +#endif // temporal_rs_I128Nanoseconds_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Instant.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/Instant.d.hpp new file mode 100644 index 000000000..85ed94674 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Instant.d.hpp @@ -0,0 +1,73 @@ +#ifndef temporal_rs_Instant_D_HPP +#define temporal_rs_Instant_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Duration; } +class Duration; +namespace capi { struct Instant; } +class Instant; +namespace capi { struct TimeDuration; } +class TimeDuration; +struct DifferenceSettings; +struct I128Nanoseconds; +struct RoundingOptions; +struct TemporalError; +} + + +namespace temporal_rs { +namespace capi { + struct Instant; +} // namespace capi +} // namespace + +namespace temporal_rs { +class Instant { +public: + + inline static diplomat::result, temporal_rs::TemporalError> try_new(temporal_rs::I128Nanoseconds ns); + + inline static diplomat::result, temporal_rs::TemporalError> from_epoch_milliseconds(int64_t epoch_milliseconds); + + inline diplomat::result, temporal_rs::TemporalError> add(const temporal_rs::Duration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> add_time_duration(const temporal_rs::TimeDuration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract(const temporal_rs::Duration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract_time_duration(const temporal_rs::TimeDuration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> since(const temporal_rs::Instant& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> until(const temporal_rs::Instant& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> round(temporal_rs::RoundingOptions options) const; + + inline int64_t epoch_milliseconds() const; + + inline temporal_rs::I128Nanoseconds epoch_nanoseconds() const; + + inline const temporal_rs::capi::Instant* AsFFI() const; + inline temporal_rs::capi::Instant* AsFFI(); + inline static const temporal_rs::Instant* FromFFI(const temporal_rs::capi::Instant* ptr); + inline static temporal_rs::Instant* FromFFI(temporal_rs::capi::Instant* ptr); + inline static void operator delete(void* ptr); +private: + Instant() = delete; + Instant(const temporal_rs::Instant&) = delete; + Instant(temporal_rs::Instant&&) noexcept = delete; + Instant operator=(const temporal_rs::Instant&) = delete; + Instant operator=(temporal_rs::Instant&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_Instant_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Instant.hpp b/temporal_capi/bindings/cpp/temporal_rs/Instant.hpp new file mode 100644 index 000000000..c58366ede --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Instant.hpp @@ -0,0 +1,148 @@ +#ifndef temporal_rs_Instant_HPP +#define temporal_rs_Instant_HPP + +#include "Instant.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "DifferenceSettings.hpp" +#include "Duration.hpp" +#include "I128Nanoseconds.hpp" +#include "RoundingOptions.hpp" +#include "TemporalError.hpp" +#include "TimeDuration.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_Instant_try_new_result {union {temporal_rs::capi::Instant* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_try_new_result; + temporal_rs_Instant_try_new_result temporal_rs_Instant_try_new(temporal_rs::capi::I128Nanoseconds ns); + + typedef struct temporal_rs_Instant_from_epoch_milliseconds_result {union {temporal_rs::capi::Instant* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_from_epoch_milliseconds_result; + temporal_rs_Instant_from_epoch_milliseconds_result temporal_rs_Instant_from_epoch_milliseconds(int64_t epoch_milliseconds); + + typedef struct temporal_rs_Instant_add_result {union {temporal_rs::capi::Instant* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_add_result; + temporal_rs_Instant_add_result temporal_rs_Instant_add(const temporal_rs::capi::Instant* self, const temporal_rs::capi::Duration* duration); + + typedef struct temporal_rs_Instant_add_time_duration_result {union {temporal_rs::capi::Instant* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_add_time_duration_result; + temporal_rs_Instant_add_time_duration_result temporal_rs_Instant_add_time_duration(const temporal_rs::capi::Instant* self, const temporal_rs::capi::TimeDuration* duration); + + typedef struct temporal_rs_Instant_subtract_result {union {temporal_rs::capi::Instant* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_subtract_result; + temporal_rs_Instant_subtract_result temporal_rs_Instant_subtract(const temporal_rs::capi::Instant* self, const temporal_rs::capi::Duration* duration); + + typedef struct temporal_rs_Instant_subtract_time_duration_result {union {temporal_rs::capi::Instant* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_subtract_time_duration_result; + temporal_rs_Instant_subtract_time_duration_result temporal_rs_Instant_subtract_time_duration(const temporal_rs::capi::Instant* self, const temporal_rs::capi::TimeDuration* duration); + + typedef struct temporal_rs_Instant_since_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_since_result; + temporal_rs_Instant_since_result temporal_rs_Instant_since(const temporal_rs::capi::Instant* self, const temporal_rs::capi::Instant* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_Instant_until_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_until_result; + temporal_rs_Instant_until_result temporal_rs_Instant_until(const temporal_rs::capi::Instant* self, const temporal_rs::capi::Instant* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_Instant_round_result {union {temporal_rs::capi::Instant* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_Instant_round_result; + temporal_rs_Instant_round_result temporal_rs_Instant_round(const temporal_rs::capi::Instant* self, temporal_rs::capi::RoundingOptions options); + + int64_t temporal_rs_Instant_epoch_milliseconds(const temporal_rs::capi::Instant* self); + + temporal_rs::capi::I128Nanoseconds temporal_rs_Instant_epoch_nanoseconds(const temporal_rs::capi::Instant* self); + + + void temporal_rs_Instant_destroy(Instant* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::try_new(temporal_rs::I128Nanoseconds ns) { + auto result = temporal_rs::capi::temporal_rs_Instant_try_new(ns.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Instant::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::from_epoch_milliseconds(int64_t epoch_milliseconds) { + auto result = temporal_rs::capi::temporal_rs_Instant_from_epoch_milliseconds(epoch_milliseconds); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Instant::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::add(const temporal_rs::Duration& duration) const { + auto result = temporal_rs::capi::temporal_rs_Instant_add(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Instant::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::add_time_duration(const temporal_rs::TimeDuration& duration) const { + auto result = temporal_rs::capi::temporal_rs_Instant_add_time_duration(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Instant::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::subtract(const temporal_rs::Duration& duration) const { + auto result = temporal_rs::capi::temporal_rs_Instant_subtract(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Instant::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::subtract_time_duration(const temporal_rs::TimeDuration& duration) const { + auto result = temporal_rs::capi::temporal_rs_Instant_subtract_time_duration(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Instant::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::since(const temporal_rs::Instant& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_Instant_since(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::until(const temporal_rs::Instant& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_Instant_until(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::Instant::round(temporal_rs::RoundingOptions options) const { + auto result = temporal_rs::capi::temporal_rs_Instant_round(this->AsFFI(), + options.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Instant::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline int64_t temporal_rs::Instant::epoch_milliseconds() const { + auto result = temporal_rs::capi::temporal_rs_Instant_epoch_milliseconds(this->AsFFI()); + return result; +} + +inline temporal_rs::I128Nanoseconds temporal_rs::Instant::epoch_nanoseconds() const { + auto result = temporal_rs::capi::temporal_rs_Instant_epoch_nanoseconds(this->AsFFI()); + return temporal_rs::I128Nanoseconds::FromFFI(result); +} + +inline const temporal_rs::capi::Instant* temporal_rs::Instant::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::Instant* temporal_rs::Instant::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::Instant* temporal_rs::Instant::FromFFI(const temporal_rs::capi::Instant* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::Instant* temporal_rs::Instant::FromFFI(temporal_rs::capi::Instant* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::Instant::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_Instant_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_Instant_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/IsoDate.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/IsoDate.d.hpp new file mode 100644 index 000000000..9e5058ad1 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/IsoDate.d.hpp @@ -0,0 +1,37 @@ +#ifndef temporal_rs_IsoDate_D_HPP +#define temporal_rs_IsoDate_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + struct IsoDate { + int32_t year; + uint8_t month; + uint8_t day; + }; + + typedef struct IsoDate_option {union { IsoDate ok; }; bool is_ok; } IsoDate_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct IsoDate { + int32_t year; + uint8_t month; + uint8_t day; + + inline temporal_rs::capi::IsoDate AsFFI() const; + inline static temporal_rs::IsoDate FromFFI(temporal_rs::capi::IsoDate c_struct); +}; + +} // namespace +#endif // temporal_rs_IsoDate_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/IsoDate.hpp b/temporal_capi/bindings/cpp/temporal_rs/IsoDate.hpp new file mode 100644 index 000000000..e0cbb5f30 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/IsoDate.hpp @@ -0,0 +1,42 @@ +#ifndef temporal_rs_IsoDate_HPP +#define temporal_rs_IsoDate_HPP + +#include "IsoDate.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::IsoDate temporal_rs::IsoDate::AsFFI() const { + return temporal_rs::capi::IsoDate { + /* .year = */ year, + /* .month = */ month, + /* .day = */ day, + }; +} + +inline temporal_rs::IsoDate temporal_rs::IsoDate::FromFFI(temporal_rs::capi::IsoDate c_struct) { + return temporal_rs::IsoDate { + /* .year = */ c_struct.year, + /* .month = */ c_struct.month, + /* .day = */ c_struct.day, + }; +} + + +#endif // temporal_rs_IsoDate_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/IsoDateTime.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/IsoDateTime.d.hpp new file mode 100644 index 000000000..717faab86 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/IsoDateTime.d.hpp @@ -0,0 +1,42 @@ +#ifndef temporal_rs_IsoDateTime_D_HPP +#define temporal_rs_IsoDateTime_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "IsoDate.d.hpp" +#include "IsoTime.d.hpp" + +namespace temporal_rs { +struct IsoDate; +struct IsoTime; +} + + +namespace temporal_rs { +namespace capi { + struct IsoDateTime { + temporal_rs::capi::IsoDate date; + temporal_rs::capi::IsoTime time; + }; + + typedef struct IsoDateTime_option {union { IsoDateTime ok; }; bool is_ok; } IsoDateTime_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct IsoDateTime { + temporal_rs::IsoDate date; + temporal_rs::IsoTime time; + + inline temporal_rs::capi::IsoDateTime AsFFI() const; + inline static temporal_rs::IsoDateTime FromFFI(temporal_rs::capi::IsoDateTime c_struct); +}; + +} // namespace +#endif // temporal_rs_IsoDateTime_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/IsoDateTime.hpp b/temporal_capi/bindings/cpp/temporal_rs/IsoDateTime.hpp new file mode 100644 index 000000000..ebec63657 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/IsoDateTime.hpp @@ -0,0 +1,42 @@ +#ifndef temporal_rs_IsoDateTime_HPP +#define temporal_rs_IsoDateTime_HPP + +#include "IsoDateTime.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "IsoDate.hpp" +#include "IsoTime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::IsoDateTime temporal_rs::IsoDateTime::AsFFI() const { + return temporal_rs::capi::IsoDateTime { + /* .date = */ date.AsFFI(), + /* .time = */ time.AsFFI(), + }; +} + +inline temporal_rs::IsoDateTime temporal_rs::IsoDateTime::FromFFI(temporal_rs::capi::IsoDateTime c_struct) { + return temporal_rs::IsoDateTime { + /* .date = */ temporal_rs::IsoDate::FromFFI(c_struct.date), + /* .time = */ temporal_rs::IsoTime::FromFFI(c_struct.time), + }; +} + + +#endif // temporal_rs_IsoDateTime_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/IsoTime.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/IsoTime.d.hpp new file mode 100644 index 000000000..fb5566391 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/IsoTime.d.hpp @@ -0,0 +1,43 @@ +#ifndef temporal_rs_IsoTime_D_HPP +#define temporal_rs_IsoTime_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + struct IsoTime { + uint8_t hour; + uint8_t minute; + uint8_t second; + uint16_t millisecond; + uint16_t microsecond; + uint16_t nanosecond; + }; + + typedef struct IsoTime_option {union { IsoTime ok; }; bool is_ok; } IsoTime_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct IsoTime { + uint8_t hour; + uint8_t minute; + uint8_t second; + uint16_t millisecond; + uint16_t microsecond; + uint16_t nanosecond; + + inline temporal_rs::capi::IsoTime AsFFI() const; + inline static temporal_rs::IsoTime FromFFI(temporal_rs::capi::IsoTime c_struct); +}; + +} // namespace +#endif // temporal_rs_IsoTime_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/IsoTime.hpp b/temporal_capi/bindings/cpp/temporal_rs/IsoTime.hpp new file mode 100644 index 000000000..42f7311f3 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/IsoTime.hpp @@ -0,0 +1,48 @@ +#ifndef temporal_rs_IsoTime_HPP +#define temporal_rs_IsoTime_HPP + +#include "IsoTime.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::IsoTime temporal_rs::IsoTime::AsFFI() const { + return temporal_rs::capi::IsoTime { + /* .hour = */ hour, + /* .minute = */ minute, + /* .second = */ second, + /* .millisecond = */ millisecond, + /* .microsecond = */ microsecond, + /* .nanosecond = */ nanosecond, + }; +} + +inline temporal_rs::IsoTime temporal_rs::IsoTime::FromFFI(temporal_rs::capi::IsoTime c_struct) { + return temporal_rs::IsoTime { + /* .hour = */ c_struct.hour, + /* .minute = */ c_struct.minute, + /* .second = */ c_struct.second, + /* .millisecond = */ c_struct.millisecond, + /* .microsecond = */ c_struct.microsecond, + /* .nanosecond = */ c_struct.nanosecond, + }; +} + + +#endif // temporal_rs_IsoTime_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/OffsetDisambiguation.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/OffsetDisambiguation.d.hpp new file mode 100644 index 000000000..3968dc2d3 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/OffsetDisambiguation.d.hpp @@ -0,0 +1,50 @@ +#ifndef temporal_rs_OffsetDisambiguation_D_HPP +#define temporal_rs_OffsetDisambiguation_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum OffsetDisambiguation { + OffsetDisambiguation_Use = 0, + OffsetDisambiguation_Prefer = 1, + OffsetDisambiguation_Ignore = 2, + OffsetDisambiguation_Reject = 3, + }; + + typedef struct OffsetDisambiguation_option {union { OffsetDisambiguation ok; }; bool is_ok; } OffsetDisambiguation_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class OffsetDisambiguation { +public: + enum Value { + Use = 0, + Prefer = 1, + Ignore = 2, + Reject = 3, + }; + + OffsetDisambiguation() = default; + // Implicit conversions between enum and ::Value + constexpr OffsetDisambiguation(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::OffsetDisambiguation AsFFI() const; + inline static temporal_rs::OffsetDisambiguation FromFFI(temporal_rs::capi::OffsetDisambiguation c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_OffsetDisambiguation_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/OffsetDisambiguation.hpp b/temporal_capi/bindings/cpp/temporal_rs/OffsetDisambiguation.hpp new file mode 100644 index 000000000..7988fdcb4 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/OffsetDisambiguation.hpp @@ -0,0 +1,39 @@ +#ifndef temporal_rs_OffsetDisambiguation_HPP +#define temporal_rs_OffsetDisambiguation_HPP + +#include "OffsetDisambiguation.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::OffsetDisambiguation temporal_rs::OffsetDisambiguation::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::OffsetDisambiguation temporal_rs::OffsetDisambiguation::FromFFI(temporal_rs::capi::OffsetDisambiguation c_enum) { + switch (c_enum) { + case temporal_rs::capi::OffsetDisambiguation_Use: + case temporal_rs::capi::OffsetDisambiguation_Prefer: + case temporal_rs::capi::OffsetDisambiguation_Ignore: + case temporal_rs::capi::OffsetDisambiguation_Reject: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_OffsetDisambiguation_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialDate.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialDate.d.hpp new file mode 100644 index 000000000..10c9b3822 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialDate.d.hpp @@ -0,0 +1,50 @@ +#ifndef temporal_rs_PartialDate_D_HPP +#define temporal_rs_PartialDate_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Calendar; } +class Calendar; +} + + +namespace temporal_rs { +namespace capi { + struct PartialDate { + diplomat::capi::OptionI32 year; + diplomat::capi::OptionU8 month; + diplomat::capi::DiplomatStringView month_code; + diplomat::capi::OptionU8 day; + diplomat::capi::DiplomatStringView era; + diplomat::capi::OptionI32 era_year; + const temporal_rs::capi::Calendar* calendar; + }; + + typedef struct PartialDate_option {union { PartialDate ok; }; bool is_ok; } PartialDate_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct PartialDate { + std::optional year; + std::optional month; + std::string_view month_code; + std::optional day; + std::string_view era; + std::optional era_year; + const temporal_rs::Calendar& calendar; + + inline temporal_rs::capi::PartialDate AsFFI() const; + inline static temporal_rs::PartialDate FromFFI(temporal_rs::capi::PartialDate c_struct); +}; + +} // namespace +#endif // temporal_rs_PartialDate_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialDate.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialDate.hpp new file mode 100644 index 000000000..e16bbd32b --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialDate.hpp @@ -0,0 +1,51 @@ +#ifndef temporal_rs_PartialDate_HPP +#define temporal_rs_PartialDate_HPP + +#include "PartialDate.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "Calendar.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::PartialDate temporal_rs::PartialDate::AsFFI() const { + return temporal_rs::capi::PartialDate { + /* .year = */ year.has_value() ? (diplomat::capi::OptionI32{ { year.value() }, true }) : (diplomat::capi::OptionI32{ {}, false }), + /* .month = */ month.has_value() ? (diplomat::capi::OptionU8{ { month.value() }, true }) : (diplomat::capi::OptionU8{ {}, false }), + /* .month_code = */ {month_code.data(), month_code.size()}, + /* .day = */ day.has_value() ? (diplomat::capi::OptionU8{ { day.value() }, true }) : (diplomat::capi::OptionU8{ {}, false }), + /* .era = */ {era.data(), era.size()}, + /* .era_year = */ era_year.has_value() ? (diplomat::capi::OptionI32{ { era_year.value() }, true }) : (diplomat::capi::OptionI32{ {}, false }), + /* .calendar = */ calendar.AsFFI(), + }; +} + +inline temporal_rs::PartialDate temporal_rs::PartialDate::FromFFI(temporal_rs::capi::PartialDate c_struct) { + return temporal_rs::PartialDate { + /* .year = */ c_struct.year.is_ok ? std::optional(c_struct.year.ok) : std::nullopt, + /* .month = */ c_struct.month.is_ok ? std::optional(c_struct.month.ok) : std::nullopt, + /* .month_code = */ std::string_view(c_struct.month_code.data, c_struct.month_code.len), + /* .day = */ c_struct.day.is_ok ? std::optional(c_struct.day.ok) : std::nullopt, + /* .era = */ std::string_view(c_struct.era.data, c_struct.era.len), + /* .era_year = */ c_struct.era_year.is_ok ? std::optional(c_struct.era_year.ok) : std::nullopt, + /* .calendar = */ *temporal_rs::Calendar::FromFFI(c_struct.calendar), + }; +} + + +#endif // temporal_rs_PartialDate_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialDateTime.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialDateTime.d.hpp new file mode 100644 index 000000000..50ae89f95 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialDateTime.d.hpp @@ -0,0 +1,42 @@ +#ifndef temporal_rs_PartialDateTime_D_HPP +#define temporal_rs_PartialDateTime_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "PartialDate.d.hpp" +#include "PartialTime.d.hpp" + +namespace temporal_rs { +struct PartialDate; +struct PartialTime; +} + + +namespace temporal_rs { +namespace capi { + struct PartialDateTime { + temporal_rs::capi::PartialDate date; + temporal_rs::capi::PartialTime time; + }; + + typedef struct PartialDateTime_option {union { PartialDateTime ok; }; bool is_ok; } PartialDateTime_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct PartialDateTime { + temporal_rs::PartialDate date; + temporal_rs::PartialTime time; + + inline temporal_rs::capi::PartialDateTime AsFFI() const; + inline static temporal_rs::PartialDateTime FromFFI(temporal_rs::capi::PartialDateTime c_struct); +}; + +} // namespace +#endif // temporal_rs_PartialDateTime_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialDateTime.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialDateTime.hpp new file mode 100644 index 000000000..41aaa7328 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialDateTime.hpp @@ -0,0 +1,42 @@ +#ifndef temporal_rs_PartialDateTime_HPP +#define temporal_rs_PartialDateTime_HPP + +#include "PartialDateTime.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "PartialDate.hpp" +#include "PartialTime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::PartialDateTime temporal_rs::PartialDateTime::AsFFI() const { + return temporal_rs::capi::PartialDateTime { + /* .date = */ date.AsFFI(), + /* .time = */ time.AsFFI(), + }; +} + +inline temporal_rs::PartialDateTime temporal_rs::PartialDateTime::FromFFI(temporal_rs::capi::PartialDateTime c_struct) { + return temporal_rs::PartialDateTime { + /* .date = */ temporal_rs::PartialDate::FromFFI(c_struct.date), + /* .time = */ temporal_rs::PartialTime::FromFFI(c_struct.time), + }; +} + + +#endif // temporal_rs_PartialDateTime_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialDuration.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialDuration.d.hpp new file mode 100644 index 000000000..daa60f830 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialDuration.d.hpp @@ -0,0 +1,53 @@ +#ifndef temporal_rs_PartialDuration_D_HPP +#define temporal_rs_PartialDuration_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + struct PartialDuration { + diplomat::capi::OptionF64 years; + diplomat::capi::OptionF64 months; + diplomat::capi::OptionF64 weeks; + diplomat::capi::OptionF64 days; + diplomat::capi::OptionF64 hours; + diplomat::capi::OptionF64 minutes; + diplomat::capi::OptionF64 seconds; + diplomat::capi::OptionF64 milliseconds; + diplomat::capi::OptionF64 microseconds; + diplomat::capi::OptionF64 nanoseconds; + }; + + typedef struct PartialDuration_option {union { PartialDuration ok; }; bool is_ok; } PartialDuration_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct PartialDuration { + std::optional years; + std::optional months; + std::optional weeks; + std::optional days; + std::optional hours; + std::optional minutes; + std::optional seconds; + std::optional milliseconds; + std::optional microseconds; + std::optional nanoseconds; + + inline bool is_empty(); + + inline temporal_rs::capi::PartialDuration AsFFI() const; + inline static temporal_rs::PartialDuration FromFFI(temporal_rs::capi::PartialDuration c_struct); +}; + +} // namespace +#endif // temporal_rs_PartialDuration_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialDuration.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialDuration.hpp new file mode 100644 index 000000000..0633144ab --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialDuration.hpp @@ -0,0 +1,63 @@ +#ifndef temporal_rs_PartialDuration_HPP +#define temporal_rs_PartialDuration_HPP + +#include "PartialDuration.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + bool temporal_rs_PartialDuration_is_empty(temporal_rs::capi::PartialDuration self); + + + } // extern "C" +} // namespace capi +} // namespace + +inline bool temporal_rs::PartialDuration::is_empty() { + auto result = temporal_rs::capi::temporal_rs_PartialDuration_is_empty(this->AsFFI()); + return result; +} + + +inline temporal_rs::capi::PartialDuration temporal_rs::PartialDuration::AsFFI() const { + return temporal_rs::capi::PartialDuration { + /* .years = */ years.has_value() ? (diplomat::capi::OptionF64{ { years.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .months = */ months.has_value() ? (diplomat::capi::OptionF64{ { months.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .weeks = */ weeks.has_value() ? (diplomat::capi::OptionF64{ { weeks.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .days = */ days.has_value() ? (diplomat::capi::OptionF64{ { days.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .hours = */ hours.has_value() ? (diplomat::capi::OptionF64{ { hours.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .minutes = */ minutes.has_value() ? (diplomat::capi::OptionF64{ { minutes.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .seconds = */ seconds.has_value() ? (diplomat::capi::OptionF64{ { seconds.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .milliseconds = */ milliseconds.has_value() ? (diplomat::capi::OptionF64{ { milliseconds.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .microseconds = */ microseconds.has_value() ? (diplomat::capi::OptionF64{ { microseconds.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + /* .nanoseconds = */ nanoseconds.has_value() ? (diplomat::capi::OptionF64{ { nanoseconds.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + }; +} + +inline temporal_rs::PartialDuration temporal_rs::PartialDuration::FromFFI(temporal_rs::capi::PartialDuration c_struct) { + return temporal_rs::PartialDuration { + /* .years = */ c_struct.years.is_ok ? std::optional(c_struct.years.ok) : std::nullopt, + /* .months = */ c_struct.months.is_ok ? std::optional(c_struct.months.ok) : std::nullopt, + /* .weeks = */ c_struct.weeks.is_ok ? std::optional(c_struct.weeks.ok) : std::nullopt, + /* .days = */ c_struct.days.is_ok ? std::optional(c_struct.days.ok) : std::nullopt, + /* .hours = */ c_struct.hours.is_ok ? std::optional(c_struct.hours.ok) : std::nullopt, + /* .minutes = */ c_struct.minutes.is_ok ? std::optional(c_struct.minutes.ok) : std::nullopt, + /* .seconds = */ c_struct.seconds.is_ok ? std::optional(c_struct.seconds.ok) : std::nullopt, + /* .milliseconds = */ c_struct.milliseconds.is_ok ? std::optional(c_struct.milliseconds.ok) : std::nullopt, + /* .microseconds = */ c_struct.microseconds.is_ok ? std::optional(c_struct.microseconds.ok) : std::nullopt, + /* .nanoseconds = */ c_struct.nanoseconds.is_ok ? std::optional(c_struct.nanoseconds.ok) : std::nullopt, + }; +} + + +#endif // temporal_rs_PartialDuration_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialTime.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialTime.d.hpp new file mode 100644 index 000000000..5a0e9ec67 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialTime.d.hpp @@ -0,0 +1,43 @@ +#ifndef temporal_rs_PartialTime_D_HPP +#define temporal_rs_PartialTime_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + struct PartialTime { + diplomat::capi::OptionU8 hour; + diplomat::capi::OptionU8 minute; + diplomat::capi::OptionU8 second; + diplomat::capi::OptionU16 millisecond; + diplomat::capi::OptionU16 microsecond; + diplomat::capi::OptionU16 nanosecond; + }; + + typedef struct PartialTime_option {union { PartialTime ok; }; bool is_ok; } PartialTime_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct PartialTime { + std::optional hour; + std::optional minute; + std::optional second; + std::optional millisecond; + std::optional microsecond; + std::optional nanosecond; + + inline temporal_rs::capi::PartialTime AsFFI() const; + inline static temporal_rs::PartialTime FromFFI(temporal_rs::capi::PartialTime c_struct); +}; + +} // namespace +#endif // temporal_rs_PartialTime_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PartialTime.hpp b/temporal_capi/bindings/cpp/temporal_rs/PartialTime.hpp new file mode 100644 index 000000000..9cc3b0b1c --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PartialTime.hpp @@ -0,0 +1,48 @@ +#ifndef temporal_rs_PartialTime_HPP +#define temporal_rs_PartialTime_HPP + +#include "PartialTime.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::PartialTime temporal_rs::PartialTime::AsFFI() const { + return temporal_rs::capi::PartialTime { + /* .hour = */ hour.has_value() ? (diplomat::capi::OptionU8{ { hour.value() }, true }) : (diplomat::capi::OptionU8{ {}, false }), + /* .minute = */ minute.has_value() ? (diplomat::capi::OptionU8{ { minute.value() }, true }) : (diplomat::capi::OptionU8{ {}, false }), + /* .second = */ second.has_value() ? (diplomat::capi::OptionU8{ { second.value() }, true }) : (diplomat::capi::OptionU8{ {}, false }), + /* .millisecond = */ millisecond.has_value() ? (diplomat::capi::OptionU16{ { millisecond.value() }, true }) : (diplomat::capi::OptionU16{ {}, false }), + /* .microsecond = */ microsecond.has_value() ? (diplomat::capi::OptionU16{ { microsecond.value() }, true }) : (diplomat::capi::OptionU16{ {}, false }), + /* .nanosecond = */ nanosecond.has_value() ? (diplomat::capi::OptionU16{ { nanosecond.value() }, true }) : (diplomat::capi::OptionU16{ {}, false }), + }; +} + +inline temporal_rs::PartialTime temporal_rs::PartialTime::FromFFI(temporal_rs::capi::PartialTime c_struct) { + return temporal_rs::PartialTime { + /* .hour = */ c_struct.hour.is_ok ? std::optional(c_struct.hour.ok) : std::nullopt, + /* .minute = */ c_struct.minute.is_ok ? std::optional(c_struct.minute.ok) : std::nullopt, + /* .second = */ c_struct.second.is_ok ? std::optional(c_struct.second.ok) : std::nullopt, + /* .millisecond = */ c_struct.millisecond.is_ok ? std::optional(c_struct.millisecond.ok) : std::nullopt, + /* .microsecond = */ c_struct.microsecond.is_ok ? std::optional(c_struct.microsecond.ok) : std::nullopt, + /* .nanosecond = */ c_struct.nanosecond.is_ok ? std::optional(c_struct.nanosecond.ok) : std::nullopt, + }; +} + + +#endif // temporal_rs_PartialTime_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainDate.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainDate.d.hpp new file mode 100644 index 000000000..f9f546621 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainDate.d.hpp @@ -0,0 +1,130 @@ +#ifndef temporal_rs_PlainDate_D_HPP +#define temporal_rs_PlainDate_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Calendar; } +class Calendar; +namespace capi { struct Duration; } +class Duration; +namespace capi { struct PlainDate; } +class PlainDate; +namespace capi { struct PlainDateTime; } +class PlainDateTime; +namespace capi { struct PlainMonthDay; } +class PlainMonthDay; +namespace capi { struct PlainTime; } +class PlainTime; +namespace capi { struct PlainYearMonth; } +class PlainYearMonth; +struct DifferenceSettings; +struct PartialDate; +struct TemporalError; +class ArithmeticOverflow; +class DisplayCalendar; +} + + +namespace temporal_rs { +namespace capi { + struct PlainDate; +} // namespace capi +} // namespace + +namespace temporal_rs { +class PlainDate { +public: + + inline static diplomat::result, temporal_rs::TemporalError> create(int32_t year, uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar); + + inline static diplomat::result, temporal_rs::TemporalError> try_create(int32_t year, uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar); + + inline static diplomat::result, temporal_rs::TemporalError> create_with_overflow(int32_t year, uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar, temporal_rs::ArithmeticOverflow overflow); + + inline static diplomat::result, temporal_rs::TemporalError> from_partial(temporal_rs::PartialDate partial, std::optional overflow); + + inline diplomat::result, temporal_rs::TemporalError> with(temporal_rs::PartialDate partial, std::optional overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> with_calendar(const temporal_rs::Calendar& calendar) const; + + inline int32_t iso_year() const; + + inline uint8_t iso_month() const; + + inline uint8_t iso_day() const; + + inline const temporal_rs::Calendar& calendar() const; + + inline bool is_valid() const; + + inline int32_t days_until(const temporal_rs::PlainDate& other) const; + + inline diplomat::result, temporal_rs::TemporalError> add(const temporal_rs::Duration& duration, std::optional overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract(const temporal_rs::Duration& duration, std::optional overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> until(const temporal_rs::PlainDate& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> since(const temporal_rs::PlainDate& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result year() const; + + inline diplomat::result month() const; + + inline diplomat::result month_code() const; + + inline diplomat::result day() const; + + inline diplomat::result day_of_week() const; + + inline diplomat::result day_of_year() const; + + inline diplomat::result, temporal_rs::TemporalError> week_of_year() const; + + inline diplomat::result, temporal_rs::TemporalError> year_of_week() const; + + inline diplomat::result days_in_week() const; + + inline diplomat::result days_in_month() const; + + inline diplomat::result days_in_year() const; + + inline diplomat::result months_in_year() const; + + inline diplomat::result in_leap_year() const; + + inline diplomat::result era() const; + + inline diplomat::result, temporal_rs::TemporalError> era_year() const; + + inline diplomat::result, temporal_rs::TemporalError> to_date_time(const temporal_rs::PlainTime* time) const; + + inline diplomat::result, temporal_rs::TemporalError> to_month_day() const; + + inline diplomat::result, temporal_rs::TemporalError> to_year_month() const; + + inline std::string to_ixdtf_string(temporal_rs::DisplayCalendar display_calendar) const; + + inline const temporal_rs::capi::PlainDate* AsFFI() const; + inline temporal_rs::capi::PlainDate* AsFFI(); + inline static const temporal_rs::PlainDate* FromFFI(const temporal_rs::capi::PlainDate* ptr); + inline static temporal_rs::PlainDate* FromFFI(temporal_rs::capi::PlainDate* ptr); + inline static void operator delete(void* ptr); +private: + PlainDate() = delete; + PlainDate(const temporal_rs::PlainDate&) = delete; + PlainDate(temporal_rs::PlainDate&&) noexcept = delete; + PlainDate operator=(const temporal_rs::PlainDate&) = delete; + PlainDate operator=(temporal_rs::PlainDate&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_PlainDate_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainDate.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainDate.hpp new file mode 100644 index 000000000..e83028752 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainDate.hpp @@ -0,0 +1,365 @@ +#ifndef temporal_rs_PlainDate_HPP +#define temporal_rs_PlainDate_HPP + +#include "PlainDate.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "ArithmeticOverflow.hpp" +#include "Calendar.hpp" +#include "DifferenceSettings.hpp" +#include "DisplayCalendar.hpp" +#include "Duration.hpp" +#include "PartialDate.hpp" +#include "PlainDateTime.hpp" +#include "PlainMonthDay.hpp" +#include "PlainTime.hpp" +#include "PlainYearMonth.hpp" +#include "TemporalError.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_PlainDate_create_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_create_result; + temporal_rs_PlainDate_create_result temporal_rs_PlainDate_create(int32_t year, uint8_t month, uint8_t day, const temporal_rs::capi::Calendar* calendar); + + typedef struct temporal_rs_PlainDate_try_create_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_try_create_result; + temporal_rs_PlainDate_try_create_result temporal_rs_PlainDate_try_create(int32_t year, uint8_t month, uint8_t day, const temporal_rs::capi::Calendar* calendar); + + typedef struct temporal_rs_PlainDate_create_with_overflow_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_create_with_overflow_result; + temporal_rs_PlainDate_create_with_overflow_result temporal_rs_PlainDate_create_with_overflow(int32_t year, uint8_t month, uint8_t day, const temporal_rs::capi::Calendar* calendar, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_PlainDate_from_partial_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_from_partial_result; + temporal_rs_PlainDate_from_partial_result temporal_rs_PlainDate_from_partial(temporal_rs::capi::PartialDate partial, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDate_with_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_with_result; + temporal_rs_PlainDate_with_result temporal_rs_PlainDate_with(const temporal_rs::capi::PlainDate* self, temporal_rs::capi::PartialDate partial, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDate_with_calendar_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_with_calendar_result; + temporal_rs_PlainDate_with_calendar_result temporal_rs_PlainDate_with_calendar(const temporal_rs::capi::PlainDate* self, const temporal_rs::capi::Calendar* calendar); + + int32_t temporal_rs_PlainDate_iso_year(const temporal_rs::capi::PlainDate* self); + + uint8_t temporal_rs_PlainDate_iso_month(const temporal_rs::capi::PlainDate* self); + + uint8_t temporal_rs_PlainDate_iso_day(const temporal_rs::capi::PlainDate* self); + + const temporal_rs::capi::Calendar* temporal_rs_PlainDate_calendar(const temporal_rs::capi::PlainDate* self); + + bool temporal_rs_PlainDate_is_valid(const temporal_rs::capi::PlainDate* self); + + int32_t temporal_rs_PlainDate_days_until(const temporal_rs::capi::PlainDate* self, const temporal_rs::capi::PlainDate* other); + + typedef struct temporal_rs_PlainDate_add_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_add_result; + temporal_rs_PlainDate_add_result temporal_rs_PlainDate_add(const temporal_rs::capi::PlainDate* self, const temporal_rs::capi::Duration* duration, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDate_subtract_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_subtract_result; + temporal_rs_PlainDate_subtract_result temporal_rs_PlainDate_subtract(const temporal_rs::capi::PlainDate* self, const temporal_rs::capi::Duration* duration, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDate_until_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_until_result; + temporal_rs_PlainDate_until_result temporal_rs_PlainDate_until(const temporal_rs::capi::PlainDate* self, const temporal_rs::capi::PlainDate* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainDate_since_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_since_result; + temporal_rs_PlainDate_since_result temporal_rs_PlainDate_since(const temporal_rs::capi::PlainDate* self, const temporal_rs::capi::PlainDate* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainDate_year_result {union {int32_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_year_result; + temporal_rs_PlainDate_year_result temporal_rs_PlainDate_year(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_month_result {union {uint8_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_month_result; + temporal_rs_PlainDate_month_result temporal_rs_PlainDate_month(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_month_code_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_month_code_result; + temporal_rs_PlainDate_month_code_result temporal_rs_PlainDate_month_code(const temporal_rs::capi::PlainDate* self, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_PlainDate_day_result {union {uint8_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_day_result; + temporal_rs_PlainDate_day_result temporal_rs_PlainDate_day(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_day_of_week_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_day_of_week_result; + temporal_rs_PlainDate_day_of_week_result temporal_rs_PlainDate_day_of_week(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_day_of_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_day_of_year_result; + temporal_rs_PlainDate_day_of_year_result temporal_rs_PlainDate_day_of_year(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_week_of_year_result {union {diplomat::capi::OptionU16 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_week_of_year_result; + temporal_rs_PlainDate_week_of_year_result temporal_rs_PlainDate_week_of_year(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_year_of_week_result {union {diplomat::capi::OptionI32 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_year_of_week_result; + temporal_rs_PlainDate_year_of_week_result temporal_rs_PlainDate_year_of_week(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_days_in_week_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_days_in_week_result; + temporal_rs_PlainDate_days_in_week_result temporal_rs_PlainDate_days_in_week(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_days_in_month_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_days_in_month_result; + temporal_rs_PlainDate_days_in_month_result temporal_rs_PlainDate_days_in_month(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_days_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_days_in_year_result; + temporal_rs_PlainDate_days_in_year_result temporal_rs_PlainDate_days_in_year(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_months_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_months_in_year_result; + temporal_rs_PlainDate_months_in_year_result temporal_rs_PlainDate_months_in_year(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_in_leap_year_result {union {bool ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_in_leap_year_result; + temporal_rs_PlainDate_in_leap_year_result temporal_rs_PlainDate_in_leap_year(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_era_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_era_result; + temporal_rs_PlainDate_era_result temporal_rs_PlainDate_era(const temporal_rs::capi::PlainDate* self, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_PlainDate_era_year_result {union {diplomat::capi::OptionI32 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_era_year_result; + temporal_rs_PlainDate_era_year_result temporal_rs_PlainDate_era_year(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_to_date_time_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_to_date_time_result; + temporal_rs_PlainDate_to_date_time_result temporal_rs_PlainDate_to_date_time(const temporal_rs::capi::PlainDate* self, const temporal_rs::capi::PlainTime* time); + + typedef struct temporal_rs_PlainDate_to_month_day_result {union {temporal_rs::capi::PlainMonthDay* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_to_month_day_result; + temporal_rs_PlainDate_to_month_day_result temporal_rs_PlainDate_to_month_day(const temporal_rs::capi::PlainDate* self); + + typedef struct temporal_rs_PlainDate_to_year_month_result {union {temporal_rs::capi::PlainYearMonth* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDate_to_year_month_result; + temporal_rs_PlainDate_to_year_month_result temporal_rs_PlainDate_to_year_month(const temporal_rs::capi::PlainDate* self); + + void temporal_rs_PlainDate_to_ixdtf_string(const temporal_rs::capi::PlainDate* self, temporal_rs::capi::DisplayCalendar display_calendar, diplomat::capi::DiplomatWrite* write); + + + void temporal_rs_PlainDate_destroy(PlainDate* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::create(int32_t year, uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar) { + auto result = temporal_rs::capi::temporal_rs_PlainDate_create(year, + month, + day, + calendar.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::try_create(int32_t year, uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar) { + auto result = temporal_rs::capi::temporal_rs_PlainDate_try_create(year, + month, + day, + calendar.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::create_with_overflow(int32_t year, uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar, temporal_rs::ArithmeticOverflow overflow) { + auto result = temporal_rs::capi::temporal_rs_PlainDate_create_with_overflow(year, + month, + day, + calendar.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::from_partial(temporal_rs::PartialDate partial, std::optional overflow) { + auto result = temporal_rs::capi::temporal_rs_PlainDate_from_partial(partial.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::with(temporal_rs::PartialDate partial, std::optional overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_with(this->AsFFI(), + partial.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::with_calendar(const temporal_rs::Calendar& calendar) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_with_calendar(this->AsFFI(), + calendar.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline int32_t temporal_rs::PlainDate::iso_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_iso_year(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainDate::iso_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_iso_month(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainDate::iso_day() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_iso_day(this->AsFFI()); + return result; +} + +inline const temporal_rs::Calendar& temporal_rs::PlainDate::calendar() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_calendar(this->AsFFI()); + return *temporal_rs::Calendar::FromFFI(result); +} + +inline bool temporal_rs::PlainDate::is_valid() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_is_valid(this->AsFFI()); + return result; +} + +inline int32_t temporal_rs::PlainDate::days_until(const temporal_rs::PlainDate& other) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_days_until(this->AsFFI(), + other.AsFFI()); + return result; +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::add(const temporal_rs::Duration& duration, std::optional overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_add(this->AsFFI(), + duration.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::subtract(const temporal_rs::Duration& duration, std::optional overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_subtract(this->AsFFI(), + duration.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::until(const temporal_rs::PlainDate& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_until(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::since(const temporal_rs::PlainDate& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_since(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::month() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_month(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::month_code() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainDate_month_code(this->AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::day() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_day(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::day_of_week() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_day_of_week(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::day_of_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_day_of_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::week_of_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_week_of_year(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::year_of_week() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_year_of_week(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::days_in_week() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_days_in_week(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::days_in_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_days_in_month(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::days_in_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_days_in_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::months_in_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_months_in_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::in_leap_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_in_leap_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDate::era() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainDate_era(this->AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::era_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_era_year(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::to_date_time(const temporal_rs::PlainTime* time) const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_to_date_time(this->AsFFI(), + time ? time->AsFFI() : nullptr); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::to_month_day() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_to_month_day(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainMonthDay::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDate::to_year_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainDate_to_year_month(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainYearMonth::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline std::string temporal_rs::PlainDate::to_ixdtf_string(temporal_rs::DisplayCalendar display_calendar) const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + temporal_rs::capi::temporal_rs_PlainDate_to_ixdtf_string(this->AsFFI(), + display_calendar.AsFFI(), + &write); + return output; +} + +inline const temporal_rs::capi::PlainDate* temporal_rs::PlainDate::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::PlainDate* temporal_rs::PlainDate::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::PlainDate* temporal_rs::PlainDate::FromFFI(const temporal_rs::capi::PlainDate* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::PlainDate* temporal_rs::PlainDate::FromFFI(temporal_rs::capi::PlainDate* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::PlainDate::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_PlainDate_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_PlainDate_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainDateTime.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainDateTime.d.hpp new file mode 100644 index 000000000..6c8fb18a5 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainDateTime.d.hpp @@ -0,0 +1,132 @@ +#ifndef temporal_rs_PlainDateTime_D_HPP +#define temporal_rs_PlainDateTime_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Calendar; } +class Calendar; +namespace capi { struct Duration; } +class Duration; +namespace capi { struct PlainDateTime; } +class PlainDateTime; +namespace capi { struct PlainTime; } +class PlainTime; +struct DifferenceSettings; +struct PartialDateTime; +struct RoundingOptions; +struct TemporalError; +struct ToStringRoundingOptions; +class ArithmeticOverflow; +class DisplayCalendar; +} + + +namespace temporal_rs { +namespace capi { + struct PlainDateTime; +} // namespace capi +} // namespace + +namespace temporal_rs { +class PlainDateTime { +public: + + inline static diplomat::result, temporal_rs::TemporalError> create(int32_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond, const temporal_rs::Calendar& calendar); + + inline static diplomat::result, temporal_rs::TemporalError> try_create(int32_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond, const temporal_rs::Calendar& calendar); + + inline static diplomat::result, temporal_rs::TemporalError> from_partial(temporal_rs::PartialDateTime partial, std::optional overflow); + + inline diplomat::result, temporal_rs::TemporalError> with(temporal_rs::PartialDateTime partial, std::optional overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> with_time(const temporal_rs::PlainTime& time) const; + + inline diplomat::result, temporal_rs::TemporalError> with_calendar(const temporal_rs::Calendar& calendar) const; + + inline int32_t iso_year() const; + + inline uint8_t iso_month() const; + + inline uint8_t iso_day() const; + + inline uint8_t hour() const; + + inline uint8_t minute() const; + + inline uint8_t second() const; + + inline uint16_t millisecond() const; + + inline uint16_t microsecond() const; + + inline uint16_t nanosecond() const; + + inline const temporal_rs::Calendar& calendar() const; + + inline diplomat::result year() const; + + inline diplomat::result month() const; + + inline diplomat::result month_code() const; + + inline diplomat::result day() const; + + inline diplomat::result day_of_week() const; + + inline diplomat::result day_of_year() const; + + inline diplomat::result, temporal_rs::TemporalError> week_of_year() const; + + inline diplomat::result, temporal_rs::TemporalError> year_of_week() const; + + inline diplomat::result days_in_week() const; + + inline diplomat::result days_in_month() const; + + inline diplomat::result days_in_year() const; + + inline diplomat::result months_in_year() const; + + inline diplomat::result in_leap_year() const; + + inline diplomat::result era() const; + + inline diplomat::result, temporal_rs::TemporalError> era_year() const; + + inline diplomat::result, temporal_rs::TemporalError> add(const temporal_rs::Duration& duration, std::optional overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract(const temporal_rs::Duration& duration, std::optional overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> until(const temporal_rs::PlainDateTime& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> since(const temporal_rs::PlainDateTime& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> round(temporal_rs::RoundingOptions options) const; + + inline diplomat::result, temporal_rs::TemporalError> to_plain_time() const; + + inline diplomat::result to_ixdtf_string(temporal_rs::ToStringRoundingOptions options, temporal_rs::DisplayCalendar display_calendar) const; + + inline const temporal_rs::capi::PlainDateTime* AsFFI() const; + inline temporal_rs::capi::PlainDateTime* AsFFI(); + inline static const temporal_rs::PlainDateTime* FromFFI(const temporal_rs::capi::PlainDateTime* ptr); + inline static temporal_rs::PlainDateTime* FromFFI(temporal_rs::capi::PlainDateTime* ptr); + inline static void operator delete(void* ptr); +private: + PlainDateTime() = delete; + PlainDateTime(const temporal_rs::PlainDateTime&) = delete; + PlainDateTime(temporal_rs::PlainDateTime&&) noexcept = delete; + PlainDateTime operator=(const temporal_rs::PlainDateTime&) = delete; + PlainDateTime operator=(temporal_rs::PlainDateTime&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_PlainDateTime_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainDateTime.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainDateTime.hpp new file mode 100644 index 000000000..b830d51de --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainDateTime.hpp @@ -0,0 +1,394 @@ +#ifndef temporal_rs_PlainDateTime_HPP +#define temporal_rs_PlainDateTime_HPP + +#include "PlainDateTime.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "ArithmeticOverflow.hpp" +#include "Calendar.hpp" +#include "DifferenceSettings.hpp" +#include "DisplayCalendar.hpp" +#include "Duration.hpp" +#include "PartialDateTime.hpp" +#include "PlainTime.hpp" +#include "RoundingOptions.hpp" +#include "TemporalError.hpp" +#include "ToStringRoundingOptions.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_PlainDateTime_create_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_create_result; + temporal_rs_PlainDateTime_create_result temporal_rs_PlainDateTime_create(int32_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond, const temporal_rs::capi::Calendar* calendar); + + typedef struct temporal_rs_PlainDateTime_try_create_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_try_create_result; + temporal_rs_PlainDateTime_try_create_result temporal_rs_PlainDateTime_try_create(int32_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond, const temporal_rs::capi::Calendar* calendar); + + typedef struct temporal_rs_PlainDateTime_from_partial_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_from_partial_result; + temporal_rs_PlainDateTime_from_partial_result temporal_rs_PlainDateTime_from_partial(temporal_rs::capi::PartialDateTime partial, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDateTime_with_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_with_result; + temporal_rs_PlainDateTime_with_result temporal_rs_PlainDateTime_with(const temporal_rs::capi::PlainDateTime* self, temporal_rs::capi::PartialDateTime partial, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDateTime_with_time_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_with_time_result; + temporal_rs_PlainDateTime_with_time_result temporal_rs_PlainDateTime_with_time(const temporal_rs::capi::PlainDateTime* self, const temporal_rs::capi::PlainTime* time); + + typedef struct temporal_rs_PlainDateTime_with_calendar_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_with_calendar_result; + temporal_rs_PlainDateTime_with_calendar_result temporal_rs_PlainDateTime_with_calendar(const temporal_rs::capi::PlainDateTime* self, const temporal_rs::capi::Calendar* calendar); + + int32_t temporal_rs_PlainDateTime_iso_year(const temporal_rs::capi::PlainDateTime* self); + + uint8_t temporal_rs_PlainDateTime_iso_month(const temporal_rs::capi::PlainDateTime* self); + + uint8_t temporal_rs_PlainDateTime_iso_day(const temporal_rs::capi::PlainDateTime* self); + + uint8_t temporal_rs_PlainDateTime_hour(const temporal_rs::capi::PlainDateTime* self); + + uint8_t temporal_rs_PlainDateTime_minute(const temporal_rs::capi::PlainDateTime* self); + + uint8_t temporal_rs_PlainDateTime_second(const temporal_rs::capi::PlainDateTime* self); + + uint16_t temporal_rs_PlainDateTime_millisecond(const temporal_rs::capi::PlainDateTime* self); + + uint16_t temporal_rs_PlainDateTime_microsecond(const temporal_rs::capi::PlainDateTime* self); + + uint16_t temporal_rs_PlainDateTime_nanosecond(const temporal_rs::capi::PlainDateTime* self); + + const temporal_rs::capi::Calendar* temporal_rs_PlainDateTime_calendar(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_year_result {union {int32_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_year_result; + temporal_rs_PlainDateTime_year_result temporal_rs_PlainDateTime_year(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_month_result {union {uint8_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_month_result; + temporal_rs_PlainDateTime_month_result temporal_rs_PlainDateTime_month(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_month_code_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_month_code_result; + temporal_rs_PlainDateTime_month_code_result temporal_rs_PlainDateTime_month_code(const temporal_rs::capi::PlainDateTime* self, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_PlainDateTime_day_result {union {uint8_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_day_result; + temporal_rs_PlainDateTime_day_result temporal_rs_PlainDateTime_day(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_day_of_week_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_day_of_week_result; + temporal_rs_PlainDateTime_day_of_week_result temporal_rs_PlainDateTime_day_of_week(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_day_of_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_day_of_year_result; + temporal_rs_PlainDateTime_day_of_year_result temporal_rs_PlainDateTime_day_of_year(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_week_of_year_result {union {diplomat::capi::OptionU16 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_week_of_year_result; + temporal_rs_PlainDateTime_week_of_year_result temporal_rs_PlainDateTime_week_of_year(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_year_of_week_result {union {diplomat::capi::OptionI32 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_year_of_week_result; + temporal_rs_PlainDateTime_year_of_week_result temporal_rs_PlainDateTime_year_of_week(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_days_in_week_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_days_in_week_result; + temporal_rs_PlainDateTime_days_in_week_result temporal_rs_PlainDateTime_days_in_week(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_days_in_month_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_days_in_month_result; + temporal_rs_PlainDateTime_days_in_month_result temporal_rs_PlainDateTime_days_in_month(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_days_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_days_in_year_result; + temporal_rs_PlainDateTime_days_in_year_result temporal_rs_PlainDateTime_days_in_year(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_months_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_months_in_year_result; + temporal_rs_PlainDateTime_months_in_year_result temporal_rs_PlainDateTime_months_in_year(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_in_leap_year_result {union {bool ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_in_leap_year_result; + temporal_rs_PlainDateTime_in_leap_year_result temporal_rs_PlainDateTime_in_leap_year(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_era_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_era_result; + temporal_rs_PlainDateTime_era_result temporal_rs_PlainDateTime_era(const temporal_rs::capi::PlainDateTime* self, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_PlainDateTime_era_year_result {union {diplomat::capi::OptionI32 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_era_year_result; + temporal_rs_PlainDateTime_era_year_result temporal_rs_PlainDateTime_era_year(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_add_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_add_result; + temporal_rs_PlainDateTime_add_result temporal_rs_PlainDateTime_add(const temporal_rs::capi::PlainDateTime* self, const temporal_rs::capi::Duration* duration, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDateTime_subtract_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_subtract_result; + temporal_rs_PlainDateTime_subtract_result temporal_rs_PlainDateTime_subtract(const temporal_rs::capi::PlainDateTime* self, const temporal_rs::capi::Duration* duration, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainDateTime_until_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_until_result; + temporal_rs_PlainDateTime_until_result temporal_rs_PlainDateTime_until(const temporal_rs::capi::PlainDateTime* self, const temporal_rs::capi::PlainDateTime* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainDateTime_since_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_since_result; + temporal_rs_PlainDateTime_since_result temporal_rs_PlainDateTime_since(const temporal_rs::capi::PlainDateTime* self, const temporal_rs::capi::PlainDateTime* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainDateTime_round_result {union {temporal_rs::capi::PlainDateTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_round_result; + temporal_rs_PlainDateTime_round_result temporal_rs_PlainDateTime_round(const temporal_rs::capi::PlainDateTime* self, temporal_rs::capi::RoundingOptions options); + + typedef struct temporal_rs_PlainDateTime_to_plain_time_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_to_plain_time_result; + temporal_rs_PlainDateTime_to_plain_time_result temporal_rs_PlainDateTime_to_plain_time(const temporal_rs::capi::PlainDateTime* self); + + typedef struct temporal_rs_PlainDateTime_to_ixdtf_string_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainDateTime_to_ixdtf_string_result; + temporal_rs_PlainDateTime_to_ixdtf_string_result temporal_rs_PlainDateTime_to_ixdtf_string(const temporal_rs::capi::PlainDateTime* self, temporal_rs::capi::ToStringRoundingOptions options, temporal_rs::capi::DisplayCalendar display_calendar, diplomat::capi::DiplomatWrite* write); + + + void temporal_rs_PlainDateTime_destroy(PlainDateTime* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::create(int32_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond, const temporal_rs::Calendar& calendar) { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_create(year, + month, + day, + hour, + minute, + second, + millisecond, + microsecond, + nanosecond, + calendar.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::try_create(int32_t year, uint8_t month, uint8_t day, uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond, const temporal_rs::Calendar& calendar) { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_try_create(year, + month, + day, + hour, + minute, + second, + millisecond, + microsecond, + nanosecond, + calendar.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::from_partial(temporal_rs::PartialDateTime partial, std::optional overflow) { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_from_partial(partial.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::with(temporal_rs::PartialDateTime partial, std::optional overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_with(this->AsFFI(), + partial.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::with_time(const temporal_rs::PlainTime& time) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_with_time(this->AsFFI(), + time.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::with_calendar(const temporal_rs::Calendar& calendar) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_with_calendar(this->AsFFI(), + calendar.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline int32_t temporal_rs::PlainDateTime::iso_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_iso_year(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainDateTime::iso_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_iso_month(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainDateTime::iso_day() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_iso_day(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainDateTime::hour() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_hour(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainDateTime::minute() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_minute(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainDateTime::second() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_second(this->AsFFI()); + return result; +} + +inline uint16_t temporal_rs::PlainDateTime::millisecond() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_millisecond(this->AsFFI()); + return result; +} + +inline uint16_t temporal_rs::PlainDateTime::microsecond() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_microsecond(this->AsFFI()); + return result; +} + +inline uint16_t temporal_rs::PlainDateTime::nanosecond() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_nanosecond(this->AsFFI()); + return result; +} + +inline const temporal_rs::Calendar& temporal_rs::PlainDateTime::calendar() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_calendar(this->AsFFI()); + return *temporal_rs::Calendar::FromFFI(result); +} + +inline diplomat::result temporal_rs::PlainDateTime::year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::month() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_month(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::month_code() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_month_code(this->AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::day() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_day(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::day_of_week() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_day_of_week(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::day_of_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_day_of_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::week_of_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_week_of_year(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::year_of_week() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_year_of_week(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::days_in_week() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_days_in_week(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::days_in_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_days_in_month(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::days_in_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_days_in_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::months_in_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_months_in_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::in_leap_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_in_leap_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::era() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_era(this->AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::era_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_era_year(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::add(const temporal_rs::Duration& duration, std::optional overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_add(this->AsFFI(), + duration.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::subtract(const temporal_rs::Duration& duration, std::optional overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_subtract(this->AsFFI(), + duration.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::until(const temporal_rs::PlainDateTime& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_until(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::since(const temporal_rs::PlainDateTime& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_since(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::round(temporal_rs::RoundingOptions options) const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_round(this->AsFFI(), + options.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDateTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainDateTime::to_plain_time() const { + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_to_plain_time(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainDateTime::to_ixdtf_string(temporal_rs::ToStringRoundingOptions options, temporal_rs::DisplayCalendar display_calendar) const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainDateTime_to_ixdtf_string(this->AsFFI(), + options.AsFFI(), + display_calendar.AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline const temporal_rs::capi::PlainDateTime* temporal_rs::PlainDateTime::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::PlainDateTime* temporal_rs::PlainDateTime::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::PlainDateTime* temporal_rs::PlainDateTime::FromFFI(const temporal_rs::capi::PlainDateTime* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::PlainDateTime* temporal_rs::PlainDateTime::FromFFI(temporal_rs::capi::PlainDateTime* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::PlainDateTime::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_PlainDateTime_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_PlainDateTime_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainMonthDay.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainMonthDay.d.hpp new file mode 100644 index 000000000..58e8d73a6 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainMonthDay.d.hpp @@ -0,0 +1,66 @@ +#ifndef temporal_rs_PlainMonthDay_D_HPP +#define temporal_rs_PlainMonthDay_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Calendar; } +class Calendar; +namespace capi { struct PlainDate; } +class PlainDate; +namespace capi { struct PlainMonthDay; } +class PlainMonthDay; +struct PartialDate; +struct TemporalError; +class ArithmeticOverflow; +} + + +namespace temporal_rs { +namespace capi { + struct PlainMonthDay; +} // namespace capi +} // namespace + +namespace temporal_rs { +class PlainMonthDay { +public: + + inline static diplomat::result, temporal_rs::TemporalError> create_with_overflow(uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar, temporal_rs::ArithmeticOverflow overflow, std::optional ref_year); + + inline diplomat::result, temporal_rs::TemporalError> with(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const; + + inline int32_t iso_year() const; + + inline uint8_t iso_month() const; + + inline uint8_t iso_day() const; + + inline const temporal_rs::Calendar& calendar() const; + + inline diplomat::result month_code() const; + + inline diplomat::result, temporal_rs::TemporalError> to_plain_date() const; + + inline const temporal_rs::capi::PlainMonthDay* AsFFI() const; + inline temporal_rs::capi::PlainMonthDay* AsFFI(); + inline static const temporal_rs::PlainMonthDay* FromFFI(const temporal_rs::capi::PlainMonthDay* ptr); + inline static temporal_rs::PlainMonthDay* FromFFI(temporal_rs::capi::PlainMonthDay* ptr); + inline static void operator delete(void* ptr); +private: + PlainMonthDay() = delete; + PlainMonthDay(const temporal_rs::PlainMonthDay&) = delete; + PlainMonthDay(temporal_rs::PlainMonthDay&&) noexcept = delete; + PlainMonthDay operator=(const temporal_rs::PlainMonthDay&) = delete; + PlainMonthDay operator=(temporal_rs::PlainMonthDay&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_PlainMonthDay_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainMonthDay.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainMonthDay.hpp new file mode 100644 index 000000000..aacb72db1 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainMonthDay.hpp @@ -0,0 +1,121 @@ +#ifndef temporal_rs_PlainMonthDay_HPP +#define temporal_rs_PlainMonthDay_HPP + +#include "PlainMonthDay.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "ArithmeticOverflow.hpp" +#include "Calendar.hpp" +#include "PartialDate.hpp" +#include "PlainDate.hpp" +#include "TemporalError.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_PlainMonthDay_create_with_overflow_result {union {temporal_rs::capi::PlainMonthDay* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainMonthDay_create_with_overflow_result; + temporal_rs_PlainMonthDay_create_with_overflow_result temporal_rs_PlainMonthDay_create_with_overflow(uint8_t month, uint8_t day, const temporal_rs::capi::Calendar* calendar, temporal_rs::capi::ArithmeticOverflow overflow, diplomat::capi::OptionI32 ref_year); + + typedef struct temporal_rs_PlainMonthDay_with_result {union {temporal_rs::capi::PlainMonthDay* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainMonthDay_with_result; + temporal_rs_PlainMonthDay_with_result temporal_rs_PlainMonthDay_with(const temporal_rs::capi::PlainMonthDay* self, temporal_rs::capi::PartialDate partial, temporal_rs::capi::ArithmeticOverflow overflow); + + int32_t temporal_rs_PlainMonthDay_iso_year(const temporal_rs::capi::PlainMonthDay* self); + + uint8_t temporal_rs_PlainMonthDay_iso_month(const temporal_rs::capi::PlainMonthDay* self); + + uint8_t temporal_rs_PlainMonthDay_iso_day(const temporal_rs::capi::PlainMonthDay* self); + + const temporal_rs::capi::Calendar* temporal_rs_PlainMonthDay_calendar(const temporal_rs::capi::PlainMonthDay* self); + + typedef struct temporal_rs_PlainMonthDay_month_code_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainMonthDay_month_code_result; + temporal_rs_PlainMonthDay_month_code_result temporal_rs_PlainMonthDay_month_code(const temporal_rs::capi::PlainMonthDay* self, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_PlainMonthDay_to_plain_date_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainMonthDay_to_plain_date_result; + temporal_rs_PlainMonthDay_to_plain_date_result temporal_rs_PlainMonthDay_to_plain_date(const temporal_rs::capi::PlainMonthDay* self); + + + void temporal_rs_PlainMonthDay_destroy(PlainMonthDay* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainMonthDay::create_with_overflow(uint8_t month, uint8_t day, const temporal_rs::Calendar& calendar, temporal_rs::ArithmeticOverflow overflow, std::optional ref_year) { + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_create_with_overflow(month, + day, + calendar.AsFFI(), + overflow.AsFFI(), + ref_year.has_value() ? (diplomat::capi::OptionI32{ { ref_year.value() }, true }) : (diplomat::capi::OptionI32{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainMonthDay::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainMonthDay::with(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_with(this->AsFFI(), + partial.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainMonthDay::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline int32_t temporal_rs::PlainMonthDay::iso_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_iso_year(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainMonthDay::iso_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_iso_month(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainMonthDay::iso_day() const { + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_iso_day(this->AsFFI()); + return result; +} + +inline const temporal_rs::Calendar& temporal_rs::PlainMonthDay::calendar() const { + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_calendar(this->AsFFI()); + return *temporal_rs::Calendar::FromFFI(result); +} + +inline diplomat::result temporal_rs::PlainMonthDay::month_code() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_month_code(this->AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainMonthDay::to_plain_date() const { + auto result = temporal_rs::capi::temporal_rs_PlainMonthDay_to_plain_date(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline const temporal_rs::capi::PlainMonthDay* temporal_rs::PlainMonthDay::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::PlainMonthDay* temporal_rs::PlainMonthDay::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::PlainMonthDay* temporal_rs::PlainMonthDay::FromFFI(const temporal_rs::capi::PlainMonthDay* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::PlainMonthDay* temporal_rs::PlainMonthDay::FromFFI(temporal_rs::capi::PlainMonthDay* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::PlainMonthDay::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_PlainMonthDay_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_PlainMonthDay_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainTime.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainTime.d.hpp new file mode 100644 index 000000000..68dad675b --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainTime.d.hpp @@ -0,0 +1,90 @@ +#ifndef temporal_rs_PlainTime_D_HPP +#define temporal_rs_PlainTime_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Duration; } +class Duration; +namespace capi { struct PlainTime; } +class PlainTime; +namespace capi { struct TimeDuration; } +class TimeDuration; +struct DifferenceSettings; +struct PartialTime; +struct TemporalError; +struct ToStringRoundingOptions; +class ArithmeticOverflow; +class TemporalRoundingMode; +class TemporalUnit; +} + + +namespace temporal_rs { +namespace capi { + struct PlainTime; +} // namespace capi +} // namespace + +namespace temporal_rs { +class PlainTime { +public: + + inline static diplomat::result, temporal_rs::TemporalError> create(uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond); + + inline static diplomat::result, temporal_rs::TemporalError> try_create(uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond); + + inline static diplomat::result, temporal_rs::TemporalError> from_partial(temporal_rs::PartialTime partial, std::optional overflow); + + inline diplomat::result, temporal_rs::TemporalError> with(temporal_rs::PartialTime partial, std::optional overflow) const; + + inline uint8_t hour() const; + + inline uint8_t minute() const; + + inline uint8_t second() const; + + inline uint16_t millisecond() const; + + inline uint16_t microsecond() const; + + inline uint16_t nanosecond() const; + + inline diplomat::result, temporal_rs::TemporalError> add(const temporal_rs::Duration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract(const temporal_rs::Duration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> add_time_duration(const temporal_rs::TimeDuration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract_time_duration(const temporal_rs::TimeDuration& duration) const; + + inline diplomat::result, temporal_rs::TemporalError> until(const temporal_rs::PlainTime& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> since(const temporal_rs::PlainTime& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> round(temporal_rs::TemporalUnit smallest_unit, std::optional rounding_increment, std::optional rounding_mode) const; + + inline diplomat::result to_ixdtf_string(temporal_rs::ToStringRoundingOptions options) const; + + inline const temporal_rs::capi::PlainTime* AsFFI() const; + inline temporal_rs::capi::PlainTime* AsFFI(); + inline static const temporal_rs::PlainTime* FromFFI(const temporal_rs::capi::PlainTime* ptr); + inline static temporal_rs::PlainTime* FromFFI(temporal_rs::capi::PlainTime* ptr); + inline static void operator delete(void* ptr); +private: + PlainTime() = delete; + PlainTime(const temporal_rs::PlainTime&) = delete; + PlainTime(temporal_rs::PlainTime&&) noexcept = delete; + PlainTime operator=(const temporal_rs::PlainTime&) = delete; + PlainTime operator=(temporal_rs::PlainTime&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_PlainTime_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainTime.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainTime.hpp new file mode 100644 index 000000000..91e57dc97 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainTime.hpp @@ -0,0 +1,222 @@ +#ifndef temporal_rs_PlainTime_HPP +#define temporal_rs_PlainTime_HPP + +#include "PlainTime.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "ArithmeticOverflow.hpp" +#include "DifferenceSettings.hpp" +#include "Duration.hpp" +#include "PartialTime.hpp" +#include "TemporalError.hpp" +#include "TemporalRoundingMode.hpp" +#include "TemporalUnit.hpp" +#include "TimeDuration.hpp" +#include "ToStringRoundingOptions.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_PlainTime_create_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_create_result; + temporal_rs_PlainTime_create_result temporal_rs_PlainTime_create(uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond); + + typedef struct temporal_rs_PlainTime_try_create_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_try_create_result; + temporal_rs_PlainTime_try_create_result temporal_rs_PlainTime_try_create(uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond); + + typedef struct temporal_rs_PlainTime_from_partial_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_from_partial_result; + temporal_rs_PlainTime_from_partial_result temporal_rs_PlainTime_from_partial(temporal_rs::capi::PartialTime partial, temporal_rs::capi::ArithmeticOverflow_option overflow); + + typedef struct temporal_rs_PlainTime_with_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_with_result; + temporal_rs_PlainTime_with_result temporal_rs_PlainTime_with(const temporal_rs::capi::PlainTime* self, temporal_rs::capi::PartialTime partial, temporal_rs::capi::ArithmeticOverflow_option overflow); + + uint8_t temporal_rs_PlainTime_hour(const temporal_rs::capi::PlainTime* self); + + uint8_t temporal_rs_PlainTime_minute(const temporal_rs::capi::PlainTime* self); + + uint8_t temporal_rs_PlainTime_second(const temporal_rs::capi::PlainTime* self); + + uint16_t temporal_rs_PlainTime_millisecond(const temporal_rs::capi::PlainTime* self); + + uint16_t temporal_rs_PlainTime_microsecond(const temporal_rs::capi::PlainTime* self); + + uint16_t temporal_rs_PlainTime_nanosecond(const temporal_rs::capi::PlainTime* self); + + typedef struct temporal_rs_PlainTime_add_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_add_result; + temporal_rs_PlainTime_add_result temporal_rs_PlainTime_add(const temporal_rs::capi::PlainTime* self, const temporal_rs::capi::Duration* duration); + + typedef struct temporal_rs_PlainTime_subtract_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_subtract_result; + temporal_rs_PlainTime_subtract_result temporal_rs_PlainTime_subtract(const temporal_rs::capi::PlainTime* self, const temporal_rs::capi::Duration* duration); + + typedef struct temporal_rs_PlainTime_add_time_duration_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_add_time_duration_result; + temporal_rs_PlainTime_add_time_duration_result temporal_rs_PlainTime_add_time_duration(const temporal_rs::capi::PlainTime* self, const temporal_rs::capi::TimeDuration* duration); + + typedef struct temporal_rs_PlainTime_subtract_time_duration_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_subtract_time_duration_result; + temporal_rs_PlainTime_subtract_time_duration_result temporal_rs_PlainTime_subtract_time_duration(const temporal_rs::capi::PlainTime* self, const temporal_rs::capi::TimeDuration* duration); + + typedef struct temporal_rs_PlainTime_until_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_until_result; + temporal_rs_PlainTime_until_result temporal_rs_PlainTime_until(const temporal_rs::capi::PlainTime* self, const temporal_rs::capi::PlainTime* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainTime_since_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_since_result; + temporal_rs_PlainTime_since_result temporal_rs_PlainTime_since(const temporal_rs::capi::PlainTime* self, const temporal_rs::capi::PlainTime* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainTime_round_result {union {temporal_rs::capi::PlainTime* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_round_result; + temporal_rs_PlainTime_round_result temporal_rs_PlainTime_round(const temporal_rs::capi::PlainTime* self, temporal_rs::capi::TemporalUnit smallest_unit, diplomat::capi::OptionF64 rounding_increment, temporal_rs::capi::TemporalRoundingMode_option rounding_mode); + + typedef struct temporal_rs_PlainTime_to_ixdtf_string_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainTime_to_ixdtf_string_result; + temporal_rs_PlainTime_to_ixdtf_string_result temporal_rs_PlainTime_to_ixdtf_string(const temporal_rs::capi::PlainTime* self, temporal_rs::capi::ToStringRoundingOptions options, diplomat::capi::DiplomatWrite* write); + + + void temporal_rs_PlainTime_destroy(PlainTime* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::create(uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond) { + auto result = temporal_rs::capi::temporal_rs_PlainTime_create(hour, + minute, + second, + millisecond, + microsecond, + nanosecond); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::try_create(uint8_t hour, uint8_t minute, uint8_t second, uint16_t millisecond, uint16_t microsecond, uint16_t nanosecond) { + auto result = temporal_rs::capi::temporal_rs_PlainTime_try_create(hour, + minute, + second, + millisecond, + microsecond, + nanosecond); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::from_partial(temporal_rs::PartialTime partial, std::optional overflow) { + auto result = temporal_rs::capi::temporal_rs_PlainTime_from_partial(partial.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::with(temporal_rs::PartialTime partial, std::optional overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_with(this->AsFFI(), + partial.AsFFI(), + overflow.has_value() ? (temporal_rs::capi::ArithmeticOverflow_option{ { overflow.value().AsFFI() }, true }) : (temporal_rs::capi::ArithmeticOverflow_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline uint8_t temporal_rs::PlainTime::hour() const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_hour(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainTime::minute() const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_minute(this->AsFFI()); + return result; +} + +inline uint8_t temporal_rs::PlainTime::second() const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_second(this->AsFFI()); + return result; +} + +inline uint16_t temporal_rs::PlainTime::millisecond() const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_millisecond(this->AsFFI()); + return result; +} + +inline uint16_t temporal_rs::PlainTime::microsecond() const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_microsecond(this->AsFFI()); + return result; +} + +inline uint16_t temporal_rs::PlainTime::nanosecond() const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_nanosecond(this->AsFFI()); + return result; +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::add(const temporal_rs::Duration& duration) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_add(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::subtract(const temporal_rs::Duration& duration) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_subtract(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::add_time_duration(const temporal_rs::TimeDuration& duration) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_add_time_duration(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::subtract_time_duration(const temporal_rs::TimeDuration& duration) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_subtract_time_duration(this->AsFFI(), + duration.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::until(const temporal_rs::PlainTime& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_until(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::since(const temporal_rs::PlainTime& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_since(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainTime::round(temporal_rs::TemporalUnit smallest_unit, std::optional rounding_increment, std::optional rounding_mode) const { + auto result = temporal_rs::capi::temporal_rs_PlainTime_round(this->AsFFI(), + smallest_unit.AsFFI(), + rounding_increment.has_value() ? (diplomat::capi::OptionF64{ { rounding_increment.value() }, true }) : (diplomat::capi::OptionF64{ {}, false }), + rounding_mode.has_value() ? (temporal_rs::capi::TemporalRoundingMode_option{ { rounding_mode.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalRoundingMode_option{ {}, false })); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainTime::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainTime::to_ixdtf_string(temporal_rs::ToStringRoundingOptions options) const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainTime_to_ixdtf_string(this->AsFFI(), + options.AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline const temporal_rs::capi::PlainTime* temporal_rs::PlainTime::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::PlainTime* temporal_rs::PlainTime::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::PlainTime* temporal_rs::PlainTime::FromFFI(const temporal_rs::capi::PlainTime* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::PlainTime* temporal_rs::PlainTime::FromFFI(temporal_rs::capi::PlainTime* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::PlainTime::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_PlainTime_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_PlainTime_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainYearMonth.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainYearMonth.d.hpp new file mode 100644 index 000000000..f3d592991 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainYearMonth.d.hpp @@ -0,0 +1,93 @@ +#ifndef temporal_rs_PlainYearMonth_D_HPP +#define temporal_rs_PlainYearMonth_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct Calendar; } +class Calendar; +namespace capi { struct Duration; } +class Duration; +namespace capi { struct PlainDate; } +class PlainDate; +namespace capi { struct PlainYearMonth; } +class PlainYearMonth; +struct DifferenceSettings; +struct PartialDate; +struct TemporalError; +class ArithmeticOverflow; +} + + +namespace temporal_rs { +namespace capi { + struct PlainYearMonth; +} // namespace capi +} // namespace + +namespace temporal_rs { +class PlainYearMonth { +public: + + inline static diplomat::result, temporal_rs::TemporalError> create_with_overflow(int32_t year, uint8_t month, std::optional reference_day, const temporal_rs::Calendar& calendar, temporal_rs::ArithmeticOverflow overflow); + + inline diplomat::result, temporal_rs::TemporalError> with(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const; + + inline int32_t iso_year() const; + + inline std::string padded_iso_year_string() const; + + inline uint8_t iso_month() const; + + inline diplomat::result year() const; + + inline diplomat::result month() const; + + inline diplomat::result month_code() const; + + inline bool in_leap_year() const; + + inline diplomat::result days_in_month() const; + + inline diplomat::result days_in_year() const; + + inline diplomat::result months_in_year() const; + + inline diplomat::result era() const; + + inline diplomat::result, temporal_rs::TemporalError> era_year() const; + + inline const temporal_rs::Calendar& calendar() const; + + inline diplomat::result, temporal_rs::TemporalError> add(const temporal_rs::Duration& duration, temporal_rs::ArithmeticOverflow overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> subtract(const temporal_rs::Duration& duration, temporal_rs::ArithmeticOverflow overflow) const; + + inline diplomat::result, temporal_rs::TemporalError> until(const temporal_rs::PlainYearMonth& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> since(const temporal_rs::PlainYearMonth& other, temporal_rs::DifferenceSettings settings) const; + + inline diplomat::result, temporal_rs::TemporalError> to_plain_date() const; + + inline const temporal_rs::capi::PlainYearMonth* AsFFI() const; + inline temporal_rs::capi::PlainYearMonth* AsFFI(); + inline static const temporal_rs::PlainYearMonth* FromFFI(const temporal_rs::capi::PlainYearMonth* ptr); + inline static temporal_rs::PlainYearMonth* FromFFI(temporal_rs::capi::PlainYearMonth* ptr); + inline static void operator delete(void* ptr); +private: + PlainYearMonth() = delete; + PlainYearMonth(const temporal_rs::PlainYearMonth&) = delete; + PlainYearMonth(temporal_rs::PlainYearMonth&&) noexcept = delete; + PlainYearMonth operator=(const temporal_rs::PlainYearMonth&) = delete; + PlainYearMonth operator=(temporal_rs::PlainYearMonth&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_PlainYearMonth_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/PlainYearMonth.hpp b/temporal_capi/bindings/cpp/temporal_rs/PlainYearMonth.hpp new file mode 100644 index 000000000..0bbb3038c --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/PlainYearMonth.hpp @@ -0,0 +1,232 @@ +#ifndef temporal_rs_PlainYearMonth_HPP +#define temporal_rs_PlainYearMonth_HPP + +#include "PlainYearMonth.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "ArithmeticOverflow.hpp" +#include "Calendar.hpp" +#include "DifferenceSettings.hpp" +#include "Duration.hpp" +#include "PartialDate.hpp" +#include "PlainDate.hpp" +#include "TemporalError.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_PlainYearMonth_create_with_overflow_result {union {temporal_rs::capi::PlainYearMonth* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_create_with_overflow_result; + temporal_rs_PlainYearMonth_create_with_overflow_result temporal_rs_PlainYearMonth_create_with_overflow(int32_t year, uint8_t month, diplomat::capi::OptionU8 reference_day, const temporal_rs::capi::Calendar* calendar, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_PlainYearMonth_with_result {union {temporal_rs::capi::PlainYearMonth* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_with_result; + temporal_rs_PlainYearMonth_with_result temporal_rs_PlainYearMonth_with(const temporal_rs::capi::PlainYearMonth* self, temporal_rs::capi::PartialDate partial, temporal_rs::capi::ArithmeticOverflow overflow); + + int32_t temporal_rs_PlainYearMonth_iso_year(const temporal_rs::capi::PlainYearMonth* self); + + void temporal_rs_PlainYearMonth_padded_iso_year_string(const temporal_rs::capi::PlainYearMonth* self, diplomat::capi::DiplomatWrite* write); + + uint8_t temporal_rs_PlainYearMonth_iso_month(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_year_result {union {int32_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_year_result; + temporal_rs_PlainYearMonth_year_result temporal_rs_PlainYearMonth_year(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_month_result {union {uint8_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_month_result; + temporal_rs_PlainYearMonth_month_result temporal_rs_PlainYearMonth_month(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_month_code_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_month_code_result; + temporal_rs_PlainYearMonth_month_code_result temporal_rs_PlainYearMonth_month_code(const temporal_rs::capi::PlainYearMonth* self, diplomat::capi::DiplomatWrite* write); + + bool temporal_rs_PlainYearMonth_in_leap_year(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_days_in_month_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_days_in_month_result; + temporal_rs_PlainYearMonth_days_in_month_result temporal_rs_PlainYearMonth_days_in_month(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_days_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_days_in_year_result; + temporal_rs_PlainYearMonth_days_in_year_result temporal_rs_PlainYearMonth_days_in_year(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_months_in_year_result {union {uint16_t ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_months_in_year_result; + temporal_rs_PlainYearMonth_months_in_year_result temporal_rs_PlainYearMonth_months_in_year(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_era_result {union { temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_era_result; + temporal_rs_PlainYearMonth_era_result temporal_rs_PlainYearMonth_era(const temporal_rs::capi::PlainYearMonth* self, diplomat::capi::DiplomatWrite* write); + + typedef struct temporal_rs_PlainYearMonth_era_year_result {union {diplomat::capi::OptionI32 ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_era_year_result; + temporal_rs_PlainYearMonth_era_year_result temporal_rs_PlainYearMonth_era_year(const temporal_rs::capi::PlainYearMonth* self); + + const temporal_rs::capi::Calendar* temporal_rs_PlainYearMonth_calendar(const temporal_rs::capi::PlainYearMonth* self); + + typedef struct temporal_rs_PlainYearMonth_add_result {union {temporal_rs::capi::PlainYearMonth* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_add_result; + temporal_rs_PlainYearMonth_add_result temporal_rs_PlainYearMonth_add(const temporal_rs::capi::PlainYearMonth* self, const temporal_rs::capi::Duration* duration, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_PlainYearMonth_subtract_result {union {temporal_rs::capi::PlainYearMonth* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_subtract_result; + temporal_rs_PlainYearMonth_subtract_result temporal_rs_PlainYearMonth_subtract(const temporal_rs::capi::PlainYearMonth* self, const temporal_rs::capi::Duration* duration, temporal_rs::capi::ArithmeticOverflow overflow); + + typedef struct temporal_rs_PlainYearMonth_until_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_until_result; + temporal_rs_PlainYearMonth_until_result temporal_rs_PlainYearMonth_until(const temporal_rs::capi::PlainYearMonth* self, const temporal_rs::capi::PlainYearMonth* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainYearMonth_since_result {union {temporal_rs::capi::Duration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_since_result; + temporal_rs_PlainYearMonth_since_result temporal_rs_PlainYearMonth_since(const temporal_rs::capi::PlainYearMonth* self, const temporal_rs::capi::PlainYearMonth* other, temporal_rs::capi::DifferenceSettings settings); + + typedef struct temporal_rs_PlainYearMonth_to_plain_date_result {union {temporal_rs::capi::PlainDate* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_PlainYearMonth_to_plain_date_result; + temporal_rs_PlainYearMonth_to_plain_date_result temporal_rs_PlainYearMonth_to_plain_date(const temporal_rs::capi::PlainYearMonth* self); + + + void temporal_rs_PlainYearMonth_destroy(PlainYearMonth* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::create_with_overflow(int32_t year, uint8_t month, std::optional reference_day, const temporal_rs::Calendar& calendar, temporal_rs::ArithmeticOverflow overflow) { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_create_with_overflow(year, + month, + reference_day.has_value() ? (diplomat::capi::OptionU8{ { reference_day.value() }, true }) : (diplomat::capi::OptionU8{ {}, false }), + calendar.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainYearMonth::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::with(temporal_rs::PartialDate partial, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_with(this->AsFFI(), + partial.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainYearMonth::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline int32_t temporal_rs::PlainYearMonth::iso_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_iso_year(this->AsFFI()); + return result; +} + +inline std::string temporal_rs::PlainYearMonth::padded_iso_year_string() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + temporal_rs::capi::temporal_rs_PlainYearMonth_padded_iso_year_string(this->AsFFI(), + &write); + return output; +} + +inline uint8_t temporal_rs::PlainYearMonth::iso_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_iso_month(this->AsFFI()); + return result; +} + +inline diplomat::result temporal_rs::PlainYearMonth::year() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainYearMonth::month() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_month(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainYearMonth::month_code() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_month_code(this->AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline bool temporal_rs::PlainYearMonth::in_leap_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_in_leap_year(this->AsFFI()); + return result; +} + +inline diplomat::result temporal_rs::PlainYearMonth::days_in_month() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_days_in_month(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainYearMonth::days_in_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_days_in_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainYearMonth::months_in_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_months_in_year(this->AsFFI()); + return result.is_ok ? diplomat::result(diplomat::Ok(result.ok)) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result temporal_rs::PlainYearMonth::era() const { + std::string output; + diplomat::capi::DiplomatWrite write = diplomat::WriteFromString(output); + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_era(this->AsFFI(), + &write); + return result.is_ok ? diplomat::result(diplomat::Ok(std::move(output))) : diplomat::result(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::era_year() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_era_year(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(result.ok.is_ok ? std::optional(result.ok.ok) : std::nullopt)) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline const temporal_rs::Calendar& temporal_rs::PlainYearMonth::calendar() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_calendar(this->AsFFI()); + return *temporal_rs::Calendar::FromFFI(result); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::add(const temporal_rs::Duration& duration, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_add(this->AsFFI(), + duration.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainYearMonth::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::subtract(const temporal_rs::Duration& duration, temporal_rs::ArithmeticOverflow overflow) const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_subtract(this->AsFFI(), + duration.AsFFI(), + overflow.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainYearMonth::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::until(const temporal_rs::PlainYearMonth& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_until(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::since(const temporal_rs::PlainYearMonth& other, temporal_rs::DifferenceSettings settings) const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_since(this->AsFFI(), + other.AsFFI(), + settings.AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::Duration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::PlainYearMonth::to_plain_date() const { + auto result = temporal_rs::capi::temporal_rs_PlainYearMonth_to_plain_date(this->AsFFI()); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::PlainDate::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline const temporal_rs::capi::PlainYearMonth* temporal_rs::PlainYearMonth::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::PlainYearMonth* temporal_rs::PlainYearMonth::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::PlainYearMonth* temporal_rs::PlainYearMonth::FromFFI(const temporal_rs::capi::PlainYearMonth* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::PlainYearMonth* temporal_rs::PlainYearMonth::FromFFI(temporal_rs::capi::PlainYearMonth* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::PlainYearMonth::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_PlainYearMonth_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_PlainYearMonth_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Precision.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/Precision.d.hpp new file mode 100644 index 000000000..f583257ec --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Precision.d.hpp @@ -0,0 +1,35 @@ +#ifndef temporal_rs_Precision_D_HPP +#define temporal_rs_Precision_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + struct Precision { + bool is_minute; + diplomat::capi::OptionU8 precision; + }; + + typedef struct Precision_option {union { Precision ok; }; bool is_ok; } Precision_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct Precision { + bool is_minute; + std::optional precision; + + inline temporal_rs::capi::Precision AsFFI() const; + inline static temporal_rs::Precision FromFFI(temporal_rs::capi::Precision c_struct); +}; + +} // namespace +#endif // temporal_rs_Precision_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Precision.hpp b/temporal_capi/bindings/cpp/temporal_rs/Precision.hpp new file mode 100644 index 000000000..c73af435d --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Precision.hpp @@ -0,0 +1,40 @@ +#ifndef temporal_rs_Precision_HPP +#define temporal_rs_Precision_HPP + +#include "Precision.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::Precision temporal_rs::Precision::AsFFI() const { + return temporal_rs::capi::Precision { + /* .is_minute = */ is_minute, + /* .precision = */ precision.has_value() ? (diplomat::capi::OptionU8{ { precision.value() }, true }) : (diplomat::capi::OptionU8{ {}, false }), + }; +} + +inline temporal_rs::Precision temporal_rs::Precision::FromFFI(temporal_rs::capi::Precision c_struct) { + return temporal_rs::Precision { + /* .is_minute = */ c_struct.is_minute, + /* .precision = */ c_struct.precision.is_ok ? std::optional(c_struct.precision.ok) : std::nullopt, + }; +} + + +#endif // temporal_rs_Precision_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/RoundingOptions.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/RoundingOptions.d.hpp new file mode 100644 index 000000000..cced384d0 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/RoundingOptions.d.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_RoundingOptions_D_HPP +#define temporal_rs_RoundingOptions_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "TemporalRoundingMode.d.hpp" +#include "TemporalUnit.d.hpp" + +namespace temporal_rs { +class TemporalRoundingMode; +class TemporalUnit; +} + + +namespace temporal_rs { +namespace capi { + struct RoundingOptions { + temporal_rs::capi::TemporalUnit_option largest_unit; + temporal_rs::capi::TemporalUnit_option smallest_unit; + temporal_rs::capi::TemporalRoundingMode_option rounding_mode; + diplomat::capi::OptionU32 increment; + }; + + typedef struct RoundingOptions_option {union { RoundingOptions ok; }; bool is_ok; } RoundingOptions_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct RoundingOptions { + std::optional largest_unit; + std::optional smallest_unit; + std::optional rounding_mode; + std::optional increment; + + inline temporal_rs::capi::RoundingOptions AsFFI() const; + inline static temporal_rs::RoundingOptions FromFFI(temporal_rs::capi::RoundingOptions c_struct); +}; + +} // namespace +#endif // temporal_rs_RoundingOptions_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/RoundingOptions.hpp b/temporal_capi/bindings/cpp/temporal_rs/RoundingOptions.hpp new file mode 100644 index 000000000..1d29744ee --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/RoundingOptions.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_RoundingOptions_HPP +#define temporal_rs_RoundingOptions_HPP + +#include "RoundingOptions.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "TemporalRoundingMode.hpp" +#include "TemporalUnit.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::RoundingOptions temporal_rs::RoundingOptions::AsFFI() const { + return temporal_rs::capi::RoundingOptions { + /* .largest_unit = */ largest_unit.has_value() ? (temporal_rs::capi::TemporalUnit_option{ { largest_unit.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalUnit_option{ {}, false }), + /* .smallest_unit = */ smallest_unit.has_value() ? (temporal_rs::capi::TemporalUnit_option{ { smallest_unit.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalUnit_option{ {}, false }), + /* .rounding_mode = */ rounding_mode.has_value() ? (temporal_rs::capi::TemporalRoundingMode_option{ { rounding_mode.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalRoundingMode_option{ {}, false }), + /* .increment = */ increment.has_value() ? (diplomat::capi::OptionU32{ { increment.value() }, true }) : (diplomat::capi::OptionU32{ {}, false }), + }; +} + +inline temporal_rs::RoundingOptions temporal_rs::RoundingOptions::FromFFI(temporal_rs::capi::RoundingOptions c_struct) { + return temporal_rs::RoundingOptions { + /* .largest_unit = */ c_struct.largest_unit.is_ok ? std::optional(temporal_rs::TemporalUnit::FromFFI(c_struct.largest_unit.ok)) : std::nullopt, + /* .smallest_unit = */ c_struct.smallest_unit.is_ok ? std::optional(temporal_rs::TemporalUnit::FromFFI(c_struct.smallest_unit.ok)) : std::nullopt, + /* .rounding_mode = */ c_struct.rounding_mode.is_ok ? std::optional(temporal_rs::TemporalRoundingMode::FromFFI(c_struct.rounding_mode.ok)) : std::nullopt, + /* .increment = */ c_struct.increment.is_ok ? std::optional(c_struct.increment.ok) : std::nullopt, + }; +} + + +#endif // temporal_rs_RoundingOptions_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Sign.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/Sign.d.hpp new file mode 100644 index 000000000..80dd2bbd2 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Sign.d.hpp @@ -0,0 +1,48 @@ +#ifndef temporal_rs_Sign_D_HPP +#define temporal_rs_Sign_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum Sign { + Sign_Positive = 1, + Sign_Zero = 0, + Sign_Negative = -1, + }; + + typedef struct Sign_option {union { Sign ok; }; bool is_ok; } Sign_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class Sign { +public: + enum Value { + Positive = 1, + Zero = 0, + Negative = -1, + }; + + Sign() = default; + // Implicit conversions between enum and ::Value + constexpr Sign(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::Sign AsFFI() const; + inline static temporal_rs::Sign FromFFI(temporal_rs::capi::Sign c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_Sign_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/Sign.hpp b/temporal_capi/bindings/cpp/temporal_rs/Sign.hpp new file mode 100644 index 000000000..5d237a7c8 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/Sign.hpp @@ -0,0 +1,38 @@ +#ifndef temporal_rs_Sign_HPP +#define temporal_rs_Sign_HPP + +#include "Sign.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::Sign temporal_rs::Sign::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::Sign temporal_rs::Sign::FromFFI(temporal_rs::capi::Sign c_enum) { + switch (c_enum) { + case temporal_rs::capi::Sign_Positive: + case temporal_rs::capi::Sign_Zero: + case temporal_rs::capi::Sign_Negative: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_Sign_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalError.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalError.d.hpp new file mode 100644 index 000000000..dbea81f92 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalError.d.hpp @@ -0,0 +1,38 @@ +#ifndef temporal_rs_TemporalError_D_HPP +#define temporal_rs_TemporalError_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "ErrorKind.d.hpp" + +namespace temporal_rs { +class ErrorKind; +} + + +namespace temporal_rs { +namespace capi { + struct TemporalError { + temporal_rs::capi::ErrorKind kind; + }; + + typedef struct TemporalError_option {union { TemporalError ok; }; bool is_ok; } TemporalError_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct TemporalError { + temporal_rs::ErrorKind kind; + + inline temporal_rs::capi::TemporalError AsFFI() const; + inline static temporal_rs::TemporalError FromFFI(temporal_rs::capi::TemporalError c_struct); +}; + +} // namespace +#endif // temporal_rs_TemporalError_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalError.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalError.hpp new file mode 100644 index 000000000..0847d7f85 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalError.hpp @@ -0,0 +1,39 @@ +#ifndef temporal_rs_TemporalError_HPP +#define temporal_rs_TemporalError_HPP + +#include "TemporalError.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "ErrorKind.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::TemporalError temporal_rs::TemporalError::AsFFI() const { + return temporal_rs::capi::TemporalError { + /* .kind = */ kind.AsFFI(), + }; +} + +inline temporal_rs::TemporalError temporal_rs::TemporalError::FromFFI(temporal_rs::capi::TemporalError c_struct) { + return temporal_rs::TemporalError { + /* .kind = */ temporal_rs::ErrorKind::FromFFI(c_struct.kind), + }; +} + + +#endif // temporal_rs_TemporalError_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalRoundingMode.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalRoundingMode.d.hpp new file mode 100644 index 000000000..65ff5d890 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalRoundingMode.d.hpp @@ -0,0 +1,60 @@ +#ifndef temporal_rs_TemporalRoundingMode_D_HPP +#define temporal_rs_TemporalRoundingMode_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum TemporalRoundingMode { + TemporalRoundingMode_Ceil = 0, + TemporalRoundingMode_Floor = 1, + TemporalRoundingMode_Expand = 2, + TemporalRoundingMode_Trunc = 3, + TemporalRoundingMode_HalfCeil = 4, + TemporalRoundingMode_HalfFloor = 5, + TemporalRoundingMode_HalfExpand = 6, + TemporalRoundingMode_HalfTrunc = 7, + TemporalRoundingMode_HalfEven = 8, + }; + + typedef struct TemporalRoundingMode_option {union { TemporalRoundingMode ok; }; bool is_ok; } TemporalRoundingMode_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class TemporalRoundingMode { +public: + enum Value { + Ceil = 0, + Floor = 1, + Expand = 2, + Trunc = 3, + HalfCeil = 4, + HalfFloor = 5, + HalfExpand = 6, + HalfTrunc = 7, + HalfEven = 8, + }; + + TemporalRoundingMode() = default; + // Implicit conversions between enum and ::Value + constexpr TemporalRoundingMode(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::TemporalRoundingMode AsFFI() const; + inline static temporal_rs::TemporalRoundingMode FromFFI(temporal_rs::capi::TemporalRoundingMode c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_TemporalRoundingMode_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalRoundingMode.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalRoundingMode.hpp new file mode 100644 index 000000000..839e826cb --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalRoundingMode.hpp @@ -0,0 +1,44 @@ +#ifndef temporal_rs_TemporalRoundingMode_HPP +#define temporal_rs_TemporalRoundingMode_HPP + +#include "TemporalRoundingMode.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::TemporalRoundingMode temporal_rs::TemporalRoundingMode::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::TemporalRoundingMode temporal_rs::TemporalRoundingMode::FromFFI(temporal_rs::capi::TemporalRoundingMode c_enum) { + switch (c_enum) { + case temporal_rs::capi::TemporalRoundingMode_Ceil: + case temporal_rs::capi::TemporalRoundingMode_Floor: + case temporal_rs::capi::TemporalRoundingMode_Expand: + case temporal_rs::capi::TemporalRoundingMode_Trunc: + case temporal_rs::capi::TemporalRoundingMode_HalfCeil: + case temporal_rs::capi::TemporalRoundingMode_HalfFloor: + case temporal_rs::capi::TemporalRoundingMode_HalfExpand: + case temporal_rs::capi::TemporalRoundingMode_HalfTrunc: + case temporal_rs::capi::TemporalRoundingMode_HalfEven: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_TemporalRoundingMode_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalUnit.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnit.d.hpp new file mode 100644 index 000000000..6d36f8642 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnit.d.hpp @@ -0,0 +1,64 @@ +#ifndef temporal_rs_TemporalUnit_D_HPP +#define temporal_rs_TemporalUnit_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum TemporalUnit { + TemporalUnit_Auto = 0, + TemporalUnit_Nanosecond = 1, + TemporalUnit_Microsecond = 2, + TemporalUnit_Millisecond = 3, + TemporalUnit_Second = 4, + TemporalUnit_Minute = 5, + TemporalUnit_Hour = 6, + TemporalUnit_Day = 7, + TemporalUnit_Week = 8, + TemporalUnit_Month = 9, + TemporalUnit_Year = 10, + }; + + typedef struct TemporalUnit_option {union { TemporalUnit ok; }; bool is_ok; } TemporalUnit_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class TemporalUnit { +public: + enum Value { + Auto = 0, + Nanosecond = 1, + Microsecond = 2, + Millisecond = 3, + Second = 4, + Minute = 5, + Hour = 6, + Day = 7, + Week = 8, + Month = 9, + Year = 10, + }; + + TemporalUnit() = default; + // Implicit conversions between enum and ::Value + constexpr TemporalUnit(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::TemporalUnit AsFFI() const; + inline static temporal_rs::TemporalUnit FromFFI(temporal_rs::capi::TemporalUnit c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_TemporalUnit_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalUnit.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnit.hpp new file mode 100644 index 000000000..b66c7f9a9 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnit.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_TemporalUnit_HPP +#define temporal_rs_TemporalUnit_HPP + +#include "TemporalUnit.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::TemporalUnit temporal_rs::TemporalUnit::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::TemporalUnit temporal_rs::TemporalUnit::FromFFI(temporal_rs::capi::TemporalUnit c_enum) { + switch (c_enum) { + case temporal_rs::capi::TemporalUnit_Auto: + case temporal_rs::capi::TemporalUnit_Nanosecond: + case temporal_rs::capi::TemporalUnit_Microsecond: + case temporal_rs::capi::TemporalUnit_Millisecond: + case temporal_rs::capi::TemporalUnit_Second: + case temporal_rs::capi::TemporalUnit_Minute: + case temporal_rs::capi::TemporalUnit_Hour: + case temporal_rs::capi::TemporalUnit_Day: + case temporal_rs::capi::TemporalUnit_Week: + case temporal_rs::capi::TemporalUnit_Month: + case temporal_rs::capi::TemporalUnit_Year: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_TemporalUnit_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalUnsignedRoundingMode.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnsignedRoundingMode.d.hpp new file mode 100644 index 000000000..b5017267a --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnsignedRoundingMode.d.hpp @@ -0,0 +1,52 @@ +#ifndef temporal_rs_TemporalUnsignedRoundingMode_D_HPP +#define temporal_rs_TemporalUnsignedRoundingMode_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + enum TemporalUnsignedRoundingMode { + TemporalUnsignedRoundingMode_Infinity = 0, + TemporalUnsignedRoundingMode_Zero = 1, + TemporalUnsignedRoundingMode_HalfInfinity = 2, + TemporalUnsignedRoundingMode_HalfZero = 3, + TemporalUnsignedRoundingMode_HalfEven = 4, + }; + + typedef struct TemporalUnsignedRoundingMode_option {union { TemporalUnsignedRoundingMode ok; }; bool is_ok; } TemporalUnsignedRoundingMode_option; +} // namespace capi +} // namespace + +namespace temporal_rs { +class TemporalUnsignedRoundingMode { +public: + enum Value { + Infinity = 0, + Zero = 1, + HalfInfinity = 2, + HalfZero = 3, + HalfEven = 4, + }; + + TemporalUnsignedRoundingMode() = default; + // Implicit conversions between enum and ::Value + constexpr TemporalUnsignedRoundingMode(Value v) : value(v) {} + constexpr operator Value() const { return value; } + // Prevent usage as boolean value + explicit operator bool() const = delete; + + inline temporal_rs::capi::TemporalUnsignedRoundingMode AsFFI() const; + inline static temporal_rs::TemporalUnsignedRoundingMode FromFFI(temporal_rs::capi::TemporalUnsignedRoundingMode c_enum); +private: + Value value; +}; + +} // namespace +#endif // temporal_rs_TemporalUnsignedRoundingMode_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TemporalUnsignedRoundingMode.hpp b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnsignedRoundingMode.hpp new file mode 100644 index 000000000..396772ca6 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TemporalUnsignedRoundingMode.hpp @@ -0,0 +1,40 @@ +#ifndef temporal_rs_TemporalUnsignedRoundingMode_HPP +#define temporal_rs_TemporalUnsignedRoundingMode_HPP + +#include "TemporalUnsignedRoundingMode.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + +inline temporal_rs::capi::TemporalUnsignedRoundingMode temporal_rs::TemporalUnsignedRoundingMode::AsFFI() const { + return static_cast(value); +} + +inline temporal_rs::TemporalUnsignedRoundingMode temporal_rs::TemporalUnsignedRoundingMode::FromFFI(temporal_rs::capi::TemporalUnsignedRoundingMode c_enum) { + switch (c_enum) { + case temporal_rs::capi::TemporalUnsignedRoundingMode_Infinity: + case temporal_rs::capi::TemporalUnsignedRoundingMode_Zero: + case temporal_rs::capi::TemporalUnsignedRoundingMode_HalfInfinity: + case temporal_rs::capi::TemporalUnsignedRoundingMode_HalfZero: + case temporal_rs::capi::TemporalUnsignedRoundingMode_HalfEven: + return static_cast(c_enum); + default: + abort(); + } +} +#endif // temporal_rs_TemporalUnsignedRoundingMode_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TimeDuration.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/TimeDuration.d.hpp new file mode 100644 index 000000000..13a2020c3 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TimeDuration.d.hpp @@ -0,0 +1,55 @@ +#ifndef temporal_rs_TimeDuration_D_HPP +#define temporal_rs_TimeDuration_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" + +namespace temporal_rs { +namespace capi { struct TimeDuration; } +class TimeDuration; +struct TemporalError; +class Sign; +} + + +namespace temporal_rs { +namespace capi { + struct TimeDuration; +} // namespace capi +} // namespace + +namespace temporal_rs { +class TimeDuration { +public: + + inline static diplomat::result, temporal_rs::TemporalError> new_(double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds); + + inline std::unique_ptr abs() const; + + inline std::unique_ptr negated() const; + + inline bool is_within_range() const; + + inline temporal_rs::Sign sign() const; + + inline const temporal_rs::capi::TimeDuration* AsFFI() const; + inline temporal_rs::capi::TimeDuration* AsFFI(); + inline static const temporal_rs::TimeDuration* FromFFI(const temporal_rs::capi::TimeDuration* ptr); + inline static temporal_rs::TimeDuration* FromFFI(temporal_rs::capi::TimeDuration* ptr); + inline static void operator delete(void* ptr); +private: + TimeDuration() = delete; + TimeDuration(const temporal_rs::TimeDuration&) = delete; + TimeDuration(temporal_rs::TimeDuration&&) noexcept = delete; + TimeDuration operator=(const temporal_rs::TimeDuration&) = delete; + TimeDuration operator=(temporal_rs::TimeDuration&&) noexcept = delete; + static void operator delete[](void*, size_t) = delete; +}; + +} // namespace +#endif // temporal_rs_TimeDuration_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/TimeDuration.hpp b/temporal_capi/bindings/cpp/temporal_rs/TimeDuration.hpp new file mode 100644 index 000000000..8da723487 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/TimeDuration.hpp @@ -0,0 +1,90 @@ +#ifndef temporal_rs_TimeDuration_HPP +#define temporal_rs_TimeDuration_HPP + +#include "TimeDuration.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "Sign.hpp" +#include "TemporalError.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + typedef struct temporal_rs_TimeDuration_new_result {union {temporal_rs::capi::TimeDuration* ok; temporal_rs::capi::TemporalError err;}; bool is_ok;} temporal_rs_TimeDuration_new_result; + temporal_rs_TimeDuration_new_result temporal_rs_TimeDuration_new(double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds); + + temporal_rs::capi::TimeDuration* temporal_rs_TimeDuration_abs(const temporal_rs::capi::TimeDuration* self); + + temporal_rs::capi::TimeDuration* temporal_rs_TimeDuration_negated(const temporal_rs::capi::TimeDuration* self); + + bool temporal_rs_TimeDuration_is_within_range(const temporal_rs::capi::TimeDuration* self); + + temporal_rs::capi::Sign temporal_rs_TimeDuration_sign(const temporal_rs::capi::TimeDuration* self); + + + void temporal_rs_TimeDuration_destroy(TimeDuration* self); + + } // extern "C" +} // namespace capi +} // namespace + +inline diplomat::result, temporal_rs::TemporalError> temporal_rs::TimeDuration::new_(double hours, double minutes, double seconds, double milliseconds, double microseconds, double nanoseconds) { + auto result = temporal_rs::capi::temporal_rs_TimeDuration_new(hours, + minutes, + seconds, + milliseconds, + microseconds, + nanoseconds); + return result.is_ok ? diplomat::result, temporal_rs::TemporalError>(diplomat::Ok>(std::unique_ptr(temporal_rs::TimeDuration::FromFFI(result.ok)))) : diplomat::result, temporal_rs::TemporalError>(diplomat::Err(temporal_rs::TemporalError::FromFFI(result.err))); +} + +inline std::unique_ptr temporal_rs::TimeDuration::abs() const { + auto result = temporal_rs::capi::temporal_rs_TimeDuration_abs(this->AsFFI()); + return std::unique_ptr(temporal_rs::TimeDuration::FromFFI(result)); +} + +inline std::unique_ptr temporal_rs::TimeDuration::negated() const { + auto result = temporal_rs::capi::temporal_rs_TimeDuration_negated(this->AsFFI()); + return std::unique_ptr(temporal_rs::TimeDuration::FromFFI(result)); +} + +inline bool temporal_rs::TimeDuration::is_within_range() const { + auto result = temporal_rs::capi::temporal_rs_TimeDuration_is_within_range(this->AsFFI()); + return result; +} + +inline temporal_rs::Sign temporal_rs::TimeDuration::sign() const { + auto result = temporal_rs::capi::temporal_rs_TimeDuration_sign(this->AsFFI()); + return temporal_rs::Sign::FromFFI(result); +} + +inline const temporal_rs::capi::TimeDuration* temporal_rs::TimeDuration::AsFFI() const { + return reinterpret_cast(this); +} + +inline temporal_rs::capi::TimeDuration* temporal_rs::TimeDuration::AsFFI() { + return reinterpret_cast(this); +} + +inline const temporal_rs::TimeDuration* temporal_rs::TimeDuration::FromFFI(const temporal_rs::capi::TimeDuration* ptr) { + return reinterpret_cast(ptr); +} + +inline temporal_rs::TimeDuration* temporal_rs::TimeDuration::FromFFI(temporal_rs::capi::TimeDuration* ptr) { + return reinterpret_cast(ptr); +} + +inline void temporal_rs::TimeDuration::operator delete(void* ptr) { + temporal_rs::capi::temporal_rs_TimeDuration_destroy(reinterpret_cast(ptr)); +} + + +#endif // temporal_rs_TimeDuration_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/ToStringRoundingOptions.d.hpp b/temporal_capi/bindings/cpp/temporal_rs/ToStringRoundingOptions.d.hpp new file mode 100644 index 000000000..fe4b7bb58 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/ToStringRoundingOptions.d.hpp @@ -0,0 +1,46 @@ +#ifndef temporal_rs_ToStringRoundingOptions_D_HPP +#define temporal_rs_ToStringRoundingOptions_D_HPP + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "Precision.d.hpp" +#include "TemporalRoundingMode.d.hpp" +#include "TemporalUnit.d.hpp" + +namespace temporal_rs { +struct Precision; +class TemporalRoundingMode; +class TemporalUnit; +} + + +namespace temporal_rs { +namespace capi { + struct ToStringRoundingOptions { + temporal_rs::capi::Precision precision; + temporal_rs::capi::TemporalUnit_option smallest_unit; + temporal_rs::capi::TemporalRoundingMode_option rounding_mode; + }; + + typedef struct ToStringRoundingOptions_option {union { ToStringRoundingOptions ok; }; bool is_ok; } ToStringRoundingOptions_option; +} // namespace capi +} // namespace + + +namespace temporal_rs { +struct ToStringRoundingOptions { + temporal_rs::Precision precision; + std::optional smallest_unit; + std::optional rounding_mode; + + inline temporal_rs::capi::ToStringRoundingOptions AsFFI() const; + inline static temporal_rs::ToStringRoundingOptions FromFFI(temporal_rs::capi::ToStringRoundingOptions c_struct); +}; + +} // namespace +#endif // temporal_rs_ToStringRoundingOptions_D_HPP diff --git a/temporal_capi/bindings/cpp/temporal_rs/ToStringRoundingOptions.hpp b/temporal_capi/bindings/cpp/temporal_rs/ToStringRoundingOptions.hpp new file mode 100644 index 000000000..38f6ccc28 --- /dev/null +++ b/temporal_capi/bindings/cpp/temporal_rs/ToStringRoundingOptions.hpp @@ -0,0 +1,45 @@ +#ifndef temporal_rs_ToStringRoundingOptions_HPP +#define temporal_rs_ToStringRoundingOptions_HPP + +#include "ToStringRoundingOptions.d.hpp" + +#include +#include +#include +#include +#include +#include +#include "../diplomat_runtime.hpp" +#include "Precision.hpp" +#include "TemporalRoundingMode.hpp" +#include "TemporalUnit.hpp" + + +namespace temporal_rs { +namespace capi { + extern "C" { + + + } // extern "C" +} // namespace capi +} // namespace + + +inline temporal_rs::capi::ToStringRoundingOptions temporal_rs::ToStringRoundingOptions::AsFFI() const { + return temporal_rs::capi::ToStringRoundingOptions { + /* .precision = */ precision.AsFFI(), + /* .smallest_unit = */ smallest_unit.has_value() ? (temporal_rs::capi::TemporalUnit_option{ { smallest_unit.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalUnit_option{ {}, false }), + /* .rounding_mode = */ rounding_mode.has_value() ? (temporal_rs::capi::TemporalRoundingMode_option{ { rounding_mode.value().AsFFI() }, true }) : (temporal_rs::capi::TemporalRoundingMode_option{ {}, false }), + }; +} + +inline temporal_rs::ToStringRoundingOptions temporal_rs::ToStringRoundingOptions::FromFFI(temporal_rs::capi::ToStringRoundingOptions c_struct) { + return temporal_rs::ToStringRoundingOptions { + /* .precision = */ temporal_rs::Precision::FromFFI(c_struct.precision), + /* .smallest_unit = */ c_struct.smallest_unit.is_ok ? std::optional(temporal_rs::TemporalUnit::FromFFI(c_struct.smallest_unit.ok)) : std::nullopt, + /* .rounding_mode = */ c_struct.rounding_mode.is_ok ? std::optional(temporal_rs::TemporalRoundingMode::FromFFI(c_struct.rounding_mode.ok)) : std::nullopt, + }; +} + + +#endif // temporal_rs_ToStringRoundingOptions_HPP