Editor

Editor is returned by model:edit(). It is used to edit the address space. It has the same interface as browser with additional methods to add new nodes to the model.

To save changes to the model you should call editor:save() method. Without saving changes are not committed to the model.

Objects returned from the following methods editor:addXXX() have the same interface as objects returned from model:browse() method plus additional methods to edit the node. All changes made to them are saved in the editor and will be committed to the model when you call editor:save() method.

Method argument and structure field tables use the same compact shape:

Field	Required	Description
`Name`	yes	Argument or field name.
`DataType`	yes	Data type NodeId.
`ValueRank`	optional	Value rank. If omitted for method input arguments, the default rank is used.
`ArrayDimensions`	optional	Array dimensions.
`Description`	optional	Localized description.

editor:addObject(browseName, objectType, nodeId, refType)

Add an object to the model under ObjectsFolder node.

BrowseName:: QualifiedName or String Name of the object.
ObjectType:: NodeId | ObjectType object. Object type which will be used as a template for the new object. The hierarchy of object type will be expanded.
NodeId:: Node ID for the new object. If not provided, a new Node ID is generated.
RefType:: Reference type as NodeId, String, reference type object, or nil to use HasComponent.

Example:

  local object = editor:addObject("Sensor")
  object:addVariable("Temperature", {Type=ua.VariantType.Double, Value=20})

editor:addObjectType(browseName)

Add an object type to the model.

BrowseName:: QualifiedName or String Name of the object.
Returns:: ObjectType

Example:

-- Add a sensor object type. This object type will be used
-- to create instances of sensors.
local sensorObjectType = modelEditor:addObjectType("SensorType")
-- Add a property to the sensor object type
local addressProp = sensorObjectType:addProperty("Address",
    {Type = ua.VariantType.Int32, Value = 1})

local objectsFolder = modelEditor:objectsFolder()
local sensorFolder = objectsFolder:addFolder("Sensors")

editor:addVariableType(browseName)

Add a variable type to the model.

Returns:: VariableType

Example:

-- Add a variable type for the sensor data
-- Variables of this type will have root node with structured value and
-- underlying hierarchy of fields will be expanded.
local sensorVariableDataType = modelEditor:addVariableType("SensorVariableDataType", nil, sensorDataType)
-- Add a variable to the sensor object type
local sensorDataVariable = sensorObjectType:addVariable("Data", nil, sensorVariableDataType)
sensorDataVariable.Attrs.Description = {Text="Current measured sensor data"}

editor:addEnum(browseName, values, nodeId)

Add an enum to the model.

Values:: Array of string. Each value is a name of the enum value, values are assigned in the order they are defined.
Returns:: Enum.

Example:

-- Add enum for the sensor data
local sensorDataEnum = modelEditor:addEnum("PrecisionType", {
  "Low",
  "Medium",
  "High",
})

editor:addStructure(browseName, nodeId)

Add a structure to the model.

BrowseName:: QualifiedName or String Name of the structure.
NodeId:: Node ID for the new structure. If not provided, a new Node ID is generated.
Returns:: Structure That can be used to add fields to the structure.

Example:

-- Add a structure type for the sensor data
local sensorDataType = modelEditor:addStructure("SensorDataType")
sensorDataType:addField("Temperature", ua.DataTypeId.Double, ua.ValueRank.Scalar)
sensorDataType:addField("Humidity", ua.DataTypeId.Double, ua.ValueRank.Scalar)
sensorDataType:addField("Precision", ua.DataTypeId.Enumeration, ua.ValueRank.Scalar)

editor:save()

Save the model.

Returns:: nil

Example:

local modelEditor = server.model:edit()
local objectsFolder = modelEditor:objectsFolder()
local sensorFolder = objectsFolder:addFolder("Sensors")
local sensor1 = sensorFolder:addObject("Outside", sensorObjectType)
local sensor2 = sensorFolder:addObject("Inside", sensorObjectType)

-- Save the changes to the model
modelEditor:save()

editor:objectsFolder()

Returns ‘ObjectsFolder’.

