petrppetrov / beautiful-capi Goto Github PK

Templates need a way to differentiate between class/type and constant arguments.

Something like that:

class Printer
{
public:
    void Show() {
        printer_show(this);
    }

    static void * operator new(size_t size) {
        assert(size == sizeof Printer);
        return printer_create();
    }
    
    static void operator delete(void * obj, size_t size) {
        assert(size == sizeof Printer);
        printer_destroy(obj);
    }
};

The idea was contributed by @vdimas

in template classes

Compile libraries by one compiler, compile the client examples by another compiler. Verify that it works.

Sometimes it is boring to use a long-named namespace for down_cast function:

ABC::TargetTypePtr obj = ABC::XYZ::down_castABC::TargetTypePtr(object1);

better to just write
ABC::TargetTypePtr obj = ABC::down_castABC::TargetTypePtr(object1);

which could reduced to:
using namespace ABC;
TargetTypePtr obj = down_cast(object1);

to allow using styles like:
FcCreateNewFont instead of
fc_create_new_font
in C glue layer

And fix the found problems

Add generation of C# wrappers for the same binaries as for C & C++

Write developer's guide and other documentation like FAQ, reference manual, and change log.

Generate doxygen-compatible comments in C & C++ code.
Documentation for doxygen should come from API description .xml files.

Need correctly treat exceptions from the nested library and pass them to the client side

Also allow wrapping const char* as std::string (in C++). Just for convenience.

Add namespace documentation to callback example, or add new doxygen example

Check unit_test example: how many times Delete() method called

Develop methods to map simple types (ints, unsigned ints, shorts, etc.) to well-defined size types, such as int32_t, uint32_t, int16_t etc.
This requires some research: which headers should be used on the client side to have the above types defined.

Currently API is described by XML files.
Develop some DSL (domain specific language) and parsing tools to work as replacement to XML.
Better to support both formats (XML and some DSL).

Add support overloaded methods

For instance, ABCDInit now will be converted to a_b_c_d_init C function.
But better to generate abcd_init name.

Default value is "{class_name}{wrap_suffix}"

where {class_name} is replaced by "Printer"
{wrap_suffix} is replaced by "Ptr" (for example)

When user specifies simple inheritance mode then it is required that pointer to a derived class should be equal to pointer to a base class (as casted to void*).
We need to generate some runtime (or better compile time) checks for that.

For testing purposes

And fix the found problems

Add support of explicit constructors in API descriptions.
Generated wrap classes should use "explicit" keyword for these constructors.

need check to:

1. base class has the same lifecycle semantic as derived
2. ....

For development on the library side it will be convenient to have typedef for each instantiated template.

For testing purposes

There is no way to write different documentation for set and get methods of a property.

Now we are forced to always do unity builds: bCapi always generates a huge AutoGenWrap.cpp.
Probably, in some cases it is better to generate many small files (AutoGenWrapXXX.cpp) instead one big: recompilation speed during development will be higher.

Add set_argument_name for properties. Use property name by default.

Add support of default argument values in constructors, methods and functions.

bCapi API description has noexcept flag for each method.
We can generate noexcept methods for C++ wrappers if the client's compiler support this feature of C++11 standard.

When an argument of a method has const modifier