Golang Unmarshaller.UnmarshalUint32方法代码示例

func (o *FileInfo) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.Name = u.UnmarshalStringMax(8192)
	o.Flags = u.UnmarshalUint32()
	o.Modified = int64(u.UnmarshalUint64())
	(&o.Version).UnmarshalXDRFrom(u)
	o.LocalVersion = int64(u.UnmarshalUint64())
	_BlocksSize := int(u.UnmarshalUint32())
	if _BlocksSize < 0 {
		return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 10000000)
	} else if _BlocksSize == 0 {
		o.Blocks = nil
	} else {
		if _BlocksSize > 10000000 {
			return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 10000000)
		}
		if _BlocksSize <= len(o.Blocks) {
			o.Blocks = o.Blocks[:_BlocksSize]
		} else {
			o.Blocks = make([]BlockInfo, _BlocksSize)
		}
		for i := range o.Blocks {
			(&o.Blocks[i]).UnmarshalXDRFrom(u)
		}
	}
	return u.Error
}

func (o *XDRA) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.Name = u.UnmarshalString()
	o.BirthDay = int64(u.UnmarshalUint64())
	o.Phone = u.UnmarshalString()
	o.Siblings = int32(u.UnmarshalUint32())
	o.Spouse = u.UnmarshalBool()
	o.Money = u.UnmarshalUint64()
	return u.Error
}

func (v *Vector) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	l := int(u.UnmarshalUint32())
	if l > 1e6 {
		return xdr.ElementSizeExceeded("number of counters", l, 1e6)
	}
	n := make(Vector, l)
	for i := range n {
		n[i].ID = ShortID(u.UnmarshalUint64())
		n[i].Value = u.UnmarshalUint64()
	}
	*v = n
	return u.Error
}

func (o *VersionList) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	_versionsSize := int(u.UnmarshalUint32())
	if _versionsSize < 0 {
		return xdr.ElementSizeExceeded("versions", _versionsSize, 0)
	} else if _versionsSize == 0 {
		o.versions = nil
	} else {
		if _versionsSize <= len(o.versions) {
			o.versions = o.versions[:_versionsSize]
		} else {
			o.versions = make([]fileVersion, _versionsSize)
		}
		for i := range o.versions {
			(&o.versions[i]).UnmarshalXDRFrom(u)
		}
	}
	return u.Error
}

func (o *TestStruct) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.B = u.UnmarshalBool()
	o.I = int(u.UnmarshalUint64())
	o.I8 = int8(u.UnmarshalUint8())
	o.UI8 = u.UnmarshalUint8()
	o.I16 = int16(u.UnmarshalUint16())
	o.UI16 = u.UnmarshalUint16()
	o.I32 = int32(u.UnmarshalUint32())
	o.UI32 = u.UnmarshalUint32()
	o.I64 = int64(u.UnmarshalUint64())
	o.UI64 = u.UnmarshalUint64()
	o.BS = u.UnmarshalBytesMax(1024)
	o.S = u.UnmarshalStringMax(1024)
	(&o.C).UnmarshalXDRFrom(u)
	_SSSize := int(u.UnmarshalUint32())
	if _SSSize < 0 {
		return xdr.ElementSizeExceeded("SS", _SSSize, 1024)
	} else if _SSSize == 0 {
		o.SS = nil
	} else {
		if _SSSize > 1024 {
			return xdr.ElementSizeExceeded("SS", _SSSize, 1024)
		}
		if _SSSize <= len(o.SS) {
			for i := _SSSize; i < len(o.SS); i++ {
				o.SS[i] = ""
			}
			o.SS = o.SS[:_SSSize]
		} else {
			o.SS = make([]string, _SSSize)
		}
		for i := range o.SS {
			o.SS[i] = u.UnmarshalString()
		}
	}
	(&o.ES).UnmarshalXDRFrom(u)
	(&o.OS).UnmarshalXDRFrom(u)
	_OSsSize := int(u.UnmarshalUint32())
	if _OSsSize < 0 {
		return xdr.ElementSizeExceeded("OSs", _OSsSize, 0)
	} else if _OSsSize == 0 {
		o.OSs = nil
	} else {
		if _OSsSize <= len(o.OSs) {
			o.OSs = o.OSs[:_OSsSize]
		} else {
			o.OSs = make([]OtherStruct, _OSsSize)
		}
		for i := range o.OSs {
			(&o.OSs[i]).UnmarshalXDRFrom(u)
		}
	}
	return u.Error
}