Returns:: Object that can be used for editing objects under ObjectsFolder.

Example:

local modelEditor = server.model:edit()
-- Get ObjectsFolder node
local objectsFolder = modelEditor:objectsFolder()
-- Create to node folders and add some variables to them
local folder1 = objectsFolder:addFolder("Folder1")

editor:typesFolder()

Returns the Types folder.

Returns:: Editable browser object for the Types folder.

editor:findNode(node)

Find a node by NodeId string or existing node table and return an editable object for it.

Node:: NodeId string or node table.
Returns:: Editable node object, or nil if the node is not found.

editor:getNode(node)

Return an editable object for a NodeId string or existing node table. Raises an error if the node cannot be resolved.

Node:: NodeId string or node table.
Returns:: Editable node object.

Object

object:addProperty(browseName, value, variableType, nodeId, refType)

Add a property to the object.

BrowseName:: QualifiedName | String Name of the property.
Value:: (DataValue or Variant or nil) Value of the property.
VariableType:: (optional) NodeId | DataType. Variable type which will be used as a template for the new property.
NodeId:: (optional) Node ID for the new property. If not provided, a new Node ID is generated.
RefType:: (optional) Reference type of the property.
Returns:: Variable object.

Example:

  local configurationObject = object:addObject("Configuration")
  configurationObject:addProperty("Address", {Type=ua.VariantType.String, Value="1"})
  configurationObject:addProperty("Port", {Type=ua.VariantType.UInt16, Value=1234})

object:addVariable(browseName, value, variableType, nodeId, refType)

Add a variable to the object.

BrowseName:: (String or QualifiedName) Name of the variable.
Value:: (DataValue or Variant or nil) Value of the variable.
VariableType:: (NodeId or VariableType or nil) Variable type which will be used as a template for the new variable. The hierarchy of variable type will be expanded. If not provided, then BaseDataVariableType is used.
NodeId:: (NodeId or nil) Node ID for the new variable. If not provided, a new Node ID is generated.
RefType:: (NodeId or String or reference type object or nil) Reference type of the variable. If not provided, then HasComponent reference type is used.
Returns:: Variable object.

Example:

  local editor = model:edit()

  local object = editor:addObject("Sensor")
  object:addVariable("Temperature", {Type=ua.VariantType.Double, Value=20})

object:addObject(browseName, objectType, nodeId, refType)

Add a sub-object to the object.

BrowseName:: QualifiedName or String Name of the object.
ObjectType:: NodeId | ObjectType object. Object type which will be used as a template for the new object. The hierarchy of object type will be expanded.
NodeId:: Node ID for the new object. If not provided, a new Node ID is generated.
RefType:: Reference type as NodeId, String, reference type object, or nil to use HasComponent.
Returns:: Object

Example:

  local editor = model:edit()

  local object = editor:addObject("Sensor")
  object:addVariable("Temperature", {Type=ua.VariantType.Double, Value=20})
  local configurationObject = object:addObject("Configuration")
  configurationObject:addProperty("Address", {Type=ua.VariantType.String, Value="1"})

object:addFolder(browseName[, nodeId])

Add a folder which stores other nodes (like ‘ObjectsFolder’)

BrowseName:: QualifiedName or String Name of the folder.
NodeId:: Optional Node ID for the new folder. If not provided, a new Node ID is generated.
Returns:: Object with newly created folder

-- Get ObjectsFolder node
local objectsFolder = modelEditor:objectsFolder()
-- Create to node folders and add some variables to them
local folder1 = objectsFolder:addFolder("Folder1")

object:addMethod(browseName, func, inputArguments, outputArguments, nodeId)

Add a method to the Object.

Func:: Function to be called when the method is called by client.
InputArguments:: Array of method argument tables.
OutputArguments:: Array of method argument tables.
NodeId:: (optional) Node ID for the new method. If not provided, a new Node ID is generated.

