kc3-lang/angle/src/libANGLE/BinaryStream.h

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2015-03-31 12:56:52
  Hash : f0d10f89
  Message : Replace non-copyable macro with a helper class. This class provides a simpler scheme for blocking default copy and assignment operators. It also reduces the amount of code needed since it's inherited to child classes. This also fixes the conflict between our macro and the same-named macro in Chromium code. BUG=angleproject:956 Change-Id: If0dc72aa3f63fbc7b8fa34907418821c64c39e2f Reviewed-on: https://chromium-review.googlesource.com/263257 Tested-by: Jamie Madill <jmadill@chromium.org> Reviewed-by: Geoff Lang <geofflang@chromium.org> Reviewed-by: Brandon Jones <bajones@chromium.org>

• src/libANGLE/BinaryStream.h

• //
  // Copyright (c) 2012 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // BinaryStream.h: Provides binary serialization of simple types.
  
  #ifndef LIBANGLE_BINARYSTREAM_H_
  #define LIBANGLE_BINARYSTREAM_H_
  
  #include "common/angleutils.h"
  #include "common/mathutil.h"
  
  #include <cstddef>
  #include <string>
  #include <vector>
  #include <stdint.h>
  
  template <typename T>
  void StaticAssertIsFundamental()
  {
      // c++11 STL is not available on OSX or Android
  #if !defined(ANGLE_PLATFORM_APPLE) && !defined(ANGLE_PLATFORM_ANDROID)
      static_assert(std::is_fundamental<T>::value, "T must be a fundamental type.");
  #else
      union { T dummy; } dummy;
      static_cast<void>(dummy);
  #endif
  }
  
  namespace gl
  {
  
  class BinaryInputStream : angle::NonCopyable
  {
    public:
      BinaryInputStream(const void *data, size_t length)
      {
          mError = false;
          mOffset = 0;
          mData = static_cast<const uint8_t*>(data);
          mLength = length;
      }
  
      // readInt will generate an error for bool types
      template <class IntT>
      IntT readInt()
      {
          int value;
          read(&value);
          return static_cast<IntT>(value);
      }
  
      template <class IntT>
      void readInt(IntT *outValue)
      {
          *outValue = readInt<IntT>();
      }
  
      bool readBool()
      {
          int value;
          read(&value);
          return (value > 0);
      }
  
      void readBool(bool *outValue)
      {
          *outValue = readBool();
      }
  
      void readBytes(unsigned char outArray[], size_t count)
      {
          read<unsigned char>(outArray, count);
      }
  
      std::string readString()
      {
          std::string outString;
          readString(&outString);
          return outString;
      }
  
      void readString(std::string *v)
      {
          size_t length;
          readInt(&length);
  
          if (mError)
          {
              return;
          }
  
          if (mOffset + length > mLength)
          {
              mError = true;
              return;
          }
  
          v->assign(reinterpret_cast<const char *>(mData) + mOffset, length);
          mOffset += length;
      }
  
      void skip(size_t length)
      {
          if (mOffset + length > mLength)
          {
              mError = true;
              return;
          }
  
          mOffset += length;
      }
  
      size_t offset() const
      {
          return mOffset;
      }
  
      bool error() const
      {
          return mError;
      }
  
      bool endOfStream() const
      {
          return mOffset == mLength;
      }
  
      const uint8_t *data()
      {
          return mData;
      }
  
    private:
      bool mError;
      size_t mOffset;
      const uint8_t *mData;
      size_t mLength;
  
      template <typename T>
      void read(T *v, size_t num)
      {
          StaticAssertIsFundamental<T>();
  
          size_t length = num * sizeof(T);
  
          if (mOffset + length > mLength)
          {
              mError = true;
              return;
          }
  
          memcpy(v, mData + mOffset, length);
          mOffset += length;
      }
  
      template <typename T>
      void read(T *v)
      {
          read(v, 1);
      }
  
  };
  
  class BinaryOutputStream : angle::NonCopyable
  {
    public:
      BinaryOutputStream()
      {
      }
  
      // writeInt also handles bool types
      template <class IntT>
      void writeInt(IntT param)
      {
          ASSERT(rx::IsIntegerCastSafe<int>(param));
          int intValue = static_cast<int>(param);
          write(&intValue, 1);
      }
  
      void writeString(const std::string &v)
      {
          writeInt(v.length());
          write(v.c_str(), v.length());
      }
  
      void writeBytes(const unsigned char *bytes, size_t count)
      {
          write(bytes, count);
      }
  
      size_t length() const
      {
          return mData.size();
      }
  
      const void* data() const
      {
          return mData.size() ? &mData[0] : NULL;
      }
  
    private:
      std::vector<char> mData;
  
      template <typename T>
      void write(const T *v, size_t num)
      {
          StaticAssertIsFundamental<T>();
          const char *asBytes = reinterpret_cast<const char*>(v);
          mData.insert(mData.end(), asBytes, asBytes + num * sizeof(T));
      }
  
  };
  }
  
  #endif  // LIBANGLE_BINARYSTREAM_H_