1130 lines
29 KiB
Text
1130 lines
29 KiB
Text
/**
|
|
* 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."
|
|
*
|
|
* @file dcPacker.I
|
|
* @author drose
|
|
* @date 2004-06-15
|
|
*/
|
|
|
|
/**
|
|
* Empties the data in the pack buffer and unpack buffer. This should be
|
|
* called between calls to begin_pack(), unless you want to concatenate all of
|
|
* the pack results together.
|
|
*/
|
|
INLINE void DCPacker::
|
|
clear_data() {
|
|
_pack_data.clear();
|
|
|
|
if (_owns_unpack_data) {
|
|
delete[] _unpack_data;
|
|
_owns_unpack_data = false;
|
|
}
|
|
_unpack_data = nullptr;
|
|
}
|
|
|
|
/**
|
|
* Returns true if the current field has any nested fields (and thus expects a
|
|
* push() .. pop() interface), or false otherwise. If this returns true,
|
|
* get_num_nested_fields() may be called to determine how many nested fields
|
|
* are expected.
|
|
*/
|
|
INLINE bool DCPacker::
|
|
has_nested_fields() const {
|
|
if (_current_field == nullptr) {
|
|
return false;
|
|
} else {
|
|
return _current_field->has_nested_fields();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the number of nested fields associated with the current field, if
|
|
* has_nested_fields() returned true.
|
|
*
|
|
* The return value may be -1 to indicate that a variable number of nested
|
|
* fields are accepted by this field type (e.g. a variable-length array).
|
|
*
|
|
* Note that this method is unreliable to determine how many fields you must
|
|
* traverse before you can call pop(), since particularly in the presence of a
|
|
* DCSwitch, it may change during traversal. Use more_nested_fields()
|
|
* instead.
|
|
*/
|
|
INLINE int DCPacker::
|
|
get_num_nested_fields() const {
|
|
return _num_nested_fields;
|
|
}
|
|
|
|
/**
|
|
* Returns true if there are more nested fields to pack or unpack in the
|
|
* current push sequence, false if it is time to call pop().
|
|
*/
|
|
INLINE bool DCPacker::
|
|
more_nested_fields() const {
|
|
return (_current_field != nullptr && !_pack_error);
|
|
}
|
|
|
|
/**
|
|
* Returns the field that we left in our last call to push(): the owner of the
|
|
* current level of fields. This may be NULL at the beginning of the pack
|
|
* operation.
|
|
*/
|
|
INLINE const DCPackerInterface *DCPacker::
|
|
get_current_parent() const {
|
|
return _current_parent;
|
|
}
|
|
|
|
/**
|
|
* Returns the field that will be referenced by the next call to pack_*() or
|
|
* unpack_*(). This will be NULL if we have unpacked (or packed) all fields,
|
|
* or if it is time to call pop().
|
|
*/
|
|
INLINE const DCPackerInterface *DCPacker::
|
|
get_current_field() const {
|
|
return _current_field;
|
|
}
|
|
|
|
/**
|
|
* Returns a pointer to the last DCSwitch instance that we have passed by and
|
|
* selected one case of during the pack/unpack process. Each time we
|
|
* encounter a new DCSwitch and select a case, this will change state.
|
|
*
|
|
* This may be used to detect when a DCSwitch has been selected. At the
|
|
* moment this changes state, get_current_parent() will contain the particular
|
|
* SwitchCase that was selected by the switch.
|
|
*/
|
|
INLINE const DCSwitchParameter *DCPacker::
|
|
get_last_switch() const {
|
|
return _last_switch;
|
|
}
|
|
|
|
/**
|
|
* Returns the type of value expected by the current field. See the
|
|
* enumerated type definition at the top of DCPackerInterface.h. If this
|
|
* returns one of PT_double, PT_int, PT_int64, or PT_string, then you should
|
|
* call the corresponding pack_double(), pack_int() function (or
|
|
* unpack_double(), unpack_int(), etc.) to transfer data. Otherwise, you
|
|
* should call push() and begin packing or unpacking the nested fields.
|
|
*/
|
|
INLINE DCPackType DCPacker::
|
|
get_pack_type() const {
|
|
if (_current_field == nullptr) {
|
|
return PT_invalid;
|
|
} else {
|
|
return _current_field->get_pack_type();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the name of the current field, if it has a name, or the empty
|
|
* string if the field does not have a name or there is no current field.
|
|
*/
|
|
INLINE std::string DCPacker::
|
|
get_current_field_name() const {
|
|
if (_current_field == nullptr) {
|
|
return std::string();
|
|
} else {
|
|
return _current_field->get_name();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Packs the indicated numeric or string value into the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_double(double value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_current_field->pack_double(_pack_data, value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Packs the indicated numeric or string value into the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_int(int value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_current_field->pack_int(_pack_data, value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Packs the indicated numeric or string value into the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_uint(unsigned int value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_current_field->pack_uint(_pack_data, value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Packs the indicated numeric or string value into the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_int64(int64_t value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_current_field->pack_int64(_pack_data, value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Packs the indicated numeric or string value into the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_uint64(uint64_t value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_current_field->pack_uint64(_pack_data, value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Packs the indicated numeric or string value into the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_string(const std::string &value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_current_field->pack_string(_pack_data, value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Packs the indicated numeric or string value into the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_blob(const vector_uchar &value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_current_field->pack_blob(_pack_data, value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Adds the indicated string value into the stream, representing a single pre-
|
|
* packed field element, or a whole group of field elements at once.
|
|
*/
|
|
INLINE void DCPacker::
|
|
pack_literal_value(const vector_uchar &value) {
|
|
nassertv(_mode == M_pack || _mode == M_repack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
} else {
|
|
_pack_data.append_data((const char *)value.data(), value.size());
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE double DCPacker::
|
|
unpack_double() {
|
|
double value = 0.0;
|
|
nassertr(_mode == M_unpack, value);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_double(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE int DCPacker::
|
|
unpack_int() {
|
|
int value = 0;
|
|
nassertr(_mode == M_unpack, value);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_int(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE unsigned int DCPacker::
|
|
unpack_uint() {
|
|
unsigned int value = 0;
|
|
nassertr(_mode == M_unpack, value);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_uint(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE int64_t DCPacker::
|
|
unpack_int64() {
|
|
int64_t value = 0;
|
|
nassertr(_mode == M_unpack, value);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_int64(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE uint64_t DCPacker::
|
|
unpack_uint64() {
|
|
uint64_t value = 0;
|
|
nassertr(_mode == M_unpack, value);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_uint64(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE std::string DCPacker::
|
|
unpack_string() {
|
|
std::string value;
|
|
nassertr(_mode == M_unpack, value);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_string(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current binary data value from the stream.
|
|
*/
|
|
INLINE vector_uchar DCPacker::
|
|
unpack_blob() {
|
|
vector_uchar value;
|
|
nassertr(_mode == M_unpack, value);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_blob(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Returns the literal string that represents the packed value of the current
|
|
* field, and advances the field pointer.
|
|
*/
|
|
INLINE vector_uchar DCPacker::
|
|
unpack_literal_value() {
|
|
size_t start = _unpack_p;
|
|
unpack_skip();
|
|
nassertr(_unpack_p >= start, vector_uchar());
|
|
return vector_uchar((const unsigned char *)_unpack_data + start,
|
|
(const unsigned char *)_unpack_data + _unpack_p);
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_double(double &value) {
|
|
nassertv(_mode == M_unpack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_double(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_int(int &value) {
|
|
nassertv(_mode == M_unpack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_int(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_uint(unsigned int &value) {
|
|
nassertv(_mode == M_unpack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_uint(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_int64(int64_t &value) {
|
|
nassertv(_mode == M_unpack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_int64(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_uint64(uint64_t &value) {
|
|
nassertv(_mode == M_unpack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_uint64(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_string(std::string &value) {
|
|
nassertv(_mode == M_unpack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_string(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Unpacks the current numeric or string value from the stream.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_blob(vector_uchar &value) {
|
|
nassertv(_mode == M_unpack);
|
|
if (_current_field == nullptr) {
|
|
_pack_error = true;
|
|
|
|
} else {
|
|
_current_field->unpack_blob(_unpack_data, _unpack_length, _unpack_p,
|
|
value, _pack_error, _range_error);
|
|
advance();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the literal string that represents the packed value of the current
|
|
* field, and advances the field pointer.
|
|
*/
|
|
INLINE void DCPacker::
|
|
unpack_literal_value(vector_uchar &value) {
|
|
size_t start = _unpack_p;
|
|
unpack_skip();
|
|
nassertv(_unpack_p >= start);
|
|
value = vector_uchar((const unsigned char *)_unpack_data + start,
|
|
(const unsigned char *)_unpack_data + _unpack_p);
|
|
}
|
|
|
|
/**
|
|
* Returns true if there has been an parse error since the most recent call to
|
|
* begin(); this can only happen if you call parse_and_pack().
|
|
*/
|
|
INLINE bool DCPacker::
|
|
had_parse_error() const {
|
|
return _parse_error;
|
|
}
|
|
|
|
/**
|
|
* Returns true if there has been an packing error since the most recent call
|
|
* to begin(); in particular, this may be called after end() has returned
|
|
* false to determine the nature of the failure.
|
|
*
|
|
* A return value of true indicates there was a push/pop mismatch, or the
|
|
* push/pop structure did not match the data structure, or there were the
|
|
* wrong number of elements in a nested push/pop structure, or on unpack that
|
|
* the data stream was truncated.
|
|
*/
|
|
INLINE bool DCPacker::
|
|
had_pack_error() const {
|
|
return _pack_error;
|
|
}
|
|
|
|
/**
|
|
* Returns true if there has been an range validation error since the most
|
|
* recent call to begin(); in particular, this may be called after end() has
|
|
* returned false to determine the nature of the failure.
|
|
*
|
|
* A return value of true indicates a value that was packed or unpacked did
|
|
* not fit within the specified legal range for a parameter, or within the
|
|
* limits of the field size.
|
|
*/
|
|
INLINE bool DCPacker::
|
|
had_range_error() const {
|
|
return _range_error;
|
|
}
|
|
|
|
/**
|
|
* Returns true if there has been any error (either a pack error or a range
|
|
* error) since the most recent call to begin(). If this returns true, then
|
|
* the matching call to end() will indicate an error (false).
|
|
*/
|
|
INLINE bool DCPacker::
|
|
had_error() const {
|
|
return _range_error || _pack_error || _parse_error;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of bytes that have been unpacked so far, or after
|
|
* unpack_end(), the total number of bytes that were unpacked at all. This
|
|
* can be used to validate that all of the bytes in the buffer were actually
|
|
* unpacked (which is not otherwise considered an error).
|
|
*/
|
|
INLINE size_t DCPacker::
|
|
get_num_unpacked_bytes() const {
|
|
return _unpack_p;
|
|
}
|
|
|
|
/**
|
|
* Returns the current length of the buffer. This is the number of useful
|
|
* bytes stored in the buffer, not the amount of memory it takes up.
|
|
*/
|
|
INLINE size_t DCPacker::
|
|
get_length() const {
|
|
return _pack_data.get_length();
|
|
}
|
|
|
|
/**
|
|
* Returns the packed data buffer as a string. Also see get_data().
|
|
*/
|
|
INLINE std::string DCPacker::
|
|
get_string() const {
|
|
return _pack_data.get_string();
|
|
}
|
|
|
|
/**
|
|
* Returns the packed data buffer as a bytes object. Also see get_data().
|
|
*/
|
|
INLINE vector_uchar DCPacker::
|
|
get_bytes() const {
|
|
const unsigned char *p = (const unsigned char *)_pack_data.get_data();
|
|
return vector_uchar(p, p + _pack_data.get_length());
|
|
}
|
|
|
|
/**
|
|
* Returns the total number of bytes in the unpack data buffer. This is the
|
|
* buffer used when unpacking; it is separate from the pack data returned by
|
|
* get_length(), which is filled during packing.
|
|
*/
|
|
INLINE size_t DCPacker::
|
|
get_unpack_length() const {
|
|
return _unpack_length;
|
|
}
|
|
|
|
/**
|
|
* Returns the unpack data buffer, as a string. This is the buffer used when
|
|
* unpacking; it is separate from the pack data returned by get_string(),
|
|
* which is filled during packing. Also see get_unpack_data().
|
|
*/
|
|
INLINE std::string DCPacker::
|
|
get_unpack_string() const {
|
|
return std::string(_unpack_data, _unpack_length);
|
|
}
|
|
|
|
/**
|
|
* Copies the packed data into the indicated string. Also see get_data().
|
|
*/
|
|
INLINE void DCPacker::
|
|
get_string(std::string &data) const {
|
|
data.assign(_pack_data.get_data(), _pack_data.get_length());
|
|
}
|
|
|
|
/**
|
|
* Returns the beginning of the data buffer. The buffer is not null-
|
|
* terminated, but see also get_string().
|
|
*
|
|
* This may be used in conjunction with get_length() to copy all of the bytes
|
|
* out of the buffer. Also see take_data() to get the packed data without a
|
|
* copy operation.
|
|
*/
|
|
INLINE const char *DCPacker::
|
|
get_data() const {
|
|
return _pack_data.get_data();
|
|
}
|
|
|
|
/**
|
|
* Returns the pointer to the beginning of the data buffer, and transfers
|
|
* ownership of the buffer to the caller. The caller is now responsible for
|
|
* ultimately freeing the returned pointer with delete[], if it is non-NULL.
|
|
* This may (or may not) return NULL if the buffer is empty.
|
|
*
|
|
* This also empties the DCPackData structure, and sets its length to zero (so
|
|
* you should call get_length() before calling this method).
|
|
*/
|
|
INLINE char *DCPacker::
|
|
take_data() {
|
|
return _pack_data.take_data();
|
|
}
|
|
|
|
/**
|
|
* Adds the indicated bytes to the end of the data. This may only be called
|
|
* between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
append_data(const unsigned char *buffer, size_t size) {
|
|
nassertv(_mode == M_idle);
|
|
_pack_data.append_data((const char *)buffer, size);
|
|
}
|
|
|
|
/**
|
|
* Adds the indicated number of bytes to the end of the data without
|
|
* initializing them, and returns a pointer to the beginning of the new data.
|
|
* This may only be called between packing sessions.
|
|
*/
|
|
INLINE char *DCPacker::
|
|
get_write_pointer(size_t size) {
|
|
nassertr(_mode == M_idle, nullptr);
|
|
return _pack_data.get_write_pointer(size);
|
|
}
|
|
|
|
/**
|
|
* Returns a read pointer to the unpack data buffer. This is the buffer used
|
|
* when unpacking; it is separate from the pack data returned by get_data(),
|
|
* which is filled during packing.
|
|
*/
|
|
INLINE const char *DCPacker::
|
|
get_unpack_data() const {
|
|
return _unpack_data;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of DCPacker::StackElement pointers ever simultaneously
|
|
* allocated; these are now either in active use or have been recycled into
|
|
* the deleted DCPacker::StackElement pool to be used again.
|
|
*/
|
|
INLINE int DCPacker::
|
|
get_num_stack_elements_ever_allocated() {
|
|
return StackElement::_num_ever_allocated;
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_int8(int value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_int8(_pack_data.get_write_pointer(1), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_int16(int value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_int16(_pack_data.get_write_pointer(2), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_int32(int value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_int32(_pack_data.get_write_pointer(4), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_int64(int64_t value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_int64(_pack_data.get_write_pointer(8), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_uint8(unsigned int value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_uint8(_pack_data.get_write_pointer(1), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_uint16(unsigned int value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_uint16(_pack_data.get_write_pointer(2), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_uint32(unsigned int value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_uint32(_pack_data.get_write_pointer(4), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_uint64(uint64_t value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_uint64(_pack_data.get_write_pointer(8), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_float64(double value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_float64(_pack_data.get_write_pointer(8), value);
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_string(const std::string &value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_uint16(_pack_data.get_write_pointer(2), value.length());
|
|
_pack_data.append_data(value.data(), value.length());
|
|
}
|
|
|
|
/**
|
|
* Packs the data into the buffer between packing sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_pack_blob(const vector_uchar &value) {
|
|
nassertv(_mode == M_idle);
|
|
DCPackerInterface::do_pack_uint16(_pack_data.get_write_pointer(2), value.size());
|
|
_pack_data.append_data((const char *)value.data(), value.size());
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE int DCPacker::
|
|
raw_unpack_int8() {
|
|
int value = 0;
|
|
raw_unpack_int8(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE int DCPacker::
|
|
raw_unpack_int16() {
|
|
int value = 0;
|
|
raw_unpack_int16(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE int DCPacker::
|
|
raw_unpack_int32() {
|
|
int value = 0;
|
|
raw_unpack_int32(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE int64_t DCPacker::
|
|
raw_unpack_int64() {
|
|
int64_t value = 0;
|
|
raw_unpack_int64(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_int8(int &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 1 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_int8(_unpack_data + _unpack_p);
|
|
_unpack_p++;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_int16(int &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 2 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_int16(_unpack_data + _unpack_p);
|
|
_unpack_p += 2;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_int32(int &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 4 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_int32(_unpack_data + _unpack_p);
|
|
_unpack_p += 4;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE unsigned int DCPacker::
|
|
raw_unpack_uint8() {
|
|
unsigned int value = 0;
|
|
raw_unpack_uint8(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE unsigned int DCPacker::
|
|
raw_unpack_uint16() {
|
|
unsigned int value = 0;
|
|
raw_unpack_uint16(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE unsigned int DCPacker::
|
|
raw_unpack_uint32() {
|
|
unsigned int value = 0;
|
|
raw_unpack_uint32(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE uint64_t DCPacker::
|
|
raw_unpack_uint64() {
|
|
uint64_t value = 0;
|
|
raw_unpack_uint64(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE double DCPacker::
|
|
raw_unpack_float64() {
|
|
double value = 0;
|
|
raw_unpack_float64(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE std::string DCPacker::
|
|
raw_unpack_string() {
|
|
std::string value;
|
|
raw_unpack_string(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE vector_uchar DCPacker::
|
|
raw_unpack_blob() {
|
|
vector_uchar value;
|
|
raw_unpack_blob(value);
|
|
return value;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_int64(int64_t &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 8 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_int64(_unpack_data + _unpack_p);
|
|
_unpack_p += 8;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_uint8(unsigned int &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 1 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_uint8(_unpack_data + _unpack_p);
|
|
_unpack_p++;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_uint16(unsigned int &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 2 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_uint16(_unpack_data + _unpack_p);
|
|
_unpack_p += 2;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_uint32(unsigned int &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 4 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_uint32(_unpack_data + _unpack_p);
|
|
_unpack_p += 4;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_uint64(uint64_t &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 8 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_uint64(_unpack_data + _unpack_p);
|
|
_unpack_p += 8;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_float64(double &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
if (_unpack_p + 8 > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
value = DCPackerInterface::do_unpack_float64(_unpack_data + _unpack_p);
|
|
_unpack_p += 8;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_string(std::string &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
unsigned int string_length = raw_unpack_uint16();
|
|
|
|
if (_unpack_p + string_length > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
|
|
value.assign(_unpack_data + _unpack_p, string_length);
|
|
_unpack_p += string_length;
|
|
}
|
|
|
|
/**
|
|
* Unpacks the data from the buffer between unpacking sessions.
|
|
*/
|
|
INLINE void DCPacker::
|
|
raw_unpack_blob(vector_uchar &value) {
|
|
nassertv(_mode == M_idle && _unpack_data != nullptr);
|
|
unsigned int blob_size = raw_unpack_uint16();
|
|
|
|
if (_unpack_p + blob_size > _unpack_length) {
|
|
_pack_error = true;
|
|
return;
|
|
}
|
|
|
|
const unsigned char *p = (const unsigned char *)_unpack_data + _unpack_p;
|
|
value = vector_uchar(p, p + blob_size);
|
|
_unpack_p += blob_size;
|
|
}
|
|
|
|
/**
|
|
* Advances to the next field after a call to pack_value() or pop().
|
|
*/
|
|
INLINE void DCPacker::
|
|
advance() {
|
|
_current_field_index++;
|
|
if (_num_nested_fields >= 0 &&
|
|
_current_field_index >= _num_nested_fields) {
|
|
// Done with all the fields on this parent. The caller must now call
|
|
// pop().
|
|
_current_field = nullptr;
|
|
|
|
// But if the parent is a switch record, we make a special case so we can
|
|
// get the alternate fields.
|
|
if (_current_parent != nullptr) {
|
|
const DCSwitchParameter *switch_parameter = ((DCPackerInterface *)_current_parent)->as_switch_parameter();
|
|
if (switch_parameter != nullptr) {
|
|
handle_switch(switch_parameter);
|
|
}
|
|
}
|
|
|
|
} else if (_pop_marker != 0 && _unpack_p >= _pop_marker) {
|
|
// Done with all the fields on this parent. The caller must now call
|
|
// pop().
|
|
_current_field = nullptr;
|
|
|
|
} else {
|
|
// We have another field to advance to.
|
|
_current_field = _current_parent->get_nested_field(_current_field_index);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Allocates the memory for a new DCPacker::StackElement. This is specialized
|
|
* here to provide for fast allocation of these things.
|
|
*/
|
|
INLINE void *DCPacker::StackElement::
|
|
operator new(size_t size) {
|
|
if (_deleted_chain != nullptr) {
|
|
StackElement *obj = _deleted_chain;
|
|
_deleted_chain = _deleted_chain->_next;
|
|
return obj;
|
|
}
|
|
#ifndef NDEBUG
|
|
_num_ever_allocated++;
|
|
#endif // NDEBUG
|
|
return ::operator new(size);
|
|
}
|
|
|
|
/**
|
|
* Frees the memory for a deleted DCPacker::StackElement. This is specialized
|
|
* here to provide for fast allocation of these things.
|
|
*/
|
|
INLINE void DCPacker::StackElement::
|
|
operator delete(void *ptr) {
|
|
StackElement *obj = (StackElement *)ptr;
|
|
obj->_next = _deleted_chain;
|
|
_deleted_chain = obj;
|
|
}
|