FreeOpcUa / python-opcua

        ('ServerType', 'ApplicationType'),

        ('GatewayServerUri', 'String'),

        ('DiscoveryUrls', 'ListOfString'),

        ('SemaphoreFilePath', 'String'),

        ('IsOnline', 'Boolean'),

               ]

    def __init__(self):

        self.ServerUri = None

        self.ProductUri = None

        self.ServerNames = []

        self.ServerType = ApplicationType(0)

        self.GatewayServerUri = None

        self.DiscoveryUrls = []

        self.SemaphoreFilePath = None

        self.IsOnline = True

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.String.pack(self.ServerUri))

        packet.append(uabin.Primitives.String.pack(self.ProductUri))

        packet.append(uabin.Primitives.Int32.pack(len(self.ServerNames)))

        for fieldname in self.ServerNames:

            packet.append(fieldname.to_binary())

        packet.append(uabin.Primitives.UInt32.pack(self.ServerType.value))

        packet.append(uabin.Primitives.String.pack(self.GatewayServerUri))

        packet.append(uabin.Primitives.Int32.pack(len(self.DiscoveryUrls)))

        for fieldname in self.DiscoveryUrls:

            packet.append(uabin.Primitives.String.pack(fieldname))

        packet.append(uabin.Primitives.String.pack(self.SemaphoreFilePath))

        packet.append(uabin.Primitives.Boolean.pack(self.IsOnline))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = RegisteredServer()

        self.ServerUri = uabin.Primitives.String.unpack(data)

        self.ProductUri = uabin.Primitives.String.unpack(data)

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(LocalizedText.from_binary(data))

        obj.ServerNames = array

        self.ServerType = ApplicationType(uabin.Primitives.UInt32.unpack(data))

        self.GatewayServerUri = uabin.Primitives.String.unpack(data)

        obj.DiscoveryUrls = uabin.Primitives.String.unpack_array(data)

        self.SemaphoreFilePath = uabin.Primitives.String.unpack(data)

        self.IsOnline = uabin.Primitives.Boolean.unpack(data)

        return obj

    def __str__(self):

        return 'RegisteredServer(' + 'ServerUri:' + str(self.ServerUri) + ', ' + \

        ('ServerCapabilities', 'ListOfString'),

               ]

    def __init__(self):

        self.RecordId = 0

        self.ServerName = None

        self.DiscoveryUrl = None

        self.ServerCapabilities = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.UInt32.pack(self.RecordId))

        packet.append(uabin.Primitives.String.pack(self.ServerName))

        packet.append(uabin.Primitives.String.pack(self.DiscoveryUrl))

        packet.append(uabin.Primitives.Int32.pack(len(self.ServerCapabilities)))

        for fieldname in self.ServerCapabilities:

            packet.append(uabin.Primitives.String.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = ServerOnNetwork()

        self.RecordId = uabin.Primitives.UInt32.unpack(data)

        self.ServerName = uabin.Primitives.String.unpack(data)

        self.DiscoveryUrl = uabin.Primitives.String.unpack(data)

        obj.ServerCapabilities = uabin.Primitives.String.unpack_array(data)

        return obj

    def __str__(self):

        return 'ServerOnNetwork(' + 'RecordId:' + str(self.RecordId) + ', ' + \

               'ServerName:' + str(self.ServerName) + ', ' + \

               'DiscoveryUrl:' + str(self.DiscoveryUrl) + ', ' + \

               'ServerCapabilities:' + str(self.ServerCapabilities) + ')'

    __repr__ = __str__

class FindServersOnNetworkParameters(FrozenClass):

    '''

    :ivar StartingRecordId:

    :vartype StartingRecordId: UInt32

    :ivar MaxRecordsToReturn:

    :vartype MaxRecordsToReturn: UInt32

    :ivar ServerCapabilityFilter:

    :vartype ServerCapabilityFilter: String

    '''

    ua_types = [

        ('StartingRecordId', 'UInt32'),

        ('MaxRecordsToReturn', 'UInt32'),

        ('ServerCapabilityFilter', 'ListOfString'),

               ]

            for _ in range(0, length):

                array.append(StatusCode.from_binary(data))

        obj.RemoveResults = array

        length = uabin.Primitives.Int32.unpack(data)

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(DiagnosticInfo.from_binary(data))

        obj.RemoveDiagnosticInfos = array

        return obj

    def __str__(self):

        return 'SetTriggeringResult(' + 'AddResults:' + str(self.AddResults) + ', ' + \

               'AddDiagnosticInfos:' + str(self.AddDiagnosticInfos) + ', ' + \

               'RemoveResults:' + str(self.RemoveResults) + ', ' + \

               'RemoveDiagnosticInfos:' + str(self.RemoveDiagnosticInfos) + ')'

    __repr__ = __str__

class SetTriggeringResponse(FrozenClass):

    '''

    :ivar TypeId:

    :vartype TypeId: NodeId

    :ivar ResponseHeader:

    :vartype ResponseHeader: ResponseHeader

    :ivar Parameters:

    :vartype Parameters: SetTriggeringResult

    '''

    ua_types = [

        ('TypeId', 'NodeId'),

        ('ResponseHeader', 'ResponseHeader'),

        ('Parameters', 'SetTriggeringResult'),

               ]

    def __init__(self):

        self.TypeId = FourByteNodeId(ObjectIds.SetTriggeringResponse_Encoding_DefaultBinary)

        self.ResponseHeader = ResponseHeader()

        self.Parameters = SetTriggeringResult()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.TypeId.to_binary())

        packet.append(self.ResponseHeader.to_binary())

        packet.append(self.Parameters.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        obj = SetTriggeringResponse()

        obj.ResponseHeader = ResponseHeader.from_binary(data)

        obj.Parameters = FindServersOnNetworkResult.from_binary(data)

        return obj

    def __str__(self):

        return 'FindServersOnNetworkResponse(' + 'TypeId:' + str(self.TypeId) + ', ' + \

               'ResponseHeader:' + str(self.ResponseHeader) + ', ' + \

               'Parameters:' + str(self.Parameters) + ')'

    __repr__ = __str__

class UserTokenPolicy(FrozenClass):

    '''

    Describes a user token that can be used with a server.

    :ivar PolicyId:

    :vartype PolicyId: String

    :ivar TokenType:

    :vartype TokenType: UserTokenType

    :ivar IssuedTokenType:

    :vartype IssuedTokenType: String

    :ivar IssuerEndpointUrl:

    :vartype IssuerEndpointUrl: String

    :ivar SecurityPolicyUri:

    :vartype SecurityPolicyUri: String

    '''

    ua_types = [

        ('PolicyId', 'String'),

        ('TokenType', 'UserTokenType'),

        ('IssuedTokenType', 'String'),

        ('IssuerEndpointUrl', 'String'),

        ('SecurityPolicyUri', 'String'),

               ]

    def __init__(self):

        self.PolicyId = None

        self.TokenType = UserTokenType(0)

        self.IssuedTokenType = None

        self.IssuerEndpointUrl = None

        self.SecurityPolicyUri = None

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uabin.Primitives.String.pack(self.PolicyId))

        packet.append(uabin.Primitives.UInt32.pack(self.TokenType.value))

        packet.append(uabin.Primitives.String.pack(self.IssuedTokenType))

        packet.append(uabin.Primitives.String.pack(self.IssuerEndpointUrl))

        packet.append(uabin.Primitives.String.pack(self.SecurityPolicyUri))

        return b''.join(packet)