Deserialize full object.

        Args:
            reader (neocore.IO.BinaryReader):
423113
def Deserialize(self, reader: BinaryReader):
        

        self.Type = StateType(reader.ReadByte())

        self.Key = reader.ReadVarBytes(max=100)
        self.Field = reader.ReadVarString(max=32).decode('utf-8')
        self.Value = reader.ReadVarBytes(max=65535)

        if self.Type == StateType.Account:
            self.CheckAccountState()
        elif self.Type == StateType.Validator:
            self.CheckValidatorState()
9260
public void readExternal(PofReader reader)
            throws IOException {
        super.readExternal(reader);
        setBinaryValue("value", reader.readBinary(0));
        fReturnOld = reader.readBoolean(1);
    }
18893
def DeserializeExclusiveData(self, reader):
        
        self.Nonce = reader.ReadUInt32()
        self.Type = TransactionType.MinerTransaction
1032479
def Deserialize(self, reader):
        
        self.AssetId = reader.ReadUInt256()
        self.Value = reader.ReadFixed8()
        self.ScriptHash = reader.ReadUInt160()
        if self.ScriptHash is None:
            raise Exception("Script hash is required from deserialize!!!!!!!!")
1299020
public Object unmarshal(HierarchicalStreamReader reader,
			UnmarshallingContext context) {
		XAttributeMap map = null;
		// restore correct type of attribute map, i.e., check for buffered
		// implementation, and correctly restore lazy implementation if
		// this had been used for serialization.
		boolean lazy = reader.getAttribute("lazy").equals("true");
		boolean buffered = reader.getAttribute("buffered").equals("true");
		if (lazy) {
			if (buffered) {
				map = new XAttributeMapLazyImpl<XAttributeMapBufferedImpl>(
						XAttributeMapBufferedImpl.class);
			} else {
				map = new XAttributeMapLazyImpl<XAttributeMapImpl>(
						XAttributeMapImpl.class);
			}
		} else if (buffered) {
			map = new XAttributeMapBufferedImpl();
		} else {
			map = new XAttributeMapImpl();
		}
		while (reader.hasMoreChildren()) {
			reader.moveDown();
			XAttribute attribute = (XAttribute) context.convertAnother(map,
					XAttribute.class, XesXStreamPersistency.attributeConverter);
			map.put(attribute.getKey(), attribute);
			reader.moveUp();
		}
		return map;
	}
593970
public void parseReader(Reader reader) throws ParserException, IOException {

        try {
            nanoElement.parseFromReader(reader);
        } catch (XMLParseException e) {
            throw new ParserException(e.getMessage());
        }
    }
114075
def DeserializeExclusiveData(self, reader):
        
        if self.Version > 1:
            logger.error("format exception...")

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

        if self.Version >= 1:
            self.NeedStorage = reader.ReadBool()
        else:
            self.NeedStorage = False

        self.Name = reader.ReadVarString()
        self.CodeVersion = reader.ReadVarString()
        self.Author = reader.ReadVarString()
        self.Email = reader.ReadVarString()
        self.Description = reader.ReadVarString()
1249085
public <T> T read(final Reader reader, final DataTypeDescriptor<T> descriptor) {
		try {
			return jsonFormat.read(reader, descriptor);
		} catch (Exception e) {
			throw propagate(e);
		}
	}
1139200
def DeserializeFromDB(buffer):
        
        m = StreamManager.GetStream(buffer)
        reader = BinaryReader(m)
        uns = UnspentCoinState()
        uns.Deserialize(reader)

        StreamManager.ReleaseStream(m)

        return uns
1278830
public Object parse(Reader reader) {
        Object content;

        JsonLexer lexer = new JsonLexer(reader);

        JsonToken token = lexer.nextToken();
        if (token.getType() == OPEN_CURLY) {
            content = parseObject(lexer);
        } else if (token.getType() == OPEN_BRACKET) {
            content = parseArray(lexer);
        } else {
            throw new JsonException(
                    "A JSON payload should start with " + OPEN_CURLY.getLabel() +
                            " or " + OPEN_BRACKET.getLabel() + ".\n" +
                            "Instead, '" + token.getText() + "' was found " +
                            "on line: " + token.getStartLine() + ", " +
                            "column: " + token.getStartColumn()
            );
        }

        return content;
    }
703501
public void readExternal(PofReader reader)
            throws IOException {
        value = reader.readObject(0);
        fReturnOld = reader.readBoolean(1);
    }
773471
def loads(s, single=False, version=_default_version,
          strict=False, errors='warn'):
    
    ms = deserialize(s, version=version, strict=strict, errors=errors)
    if single:
        return next(ms)
    else:
        return ms
77104
public static ReadStreamOld openRead(Reader reader)
  {
    if (reader instanceof ReadStreamOld.StreamReader)
      return ((ReadStreamOld.StreamReader) reader).getStream();
    
    ReaderWriterStream s = new ReaderWriterStream(reader, null);
    ReadStreamOld is = new ReadStreamOld(s);
    try {
      is.setEncoding("utf-8");
    } catch (Exception e) {
    }

    return is;
  }
414615
def Deserialize(self, reader):
        
        self.DeserializeUnsigned(reader)

        self.scripts = reader.ReadSerializableArray()
        self.OnDeserialized()
1134819
def deserialize(self, value, **kwargs):
        
        for validator in self.validators:
            validator.validate(value, **kwargs)

        return value
1250938
def Deserialize(self, reader):
        
        usage = reader.ReadByte()
        self.Usage = usage

        if usage == TransactionAttributeUsage.ContractHash or usage == TransactionAttributeUsage.Vote or \
                (usage >= TransactionAttributeUsage.Hash1 and usage <= TransactionAttributeUsage.Hash15):
            self.Data = reader.ReadBytes(32)

        elif usage == TransactionAttributeUsage.ECDH02 or usage == TransactionAttributeUsage.ECDH03:
            self.Data = bytearray(usage) + bytearray(reader.ReadBytes(32))

        elif usage == TransactionAttributeUsage.Script:
            self.Data = reader.ReadBytes(20)

        elif usage == TransactionAttributeUsage.DescriptionUrl:

            self.Data = reader.ReadBytes(reader.ReadByte())

        elif usage == TransactionAttributeUsage.Description or usage >= TransactionAttributeUsage.Remark:
            self.Data = reader.ReadVarBytes(max=self.MAX_ATTR_DATA_SIZE)
        else:
            logger.error("format error!!!")
847424
public Object unmarshal(HierarchicalStreamReader reader,
			UnmarshallingContext context) {
		XEventImpl event = new XEventImpl();

		String id = reader.getAttribute("xid");
		event.setID(XID.parse(id));

		if (reader.hasMoreChildren()) {
			reader.moveDown();
			XAttributeMap attributes = (XAttributeMap) context.convertAnother(
					event, XAttributeMap.class,  XesXStreamPersistency.attributeMapConverter);
			event.setAttributes(attributes);
			reader.moveUp();
		}
		return event;
	}