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).

Attempt to retrieve a type equivalent to the provided input type, but whose string representation is shorter.

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 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.