Example:

  local inputArguments = {
    {Name = "Address",  DataType = ua.DataTypeId.String},
    {Name = "Port",     DataType = ua.DataTypeId.UInt16},
    {Name = "Enabled",  DataType = ua.DataTypeId.Boolean},
  }

  local outputArguments = {
    {Name = "Result",  DataType = ua.DataTypeId.StatusCode},
  }

  local func = function(address, port, enabled)
    trace(string.format("New configuration: address=%s, port=%d, enabled=%s",
      address, port, enabled))

    return {
      {Name="Result", {Type = ua.DataTypeId.StatusCode, Value = ua.StatusCode.Good}}
    }
  end

  local method = object:addMethod("SetConfiguration",
    func, inputArguments, outputArguments)

Returns:: Method

object:getProperty(browseName)

Get a property from the object.

Returns:: Variable

object:getVariable(browseName)

Get a variable from the object.

Returns:: Variable

object:getComponent(browseName)

Get a component from the object.

Returns:: Object

object:getMethod(browseName)

Get a method from the object.

Returns:: Method

object:path(names)

Resolve node by path relative to current object.

Throws:: Error if path is not found.
Returns:: Node corresponding to the path.

ObjectType

objectType:addProperty(browseName, value, variableType, nodeId, refType)

Add a property to the object type.

BrowseName:: QualifiedName | String Name of the property.
Value:: (DataValue or Variant or nil) Value of the property.
VariableType:: (optional) NodeId | DataType. Variable type which will be used as a template for the new property.
NodeId:: (optional) Node ID for the new property. If not provided, a new Node ID is generated.
RefType:: (optional) Reference type of the property.
Returns:: Variable object.

Example:

-- Add a sensor object type. This object type will be used
-- to create instances of sensors.
local sensorObjectType = modelEditor:addObjectType("SensorType")
-- Add a property to the sensor object type

objectType:addVariable(browseName, value, variableType, nodeId, refType)

Add a variable to the object.

BrowseName:: (String or QualifiedName) Name of the variable.
Value:: (DataValue or Variant or nil) Value of the variable. If not provided, then nil is used.
VariableType:: (NodeId or VariableType or nil) Variable type which will be used as a template for the new variable. The hierarchy of variable type will be expanded. If not provided, then BaseDataVariableType is used.
NodeId:: (NodeId or nil) Node ID for the new variable. If not provided, a new Node ID is generated.
RefType:: (NodeId or String or reference type object or nil) Reference type of the variable. If not provided, then HasComponent reference type is used.
Returns:: Variable object.

Example:

-- Add a sensor object type. This object type will be used
-- to create instances of sensors.
local sensorObjectType = modelEditor:addObjectType("SensorType")
-- Add a variable to the sensor object type
local sensorDataVariable = sensorObjectType:addVariable("Data", nil, sensorVariableDataType)
sensorDataVariable.Attrs.Description = {Text="Current measured sensor data"}

objectType:addObject(browseName, objectType, nodeId, refType)

Add a sub-object to the object type.

BrowseName:: QualifiedName or String Name of the object.
ObjectType:: NodeId | ObjectType object. Object type which will be used as a template for the new object. The hierarchy of object type will be expanded.
NodeId:: Node ID for the new object. If not provided, a new Node ID is generated.
RefType:: Reference type as NodeId, String, reference type object, or nil to use HasComponent.
Returns:: Object

Example:

-- Add a sensor object type. This object type will be used
-- to create instances of sensors.
local sensorObjectType = modelEditor:addObjectType("SensorType")
-- Add an object to the sensor object type
local busObject = sensorObjectType:addObject("Bus")
busObject.Attrs.Description = {Text="Ethernet bus object"}

objectType:addFolder(browseName[, nodeId])

Add a folder which stores other nodes (like ‘ObjectsFolder’) Parameters are the same as for object:addFolder().

Returns:: Object with newly created folder

Example:

-- Add a sensor object type. This object type will be used
-- Add an object to the sensor object type
local gpioFolder = sensorObjectType:addFolder("GPIO Pins")
gpioFolder:addVariable("GPIO 1", {Type = ua.VariantType.Int32, Value = 1})
gpioFolder:addVariable("GPIO 2", {Type = ua.VariantType.Int32, Value = 2})
gpioFolder:addVariable("GPIO 3", {Type = ua.VariantType.Int32, Value = 3})

