Deckard - Utility Modules

1. in your CMakelists.txt add:

include(FetchContent)
FetchContent_Declare(
  Deckard
  GIT_REPOSITORY https://github.com/Masfo/Deckard.git
  GIT_TAG main
)
FetchContent_MakeAvailable(Deckard)

target_link_libraries(${CMAKE_PROJECT_NAME} Deckard)

Modules:

• namespace

  // Everything is under deckard namespace
  using namespace deckard;

• Debug / Assert

  import deckard;
  
  dbg::trace("Hello {}", "World"); // winmain.cpp(15): Hello World
  dbg::println("Similar to trace");  // Similar to trace
  dbg::print("Like dbgln but ");     // 
  dbg::print("w/o newline\n");       // Like dbgln but w/o newline 
  
  dbg::panic("reason");	
  
  assert::check(1==2, "Wrong");
  

• Basic types

  import deckard;
  
  // integers: i8,u8,i16,u16,i32,u32,i64,u64
  - // floats: f32, f64
  
  u8 u  = 64_u8;
  i64 i = 112233_i64;
  
  // auto value = as<To>(From)
  f32 X = 128.0f;
  auto  u = as<i8>(X);
  //  :Unable to cast '128' safely. Target range is -128...127, casting to '-128'
  
  f32 X = 128.0f;
  auto  u = as<u16>(X);  // No warning, value fits
  
  auto value = as<u32>(256);

• UTF-8 string

• enums

• Result

  // Default error is std::string
  Ok(<value>);
  Err("error value");
  
  // Return value or error
  auto getex(int x) -> Result<int>
  {
  	if (x == 10)
  		return Ok(x); 
  	else
  		return Err("bad int {}", x);
  }
  
  if (auto v = getex(100); v)
  {
  	dbg::trace("int {}", *v);
  }

• Fileview

  import deckard;
  
  Fileview f;
  f.open("dice.qoi", FileAccess::ReadWrite);
  
  f[f.size()-1] = 0x01;

• Base64

  import deckard.base64;
  
  // Encode
  std::string encode(const std::span<const u8> input)
  std::string encode_str(std::string_view input)
  
  // Decode
  std::optional<std::vector<u8>> decode(std::string_view encoded_input)
  std::string decode_str(std::string_view encoded_input)
  
  // example:
  std::array<byte, 4> buff{'Z', 'E', 'U', 'S'};
  
  auto encoded_base64 = utils::base64::encode(buff); // WkVVUw==
  auto decoded_base64 = utils::base64::decode(encoded_base64); // Optional vector with original data

• SHA256

  import deckard.sha;
  
  using namespace deckard;
  sha256::hasher hasher256;
  hasher256.update("abc");
  auto digest = hasher256.finalize().to_string();
  // digest = "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"
  
  
  sha512::hasher hasher512;
  hasher512.update("abc");
  auto digest = hasher512.finalize().to_string();
  // digest = "ddaf35a193617abacc417349ae20...d454d4423643ce80e2a9ac94fa54ca49f"

• ZSTD

  import deckard.zstd;
  
  using namespace deckard;
  std::vector<u8> buffer;
  buffer.resize(1'024);
  std::ranges::fill(buffer, 'X');
  
  // Compress
  std::vector<u8> comp;
  comp.resize(zstd::bound(buffer));
  auto ok = zstd::compress(buffer, comp);
  if (!ok)
  {
  	dbg::println("Failed to compress");
  }
  else
  	comp.resize(*ok);
  
  
  // Uncompress
  std::vector<u8> uncomp;
  uncomp.resize(buffer.size());
  ok = zstd::uncompress(comp, uncomp);
  if (!ok)
  	dbg::println("Failed to uncompress");
  else
  {
  	auto kss = *ok;
  	uncomp.resize(*ok);
  }

• Serialization

  // TODO

  • Big integer

  // operators: + - * / %
  // functions: pow sqrt abs gcd lcm random_range popcount
  // bitwise ops: & | ^ ~ (and or xor not)
  // comparison: == != < > <= >=
  // conversion: to_string to_integer
  
  import deckard.bigint;
  using namespace deckard;
  
  bigint p(6);
  bigint q(7);
  
  assert::check(p + q == bigint{13}, "add");
  assert::check(p - q == bigint{-1}, "subtract");
  assert::check(p * q == bigint{42}, "multiply");
  assert::check((p * q) / q == p, "divide");
  assert::check(((p * q) % (p + q)) == bigint{3}, "mod");
  assert::check((p ^ q) == bigint{279'936}, "power");
  
  
  p = "641352894770715802787901901705773890848250147429434472081168596"
  	"32024532344630238623598752668347708737661925585694639798853367";
  
  q = "333720275949781565562260106053551142279407603447675546667845209"
  	"87023841729210037080257448673296881877565718986258036932062711";
  
  bigint n = p * q;
  
  bigint rsa250(
    "214032465024074496126442307283933356300861471514475501779775492088141
    "802344714013664334551909580467961099285187247091458768739626192155736
    "304745477052080511905649310668769159001975940569345745223058932597669
    "7471681738069364894699871578494975937497937");
  
  assert::check(n == rsa250, "RSA250 calculation is wrong");
  
  assert::check(sqrt(bigint(9)) == bigint(3), "sqrt");
  assert::check(abs(bigint(-9)) == bigint(9), "abs");
  assert::check(mod(bigint(42), bigint(13)) == bigint(3), "mod");
  assert::check(pow(bigint(6), bigint(7)) == bigint(279'936), "pow");
  assert::check(gcd(bigint(68), bigint(42)) == bigint(2), "gcd");
  assert::check(lcm(bigint(68), bigint(42)) == bigint(1428), "lcm");
  
  assert::check(bigint(42).to_string() == "42");
  assert::check(bigint("42").to_integer<u32>() == 42);
  
  auto rnd = random_bigint(42); // 42 digit (base 10) random number
  
  rnd.to_string(16, true);      // base 16, uppercase
  rnd.to_string(24, false);     // base 24, lowercase
  
  std::format("{}", rnd);       // base 10
  std::format("{:x}", rnd);     // base 16 (:x, :X, :h, :H)
  std::format("{:b2}", rnd);    // base 2
  std::format("{:B36}", rnd);   // base 36