RomanNum3ral
/
open_toontown_panda3d
mirror of https://github.com/open-toontown/panda3d.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
open_toontown_panda3d/dtool/src/prc/streamWriter.I

430 lines
15 KiB
Plaintext
Raw Blame History

// Filename: streamWriter.I
// Created by: drose (04Aug02)
//
////////////////////////////////////////////////////////////////////
//
// PANDA 3D SOFTWARE
// Copyright (c) Carnegie Mellon University. All rights reserved.
//
// All use of this software is subject to the terms of the revised BSD
// license. You should have received a copy of this license along
// with this source code in a file named "LICENSE."
//
////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::Constructor
// Access: Public
// Description:
////////////////////////////////////////////////////////////////////
INLINE StreamWriter::
StreamWriter(ostream &out) :
_out(&out),
_owns_stream(false)
{
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::Constructor
// Access: Published
// Description:
////////////////////////////////////////////////////////////////////
INLINE StreamWriter::
StreamWriter(ostream *out, bool owns_stream) :
_out(out),
_owns_stream(owns_stream)
{
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::Copy Constructor
// Access: Published
// Description: The copy constructor does not copy ownership of the
// stream.
////////////////////////////////////////////////////////////////////
INLINE StreamWriter::
StreamWriter(const StreamWriter &copy) :
_out(copy._out),
_owns_stream(false)
{
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::Copy Assignment Operator
// Access: Published
// Description: The copy constructor does not copy ownership of the
// stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
operator = (const StreamWriter &copy) {
if (_owns_stream) {
delete _out;
}
_out = copy._out;
_owns_stream = false;
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::Destructor
// Access: Published
// Description:
////////////////////////////////////////////////////////////////////
INLINE StreamWriter::
~StreamWriter() {
if (_owns_stream) {
delete _out;
}
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::get_ostream
// Access: Published
// Description: Returns the stream in use.
////////////////////////////////////////////////////////////////////
INLINE ostream *StreamWriter::
get_ostream() const {
return _out;
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_bool
// Access: Published
// Description: Adds a boolean value to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_bool(bool b) {
add_uint8(b);
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_int8
// Access: Published
// Description: Adds a signed 8-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_int8(PN_int8 value) {
append_data(&value, 1);
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_uint8
// Access: Published
// Description: Adds an unsigned 8-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_uint8(PN_uint8 value) {
append_data(&value, 1);
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_int16
// Access: Published
// Description: Adds a signed 16-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_int16(PN_int16 value) {
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_int32
// Access: Published
// Description: Adds a signed 32-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_int32(PN_int32 value) {
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_int64
// Access: Published
// Description: Adds a signed 64-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_int64(PN_int64 value) {
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_uint16
// Access: Published
// Description: Adds an unsigned 16-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_uint16(PN_uint16 value) {
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_uint32
// Access: Published
// Description: Adds an unsigned 32-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_uint32(PN_uint32 value) {
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_uint64
// Access: Published
// Description: Adds an unsigned 64-bit integer to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_uint64(PN_uint64 value) {
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_float32
// Access: Published
// Description: Adds a 32-bit single-precision floating-point number
// to the stream. Since this kind of float is not
// necessarily portable across different architectures,
// special care is required.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_float32(float value) {
// For now, we assume the float format is portable across all
// architectures we are concerned with. If we come across one that
// is different, we will have to convert.
nassertv(sizeof(value) == 4);
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_float64
// Access: Published
// Description: Adds a 64-bit floating-point number to the stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_float64(PN_float64 value) {
LittleEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_int16
// Access: Published
// Description: Adds a signed 16-bit big-endian integer to the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_int16(PN_int16 value) {
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_int32
// Access: Published
// Description: Adds a signed 32-bit big-endian integer to the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_int32(PN_int32 value) {
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_int64
// Access: Published
// Description: Adds a signed 64-bit big-endian integer to the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_int64(PN_int64 value) {
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_uint16
// Access: Published
// Description: Adds an unsigned 16-bit big-endian integer to the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_uint16(PN_uint16 value) {
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_uint32
// Access: Published
// Description: Adds an unsigned 32-bit big-endian integer to the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_uint32(PN_uint32 value) {
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_uint64
// Access: Published
// Description: Adds an unsigned 64-bit big-endian integer to the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_uint64(PN_uint64 value) {
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_float32
// Access: Published
// Description: Adds a 32-bit single-precision big-endian
// floating-point number to the stream. Since this
// kind of float is not necessarily portable across
// different architectures, special care is required.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_float32(float value) {
// For now, we assume the float format is portable across all
// architectures we are concerned with. If we come across one that
// is different, we will have to convert.
nassertv(sizeof(value) == 4);
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_be_float64
// Access: Published
// Description: Adds a 64-bit big-endian floating-point number to the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_be_float64(PN_float64 value) {
BigEndian s(&value, sizeof(value));
append_data(s.get_data(), sizeof(value));
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_string
// Access: Published
// Description: Adds a variable-length string to the stream. This
// actually adds a count followed by n bytes.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_string(const string &str) {
// The max sendable length for a string is 2^16.
nassertv(str.length() <= (PN_uint16)0xffff);
// Strings always are preceded by their length
add_uint16(str.length());
// Add the string
append_data(str);
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_string32
// Access: Published
// Description: Adds a variable-length string to the stream, using a
// 32-bit length field.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_string32(const string &str) {
// Strings always are preceded by their length
add_uint32(str.length());
// Add the string
append_data(str);
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_z_string
// Access: Published
// Description: Adds a variable-length string to the stream, as a
// NULL-terminated string.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_z_string(string str) {
// We must not have any nested null characters in the string.
size_t null_pos = str.find('\0');
// Add the string (sans the null character).
append_data(str.substr(0, null_pos));
// And the null character.
add_uint8('\0');
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::add_fixed_string
// Access: Published
// Description: Adds a fixed-length string to the stream. If the
// string given is less than the requested size, this
// will pad the string out with zeroes; if it is greater
// than the requested size, this will silently truncate
// the string.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
add_fixed_string(const string &str, size_t size) {
if (str.length() < size) {
append_data(str);
pad_bytes(size - str.length());
} else { // str.length() >= size
append_data(str.substr(0, size));
}
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::append_data
// Access: Published
// Description: Appends some more raw data to the end of the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
append_data(const void *data, size_t size) {
_out->write((const char *)data, size);
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::append_data
// Access: Published
// Description: Appends some more raw data to the end of the
// streamWriter.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
append_data(const string &data) {
append_data(data.data(), data.length());
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::flush
// Access: Published
// Description: Calls flush() on the underlying stream.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
flush() {
_out->flush();
}
////////////////////////////////////////////////////////////////////
// Function: StreamWriter::write
// Access: Published
// Description: A synonym of append_data(). This is useful when
// assigning the StreamWriter to sys.stderr and/or
// sys.stdout in Python.
////////////////////////////////////////////////////////////////////
INLINE void StreamWriter::
write(const string &data) {
append_data(data.data(), data.length());
}
Reference in New Issue View Git Blame Copy Permalink