More fixes to streams

src/core/streams/BinaryReader.cpp

@@ -30,12 +30,7 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-BinaryReader::BinaryReader(Stream* stream) : m_stream(stream)
-{
-}
-
-//-----------------------------------------------------------------------------
-BinaryReader::~BinaryReader()
+BinaryReader::BinaryReader(Stream& stream) : m_stream(stream)
 {
 }
 
@@ -43,7 +38,7 @@ BinaryReader::~BinaryReader()
 int8_t BinaryReader::read_byte()
 {
 	int8_t buffer;
-	m_stream->read(&buffer, sizeof(int8_t));
+	m_stream.read(&buffer, sizeof(int8_t));
 	return buffer;
 }
 
@@ -51,7 +46,7 @@ int8_t BinaryReader::read_byte()
 int16_t BinaryReader::read_int16()
 {
 	int16_t buffer;
-	m_stream->read(&buffer, sizeof(int16_t));
+	m_stream.read(&buffer, sizeof(int16_t));
 	return buffer;
 }
 
@@ -59,7 +54,7 @@ int16_t BinaryReader::read_int16()
 uint16_t BinaryReader::read_uint16()
 {
 	uint16_t buffer;
-	m_stream->read(&buffer, sizeof(uint16_t));
+	m_stream.read(&buffer, sizeof(uint16_t));
 	return buffer;
 }
 
@@ -67,7 +62,7 @@ uint16_t BinaryReader::read_uint16()
 int32_t BinaryReader::read_int32()
 {
 	int32_t buffer;
-	m_stream->read(&buffer, sizeof(int32_t));
+	m_stream.read(&buffer, sizeof(int32_t));
 	return buffer;
 }
 
@@ -75,7 +70,7 @@ int32_t BinaryReader::read_int32()
 uint32_t BinaryReader::read_uint32()
 {
 	uint32_t buffer;
-	m_stream->read(&buffer, sizeof(uint32_t));
+	m_stream.read(&buffer, sizeof(uint32_t));
 	return buffer;
 }
 
@@ -83,7 +78,7 @@ uint32_t BinaryReader::read_uint32()
 int64_t BinaryReader::read_int64()
 {
 	int64_t buffer;
-	m_stream->read(&buffer, sizeof(int64_t));
+	m_stream.read(&buffer, sizeof(int64_t));
 	return buffer;
 }
 
@@ -91,14 +86,15 @@ int64_t BinaryReader::read_int64()
 double BinaryReader::read_double()
 {
 	double buffer;
-	m_stream->read(&buffer, sizeof(double));
+	m_stream.read(&buffer, sizeof(double));
 	return buffer;
 }
 
+//-----------------------------------------------------------------------------
 float BinaryReader::read_float()
 {
 	float buffer;
-	m_stream->read(&buffer, sizeof(float));
+	m_stream.read(&buffer, sizeof(float));
 	return buffer;
 }
 

src/core/streams/BinaryReader.h

@@ -36,8 +36,7 @@ class BinaryReader
 
 public:
 
-						BinaryReader(Stream* s);
-						~BinaryReader();
+						BinaryReader(Stream& s);
 
 	int8_t				read_byte();
 	int16_t				read_int16();
@@ -50,7 +49,7 @@ public:
 
 private:
 
-	Stream*				m_stream;
+	Stream&				m_stream;
 };
 
 } // namespace crown

src/core/streams/BinaryWriter.cpp

