RefactorScript – Data Model

This page describes the data model used by RefactorScript. Each C/C++ entity (e.g. a class or a function) is represented by a single RefactorScript object of one of the types shown below:

• Entity
  • Typedef
  • Enum
  • Record
  • Value
  • Variable
    • Field
    • FunctionArgument
  • Function
• TypeRef
  • FunctionPrototype
• ResolvedType
• Base

RefactorScript objects automatically inherit properties from the base object types. E.g. an instance of the Field type will inherit all properties of Variable and Entity. You can check whether the object belongs to a particular type using the “is” operator, e.g.:

if (obj is Function)
{
    //...
}

The properties of all object types are described below:

Entity

Entity is a base type for all C/C++ entities (e.g. classes, functions, variables, etc.). It always defines the properties shown below:

Typedef

The Typedef object represents a single C/C++ typedef. It inherits the Entity and TypeRef types and does not define any additional properties on top of them.

Enum

The Enum object represents a single enum declaration. It inherits the Entity type.

Record

The Record object represents a single struct/class/union declaration. It inherits the Entity type.

Value

The Value object represents a single enum constant. It inherits the Entity type.

Variable

The Variable object represents a single variable (see also Field and FunctionArgument). It inherits the Entity type.

Field

The Field object represents a single field. It inherits the Variable type.

FunctionArgument

The FunctionArgument object represents a single function argument. It inherits the Variable type.

Function

The Function object represents a single function, method, constructor, destructor or an operator. It inherits from the Entity type.

The following properties are only available with IsMethod == true:

TypeRef

A TypeRef object represents a reference to a C/C++ type. It is typically exposed as a part of the Typedef object, or via the Type property of the Variable object.

Because C/C++ types can be referenced via typedefs or preprocessor macros, simply finding out the actual type of the variable might not be always sufficient (e.g. in many cases you would like to use “string” instead of “std::basic_string<…>“. The TypeRef object contains multiple levels of information about a type, allowing the scripts to pick what works the best in a particular scenario.

Typically, the fields of TypeRef should be used as follows:

• Use $decl.Type.Literal to copy the exact syntax that was used by an existing declaration to reference a type.
• Use $decl.Type.Referenced.Name to get the fully qualified type name (with the parent classes or namespaces) useful in generating method implementations.
• Check fields of decl.Type.Resolved to test whether the type is a pointer, array, or another special case.

FunctionPrototype

A FunctionPrototype object is a special case of TypeRef. It represents the type of a field or typedef that is declared as a function pointer, e.g.:

struct Foo
{
    int (*bar)(int x, int y, int z);
};

This allows programmatically generating implementations for function pointer fields.

Base

A Base object represents a reference to a single base class of a C++ class/struct.

ResolvedType

A ResolvedType object represents a single C/C++ type.