Registers & variables

public class CgtpVariableValue {
 
    // Value interpreted as a boolean (TRUE/FALSE).
    public bool BooleanValue { get; }
 
    // Value interpreted as a Cartesian position.
    public CartesianPositionVariable CartesianPositionValue { get; }
 
    // Value interpreted as a robot configuration.
    public Configuration ConfigurationValue { get; }
 
    // Value interpreted as an integer.
    public int IntegerValue { get; }
 
    // Value interpreted as a joint position.
    public JointPositionVariable JointPositionValue { get; }
 
    // Value interpreted as a double-precision floating-point number.
    public double RealValue { get; }
 
    // Maximum string length if the variable type is String
    public int StringLength { get; }
 
    // Raw string value of the variable
    public string StringValue { get; }
     public override string ToString()
 
    // Data type of the variable
    public CgtpVariableType Type { get; }
 
    // Value interpreted as a 3D vector.
    public VectorVariable VectorValue { get; }
}

public enum CgtpVariableType {
 
    // Boolean value (TRUE or FALSE).
    Boolean = 18
 
    // 8-bit byte value.
    Byte = 24
 
    // Cartesian position (X, Y, Z, W, P, R with configuration).
    CartesianPosition = 2
 
    // Robot configuration string.
    Config = 28
 
    // 32-bit integer value.
    Integer = 16
 
    // Joint position with up to 9 axes.
    JointPose9 = 8601
 
    // Joint position (J1..J9).
    JointPosition = 9
 
    // Numeric value that can be either integer or real.
    Numeric = 38
 
    // Full position type.
    POSITION = 257
 
    // Double-precision floating-point value.
    Real = 17
 
    // 16-bit short integer value.
    Short = 23
 
    // String value. The actual type code encodes the maximum string length.
    String = 7936
 
    // 3D vector (X, Y, Z).
    Vector = 19
 
    // XYZWPR position type.
    XYZWPR = 256
 
    // Extended XYZWPR position with additional axes.
    XYZWPRExt = 262
}

public class CgtpBatchVariables : IList<ICgtpBatchVariable>, ICollection<ICgtpBatchVariable>, IEnumerable<ICgtpBatchVariable>, IEnumerable {
     public CgtpBatchVariables()
     public void Add(ICgtpBatchVariable item)
 
    // Add a numeric register for reading. The value and comment will be populated after a batch read.
    public CgtpNumericRegister AddNumericRegister(int index)
 
    // Add a numeric register with an integer value and comment for writing.
    public CgtpNumericRegister AddNumericRegisterAsInteger(int index, string comment, int value)
 
    // Add a numeric register with a real (double) value and comment for writing.
    public CgtpNumericRegister AddNumericRegisterAsReal(int index, string comment, double value)
 
    // Add a position register for reading. The position data will be populated after a batch read.
    public CgtpPositionRegister AddPositionRegister(int index, int group = 1)
 
    // Add a position register with a Cartesian position for writing.
    public CgtpPositionRegister AddPositionRegisterAsCartesian(int index, CartesianPosition position, int group = 1, string comment = null)
 
    // Add a position register with a joint position for writing.
    public CgtpPositionRegister AddPositionRegisterAsJoint(int index, JointsPosition position, int group = 1, string comment = null)
 
    // Add multiple variables at once.
    public void AddRange(IEnumerable<ICgtpBatchVariable> items)
 
    // Add a string register for reading. The value and comment will be populated after a batch read.
    public CgtpStringRegister AddStringRegister(int index)
 
    // Add a string register with a value and comment for writing.
    public CgtpStringRegister AddStringRegisterWithValue(int index, string comment, string value)
 
    // Add a generic variable for reading or writing.
    // For system variables, leave <code class="paramref">programName</code> null.
    // Set the desired value on the returned object before performing a batch write.
    public CgtpVariable AddVariable(string name, string programName = null)
     public void Clear()
     public bool Contains(ICgtpBatchVariable item)
     public void CopyTo(ICgtpBatchVariable[] array, int arrayIndex)
     public int Count { get; }
     public IEnumerator<ICgtpBatchVariable> GetEnumerator()
     public int IndexOf(ICgtpBatchVariable item)
     public void Insert(int index, ICgtpBatchVariable item)
     public bool IsReadOnly { get; }
     public ICgtpBatchVariable this[int index] { get; set; }
     public bool Remove(ICgtpBatchVariable item)
     public void RemoveAt(int index)
}

public class NumericRegisterWithComment : NumericRegister {
 
    // Default constructor.
    public NumericRegisterWithComment()
 
    // Creates a numeric register with a real value and comment.
    public NumericRegisterWithComment(double value, string comment)
 
    // Creates a numeric register with an integer value and comment.
    public NumericRegisterWithComment(int value, string comment)
 
    // Creates a numeric register with a comment.
    public NumericRegisterWithComment(string comment)
 
    // Comment associated with this register.
    public string Comment { get; set; }
     public override string ToString()
}

public class PositionRegisterWithComment : PositionRegister {
 
    // Default constructor.
    public PositionRegisterWithComment()
 
    // Comment associated with this position register.
    public string Comment { get; set; }
 
    // Parses a position register with comment from its string representation.
    public static PositionRegisterWithComment Parse(string value)
}