--- /dev/null
+
+/*] Copyright (c) 2009-2010, Charles McGarvey [**************************
+**] All rights reserved.
+*
+* vi:ts=4 sw=4 tw=75
+*
+* Distributable under the terms and conditions of the 2-clause BSD license;
+* see the file COPYING for a complete text of the license.
+*
+**************************************************************************/
+
+/**
+ * \file Packet.hh
+ * Classes for building and interpreting datagram packets.
+ */
+
+#ifndef _MOOF_PACKET_HH_
+#define _MOOF_PACKET_HH_
+
+#include <cstring>
+#include <string>
+#include <vector>
+
+
+#ifndef PAGE_SIZE
+#define PAGE_SIZE 4096
+#endif
+
+
+namespace Mf {
+
+
+/**
+ * Represents a packet of serialized variables ready for transfer over the
+ * network. This method is most suitable for representing datagram
+ * packets, but it may also be useful for seralizing data for persistent
+ * state storage. The semantics are similar to that of a FIFO queue or
+ * stream where packets are written and read by inserting and extracting
+ * variables to and from the packet, although the actual order of the
+ * variables in the buffer may be different. At any time, a pointer to a
+ * buffer and the size of the buffer can be retrieved. This class also
+ * handles endian differences by serializing variables in network byte
+ * order (big endian).
+ */
+class Packet
+{
+public:
+
+ /**
+ * Packet flags.
+ */
+ enum Flags
+ {
+ PEEK = 0x01 /// Do not actually remove anything.
+ };
+
+
+ /**
+ * Construct a packet with an initial capacity.
+ * \param capacity Initial capacity of the packet.
+ */
+ Packet(size_t capacity = PAGE_SIZE);
+
+ /**
+ * Construct a packet with some bytes from a buffer. The bytes will be
+ * copied into the packet, so you don't need to keep the original
+ * buffer.
+ * \param data The bytes.
+ * \param size The number of bytes.
+ */
+ Packet(const char* data, size_t size);
+
+
+ /**
+ * Insert a variable into the packet, serializing it. This usually
+ * increases the size of the packet by the size of the data type.
+ * \param value The value to insert.
+ * \return This.
+ */
+ bool put(bool value);
+ bool put(int8_t value);
+ bool put(int16_t value);
+ bool put(int32_t value);
+ bool put(int64_t value);
+ bool put(uint8_t value);
+ bool put(uint16_t value);
+ bool put(uint32_t value);
+ bool put(uint64_t value);
+ bool put(float value);
+ bool put(double value);
+
+ bool put(const char* value)
+ {
+ uint16_t length = strlen(value);
+ if (put(length))
+ {
+ size_t numBytes = write(value, length);
+ return numBytes == length;
+ }
+ return false;
+ }
+
+ template <class T>
+ bool put(const std::basic_string<T>& value)
+ {
+ if (put(uint16_t(value.length())))
+ {
+ size_t byteLength = value.length() * sizeof(T);
+ size_t numBytes = write(value.data(), byteLength);
+ return numBytes == byteLength;
+ }
+ return false;
+ }
+
+ template <class T>
+ bool put(const std::vector<T>& value)
+ {
+ if (put(uint16_t(value.size())))
+ {
+ typename std::vector<T>::const_iterator it;
+ for (it = value.begin(); it != value.end(); ++it)
+ {
+ if (!put(*it)) return false;
+ }
+ return true;
+ }
+ return false;
+ }
+
+
+ /**
+ * Write some bytes to the packet.
+ * \param bytes The bytes.
+ * \param size The number of bytes.
+ * return The number of bytes actually written.
+ */
+ size_t write(const void* bytes, size_t size);
+
+
+ /**
+ * Extract a variable from the packet. This usually decreases the size
+ * of the packet by the size of the data type.
+ * \param value Reference to the variable to extract.
+ * \return This.
+ */
+ bool get(bool& value, int flags = 0);
+ bool get(int8_t& value, int flags = 0);
+ bool get(int16_t& value, int flags = 0);
+ bool get(int32_t& value, int flags = 0);
+ bool get(int64_t& value, int flags = 0);
+ bool get(uint8_t& value, int flags = 0);
+ bool get(uint16_t& value, int flags = 0);
+ bool get(uint32_t& value, int flags = 0);
+ bool get(uint64_t& value, int flags = 0);
+ bool get(float& value, int flags = 0);
+ bool get(double& value, int flags = 0);
+
+ template <class T>
+ bool get(std::basic_string<T>& value, int flags = 0)
+ {
+ uint16_t length = 0;
+ if (get(length, flags))
+ {
+ size_t byteLength = length * sizeof(T);
+ T str[length];
+ size_t numBytes = read(str, byteLength, flags);
+ value.assign(str, numBytes);
+ return numBytes == byteLength;
+ }
+ return false;
+ }
+
+ template <class T>
+ bool get(std::vector<T>& value, int flags = 0)
+ {
+ uint16_t size = 0;
+ if (get(size, flags))
+ {
+ value.clear();
+ for (uint16_t i = 0; i < size; ++i)
+ {
+ T item;
+ if (get(item, flags)) value.push_back(item);
+ else return false;
+ }
+ return true;
+ }
+ return false;
+ }
+
+ /**
+ * Read some bytes from the packet.
+ * \param bytes The buffer to hold the bytes read.
+ * \param size The size of the read buffer.
+ * \return The number of bytes actually read.
+ */
+ size_t read(void* bytes, size_t size, int flags = 0);
+
+
+ /**
+ * Clear the contents of the packet, setting the size of the packet to
+ * zero.
+ */
+ void clear();
+
+
+ /**
+ * Reset the read/write markers to their initial positions, putting the
+ * packet in the state it was at right after construction.
+ */
+ void reset();
+
+
+ /**
+ * Get a pointer to an internal structure holding the serialized bytes
+ * of the packet.
+ * return The pointer.
+ */
+ const char* bytes() const
+ {
+ return mBuffer + mR;
+ }
+
+ /**
+ * Get the size of the buffer holding the serialized bytes of the
+ * packet.
+ * \return The number of bytes.
+ */
+ size_t size() const
+ {
+ return mW - mR;
+ }
+
+ // The rest of this stuff is just to implement correct copy semantics.
+
+ Packet(const Packet& copy);
+ Packet& operator=(const Packet& copy);
+ ~Packet();
+
+
+private:
+
+ char* mBuffer;
+ size_t mSize;
+
+ size_t mR;
+ size_t mW;
+ size_t mOriginalW;
+
+ size_t mBoolR;
+ size_t mBoolW;
+ size_t mBoolNumR;
+ size_t mBoolNumW;
+};
+
+
+} // namespace Mf
+
+#endif // _MOOF_PACKET_HH_
+
projects / chaz / yoink / blobdiff