objectType:addMethod(browseName, func, inputArguments, outputArguments[, nodeId])

Add a method to the object type.

Func:: Function to be called when the method is called by client.
InputArguments:: Array of method argument tables.
OutputArguments:: Array of method argument tables.
Throws:: Error in case of errors.
Returns:: Method

Example:

-- Add a sensor object type. This object type will be used
-- to create instances of sensors.
local sensorObjectType = modelEditor:addObjectType("SensorType")
-- Add a method to the sensor object type
local function measureSensor(objectId, methodId, isAsync)
  if isAsync then
    return ua.StatusCode.Good
  end

  return ua.StatusCode.Good
end
local inputArguments = {
  {Name = "IsAsync",  DataType = ua.DataTypeId.Boolean},
}
local outputArguments = {
  {Name = "Status",  DataType = ua.DataTypeId.StatusCode},
}
local measureMethod = sensorObjectType:addMethod("Measure",
    measureSensor, inputArguments, outputArguments)
measureMethod.Attrs.Description = {Text="Measure the temperature of the sensor"}

objectType:getProperty(browseName)

Get a property from the object.

Returns:: Variable

objectType:getVariable(browseName)

Get a variable from the object.

Returns:: Variable

objectType:getComponent(browseName)

Get a component from the object.

Returns:: Object

objectType:getMethod(browseName)

Get a method from the object.

Returns:: Method

objectType:path(names)

Resolve node by path relative to current object.

Returns:: Node corresponding to the path.

Variable

variable:addVariable(browseName, value, variableType, nodeId, refType)

Add a variable to the object.

BrowseName:: (String or QualifiedName) Name of the variable.
Value:: (DataValue or Variant or nil) Value of the variable.
VariableType:: (NodeId or VariableType or nil) Variable type which will be used as a template for the new variable. The hierarchy of variable type will be expanded. If not provided, then BaseDataVariableType is used.
NodeId:: (NodeId or nil) Node ID for the new variable. If not provided, a new Node ID is generated.
RefType:: (NodeId or String or reference type object or nil) Reference type of the variable. If not provided, then HasComponent reference type is used.
Returns:: Variable object.

Example:

-- Add a variable for the sensor data
local objectsFolder = modelEditor:objectsFolder()

local sensorDataVariable = objectsFolder:addVariable("SensorData")
sensorDataVariable:addVariable("Temperature",
    {Type = ua.VariantType.Double, Value = 20})

sensorDataVariable:addVariable("Humidity",
    {Type = ua.VariantType.Double, Value = 50})

variable:getVariable(browseName)

Get a child node variable by name.

Returns:: Variable

variable:setValueCallback(func)

Set a callback used when the variable value is read or written.

Func:: Function called by the address-space value handling code.
Returns:: nil

variable:path(names)

Resolve node by path relative to current variable.

Returns:: Node corresponding to the path.

VariableType

Variable type is a type of variable. It is used to describe the type of variable. When creating a variable, the variable type is used as a template for the new variable. If the variable is structured, then VariableType is used as a template for the new variable and its underlying hierarchy.

For example, variable type BuildInfoType represents a structure with the following fields:

ProductUri
ManufacturerName
ProductName
SoftwareVersion

After creating a variable with type BuildInfoType, the variable will have the same fields as the variable type. The root node will have a single structured value. For convenience, the editor will expand the hierarchy with fields in the underlying hierarchy. For each field, a separate variable node will be created with the same type as the field.

BuildInfo - Structured value
- ProductUri - String
- ManufacturerName - String
- ProductName - String
- SoftwareVersion - String

variableType:addVariable(browseName, value, variableType, nodeId, refType)

Add a variable to the object.

BrowseName:: (String or QualifiedName) Name of the variable.
Value:: (DataValue or Variant or nil) Value of the variable.
VariableType:: (NodeId or VariableType or nil) Variable type which will be used as a template for the new variable. The hierarchy of variable type will be expanded. If not provided, then BaseDataVariableType is used.
NodeId:: (NodeId or nil) Node ID for the new variable. If not provided, a new Node ID is generated.
RefType:: (NodeId or String or reference type object or nil) Reference type of the variable. If not provided, then HasComponent reference type is used.
Returns:: Variable object.

