flexferrum
commented
5 years ago Thank you for interesting in the project. I'm going to uplift the autoprogrammer project till the upcoming CoreHard++ conference where I'm giving the talk about modern code generation tools (not only autoprogrammer). Regarding your suggestions:
I found what jinja to C++ binding produced a lot of boilerplate code. I replaced jinja with https://github.com/blockspacer/CXTPL
In the production projects I used this tool I generated not only C++ files, but C files, JSON samples etc. as well. So, template engine which is stuck to the C++ isn't a good choice for me. Another point is that I can ship templates with the production project, not with the tool. Jinja2 is a widely-used notation, template engine is fast and independent. Lot of the boilerplaite for the reflection isn't a problem till this boilerplate can be generated. :)
I can't find docs about autoprogrammer's C++ interpreter, so i used Cling as C++ interpreter.
Yes, there are no docs except my presentation. One of the reasons is that C++ interperter here is still in progress. Actually, it utilizes the idea of constexpr evaluator from the clang with one but significant addition: it allows mixing of injected and interpretable code. I. e. you can write:
inline void BoostSerializable(meta::ClassInfo dst, const meta::ClassInfo& src)
{
for (auto& v : src.variables())
$_inject_v(dst, public) v;
$_inject_v(dst, public) [&, name="serialize"](auto& ar, unsigned int ver) -> void
{
$_constexpr for (auto& v : src.variables())
$_inject(_) ar & $_v(v.name());
};
};Here $_constexpr for (auto& v : src.variables()) will be interpreted in the context of the injected method. I'm not sure the Cling allows such kind of tricks.
I wanted to chain multiple metaclasses, so i added custom C++ attribute syntax, very similar to calling C++ functions.
That's not a problem with the current autoprogrammer implementation: $_class(SomeVisitor, CRTPVisitor<A, B, C>, Interface)
I wanted to create tool not focused on predefined set of source transformation rules.
I've been thinking about the external customization/plugins. But I'm considering something like python (in addition to the Jinja2 templates). Binding isn't a big problem.
blockspacer
zamazan4ik
This project is very interesting.
Some of autoprogrammer's features in
TODOstatus, so i wanted to add them.I want to use some proposed features (like metaclasses) without waiting 3+ years for new C++ standard and can`t find stable (ready) solution.
Inspired by autoprogrammer's approach i created https://github.com/blockspacer/CXXCTP
Maybe some ideas from that project will be useful for autoprogrammer.
I found what jinja to C++ binding produced a lot of boilerplate code. I replaced jinja with https://github.com/blockspacer/CXTPL cxtpl uses approach similar to How to write a template engine in less than 30 lines of code from https://bits.theorem.co/how-to-write-a-template-library/ That approach allowed to remove
jinja2_reflector_generator.cppcompletelyI can't find docs about autoprogrammer's C++ interpreter, so i used
Clingas C++ interpreter. Maybe autoprogrammer's solution is less verbose or feature rich (i just can't understand it without some docs).I wanted to add feature-complete Rust-like traits into C++. That's why i added to typeclasses generator
typeclass combinations(when some typeclasses may be not set),std::ref support,typeclass merging(when all typeclasses must be set), out-of-source methods (so method may be defined in separate lib),typeclass with template parameters. Now typeclass instance accepts impl as first template argument, and all other template arguments may be used to combine typeclasses.I wanted to chain multiple metaclasses, so i added custom C++ attribute syntax, very similar to calling C++ functions.
// $apply is just macro that adds attribute
class $apply(make_interface;make_removefuncbody;make_reflect) SomeInterfaceName { virtual ~SomeInterfaceName() = 0; /int f ( ) { // {} int i = 6; { // { // } } return i; };/ int foo(); virtual void foobar(int& arg1) = 0; virtual inline void zoobar(int& arg2); //int m_bar; //int m_bar2 = 2; };