Implemented Very Specific Routine ONLY for ROS uint-Arrays

Author: Luxxii

ObjectToJson/entityAttribute.py

@@ -27,6 +27,9 @@
 except ImportError:
     import urllib as quote
 
+# TODO DL Threshold for converting large Arrays in ROS-Messages?
+THRESH = 256 
+
 class EntityAttribute():
     """ Here the actual Conversion to the correct JSON-Format happens 
     (no string is generated here). By initializing this class the given Object is 
@@ -73,6 +76,7 @@ def __init__(self, _object, ipmd, concreteDataType=None, baseEntity=False):
             self.setPythonMetaData(ipmd, "complex")
             # self.setConcreteMetaData(concreteDataType)
         elif objectType is str:
+            # Thanks to ROS, Bytes are converted into 
             self.type = "string"
             self.value = str(_object)
             # self.setConcreteMetaData(concreteDataType)
@@ -114,7 +118,7 @@ def __init__(self, _object, ipmd, concreteDataType=None, baseEntity=False):
                 raise ValueError("Cannot get attrs from {}".format(str(_object)))
 
             if hasattr(_object, '_type') and hasattr(_object, '_slot_types') and hasattr(_object, '__slots__'):   # ROS-Specific Type-Declaration
-                ### This is a special Class from ROS!
+                ### This is a special CASE for ROS!!!!
                 self.type = _object._type.replace("/", ".") # Needs to be replaced Fiware does not allow a '/'
                 self.setPythonMetaData(ipmd, "class")
                 # Special Case 'Image-like'-Data in ROS (very long 'int8[]'- and 'uint8[]' - arrays)
@@ -123,14 +127,14 @@ def __init__(self, _object, ipmd, concreteDataType=None, baseEntity=False):
                 for key, key_type in zip(_object.__slots__, _object._slot_types):
                     if key.startswith('_'):
                         continue
-                    if (key_type == 'int8[]' or key_type == 'uint8[]') and len(getattr(_object, key)) >= 256: 
+                    if ('int8[' in key_type or 'uint8[' in key_type) and len(getattr(_object, key)) >= THRESH: 
                         # TODO DL 256 -> Threshold?
                         # Generate Base64 String of the Array:
                         tempDict[key] = EntityAttribute(None, ipmd)
                         tempDict[key].type = "base64"
 
                         # Either generate unsigned or signed byte-array
-                        if key_type == 'int8[]':
+                        if 'int8[' in key_type:
                             tempDict[key].value = array.array('b', getattr(_object, key)).tostring()
                         else:
                             tempDict[key].value = array.array('B', getattr(_object, key)).tostring()
@@ -145,8 +149,46 @@ def __init__(self, _object, ipmd, concreteDataType=None, baseEntity=False):
                     else:
                         innerConcreteMetaData = None
                         if concreteDataType is not None and key in concreteDataType:
+                            # We have a special DatType for it
                             innerConcreteMetaData = concreteDataType[key]
-                        tempDict[key] = EntityAttribute(getattr(_object, key), ipmd, innerConcreteMetaData)
+                            alreadySet = False # Boolean to check if data ist already set
+                            if "uint8[" in innerConcreteMetaData:
+                                # SPECIAL ROS CASE we have uint8[]-Array as a String or byte
+                                # See: http://wiki.ros.org/msg#Fields -> Array-Handling
+                                strangeObj = getattr(_object, key)
+                                toConvert = None
+                                if type(strangeObj) is str:
+                                    # Looks like ROS converted it for us into str!
+                                    toConvert = array.array("B", strangeObj).tolist()
+                                if not self.python_version < (3,0) and type(strangeObj) is bytes:
+                                    # Looks like ROS converted it for us into bytes!
+                                    toConvert = list(strangeObj)
+                                if toConvert is not None and len(toConvert) >= THRESH:
+                                    # TODO DL 256 -> Threshold?
+                                    # Generate Base64 String of the Array:
+                                    tempDict[key] = EntityAttribute(None, ipmd)
+                                    tempDict[key].type = "base64"
+
+                                    # Generate unsigned or byte-array
+                                    tempDict[key].value = array.array('B', getattr(_object, key)).tostring()
+                                    
+                                    # Form that Byte-Array: generate Base64 String
+                                    tempDict[key].value = base64.b64encode(tempDict[key].value)
+
+                                    # Escape Special Characters:
+                                    tempDict[key].value = quote.quote(tempDict[key].value)
+                                    tempDict[key].metadata = dict()
+                                    self.setConcreteMetaData(innerConcreteMetaData, tempDict[key])
+                                    alreadySet = True 
+
+                            else:
+                                # Something else we should convert
+                                toConvert = getattr(_object, key)
+                            if alreadySet is False:
+                                tempDict[key] = EntityAttribute(toConvert, ipmd, innerConcreteMetaData)
+                        else:
+                            # Just get its child and convert it 
+                            tempDict[key] = EntityAttribute(getattr(_object, key), ipmd, None)
                 self.value = tempDict
             else:
                 # Simple Class. Recursively retrieve the other values