src/third_party/angle/src/libGLESv2/BinaryStream.h

   1 //
   2 // Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
   3 // Use of this source code is governed by a BSD-style license that can be
   4 // found in the LICENSE file.
   5 //
   6
   7 // BinaryStream.h: Provides binary serialization of simple types.
   8
   9 #ifndef LIBGLESV2_BINARYSTREAM_H_
  10 #define LIBGLESV2_BINARYSTREAM_H_
  11
  12 #include "common/angleutils.h"
  13 #include "common/mathutil.h"
  14
  15 namespace gl
  16 {
  17
  18 class BinaryInputStream
  19 {
  20   public:
  21     BinaryInputStream(const void *data, size_t length)
  22     {
  23         mError = false;
  24         mOffset = 0;
  25         mData = static_cast<const char*>(data);
  26         mLength = length;
  27     }
  28
  29     // readInt will generate an error for bool types
  30     template <class IntT>
  31     IntT readInt()
  32     {
  33         int value;
  34         read(&value);
  35         return static_cast<IntT>(value);
  36     }
  37
  38     template <class IntT>
  39     void readInt(IntT *outValue)
  40     {
  41         *outValue = readInt<IntT>();
  42     }
  43
  44     bool readBool()
  45     {
  46         int value;
  47         read(&value);
  48         return (value > 0);
  49     }
  50
  51     void readBool(bool *outValue)
  52     {
  53         *outValue = readBool();
  54     }
  55
  56     void readBytes(unsigned char outArray[], size_t count)
  57     {
  58         read<unsigned char>(outArray, count);
  59     }
  60
  61     std::string readString()
  62     {
  63         std::string outString;
  64         readString(&outString);
  65         return outString;
  66     }
  67
  68     void readString(std::string *v)
  69     {
  70         size_t length;
  71         readInt(&length);
  72
  73         if (mError)
  74         {
  75             return;
  76         }
  77
  78         if (mOffset + length > mLength)
  79         {
  80             mError = true;
  81             return;
  82         }
  83
  84         v->assign(mData + mOffset, length);
  85         mOffset += length;
  86     }
  87
  88     void skip(size_t length)
  89     {
  90         if (mOffset + length > mLength)
  91         {
  92             mError = true;
  93             return;
  94         }
  95
  96         mOffset += length;
  97     }
  98
  99     size_t offset() const
 100     {
 101         return mOffset;
 102     }
 103
 104     bool error() const
 105     {
 106         return mError;
 107     }
 108
 109     bool endOfStream() const
 110     {
 111         return mOffset == mLength;
 112     }
 113
 114   private:
 115     DISALLOW_COPY_AND_ASSIGN(BinaryInputStream);
 116     bool mError;
 117     size_t mOffset;
 118     const char *mData;
 119     size_t mLength;
 120
 121     template <typename T>
 122     void read(T *v, size_t num)
 123     {
 124         META_ASSERT(std::is_fundamental<T>::value);
 125
 126         size_t length = num * sizeof(T);
 127
 128         if (mOffset + length > mLength)
 129         {
 130             mError = true;
 131             return;
 132         }
 133
 134         memcpy(v, mData + mOffset, length);
 135         mOffset += length;
 136     }
 137
 138     template <typename T>
 139     void read(T *v)
 140     {
 141         read(v, 1);
 142     }
 143
 144 };
 145
 146 class BinaryOutputStream
 147 {
 148   public:
 149     BinaryOutputStream()
 150     {
 151     }
 152
 153     // writeInt also handles bool types
 154     template <class IntT>
 155     void writeInt(IntT param)
 156     {
 157         ASSERT(rx::IsIntegerCastSafe<int>(param));
 158         int intValue = static_cast<int>(param);
 159         write(&intValue, 1);
 160     }
 161
 162     void writeString(const std::string &v)
 163     {
 164         writeInt(v.length());
 165         write(v.c_str(), v.length());
 166     }
 167
 168     void writeBytes(const unsigned char *bytes, size_t count)
 169     {
 170         write(bytes, count);
 171     }
 172
 173     size_t length() const
 174     {
 175         return mData.size();
 176     }
 177
 178     const void* data() const
 179     {
 180         return mData.size() ? &mData[0] : NULL;
 181     }
 182
 183   private:
 184     DISALLOW_COPY_AND_ASSIGN(BinaryOutputStream);
 185     std::vector<char> mData;
 186
 187     template <typename T>
 188     void write(const T *v, size_t num)
 189     {
 190         META_ASSERT(std::is_fundamental<T>::value);
 191         const char *asBytes = reinterpret_cast<const char*>(v);
 192         mData.insert(mData.end(), asBytes, asBytes + num * sizeof(T));
 193     }
 194
 195 };
 196 }
 197
 198 #endif  // LIBGLESV2_BINARYSTREAM_H_