tsmanner/cpp-gen - Change 7OON6I5DETIRCQ24MOUVJ5QWQIMPTNP2PCRAA3BFOUMZ3I6PZOKQC

Started structuring the project code a little. First pass at creating a minterm from a list of constraints.

Created by BZRjFpe4yWcELV5q9m5goQecQ5GyKG6yp24mWXjq2gpf on July 10, 2024

7OON6I5DETIRCQ24MOUVJ5QWQIMPTNP2PCRAA3BFOUMZ3I6PZOKQC

Dependencies

In channels

main

Change contents

File deletion: buildfile
BF:BFD[3.15] → [3.1798:1831]
BF:BFD[3.1831] → [3.1832:1832]
B:BD[3.1832] → [3.1833:1870]
```
using cxx
exe{main} : cxx{main.cpp}
```
Insertion in src/main.cpp at line 1 [3.50]
[3.50]
[2.0]
```
#include "cpp-gen/Term.h"
```

Deletion in src/main.cpp at line 12 [3.50]

B:BD[3.441] → [3.441:443]

B:BD[3.443] → [2.60:80]

∅:D[2.80] → [3.459:473]

B:BD[3.459] → [3.459:473]

B:BD[3.473] → [2.81:182]

∅:D[2.182] → [3.526:548]

B:BD[3.526] → [3.526:548]

B:BD[3.548] → [2.183:358]

∅:D[2.358] → [4.22:23]

B:BD[4.22] → [4.22:23]

B:BD[4.23] → [2.359:557]

∅:D[2.557] → [4.112:116]

B:BD[4.112] → [4.112:116]

∅:D[4.116] → [3.548:552]

B:BD[3.548] → [3.548:552]

B:BD[3.552] → [2.558:744]

∅:D[2.744] → [4.139:140]

B:BD[4.139] → [4.139:140]

B:BD[4.140] → [2.745:948]

∅:D[2.948] → [4.228:232]

B:BD[4.228] → [4.228:232]

∅:D[4.232] → [3.631:635]

B:BD[3.631] → [3.631:635]

B:BD[3.635] → [2.949:1221]

∅:D[2.1221] → [4.255:256]

B:BD[4.255] → [4.255:256]

B:BD[4.256] → [2.1222:1469]

∅:D[2.1469] → [4.350:354]

B:BD[4.350] → [4.350:354]

∅:D[4.354] → [3.720:723]

B:BD[3.720] → [3.720:723]

B:BD[3.723] → [2.1470:1471]


template <auto ...>
struct Term;
// Single item: field (member or method) of _T.
template <typename _T, typename _R, _R(_T::*_field)>
struct Term<_field> {
  using Operand = std::decay_t<_T>;
  using Result = std::decay_t<std::conditional_t<
    std::is_function_v<_R>,
    std::invoke_result_t<decltype(_field), _T>,
    _R
  >>;
  constexpr
  Result const &operator()(Operand const &operand) const {
    if constexpr (std::is_function_v<_R>) {
      return (operand.*_field)();
    } else {
      return operand.*_field;
    }
  }
};
// Single item: function of _T.
template <typename _T, typename _R, _R(*_function)(_T &)>
struct Term<_function> {
  using Operand = std::decay_t<_T>;
  using Result = std::decay_t<_R>;
  constexpr
  Result const &operator()(Operand const &operand) const {
    return _function(operand);
  }
  constexpr
  Result const &operator()(Operand &operand) const {
    return _function(operand);
  }
};
// Multiple items: recursively forward the result of the first term to the remaining ones.
template <auto _head, auto ..._tail>
struct Term<_head, _tail...> {
  using Operand = std::decay_t<typename Term<_head>::Operand>;
  using Result = typename Term<_tail...>::Result;
  constexpr
  Result const &operator()(Operand const &operand) const {
    return Term<_tail...>{}(Term<_head>{}(operand));
  }
  constexpr
  Result const &operator()(Operand &operand) const {
    return Term<_tail...>{}(Term<_head>{}(operand));
  }
};

Replacement in src/main.cpp at line 68 [3.50]

B:BD[4.713] → [2.2541:2573]

template <auto ..._constraints>

[4.713]

[2.2573]

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>

Replacement in src/main.cpp at line 82 [3.50]

B:BD[2.2594] → [2.2594:2753]

∅:D[2.2753] → [3.1358:1361]

B:BD[3.1358] → [3.1358:1361]

  static_assert((std::is_same_v<bool, typename std::decay_t<decltype(_constraints)>::Result> && ...));
  using Minterm = std::bitset<sizeof...(_constraints)>;
};

[2.2594]

[4.808]

  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...>{});
    }
  }

Insertion in src/main.cpp at line 98 [3.50]

[4.809]

[2.2754]

  constexpr
  Minterm operator()(Operand const &operand) const {
    Minterm minterm {};
    populate<0>(minterm, operand, List<_Terms...>{});
    return minterm;
  }
};

Insertion in src/main.cpp at line 113 [3.50]

[2.2782]


constexpr
bool isOdd(int const &value) {
  return value & 1;
}

Insertion in src/main.cpp at line 121 [3.50]

[2.2783]

[3.1361]

