Python struct.error函数代码示例

 def serialize(self, buff):
     """
 serialize message into buffer
 :param buff: buffer, ``StringIO``
 """
     try:
         _x = self.agent_one
         length = len(_x)
         if python3 or type(_x) == unicode:
             _x = _x.encode("utf-8")
             length = len(_x)
         buff.write(struct.pack("<I%ss" % length, length, _x))
         _x = self.agent_two
         length = len(_x)
         if python3 or type(_x) == unicode:
             _x = _x.encode("utf-8")
             length = len(_x)
         buff.write(struct.pack("<I%ss" % length, length, _x))
         _x = self
         buff.write(
             _struct_6d.pack(_x.rotationx, _x.rotationy, _x.angle, _x.referencex, _x.referencey, _x.evaluation)
         )
     except struct.error as se:
         self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
     except TypeError as te:
         self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def _struct_check_length(self, fmt, offset):
     if offset < 0:
         raise struct.error('can not (un)pack at a negative offset')
     
     fmt_size = struct.calcsize(fmt)
     if fmt_size > len(self) - offset:
         raise struct.error('(un)pack requires a buffer of at least %d bytes' % fmt_size)

def _count(format):
    """
    Count the number of variables needed to pack a given format.
    """
    if format[:1] in b"@=<>!":
        format = format[1:]

    count = 0
    q = b""

    for index in range(len(format)):
        char = format[index:index+1]
        if char.isdigit():
            q += char
            continue
        elif char in b" \t\r\n":
            if q:
                raise error("bad char in struct format")
            continue
        elif char in b"ps":
            count += 1
            q = b""
        elif char in b"xcbB?hHiIlLqQfdP":
            count += int(q or 1)
            q = b""
        else:
            raise error("bad char in struct format")

    return count

 def fromstr(self, data):
 
     try:
         vals = self.unpack(data)
         ind = self._pack.index('id')
         if vals[ind] != self.id:
             raise struct.error("Packet id %s does not match my id %s" % (vals[ind], self.id))
         if len(vals) == len(self._pack):
             for var in self._pack:
                 setattr(self, var, vals[self._pack.index(var)])
             return vals
         else:
             raise struct.error("Data indexes do not match pack indexes.")
     except (struct.error) as e: raise

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     _x = self
     buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
     _x = self.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self
     buff.write(_struct_2I.pack(_x.status.goal_id.stamp.secs, _x.status.goal_id.stamp.nsecs))
     _x = self.status.goal_id.id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     buff.write(struct.pack('<I%ss'%length, length, _x))
     buff.write(_struct_B.pack(self.status.status))
     _x = self.status.text
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     buff.write(struct.pack('<I%ss'%length, length, _x))
     buff.write(_struct_f.pack(self.feedback.percent_complete))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     _x = self
     buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
     _x = self.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     length = len(self.edges)
     buff.write(_struct_I.pack(length))
     for val1 in self.edges:
       _x = val1
       buff.write(_struct_2q.pack(_x.idA, _x.idB))
       _v7 = val1.poseATB
       _v8 = _v7.position
       _x = _v8
       buff.write(_struct_3d.pack(_x.x, _x.y, _x.z))
       _v9 = _v7.orientation
       _x = _v9
       buff.write(_struct_4d.pack(_x.x, _x.y, _x.z, _x.w))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     _x = self
     buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
     _x = self.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self.ns
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self
     buff.write(_struct_3i10d4f2iB.pack(_x.id, _x.type, _x.action, _x.pose.position.x, _x.pose.position.y, _x.pose.position.z, _x.pose.orientation.x, _x.pose.orientation.y, _x.pose.orientation.z, _x.pose.orientation.w, _x.scale.x, _x.scale.y, _x.scale.z, _x.color.r, _x.color.g, _x.color.b, _x.color.a, _x.lifetime.secs, _x.lifetime.nsecs, _x.frame_locked))
     length = len(self.points)
     buff.write(_struct_I.pack(length))
     for val1 in self.points:
       _x = val1
       buff.write(_struct_3d.pack(_x.x, _x.y, _x.z))
     length = len(self.colors)
     buff.write(_struct_I.pack(length))
     for val1 in self.colors:
       _x = val1
       buff.write(_struct_4f.pack(_x.r, _x.g, _x.b, _x.a))
     _x = self.text
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self.mesh_resource
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     buff.write(_struct_B.pack(self.mesh_use_embedded_materials))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize(self, buff):
   """
   serialize message into buffer
   :param buff: buffer, ``StringIO``
   """
   try:
     _x = self
     buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
     _x = self.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     buff.write(_struct_f.pack(self.processing_time))
     length = len(self.keyframes)
     buff.write(_struct_I.pack(length))
     pattern = '<%si'%length
     buff.write(struct.pack(pattern, *self.keyframes))
     _x = self
     buff.write(_struct_3i.pack(_x.num_matches, _x.tracking_quality, _x.stage))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     _x = self
     buff.write(_struct_H3I.pack(_x.vehicle_id, _x.state.header.seq, _x.state.header.stamp.secs, _x.state.header.stamp.nsecs))
     _x = self.state.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self.state.child_frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self
     buff.write(_struct_4d2B4d.pack(_x.state.pose.pose.position.lat, _x.state.pose.pose.position.lon, _x.state.pose.pose.position.alt, _x.state.pose.pose.position.rel_alt, _x.state.pose.pose.position.using_alt, _x.state.pose.pose.position.using_rel_alt, _x.state.pose.pose.orientation.x, _x.state.pose.pose.orientation.y, _x.state.pose.pose.orientation.z, _x.state.pose.pose.orientation.w))
     buff.write(self.state.pose.covariance.tostring())
     _x = self
     buff.write(_struct_6d.pack(_x.state.twist.twist.linear.x, _x.state.twist.twist.linear.y, _x.state.twist.twist.linear.z, _x.state.twist.twist.angular.x, _x.state.twist.twist.angular.y, _x.state.twist.twist.angular.z))
     buff.write(self.state.twist.covariance.tostring())
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))

 def serialize(self, buff):
   """
   serialize message into buffer
   :param buff: buffer, ``StringIO``
   """
   try:
     _x = self.resource_name
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self.format
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self.data
     length = len(_x)
     # - if encoded as a list instead, serialize as bytes instead of string
     if type(_x) in [list, tuple]:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     length = len(self.x)
     buff.write(_struct_I.pack(length))
     pattern = '<%sf'%length
     buff.write(self.x.tostring())
     length = len(self.y)
     buff.write(_struct_I.pack(length))
     pattern = '<%sf'%length
     buff.write(self.y.tostring())
     length = len(self.z)
     buff.write(_struct_I.pack(length))
     pattern = '<%sf'%length
     buff.write(self.z.tostring())
     length = len(self.labels)
     buff.write(_struct_I.pack(length))
     pattern = '<%si'%length
     buff.write(self.labels.tostring())
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     _x = self
     buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
     _x = self.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self
     buff.write(_struct_2I.pack(_x.goal_id.stamp.secs, _x.goal_id.stamp.nsecs))
     _x = self.goal_id.id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self
     buff.write(_struct_B6fib.pack(_x.goal.mode.mode, _x.goal.mode.color.r, _x.goal.mode.color.g, _x.goal.mode.color.b, _x.goal.mode.color.a, _x.goal.mode.frequency, _x.goal.mode.timeout, _x.goal.mode.pulses, _x.goal.mode.priority))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize(self, buff):
   """
   serialize message into buffer
   :param buff: buffer, ``StringIO``
   """
   try:
     _x = self
     buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
     _x = self.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self.ssid
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     _x = self
     buff.write(_struct_h2B.pack(_x.rssi, _x.band, _x.channel))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(_x))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(_x))))

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     _x = self
     buff.write(_struct_3I.pack(_x.header.seq, _x.header.stamp.secs, _x.header.stamp.nsecs))
     _x = self.header.frame_id
     length = len(_x)
     if python3 or type(_x) == unicode:
       _x = _x.encode('utf-8')
       length = len(_x)
     if python3:
       buff.write(struct.pack('<I%sB'%length, length, *_x))
     else:
       buff.write(struct.pack('<I%ss'%length, length, _x))
     length = len(self.readings)
     buff.write(_struct_I.pack(length))
     for val1 in self.readings:
       _x = val1
       buff.write(_struct_2f.pack(_x.angle, _x.distance))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))

 def serialize_numpy(self, buff, numpy):
   """
   serialize message with numpy array types into buffer
   :param buff: buffer, ``StringIO``
   :param numpy: numpy python module
   """
   try:
     length = len(self.results)
     buff.write(_struct_I.pack(length))
     for val1 in self.results:
       _x = val1.key
       length = len(_x)
       if python3 or type(_x) == unicode:
         _x = _x.encode('utf-8')
         length = len(_x)
       if python3:
         buff.write(struct.pack('<I%sB'%length, length, *_x))
       else:
         buff.write(struct.pack('<I%ss'%length, length, _x))
       length = len(val1.values)
       buff.write(_struct_I.pack(length))
       for val2 in val1.values:
         length = len(val2)
         if python3 or type(val2) == unicode:
           val2 = val2.encode('utf-8')
           length = len(val2)
         if python3:
           buff.write(struct.pack('<I%sB'%length, length, *val2))
         else:
           buff.write(struct.pack('<I%ss'%length, length, val2))
   except struct.error as se: self._check_types(struct.error("%s: '%s' when writing '%s'" % (type(se), str(se), str(locals().get('_x', self)))))
   except TypeError as te: self._check_types(ValueError("%s: '%s' when writing '%s'" % (type(te), str(te), str(locals().get('_x', self)))))