def _deserializeField(self, structname, obj):
        fieldName, fieldType, fieldId = self.protocol.readFieldBegin()
        if fieldType == TType.STOP:
            return False
        elif fieldType != TType.VOID:
            #            if adapters.fieldAdapterRegistry.has_key(structname) and adapters.fieldAdapterRegistry[structname].has_key(fieldName):
            #                result = adapters.fieldAdapterRegistry[structname][fieldName].deserialize(self)
            #            else:
            result = self._deserializeType(fieldType)
            lookingFor = "set" + fieldName[0].upper() + fieldName[1:]

            try:
                setMethod = getattr(obj, lookingFor)

                if callable(setMethod):
                    setMethod(result)
                else:
                    raise dynamicserialize.SerializationException(
                        "Couldn't find setter method " + lookingFor)
            except:
                raise dynamicserialize.SerializationException(
                    "Couldn't find setter method " + lookingFor)

        self.protocol.readFieldEnd()
        return True
    def deserializeMessage(self):
        name = self.protocol.readStructBegin()
        name = name.decode('cp437')
        name = name.replace('_', '.')
        if name.isdigit():
            obj = self._deserializeType(int(name))
            return obj
        if name in adapters.classAdapterRegistry:
            return adapters.classAdapterRegistry[name].deserialize(self)
        elif '$' in name:
            # it's an inner class, we're going to hope it's an enum, treat it
            # special
            fieldName, fieldType, fieldId = self.protocol.readFieldBegin()
            if fieldName.decode('utf8') != '__enumValue__':
                raise dynamicserialize.SerializationException("Expected to find enum payload.  Found: " + fieldName)
            obj = self.protocol.readString()
            self.protocol.readFieldEnd()
            return obj
        else:
            clz = dsObjTypes[name]
            obj = clz()

        while self._deserializeField(name, obj):
            pass

        self.protocol.readStructEnd()
        return obj
Example #3
0
 def _lookupType(self, obj):        
     pyt = type(obj)
     if pythonToThriftMap.has_key(pyt):
         return pythonToThriftMap[pyt]
     elif pyt.__module__.startswith('dynamicserialize.dstypes'):
         return pythonToThriftMap[types.InstanceType]
     else:             
         raise dynamicserialize.SerializationException("Don't know how to serialize object of type: " + str(pyt))    
 def _lookupType(self, obj):
     pyt = type(obj)
     if pyt in pythonToThriftMap:
         return pythonToThriftMap[pyt]
     elif pyt.__module__[:DS_LEN - 1] == ('dynamicserialize.dstypes'):
         return pythonToThriftMap[object]
     else:
         raise dynamicserialize.SerializationException(
             "Don't know how to serialize object of type: " + str(pyt))
Example #5
0
    def _deserializeField(self, structname, obj):
        fieldName, fieldType, fieldId = self.protocol.readFieldBegin()
        if fieldType == TType.STOP:
            return False
        elif fieldType != TType.VOID:
            result = self._deserializeType(fieldType)
            lookingFor = "set" + fieldName[0].upper() + fieldName[1:]

            try:
                setMethod = getattr(obj, lookingFor)
                setMethod(result)
            except:
                raise dynamicserialize.SerializationException(
                    "Couldn't find setter method " + lookingFor)

        self.protocol.readFieldEnd()
        return True
Example #6
0
def serialize(context, coordinate):
    raise dynamicserialize.SerializationException('Not implemented yet')
Example #7
0
 def _serializeType(self, fieldValue, fieldType):
     if fieldType in self.typeSerializationMethod:
         return self.typeSerializationMethod[fieldType](fieldValue)
     else:
         raise dynamicserialize.SerializationException(
             "Unsupported type value " + str(fieldType))
Example #8
0
 def _deserializeType(self, b):
     try:
         return self.typeDeserializationMethod[b]()
     except KeyError:
         raise dynamicserialize.SerializationException(
             "Unsupported type value " + str(b))
Example #9
0
 def _deserializeType(self, b):
     if self.typeDeserializationMethod.has_key(b):
         return self.typeDeserializationMethod[b]()
     else:
         raise dynamicserialize.SerializationException("Unsupported type value " + str(b))