Trivial Currency Tags

- trivially copyable
- lightweight
- implicitly constructible from `string_view`

Author: teensp1rit

cdr/swaps/irs.cc

@@ -78,7 +78,7 @@ void IrsContract::ApplyCurve(const Curve& curve) noexcept {
 
 /* IrsBuilder */
 
-[[nodiscard]] IrsContract IrsBuilder::Build(const HolidayStorage& hs, const JurisdictionType& jur, DateRollingRule rule) {
+[[nodiscard]] IrsContract IrsBuilder::Build(const HolidayStorage& hs, JurisdictionType jur, DateRollingRule rule) {
 
     CDR_CHECK(maturity_date_.has_value()) << "must be defined";
     CDR_CHECK(settlement_date_.has_value()) << "must be defined";
@@ -88,10 +88,9 @@ void IrsContract::ApplyCurve(const Curve& curve) noexcept {
     CDR_CHECK(paying_fix_.has_value()) << "must be defined";
     CDR_CHECK(fixed_freq_.has_value()) << "must be defined";
     CDR_CHECK(float_freq_.has_value()) << "must be defined";
-    CDR_CHECK(!jur.empty()) << "must be non-empty";
 
     static constexpr u32 kRandomReservationConstant = 10;
-    IrsContract result(fixed_rate_.value(), paying_fix_.value());
+    IrsContract result(jur, fixed_rate_.value(), paying_fix_.value());
 
     std::vector<IrsPaymentPeriod> sched;
     sched.reserve(kRandomReservationConstant);
@@ -159,7 +158,6 @@ void IrsContract::ApplyCurve(const Curve& curve) noexcept {
         sched[last].chrono_next_idx_ = curr;
     }
 
-    result.jurisdiction_ = jur;
     result.chrono_last_idx_ = last;
     result.notional_ = *notional_;
     result.payment_periods_ = std::move(sched);
@@ -184,7 +182,7 @@ void IrsBuilder::Reset() {
 
 /* IrsBuilderExperimental */
 
-[[nodiscard]] IrsContract IrsBuilderExperimental::Build(const HolidayStorage& hs, const JurisdictionType& jur, DateRollingRule rule) {
+[[nodiscard]] IrsContract IrsBuilderExperimental::Build(const HolidayStorage& hs, JurisdictionType jur, DateRollingRule rule) {
 
     CDR_CHECK(trade_date_.has_value()) << "must be defined";
     CDR_CHECK(start_shift_.has_value()) << "must be defined";
@@ -197,12 +195,11 @@ void IrsBuilder::Reset() {
     CDR_CHECK(adjustment_.has_value()) << "must be defined";
     CDR_CHECK(notional_.has_value()) << "must be defined";
     CDR_CHECK(paying_fix_.has_value()) << "must be defined";
-    CDR_CHECK(!jur.empty()) << "must be non-empty";
 
     CDR_CHECK(fixed_freq_->number > 0) << "must be positive";
     CDR_CHECK(float_freq_->number > 0) << "must be positive";
 
-    IrsContract result(fixed_rate_.value_or(Percent::Zero()), *paying_fix_);
+    IrsContract result(jur, fixed_rate_.value_or(Percent::Zero()), *paying_fix_);
     std::vector<IrsPaymentPeriod> sched;
 
     // --------- fixed leg ------------
@@ -271,7 +268,6 @@ void IrsBuilder::Reset() {
 
     // -------------------------------
 
-    result.jurisdiction_ = jur;
     result.payment_periods_ = std::move(sched);
     result.fixed_leg_ = result.payment_periods_.data();
     result.float_leg_ = result.payment_periods_.data() + float_begin;

cdr/swaps/irs.h

@@ -121,8 +121,9 @@ class CDR_SWAPS_EXPORT IrsContract final {
 
 private:
 
-    IrsContract(Percent fixed_rate, bool paying_fix)
-        : fixed_rate_(fixed_rate)
+    IrsContract(JurisdictionType jurisdiction, Percent fixed_rate, bool paying_fix)
+        : jurisdiction_(jurisdiction)
+        , fixed_rate_(fixed_rate)
         , paying_fix_(paying_fix)
     {}
 
@@ -194,7 +195,7 @@ class CDR_SWAPS_EXPORT IrsBuilder final {
         return *this;
     }
 
-    [[nodiscard]] IrsContract Build(const HolidayStorage& hs, const std::string& jur,
+    [[nodiscard]] IrsContract Build(const HolidayStorage& hs, JurisdictionType jur,
                                     DateRollingRule rule = DateRollingRule::kFollowing);
 
     void Reset();
@@ -273,7 +274,7 @@ class CDR_SWAPS_EXPORT IrsBuilderExperimental {
         return *this;
     }
 
-    [[nodiscard]] IrsContract Build(const HolidayStorage& hs, const std::string& jur,
+    [[nodiscard]] IrsContract Build(const HolidayStorage& hs, JurisdictionType jur,
                                     DateRollingRule rule = DateRollingRule::kFollowing);
 
     void Reset();

cdr/types/jurisdiction.h

@@ -1,6 +1,67 @@
 #pragma once
 
-#include <string>
+#include <cdr/types/types.h>
+#include <cdr/base/check.h>
+
+#include <algorithm>
+#include <bit>
+#include <string_view>
+#include <ostream>
+#include <charconv>
+#include <cstring>
+#include <iostream>
+
+namespace stdr = std::ranges;
+
+class CurrencyTag {
+public:
+    // implicit
+    constexpr CurrencyTag(const char* str) noexcept: data_{} {
+        size_t str_size = std::char_traits<char>::length(str);
+
+        // NOTE: CDR_CHECK is not constexpr
+        if (str_size >= 8) [[unlikely]] {
+            std::cerr << "Fatal: currency tag too long: " << str << std::endl;
+            std::terminate();
+        }
+        stdr::copy_n(str, str_size, data_);
+    }
+
+    constexpr std::string_view Str() const noexcept {
+        return data_;
+    }
+
+    constexpr bool operator==(CurrencyTag other) const noexcept {
+        return stdr::equal(data_, other.data_);
+    }
+
+    constexpr bool operator<(CurrencyTag other) const noexcept {
+        return std::bit_cast<u64>(*this) < std::bit_cast<u64>(other);
+    }
+
+private:
+    alignas(8) char data_[8];
+};
+
+inline std::ostream& operator<<(std::ostream& os, CurrencyTag tag) {
+    return os << tag.Str();
+}
+
+namespace std {
+
+template <>
+struct hash<CurrencyTag> {
+    hash<u64> hashfunc_;
+    u64 operator()(CurrencyTag tag) const noexcept {
+        return hashfunc_(std::bit_cast<u64>(tag));
+    }
+};
+
+}  // namespace std
+
+
+static_assert(sizeof(std::hash<CurrencyTag>) == 1);
+static_assert(sizeof(CurrencyTag) == 8);
+static_assert(std::is_trivially_copyable_v<CurrencyTag>);
 
-using CurrencyTag = std::string;
 using JurisdictionType = CurrencyTag;