TypeUtil

Convenience routine to create an array type, possibly multi-dimensional.

Generate a simple prototype item from a prototype string. Complex prototypes cannot be parsed by this routine. Prototypes attributes other than var-arg (via `...`) are not supported either. Refer to TypeStringParser for a full-blown C type and prototype parser.

Format:

 [<calling-convention>]returnType([param1Type[, param2Type[, ...]]])
 

 void()
 int()
 unsigned int(char)
 <cdecl>char(int, int, int)
 

Create an array or reference type using an existing base type. This method is for convenience only, and by no means exhaustive. Proper type building requires adequate parsing; refer to TLGen. (TODO: bindings to support string type parsing provided by TLGen).

Fast check, equivalent to string.contains(CPP_PACKAGE_SEPARATOR).

Find a type by pattern (partial name or signature, original or effective). Does not include primitives.

Generate a routine signature given a prototype and a routine name.

Provide the base type of a type. The base type of a pointer type is its non-pointer type; the base type of an array type is its dimension-less type. Primitive, class, structure, union, enumeration and alias types, as well as prototypes, are all considered base types.

Get the first simple type embedded (in the most general sense) in the given type.

Given a structure type (or an alias to one), retrieve the field with the provided name.

Given a structure type (or an alias to one), retrieve the field at the provided offset.

Determine if the (unaliased) type is an array or a structure type.

Determine if the provided type is a function pointer, that is, a reference (aliased or not) to a prototype item.

Determine if the provided type is a function pointer, that is, a reference (aliased or not) to a prototype item.

Determine if the (unaliased) type is a reference type.

Determine if the (unaliased) type is a reference to a reference type.

Parse and validate the elements of a normalized signature (aka fully-qualified name).

Normalize a type signature (including reference types).

What it does: Make sure the type separator is {@value #CPP_PACKAGE_SEPARATOR} (not '.' or '/'). Remove header and trailer whitespace. Remove header {@value #CPP_PACKAGE_SEPARATOR} if any. Validate signature elements.

Process non array or single-dimension arrays of reference or non-reference types.

Split a C++ name using CPP_PACKAGE_SEPARATOR as separator.

For example, 'std::pkg:titi' will be split into [std, pkg, titi]

Split a list of C++ parameters separated by comma. Start/End Parentheses are optional.

For example, 'std::pkg:titi, long' will be split into ['std::pkg:titi, long]

Detect structure cycles: Determine if the second parameter type is or contains the structure type provided as the first parameter.