src/bytestream.cpp

#include "bytestream.h"
#include "misc.h"
#include <string.h>

union {
	uint32 i;
	float f;
} g_floatunion;

Bytestream::Bytestream( ulong len ) {
	m_data = null;
	resize( len );
	clear();
}

Bytestream::Bytestream( const char* data, ulong len ) {
	m_data = null;
	init( data, len );
}

void Bytestream::resize( ulong newsize ) {
	char* olddata = null;
	ulong oldsize;
	
	if( m_data ) {
		oldsize = m_size;
		olddata = new char[oldsize];
		memcpy( olddata, m_data, oldsize );
	}
	
	delete[] m_data;
	m_data = new uint8[newsize];
	m_size = newsize;
	
	if( olddata )
		memcpy( m_data, olddata, min<ulong> ( oldsize, newsize ));
}

void Bytestream::init( const char* data, ulong len ) {
	resize( len );
	memcpy( m_data, data, len );
	m_ptr = &m_data[0];
	m_len = len;
}

size_t Bytestream::len() const {
	return m_len;
}

void Bytestream::clear() {
	m_ptr = &m_data[0];
	m_len = 0;
}

uint8& Bytestream::subscript( ulong idx ) {
	return m_data[idx];
}

const uint8& Bytestream::const_subscript( ulong idx ) const {
	return m_data[idx];
}

void Bytestream::seek( ulong pos ) {
	m_ptr = m_data + pos;
}

// =============================================================================
void Bytestream::rewind() {
	m_ptr = m_data;
}

ulong Bytestream::bytesLeft() const {
	return ( m_len - ( m_ptr - &m_data[0] ));
}

ulong Bytestream::spaceLeft() const {
	return ( m_size - m_len );
}

// =============================================================================
bool Bytestream::readByte( uint8& val ) {
	if( bytesLeft() < 1 )
		return false;
	
	val = *m_ptr++;
	return true;
}

// =============================================================================
bool Bytestream::readShort( uint16& val ) {
	if( bytesLeft() < 2 )
		return false;
	
	val = 0;
	
	for( int i = 0; i < 2; ++i )
		val |= *m_ptr++ << ( i * 8 );

	return true;
}

// =============================================================================
bool Bytestream::readLong( uint32& val ) {
	if( bytesLeft() < 4 )
		return false;
	
	val = 0;
	
	for( int i = 0; i < 4; ++i )
		val |= *m_ptr++ << ( i * 8 );
	
	return true;
}

// =============================================================================
bool Bytestream::readFloat( float& val ) {
	if( !readLong( g_floatunion.i ))
		return false;

	val = g_floatunion.f;
	return true;
}

// =============================================================================
bool Bytestream::readString( str& val ) {
	if( bytesLeft() < 1 ) // need at least the null terminator
		return false;
	
	uint8_t c;
	
	while( readByte( c ) && c != '\0' )
		val += ( char ) c;
	
	return true;
}

// =============================================================================
void Bytestream::doWrite( uint8_t val ) {
	*m_ptr++ = val;
	m_len++;
}

void Bytestream::growToFit( ulong bytes ) {
	if( spaceLeft() < bytes )
		resize( m_size + bytes + 128 );
}

bool Bytestream::readBytes( uint8 numbytes, uint8* val ) {
	while( numbytes-- )
		if( !readByte( *val++ ))
			return false;
	
	return true;
}

void Bytestream::writeBytes( uint8 numbytes, const uint8* val ) {
	growToFit( numbytes );
	
	while( numbytes-- )
		writeByte( *val++ );
}

// =============================================================================
void Bytestream::writeByte( uint8 val ) {
	growToFit( 1 );
	doWrite( val );
}

// =============================================================================
void Bytestream::writeShort( uint16 val ) {
	growToFit( 2 );
	
	for( int i = 0; i < 2; ++i )
		doWrite(( val >> ( i * 8 )) & 0xFF );
}

// =============================================================================
void Bytestream::writeLong( uint32 val ) {
	growToFit( 4 );
	
	for( int i = 0; i < 4; ++i )
		doWrite(( val >> ( i * 8 )) & 0xFF );
}

// =============================================================================
void Bytestream::writeFloat( float val ) {
	g_floatunion.f = val;
	writeLong( g_floatunion.i );
}

// =============================================================================
void Bytestream::writeString( str val ) {
	growToFit( val.length() + 1 );
	
	for( qchar c : val )
		doWrite( c.toAscii() );
	
	doWrite( '\0' );
}

// =============================================================================
bool Bytestream::tryMerge( const Bytestream& other ) {
	if( spaceLeft() < other.len() )
		return false;
	
	for( ulong i = 0; i < other.len(); ++i )
		writeByte( other[i] );
	
	return true;
}

void Bytestream::merge( const Bytestream& other ) {
	growToFit( other.len() );
	
	if( !tryMerge( other )) {
		// Shouldn't happen
		fprint( stderr, "ByteStream: Not enough space for merge (%1 bytes left, need %2)",
				spaceLeft(), other.len() );
		abort();
	}
}

const uint8* Bytestream::data() const {
	return m_data;
}