tsmanner/cpp-gen - Change NYFRUAGKJW5ARRBK2KV74YZOYSI2HS23GBKADEPT6DD6SXON6ROQC

Factored Term and Minterm out of main.cpp, added Build2 external dependency on Catch2.

Created by BZRjFpe4yWcELV5q9m5goQecQ5GyKG6yp24mWXjq2gpf on July 15, 2024

NYFRUAGKJW5ARRBK2KV74YZOYSI2HS23GBKADEPT6DD6SXON6ROQC

Dependencies

In channels

main

Change contents

File addition: tests (d--x------)
[3.1]
File addition: testscript (----------)
[0.17]
```
: tests.out
$* &> /dev/null
```

File addition: test_Term.cpp (----------)

[0.17]

#include "cpp-gen/Term.h"
#include "cpp-gen/Minterm.h"
#include <catch2/catch_test_macros.hpp>
#include <bitset>
#include <limits>
#include <string>
#include <tuple>
// std::get helper
namespace detail {
template <std::size_t, typename>
struct std_get_f;
template <std::size_t _i, typename ..._Ts>
struct std_get_f<_i, std::tuple<_Ts...>> {
  using Function =
    std::tuple_element_t<_i, std::tuple<_Ts...>> const &(std::tuple<_Ts...> const &);
  static constexpr
  auto value =
    static_cast<Function *>(&std::get<_i, _Ts...>);
};
} // namespace detail
template <std::size_t _i, typename _T>
constexpr auto std_get =
  detail::std_get_f<_i, _T>::value;
constexpr
bool isOdd(int const &value) {
  return value & 1;
}
constexpr
bool isEven(int const &value) {
  return !isOdd(value);
}
constexpr
int popCount(int const &value) {
  int result = 0;
  for (std::size_t i = 0; i < std::numeric_limits<int>::digits; ++i) {
    result += (value >> i) & 1;
  }
  return result;
}
TEST_CASE("popCount") {
  CHECK(0 == popCount(0x00));
  CHECK(1 == popCount(0x01));
  CHECK(1 == popCount(0x02));
  CHECK(2 == popCount(0x03));
  CHECK(1 == popCount(0x04));
  CHECK(2 == popCount(0x05));
  CHECK(2 == popCount(0x06));
  CHECK(3 == popCount(0x07));
  CHECK(1 == popCount(0x08));
  CHECK(2 == popCount(0x09));
  CHECK(2 == popCount(0x0A));
  CHECK(3 == popCount(0x0B));
  CHECK(2 == popCount(0x0C));
  CHECK(3 == popCount(0x0D));
  CHECK(3 == popCount(0x0E));
  CHECK(4 == popCount(0x0F));
  CHECK(1 == popCount(0x10));
  CHECK(2 == popCount(0x11));
  CHECK(2 == popCount(0x12));
  CHECK(3 == popCount(0x13));
  CHECK(2 == popCount(0x14));
  CHECK(3 == popCount(0x15));
  CHECK(3 == popCount(0x16));
  CHECK(4 == popCount(0x17));
  CHECK(2 == popCount(0x18));
  CHECK(3 == popCount(0x19));
  CHECK(3 == popCount(0x1A));
  CHECK(4 == popCount(0x1B));
  CHECK(3 == popCount(0x1C));
  CHECK(4 == popCount(0x1D));
  CHECK(4 == popCount(0x1E));
  CHECK(5 == popCount(0x1F));
}
// Foo
struct Foo {
  std::string name;
  int value;
};
// Bar
struct Bar {
  int value;
};
// Aggregate
struct Aggregate {
  Foo foo;
  Bar bar;
};
constexpr
auto aggFooValue =
  Term<&Aggregate::foo, &Foo::value>{};
constexpr
auto aggBarValue =
  Term<&Aggregate::bar, &Bar::value>{};
constexpr
auto fooEqBar =
  aggFooValue == aggBarValue;
