RAPID variables & symbols

// Gets the value of a RAPID symbol and where it is declared (synchronous)
RapidSymbolValue GetSymbolValue(string symbolUrl);

// Sets the value a RAPID symbol is declared with, which is the one it goes back to when the program is reset (synchronous)
void SetSymbolInitialValue(string symbolUrl, string value);

// Sets the value a RAPID symbol currently holds (synchronous)
void SetSymbolValue(string symbolUrl, string value);

public class RapidSymbolValue {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidSymbolValue" data-throw-if-not-resolved="false"></xref> class
    public RapidSymbolValue()
 
    // Where the symbol is declared, null when the controller did not report it
    public RapidTextRange DeclarationPosition { get; set; }
 
    // Where the initial value of the symbol is written, null when the controller did not report it.
    // 
    // <p>The controller reports zeros when the declaration carries no initial value.</p>
    public RapidTextRange InitialValuePosition { get; set; }
 
    // Returns a string representation of this value
    public override string ToString()
 
    // Value of the symbol, written the way RAPID writes it
    public string Value { get; set; }
}

public class RapidTextRange {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidTextRange" data-throw-if-not-resolved="false"></xref> class
    public RapidTextRange()
 
    // Column the range begins at, null when the controller did not report it
    public int? BeginColumn { get; set; }
 
    // Line the range begins at, null when the controller did not report it
    public int? BeginRow { get; set; }
 
    // Column the range ends at, null when the controller did not report it
    public int? EndColumn { get; set; }
 
    // Line the range ends at, null when the controller did not report it
    public int? EndRow { get; set; }
 
    // Returns a string representation of this range
    public override string ToString()
}

// Asks the controller whether a value would be accepted for a given RAPID type, without writing it anywhere (synchronous) This is what an editor uses to tell an operator that what they typed is wrong before the write is attempted.
bool ValidateSymbolValue(string task, string dataType, string value);

// Gets what a RAPID symbol is declared as (synchronous)
RapidSymbolProperties GetSymbolProperties(string symbolUrl);

// Finds the RAPID symbols matching a set of criteria (synchronous)
RapidSymbolProperties[] SearchSymbols(RapidSymbolSearchCriteria criteria);

public class RapidSymbolProperties {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidSymbolProperties" data-throw-if-not-resolved="false"></xref> class
    public RapidSymbolProperties()
 
    // Name of the type of the symbol, for example "num"
    public string DataType { get; set; }
 
    // Size of each array dimension as the controller worded it, empty when the symbol is not an array
    public string Dimension { get; set; }
 
    // Number of array dimensions of the symbol, null when the controller did not report it
    public int? Dimensions { get; set; }
 
    // Whether the symbol is allocated on the heap, null when the controller did not report it
    public bool? Heap { get; set; }
 
    // Whether the declaration is complete, null when the controller did not report it
    public bool? Linked { get; set; }
 
    // Whether the symbol is local to its module, null when the controller did not report it
    public bool? Local { get; set; }
 
    // Name of the symbol, for example "reg1"
    public string Name { get; set; }
 
    // Whether the symbol is named, null when the controller did not report it
    public bool? Named { get; set; }
 
    // Whether the symbol may not be written, null when the controller did not report it
    public bool? ReadOnly { get; set; }
 
    // How the controller stores the symbol, for example "loaded"
    public string Storage { get; set; }
 
    // What kind of symbol this is
    public RapidSymbolType SymbolType { get; set; }
 
    // Path of the symbol, which the other symbol methods take
    public string SymbolUrl { get; set; }
 
    // Whether the symbol is global within its task, null when the controller did not report it
    public bool? TaskVariable { get; set; }
 
    // Returns a string representation of this symbol
    public override string ToString()
 
    // Path of the type of the symbol, for example "RAPID/num"
    public string TypeUrl { get; set; }
}

public class RapidSymbolSearchCriteria {
 
