berkus
/
bincode
mirror of https://git.sr.ht/~stygianentity/bincode
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove sized bounds where appropriate (#101) 

* Remove sized bounds where appropriate

* Make bounds compatible with stable
This commit is contained in:
Lena Hellström 2017-01-31 22:24:08 -06:00 committed by Ty Overby
parent fac69cfcaa
commit 419411d004
1 changed files with 12 additions and 7 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
src/serde/mod.rs
View File

@ -33,8 +33,9 @@ mod writer;
/// If this returns an `SerializeError` (other than SizeLimit), assume that the /// If this returns an `SerializeError` (other than SizeLimit), assume that the
/// writer is in an invalid state, as writing could bail out in the middle of /// writer is in an invalid state, as writing could bail out in the middle of
/// serializing. /// serializing.
pub fn serialize_into<W, T>(writer: &mut W, value: &T, size_limit: SizeLimit) -> SerializeResult<()> pub fn serialize_into<W: ?Sized, T: ?Sized>(writer: &mut W, value: &T, size_limit: SizeLimit) -> SerializeResult<()>
where W: Write, T: serde::Serialize, where W: Write,
T: serde::Serialize,
{ {
match size_limit { match size_limit {
SizeLimit::Infinite => { } SizeLimit::Infinite => { }
@ -52,8 +53,8 @@ pub fn serialize_into<W, T>(writer: &mut W, value: &T, size_limit: SizeLimit) ->
/// ///
/// If the serialization would take more bytes than allowed by `size_limit`, /// If the serialization would take more bytes than allowed by `size_limit`,
/// an error is returned. /// an error is returned.
pub fn serialize<T>(value: &T, size_limit: SizeLimit) -> SerializeResult<Vec<u8>> pub fn serialize<T: ?Sized>(value: &T, size_limit: SizeLimit) -> SerializeResult<Vec<u8>>
where T: serde::Serialize, where T: serde::Serialize
{ {
// Since we are putting values directly into a vector, we can do size // Since we are putting values directly into a vector, we can do size
// computation out here and pre-allocate a buffer of *exactly* // computation out here and pre-allocate a buffer of *exactly*
@ -77,7 +78,9 @@ pub fn serialize<T>(value: &T, size_limit: SizeLimit) -> SerializeResult<Vec<u8>
/// ///
/// This is used internally as part of the check for encode_into, but it can /// This is used internally as part of the check for encode_into, but it can
/// be useful for preallocating buffers if thats your style. /// be useful for preallocating buffers if thats your style.
pub fn serialized_size<T: serde::Serialize>(value: &T) -> u64 { pub fn serialized_size<T: ?Sized>(value: &T) -> u64
where T: serde::Serialize
{
use std::u64::MAX; use std::u64::MAX;
let mut size_checker = SizeChecker::new(MAX); let mut size_checker = SizeChecker::new(MAX);
value.serialize(&mut size_checker).ok(); value.serialize(&mut size_checker).ok();
@ -89,7 +92,9 @@ pub fn serialized_size<T: serde::Serialize>(value: &T) -> u64 {
/// ///
/// If it can be serialized in `max` or fewer bytes, that number will be returned /// If it can be serialized in `max` or fewer bytes, that number will be returned
/// inside `Some`. If it goes over bounds, then None is returned. /// inside `Some`. If it goes over bounds, then None is returned.
pub fn serialized_size_bounded<T: serde::Serialize>(value: &T, max: u64) -> Option<u64> { pub fn serialized_size_bounded<T: ?Sized>(value: &T, max: u64) -> Option<u64>
where T: serde::Serialize
{
let mut size_checker = SizeChecker::new(max); let mut size_checker = SizeChecker::new(max);
value.serialize(&mut size_checker).ok().map(|_| size_checker.written) value.serialize(&mut size_checker).ok().map(|_| size_checker.written)
} }
@ -103,7 +108,7 @@ pub fn serialized_size_bounded<T: serde::Serialize>(value: &T, max: u64) -> Opti
/// If this returns an `DeserializeError`, assume that the buffer that you passed /// If this returns an `DeserializeError`, assume that the buffer that you passed
/// in is in an invalid state, as the error could be returned during any point /// in is in an invalid state, as the error could be returned during any point
/// in the reading. /// in the reading.
pub fn deserialize_from<R, T>(reader: &mut R, size_limit: SizeLimit) -> DeserializeResult<T> pub fn deserialize_from<R: ?Sized, T>(reader: &mut R, size_limit: SizeLimit) -> DeserializeResult<T>
where R: Read, where R: Read,
T: serde::Deserialize, T: serde::Deserialize,
{ {