FreeOpcUa /
python-opcua
| @@ 11854-11888 (lines=35) @@ | ||
| 11851 | ||
| 11852 | __repr__ = __str__ |
|
| 11853 | ||
| 11854 | ||
| 11855 | class SubscriptionAcknowledgement(FrozenClass): |
|
| 11856 | ''' |
|
| 11857 | :ivar SubscriptionId: |
|
| 11858 | :vartype SubscriptionId: UInt32 |
|
| 11859 | :ivar SequenceNumber: |
|
| 11860 | :vartype SequenceNumber: UInt32 |
|
| 11861 | ''' |
|
| 11862 | def __init__(self, binary=None): |
|
| 11863 | if binary is not None: |
|
| 11864 | self._binary_init(binary) |
|
| 11865 | self._freeze = True |
|
| 11866 | return |
|
| 11867 | self.SubscriptionId = 0 |
|
| 11868 | self.SequenceNumber = 0 |
|
| 11869 | self._freeze = True |
|
| 11870 | ||
| 11871 | def to_binary(self): |
|
| 11872 | packet = [] |
|
| 11873 | packet.append(uatype_UInt32.pack(self.SubscriptionId)) |
|
| 11874 | packet.append(uatype_UInt32.pack(self.SequenceNumber)) |
|
| 11875 | return b''.join(packet) |
|
| 11876 | ||
| 11877 | @staticmethod |
|
| 11878 | def from_binary(data): |
|
| 11879 | return SubscriptionAcknowledgement(data) |
|
| 11880 | ||
| 11881 | def _binary_init(self, data): |
|
| 11882 | self.SubscriptionId = uatype_UInt32.unpack(data.read(4))[0] |
|
| 11883 | self.SequenceNumber = uatype_UInt32.unpack(data.read(4))[0] |
|
| 11884 | ||
| 11885 | def __str__(self): |
|
| 11886 | return 'SubscriptionAcknowledgement(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \ |
|
| 11887 | 'SequenceNumber:' + str(self.SequenceNumber) + ')' |
|
| 11888 | ||
| 11889 | __repr__ = __str__ |
|
| 11890 | ||
| 11891 | ||
| @@ 13905-13939 (lines=35) @@ | ||
| 13902 | ||
| 13903 | __repr__ = __str__ |
|
| 13904 | ||
| 13905 | ||
| 13906 | class XVType(FrozenClass): |
|
| 13907 | ''' |
|
| 13908 | :ivar X: |
|
| 13909 | :vartype X: Double |
|
| 13910 | :ivar Value: |
|
| 13911 | :vartype Value: Float |
|
| 13912 | ''' |
|
| 13913 | def __init__(self, binary=None): |
|
| 13914 | if binary is not None: |
|
| 13915 | self._binary_init(binary) |
|
| 13916 | self._freeze = True |
|
| 13917 | return |
|
| 13918 | self.X = 0 |
|
| 13919 | self.Value = 0 |
|
| 13920 | self._freeze = True |
|
| 13921 | ||
| 13922 | def to_binary(self): |
|
| 13923 | packet = [] |
|
| 13924 | packet.append(uatype_Double.pack(self.X)) |
|
| 13925 | packet.append(uatype_Float.pack(self.Value)) |
|
| 13926 | return b''.join(packet) |
|
| 13927 | ||
| 13928 | @staticmethod |
|
| 13929 | def from_binary(data): |
|
| 13930 | return XVType(data) |
|
| 13931 | ||
| 13932 | def _binary_init(self, data): |
|
| 13933 | self.X = uatype_Double.unpack(data.read(8))[0] |
|
| 13934 | self.Value = uatype_Float.unpack(data.read(4))[0] |
|
| 13935 | ||
| 13936 | def __str__(self): |
|
| 13937 | return 'XVType(' + 'X:' + str(self.X) + ', ' + \ |
|
| 13938 | 'Value:' + str(self.Value) + ')' |
|
| 13939 | ||
| 13940 | __repr__ = __str__ |
|
| 13941 | ||
| 13942 | ||
| @@ 13811-13845 (lines=35) @@ | ||
| 13808 | ||
| 13809 | __repr__ = __str__ |
|
| 13810 | ||
| 13811 | ||
| 13812 | class DoubleComplexNumberType(FrozenClass): |
|
| 13813 | ''' |
|
| 13814 | :ivar Real: |
|
| 13815 | :vartype Real: Double |
|
| 13816 | :ivar Imaginary: |
|
| 13817 | :vartype Imaginary: Double |
|
| 13818 | ''' |
|
| 13819 | def __init__(self, binary=None): |
|
| 13820 | if binary is not None: |
|
| 13821 | self._binary_init(binary) |
|
| 13822 | self._freeze = True |
|
| 13823 | return |
|
| 13824 | self.Real = 0 |
|
| 13825 | self.Imaginary = 0 |
|
| 13826 | self._freeze = True |
|
| 13827 | ||
| 13828 | def to_binary(self): |
|
| 13829 | packet = [] |
|
| 13830 | packet.append(uatype_Double.pack(self.Real)) |
|
| 13831 | packet.append(uatype_Double.pack(self.Imaginary)) |
|
| 13832 | return b''.join(packet) |
|
| 13833 | ||
| 13834 | @staticmethod |
|
| 13835 | def from_binary(data): |
|
| 13836 | return DoubleComplexNumberType(data) |
|
| 13837 | ||
| 13838 | def _binary_init(self, data): |
|
| 13839 | self.Real = uatype_Double.unpack(data.read(8))[0] |
|
| 13840 | self.Imaginary = uatype_Double.unpack(data.read(8))[0] |
|
| 13841 | ||
| 13842 | def __str__(self): |
|
| 13843 | return 'DoubleComplexNumberType(' + 'Real:' + str(self.Real) + ', ' + \ |
|
| 13844 | 'Imaginary:' + str(self.Imaginary) + ')' |
|
| 13845 | ||
| 13846 | __repr__ = __str__ |
|
| 13847 | ||
| 13848 | ||
| @@ 13774-13808 (lines=35) @@ | ||
| 13771 | ||
| 13772 | __repr__ = __str__ |
|
| 13773 | ||
| 13774 | ||
| 13775 | class ComplexNumberType(FrozenClass): |
|
| 13776 | ''' |
|
| 13777 | :ivar Real: |
|
| 13778 | :vartype Real: Float |
|
| 13779 | :ivar Imaginary: |
|
| 13780 | :vartype Imaginary: Float |
|
| 13781 | ''' |
|
| 13782 | def __init__(self, binary=None): |
|
| 13783 | if binary is not None: |
|
| 13784 | self._binary_init(binary) |
|
| 13785 | self._freeze = True |
|
| 13786 | return |
|
| 13787 | self.Real = 0 |
|
| 13788 | self.Imaginary = 0 |
|
| 13789 | self._freeze = True |
|
| 13790 | ||
| 13791 | def to_binary(self): |
|
| 13792 | packet = [] |
|
| 13793 | packet.append(uatype_Float.pack(self.Real)) |
|
| 13794 | packet.append(uatype_Float.pack(self.Imaginary)) |
|
| 13795 | return b''.join(packet) |
|
| 13796 | ||
| 13797 | @staticmethod |
|
| 13798 | def from_binary(data): |
|
| 13799 | return ComplexNumberType(data) |
|
| 13800 | ||
| 13801 | def _binary_init(self, data): |
|
| 13802 | self.Real = uatype_Float.unpack(data.read(4))[0] |
|
| 13803 | self.Imaginary = uatype_Float.unpack(data.read(4))[0] |
|
| 13804 | ||
| 13805 | def __str__(self): |
|
| 13806 | return 'ComplexNumberType(' + 'Real:' + str(self.Real) + ', ' + \ |
|
| 13807 | 'Imaginary:' + str(self.Imaginary) + ')' |
|
| 13808 | ||
| 13809 | __repr__ = __str__ |
|
| 13810 | ||
| 13811 | ||
| @@ 13688-13722 (lines=35) @@ | ||
| 13685 | ||
| 13686 | __repr__ = __str__ |
|
| 13687 | ||
| 13688 | ||
| 13689 | class Range(FrozenClass): |
|
| 13690 | ''' |
|
| 13691 | :ivar Low: |
|
| 13692 | :vartype Low: Double |
|
| 13693 | :ivar High: |
|
| 13694 | :vartype High: Double |
|
| 13695 | ''' |
|
| 13696 | def __init__(self, binary=None): |
|
| 13697 | if binary is not None: |
|
| 13698 | self._binary_init(binary) |
|
| 13699 | self._freeze = True |
|
| 13700 | return |
|
| 13701 | self.Low = 0 |
|
| 13702 | self.High = 0 |
|
| 13703 | self._freeze = True |
|
| 13704 | ||
| 13705 | def to_binary(self): |
|
| 13706 | packet = [] |
|
| 13707 | packet.append(uatype_Double.pack(self.Low)) |
|
| 13708 | packet.append(uatype_Double.pack(self.High)) |
|
| 13709 | return b''.join(packet) |
|
| 13710 | ||
| 13711 | @staticmethod |
|
| 13712 | def from_binary(data): |
|
| 13713 | return Range(data) |
|
| 13714 | ||
| 13715 | def _binary_init(self, data): |
|
| 13716 | self.Low = uatype_Double.unpack(data.read(8))[0] |
|
| 13717 | self.High = uatype_Double.unpack(data.read(8))[0] |
|
| 13718 | ||
| 13719 | def __str__(self): |
|
| 13720 | return 'Range(' + 'Low:' + str(self.Low) + ', ' + \ |
|
| 13721 | 'High:' + str(self.High) + ')' |
|
| 13722 | ||
| 13723 | __repr__ = __str__ |
|
| 13724 | ||
| 13725 | ||
| @@ 13323-13357 (lines=35) @@ | ||
| 13320 | ||
| 13321 | __repr__ = __str__ |
|
| 13322 | ||
| 13323 | ||
| 13324 | class ServiceCounterDataType(FrozenClass): |
|
| 13325 | ''' |
|
| 13326 | :ivar TotalCount: |
|
| 13327 | :vartype TotalCount: UInt32 |
|
| 13328 | :ivar ErrorCount: |
|
| 13329 | :vartype ErrorCount: UInt32 |
|
| 13330 | ''' |
|
| 13331 | def __init__(self, binary=None): |
|
| 13332 | if binary is not None: |
|
| 13333 | self._binary_init(binary) |
|
| 13334 | self._freeze = True |
|
| 13335 | return |
|
| 13336 | self.TotalCount = 0 |
|
| 13337 | self.ErrorCount = 0 |
|
| 13338 | self._freeze = True |
|
| 13339 | ||
| 13340 | def to_binary(self): |
|
| 13341 | packet = [] |
|
| 13342 | packet.append(uatype_UInt32.pack(self.TotalCount)) |
|
| 13343 | packet.append(uatype_UInt32.pack(self.ErrorCount)) |
|
| 13344 | return b''.join(packet) |
|
| 13345 | ||
| 13346 | @staticmethod |
|
| 13347 | def from_binary(data): |
|
| 13348 | return ServiceCounterDataType(data) |
|
| 13349 | ||
| 13350 | def _binary_init(self, data): |
|
| 13351 | self.TotalCount = uatype_UInt32.unpack(data.read(4))[0] |
|
| 13352 | self.ErrorCount = uatype_UInt32.unpack(data.read(4))[0] |
|
| 13353 | ||
| 13354 | def __str__(self): |
|
| 13355 | return 'ServiceCounterDataType(' + 'TotalCount:' + str(self.TotalCount) + ', ' + \ |
|
| 13356 | 'ErrorCount:' + str(self.ErrorCount) + ')' |
|
| 13357 | ||
| 13358 | __repr__ = __str__ |
|
| 13359 | ||
| 13360 | ||
| @@ 12092-12126 (lines=35) @@ | ||
| 12089 | ||
| 12090 | __repr__ = __str__ |
|
| 12091 | ||
| 12092 | ||
| 12093 | class RepublishParameters(FrozenClass): |
|
| 12094 | ''' |
|
| 12095 | :ivar SubscriptionId: |
|
| 12096 | :vartype SubscriptionId: UInt32 |
|
| 12097 | :ivar RetransmitSequenceNumber: |
|
| 12098 | :vartype RetransmitSequenceNumber: UInt32 |
|
| 12099 | ''' |
|
| 12100 | def __init__(self, binary=None): |
|
| 12101 | if binary is not None: |
|
| 12102 | self._binary_init(binary) |
|
| 12103 | self._freeze = True |
|
| 12104 | return |
|
| 12105 | self.SubscriptionId = 0 |
|
| 12106 | self.RetransmitSequenceNumber = 0 |
|
| 12107 | self._freeze = True |
|
| 12108 | ||
| 12109 | def to_binary(self): |
|
| 12110 | packet = [] |
|
| 12111 | packet.append(uatype_UInt32.pack(self.SubscriptionId)) |
|
| 12112 | packet.append(uatype_UInt32.pack(self.RetransmitSequenceNumber)) |
|
| 12113 | return b''.join(packet) |
|
| 12114 | ||
| 12115 | @staticmethod |
|
| 12116 | def from_binary(data): |
|
| 12117 | return RepublishParameters(data) |
|
| 12118 | ||
| 12119 | def _binary_init(self, data): |
|
| 12120 | self.SubscriptionId = uatype_UInt32.unpack(data.read(4))[0] |
|
| 12121 | self.RetransmitSequenceNumber = uatype_UInt32.unpack(data.read(4))[0] |
|
| 12122 | ||
| 12123 | def __str__(self): |
|
| 12124 | return 'RepublishParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \ |
|
| 12125 | 'RetransmitSequenceNumber:' + str(self.RetransmitSequenceNumber) + ')' |
|
| 12126 | ||
| 12127 | __repr__ = __str__ |
|
| 12128 | ||
| 12129 | ||
| @@ 1062-1096 (lines=35) @@ | ||
| 1059 | ||
| 1060 | __repr__ = __str__ |
|
| 1061 | ||
| 1062 | ||
| 1063 | class TimeZoneDataType(FrozenClass): |
|
| 1064 | ''' |
|
| 1065 | :ivar Offset: |
|
| 1066 | :vartype Offset: Int16 |
|
| 1067 | :ivar DaylightSavingInOffset: |
|
| 1068 | :vartype DaylightSavingInOffset: Boolean |
|
| 1069 | ''' |
|
| 1070 | def __init__(self, binary=None): |
|
| 1071 | if binary is not None: |
|
| 1072 | self._binary_init(binary) |
|
| 1073 | self._freeze = True |
|
| 1074 | return |
|
| 1075 | self.Offset = 0 |
|
| 1076 | self.DaylightSavingInOffset = True |
|
| 1077 | self._freeze = True |
|
| 1078 | ||
| 1079 | def to_binary(self): |
|
| 1080 | packet = [] |
|
| 1081 | packet.append(uatype_Int16.pack(self.Offset)) |
|
| 1082 | packet.append(uatype_Boolean.pack(self.DaylightSavingInOffset)) |
|
| 1083 | return b''.join(packet) |
|
| 1084 | ||
| 1085 | @staticmethod |
|
| 1086 | def from_binary(data): |
|
| 1087 | return TimeZoneDataType(data) |
|
| 1088 | ||
| 1089 | def _binary_init(self, data): |
|
| 1090 | self.Offset = uatype_Int16.unpack(data.read(2))[0] |
|
| 1091 | self.DaylightSavingInOffset = uatype_Boolean.unpack(data.read(1))[0] |
|
| 1092 | ||
| 1093 | def __str__(self): |
|
| 1094 | return 'TimeZoneDataType(' + 'Offset:' + str(self.Offset) + ', ' + \ |
|
| 1095 | 'DaylightSavingInOffset:' + str(self.DaylightSavingInOffset) + ')' |
|
| 1096 | ||
| 1097 | __repr__ = __str__ |
|
| 1098 | ||
| 1099 | ||
| @@ 12254-12290 (lines=37) @@ | ||
| 12251 | ||
| 12252 | __repr__ = __str__ |
|
| 12253 | ||
| 12254 | ||
| 12255 | class TransferSubscriptionsParameters(FrozenClass): |
|
| 12256 | ''' |
|
| 12257 | :ivar SubscriptionIds: |
|
| 12258 | :vartype SubscriptionIds: UInt32 |
|
| 12259 | :ivar SendInitialValues: |
|
| 12260 | :vartype SendInitialValues: Boolean |
|
| 12261 | ''' |
|
| 12262 | def __init__(self, binary=None): |
|
| 12263 | if binary is not None: |
|
| 12264 | self._binary_init(binary) |
|
| 12265 | self._freeze = True |
|
| 12266 | return |
|
| 12267 | self.SubscriptionIds = [] |
|
| 12268 | self.SendInitialValues = True |
|
| 12269 | self._freeze = True |
|
| 12270 | ||
| 12271 | def to_binary(self): |
|
| 12272 | packet = [] |
|
| 12273 | packet.append(uatype_Int32.pack(len(self.SubscriptionIds))) |
|
| 12274 | for fieldname in self.SubscriptionIds: |
|
| 12275 | packet.append(uatype_UInt32.pack(fieldname)) |
|
| 12276 | packet.append(uatype_Boolean.pack(self.SendInitialValues)) |
|
| 12277 | return b''.join(packet) |
|
| 12278 | ||
| 12279 | @staticmethod |
|
| 12280 | def from_binary(data): |
|
| 12281 | return TransferSubscriptionsParameters(data) |
|
| 12282 | ||
| 12283 | def _binary_init(self, data): |
|
| 12284 | self.SubscriptionIds = unpack_uatype_array('UInt32', data) |
|
| 12285 | self.SendInitialValues = uatype_Boolean.unpack(data.read(1))[0] |
|
| 12286 | ||
| 12287 | def __str__(self): |
|
| 12288 | return 'TransferSubscriptionsParameters(' + 'SubscriptionIds:' + str(self.SubscriptionIds) + ', ' + \ |
|
| 12289 | 'SendInitialValues:' + str(self.SendInitialValues) + ')' |
|
| 12290 | ||
| 12291 | __repr__ = __str__ |
|
| 12292 | ||
| 12293 | ||
| @@ 11356-11392 (lines=37) @@ | ||
| 11353 | ||
| 11354 | __repr__ = __str__ |
|
| 11355 | ||
| 11356 | ||
| 11357 | class SetPublishingModeParameters(FrozenClass): |
|
| 11358 | ''' |
|
| 11359 | :ivar PublishingEnabled: |
|
| 11360 | :vartype PublishingEnabled: Boolean |
|
| 11361 | :ivar SubscriptionIds: |
|
| 11362 | :vartype SubscriptionIds: UInt32 |
|
| 11363 | ''' |
|
| 11364 | def __init__(self, binary=None): |
|
| 11365 | if binary is not None: |
|
| 11366 | self._binary_init(binary) |
|
| 11367 | self._freeze = True |
|
| 11368 | return |
|
| 11369 | self.PublishingEnabled = True |
|
| 11370 | self.SubscriptionIds = [] |
|
| 11371 | self._freeze = True |
|
| 11372 | ||
| 11373 | def to_binary(self): |
|
| 11374 | packet = [] |
|
| 11375 | packet.append(uatype_Boolean.pack(self.PublishingEnabled)) |
|
| 11376 | packet.append(uatype_Int32.pack(len(self.SubscriptionIds))) |
|
| 11377 | for fieldname in self.SubscriptionIds: |
|
| 11378 | packet.append(uatype_UInt32.pack(fieldname)) |
|
| 11379 | return b''.join(packet) |
|
| 11380 | ||
| 11381 | @staticmethod |
|
| 11382 | def from_binary(data): |
|
| 11383 | return SetPublishingModeParameters(data) |
|
| 11384 | ||
| 11385 | def _binary_init(self, data): |
|
| 11386 | self.PublishingEnabled = uatype_Boolean.unpack(data.read(1))[0] |
|
| 11387 | self.SubscriptionIds = unpack_uatype_array('UInt32', data) |
|
| 11388 | ||
| 11389 | def __str__(self): |
|
| 11390 | return 'SetPublishingModeParameters(' + 'PublishingEnabled:' + str(self.PublishingEnabled) + ', ' + \ |
|
| 11391 | 'SubscriptionIds:' + str(self.SubscriptionIds) + ')' |
|
| 11392 | ||
| 11393 | __repr__ = __str__ |
|
| 11394 | ||
| 11395 | ||
| @@ 10825-10861 (lines=37) @@ | ||
| 10822 | ||
| 10823 | __repr__ = __str__ |
|
| 10824 | ||
| 10825 | ||
| 10826 | class DeleteMonitoredItemsParameters(FrozenClass): |
|
| 10827 | ''' |
|
| 10828 | :ivar SubscriptionId: |
|
| 10829 | :vartype SubscriptionId: UInt32 |
|
| 10830 | :ivar MonitoredItemIds: |
|
| 10831 | :vartype MonitoredItemIds: UInt32 |
|
| 10832 | ''' |
|
| 10833 | def __init__(self, binary=None): |
|
| 10834 | if binary is not None: |
|
| 10835 | self._binary_init(binary) |
|
| 10836 | self._freeze = True |
|
| 10837 | return |
|
| 10838 | self.SubscriptionId = 0 |
|
| 10839 | self.MonitoredItemIds = [] |
|
| 10840 | self._freeze = True |
|
| 10841 | ||
| 10842 | def to_binary(self): |
|
| 10843 | packet = [] |
|
| 10844 | packet.append(uatype_UInt32.pack(self.SubscriptionId)) |
|
| 10845 | packet.append(uatype_Int32.pack(len(self.MonitoredItemIds))) |
|
| 10846 | for fieldname in self.MonitoredItemIds: |
|
| 10847 | packet.append(uatype_UInt32.pack(fieldname)) |
|
| 10848 | return b''.join(packet) |
|
| 10849 | ||
| 10850 | @staticmethod |
|
| 10851 | def from_binary(data): |
|
| 10852 | return DeleteMonitoredItemsParameters(data) |
|
| 10853 | ||
| 10854 | def _binary_init(self, data): |
|
| 10855 | self.SubscriptionId = uatype_UInt32.unpack(data.read(4))[0] |
|
| 10856 | self.MonitoredItemIds = unpack_uatype_array('UInt32', data) |
|
| 10857 | ||
| 10858 | def __str__(self): |
|
| 10859 | return 'DeleteMonitoredItemsParameters(' + 'SubscriptionId:' + str(self.SubscriptionId) + ', ' + \ |
|
| 10860 | 'MonitoredItemIds:' + str(self.MonitoredItemIds) + ')' |
|
| 10861 | ||
| 10862 | __repr__ = __str__ |
|
| 10863 | ||
| 10864 | ||
| @@ 8188-8224 (lines=37) @@ | ||
| 8185 | ||
| 8186 | __repr__ = __str__ |
|
| 8187 | ||
| 8188 | ||
| 8189 | class ReadAtTimeDetails(FrozenClass): |
|
| 8190 | ''' |
|
| 8191 | :ivar ReqTimes: |
|
| 8192 | :vartype ReqTimes: DateTime |
|
| 8193 | :ivar UseSimpleBounds: |
|
| 8194 | :vartype UseSimpleBounds: Boolean |
|
| 8195 | ''' |
|
| 8196 | def __init__(self, binary=None): |
|
| 8197 | if binary is not None: |
|
| 8198 | self._binary_init(binary) |
|
| 8199 | self._freeze = True |
|
| 8200 | return |
|
| 8201 | self.ReqTimes = [] |
|
| 8202 | self.UseSimpleBounds = True |
|
| 8203 | self._freeze = True |
|
| 8204 | ||
| 8205 | def to_binary(self): |
|
| 8206 | packet = [] |
|
| 8207 | packet.append(uatype_Int32.pack(len(self.ReqTimes))) |
|
| 8208 | for fieldname in self.ReqTimes: |
|
| 8209 | packet.append(pack_datetime(fieldname)) |
|
| 8210 | packet.append(uatype_Boolean.pack(self.UseSimpleBounds)) |
|
| 8211 | return b''.join(packet) |
|
| 8212 | ||
| 8213 | @staticmethod |
|
| 8214 | def from_binary(data): |
|
| 8215 | return ReadAtTimeDetails(data) |
|
| 8216 | ||
| 8217 | def _binary_init(self, data): |
|
| 8218 | self.ReqTimes = unpack_uatype_array('DateTime', data) |
|
| 8219 | self.UseSimpleBounds = uatype_Boolean.unpack(data.read(1))[0] |
|
| 8220 | ||
| 8221 | def __str__(self): |
|
| 8222 | return 'ReadAtTimeDetails(' + 'ReqTimes:' + str(self.ReqTimes) + ', ' + \ |
|
| 8223 | 'UseSimpleBounds:' + str(self.UseSimpleBounds) + ')' |
|
| 8224 | ||
| 8225 | __repr__ = __str__ |
|
| 8226 | ||
| 8227 | ||
| @@ 5623-5659 (lines=37) @@ | ||
| 5620 | ||
| 5621 | __repr__ = __str__ |
|
| 5622 | ||
| 5623 | ||
| 5624 | class BrowseNextParameters(FrozenClass): |
|
| 5625 | ''' |
|
| 5626 | :ivar ReleaseContinuationPoints: |
|
| 5627 | :vartype ReleaseContinuationPoints: Boolean |
|
| 5628 | :ivar ContinuationPoints: |
|
| 5629 | :vartype ContinuationPoints: ByteString |
|
| 5630 | ''' |
|
| 5631 | def __init__(self, binary=None): |
|
| 5632 | if binary is not None: |
|
| 5633 | self._binary_init(binary) |
|
| 5634 | self._freeze = True |
|
| 5635 | return |
|
| 5636 | self.ReleaseContinuationPoints = True |
|
| 5637 | self.ContinuationPoints = [] |
|
| 5638 | self._freeze = True |
|
| 5639 | ||
| 5640 | def to_binary(self): |
|
| 5641 | packet = [] |
|
| 5642 | packet.append(uatype_Boolean.pack(self.ReleaseContinuationPoints)) |
|
| 5643 | packet.append(uatype_Int32.pack(len(self.ContinuationPoints))) |
|
| 5644 | for fieldname in self.ContinuationPoints: |
|
| 5645 | packet.append(pack_bytes(fieldname)) |
|
| 5646 | return b''.join(packet) |
|
| 5647 | ||
| 5648 | @staticmethod |
|
| 5649 | def from_binary(data): |
|
| 5650 | return BrowseNextParameters(data) |
|
| 5651 | ||
| 5652 | def _binary_init(self, data): |
|
| 5653 | self.ReleaseContinuationPoints = uatype_Boolean.unpack(data.read(1))[0] |
|
| 5654 | self.ContinuationPoints = unpack_uatype_array('ByteString', data) |
|
| 5655 | ||
| 5656 | def __str__(self): |
|
| 5657 | return 'BrowseNextParameters(' + 'ReleaseContinuationPoints:' + str(self.ReleaseContinuationPoints) + ', ' + \ |
|
| 5658 | 'ContinuationPoints:' + str(self.ContinuationPoints) + ')' |
|
| 5659 | ||
| 5660 | __repr__ = __str__ |
|
| 5661 | ||
| 5662 | ||
| @@ 5854-5891 (lines=38) @@ | ||
| 5851 | ||
| 5852 | __repr__ = __str__ |
|
| 5853 | ||
| 5854 | ||
| 5855 | class RelativePath(FrozenClass): |
|
| 5856 | ''' |
|
| 5857 | A relative path constructed from reference types and browse names. |
|
| 5858 | ||
| 5859 | :ivar Elements: |
|
| 5860 | :vartype Elements: RelativePathElement |
|
| 5861 | ''' |
|
| 5862 | def __init__(self, binary=None): |
|
| 5863 | if binary is not None: |
|
| 5864 | self._binary_init(binary) |
|
| 5865 | self._freeze = True |
|
| 5866 | return |
|
| 5867 | self.Elements = [] |
|
| 5868 | self._freeze = True |
|
| 5869 | ||
| 5870 | def to_binary(self): |
|
| 5871 | packet = [] |
|
| 5872 | packet.append(uatype_Int32.pack(len(self.Elements))) |
|
| 5873 | for fieldname in self.Elements: |
|
| 5874 | packet.append(fieldname.to_binary()) |
|
| 5875 | return b''.join(packet) |
|
| 5876 | ||
| 5877 | @staticmethod |
|
| 5878 | def from_binary(data): |
|
| 5879 | return RelativePath(data) |
|
| 5880 | ||
| 5881 | def _binary_init(self, data): |
|
| 5882 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 5883 | array = [] |
|
| 5884 | if length != -1: |
|
| 5885 | for _ in range(0, length): |
|
| 5886 | array.append(RelativePathElement.from_binary(data)) |
|
| 5887 | self.Elements = array |
|
| 5888 | ||
| 5889 | def __str__(self): |
|
| 5890 | return 'RelativePath(' + 'Elements:' + str(self.Elements) + ')' |
|
| 5891 | ||
| 5892 | __repr__ = __str__ |
|
| 5893 | ||
| 5894 | ||
| @@ 11891-11926 (lines=36) @@ | ||
| 11888 | ||
| 11889 | __repr__ = __str__ |
|
| 11890 | ||
| 11891 | ||
| 11892 | class PublishParameters(FrozenClass): |
|
| 11893 | ''' |
|
| 11894 | :ivar SubscriptionAcknowledgements: |
|
| 11895 | :vartype SubscriptionAcknowledgements: SubscriptionAcknowledgement |
|
| 11896 | ''' |
|
| 11897 | def __init__(self, binary=None): |
|
| 11898 | if binary is not None: |
|
| 11899 | self._binary_init(binary) |
|
| 11900 | self._freeze = True |
|
| 11901 | return |
|
| 11902 | self.SubscriptionAcknowledgements = [] |
|
| 11903 | self._freeze = True |
|
| 11904 | ||
| 11905 | def to_binary(self): |
|
| 11906 | packet = [] |
|
| 11907 | packet.append(uatype_Int32.pack(len(self.SubscriptionAcknowledgements))) |
|
| 11908 | for fieldname in self.SubscriptionAcknowledgements: |
|
| 11909 | packet.append(fieldname.to_binary()) |
|
| 11910 | return b''.join(packet) |
|
| 11911 | ||
| 11912 | @staticmethod |
|
| 11913 | def from_binary(data): |
|
| 11914 | return PublishParameters(data) |
|
| 11915 | ||
| 11916 | def _binary_init(self, data): |
|
| 11917 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 11918 | array = [] |
|
| 11919 | if length != -1: |
|
| 11920 | for _ in range(0, length): |
|
| 11921 | array.append(SubscriptionAcknowledgement.from_binary(data)) |
|
| 11922 | self.SubscriptionAcknowledgements = array |
|
| 11923 | ||
| 11924 | def __str__(self): |
|
| 11925 | return 'PublishParameters(' + 'SubscriptionAcknowledgements:' + str(self.SubscriptionAcknowledgements) + ')' |
|
| 11926 | ||
| 11927 | __repr__ = __str__ |
|
| 11928 | ||
| 11929 | ||
| @@ 11779-11814 (lines=36) @@ | ||
| 11776 | ||
| 11777 | __repr__ = __str__ |
|
| 11778 | ||
| 11779 | ||
| 11780 | class HistoryEventFieldList(FrozenClass): |
|
| 11781 | ''' |
|
| 11782 | :ivar EventFields: |
|
| 11783 | :vartype EventFields: Variant |
|
| 11784 | ''' |
|
| 11785 | def __init__(self, binary=None): |
|
| 11786 | if binary is not None: |
|
| 11787 | self._binary_init(binary) |
|
| 11788 | self._freeze = True |
|
| 11789 | return |
|
| 11790 | self.EventFields = [] |
|
| 11791 | self._freeze = True |
|
| 11792 | ||
| 11793 | def to_binary(self): |
|
| 11794 | packet = [] |
|
| 11795 | packet.append(uatype_Int32.pack(len(self.EventFields))) |
|
| 11796 | for fieldname in self.EventFields: |
|
| 11797 | packet.append(fieldname.to_binary()) |
|
| 11798 | return b''.join(packet) |
|
| 11799 | ||
| 11800 | @staticmethod |
|
| 11801 | def from_binary(data): |
|
| 11802 | return HistoryEventFieldList(data) |
|
| 11803 | ||
| 11804 | def _binary_init(self, data): |
|
| 11805 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 11806 | array = [] |
|
| 11807 | if length != -1: |
|
| 11808 | for _ in range(0, length): |
|
| 11809 | array.append(Variant.from_binary(data)) |
|
| 11810 | self.EventFields = array |
|
| 11811 | ||
| 11812 | def __str__(self): |
|
| 11813 | return 'HistoryEventFieldList(' + 'EventFields:' + str(self.EventFields) + ')' |
|
| 11814 | ||
| 11815 | __repr__ = __str__ |
|
| 11816 | ||
| 11817 | ||
| @@ 11697-11732 (lines=36) @@ | ||
| 11694 | ||
| 11695 | __repr__ = __str__ |
|
| 11696 | ||
| 11697 | ||
| 11698 | class EventNotificationList(FrozenClass): |
|
| 11699 | ''' |
|
| 11700 | :ivar Events: |
|
| 11701 | :vartype Events: EventFieldList |
|
| 11702 | ''' |
|
| 11703 | def __init__(self, binary=None): |
|
| 11704 | if binary is not None: |
|
| 11705 | self._binary_init(binary) |
|
| 11706 | self._freeze = True |
|
| 11707 | return |
|
| 11708 | self.Events = [] |
|
| 11709 | self._freeze = True |
|
| 11710 | ||
| 11711 | def to_binary(self): |
|
| 11712 | packet = [] |
|
| 11713 | packet.append(uatype_Int32.pack(len(self.Events))) |
|
| 11714 | for fieldname in self.Events: |
|
| 11715 | packet.append(fieldname.to_binary()) |
|
| 11716 | return b''.join(packet) |
|
| 11717 | ||
| 11718 | @staticmethod |
|
| 11719 | def from_binary(data): |
|
| 11720 | return EventNotificationList(data) |
|
| 11721 | ||
| 11722 | def _binary_init(self, data): |
|
| 11723 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 11724 | array = [] |
|
| 11725 | if length != -1: |
|
| 11726 | for _ in range(0, length): |
|
| 11727 | array.append(EventFieldList.from_binary(data)) |
|
| 11728 | self.Events = array |
|
| 11729 | ||
| 11730 | def __str__(self): |
|
| 11731 | return 'EventNotificationList(' + 'Events:' + str(self.Events) + ')' |
|
| 11732 | ||
| 11733 | __repr__ = __str__ |
|
| 11734 | ||
| 11735 | ||
| @@ 9387-9422 (lines=36) @@ | ||
| 9384 | ||
| 9385 | __repr__ = __str__ |
|
| 9386 | ||
| 9387 | ||
| 9388 | class CallParameters(FrozenClass): |
|
| 9389 | ''' |
|
| 9390 | :ivar MethodsToCall: |
|
| 9391 | :vartype MethodsToCall: CallMethodRequest |
|
| 9392 | ''' |
|
| 9393 | def __init__(self, binary=None): |
|
| 9394 | if binary is not None: |
|
| 9395 | self._binary_init(binary) |
|
| 9396 | self._freeze = True |
|
| 9397 | return |
|
| 9398 | self.MethodsToCall = [] |
|
| 9399 | self._freeze = True |
|
| 9400 | ||
| 9401 | def to_binary(self): |
|
| 9402 | packet = [] |
|
| 9403 | packet.append(uatype_Int32.pack(len(self.MethodsToCall))) |
|
| 9404 | for fieldname in self.MethodsToCall: |
|
| 9405 | packet.append(fieldname.to_binary()) |
|
| 9406 | return b''.join(packet) |
|
| 9407 | ||
| 9408 | @staticmethod |
|
| 9409 | def from_binary(data): |
|
| 9410 | return CallParameters(data) |
|
| 9411 | ||
| 9412 | def _binary_init(self, data): |
|
| 9413 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 9414 | array = [] |
|
| 9415 | if length != -1: |
|
| 9416 | for _ in range(0, length): |
|
| 9417 | array.append(CallMethodRequest.from_binary(data)) |
|
| 9418 | self.MethodsToCall = array |
|
| 9419 | ||
| 9420 | def __str__(self): |
|
| 9421 | return 'CallParameters(' + 'MethodsToCall:' + str(self.MethodsToCall) + ')' |
|
| 9422 | ||
| 9423 | __repr__ = __str__ |
|
| 9424 | ||
| 9425 | ||
| @@ 9123-9158 (lines=36) @@ | ||
| 9120 | ||
| 9121 | __repr__ = __str__ |
|
| 9122 | ||
| 9123 | ||
| 9124 | class HistoryUpdateParameters(FrozenClass): |
|
| 9125 | ''' |
|
| 9126 | :ivar HistoryUpdateDetails: |
|
| 9127 | :vartype HistoryUpdateDetails: ExtensionObject |
|
| 9128 | ''' |
|
| 9129 | def __init__(self, binary=None): |
|
| 9130 | if binary is not None: |
|
| 9131 | self._binary_init(binary) |
|
| 9132 | self._freeze = True |
|
| 9133 | return |
|
| 9134 | self.HistoryUpdateDetails = [] |
|
| 9135 | self._freeze = True |
|
| 9136 | ||
| 9137 | def to_binary(self): |
|
| 9138 | packet = [] |
|
| 9139 | packet.append(uatype_Int32.pack(len(self.HistoryUpdateDetails))) |
|
| 9140 | for fieldname in self.HistoryUpdateDetails: |
|
| 9141 | packet.append(extensionobject_to_binary(fieldname)) |
|
| 9142 | return b''.join(packet) |
|
| 9143 | ||
| 9144 | @staticmethod |
|
| 9145 | def from_binary(data): |
|
| 9146 | return HistoryUpdateParameters(data) |
|
| 9147 | ||
| 9148 | def _binary_init(self, data): |
|
| 9149 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 9150 | array = [] |
|
| 9151 | if length != -1: |
|
| 9152 | for _ in range(0, length): |
|
| 9153 | array.append(extensionobject_from_binary(data)) |
|
| 9154 | self.HistoryUpdateDetails = array |
|
| 9155 | ||
| 9156 | def __str__(self): |
|
| 9157 | return 'HistoryUpdateParameters(' + 'HistoryUpdateDetails:' + str(self.HistoryUpdateDetails) + ')' |
|
| 9158 | ||
| 9159 | __repr__ = __str__ |
|
| 9160 | ||
| 9161 | ||
| @@ 8608-8643 (lines=36) @@ | ||
| 8605 | ||
| 8606 | __repr__ = __str__ |
|
| 8607 | ||
| 8608 | ||
| 8609 | class WriteParameters(FrozenClass): |
|
| 8610 | ''' |
|
| 8611 | :ivar NodesToWrite: |
|
| 8612 | :vartype NodesToWrite: WriteValue |
|
| 8613 | ''' |
|
| 8614 | def __init__(self, binary=None): |
|
| 8615 | if binary is not None: |
|
| 8616 | self._binary_init(binary) |
|
| 8617 | self._freeze = True |
|
| 8618 | return |
|
| 8619 | self.NodesToWrite = [] |
|
| 8620 | self._freeze = True |
|
| 8621 | ||
| 8622 | def to_binary(self): |
|
| 8623 | packet = [] |
|
| 8624 | packet.append(uatype_Int32.pack(len(self.NodesToWrite))) |
|
| 8625 | for fieldname in self.NodesToWrite: |
|
| 8626 | packet.append(fieldname.to_binary()) |
|
| 8627 | return b''.join(packet) |
|
| 8628 | ||
| 8629 | @staticmethod |
|
| 8630 | def from_binary(data): |
|
| 8631 | return WriteParameters(data) |
|
| 8632 | ||
| 8633 | def _binary_init(self, data): |
|
| 8634 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 8635 | array = [] |
|
| 8636 | if length != -1: |
|
| 8637 | for _ in range(0, length): |
|
| 8638 | array.append(WriteValue.from_binary(data)) |
|
| 8639 | self.NodesToWrite = array |
|
| 8640 | ||
| 8641 | def __str__(self): |
|
| 8642 | return 'WriteParameters(' + 'NodesToWrite:' + str(self.NodesToWrite) + ')' |
|
| 8643 | ||
| 8644 | __repr__ = __str__ |
|
| 8645 | ||
| 8646 | ||
| @@ 8359-8394 (lines=36) @@ | ||
| 8356 | ||
| 8357 | __repr__ = __str__ |
|
| 8358 | ||
| 8359 | ||
| 8360 | class HistoryEvent(FrozenClass): |
|
| 8361 | ''' |
|
| 8362 | :ivar Events: |
|
| 8363 | :vartype Events: HistoryEventFieldList |
|
| 8364 | ''' |
|
| 8365 | def __init__(self, binary=None): |
|
| 8366 | if binary is not None: |
|
| 8367 | self._binary_init(binary) |
|
| 8368 | self._freeze = True |
|
| 8369 | return |
|
| 8370 | self.Events = [] |
|
| 8371 | self._freeze = True |
|
| 8372 | ||
| 8373 | def to_binary(self): |
|
| 8374 | packet = [] |
|
| 8375 | packet.append(uatype_Int32.pack(len(self.Events))) |
|
| 8376 | for fieldname in self.Events: |
|
| 8377 | packet.append(fieldname.to_binary()) |
|
| 8378 | return b''.join(packet) |
|
| 8379 | ||
| 8380 | @staticmethod |
|
| 8381 | def from_binary(data): |
|
| 8382 | return HistoryEvent(data) |
|
| 8383 | ||
| 8384 | def _binary_init(self, data): |
|
| 8385 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 8386 | array = [] |
|
| 8387 | if length != -1: |
|
| 8388 | for _ in range(0, length): |
|
| 8389 | array.append(HistoryEventFieldList.from_binary(data)) |
|
| 8390 | self.Events = array |
|
| 8391 | ||
| 8392 | def __str__(self): |
|
| 8393 | return 'HistoryEvent(' + 'Events:' + str(self.Events) + ')' |
|
| 8394 | ||
| 8395 | __repr__ = __str__ |
|
| 8396 | ||
| 8397 | ||
| @@ 8227-8262 (lines=36) @@ | ||
| 8224 | ||
| 8225 | __repr__ = __str__ |
|
| 8226 | ||
| 8227 | ||
| 8228 | class HistoryData(FrozenClass): |
|
| 8229 | ''' |
|
| 8230 | :ivar DataValues: |
|
| 8231 | :vartype DataValues: DataValue |
|
| 8232 | ''' |
|
| 8233 | def __init__(self, binary=None): |
|
| 8234 | if binary is not None: |
|
| 8235 | self._binary_init(binary) |
|
| 8236 | self._freeze = True |
|
| 8237 | return |
|
| 8238 | self.DataValues = [] |
|
| 8239 | self._freeze = True |
|
| 8240 | ||
| 8241 | def to_binary(self): |
|
| 8242 | packet = [] |
|
| 8243 | packet.append(uatype_Int32.pack(len(self.DataValues))) |
|
| 8244 | for fieldname in self.DataValues: |
|
| 8245 | packet.append(fieldname.to_binary()) |
|
| 8246 | return b''.join(packet) |
|
| 8247 | ||
| 8248 | @staticmethod |
|
| 8249 | def from_binary(data): |
|
| 8250 | return HistoryData(data) |
|
| 8251 | ||
| 8252 | def _binary_init(self, data): |
|
| 8253 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 8254 | array = [] |
|
| 8255 | if length != -1: |
|
| 8256 | for _ in range(0, length): |
|
| 8257 | array.append(DataValue.from_binary(data)) |
|
| 8258 | self.DataValues = array |
|
| 8259 | ||
| 8260 | def __str__(self): |
|
| 8261 | return 'HistoryData(' + 'DataValues:' + str(self.DataValues) + ')' |
|
| 8262 | ||
| 8263 | __repr__ = __str__ |
|
| 8264 | ||
| 8265 | ||
| @@ 6931-6966 (lines=36) @@ | ||
| 6928 | ||
| 6929 | __repr__ = __str__ |
|
| 6930 | ||
| 6931 | ||
| 6932 | class ContentFilter(FrozenClass): |
|
| 6933 | ''' |
|
| 6934 | :ivar Elements: |
|
| 6935 | :vartype Elements: ContentFilterElement |
|
| 6936 | ''' |
|
| 6937 | def __init__(self, binary=None): |
|
| 6938 | if binary is not None: |
|
| 6939 | self._binary_init(binary) |
|
| 6940 | self._freeze = True |
|
| 6941 | return |
|
| 6942 | self.Elements = [] |
|
| 6943 | self._freeze = True |
|
| 6944 | ||
| 6945 | def to_binary(self): |
|
| 6946 | packet = [] |
|
| 6947 | packet.append(uatype_Int32.pack(len(self.Elements))) |
|
| 6948 | for fieldname in self.Elements: |
|
| 6949 | packet.append(fieldname.to_binary()) |
|
| 6950 | return b''.join(packet) |
|
| 6951 | ||
| 6952 | @staticmethod |
|
| 6953 | def from_binary(data): |
|
| 6954 | return ContentFilter(data) |
|
| 6955 | ||
| 6956 | def _binary_init(self, data): |
|
| 6957 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 6958 | array = [] |
|
| 6959 | if length != -1: |
|
| 6960 | for _ in range(0, length): |
|
| 6961 | array.append(ContentFilterElement.from_binary(data)) |
|
| 6962 | self.Elements = array |
|
| 6963 | ||
| 6964 | def __str__(self): |
|
| 6965 | return 'ContentFilter(' + 'Elements:' + str(self.Elements) + ')' |
|
| 6966 | ||
| 6967 | __repr__ = __str__ |
|
| 6968 | ||
| 6969 | ||
| @@ 6332-6367 (lines=36) @@ | ||
| 6329 | ||
| 6330 | __repr__ = __str__ |
|
| 6331 | ||
| 6332 | ||
| 6333 | class UnregisterNodesParameters(FrozenClass): |
|
| 6334 | ''' |
|
| 6335 | :ivar NodesToUnregister: |
|
| 6336 | :vartype NodesToUnregister: NodeId |
|
| 6337 | ''' |
|
| 6338 | def __init__(self, binary=None): |
|
| 6339 | if binary is not None: |
|
| 6340 | self._binary_init(binary) |
|
| 6341 | self._freeze = True |
|
| 6342 | return |
|
| 6343 | self.NodesToUnregister = [] |
|
| 6344 | self._freeze = True |
|
| 6345 | ||
| 6346 | def to_binary(self): |
|
| 6347 | packet = [] |
|
| 6348 | packet.append(uatype_Int32.pack(len(self.NodesToUnregister))) |
|
| 6349 | for fieldname in self.NodesToUnregister: |
|
| 6350 | packet.append(fieldname.to_binary()) |
|
| 6351 | return b''.join(packet) |
|
| 6352 | ||
| 6353 | @staticmethod |
|
| 6354 | def from_binary(data): |
|
| 6355 | return UnregisterNodesParameters(data) |
|
| 6356 | ||
| 6357 | def _binary_init(self, data): |
|
| 6358 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 6359 | array = [] |
|
| 6360 | if length != -1: |
|
| 6361 | for _ in range(0, length): |
|
| 6362 | array.append(NodeId.from_binary(data)) |
|
| 6363 | self.NodesToUnregister = array |
|
| 6364 | ||
| 6365 | def __str__(self): |
|
| 6366 | return 'UnregisterNodesParameters(' + 'NodesToUnregister:' + str(self.NodesToUnregister) + ')' |
|
| 6367 | ||
| 6368 | __repr__ = __str__ |
|
| 6369 | ||
| 6370 | ||
| @@ 6249-6284 (lines=36) @@ | ||
| 6246 | ||
| 6247 | __repr__ = __str__ |
|
| 6248 | ||
| 6249 | ||
| 6250 | class RegisterNodesResult(FrozenClass): |
|
| 6251 | ''' |
|
| 6252 | :ivar RegisteredNodeIds: |
|
| 6253 | :vartype RegisteredNodeIds: NodeId |
|
| 6254 | ''' |
|
| 6255 | def __init__(self, binary=None): |
|
| 6256 | if binary is not None: |
|
| 6257 | self._binary_init(binary) |
|
| 6258 | self._freeze = True |
|
| 6259 | return |
|
| 6260 | self.RegisteredNodeIds = [] |
|
| 6261 | self._freeze = True |
|
| 6262 | ||
| 6263 | def to_binary(self): |
|
| 6264 | packet = [] |
|
| 6265 | packet.append(uatype_Int32.pack(len(self.RegisteredNodeIds))) |
|
| 6266 | for fieldname in self.RegisteredNodeIds: |
|
| 6267 | packet.append(fieldname.to_binary()) |
|
| 6268 | return b''.join(packet) |
|
| 6269 | ||
| 6270 | @staticmethod |
|
| 6271 | def from_binary(data): |
|
| 6272 | return RegisterNodesResult(data) |
|
| 6273 | ||
| 6274 | def _binary_init(self, data): |
|
| 6275 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 6276 | array = [] |
|
| 6277 | if length != -1: |
|
| 6278 | for _ in range(0, length): |
|
| 6279 | array.append(NodeId.from_binary(data)) |
|
| 6280 | self.RegisteredNodeIds = array |
|
| 6281 | ||
| 6282 | def __str__(self): |
|
| 6283 | return 'RegisterNodesResult(' + 'RegisteredNodeIds:' + str(self.RegisteredNodeIds) + ')' |
|
| 6284 | ||
| 6285 | __repr__ = __str__ |
|
| 6286 | ||
| 6287 | ||
| @@ 6166-6201 (lines=36) @@ | ||
| 6163 | ||
| 6164 | __repr__ = __str__ |
|
| 6165 | ||
| 6166 | ||
| 6167 | class RegisterNodesParameters(FrozenClass): |
|
| 6168 | ''' |
|
| 6169 | :ivar NodesToRegister: |
|
| 6170 | :vartype NodesToRegister: NodeId |
|
| 6171 | ''' |
|
| 6172 | def __init__(self, binary=None): |
|
| 6173 | if binary is not None: |
|
| 6174 | self._binary_init(binary) |
|
| 6175 | self._freeze = True |
|
| 6176 | return |
|
| 6177 | self.NodesToRegister = [] |
|
| 6178 | self._freeze = True |
|
| 6179 | ||
| 6180 | def to_binary(self): |
|
| 6181 | packet = [] |
|
| 6182 | packet.append(uatype_Int32.pack(len(self.NodesToRegister))) |
|
| 6183 | for fieldname in self.NodesToRegister: |
|
| 6184 | packet.append(fieldname.to_binary()) |
|
| 6185 | return b''.join(packet) |
|
| 6186 | ||
| 6187 | @staticmethod |
|
| 6188 | def from_binary(data): |
|
| 6189 | return RegisterNodesParameters(data) |
|
| 6190 | ||
| 6191 | def _binary_init(self, data): |
|
| 6192 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 6193 | array = [] |
|
| 6194 | if length != -1: |
|
| 6195 | for _ in range(0, length): |
|
| 6196 | array.append(NodeId.from_binary(data)) |
|
| 6197 | self.NodesToRegister = array |
|
| 6198 | ||
| 6199 | def __str__(self): |
|
| 6200 | return 'RegisterNodesParameters(' + 'NodesToRegister:' + str(self.NodesToRegister) + ')' |
|
| 6201 | ||
| 6202 | __repr__ = __str__ |
|
| 6203 | ||
| 6204 | ||
| @@ 6018-6053 (lines=36) @@ | ||
| 6015 | ||
| 6016 | __repr__ = __str__ |
|
| 6017 | ||
| 6018 | ||
| 6019 | class TranslateBrowsePathsToNodeIdsParameters(FrozenClass): |
|
| 6020 | ''' |
|
| 6021 | :ivar BrowsePaths: |
|
| 6022 | :vartype BrowsePaths: BrowsePath |
|
| 6023 | ''' |
|
| 6024 | def __init__(self, binary=None): |
|
| 6025 | if binary is not None: |
|
| 6026 | self._binary_init(binary) |
|
| 6027 | self._freeze = True |
|
| 6028 | return |
|
| 6029 | self.BrowsePaths = [] |
|
| 6030 | self._freeze = True |
|
| 6031 | ||
| 6032 | def to_binary(self): |
|
| 6033 | packet = [] |
|
| 6034 | packet.append(uatype_Int32.pack(len(self.BrowsePaths))) |
|
| 6035 | for fieldname in self.BrowsePaths: |
|
| 6036 | packet.append(fieldname.to_binary()) |
|
| 6037 | return b''.join(packet) |
|
| 6038 | ||
| 6039 | @staticmethod |
|
| 6040 | def from_binary(data): |
|
| 6041 | return TranslateBrowsePathsToNodeIdsParameters(data) |
|
| 6042 | ||
| 6043 | def _binary_init(self, data): |
|
| 6044 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 6045 | array = [] |
|
| 6046 | if length != -1: |
|
| 6047 | for _ in range(0, length): |
|
| 6048 | array.append(BrowsePath.from_binary(data)) |
|
| 6049 | self.BrowsePaths = array |
|
| 6050 | ||
| 6051 | def __str__(self): |
|
| 6052 | return 'TranslateBrowsePathsToNodeIdsParameters(' + 'BrowsePaths:' + str(self.BrowsePaths) + ')' |
|
| 6053 | ||
| 6054 | __repr__ = __str__ |
|
| 6055 | ||
| 6056 | ||
| @@ 5055-5090 (lines=36) @@ | ||
| 5052 | ||
| 5053 | __repr__ = __str__ |
|
| 5054 | ||
| 5055 | ||
| 5056 | class DeleteReferencesParameters(FrozenClass): |
|
| 5057 | ''' |
|
| 5058 | :ivar ReferencesToDelete: |
|
| 5059 | :vartype ReferencesToDelete: DeleteReferencesItem |
|
| 5060 | ''' |
|
| 5061 | def __init__(self, binary=None): |
|
| 5062 | if binary is not None: |
|
| 5063 | self._binary_init(binary) |
|
| 5064 | self._freeze = True |
|
| 5065 | return |
|
| 5066 | self.ReferencesToDelete = [] |
|
| 5067 | self._freeze = True |
|
| 5068 | ||
| 5069 | def to_binary(self): |
|
| 5070 | packet = [] |
|
| 5071 | packet.append(uatype_Int32.pack(len(self.ReferencesToDelete))) |
|
| 5072 | for fieldname in self.ReferencesToDelete: |
|
| 5073 | packet.append(fieldname.to_binary()) |
|
| 5074 | return b''.join(packet) |
|
| 5075 | ||
| 5076 | @staticmethod |
|
| 5077 | def from_binary(data): |
|
| 5078 | return DeleteReferencesParameters(data) |
|
| 5079 | ||
| 5080 | def _binary_init(self, data): |
|
| 5081 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 5082 | array = [] |
|
| 5083 | if length != -1: |
|
| 5084 | for _ in range(0, length): |
|
| 5085 | array.append(DeleteReferencesItem.from_binary(data)) |
|
| 5086 | self.ReferencesToDelete = array |
|
| 5087 | ||
| 5088 | def __str__(self): |
|
| 5089 | return 'DeleteReferencesParameters(' + 'ReferencesToDelete:' + str(self.ReferencesToDelete) + ')' |
|
| 5090 | ||
| 5091 | __repr__ = __str__ |
|
| 5092 | ||
| 5093 | ||
| @@ 4850-4885 (lines=36) @@ | ||
| 4847 | ||
| 4848 | __repr__ = __str__ |
|
| 4849 | ||
| 4850 | ||
| 4851 | class DeleteNodesParameters(FrozenClass): |
|
| 4852 | ''' |
|
| 4853 | :ivar NodesToDelete: |
|
| 4854 | :vartype NodesToDelete: DeleteNodesItem |
|
| 4855 | ''' |
|
| 4856 | def __init__(self, binary=None): |
|
| 4857 | if binary is not None: |
|
| 4858 | self._binary_init(binary) |
|
| 4859 | self._freeze = True |
|
| 4860 | return |
|
| 4861 | self.NodesToDelete = [] |
|
| 4862 | self._freeze = True |
|
| 4863 | ||
| 4864 | def to_binary(self): |
|
| 4865 | packet = [] |
|
| 4866 | packet.append(uatype_Int32.pack(len(self.NodesToDelete))) |
|
| 4867 | for fieldname in self.NodesToDelete: |
|
| 4868 | packet.append(fieldname.to_binary()) |
|
| 4869 | return b''.join(packet) |
|
| 4870 | ||
| 4871 | @staticmethod |
|
| 4872 | def from_binary(data): |
|
| 4873 | return DeleteNodesParameters(data) |
|
| 4874 | ||
| 4875 | def _binary_init(self, data): |
|
| 4876 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 4877 | array = [] |
|
| 4878 | if length != -1: |
|
| 4879 | for _ in range(0, length): |
|
| 4880 | array.append(DeleteNodesItem.from_binary(data)) |
|
| 4881 | self.NodesToDelete = array |
|
| 4882 | ||
| 4883 | def __str__(self): |
|
| 4884 | return 'DeleteNodesParameters(' + 'NodesToDelete:' + str(self.NodesToDelete) + ')' |
|
| 4885 | ||
| 4886 | __repr__ = __str__ |
|
| 4887 | ||
| 4888 | ||
| @@ 4483-4518 (lines=36) @@ | ||
| 4480 | ||
| 4481 | __repr__ = __str__ |
|
| 4482 | ||
| 4483 | ||
| 4484 | class AddNodesParameters(FrozenClass): |
|
| 4485 | ''' |
|
| 4486 | :ivar NodesToAdd: |
|
| 4487 | :vartype NodesToAdd: AddNodesItem |
|
| 4488 | ''' |
|
| 4489 | def __init__(self, binary=None): |
|
| 4490 | if binary is not None: |
|
| 4491 | self._binary_init(binary) |
|
| 4492 | self._freeze = True |
|
| 4493 | return |
|
| 4494 | self.NodesToAdd = [] |
|
| 4495 | self._freeze = True |
|
| 4496 | ||
| 4497 | def to_binary(self): |
|
| 4498 | packet = [] |
|
| 4499 | packet.append(uatype_Int32.pack(len(self.NodesToAdd))) |
|
| 4500 | for fieldname in self.NodesToAdd: |
|
| 4501 | packet.append(fieldname.to_binary()) |
|
| 4502 | return b''.join(packet) |
|
| 4503 | ||
| 4504 | @staticmethod |
|
| 4505 | def from_binary(data): |
|
| 4506 | return AddNodesParameters(data) |
|
| 4507 | ||
| 4508 | def _binary_init(self, data): |
|
| 4509 | length = uatype_Int32.unpack(data.read(4))[0] |
|
| 4510 | array = [] |
|
| 4511 | if length != -1: |
|
| 4512 | for _ in range(0, length): |
|
| 4513 | array.append(AddNodesItem.from_binary(data)) |
|
| 4514 | self.NodesToAdd = array |
|
| 4515 | ||
| 4516 | def __str__(self): |
|
| 4517 | return 'AddNodesParameters(' + 'NodesToAdd:' + str(self.NodesToAdd) + ')' |
|
| 4518 | ||
| 4519 | __repr__ = __str__ |
|
| 4520 | ||
| 4521 | ||
| @@ 214-240 (lines=27) @@ | ||
| 211 | ||
| 212 | def __str__(self): |
|
| 213 | return "{}(TokenId:{} )".format(self.__class__.__name__, self.TokenId) |
|
| 214 | __repr__ = __str__ |
|
| 215 | ||
| 216 | ||
| 217 | class SequenceHeader(uatypes.FrozenClass): |
|
| 218 | ||
| 219 | def __init__(self): |
|
| 220 | self.SequenceNumber = None |
|
| 221 | self.RequestId = None |
|
| 222 | self._freeze = True |
|
| 223 | ||
| 224 | @staticmethod |
|
| 225 | def from_binary(data): |
|
| 226 | obj = SequenceHeader() |
|
| 227 | obj.SequenceNumber = uatype_UInt32.unpack(data.read(4))[0] |
|
| 228 | obj.RequestId = uatype_UInt32.unpack(data.read(4))[0] |
|
| 229 | return obj |
|
| 230 | ||
| 231 | def to_binary(self): |
|
| 232 | b = [] |
|
| 233 | b.append(uatype_UInt32.pack(self.SequenceNumber)) |
|
| 234 | b.append(uatype_UInt32.pack(self.RequestId)) |
|
| 235 | return b"".join(b) |
|
| 236 | ||
| 237 | @staticmethod |
|
| 238 | def max_size(): |
|
| 239 | return struct.calcsize("<II") |
|
| 240 | ||
| 241 | def __str__(self): |
|
| 242 | return "{}(SequenceNumber:{}, RequestId:{} )".format( |
|
| 243 | self.__class__.__name__, self.SequenceNumber, self.RequestId) |
|