// Pair of Foo
using FooFoo = std::pair<Foo, Foo>;
constexpr
auto fooEqFoo =
  Term<&FooFoo::first, &Foo::value>{} == Term<&FooFoo::second, &Foo::value>{};
// Tuple of Foo
using FooFooFoo = std::tuple<Foo, Foo, Foo>;
constexpr
auto fooEqFoo2 =
  Term<std_get<0, FooFooFoo>, &Foo::value>{} == Term<std_get<1, FooFooFoo>, &Foo::value>{};
//
// Constraints
//
TEST_CASE("Term popCount") {
  CHECK(2 == Term<&Aggregate::foo, &Foo::value, popCount>{}({Foo{"foo", 3}, {7}}));
  CHECK_FALSE(Term<&Aggregate::foo, &Foo::value, popCount, isOdd>{}({Foo{"foo", 3}, {7}}));
  CHECK(1 == Term<&Aggregate::foo, &Foo::value, popCount>{}({Foo{"foo", 2}, {7}}));
  CHECK(Term<&Aggregate::foo, &Foo::value, popCount, isOdd>{}({Foo{"foo", 2}, {7}}));
}
TEST_CASE("Minterm") {
  { using MT = Minterm<
      Term<&Foo::value, isOdd>,
      Term<&Foo::value, popCount, isOdd>
    >;
    CHECK(MT({"", 0}).value == std::bitset<2>(0b00));
    CHECK(MT({"", 1}).value == std::bitset<2>(0b11));
    CHECK(MT({"", 2}).value == std::bitset<2>(0b10));
    CHECK(MT({"", 3}).value == std::bitset<2>(0b01));
  }
  { using MT = Minterm<
      Term<&Aggregate::foo, &Foo::value, isOdd>,
      Term<&Aggregate::foo, &Foo::value, popCount, isOdd>,
      Term<&Aggregate::bar, &Bar::value, isEven>,
      Term<&Aggregate::bar, &Bar::value, popCount, isEven>
    >;
    CHECK(MT({Foo{"", 0}, Bar{0}}).value == std::bitset<4>(0b1100));
    CHECK(MT({Foo{"", 0}, Bar{1}}).value == std::bitset<4>(0b0000));
    CHECK(MT({Foo{"", 0}, Bar{2}}).value == std::bitset<4>(0b0100));
    CHECK(MT({Foo{"", 0}, Bar{3}}).value == std::bitset<4>(0b1000));
    CHECK(MT({Foo{"", 1}, Bar{0}}).value == std::bitset<4>(0b1111));
    CHECK(MT({Foo{"", 1}, Bar{1}}).value == std::bitset<4>(0b0011));
    CHECK(MT({Foo{"", 1}, Bar{2}}).value == std::bitset<4>(0b0111));
    CHECK(MT({Foo{"", 1}, Bar{3}}).value == std::bitset<4>(0b1011));
    CHECK(MT({Foo{"", 2}, Bar{0}}).value == std::bitset<4>(0b1110));
    CHECK(MT({Foo{"", 2}, Bar{1}}).value == std::bitset<4>(0b0010));
    CHECK(MT({Foo{"", 2}, Bar{2}}).value == std::bitset<4>(0b0110));
    CHECK(MT({Foo{"", 2}, Bar{3}}).value == std::bitset<4>(0b1010));
    CHECK(MT({Foo{"", 3}, Bar{0}}).value == std::bitset<4>(0b1101));
    CHECK(MT({Foo{"", 3}, Bar{1}}).value == std::bitset<4>(0b0001));
    CHECK(MT({Foo{"", 3}, Bar{2}}).value == std::bitset<4>(0b0101));
    CHECK(MT({Foo{"", 3}, Bar{3}}).value == std::bitset<4>(0b1001));
  }
}
TEST_CASE("Equal") {
  CHECK((Term<popCount>{} == Term<popCount>{})(13));
  Foo foo { "foo", 5 };
  Bar bar { 0 };
  CHECK_FALSE(fooEqBar({foo, bar}));
  CHECK_FALSE(fooEqFoo({foo, Foo{"foo2", 4}}));
  CHECK(fooEqFoo2({Foo{"foo0", 0}, Foo{"foo1", 0}, Foo{"foo2", 0}}));
  bar.value = 5;
  CHECK(fooEqBar({foo, bar}));
  CHECK(fooEqFoo({foo, Foo{"foo2", 5}}));
  CHECK_FALSE(fooEqFoo2({Foo{"foo0", 0}, Foo{"foo1", 1}, Foo{"foo2", 2}}));
}

