Bindgen::Parser::Method

Method names Crystal reserves, which a C++ method of that name gets prefixed with cpp_: QHeaderView::initialize is #cpp_initialize.

Utility method to easily build a Method using a more Crystal-style syntax.

Parses a C++ member method declaration, as written in a header, into a Method of the class class_name, for the declare_methods: type rule: QMenu *menu() const, static Foo *make(int count = 1), void setMenu(QMenu *menu). Every argument is named, like in a declaration. A default is exposed if it's a literal number, boolean or nullptr. Raises an ArgumentError for anything else.

Returns true if this reference is the same as other. Invokes same?.

Visibility of the method.

Is this a constructor that can take no arguments?

Arguments of the method.

Arguments of the method.

Name of the method in C++ and Crystal bindings. If an explicit #binding_name name is set, it'll be returned without further processing.

Forces the bindings to use the specified name.

Name of the unary operator method in C++ and Crystal bindings. Uniquely identifies a C++ operator.

Is this a method implicitly generated by C++?

Fully qualified name of the class in which the method is defined.

Returns if the method is const-qualified: std::string getName() const;

Turns the method name into something canonical to Crystal. If an explicit #crystal_name name is set, it'll be returned without further processing. If override is not nil, it'll be used over #name. Otherwise, the generated name will be based on #name.

Forces the Crystal wrapper to use the specified name.

Is this method declared [[deprecated]]? Removed by the filter_methods processor if ignore_deprecated is configured.

Documentation comment from the C++ source, without comment markers.

Checks if this method is equal to other, except for the const-qualification.

Checks if this method is equal to other, as is suitable to determine if they're the same for C++ virtual methods between parent- and sub-classes.

Checks if the #crystal_name was set explicitly (true), or will be generated (false).

Does this function use the C ABI?

Is this method filtered out?

TODO: Can we move this into Processor::FilterMethods?

Is this a final virtual function, which can't be overridden?

The index of the first argument with a default value, if any.

Checks if this method is a post-increment or post-decrement method that takes a placeholder int argument. If true, returns a copy of this method with the int argument removed.

Is this a free function of member_functions, like qHash, bound as a member method of the class of its first argument, which is self? The C++ glue calls it with *_self_ first.

Generates a C++ function pointer type matching this methods prototype.

Try to deduce if this is a getter.

Does this method have move semantics anywhere?

Returns if this method returns something, or not

See Object#hash(hasher)

Mangled name for the C++ wrapper method name

Merges this and the other method with regards to default values and type deductions. Expects that this and other methods point at the same method, but in different classes in the inheritance chain.

Keeps the class name, access, constness, virtuality and type of this method.

Unify arguments of this and another method.

Modifies the argument list of this method.

Name of the method.

Returns if this method needs a class instance to be called.

The method this method is based on. Used by #variants to indicate the methods origin when splitting occurs.

The indices of the out arguments: the non-const references and pointers to converted value types (TypeDatabase#converted_out_argument?), like QString & or QString *, and in a method having one, those to built-in types and enums too (TypeDatabase#builtin_out_argument?), like int &. The wrapper appends their values to the result: a reference is an in/out argument, which it keeps, a pointer is out-only, which it drops. Empty for a method which can't take out arguments, see #takes_out_arguments?, and for one without a converted out argument, whose int & stays an Int32*.

An out_arguments entry of the class decides instead, see TypeDatabase#out_arguments_rule: true takes every such argument, false none, and a list of indices those among them. Without one, with TypeDatabase#builtin_out_arguments? the built-in ones are out arguments in every method, not only next to a converted one; a pointer to a byte or character type, or to void, is a buffer then, not an out argument (TypeDatabase#buffer_argument?).

Is this a pure virtual function?

Fully qualified name of the method: class_name::name. For a function in the global scope, it's the name itself.

Try to deduce if this is a getter for a boolean value.

The return type of this method

Replaces the return type, see the nilable: type rule.

Does other have the same Crystal name and argument types, like try_lock next to tryLock? Both would define the same method.

Try to deduce if this is a setter.

C++ signature of the method, naming its overload: name(type, type), with const appended for a const method. The argument types are written like the parser prints them, const QString &, int *. TypeDatabase::MethodPattern matches ignore_methods against it.

Substitutes all uses of name on the argument and return types of this method with the given type.

Performs type substitution on the argument and return types of this method using the given replacements.

Returns a non-virtual copy of this method suitable for use in superclass wrapper structs. The bodies of such copies are expected to ignore method overriding.

Is this operator one bindgen can name, like operator+? Not operator-> or operator,, which filter_methods drops.

Can this method have out arguments? A constructor usually keeps the pointer it is given, like QTextStream(QString *), and so does the setter of a pointer member, a signal passes its arguments to the block, and an operator returning a tuple would be odd: these keep dropping the non-const references and pointers to converted types.

Can this method take a pointer to the structure a wrapper hosts, see TypeDatabase#storage_reference?? Not a virtual method, whose Crystal override would get a copy, nor a signal or a constructor.

Type of the method.

Does this function take a variable amount of arguments?

Yields all variants of this method, going through an increasing level of default arguments. It will respect exposed default-values.

A C++ method like int foo(int a, int b = 1, std::string c = "foo") would yield two methods like:

• int foo(int a, int b, std::string c)
• int foo(int a, int b = 1)

Note that only built-in types (These are: Integers, Floats and Booleans) support an exposed default value. For other types (Like std::string in the example), no default value will be set.

Also see #find_variant_splits for the algorithm.

Non-yielding version of #variants.

Makes the method non-virtual for the wrappers, so a Crystal subclass can't override it, and the C++ subclass of Processor::VirtualOverride gets no forwarder for it: the Qt processor does this to the methods Q_OBJECT declares, which Processor::QtMetaObject overrides itself.

Is this a virtual function?