func (o *ClusterConfigMessage) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.DeviceName = u.UnmarshalStringMax(64)
	o.ClientName = u.UnmarshalStringMax(64)
	o.ClientVersion = u.UnmarshalStringMax(64)
	_FoldersSize := int(u.UnmarshalUint32())
	if _FoldersSize < 0 {
		return xdr.ElementSizeExceeded("Folders", _FoldersSize, 1000000)
	} else if _FoldersSize == 0 {
		o.Folders = nil
	} else {
		if _FoldersSize > 1000000 {
			return xdr.ElementSizeExceeded("Folders", _FoldersSize, 1000000)
		}
		if _FoldersSize <= len(o.Folders) {
			o.Folders = o.Folders[:_FoldersSize]
		} else {
			o.Folders = make([]Folder, _FoldersSize)
		}
		for i := range o.Folders {
			(&o.Folders[i]).UnmarshalXDRFrom(u)
		}
	}
	_OptionsSize := int(u.UnmarshalUint32())
	if _OptionsSize < 0 {
		return xdr.ElementSizeExceeded("Options", _OptionsSize, 64)
	} else if _OptionsSize == 0 {
		o.Options = nil
	} else {
		if _OptionsSize > 64 {
			return xdr.ElementSizeExceeded("Options", _OptionsSize, 64)
		}
		if _OptionsSize <= len(o.Options) {
			o.Options = o.Options[:_OptionsSize]
		} else {
			o.Options = make([]Option, _OptionsSize)
		}
		for i := range o.Options {
			(&o.Options[i]).UnmarshalXDRFrom(u)
		}
	}
	return u.Error
}

func (o *Device) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.ID = u.UnmarshalBytesMax(32)
	_AddressesSize := int(u.UnmarshalUint32())
	if _AddressesSize < 0 {
		return xdr.ElementSizeExceeded("Addresses", _AddressesSize, 16)
	} else if _AddressesSize == 0 {
		o.Addresses = nil
	} else {
		if _AddressesSize > 16 {
			return xdr.ElementSizeExceeded("Addresses", _AddressesSize, 16)
		}
		if _AddressesSize <= len(o.Addresses) {
			o.Addresses = o.Addresses[:_AddressesSize]
		} else {
			o.Addresses = make([]Address, _AddressesSize)
		}
		for i := range o.Addresses {
			(&o.Addresses[i]).UnmarshalXDRFrom(u)
		}
	}
	_RelaysSize := int(u.UnmarshalUint32())
	if _RelaysSize < 0 {
		return xdr.ElementSizeExceeded("Relays", _RelaysSize, 16)
	} else if _RelaysSize == 0 {
		o.Relays = nil
	} else {
		if _RelaysSize > 16 {
			return xdr.ElementSizeExceeded("Relays", _RelaysSize, 16)
		}
		if _RelaysSize <= len(o.Relays) {
			o.Relays = o.Relays[:_RelaysSize]
		} else {
			o.Relays = make([]Relay, _RelaysSize)
		}
		for i := range o.Relays {
			(&o.Relays[i]).UnmarshalXDRFrom(u)
		}
	}
	return u.Error
}

func (o *XDRBenchStruct) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.I1 = u.UnmarshalUint64()
	o.I2 = u.UnmarshalUint32()
	o.I3 = u.UnmarshalUint16()
	o.I4 = u.UnmarshalUint8()
	o.Bs0 = u.UnmarshalBytesMax(128)
	o.Bs1 = u.UnmarshalBytes()
	_Is0Size := int(u.UnmarshalUint32())
	if _Is0Size < 0 {
		return xdr.ElementSizeExceeded("Is0", _Is0Size, 0)
	} else if _Is0Size == 0 {
		o.Is0 = nil
	} else {
		if _Is0Size <= len(o.Is0) {
			o.Is0 = o.Is0[:_Is0Size]
		} else {
			o.Is0 = make([]int32, _Is0Size)
		}
		for i := range o.Is0 {
			o.Is0[i] = int32(u.UnmarshalUint32())
		}
	}
	o.S0 = u.UnmarshalStringMax(128)
	o.S1 = u.UnmarshalString()
	return u.Error
}

func (o *FileInfoTruncated) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.Name = u.UnmarshalStringMax(8192)
	o.Flags = u.UnmarshalUint32()
	o.Modified = int64(u.UnmarshalUint64())
	(&o.Version).UnmarshalXDRFrom(u)
	o.LocalVersion = int64(u.UnmarshalUint64())
	_BlocksSize := int(u.UnmarshalUint32())
	if _BlocksSize < 0 {
		return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 1000000)
	} else if _BlocksSize == 0 {
		o.Blocks = nil
	} else {
		if _BlocksSize > 1000000 {
			return xdr.ElementSizeExceeded("Blocks", _BlocksSize, 1000000)
		}
		for i := 0; i < _BlocksSize; i++ {
			size := int64(u.UnmarshalUint32())
			o.CachedSize += size
			u.UnmarshalBytes()
		}
	}

	return u.Error
}

func (h *header) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	v := u.UnmarshalUint32()
	*h = decodeHeader(v)
	return u.Error
}

func (o *Response) UnmarshalXDRFrom(u *xdr.Unmarshaller) error {
	o.Code = int32(u.UnmarshalUint32())
	o.Message = u.UnmarshalString()
	return u.Error
}