File deletion: main.cpp

BF:BFD[4.15] → [4.17:49]

BF:BFD[4.49] → [4.50:50]

∅:D[5.18] → [4.51:71]

B:BD[4.50] → [4.51:71]

∅:D[2.18] → [4.71:89]

B:BD[4.71] → [4.71:89]

∅:D[5.59] → [4.89:131]

B:BD[4.89] → [4.89:131]

B:BD[5.1471] → [5.1471:1678]

∅:D[5.1678] → [4.723:724]

B:BD[4.723] → [4.723:724]

∅:D[5.1790] → [6.377:378]

B:BD[6.377] → [6.377:378]

∅:D[5.1892] → [6.468:472]

B:BD[6.468] → [6.468:472]

∅:D[6.472] → [4.807:811]

B:BD[4.807] → [4.807:811]

∅:D[6.495] → [4.1104:1105]

∅:D[5.2121] → [4.1104:1105]

B:BD[4.1104] → [4.1104:1105]

B:BD[4.1105] → [5.2122:2317]

∅:D[5.2317] → [6.496:515]

B:BD[4.1105] → [6.496:515]

∅:D[5.2383] → [4.1230:1234]

B:BD[4.1230] → [4.1230:1234]

B:BD[4.1234] → [5.2384:2406]

∅:D[5.2406] → [4.1234:1235]

B:BD[4.1234] → [4.1234:1235]

∅:D[5.2540] → [6.712:713]

B:BD[6.712] → [6.712:713]

∅:D[7.360] → [5.2573:2594]

B:BD[5.2573] → [5.2573:2594]

B:BD[5.2594] → [7.361:922]

∅:D[7.922] → [6.808:809]

B:BD[4.1361] → [6.808:809]

∅:D[6.1008] → [4.1361:1362]

∅:D[7.1229] → [4.1361:1362]

∅:D[5.2783] → [4.1361:1362]

B:BD[4.1361] → [4.1361:1362]

B:BD[4.1362] → [5.2784:2792]

∅:D[5.2792] → [4.1362:1412]

B:BD[4.1362] → [4.1362:1412]

B:BD[4.1412] → [5.2793:2802]

∅:D[5.2802] → [4.1412:1443]

B:BD[4.1412] → [4.1412:1443]

B:BD[4.1565] → [4.1565:1566]

B:BD[4.1566] → [5.2803:2816]

∅:D[5.2816] → [4.1566:1567]

B:BD[4.1566] → [4.1566:1567]

B:BD[4.1567] → [5.2817:3404]

∅:D[7.1251] → [5.3404:3405]

B:BD[5.3404] → [5.3404:3405]

∅:D[7.1642] → [5.3405:3420]

B:BD[5.3405] → [5.3405:3420]

B:BD[5.3405] → [7.1252:1341]

∅:D[2.370] → [7.1388:1642]

B:BD[7.1388] → [7.1388:1642]

B:BD[7.1341] → [2.209:370]

B:BD[5.3404] → [7.1230:1251]

∅:D[5.3420] → [4.1567:1656]

B:BD[4.1567] → [4.1567:1656]

∅:D[6.1093] → [4.1711:1728]

∅:D[5.3578] → [4.1711:1728]

B:BD[4.1711] → [4.1711:1728]

∅:D[6.1178] → [4.1783:1797]

∅:D[7.2589] → [4.1783:1797]

∅:D[5.3736] → [4.1783:1797]

B:BD[4.1783] → [4.1783:1797]

B:BD[4.1728] → [5.3579:3736]

B:BD[5.3736] → [7.1643:1700]

