Deserialize full object.

        Args:
            reader (neo.IO.BinaryReader):
975257
def Deserialize(self, reader):
        
        self.Timestamp = reader.ReadUInt32()
        self.Services = reader.ReadUInt64()
        addr = bytearray(reader.ReadFixedString(16))
        addr.reverse()
        addr.strip(b'\x00')
        nums = []
        for i in range(0, 4):
            nums.append(str(addr[i]))
        nums.reverse()
        adddd = '.'.join(nums)
        self.Address = adddd
        self.Port = reader.ReadUInt16(endian='>')
1097472
def deserialize(stream_or_string, **options):
    '''
    
    '''

    if six.PY3:
        cp = configparser.ConfigParser(**options)
    else:
        cp = configparser.SafeConfigParser(**options)

    try:
        if not isinstance(stream_or_string, (bytes, six.string_types)):
            if six.PY3:
                cp.read_file(stream_or_string)
            else:
                cp.readfp(stream_or_string)
        else:
            if six.PY3:
                cp.read_file(six.moves.StringIO(stream_or_string))
            else:
                # python2's ConfigParser cannot parse a config from a string
                cp.readfp(six.moves.StringIO(stream_or_string))
        data = {}
        for section_name in cp.sections():
            section = {}
            for k, v in cp.items(section_name):
                section[k] = v
            data[section_name] = section
        return data
    except Exception as error:
        raise DeserializationError(error)
711214
def Deserialize(self, reader):
        
        super(ContractState, self).Deserialize(reader)

        code = FunctionCode()
        code.Deserialize(reader)
        self.Code = code

        self.ContractProperties = reader.ReadUInt8()
        self.Name = reader.ReadVarString(max=252)
        self.CodeVersion = reader.ReadVarString(max=252)
        self.Author = reader.ReadVarString(max=252)
        self.Email = reader.ReadVarString(max=252)
        self.Description = reader.ReadVarString(max=65536)
645830
def DeserializeFromBufer(buffer, offset=0):
        
        mstream = StreamManager.GetStream(buffer)
        reader = BinaryReader(mstream)
        tx = Transaction.DeserializeFrom(reader)

        StreamManager.ReleaseStream(mstream)
        return tx
673728
public V deserialize( JsonReader reader, JsonDeserializationContext ctx ) {
        return getDeserializer().deserialize( reader, ctx, getParameters() );
    }
538365
public <V> V convertFrom(final JsonReader reader) {
        if (reader == null) return null;
        return (V) new AnyDecoder(factory).convertFrom(reader);
    }
55379
public Object unmarshal(HierarchicalStreamReader reader,
			UnmarshallingContext context) {
		XFactory factory = XFactoryRegistry.instance().currentDefault();
		XTrace trace = factory.createTrace();
		reader.moveDown();
		XAttributeMap attributes = (XAttributeMap) context.convertAnother(
				trace, XAttributeMap.class,
				XesXStreamPersistency.attributeMapConverter);
		trace.setAttributes(attributes);
		reader.moveUp();
		while (reader.hasMoreChildren()) {
			reader.moveDown();
			XEvent event = (XEvent) context.convertAnother(trace, XEvent.class,
					XesXStreamPersistency.eventConverter);
			trace.add(event);
			reader.moveUp();
		}
		return trace;
	}
707812
def Deserialize(self, reader):
        
        super(StorageItem, self).Deserialize(reader)
        self.Value = reader.ReadVarBytes()
171387
function read(reader) {

            var offset = this.offset;

            if (undefined !== offset) {
                reader.seek(offset);
            }

            var me = this;

            this.struct.forEach(function (item) {
                var name = item[0];
                var type = item[1];

                switch (type) {
                    case struct.Int8:
                    case struct.Uint8:
                    case struct.Int16:
                    case struct.Uint16:
                    case struct.Int32:
                    case struct.Uint32:
                        var typeName = struct.names[type];
                        me[name] = reader.read(typeName);
                        break;

                    case struct.Fixed:
                        me[name] = reader.readFixed();
                        break;

                    case struct.LongDateTime:
                        me[name] = reader.readLongDateTime();
                        break;

                    case struct.Bytes:
                        me[name] = reader.readBytes(reader.offset, item[2] || 0);
                        break;

                    case struct.Char:
                        me[name] = reader.readChar();
                        break;

                    case struct.String:
                        me[name] = reader.readString(reader.offset, item[2] || 0);
                        break;

                    default:
                        error.raise(10003, name, type);
                }
            });

            return this.valueOf();
        }
669715
def DeserializeExclusiveData(self, reader):
        
        self.Type = TransactionType.ClaimTransaction
        if self.Version != 0:
            raise Exception('Format Exception')

        numrefs = reader.ReadVarInt()

        claims = []
        for i in range(0, numrefs):
            c = CoinReference()
            c.Deserialize(reader)
            claims.append(c)

        self.Claims = claims
        if len(self.Claims) == 0:
            raise Exception('Format Exception')
225648
public static JsonElement parseReader(JsonReader reader)
      throws JsonIOException, JsonSyntaxException {
    boolean lenient = reader.isLenient();
    reader.setLenient(true);
    try {
      return Streams.parse(reader);
    } catch (StackOverflowError e) {
      throw new JsonParseException("Failed parsing JSON source: " + reader + " to Json", e);
    } catch (OutOfMemoryError e) {
      throw new JsonParseException("Failed parsing JSON source: " + reader + " to Json", e);
    } finally {
      reader.setLenient(lenient);
    }
  }
18893
def DeserializeExclusiveData(self, reader):
        
        self.Nonce = reader.ReadUInt32()
        self.Type = TransactionType.MinerTransaction
113100
def decode_string(reader) -> bytes:
    
    length_bytes = yield from read_or_raise(reader, 2)
    str_length = unpack("!H", length_bytes)
    if str_length[0]:
        byte_str = yield from read_or_raise(reader, str_length[0])
        try:
            return byte_str.decode(encoding='utf-8')
        except:
            return str(byte_str)
    else:
        return ''
973590
public void readDictionary(Reader reader, String name) {
        name = name.toLowerCase();
        logger.debug("Reading dictionary: ", name);
        if (!dictionaries.containsKey(name)) {
            try {
                Dictionary dictionary = Dictionary.unmarshal(reader);
                dictionaries.put(name, dictionary);
                logger.debug("  ... loaded and stored");
            } catch (Exception exception) {
                logger.error("Could not read dictionary: ", name);
                logger.debug(exception);
            }
        } else {
            logger.error("Dictionary already loaded: ", name);
        }
    }
175616
def deserialize(self, value, **kwargs):                                    #pylint: disable=unused-argument
        
        kwargs.update({'trusted': kwargs.get('trusted', False)})
        if self.deserializer is not None:
            return self.deserializer(value, **kwargs)
        if value is None:
            return None
        return self.from_json(value, **kwargs)
211587
def DeserializeExclusiveData(self, reader):
        
        self.Type = TransactionType.StateTransaction

        self.Descriptors = reader.ReadSerializableArray('neo.Core.State.StateDescriptor.StateDescriptor')
973862
def deserialize(stream_or_string, **options):
    '''
    
    '''

    try:
        if not isinstance(stream_or_string, (bytes, six.string_types)):
            return toml.load(stream_or_string, **options)

        if isinstance(stream_or_string, bytes):
            stream_or_string = stream_or_string.decode('utf-8')

        return toml.loads(stream_or_string)
    except Exception as error:
        raise DeserializationError(error)