Serialization Namespace Reference

Classes
struct	ArrayOutputStream
struct	FatalSerializationException
struct	InputStream
struct	MemoryInputStream
struct	OutputStream

Functions
FORCEINLINE void	serializeBytes (OutputStream &stream, const U8 *bytes, Uptr numBytes)
FORCEINLINE void	serializeBytes (InputStream &stream, U8 *bytes, Uptr numBytes)
template<typename Stream , typename Value >
FORCEINLINE void	serializeNativeValue (Stream &stream, Value &value)
template<typename Stream >
void	serialize (Stream &stream, U8 &i)
template<typename Stream >
void	serialize (Stream &stream, U32 &i)
template<typename Stream >
void	serialize (Stream &stream, U64 &i)
template<typename Stream >
void	serialize (Stream &stream, I8 &i)
template<typename Stream >
void	serialize (Stream &stream, I32 &i)
template<typename Stream >
void	serialize (Stream &stream, I64 &i)
template<typename Stream >
void	serialize (Stream &stream, F32 &f)
template<typename Stream >
void	serialize (Stream &stream, F64 &f)
template<typename Value , Uptr maxBits>
FORCEINLINE void	serializeVarInt (OutputStream &stream, Value &inValue, Value minValue, Value maxValue)
template<typename Value , Uptr maxBits>
FORCEINLINE void	serializeVarInt (InputStream &stream, Value &value, Value minValue, Value maxValue)
template<typename Stream , typename Value >
void	serializeVarUInt1 (Stream &stream, Value &value)
template<typename Stream , typename Value >
void	serializeVarUInt7 (Stream &stream, Value &value)
template<typename Stream , typename Value >
void	serializeVarUInt32 (Stream &stream, Value &value)
template<typename Stream , typename Value >
void	serializeVarUInt64 (Stream &stream, Value &value)
template<typename Stream , typename Value >
void	serializeVarInt7 (Stream &stream, Value &value)
template<typename Stream , typename Value >
void	serializeVarInt32 (Stream &stream, Value &value)
template<typename Stream , typename Value >
void	serializeVarInt64 (Stream &stream, Value &value)
template<typename Constant >
void	serializeConstant (InputStream &stream, const char *constantMismatchMessage, Constant constant)
template<typename Constant >
void	serializeConstant (OutputStream &stream, const char *constantMismatchMessage, Constant constant)
template<typename Stream >
void	serialize (Stream &stream, std::string &string)
template<typename Stream , typename Element , typename Allocator , typename SerializeElement >
void	serializeArray (Stream &stream, std::vector< Element, Allocator > &vector, SerializeElement serializeElement)
template<typename Stream , typename Element , typename Allocator >
void	serialize (Stream &stream, std::vector< Element, Allocator > &vector)

Function Documentation

serialize() [1/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		F32 &	f )

Definition at line 153 of file Serialization.h.

{ serializeNativeValue(stream,f); }

Here is the call graph for this function:

serialize() [2/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		F64 &	f )

Definition at line 154 of file Serialization.h.

{ serializeNativeValue(stream,f); }

Here is the call graph for this function:

serialize() [3/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		I32 &	i )

Definition at line 151 of file Serialization.h.

{ serializeNativeValue(stream,i); }

Here is the call graph for this function:

serialize() [4/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		I64 &	i )

Definition at line 152 of file Serialization.h.

{ serializeNativeValue(stream,i); }

Here is the call graph for this function:

serialize() [5/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		I8 &	i )

Definition at line 150 of file Serialization.h.

{ serializeNativeValue(stream,i); }

Here is the call graph for this function:

serialize() [6/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		std::string &	string )

Definition at line 264 of file Serialization.h.

    {
      constexpr size_t max_size = sysio::chain::wasm_constraints::maximum_func_local_bytes;
        Uptr size = string.size();
        serializeVarUInt32(stream,size);
        if(Stream::isInput)
        {
            // Advance the stream before resizing the string:
            // try to get a serialization exception before making a huge allocation for malformed input.
            const U8* inputBytes = stream.advance(size);
         if (size >= max_size && WASM::check_limits)
            throw FatalSerializationException(std::string("Trying to deserialize string of size : " + std::to_string((uint64_t)size) + ", which is over by "+std::to_string(size - max_size )+" bytes"));
            string.resize(size);
            memcpy(const_cast<char*>(string.data()),inputBytes,size);
            string.shrink_to_fit();
        }
        else { serializeBytes(stream,(U8*)string.c_str(),size); }
    }

Here is the call graph for this function:

serialize() [7/10]

template<typename Stream , typename Element , typename Allocator >

void Serialization::serialize	(	Stream &	stream,
		std::vector< Element, Allocator > &	vector )

Definition at line 310 of file Serialization.h.

    {
        serializeArray(stream,vector,[](Stream& stream,Element& element){serialize(stream,element);});
    }