Example:

-- Add a variable type for the sensor data
-- Variables of this type will have root node with structured value and underlying hierarchy of fields will be expanded.
local sensorVariableDataType = modelEditor:addVariableType("SensorVariableType")
sensorVariableDataType:addVariable("Temperature",
    {Type = ua.VariantType.Double, Value = 20})

sensorVariableDataType:addVariable("Humidity",
    {Type = ua.VariantType.Double, Value = 50})

variableType:getVariable(browseName)

Get a child node variable by name.

Returns:: Variable

variableType:path(names)

Resolve node by path relative to current variable type.

Throws:: Error if path is not found.
Returns:: Node corresponding to the path relative to current variable type.

Enum

enum:setValues(values)

Set values for the enum.

Values:: Array of string. Each value is a name of the enum value, values are assigned in the order they are defined.
Returns:: nil

Example:

local values = sensorDataEnum:getValues()
for i, value in ipairs(values) do
  print(value)
end

-- Add a new value to the enum
sensorDataEnum:setValues({"Low", "Medium", "High", "VeryHigh"})

enum:getValues()

Get values for the enum.

Returns:: Array of string. Each value is a name of the enum value, values are assigned in the order they are defined.

Example:

local values = sensorDataEnum:getValues()
for i, value in ipairs(values) do
  print(value)
end

Structure

Structure is a complex data type. It is a collection of fields. Structure types describe how to encode and decode the structure. Fields are encoded in the order they are defined.

structure:addField(browseName, dataType, rank)

Add one field to the structure definition.

BrowseName:: Field name.
DataType:: Field data type NodeId.
Rank:: Optional value rank.
Returns:: nil

structure:setFields(fields)

Set fields for the structure.

Fields:: Array of structure field tables.
Returns:: nil

Example:

local fields = {
  {
    Name = "Temperature",
    DisplayName = {Text = "Temperature"},
    DataType = ua.DataTypeId.Double,
    ValueRank = ua.ValueRank.Scalar,
    IsOptional = false
  },
  {
    Name = "Humidity",
    DisplayName = {Text = "Humidity"},
    DataType = ua.DataTypeId.Double,
    ValueRank = ua.ValueRank.Scalar,
    IsOptional = false
  },
  {
    Name = "Precision",
    DisplayName = {Text = "Precision"},
    DataType = ua.DataTypeId.Enumeration,
    ValueRank = ua.ValueRank.Scalar,
    IsOptional = false
  },
}
sensorDataType:setFields(fields)

structure:getFields()

Get fields for the structure.

Returns:: Array of structure field tables.

Example:

local allFields = sensorDataType:getFields()
for _, field in ipairs(allFields) do
  print(field.Name, field.DisplayName, field.DataType, field.ValueRank, field.IsOptional)
end

structure:getField(fieldName)

Get field for the structure.

FieldName:: Name of the field.
Returns:: Field.

Example:

local field = sensorDataType:getField("Precision")
print(field.Name, field.DisplayName, field.DataType, field.ValueRank, field.IsOptional)

Method

method:setInputArguments(inputArguments)

Set input arguments for the method.

InputArguments:: Array of method argument tables.
Returns:: nil

Example:

local inputArguments = {
  {Name = "IsAsync",  DataType = ua.DataTypeId.Boolean},
  {Name = "Unit",  DataType = ua.DataTypeId.String},
}
measureMethod:setInputArguments(inputArguments)

method:setOutputArguments(outputArguments)

Set output arguments for the method.

OutputArguments:: Array of method argument tables.
Returns:: nil

Example:

local outputArguments = {
  {Name = "Status",  DataType = ua.DataTypeId.StatusCode},
  {Name = "Temperature",  DataType = ua.DataTypeId.Double},
}
measureMethod:setOutputArguments(outputArguments)