FreeOpcUa / python-opcua

    __repr__ = __str__

class BrowsePathResult(FrozenClass):

    '''

    The result of a translate opearation.

    :ivar StatusCode:

    :vartype StatusCode: StatusCode

    :ivar Targets:

    :vartype Targets: BrowsePathTarget

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.StatusCode = StatusCode()

        self.Targets = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.StatusCode.to_binary())

        packet.append(uatype_Int32.pack(len(self.Targets)))

        for fieldname in self.Targets:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return BrowsePathResult(data)

    def _binary_init(self, data):

        self.StatusCode = StatusCode.from_binary(data)

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(BrowsePathTarget.from_binary(data))

        self.Targets = array

    def __str__(self):

        return 'BrowsePathResult(' + 'StatusCode:' + str(self.StatusCode) + ', ' + \

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

    __repr__ = __str__

class TranslateBrowsePathsToNodeIdsParameters(FrozenClass):

    __repr__ = __str__

class SetMonitoringModeParameters(FrozenClass):

    '''

    :ivar SubscriptionId:

    :vartype SubscriptionId: UInt32

    :ivar MonitoringMode:

    :vartype MonitoringMode: MonitoringMode

    :ivar MonitoredItemIds:

    :vartype MonitoredItemIds: UInt32

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SubscriptionId = 0

        self.MonitoringMode = MonitoringMode(0)

        self.MonitoredItemIds = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_UInt32.pack(self.SubscriptionId))

        packet.append(uatype_UInt32.pack(self.MonitoringMode.value))

        packet.append(uatype_Int32.pack(len(self.MonitoredItemIds)))

        for fieldname in self.MonitoredItemIds:

            packet.append(uatype_UInt32.pack(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return SetMonitoringModeParameters(data)

    def _binary_init(self, data):

        self.SubscriptionId = uatype_UInt32.unpack(data.read(4))[0]

        self.MonitoringMode = MonitoringMode(uatype_UInt32.unpack(data.read(4))[0])

        self.MonitoredItemIds = unpack_uatype_array('UInt32', data)

    def __str__(self):

        return 'SetMonitoringModeParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \

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

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

    __repr__ = __str__

class SetMonitoringModeRequest(FrozenClass):

    __repr__ = __str__

class EventFieldList(FrozenClass):

    '''

    :ivar ClientHandle:

    :vartype ClientHandle: UInt32

    :ivar EventFields:

    :vartype EventFields: Variant

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.ClientHandle = 0

        self.EventFields = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_UInt32.pack(self.ClientHandle))

        packet.append(uatype_Int32.pack(len(self.EventFields)))

        for fieldname in self.EventFields:

            packet.append(fieldname.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return EventFieldList(data)

    def _binary_init(self, data):

        self.ClientHandle = uatype_UInt32.unpack(data.read(4))[0]

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(Variant.from_binary(data))

        self.EventFields = array

    def __str__(self):

        return 'EventFieldList(' + 'ClientHandle:' + str(self.ClientHandle) + ', ' + \

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

    __repr__ = __str__

class HistoryEventFieldList(FrozenClass):

    __repr__ = __str__

class EventFilter(FrozenClass):

    '''

    :ivar SelectClauses:

    :vartype SelectClauses: SimpleAttributeOperand

    :ivar WhereClause:

    :vartype WhereClause: ContentFilter

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.SelectClauses = []

        self.WhereClause = ContentFilter()

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_Int32.pack(len(self.SelectClauses)))

        for fieldname in self.SelectClauses:

            packet.append(fieldname.to_binary())

        packet.append(self.WhereClause.to_binary())

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return EventFilter(data)

    def _binary_init(self, data):

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(SimpleAttributeOperand.from_binary(data))

        self.SelectClauses = array

        self.WhereClause = ContentFilter.from_binary(data)

    def __str__(self):

        return 'EventFilter(' + 'SelectClauses:' + str(self.SelectClauses) + ', ' + \

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

    __repr__ = __str__

class AggregateConfiguration(FrozenClass):

    __repr__ = __str__

class ContentFilterElement(FrozenClass):

    '''

    :ivar FilterOperator:

    :vartype FilterOperator: FilterOperator

    :ivar FilterOperands:

    :vartype FilterOperands: ExtensionObject

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.FilterOperator = FilterOperator(0)

        self.FilterOperands = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(uatype_UInt32.pack(self.FilterOperator.value))

        packet.append(uatype_Int32.pack(len(self.FilterOperands)))

        for fieldname in self.FilterOperands:

            packet.append(extensionobject_to_binary(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return ContentFilterElement(data)

    def _binary_init(self, data):

        self.FilterOperator = FilterOperator(uatype_UInt32.unpack(data.read(4))[0])

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(extensionobject_from_binary(data))

        self.FilterOperands = array

    def __str__(self):

        return 'ContentFilterElement(' + 'FilterOperator:' + str(self.FilterOperator) + ', ' + \

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

    __repr__ = __str__

class ContentFilter(FrozenClass):

    __repr__ = __str__

class RegisterServer2Parameters(FrozenClass):

    '''

    :ivar Server:

    :vartype Server: RegisteredServer

    :ivar DiscoveryConfiguration:

    :vartype DiscoveryConfiguration: ExtensionObject

    '''

    def __init__(self, binary=None):

        if binary is not None:

            self._binary_init(binary)

            self._freeze = True

            return

        self.Server = RegisteredServer()

        self.DiscoveryConfiguration = []

        self._freeze = True

    def to_binary(self):

        packet = []

        packet.append(self.Server.to_binary())

        packet.append(uatype_Int32.pack(len(self.DiscoveryConfiguration)))

        for fieldname in self.DiscoveryConfiguration:

            packet.append(extensionobject_to_binary(fieldname))

        return b''.join(packet)

    @staticmethod

    def from_binary(data):

        return RegisterServer2Parameters(data)

    def _binary_init(self, data):

        self.Server = RegisteredServer.from_binary(data)

        length = uatype_Int32.unpack(data.read(4))[0]

        array = []

        if length != -1:

            for _ in range(0, length):

                array.append(extensionobject_from_binary(data))

        self.DiscoveryConfiguration = array

    def __str__(self):

        return 'RegisterServer2Parameters(' + 'Server:' + str(self.Server) + ', ' + \

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

    __repr__ = __str__

class RegisterServer2Request(FrozenClass):