∅:D[2.407] → [7.1700:1734]

B:BD[7.1700] → [7.1700:1734]

∅:D[2.548] → [7.1823:1827]

B:BD[7.1823] → [7.1823:1827]

B:BD[7.2588] → [7.2588:2589]

B:BD[7.1734] → [2.408:548]

B:BD[7.1700] → [2.371:407]

B:BD[4.1656] → [5.3421:3578]

∅:D[7.1093] → [5.2754:2782]

B:BD[6.809] → [5.2754:2782]

∅:D[7.1160] → [5.2782:2783]

B:BD[5.2782] → [5.2782:2783]

B:BD[5.2783] → [7.1161:1227]

∅:D[2.208] → [7.1227:1229]

B:BD[7.1227] → [7.1227:1229]

B:BD[7.1227] → [2.19:208]

B:BD[5.2782] → [7.1094:1160]

B:BD[6.809] → [7.923:1093]

B:BD[6.713] → [7.28:360]

B:BD[4.1235] → [5.2407:2540]

B:BD[6.515] → [5.2318:2383]

B:BD[4.811] → [5.1893:2121]

B:BD[6.378] → [5.1791:1892]

B:BD[4.724] → [5.1679:1790]

B:BD[4.89] → [5.19:59]

B:BD[4.71] → [2.0:18]

∅:D[7.27] → [5.0:18]

B:BD[4.50] → [5.0:18]

B:BD[4.50] → [7.0:27]

#include <iostream>
#include <string>
template <typename ...>
struct List {};
template <typename _L, typename _R>
struct Equal {
 static_assert(std::is_same_v<typename _L::Operand, typename _R::Operand>);
  using Operand = std::decay_t<typename _L::Operand>;
  using Result = bool;
  }
};
template <std::size_t _i, typename ..._Ts>
struct std_get_f<_i, std::tuple<_Ts...>> {
  using Function =
    std::tuple_element_t<_i, std::tuple<_Ts...>> const &(*)(std::tuple<_Ts...> const &);
  static constexpr
};
} // namespace detail
struct Constraints {
  static_assert(
    (std::is_same_v<bool, typename std::decay_t<_Terms>::Result> && ...),
    "All Constraints must have a Result type of bool"
  );
  using Operand = detail::Operand<_Terms...>;
  using Minterm = std::bitset<sizeof...(_Terms)>;
  template <std::size_t _bit, typename _Head, typename ..._Tail>
  constexpr
  void populate(Minterm &minterm, Operand const &operand, List<_Head, _Tail...>) const {
    minterm[_bit] = _Head{}(operand);
    if constexpr (sizeof...(_Tail)) {
      populate<_bit + 1>(minterm, operand, List<_Tail...>{});
    }
  }
// Foo
struct Foo {
  std::string name;
  int value;
};
// Bar
struct Bar {
  int value;
};
// Aggregate
struct Aggregate {
  Foo foo;
  Bar bar;
};
constexpr
auto aggFooValue =
  Term<&Aggregate::foo, &Foo::value>{};
constexpr
auto aggBarValue =
  Term<&Aggregate::bar, &Bar::value>{};
constexpr
auto fooEqBar =
  aggFooValue == aggBarValue;
// Pair of Foo
using FooFoo = std::pair<Foo, Foo>;
constexpr
auto fooEqFoo =
  Term<&FooFoo::first, &Foo::value>{} == Term<&FooFoo::second, &Foo::value>{};
// Tuple of Foo
using FooFooFoo = std::tuple<Foo, Foo, Foo>;
constexpr
auto fooEqFoo2 =
  Term<std_get<0, FooFooFoo>, &Foo::value>{} == Term<std_get<1, FooFooFoo>, &Foo::value>{};
//
// Main
//
constexpr
auto fooBarOdd =
  Constraints<
    Term<&Aggregate::foo, &Foo::value, isOdd>,
  >{};
//
// Assertions
//
template <typename _Term>
struct TermClosure {
  _Term term;
  typename _Term::Operand operand;
};
template <typename ..._Terms>
bool check(_Terms &&...terms) {
  return (std::get<0>(terms)(std::get<1>(terms)) && ...);
}
    Term<&Aggregate::foo, &Foo::value, popcount, isOdd>,
    Term<&Aggregate::bar, &Bar::value, isEven>,
    Term<&Aggregate::bar, &Bar::value, popcount, isOdd>
//
// Constraints
//
int main () {
  std::cout << "Hello, world!\n";
  Foo foo { "foo", 5 };
  Bar bar { 0 };
  bar.value = 5;
  return 0;
}
  std::cout << fooEqBar({foo, bar}) << ' ' << fooEqFoo({foo, Foo{"foo2", 5}}) << ' ' << fooEqFoo2({Foo{"foo0", 0}, Foo{"foo1", 1}, Foo{"foo2", 2}}) << '\n';
  std::cout << Term<&Foo::value, isOdd>{}(foo) << '\n';
  for (int i = 0; i < 10; ++i) {
  }
    std::cout << i << ":  " << fooBarOdd(Aggregate{Foo{"foo", i}, Bar{i >> 1}}) << ' ' << popcount(i) << ' ' << isOdd(popcount(i)) << '\n';
  std::cout << popcount(4) << '\n';
  std::cout << fooEqBar({foo, bar}) << ' ' << fooEqFoo({foo, Foo{"foo2", 4}}) << ' ' << fooEqFoo2({Foo{"foo0", 0}, Foo{"foo1", 0}, Foo{"foo2", 0}}) << '\n';
//
//
// Userland!
//
//
constexpr
bool isEven(int const &value) {
  return !isOdd(value);
}
}
constexpr
int popcount(int const &value) {
  int result = 0;
  for (std::size_t i = 0; i < std::numeric_limits<int>::digits; ++i) {
    result += (value >> i) & 1;
  }
  return result;
constexpr
bool isOdd(int const &value) {
  return value & 1;
}
  constexpr
  Minterm operator()(Operand const &operand) const {
    Minterm minterm {};
    populate<0>(minterm, operand, List<_Terms...>{});
    return minterm;
  }
};
namespace detail {
template <typename ..._Terms> struct operand_f;
template <typename ..._Terms> using Operand = typename operand_f<_Terms...>::value;
template <typename _Head, typename ..._Tail>
struct operand_f<_Head, _Tail...> {
  using value = typename _Head::Operand;
};
} // namespace detail
template <typename ..._Terms>
template <std::size_t _i, typename _T>
constexpr auto std_get =
  detail::std_get_f<_i, _T>::value;