constexpr
bool isEven(int const &value) {
  return !isOdd(value);
}

Insertion in src/main.cpp at line 180 [3.50]
[2.3404]
[2.3404]
```
//
// Constraints
//
```

Insertion in src/main.cpp at line 184 [3.50]

[2.3405]

constexpr
auto fooBarOdd =
  Constraints<
    Term<&Aggregate::foo, &Foo::value, isOdd>,
    Term<&Aggregate::bar, &Bar::value, isEven>
  >{};
//
// 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)) && ...);
}

Insertion in src/main.cpp at line 219 [3.50]

[2.3736]

[3.1783]


  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}}) << '\n';
  }
  std::cout << check(
    std::make_tuple(Term<&Foo::value, isEven>{}, Foo{"foo",  0}),
    std::make_tuple(Term<&Foo::value, isOdd >{}, Foo{"foo",  1}),
    std::make_tuple(Term<&Foo::value, isEven>{}, Foo{"foo",  2}),
    std::make_tuple(Term<&Foo::value, isOdd >{}, Foo{"foo",  3}),
    std::make_tuple(Term<&Foo::value, isEven>{}, Foo{"foo",  4}),
    std::make_tuple(Term<&Foo::value, isOdd >{}, Foo{"foo",  5}),
    std::make_tuple(Term<&Foo::value, isEven>{}, Foo{"foo",  6}),
    std::make_tuple(Term<&Foo::value, isOdd >{}, Foo{"foo",  7}),
    std::make_tuple(Term<&Foo::value, isEven>{}, Foo{"foo",  8}),
    std::make_tuple(Term<&Foo::value, isOdd >{}, Foo{"foo",  9}),
    std::make_tuple(Term<&Foo::value, isEven>{}, Foo{"foo", 10})
  ) << '\n';

File addition: manifest (----------)

[5.1]

: 1
name: cpp-gen
version: 0.0.1
summary: C++ constraint based generator.
type: exe
language: c++
project: cpp-gen
license: MIT

File addition: cpp-gen (d--x------)
[3.1890]

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

[0.2772]

#pragma once
#include <type_traits>
template <auto ...>
struct Term;
// Single item: field (member or method) of _T.
template <typename _T, typename _R, _R(_T::*_field)>
struct Term<_field> {
  using Operand = std::decay_t<_T>;
  using Result = std::conditional_t<
    std::is_function_v<_R>,
    std::invoke_result_t<decltype(_field), _T>,
    _R const &
  >;
  constexpr
  Result operator()(Operand const &operand) const {
    if constexpr (std::is_function_v<_R>) {
      return (operand.*_field)();
    } else {
      return operand.*_field;
    }
  }
};
// Single item: function of _T.
template <typename _T, typename _R, _R(*_function)(_T &)>
struct Term<_function> {
  using Operand = std::decay_t<_T>;
  using Result = _R;
  constexpr
  Result operator()(Operand const &operand) const {
    return _function(operand);
  }
  constexpr
  Result operator()(Operand &operand) const {
    return _function(operand);
  }
};
// Multiple items: recursively forward the result of the first term to the remaining ones.
template <auto _head, auto ..._tail>
struct Term<_head, _tail...> {
  using Operand = std::decay_t<typename Term<_head>::Operand>;
  using Result = typename Term<_tail...>::Result;
  constexpr
  Result operator()(Operand const &operand) const {
    return Term<_tail...>{}(Term<_head>{}(operand));
  }
  constexpr
  Result operator()(Operand &operand) const {
    return Term<_tail...>{}(Term<_head>{}(operand));
  }
};

File addition: buildfile (----------)

[5.1]

using cxx
cxx.poptions += "-I$src_root/include/"
cxx.coptions += "-Wall" "-Werror"
exe{main} : cxx{src/main.cpp} hxx{include/cpp-gen/Term.h}

Deletion in .ignore at line 5 [3.1924]
B:BD[3.1989] → [3.1989:1996]
```
build/
```
Replacement in .ignore at line 9 [3.1924]
B:BD[3.2043] → [3.2043:2048]
```
*.so
```
[3.2043]
[3.2048]
```
*.d
```
Insertion in .ignore at line 11 [3.1924]
[3.2052]
[3.2052]
```
*.so
```

Started structuring the project code a little. First pass at creating a minterm from a list of constraints.

Dependencies

In channels

Change contents

File deletion: buildfile

Insertion in src/main.cpp at line 1 [3.50]

Deletion in src/main.cpp at line 12 [3.50]

Replacement in src/main.cpp at line 68 [3.50]

Replacement in src/main.cpp at line 82 [3.50]

Insertion in src/main.cpp at line 98 [3.50]

Insertion in src/main.cpp at line 113 [3.50]

Insertion in src/main.cpp at line 121 [3.50]

Insertion in src/main.cpp at line 180 [3.50]

Insertion in src/main.cpp at line 184 [3.50]

Insertion in src/main.cpp at line 219 [3.50]

File addition: manifest (----------)

File addition: cpp-gen (d--x------)

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

File addition: buildfile (----------)

Deletion in .ignore at line 5 [3.1924]

Replacement in .ignore at line 9 [3.1924]

Insertion in .ignore at line 11 [3.1924]