Here is the call graph for this function:

serialize() [8/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		U32 &	i )

Definition at line 148 of file Serialization.h.

{ serializeNativeValue(stream,i); }

Here is the call graph for this function:

serialize() [9/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		U64 &	i )

Definition at line 149 of file Serialization.h.

{ serializeNativeValue(stream,i);  }

Here is the call graph for this function:

serialize() [10/10]

template<typename Stream >

void Serialization::serialize	(	Stream &	stream,
		U8 &	i )

Definition at line 147 of file Serialization.h.

{ serializeNativeValue(stream,i); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeArray()

template<typename Stream , typename Element , typename Allocator , typename SerializeElement >

void Serialization::serializeArray	(	Stream &	stream,
		std::vector< Element, Allocator > &	vector,
		SerializeElement	serializeElement )

Definition at line 284 of file Serialization.h.

    {
      constexpr size_t max_size = sysio::chain::wasm_constraints::maximum_func_local_bytes;
        Uptr size = vector.size();
        serializeVarUInt32(stream,size);
        if(Stream::isInput)
        {
            // Grow the vector one element at a time:
            // try to get a serialization exception before making a huge allocation for malformed input.
            vector.clear();
         if (size >= max_size && WASM::check_limits)
            throw FatalSerializationException(std::string("Trying to deserialize array of size : " + std::to_string((uint64_t)size) + ", which is over by "+std::to_string(size - max_size )+" bytes"));
            for(Uptr index = 0;index < size;++index)
            {
                vector.push_back(Element());
                serializeElement(stream,vector.back());
            }
         vector.shrink_to_fit();
        }
        else
        {
            for(Uptr index = 0;index < vector.size();++index) { serializeElement(stream,vector[index]); }
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeBytes() [1/2]

FORCEINLINE void Serialization::serializeBytes	(	InputStream &	stream,
		U8 *	bytes,
		Uptr	numBytes )

Definition at line 135 of file Serialization.h.

    { 
      if ( numBytes < sysio::chain::wasm_constraints::wasm_page_size || !WASM::check_limits)
         memcpy(bytes,stream.advance(numBytes),numBytes); 
      else
         throw FatalSerializationException(std::string("Trying to deserialize bytes of size : " + std::to_string((uint64_t)numBytes)));
   }

Here is the call graph for this function:

serializeBytes() [2/2]

FORCEINLINE void Serialization::serializeBytes	(	OutputStream &	stream,
		const U8 *	bytes,
		Uptr	numBytes )

Definition at line 133 of file Serialization.h.

    { memcpy(stream.advance(numBytes),bytes,numBytes); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeConstant() [1/2]

template<typename Constant >

void Serialization::serializeConstant	(	InputStream &	stream,
		const char *	constantMismatchMessage,
		Constant	constant )

Definition at line 247 of file Serialization.h.

    {
        Constant savedConstant;
        serialize(stream,savedConstant);
        if(savedConstant != constant)
        {
            throw FatalSerializationException(std::string(constantMismatchMessage) + ": loaded " + std::to_string(savedConstant) + " but was expecting " + std::to_string(constant));
        }
    }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeConstant() [2/2]

template<typename Constant >

void Serialization::serializeConstant	(	OutputStream &	stream,
		const char *	constantMismatchMessage,
		Constant	constant )

Definition at line 257 of file Serialization.h.

    {
        serialize(stream,constant);
    }

Here is the call graph for this function:

serializeNativeValue()

template<typename Stream , typename Value >

FORCEINLINE void Serialization::serializeNativeValue	(	Stream &	stream,
		Value &	value )

Definition at line 145 of file Serialization.h.

{ serializeBytes(stream,(U8*)&value,sizeof(Value)); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeVarInt() [1/2]

template<typename Value , Uptr maxBits>

FORCEINLINE void Serialization::serializeVarInt	(	InputStream &	stream,
		Value &	value,
		Value	minValue,
		Value	maxValue )

Definition at line 181 of file Serialization.h.

    {
        // First, read the variable number of input bytes into a fixed size buffer.
        enum { maxBytes = (maxBits + 6) / 7 };
        U8 bytes[maxBytes] = {0};
        Uptr numBytes = 0;
        I8 signExtendShift = (I8)sizeof(Value) * 8;
        while(numBytes < maxBytes)
        {
            U8 byte = *stream.advance(1);
            bytes[numBytes] = byte;
            ++numBytes;
            signExtendShift -= 7;
            if(!(byte & 0x80)) { break; }
        };
 
        // Ensure that the input does not encode more than maxBits of data.
        enum { numUsedBitsInLastByte = maxBits - (maxBytes-1) * 7 };
        enum { numUnusedBitsInLast = 8 - numUsedBitsInLastByte };
        enum { lastBitUsedMask = U8(1<<(numUsedBitsInLastByte-1)) };
        enum { lastByteUsedMask = U8(1<<numUsedBitsInLastByte)-U8(1) };
        enum { lastByteSignedMask = U8(~U8(lastByteUsedMask) & ~U8(0x80)) };
        const U8 lastByte = bytes[maxBytes-1];
        if(!std::is_signed<Value>::value)
        {
            if((lastByte & ~lastByteUsedMask) != 0)
            {
                throw FatalSerializationException("Invalid unsigned LEB encoding: unused bits in final byte must be 0");
            }
        }
        else
        {
            const I8 signBit = I8((lastByte & lastBitUsedMask) << numUnusedBitsInLast);
            const I8 signExtendedLastBit = signBit >> numUnusedBitsInLast;
            if((lastByte & ~lastByteUsedMask) != (signExtendedLastBit & lastByteSignedMask))
            {
                throw FatalSerializationException(
                    "Invalid signed LEB encoding: unused bits in final byte must match the most-significant used bit");
            }
        }
 
        // Decode the buffer's bytes into the output integer.
        value = 0;
        for(Uptr byteIndex = 0;byteIndex < maxBytes;++byteIndex)
        { value |= Value(bytes[byteIndex] & ~0x80) << (byteIndex * 7); }
        
        // Sign extend the output integer to the full size of Value.
        if(std::is_signed<Value>::value && signExtendShift > 0)
        { value = Value(value << signExtendShift) >> signExtendShift; }
 
        // Check that the output integer is in the expected range.
        if(value < minValue || value > maxValue)
        { throw FatalSerializationException(std::string("out-of-range value: ") + std::to_string(minValue) + "<=" + std::to_string(value) + "<=" + std::to_string(maxValue)); }
    }

serializeVarInt() [2/2]

template<typename Value , Uptr maxBits>

FORCEINLINE void Serialization::serializeVarInt	(	OutputStream &	stream,
		Value &	inValue,
		Value	minValue,
		Value	maxValue )

Definition at line 158 of file Serialization.h.

    {
        Value value = inValue;
 
        if(value < minValue || value > maxValue)
        {
            throw FatalSerializationException(std::string("out-of-range value: ") + std::to_string(minValue) + "<=" + std::to_string(value) + "<=" + std::to_string(maxValue));
        }
 
        bool more = true;
        while(more)
        {
            U8 outputByte = (U8)(value&127);
            value >>= 7;
            more = std::is_signed<Value>::value
                ? (value != 0 && value != Value(-1)) || (value >= 0 && (outputByte & 0x40)) || (value < 0 && !(outputByte & 0x40))
                : (value != 0);
            if(more) { outputByte |= 0x80; }
            *stream.advance(1) = outputByte;
        };
    }

Here is the caller graph for this function:

serializeVarInt32()

template<typename Stream , typename Value >

void Serialization::serializeVarInt32	(	Stream &	stream,
		Value &	value )

Definition at line 242 of file Serialization.h.

{ serializeVarInt<Value,32>(stream,value,INT32_MIN,INT32_MAX); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeVarInt64()

template<typename Stream , typename Value >

void Serialization::serializeVarInt64	(	Stream &	stream,
		Value &	value )

Definition at line 243 of file Serialization.h.

{ serializeVarInt<Value,64>(stream,value,INT64_MIN,INT64_MAX); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeVarInt7()

template<typename Stream , typename Value >

void Serialization::serializeVarInt7	(	Stream &	stream,
		Value &	value )

Definition at line 241 of file Serialization.h.

{ serializeVarInt<Value,7>(stream,value,-64,63); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeVarUInt1()

template<typename Stream , typename Value >

void Serialization::serializeVarUInt1	(	Stream &	stream,
		Value &	value )

Definition at line 237 of file Serialization.h.

{ serializeVarInt<Value,1>(stream,value,0,1); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeVarUInt32()

template<typename Stream , typename Value >

void Serialization::serializeVarUInt32	(	Stream &	stream,
		Value &	value )

Definition at line 239 of file Serialization.h.

{ serializeVarInt<Value,32>(stream,value,0,UINT32_MAX); }

Here is the call graph for this function:

Here is the caller graph for this function:

serializeVarUInt64()

template<typename Stream , typename Value >

void Serialization::serializeVarUInt64	(	Stream &	stream,
		Value &	value )

Definition at line 240 of file Serialization.h.

{ serializeVarInt<Value,64>(stream,value,0,UINT64_MAX); }

Here is the call graph for this function:

serializeVarUInt7()

template<typename Stream , typename Value >

void Serialization::serializeVarUInt7	(	Stream &	stream,
		Value &	value )

Definition at line 238 of file Serialization.h.

{ serializeVarInt<Value,7>(stream,value,0,127); }

Here is the call graph for this function:

Here is the caller graph for this function: