engine/include/core/Buffer.h

   1 /*
   2 Copyright (C) 2008  Mathias Gottschlag, Lukas Kropatschek
   3
   4 Permission is hereby granted, free of charge, to any person obtaining a copy of
   5 this software and associated documentation files (the "Software"), to deal in the
   6 Software without restriction, including without limitation the rights to use,
   7 copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
   8 Software, and to permit persons to whom the Software is furnished to do so,
   9 subject to the following conditions:
  10
  11 The above copyright notice and this permission notice shall be included in all
  12 copies or substantial portions of the Software.
  13
  14 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
  15 INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
  16 PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
  17 HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  18 OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  19 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  20 */
  21
  22 #ifndef _BUFFER_H_
  23 #define _BUFFER_H_
  24
  25 #include <string>
  26
  27 #include "core/Vector3D.h"
  28 #include "core/Vector2D.h"
  29 #include "core/Quaternion.h"
  30
  31 //tolua_begin
  32 namespace peak
  33 {
  34         /**
  35          * \brief Dynamically sized buffer for network data etc.
  36          */
  37         class Buffer
  38         {
  39                 public:
  40                         Buffer();
  41                         Buffer(unsigned int size);
  42                         Buffer(void *data, unsigned int size);
  43                         Buffer(const Buffer &buf);
  44                         ~Buffer();
  45
  46                         /**
  47                          * \brief Sets buffer size.
  48                          *
  49                          * If there is more data than the new size, the data is truncated.
  50                          * \param size New size
  51                          */
  52                         void setSize(unsigned int size);
  53                         /**
  54                          * \brief Returns the buffer size.
  55                          * \return Buffer size
  56                          */
  57                         unsigned int getSize(void);
  58                         /**
  59                          * \brief Returns the size of the data stored in the buffer.
  60                          * \return Data size
  61                          */
  62                         unsigned int getDataSize(void);
  63
  64                         /**
  65                          * \brief Returns the current write/read position.
  66                          * \return Position
  67                          */
  68                         unsigned int getPosition(void);
  69                         /**
  70                          * \brief Sets the current write/read position.
  71                          * \param position New position
  72                          * \param relative If set, add the current position to the new position
  73                          */
  74                         void setPosition(unsigned int position, bool relative = false);
  75
  76                         /**
  77                          * \brief Reads raw data from the current position.
  78                          *
  79                          * Might read less than size bytes if there is not enough data.
  80                          * \param dest Memory to hold the data. Must be at least size bytes long.
  81                          * \param size Size to be read
  82                          * \return Number of bytes read
  83                          */
  84                         int readData(void *dest, unsigned int size);
  85                         /**
  86                          * \brief Write data to the buffer.
  87                          *
  88                          * Might write less then size bytes if resize is not set.
  89                          * \param source Pointer to the data.
  90                          * \param size Size to be written
  91                          * \param resize If set, resize the buffer if it is not big enougth to hold the data
  92                          * \return Number of bytes written
  93                          */
  94                         int writeData(const void *source, unsigned int size,
  95                                         bool resize = true);
  96
  97                         /**
  98                          * \brief Write integer to the buffer.
  99                          * \param value Number to be written
 100                          */
 101                         void writeInt(int value);
 102                         /**
 103                          * \brief Read integer from the buffer.
 104                          * \return Value of the integer
 105                          */
 106                         int readInt(void);
 107                         /**
 108                          * \brief Write float to the buffer.
 109                          * \param value Number to be written
 110                          */
 111                         void writeFloat(float value);
 112                         /**
 113                          * \brief Read float from the buffer.
 114                          * \return Value of the float
 115                          */
 116                         float readFloat(void);
 117                         /**
 118                          * \brief Write string to the buffer.
 119                          * \param str String to be written
 120                          */
 121                         void writeString(std::string str);
 122                         /**
 123                          * \brief Read string from the buffer.
 124                          * \return String which was read
 125                          */
 126                         std::string readString(void);
 127                         /**
 128                          * \brief Write single byte to the buffer.
 129                          * \param value Byte to be written
 130                          */
 131                         void writeByte(unsigned char value);
 132                         /**
 133                          * \brief Read single byte from the buffer.
 134                          * \return Value of the byte
 135                          */
 136                         unsigned char readByte(void);
 137                         /**
 138                          * \brief Write word (2 bytes) to the buffer.
 139                          * \param value Word to be written
 140                          */
 141                         void writeWord(short value);
 142                         /**
 143                          * \brief Read word (2 bytes) from the buffer.
 144                          * \return Value of the word
 145                          */
 146                         short readWord(void);
 147                         /**
 148                          * \brief Write a bool variable to the buffer.
 149                          * \param flag bool variable to be written.
 150                          */
 151                         void writeBool(bool flag);
 152                         /**
 153                          * \brief Read a bool variable from the buffer.
 154                          * \return Value of the bool variable.
 155                          */
 156                         bool readBool(void);
 157                         /**
 158                          * \brief Write 2-dimensional vector to the buffer.
 159                          * \param v Vector to be written
 160                          */
 161                         void writeVector2D(Vector2D v);
 162                         /**
 163                          * \brief Read 2-dimensional vector from the buffer.
 164                          * \return Value of the vector.
 165                          */
 166                         Vector2D readVector2D(void);
 167                         /**
 168                          * \brief Write vector to the buffer.
 169                          * \param v Vector to be written
 170                          */
 171                         void writeVector3D(Vector3D v);
 172                         /**
 173                          * \brief Read vector from the buffer.
 174                          * \return Value of the vector
 175                          */
 176                         Vector3D readVector3D(void);
 177                         /**
 178                          * \brief Write quaternion to the buffer.
 179                          * \param q Quaternion to be written
 180                          */
 181                         void writeQuaternion(Quaternion q);
 182                         /**
 183                          * \brief Read quaternion from the buffer.
 184                          * \return Value of the quaternion
 185                          */
 186                         Quaternion readQuaternion(void);
 187
 188                         /**
 189                          * \brief Returns pointer to the raw buffer data.
 190                          * \return Pointer to buffer data
 191                          */
 192                         char *getData(void);
 193
 194                         /**
 195                          * \brief Clear the buffer and free the data.
 196                          */
 197                         void clear(void);
 198
 199                         //tolua_end
 200                         Buffer &operator=(const Buffer &buf);
 201                         Buffer &operator+=(const Buffer &buf);
 202                         Buffer &operator<<(const Buffer &buf);
 203                         Buffer &operator<<(int &data);
 204                         Buffer &operator<<(float &data);
 205                 private:
 206                         char *data;
 207                         unsigned int size;
 208                         unsigned int datasize;
 209                         unsigned int position;
 210                         //tolua_begin
 211         };
 212 }
 213 //tolua_end
 214
 215 #endif