    // Initializes a new instance of the <xref href="UnderAutomation.ABB.Rws.Data.RapidSymbolSearchCriteria" data-throw-if-not-resolved="false"></xref> class
    public RapidSymbolSearchCriteria()
 
    // Path the search starts from, for example "RAPID/T_ROB1"
    public string BlockUrl { get; set; }
 
    // Name of the type a symbol has to have to be kept, for example "robtarget"
    public string DataType { get; set; }
 
    // Regular expression the name of a symbol has to match to be kept
    public string NamePattern { get; set; }
 
    // Whether only the symbols the program actually refers to are kept, null to leave it to the controller
    public bool? OnlyUsed { get; set; }
 
    // Column the search starts from, used together with <xref href="UnderAutomation.ABB.Rws.Data.RapidSymbolSearchView.Scope" data-throw-if-not-resolved="false"></xref>
    public int? PositionColumn { get; set; }
 
    // Line the search starts from, used together with <xref href="UnderAutomation.ABB.Rws.Data.RapidSymbolSearchView.Scope" data-throw-if-not-resolved="false"></xref>
    public int? PositionRow { get; set; }
 
    // Whether the search also walks what the starting point contains, null to leave it to the controller
    public bool? Recursive { get; set; }
 
    // Whether the symbols shared between tasks are skipped, null to leave it to the controller
    public bool? SkipShared { get; set; }
 
    // Frame of the call stack the search starts from, used together with
    // <xref href="UnderAutomation.ABB.Rws.Data.RapidSymbolSearchView.Stack" data-throw-if-not-resolved="false"></xref>
    public int? StackFrame { get; set; }
 
    // Kinds of symbol the search keeps, empty to keep every kind
    public RapidSymbolType[] SymbolTypes { get; set; }
 
    // Which variables the search keeps, by what may be done with them
    public RapidSymbolVariableType VariableType { get; set; }
 
    // Which part of the system the search walks
    public RapidSymbolSearchView View { get; set; }
}

public enum RapidSymbolType {
 
    // An alias of another type
    Alias = 4
 
    // Any of the other types, which a search uses to mean that it does not filter on the type
    Any = 17
 
    // A built-in type such as num or string
    Atomic = 2
 
    // A constant
    Constant = 6
 
    // The loop variable of a FOR statement
    ForVariable = 11
 
    // A function
    Function = 12
 
    // A label
    Label = 10
 
    // A module
    Module = 15
 
    // A parameter of a routine
    Parameter = 9
 
    // A persistent variable, whose value survives a restart
    Persistent = 8
 
    // A procedure
    Procedure = 13
 
    // A record type
    Record = 3
 
    // One component of a record
    RecordComponent = 5
 
    // A task
    Task = 16
 
    // A trap routine
    Trap = 14
 
    // The type is not defined
    Undefined = 1
 
    // The controller reported a type this library does not know
    Unknown = 0
 
    // A variable
    Variable = 7
}

public enum RapidSymbolSearchView {
 
    // Search the block the search path names, and optionally what it contains
    Block = 1
 
    // Search what is visible from a position of the source, which the search path and the
    // position both have to be given for
    Scope = 2
 
    // Search what is visible from a frame of the call stack, which needs the program pointer to be set
    Stack = 3
 
    // Let the controller decide
    Undefined = 0
}

public enum RapidSymbolVariableType {
 
    // Any of them
    Any = 4
 
    // Only the loop variables
    Loop = 3
 
    // Only the variables that can be read but not written
    ReadOnly = 2
 
    // Only the variables that can be read and written
    ReadWrite = 1
 
    // Let the controller decide
    Undefined = 0
}

// Gets whether the persistent variables of a module are kept synchronized with the other tasks declaring them (synchronous)
bool GetSyncPersStatus(string task, string module);

// Synchronizes the persistent variables of a module with the other tasks declaring them (synchronous)
void SyncPersistentVariables(string task, string module);