15#ifndef _FASTCDR_FASTCDR_H_
16#define _FASTCDR_FASTCDR_H_
18#include "fastcdr_dll.h"
19#include "FastBuffer.h"
20#include "exceptions/NotEnoughMemoryException.h"
25#if !__APPLE__ && !__FreeBSD__ && !__VXWORKS__
68 const state&) =
delete;
107 return m_currentPosition - m_cdrBuffer.begin();
130 const uint8_t octet_t)
132 return serialize(octet_t);
144 return serialize(char_t);
156 return serialize(int8);
166 const uint16_t ushort_t)
168 return serialize(ushort_t);
178 const int16_t short_t)
180 return serialize(short_t);
190 const uint32_t ulong_t)
192 return serialize(ulong_t);
202 const int32_t long_t)
204 return serialize(long_t);
216 return serialize(wchar);
226 const uint64_t ulonglong_t)
228 return serialize(ulonglong_t);
238 const int64_t longlong_t)
240 return serialize(longlong_t);
252 return serialize(float_t);
262 const double double_t)
264 return serialize(double_t);
274 const long double ldouble_t)
276 return serialize(ldouble_t);
288 return serialize(bool_t);
298 const char* string_t)
300 return serialize(string_t);
310 const wchar_t* string_t)
312 return serialize(string_t);
322 const std::string& string_t)
324 return serialize(string_t);
334 const std::wstring& string_t)
336 return serialize(string_t);
345 template<
class _T,
size_t _Size>
347 const std::array<_T, _Size>& array_t)
349 return serialize<_T, _Size>(array_t);
360 const std::vector<_T>& vector_t)
362 return serialize<_T>(vector_t);
388 return deserialize(octet_t);
400 return deserialize(char_t);
412 return deserialize(int8);
424 return deserialize(ushort_t);
436 return deserialize(short_t);
448 return deserialize(ulong_t);
460 return deserialize(long_t);
472 return deserialize(wchar);
482 uint64_t& ulonglong_t)
484 return deserialize(ulonglong_t);
496 return deserialize(longlong_t);
508 return deserialize(float_t);
520 return deserialize(double_t);
530 long double& ldouble_t)
532 return deserialize(ldouble_t);
545 return deserialize(bool_t);
560 return deserialize(string_t);
570 std::string& string_t)
572 return deserialize(string_t);
582 std::wstring& string_t)
584 return deserialize(string_t);
593 template<
class _T,
size_t _Size>
595 std::array<_T, _Size>& array_t)
597 return deserialize<_T, _Size>(array_t);
608 std::vector<_T>& vector_t)
610 return deserialize<_T>(vector_t);
635 const uint8_t octet_t)
637 return serialize(
static_cast<char>(octet_t));
650 if (((m_lastPosition - m_currentPosition) >=
sizeof(char_t)) || resize(
sizeof(char_t)))
652 m_currentPosition++ << char_t;
669 return serialize(
static_cast<char>(int8));
680 const uint16_t ushort_t)
682 return serialize(
static_cast<int16_t
>(ushort_t));
693 const int16_t short_t)
695 if (((m_lastPosition - m_currentPosition) >=
sizeof(short_t)) || resize(
sizeof(short_t)))
697 m_currentPosition << short_t;
698 m_currentPosition +=
sizeof(short_t);
714 const uint32_t ulong_t)
716 return serialize(
static_cast<int32_t
>(ulong_t));
727 const int32_t long_t)
729 if (((m_lastPosition - m_currentPosition) >=
sizeof(long_t)) || resize(
sizeof(long_t)))
731 m_currentPosition << long_t;
732 m_currentPosition +=
sizeof(long_t);
750 return serialize(
static_cast<uint32_t
>(wchar));
761 const uint64_t ulonglong_t)
763 return serialize(
static_cast<int64_t
>(ulonglong_t));
774 const int64_t longlong_t)
776 if (((m_lastPosition - m_currentPosition) >=
sizeof(longlong_t)) || resize(
sizeof(longlong_t)))
778 m_currentPosition << longlong_t;
779 m_currentPosition +=
sizeof(longlong_t);
797 if (((m_lastPosition - m_currentPosition) >=
sizeof(float_t)) || resize(
sizeof(float_t)))
799 m_currentPosition << float_t;
800 m_currentPosition +=
sizeof(float_t);
816 const double double_t)
818 if (((m_lastPosition - m_currentPosition) >=
sizeof(double_t)) || resize(
sizeof(double_t)))
820 m_currentPosition << double_t;
821 m_currentPosition +=
sizeof(double_t);
837 const long double ldouble_t)
839 if (((m_lastPosition - m_currentPosition) >=
sizeof(ldouble_t)) || resize(
sizeof(ldouble_t)))
841 m_currentPosition << ldouble_t;
843 m_currentPosition +=
sizeof(ldouble_t);
844 m_currentPosition << static_cast<long double>(0);
846 m_currentPosition +=
sizeof(ldouble_t);
870 const char* string_t);
879 const wchar_t* string_t);
889 const std::string& string_t)
891 return serialize(string_t.c_str());
902 const std::wstring& string_t)
904 return serialize(string_t.c_str());
913 template<
class _T,
size_t _Size>
915 const std::array<_T, _Size>& array_t)
917 return serializeArray(array_t.data(), array_t.size());
926 template<
class _T =
bool>
928 const std::vector<bool>& vector_t)
930 return serializeBoolSequence(vector_t);
941 const std::vector<_T>& vector_t)
943 state state_before_error(*
this);
945 *this << static_cast<int32_t>(vector_t.size());
949 return serializeArray(vector_t.data(), vector_t.size());
953 setState(state_before_error);
969 const std::vector<bool>& vector_t)
971 return serializeBoolSequence(vector_t);
999 const uint8_t* octet_t,
1002 return serializeArray(
reinterpret_cast<const char*
>(octet_t), numElements);
1014 size_t numElements);
1028 return serializeArray(
reinterpret_cast<const char*
>(int8), numElements);
1040 const uint16_t* ushort_t,
1043 return serializeArray(
reinterpret_cast<const int16_t*
>(ushort_t), numElements);
1054 const int16_t* short_t,
1055 size_t numElements);
1066 const uint32_t* ulong_t,
1069 return serializeArray(
reinterpret_cast<const int32_t*
>(ulong_t), numElements);
1080 const int32_t* long_t,
1081 size_t numElements);
1091 const wchar_t* wchar,
1092 size_t numElements);
1103 const uint64_t* ulonglong_t,
1106 return serializeArray(
reinterpret_cast<const int64_t*
>(ulonglong_t), numElements);
1117 const int64_t* longlong_t,
1118 size_t numElements);
1128 const float* float_t,
1129 size_t numElements);
1139 const double* double_t,
1140 size_t numElements);
1150 const long double* ldouble_t,
1151 size_t numElements);
1162 size_t numElements);
1173 const std::string* string_t,
1176 for (
size_t count = 0; count < numElements; ++count)
1178 serialize(string_t[count].c_str());
1192 const std::wstring* string_t,
1195 for (
size_t count = 0; count < numElements; ++count)
1197 serialize(string_t[count].c_str());
1211 const std::vector<_T>* vector_t,
1214 for (
size_t count = 0; count < numElements; ++count)
1216 serialize(vector_t[count]);
1233 for (
size_t count = 0; count < numElements; ++count)
1249 const _T* sequence_t,
1252 state state_before_error(*
this);
1254 serialize(
static_cast<int32_t
>(numElements));
1258 return serializeArray(sequence_t, numElements);
1262 setState(state_before_error);
1279 return deserialize(
reinterpret_cast<char&
>(octet_t));
1292 if ((m_lastPosition - m_currentPosition) >=
sizeof(char_t))
1294 m_currentPosition++ >> char_t;
1311 return deserialize(
reinterpret_cast<char&
>(int8));
1324 return deserialize(
reinterpret_cast<int16_t&
>(ushort_t));
1337 if ((m_lastPosition - m_currentPosition) >=
sizeof(short_t))
1339 m_currentPosition >> short_t;
1340 m_currentPosition +=
sizeof(short_t);
1358 return deserialize(
reinterpret_cast<int32_t&
>(ulong_t));
1371 if ((m_lastPosition - m_currentPosition) >=
sizeof(long_t))
1373 m_currentPosition >> long_t;
1374 m_currentPosition +=
sizeof(long_t);
1394 wchar =
static_cast<wchar_t>(ret);
1406 uint64_t& ulonglong_t)
1408 return deserialize(
reinterpret_cast<int64_t&
>(ulonglong_t));
1419 int64_t& longlong_t)
1421 if ((m_lastPosition - m_currentPosition) >=
sizeof(longlong_t))
1423 m_currentPosition >> longlong_t;
1424 m_currentPosition +=
sizeof(longlong_t);
1442 if ((m_lastPosition - m_currentPosition) >=
sizeof(float_t))
1444 m_currentPosition >> float_t;
1445 m_currentPosition +=
sizeof(float_t);
1463 if ((m_lastPosition - m_currentPosition) >=
sizeof(double_t))
1465 m_currentPosition >> double_t;
1466 m_currentPosition +=
sizeof(double_t);
1482 long double& ldouble_t)
1484 if ((m_lastPosition - m_currentPosition) >=
sizeof(ldouble_t))
1486 m_currentPosition >> ldouble_t;
1487 m_currentPosition +=
sizeof(ldouble_t);
1489 m_currentPosition +=
sizeof(ldouble_t);
1530 wchar_t*& string_t);
1540 std::string& string_t)
1542 uint32_t length = 0;
1543 const char* str = readString(length);
1544 string_t = std::string(str, length);
1556 std::wstring& string_t)
1558 uint32_t length = 0;
1559 string_t = readWString(length);
1569 template<
class _T,
size_t _Size>
1571 std::array<_T, _Size>& array_t)
1573 return deserializeArray(array_t.data(), array_t.size());
1582 template<
class _T =
bool>
1584 std::vector<bool>& vector_t)
1586 return deserializeBoolSequence(vector_t);
1597 std::vector<_T>& vector_t)
1599 uint32_t seqLength = 0;
1600 state state_before_error(*
this);
1606 vector_t.resize(seqLength);
1607 return deserializeArray(vector_t.data(), vector_t.size());
1611 setState(state_before_error);
1627 std::vector<bool>& vector_t)
1629 return deserializeBoolSequence(vector_t);
1660 return deserializeArray(
reinterpret_cast<char*
>(octet_t), numElements);
1672 size_t numElements);
1686 return deserializeArray(
reinterpret_cast<char*
>(int8), numElements);
1701 return deserializeArray(
reinterpret_cast<int16_t*
>(ushort_t), numElements);
1713 size_t numElements);
1727 return deserializeArray(
reinterpret_cast<int32_t*
>(ulong_t), numElements);
1739 size_t numElements);
1750 size_t numElements);
1761 uint64_t* ulonglong_t,
1764 return deserializeArray(
reinterpret_cast<int64_t*
>(ulonglong_t), numElements);
1775 int64_t* longlong_t,
1776 size_t numElements);
1787 size_t numElements);
1798 size_t numElements);
1808 long double* ldouble_t,
1809 size_t numElements);
1820 size_t numElements);
1831 std::string* string_t,
1834 for (
size_t count = 0; count < numElements; ++count)
1836 deserialize(string_t[count]);
1850 std::wstring* string_t,
1853 for (
size_t count = 0; count < numElements; ++count)
1855 deserialize(string_t[count]);
1869 std::vector<_T>* vector_t,
1872 for (
size_t count = 0; count < numElements; ++count)
1874 deserialize(vector_t[count]);
1891 for (
size_t count = 0; count < numElements; ++count)
1907 template<
class _T = std::
string>
1909 std::string*& sequence_t,
1910 size_t& numElements)
1912 return deserializeStringSequence(sequence_t, numElements);
1924 template<
class _T = std::w
string>
1926 std::wstring*& sequence_t,
1927 size_t& numElements)
1929 return deserializeWStringSequence(sequence_t, numElements);
1944 size_t& numElements)
1946 uint32_t seqLength = 0;
1947 state state_before_error(*
this);
1949 deserialize(seqLength);
1953 sequence_t =
reinterpret_cast<_T*
>(calloc(seqLength,
sizeof(_T)));
1954 deserializeArray(sequence_t, seqLength);
1960 setState(state_before_error);
1964 numElements = seqLength;
1979 FastCdr& deserializeSequence<std::string>(
1980 std::string*& sequence_t,
1981 size_t& numElements)
1983 return deserializeStringSequence(sequence_t, numElements);
1996 FastCdr& deserializeSequence<std::wstring>(
1997 std::wstring*& sequence_t,
1998 size_t& numElements)
2000 return deserializeWStringSequence(sequence_t, numElements);
2008 const FastCdr&) =
delete;
2010 FastCdr& operator =(
2011 const FastCdr&) =
delete;
2013 FastCdr& serializeBoolSequence(
2014 const std::vector<bool>& vector_t);
2016 FastCdr& deserializeBoolSequence(
2017 std::vector<bool>& vector_t);
2019 FastCdr& deserializeStringSequence(
2020 std::string*& sequence_t,
2021 size_t& numElements);
2023 FastCdr& deserializeWStringSequence(
2024 std::wstring*& sequence_t,
2025 size_t& numElements);
2034 template<
class _T,
size_t _Size>
2035 FastCdr& serializeArray(
2036 const std::array<_T, _Size>* array_t,
2039 return serializeArray(array_t->data(), numElements * array_t->size());
2049 template<
class _T,
size_t _Size>
2050 FastCdr& deserializeArray(
2051 std::array<_T, _Size>* array_t,
2054 return deserializeArray(array_t->data(), numElements * array_t->size());
2060 const char* readString(
2063 std::wstring readWString(
2067 FastBuffer& m_cdrBuffer;
This class implements the iterator used to go through a FastBuffer.
Definition: FastBuffer.h:43
This class represents a stream of bytes that contains (or will contain) serialized data.
Definition: FastBuffer.h:229
_FastBuffer_iterator iterator
Definition: FastBuffer.h:232
This class stores the current state of a CDR serialization.
Definition: FastCdr.h:48
state(const FastCdr &fastcdr)
Default constructor.
state(const state &)
Copy constructor.
This class offers an interface to serialize/deserialize some basic types using a modified CDR protoco...
Definition: FastCdr.h:41
FastCdr::state getState()
This function returns the current state of the CDR stream.
FastCdr & deserializeArray(std::vector< _T > *vector_t, size_t numElements)
This function template deserializes an array of sequences.
Definition: FastCdr.h:1868
FastCdr & deserializeArray(int8_t *int8, size_t numElements)
This function deserializes an array of int8_t.
Definition: FastCdr.h:1682
FastCdr & serialize(const wchar_t *string_t)
This function serializes a wstring.
FastCdr & serializeArray(const int32_t *long_t, size_t numElements)
This function serializes an array of longs.
FastCdr & deserialize(char *&string_t)
This function deserializes a string.
FastCdr & deserializeArray(uint16_t *ushort_t, size_t numElements)
This function deserializes an array of unsigned shorts.
Definition: FastCdr.h:1697
FastCdr & deserialize(int8_t &int8)
This function deserializes an int8_t.
Definition: FastCdr.h:1308
FastCdr & serialize(const wchar_t wchar)
This function serializes a wide-char.
Definition: FastCdr.h:747
FastCdr & serialize(const std::vector< _T > &vector_t)
This function template serializes a sequence.
Definition: FastCdr.h:940
FastCdr & deserialize(wchar_t &wchar)
This function deserializes a wide-char.
Definition: FastCdr.h:1389
FastCdr & deserializeArray(_T *type_t, size_t numElements)
This function template deserializes an array of non-basic type objects.
Definition: FastCdr.h:1887
FastCdr & serializeArray(const int64_t *longlong_t, size_t numElements)
This function serializes an array of long longs.
FastCdr & serializeArray(const std::wstring *string_t, size_t numElements)
This function serializes an array of wstrings.
Definition: FastCdr.h:1191
FastCdr & serializeArray(const uint32_t *ulong_t, size_t numElements)
This function serializes an array of unsigned longs.
Definition: FastCdr.h:1065
FastCdr & deserializeSequence(_T *&sequence_t, size_t &numElements)
This function template deserializes a raw sequence.
Definition: FastCdr.h:1942
FastCdr & deserializeArray(uint8_t *octet_t, size_t numElements)
This function deserializes an array of octets.
Definition: FastCdr.h:1656
FastCdr & serializeArray(const std::string *string_t, size_t numElements)
This function serializes an array of strings.
Definition: FastCdr.h:1172
FastCdr & deserializeArray(int64_t *longlong_t, size_t numElements)
This function deserializes an array of long longs.
FastCdr & serialize(const uint8_t octet_t)
This function serializes an octet.
Definition: FastCdr.h:634
FastCdr & deserializeArray(wchar_t *wchar, size_t numElements)
This function deserializes an array of wide-chars.
FastCdr & deserializeArray(uint32_t *ulong_t, size_t numElements)
This function deserializes an array of unsigned longs.
Definition: FastCdr.h:1723
FastCdr & deserialize(double &double_t)
This function deserializes a double.
Definition: FastCdr.h:1460
FastCdr & serializeArray(const std::vector< _T > *vector_t, size_t numElements)
This function template serializes an array of sequences.
Definition: FastCdr.h:1210
FastCdr & serialize(const int16_t short_t)
This function serializes a short.
Definition: FastCdr.h:692
FastCdr & deserialize(float &float_t)
This function deserializes a float.
Definition: FastCdr.h:1439
FastCdr & deserializeArray(int32_t *long_t, size_t numElements)
This function deserializes an array of longs.
FastCdr(FastBuffer &cdrBuffer)
This constructor creates a eprosima::fastcdr::FastCdr object that can serialize/deserialize the assig...
FastCdr & deserializeArray(std::string *string_t, size_t numElements)
This function deserializes an array of strings.
Definition: FastCdr.h:1830
size_t getSerializedDataLength() const
This function returns the length of the serialized data inside the stream.
Definition: FastCdr.h:105
FastCdr & deserialize(bool &bool_t)
This function deserializes a boolean.
FastCdr & deserializeSequence(std::string *&sequence_t, size_t &numElements)
This function template deserializes a string sequence.
Definition: FastCdr.h:1908
FastCdr & deserialize(uint64_t &ulonglong_t)
This function deserializes an unsigned long long.
Definition: FastCdr.h:1405
FastCdr & deserialize(std::array< _T, _Size > &array_t)
This function template deserializes an array.
Definition: FastCdr.h:1570
FastCdr & deserializeArray(char *char_t, size_t numElements)
This function deserializes an array of characters.
FastCdr & serializeArray(const float *float_t, size_t numElements)
This function serializes an array of floats.
FastCdr & serializeArray(const int8_t *int8, size_t numElements)
This function serializes an array of int8_t.
Definition: FastCdr.h:1024
FastCdr & deserializeArray(double *double_t, size_t numElements)
This function deserializes an array of doubles.
FastCdr & deserializeArray(uint64_t *ulonglong_t, size_t numElements)
This function deserializes an array of unsigned long longs.
Definition: FastCdr.h:1760
FastCdr & deserialize(int64_t &longlong_t)
This function deserializes a long long.
Definition: FastCdr.h:1418
FastCdr & deserialize(_T &type_t)
This function template deserializes a non-basic type object.
Definition: FastCdr.h:1641
FastCdr & deserialize(int16_t &short_t)
This function deserializes a short.
Definition: FastCdr.h:1334
FastCdr & serialize(const float float_t)
This function serializes a float.
Definition: FastCdr.h:794
FastCdr & serializeArray(const int16_t *short_t, size_t numElements)
This function serializes an array of shorts.
FastCdr & serialize(const int8_t int8)
This function serializes an int8_t.
Definition: FastCdr.h:666
FastCdr & deserialize(std::wstring &string_t)
This function deserializes a std::wstring.
Definition: FastCdr.h:1555
FastCdr & deserialize(char &char_t)
This function deserializes a character.
Definition: FastCdr.h:1289
FastCdr & serialize(const double double_t)
This function serializes a double.
Definition: FastCdr.h:815
FastCdr & deserializeArray(int16_t *short_t, size_t numElements)
This function deserializes an array of shorts.
FastCdr & serialize(const bool bool_t)
This function serializes a boolean.
FastCdr & deserialize(std::vector< _T > &vector_t)
This function template deserializes a sequence.
Definition: FastCdr.h:1596
FastCdr & deserialize(long double &ldouble_t)
This function deserializes a long double.
Definition: FastCdr.h:1481
FastCdr & deserialize(wchar_t *&string_t)
This function deserializes a wide string.
FastCdr & serializeArray(const uint16_t *ushort_t, size_t numElements)
This function serializes an array of unsigned shorts.
Definition: FastCdr.h:1039
FastCdr & serializeArray(const uint64_t *ulonglong_t, size_t numElements)
This function serializes an array of unsigned long longs.
Definition: FastCdr.h:1102
FastCdr & serializeArray(const double *double_t, size_t numElements)
This function serializes an array of doubles.
FastCdr & serializeArray(const bool *bool_t, size_t numElements)
This function serializes an array of booleans.
FastCdr & serialize(const uint32_t ulong_t)
This function serializes an unsigned long.
Definition: FastCdr.h:713
FastCdr & serialize(const std::wstring &string_t)
This function serializes a std::wstring.
Definition: FastCdr.h:901
FastCdr & serializeArray(const long double *ldouble_t, size_t numElements)
This function serializes an array of long doubles.
FastCdr & serialize(const uint16_t ushort_t)
This function serializes an unsigned short.
Definition: FastCdr.h:679
FastCdr & serializeArray(const _T *type_t, size_t numElements)
This function template serializes an array of non-basic type objects.
Definition: FastCdr.h:1229
FastCdr & serialize(const std::array< _T, _Size > &array_t)
This function template serializes an array.
Definition: FastCdr.h:914
FastCdr & serializeArray(const char *char_t, size_t numElements)
This function serializes an array of characters.
FastCdr & serialize(const uint64_t ulonglong_t)
This function serializes an unsigned long long.
Definition: FastCdr.h:760
FastCdr & deserializeArray(std::wstring *string_t, size_t numElements)
This function deserializes an array of wide-strings.
Definition: FastCdr.h:1849
FastCdr & deserialize(int32_t &long_t)
This function deserializes a long.
Definition: FastCdr.h:1368
void setState(FastCdr::state &state)
This function sets a previous state of the CDR stream;.
FastCdr & serialize(const char *string_t)
This function serializes a string.
FastCdr & deserialize(uint16_t &ushort_t)
This function deserializes an unsigned short.
Definition: FastCdr.h:1321
FastCdr & serializeArray(const uint8_t *octet_t, size_t numElements)
This function serializes an array of octets.
Definition: FastCdr.h:998
FastCdr & deserialize(uint32_t &ulong_t)
This function deserializes an unsigned long.
Definition: FastCdr.h:1355
FastCdr & serialize(const int32_t long_t)
This function serializes a long.
Definition: FastCdr.h:726
FastCdr & serialize(const std::vector< bool > &vector_t)
This function template serializes a sequence of booleans.
Definition: FastCdr.h:927
FastCdr & deserializeArray(bool *bool_t, size_t numElements)
This function deserializes an array of booleans.
FastCdr & deserialize(std::vector< bool > &vector_t)
This function template deserializes a sequence of booleans.
Definition: FastCdr.h:1583
void reset()
This function resets the current position in the buffer to the begining.
FastCdr & deserializeArray(float *float_t, size_t numElements)
This function deserializes an array of floats.
FastCdr & deserializeArray(long double *ldouble_t, size_t numElements)
This function deserializes an array of long doubles.
FastCdr & serialize(const char char_t)
This function serializes a character.
Definition: FastCdr.h:647
bool jump(size_t numBytes)
This function skips a number of bytes in the CDR stream buffer.
FastCdr & deserialize(uint8_t &octet_t)
This function deserializes an octet.
Definition: FastCdr.h:1276
FastCdr & serializeArray(const wchar_t *wchar, size_t numElements)
This function serializes an array of wide-chars.
FastCdr & serialize(const std::string &string_t)
This function serializes a std::string.
Definition: FastCdr.h:888
FastCdr & serialize(const long double ldouble_t)
This function serializes a long double.
Definition: FastCdr.h:836
FastCdr & serializeSequence(const _T *sequence_t, size_t numElements)
This function template serializes a raw sequence.
Definition: FastCdr.h:1248
FastCdr & serialize(const int64_t longlong_t)
This function serializes a long long.
Definition: FastCdr.h:773
char * getCurrentPosition()
This function returns the current position in the CDR stream.
FastCdr & deserializeSequence(std::wstring *&sequence_t, size_t &numElements)
This function template deserializes a wide-string sequence.
Definition: FastCdr.h:1925
FastCdr & serialize(const _T &type_t)
This function template serializes a non-basic type.
Definition: FastCdr.h:983
FastCdr & deserialize(std::string &string_t)
This function deserializes a std::string.
Definition: FastCdr.h:1539
This abstract class is used to create exceptions.
Definition: Exception.h:30
virtual void raise() const =0
This function throws the object as exception.
This class is thrown as an exception when the buffer's internal memory reachs its size limit.
Definition: NotEnoughMemoryException.h:28
static const char *const NOT_ENOUGH_MEMORY_MESSAGE_DEFAULT
Default message used in the library.
Definition: NotEnoughMemoryException.h:78