Code Duplication - FreeOpcUa/python-opcua - Measure and Improve Code Quality continuously with Scrutinizer

Code Duplication Length = 49-49 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations



    __repr__ = __str__


class TransferSubscriptionsResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: TransferResult
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Results = []
        self.DiagnosticInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.Results)))
        for fieldname in self.Results:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
        for fieldname in self.DiagnosticInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return TransferSubscriptionsResult(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(TransferResult.from_binary(data))
        self.Results = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(DiagnosticInfo.from_binary(data))
        self.DiagnosticInfos = array

    def __str__(self):
        return 'TransferSubscriptionsResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__




    __repr__ = __str__


class DataChangeNotification(FrozenClass):
    '''
    :ivar MonitoredItems:
    :vartype MonitoredItems: MonitoredItemNotification
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.MonitoredItems = []
        self.DiagnosticInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.MonitoredItems)))
        for fieldname in self.MonitoredItems:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
        for fieldname in self.DiagnosticInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return DataChangeNotification(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(MonitoredItemNotification.from_binary(data))
        self.MonitoredItems = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(DiagnosticInfo.from_binary(data))
        self.DiagnosticInfos = array

    def __str__(self):
        return 'DataChangeNotification(' + 'MonitoredItems:' + str(self.MonitoredItems) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__




    __repr__ = __str__


class SetPublishingModeResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: StatusCode
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Results = []
        self.DiagnosticInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.Results)))
        for fieldname in self.Results:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
        for fieldname in self.DiagnosticInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return SetPublishingModeResult(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(StatusCode.from_binary(data))
        self.Results = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(DiagnosticInfo.from_binary(data))
        self.DiagnosticInfos = array

    def __str__(self):
        return 'SetPublishingModeResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__




    __repr__ = __str__


class SetMonitoringModeResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: StatusCode
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Results = []
        self.DiagnosticInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.Results)))
        for fieldname in self.Results:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
        for fieldname in self.DiagnosticInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return SetMonitoringModeResult(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(StatusCode.from_binary(data))
        self.Results = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(DiagnosticInfo.from_binary(data))
        self.DiagnosticInfos = array

    def __str__(self):
        return 'SetMonitoringModeResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__




    __repr__ = __str__


class HistoryModifiedData(FrozenClass):
    '''
    :ivar DataValues:
    :vartype DataValues: DataValue
    :ivar ModificationInfos:
    :vartype ModificationInfos: ModificationInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.DataValues = []
        self.ModificationInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.DataValues)))
        for fieldname in self.DataValues:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.ModificationInfos)))
        for fieldname in self.ModificationInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return HistoryModifiedData(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(DataValue.from_binary(data))
        self.DataValues = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(ModificationInfo.from_binary(data))
        self.ModificationInfos = array

    def __str__(self):
        return 'HistoryModifiedData(' + 'DataValues:' + str(self.DataValues) + ', ' + \
               'ModificationInfos:' + str(self.ModificationInfos) + ')'

    __repr__ = __str__




    __repr__ = __str__


class ContentFilterResult(FrozenClass):
    '''
    :ivar ElementResults:
    :vartype ElementResults: ContentFilterElementResult
    :ivar ElementDiagnosticInfos:
    :vartype ElementDiagnosticInfos: DiagnosticInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.ElementResults = []
        self.ElementDiagnosticInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.ElementResults)))
        for fieldname in self.ElementResults:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.ElementDiagnosticInfos)))
        for fieldname in self.ElementDiagnosticInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return ContentFilterResult(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(ContentFilterElementResult.from_binary(data))
        self.ElementResults = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(DiagnosticInfo.from_binary(data))
        self.ElementDiagnosticInfos = array

    def __str__(self):
        return 'ContentFilterResult(' + 'ElementResults:' + str(self.ElementResults) + ', ' + \
               'ElementDiagnosticInfos:' + str(self.ElementDiagnosticInfos) + ')'

    __repr__ = __str__




    __repr__ = __str__


class BrowseNextResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: BrowseResult
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Results = []
        self.DiagnosticInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.Results)))
        for fieldname in self.Results:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
        for fieldname in self.DiagnosticInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return BrowseNextResult(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(BrowseResult.from_binary(data))
        self.Results = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(DiagnosticInfo.from_binary(data))
        self.DiagnosticInfos = array

    def __str__(self):
        return 'BrowseNextResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__




    __repr__ = __str__


class DeleteReferencesResult(FrozenClass):
    '''
    :ivar Results:
    :vartype Results: StatusCode
    :ivar DiagnosticInfos:
    :vartype DiagnosticInfos: DiagnosticInfo
    '''
    def __init__(self, binary=None):
        if binary is not None:
            self._binary_init(binary)
            self._freeze = True
            return
        self.Results = []
        self.DiagnosticInfos = []
        self._freeze = True

    def to_binary(self):
        packet = []
        packet.append(uatype_Int32.pack(len(self.Results)))
        for fieldname in self.Results:
            packet.append(fieldname.to_binary())
        packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
        for fieldname in self.DiagnosticInfos:
            packet.append(fieldname.to_binary())
        return b''.join(packet)

    @staticmethod
    def from_binary(data):
        return DeleteReferencesResult(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(StatusCode.from_binary(data))
        self.Results = array
        length = uatype_Int32.unpack(data.read(4))[0]
        array = []
        if length != -1:
            for _ in range(0, length):
                array.append(DiagnosticInfo.from_binary(data))
        self.DiagnosticInfos = array

    def __str__(self):
        return 'DeleteReferencesResult(' + 'Results:' + str(self.Results) + ', ' + \
               'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'

    __repr__ = __str__



		@@ 12336-12384 (lines=49) @@
12333
12334		__repr__ = __str__
12335
12336
12337		class TransferSubscriptionsResult(FrozenClass):
12338		'''
12339		:ivar Results:
12340		:vartype Results: TransferResult
12341		:ivar DiagnosticInfos:
12342		:vartype DiagnosticInfos: DiagnosticInfo
12343		'''
12344		def __init__(self, binary=None):
12345		if binary is not None:
12346		self._binary_init(binary)
12347		self._freeze = True
12348		return
12349		self.Results = []
12350		self.DiagnosticInfos = []
12351		self._freeze = True
12352
12353		def to_binary(self):
12354		packet = []
12355		packet.append(uatype_Int32.pack(len(self.Results)))
12356		for fieldname in self.Results:
12357		packet.append(fieldname.to_binary())
12358		packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
12359		for fieldname in self.DiagnosticInfos:
12360		packet.append(fieldname.to_binary())
12361		return b''.join(packet)
12362
12363		@staticmethod
12364		def from_binary(data):
12365		return TransferSubscriptionsResult(data)
12366
12367		def _binary_init(self, data):
12368		length = uatype_Int32.unpack(data.read(4))[0]
12369		array = []
12370		if length != -1:
12371		for _ in range(0, length):
12372		array.append(TransferResult.from_binary(data))
12373		self.Results = array
12374		length = uatype_Int32.unpack(data.read(4))[0]
12375		array = []
12376		if length != -1:
12377		for _ in range(0, length):
12378		array.append(DiagnosticInfo.from_binary(data))
12379		self.DiagnosticInfos = array
12380
12381		def __str__(self):
12382		return 'TransferSubscriptionsResult(' + 'Results:' + str(self.Results) + ', ' + \
12383		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
12384
12385		__repr__ = __str__
12386
12387
		@@ 11609-11657 (lines=49) @@
11606
11607		__repr__ = __str__
11608
11609
11610		class DataChangeNotification(FrozenClass):
11611		'''
11612		:ivar MonitoredItems:
11613		:vartype MonitoredItems: MonitoredItemNotification
11614		:ivar DiagnosticInfos:
11615		:vartype DiagnosticInfos: DiagnosticInfo
11616		'''
11617		def __init__(self, binary=None):
11618		if binary is not None:
11619		self._binary_init(binary)
11620		self._freeze = True
11621		return
11622		self.MonitoredItems = []
11623		self.DiagnosticInfos = []
11624		self._freeze = True
11625
11626		def to_binary(self):
11627		packet = []
11628		packet.append(uatype_Int32.pack(len(self.MonitoredItems)))
11629		for fieldname in self.MonitoredItems:
11630		packet.append(fieldname.to_binary())
11631		packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
11632		for fieldname in self.DiagnosticInfos:
11633		packet.append(fieldname.to_binary())
11634		return b''.join(packet)
11635
11636		@staticmethod
11637		def from_binary(data):
11638		return DataChangeNotification(data)
11639
11640		def _binary_init(self, data):
11641		length = uatype_Int32.unpack(data.read(4))[0]
11642		array = []
11643		if length != -1:
11644		for _ in range(0, length):
11645		array.append(MonitoredItemNotification.from_binary(data))
11646		self.MonitoredItems = array
11647		length = uatype_Int32.unpack(data.read(4))[0]
11648		array = []
11649		if length != -1:
11650		for _ in range(0, length):
11651		array.append(DiagnosticInfo.from_binary(data))
11652		self.DiagnosticInfos = array
11653
11654		def __str__(self):
11655		return 'DataChangeNotification(' + 'MonitoredItems:' + str(self.MonitoredItems) + ', ' + \
11656		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
11657
11658		__repr__ = __str__
11659
11660
		@@ 11438-11486 (lines=49) @@
11435
11436		__repr__ = __str__
11437
11438
11439		class SetPublishingModeResult(FrozenClass):
11440		'''
11441		:ivar Results:
11442		:vartype Results: StatusCode
11443		:ivar DiagnosticInfos:
11444		:vartype DiagnosticInfos: DiagnosticInfo
11445		'''
11446		def __init__(self, binary=None):
11447		if binary is not None:
11448		self._binary_init(binary)
11449		self._freeze = True
11450		return
11451		self.Results = []
11452		self.DiagnosticInfos = []
11453		self._freeze = True
11454
11455		def to_binary(self):
11456		packet = []
11457		packet.append(uatype_Int32.pack(len(self.Results)))
11458		for fieldname in self.Results:
11459		packet.append(fieldname.to_binary())
11460		packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
11461		for fieldname in self.DiagnosticInfos:
11462		packet.append(fieldname.to_binary())
11463		return b''.join(packet)
11464
11465		@staticmethod
11466		def from_binary(data):
11467		return SetPublishingModeResult(data)
11468
11469		def _binary_init(self, data):
11470		length = uatype_Int32.unpack(data.read(4))[0]
11471		array = []
11472		if length != -1:
11473		for _ in range(0, length):
11474		array.append(StatusCode.from_binary(data))
11475		self.Results = array
11476		length = uatype_Int32.unpack(data.read(4))[0]
11477		array = []
11478		if length != -1:
11479		for _ in range(0, length):
11480		array.append(DiagnosticInfo.from_binary(data))
11481		self.DiagnosticInfos = array
11482
11483		def __str__(self):
11484		return 'SetPublishingModeResult(' + 'Results:' + str(self.Results) + ', ' + \
11485		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
11486
11487		__repr__ = __str__
11488
11489
		@@ 10515-10563 (lines=49) @@
10512
10513		__repr__ = __str__
10514
10515
10516		class SetMonitoringModeResult(FrozenClass):
10517		'''
10518		:ivar Results:
10519		:vartype Results: StatusCode
10520		:ivar DiagnosticInfos:
10521		:vartype DiagnosticInfos: DiagnosticInfo
10522		'''
10523		def __init__(self, binary=None):
10524		if binary is not None:
10525		self._binary_init(binary)
10526		self._freeze = True
10527		return
10528		self.Results = []
10529		self.DiagnosticInfos = []
10530		self._freeze = True
10531
10532		def to_binary(self):
10533		packet = []
10534		packet.append(uatype_Int32.pack(len(self.Results)))
10535		for fieldname in self.Results:
10536		packet.append(fieldname.to_binary())
10537		packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
10538		for fieldname in self.DiagnosticInfos:
10539		packet.append(fieldname.to_binary())
10540		return b''.join(packet)
10541
10542		@staticmethod
10543		def from_binary(data):
10544		return SetMonitoringModeResult(data)
10545
10546		def _binary_init(self, data):
10547		length = uatype_Int32.unpack(data.read(4))[0]
10548		array = []
10549		if length != -1:
10550		for _ in range(0, length):
10551		array.append(StatusCode.from_binary(data))
10552		self.Results = array
10553		length = uatype_Int32.unpack(data.read(4))[0]
10554		array = []
10555		if length != -1:
10556		for _ in range(0, length):
10557		array.append(DiagnosticInfo.from_binary(data))
10558		self.DiagnosticInfos = array
10559
10560		def __str__(self):
10561		return 'SetMonitoringModeResult(' + 'Results:' + str(self.Results) + ', ' + \
10562		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
10563
10564		__repr__ = __str__
10565
10566
		@@ 8308-8356 (lines=49) @@
8305
8306		__repr__ = __str__
8307
8308
8309		class HistoryModifiedData(FrozenClass):
8310		'''
8311		:ivar DataValues:
8312		:vartype DataValues: DataValue
8313		:ivar ModificationInfos:
8314		:vartype ModificationInfos: ModificationInfo
8315		'''
8316		def __init__(self, binary=None):
8317		if binary is not None:
8318		self._binary_init(binary)
8319		self._freeze = True
8320		return
8321		self.DataValues = []
8322		self.ModificationInfos = []
8323		self._freeze = True
8324
8325		def to_binary(self):
8326		packet = []
8327		packet.append(uatype_Int32.pack(len(self.DataValues)))
8328		for fieldname in self.DataValues:
8329		packet.append(fieldname.to_binary())
8330		packet.append(uatype_Int32.pack(len(self.ModificationInfos)))
8331		for fieldname in self.ModificationInfos:
8332		packet.append(fieldname.to_binary())
8333		return b''.join(packet)
8334
8335		@staticmethod
8336		def from_binary(data):
8337		return HistoryModifiedData(data)
8338
8339		def _binary_init(self, data):
8340		length = uatype_Int32.unpack(data.read(4))[0]
8341		array = []
8342		if length != -1:
8343		for _ in range(0, length):
8344		array.append(DataValue.from_binary(data))
8345		self.DataValues = array
8346		length = uatype_Int32.unpack(data.read(4))[0]
8347		array = []
8348		if length != -1:
8349		for _ in range(0, length):
8350		array.append(ModificationInfo.from_binary(data))
8351		self.ModificationInfos = array
8352
8353		def __str__(self):
8354		return 'HistoryModifiedData(' + 'DataValues:' + str(self.DataValues) + ', ' + \
8355		'ModificationInfos:' + str(self.ModificationInfos) + ')'
8356
8357		__repr__ = __str__
8358
8359
		@@ 7199-7247 (lines=49) @@
7196
7197		__repr__ = __str__
7198
7199
7200		class ContentFilterResult(FrozenClass):
7201		'''
7202		:ivar ElementResults:
7203		:vartype ElementResults: ContentFilterElementResult
7204		:ivar ElementDiagnosticInfos:
7205		:vartype ElementDiagnosticInfos: DiagnosticInfo
7206		'''
7207		def __init__(self, binary=None):
7208		if binary is not None:
7209		self._binary_init(binary)
7210		self._freeze = True
7211		return
7212		self.ElementResults = []
7213		self.ElementDiagnosticInfos = []
7214		self._freeze = True
7215
7216		def to_binary(self):
7217		packet = []
7218		packet.append(uatype_Int32.pack(len(self.ElementResults)))
7219		for fieldname in self.ElementResults:
7220		packet.append(fieldname.to_binary())
7221		packet.append(uatype_Int32.pack(len(self.ElementDiagnosticInfos)))
7222		for fieldname in self.ElementDiagnosticInfos:
7223		packet.append(fieldname.to_binary())
7224		return b''.join(packet)
7225
7226		@staticmethod
7227		def from_binary(data):
7228		return ContentFilterResult(data)
7229
7230		def _binary_init(self, data):
7231		length = uatype_Int32.unpack(data.read(4))[0]
7232		array = []
7233		if length != -1:
7234		for _ in range(0, length):
7235		array.append(ContentFilterElementResult.from_binary(data))
7236		self.ElementResults = array
7237		length = uatype_Int32.unpack(data.read(4))[0]
7238		array = []
7239		if length != -1:
7240		for _ in range(0, length):
7241		array.append(DiagnosticInfo.from_binary(data))
7242		self.ElementDiagnosticInfos = array
7243
7244		def __str__(self):
7245		return 'ContentFilterResult(' + 'ElementResults:' + str(self.ElementResults) + ', ' + \
7246		'ElementDiagnosticInfos:' + str(self.ElementDiagnosticInfos) + ')'
7247
7248		__repr__ = __str__
7249
7250
		@@ 5707-5755 (lines=49) @@
5704
5705		__repr__ = __str__
5706
5707
5708		class BrowseNextResult(FrozenClass):
5709		'''
5710		:ivar Results:
5711		:vartype Results: BrowseResult
5712		:ivar DiagnosticInfos:
5713		:vartype DiagnosticInfos: DiagnosticInfo
5714		'''
5715		def __init__(self, binary=None):
5716		if binary is not None:
5717		self._binary_init(binary)
5718		self._freeze = True
5719		return
5720		self.Results = []
5721		self.DiagnosticInfos = []
5722		self._freeze = True
5723
5724		def to_binary(self):
5725		packet = []
5726		packet.append(uatype_Int32.pack(len(self.Results)))
5727		for fieldname in self.Results:
5728		packet.append(fieldname.to_binary())
5729		packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
5730		for fieldname in self.DiagnosticInfos:
5731		packet.append(fieldname.to_binary())
5732		return b''.join(packet)
5733
5734		@staticmethod
5735		def from_binary(data):
5736		return BrowseNextResult(data)
5737
5738		def _binary_init(self, data):
5739		length = uatype_Int32.unpack(data.read(4))[0]
5740		array = []
5741		if length != -1:
5742		for _ in range(0, length):
5743		array.append(BrowseResult.from_binary(data))
5744		self.Results = array
5745		length = uatype_Int32.unpack(data.read(4))[0]
5746		array = []
5747		if length != -1:
5748		for _ in range(0, length):
5749		array.append(DiagnosticInfo.from_binary(data))
5750		self.DiagnosticInfos = array
5751
5752		def __str__(self):
5753		return 'BrowseNextResult(' + 'Results:' + str(self.Results) + ', ' + \
5754		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
5755
5756		__repr__ = __str__
5757
5758
		@@ 5138-5186 (lines=49) @@
5135
5136		__repr__ = __str__
5137
5138
5139		class DeleteReferencesResult(FrozenClass):
5140		'''
5141		:ivar Results:
5142		:vartype Results: StatusCode
5143		:ivar DiagnosticInfos:
5144		:vartype DiagnosticInfos: DiagnosticInfo
5145		'''
5146		def __init__(self, binary=None):
5147		if binary is not None:
5148		self._binary_init(binary)
5149		self._freeze = True
5150		return
5151		self.Results = []
5152		self.DiagnosticInfos = []
5153		self._freeze = True
5154
5155		def to_binary(self):
5156		packet = []
5157		packet.append(uatype_Int32.pack(len(self.Results)))
5158		for fieldname in self.Results:
5159		packet.append(fieldname.to_binary())
5160		packet.append(uatype_Int32.pack(len(self.DiagnosticInfos)))
5161		for fieldname in self.DiagnosticInfos:
5162		packet.append(fieldname.to_binary())
5163		return b''.join(packet)
5164
5165		@staticmethod
5166		def from_binary(data):
5167		return DeleteReferencesResult(data)
5168
5169		def _binary_init(self, data):
5170		length = uatype_Int32.unpack(data.read(4))[0]
5171		array = []
5172		if length != -1:
5173		for _ in range(0, length):
5174		array.append(StatusCode.from_binary(data))
5175		self.Results = array
5176		length = uatype_Int32.unpack(data.read(4))[0]
5177		array = []
5178		if length != -1:
5179		for _ in range(0, length):
5180		array.append(DiagnosticInfo.from_binary(data))
5181		self.DiagnosticInfos = array
5182
5183		def __str__(self):
5184		return 'DeleteReferencesResult(' + 'Results:' + str(self.Results) + ', ' + \
5185		'DiagnosticInfos:' + str(self.DiagnosticInfos) + ')'
5186
5187		__repr__ = __str__
5188
5189

FreeOpcUa / python-opcua

Code Duplication Length = 49-49 lines in 8 locations

opcua/ua/uaprotocol_auto.py 8 locations