//
// A list of constraints
//
  auto value =
    static_cast<Function>(&std::get<_i, _Ts...>);
template <auto ..._l, auto ..._r>
constexpr
Equal<Term<_l ...>, Term<_r ...>> operator==(Term<_l ...>, Term<_r ...>) {
  return {};
}
// std::get helper
namespace detail {
template <std::size_t, typename>
struct std_get_f;
  constexpr
  Result operator()(Operand &operand) const {
    return _L{}(operand) == _R{}(operand);
  constexpr
  Result operator()(Operand const &operand) const {
    return _L{}(operand) == _R{}(operand);
  }
#include <tuple>
#include <type_traits>
#include <limits>
#include <bitset>
#include "cpp-gen/Term.h"

File addition: repositories.manifest (----------)

[3.1]

: 1
summary: cpp-gen project repository
:
role: prerequisite
location: https://pkg.cppget.org/1/stable
trust: 70:64:FE:E4:E0:F3:60:F1:B4:51:E1:FA:12:5C:E0:B3:DB:DF:96:33:39:B9:2E:E5:C2:68:63:4C:A6:47:39:43

Insertion in manifest at line 9 [7.2623]
[7.2752]
```
depends: catch2 ^ 3.3.2
```

Insertion in include/cpp-gen/Term.h at line 63 [7.2805]

[7.4250]

  }
};
//
// Equality compare
//
template <typename _L, typename _R>
struct Equal {
 static_assert(std::is_same_v<typename _L::Operand, typename _R::Operand>);
  using Operand = std::decay_t<typename _L::Operand>;
  using Result = bool;
  constexpr
  Result operator()(Operand const &operand) const {
    return _L{}(operand) == _R{}(operand);
  }
  constexpr
  Result operator()(Operand &operand) const {
    return _L{}(operand) == _R{}(operand);

Insertion in include/cpp-gen/Term.h at line 88 [7.2805]

[7.4257]


template <auto ..._l, auto ..._r>
constexpr
Equal<Term<_l ...>, Term<_r ...>> operator==(Term<_l ...>, Term<_r ...>) {
  return {};
}

File addition: Minterm.h (----------)

[7.2772]

#pragma once
#include <bitset>
#include <type_traits>
namespace detail {
template <typename ...>
struct List {};
template <typename ..._Terms> struct head_f;
template <typename ..._Terms> using Head = typename head_f<_Terms...>::value;
template <typename _Head, typename ..._Tail>
struct head_f<_Head, _Tail...> {
  using value = _Head;
};
} // namespace detail
template <typename ..._Terms>
struct Minterm {
  static_assert(
    (std::is_same_v<bool, typename _Terms::Result> && ...),
    "All Minterm Terms must have a Result type of bool"
  );
  using Operand = typename detail::Head<_Terms...>::Operand;
  using Value = std::bitset<sizeof...(_Terms)>;
  Value value;
  constexpr
  Minterm(Operand const &operand) {
    populate<0>(value, operand, detail::List<_Terms...>{});
  }
  template <std::size_t _bit, typename _Head, typename ..._Tail>
  constexpr
  void populate(Value &minterm, Operand const &operand, detail::List<_Head, _Tail...>) const {
    minterm[_bit] = _Head{}(operand);
    if constexpr (sizeof...(_Tail)) {
      populate<_bit + 1>(minterm, operand, detail::List<_Tail...>{});
    }
  }
};

Insertion in buildfile at line 1 [7.4292]
[7.4292]
[7.4293]
```
import libs += catch2%liba{catch2wmain}
```

Replacement in buildfile at line 8 [7.4292]

B:BD[7.4378] → [7.4378:4436]

exe{main} : cxx{src/main.cpp} hxx{include/cpp-gen/Term.h}

[7.4378]

headers += hxx{include/cpp-gen/Term.h}
headers += hxx{include/cpp-gen/Minterm.h}
exe{tests.out} : cxx{tests/test_Term.cpp} $headers testscript{tests/testscript} $libs
test.target = $cxx.target

File addition: build (d--x------)
[3.1]

File addition: bootstrap.build (----------)

[0.7644]

project = cpp-gen
using version
using config
using test

File addition: .ignore (----------)
[0.7644]
```
/config.build
/root/
/bootstrap/
build/
```
Insertion in .ignore at line 3 [4.1924]
[4.1971]
[4.1971]
```
.gitignore
```
Replacement in .ignore at line 13 [4.1924]
∅:D[7.4447] → [4.2052:2057]
B:BD[4.2052] → [4.2052:2057]
```
main
```
[7.4447]
```
# Build2
.bdep/
```

Factored Term and Minterm out of main.cpp, added Build2 external dependency on Catch2.

Dependencies

In channels

Change contents

File addition: tests (d--x------)

File addition: testscript (----------)

File addition: test_Term.cpp (----------)

File deletion: main.cpp

File addition: repositories.manifest (----------)

Insertion in manifest at line 9 [7.2623]

Insertion in include/cpp-gen/Term.h at line 63 [7.2805]

Insertion in include/cpp-gen/Term.h at line 88 [7.2805]

File addition: Minterm.h (----------)

Insertion in buildfile at line 1 [7.4292]

Replacement in buildfile at line 8 [7.4292]

File addition: build (d--x------)

File addition: bootstrap.build (----------)

File addition: .ignore (----------)

Insertion in .ignore at line 3 [4.1924]

Replacement in .ignore at line 13 [4.1924]