@@ -30,77 +30,72 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-BinaryWriter::BinaryWriter(Stream* stream) : m_stream(stream)
-{
-}
-
-//-----------------------------------------------------------------------------
-BinaryWriter::~BinaryWriter()
+BinaryWriter::BinaryWriter(Stream& stream) : m_stream(stream)
 {
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_byte(int8_t buffer)
 {
-	m_stream->write(&buffer, sizeof(int8_t));
+	m_stream.write(&buffer, sizeof(int8_t));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_int16(int16_t buffer)
 {
-	m_stream->write(&buffer, sizeof(int16_t));
+	m_stream.write(&buffer, sizeof(int16_t));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_uint16(uint16_t buffer)
 {
-	m_stream->write(&buffer, sizeof(uint16_t));
+	m_stream.write(&buffer, sizeof(uint16_t));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_int32(int32_t buffer)
 {
-	m_stream->write(&buffer, sizeof(int32_t));
+	m_stream.write(&buffer, sizeof(int32_t));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_uint32(uint32_t buffer)
 {
-	m_stream->write(&buffer, sizeof(uint32_t));
+	m_stream.write(&buffer, sizeof(uint32_t));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_int64(int64_t buffer)
 {
-	m_stream->write(&buffer, sizeof(int64_t));
+	m_stream.write(&buffer, sizeof(int64_t));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_double(double buffer)
 {
-	m_stream->write(&buffer, sizeof(double));
+	m_stream.write(&buffer, sizeof(double));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::write_float(float buffer)
 {
-	m_stream->write(&buffer, sizeof(float));
+	m_stream.write(&buffer, sizeof(float));
 }
 
 //-----------------------------------------------------------------------------
 void BinaryWriter::insert_byte(int8_t val, size_t offset)
 {
-	size_t tmpSize = m_stream->size() - offset;
+	size_t tmpSize = m_stream.size() - offset;
 	int8_t* tmp = new int8_t[tmpSize];
 
-	m_stream->seek(offset);
-	m_stream->read(tmp, tmpSize);
+	m_stream.seek(offset);
+	m_stream.read(tmp, tmpSize);
 
-	m_stream->seek(offset);
+	m_stream.seek(offset);
 
-	m_stream->write_byte(val);
+	m_stream.write_byte(val);
 
-	m_stream->write(tmp, tmpSize);
+	m_stream.write(tmp, tmpSize);
 
 	delete[] tmp;
 }

src/core/streams/BinaryWriter.h

@@ -36,8 +36,7 @@ class BinaryWriter
 
 public:
 
-						BinaryWriter(Stream* s);
-	virtual				~BinaryWriter();
+						BinaryWriter(Stream& s);
 
 	void				write_byte(int8_t);
 	void				write_int16(int16_t);
@@ -52,7 +51,7 @@ public:
 
 private:
 
-	Stream*				m_stream;
+	Stream&				m_stream;
 };
 
 } // namespace crown

src/core/streams/TextReader.cpp

@@ -31,19 +31,14 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-TextReader::TextReader(Stream* stream) : m_stream(stream)
-{
-}
-
-//-----------------------------------------------------------------------------
-TextReader::~TextReader()
+TextReader::TextReader(Stream& stream) : m_stream(stream)
 {
 }
 
 //-----------------------------------------------------------------------------
 char TextReader::read_char()
 {
-	return m_stream->read_byte();
+	return m_stream.read_byte();
 }
 
 //-----------------------------------------------------------------------------
@@ -52,9 +47,9 @@ char* TextReader::read_string(char* string, uint32_t count)
 	char currentChar;
 	uint32_t i = 0;
 
-	while(!m_stream->end_of_stream() && i < count - 1)
+	while(!m_stream.end_of_stream() && i < count - 1)
 	{
-		currentChar = m_stream->read_byte();
+		currentChar = m_stream.read_byte();
 		string[i] = currentChar;
 
 		i++;

src/core/streams/TextReader.h

@@ -36,8 +36,7 @@ class TextReader
 
 public:
 
-						TextReader(Stream* s);
-						~TextReader();
+						TextReader(Stream& s);
 
 	/// Read a single character from the stream
 	char				read_char();
@@ -54,7 +53,7 @@ public:
 
 private:
 
-	Stream*				m_stream;
+	Stream&				m_stream;
 };
 
 } // namespace crown

src/core/streams/TextWriter.cpp

@@ -30,18 +30,14 @@ namespace crown
 {
 
 //-----------------------------------------------------------------------------
-TextWriter::TextWriter(Stream* stream) : m_stream(stream)
+TextWriter::TextWriter(Stream& stream) : m_stream(stream)
 {
 }
 
 //-----------------------------------------------------------------------------
-TextWriter::~TextWriter()
-{
-}
-
 void TextWriter::write_char(char c)
 {
-	m_stream->write_byte(c);
+	m_stream.write_byte(c);
 }
 
 //-----------------------------------------------------------------------------
@@ -51,7 +47,7 @@ void TextWriter::write_string(const char* string)
 
 	while(string[count] != '\0')
 	{
-		m_stream->write_byte(string[count]);
+		m_stream.write_byte(string[count]);
 		count++;
 	}
 }

src/core/streams/TextWriter.h

@@ -34,13 +34,12 @@ class TextWriter
 
 public:
 
-						TextWriter(Stream* s);
-	virtual				~TextWriter();
+						TextWriter(Stream& s);
 
 	/// Writes a single character to the stream.
 	void				write_char(char c);
 	
-	/// Writes the string point32_ted by string to the stream.
+	/// Writes the string pointed by string to the stream.
 	/// The function begins copying from the address specified (string)
 	/// until it reaches the terminating null character ('\0').
 	/// This final null character is not copied to the stream.
@@ -48,7 +47,7 @@ public:
 
 private:
 
-	Stream*				m_stream;
+	Stream&				m_stream;
 };
 
 } // namespace crown