Draft C++ wrapper to TigerBeetle database

client.cpp

#include "tb_client.hpp"

int main() {
  tb::Client client("localhost", 8080);

  tb::Account account({0, 0, {0}, 1, 1, TB_ACCOUNT_LINKED, 0, 0, 0, 0, 0});
  tb::create_account_result result = client.create_account(account);
  if (result != TB_CREATE_ACCOUNT_OK) {
    // Handle error
  }

  tb::Transfer transfer({0, account.id(), account.id(), 0, 0, 0, 0, 1, 1, TB_TRANSFER_LINKED, 1, 0});
  tb::create_transfer_result result = client.create_transfer(transfer);
  if (result != TB_CREATE_TRANSFER_OK) {
    // Handle error
  }
}

tb_client.hpp

// https://github.com/tigerbeetledb/tigerbeetle/blob/main/src/clients/c/tb_client.h
#include "tb_client.h"
#include <string>
#include <vector>
#include <cstring>
#include <sstream>
#include <cstdlib>

namespace tb {

class Account {
 public:
  Account(tb_account_t account) : account_(account) {}

  tb_uint128_t id() const { return account_.id; }
  tb_uint128_t user_data() const { return account_.user_data; }
  uint32_t ledger() const { return account_.ledger; }
  uint16_t code() const { return account_.code; }
  uint16_t flags() const { return account_.flags; }
  uint64_t debits_pending() const { return account_.debits_pending; }
  uint64_t debits_posted() const { return account_.debits_posted; }
  uint64_t credits_pending() const { return account_.credits_pending; }
  uint64_t credits_posted() const { return account_.credits_posted; }
  uint64_t timestamp() const { return account_.timestamp; }

 private:
  tb_account_t account_;
};

class Transfer {
 public:
  Transfer(tb_transfer_t transfer) : transfer_(transfer) {}

  tb_uint128_t id() const { return transfer_.id; }
  tb_uint128_t debit_account_id() const { return transfer_.debit_account_id; }
  tb_uint128_t credit_account_id() const { return transfer_.credit_account_id; }
  tb_uint128_t user_data() const { return transfer_.user_data; }
  tb_uint128_t pending_id() const { return transfer_.pending_id; }
  uint64_t timeout() const { return transfer_.timeout; }
  uint32_t ledger() const { return transfer_.ledger; }
  uint16_t code() const { return transfer_.code; }
  uint16_t flags() const { return transfer_.flags; }
  uint64_t amount() const { return transfer_.amount; }
  uint64_t timestamp() const { return transfer_.timestamp; }

 private:
  tb_transfer_t transfer_;
};

class Client {
 public:
  Client(std::string host, uint16_t port)
      : host_(std::move(host)), port_(port) {}

  std::vector<Account> get_accounts();
  std::vector<Transfer> get_transfers();
  tb_create_account_result create_account(Account& account);
  tb_create_transfer_result create_transfer(Transfer& transfer);
  tb_void_result void_transfer(tb_uint128_t transfer_id);

 private:
 void tb_free(void* ptr) {
  std::free(ptr);
}
  std::string host_;
  uint16_t port_;
};

std::vector<Account> Client::get_accounts() {
  tb_account_t* accounts = nullptr;
  size_t num_accounts = 0;
  tb_get_accounts(host_.c_str(), port_, &accounts, &num_accounts);

  std::vector<Account> result;
  result.reserve(num_accounts);
  for (size_t i = 0; i < num_accounts; ++i) {
    result.emplace_back(accounts[i]);
  }

  tb_free(accounts);
  return result;
}

std::vector<Transfer> Client::get_transfers() {
  tb_transfer_t* transfers = nullptr;
  size_t num_transfers = 0;
  tb_get_transfers(host_.c_str(), port_, &transfers, &num_transfers);

  std::vector<Transfer> result;
  result.reserve(num_transfers);
  for (size_t i = 0; i < num_transfers; ++i) {
    result.emplace_back(transfers[i]);
  }

  tb_free(transfers);
  return result;
}

tb_create_account_result Client::create_account(Account& account) {
  tb_account_t account_struct = account.account_;
  return tb_create_account(host_.c_str(), port_, &account_struct);
}

tb_create_transfer_result Client::create_transfer(Transfer& transfer) {
  tb_transfer_t transfer_struct = transfer.transfer_;
  return tb_create_transfer(host_.c_str(), port_, &transfer_struct);
}

tb_void_result Client::void_transfer(tb_uint128_t transfer_id) {
  return tb_void_transfer(host_.c_str(), port_, transfer_id);
}

}  // namespace tb