kytos / python-openflow

        if self.isenum():

            if isinstance(self._value, self.enum_ref):

                return self._value.value

            return self._value

        elif self.is_bitmask():

            return self._value.bitmask

        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__,

        """

        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.

        self.length = length

        self._fmt = '!{}{}'.format(self.length, 's')

    def pack(self, value=None):

        """Pack the value as a binary representation.

        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()

        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.

        super().__init__(address)

        self.netmask = int(netmask)

    def pack(self, value=None):

        """Pack the value as a binary representation.

        If the value is None the self._value will be used to pack.

        Args:

            value (str): IP Address with ipv4 format.

        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.find('/') >= 0:

            value = value.split('/')[0]

        try:

            value = value.split('.')

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

        except struct.error as err:

            msg = "IPAddress 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.