kytos / python-openflow

        else:

            return self._value

    def pack(self, value=None):

        r"""Pack the value as a binary representation.

        Considering an example with UBInt8 class, that inherits from

        GenericType:

        >>> from pyof.foundation.basic_types import UBInt8

        >>> objectA = UBInt8(1)

        >>> objectB = 5

        >>> objectA.pack()

        b'\x01'

        >>> objectA.pack(objectB)

        b'\x05'

        Args:

            value: If the value is None, then we will pack the value of the

                current instance. Otherwise, if value is an instance of the

                same type as the current instance, then we call the pack of the

                value object. Otherwise, we will use the current instance pack

                method on the passed value.

        Returns:

            bytes: The binary representation.

        Raises:

            :exc:`~.exceptions.BadValueException`: If the value does not

                fit the binary format.

        """

        if isinstance(value, type(self)):

            return value.pack()

        if value is None:

            value = self.value

        elif 'value' in dir(value):

            # if it is enum or bitmask gets only the 'int' value

            value = value.value

        try:

            return struct.pack(self._fmt, value)

        except struct.error:

            msg = '{} could not pack {} = {}.'.format(type(self).__name__,

                                                      type(value).__name__,

                                                      value)

            raise PackException(msg)

    def unpack(self, buff, offset=0):

        """Unpack *buff* into this object.

        super().__init__(hw_address)

    def pack(self, value=None):

        """Pack the value as a binary representation.

        If the passed value (or the self._value) is zero (int), then the pack

        will assume that the value to be packed is '00:00:00:00:00:00'.

        Returns

            bytes: The binary representation.

        Raises:

            struct.error: If the value does not fit the binary format.

        """

        if isinstance(value, type(self)):

            return value.pack()

        if value is None:

            value = self._value

        if value == 0:

            value = '00:00:00:00:00:00'

        value = value.split(':')

        try:

            return struct.pack('!6B', *[int(x, 16) for x in value])

        except struct.error as err:

            msg = "HWAddress error. "

            msg += "Class: {}, struct error: {} ".format(type(value).__name__,

                                                         err)

            raise exceptions.PackException(msg)

    def unpack(self, buff, offset=0):

        """Unpack a binary message into this object's attributes.

        """

        if isinstance(value, type(self)):

            return value.pack()

        try:

            if value is None:

                value = self.value

            packed = struct.pack(self._fmt, bytes(value, 'ascii'))

            return packed[:-1] + b'\0'  # null-terminated

        except struct.error as err:

            msg = "Char Pack error. "

            msg += "Class: {}, struct error: {} ".format(type(value).__name__,

                                                         err)

            raise exceptions.PackException(msg)

    def unpack(self, buff, offset=0):

        """Unpack a binary message into this object's attributes.

        Unpack the binary value *buff* and update this object attributes based

        on the results.

        Args:

            buff (bytes): Binary data package to be unpacked.

            offset (int): Where to begin unpacking.

        Raises:

            Exception: If there is a struct unpacking error.

        """