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

• Show log

  Commit

• Hash : acf2f3ad
  Author :
  Date : 2017-11-21T19:22:44
  

  Apply Chromium style fixes.
  
  This addresses several minor code quality issues that are validated
  in Chromium, but not yet applied to ANGLE:
  
  * constructors and destructors must be defined out-of-line
  * auto is not allowed for simple pointer types
  * use override everywhere instead of virtual
  * virtual functions must also be defined out-of-line
  
  Slightly reduces binary size for me (~2k on Win, 150k on Linux).
  
  Bug: angleproject:1569
  Change-Id: I073ca3365188caf5f29fb28d9eb207903c1843e6
  Reviewed-on: https://chromium-review.googlesource.com/779959
  Commit-Queue: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libANGLE/Error.h

• //
  // Copyright (c) 2014 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.
  
  // Error.h: Defines the egl::Error and gl::Error classes which encapsulate API errors
  // and optional error messages.
  
  #ifndef LIBANGLE_ERROR_H_
  #define LIBANGLE_ERROR_H_
  
  #include <EGL/egl.h>
  #include <EGL/eglext.h>
  #include "angle_gl.h"
  #include "common/angleutils.h"
  #include "common/debug.h"
  
  #include <memory>
  #include <ostream>
  #include <string>
  
  namespace angle
  {
  template <typename ErrorT, typename ResultT, typename ErrorBaseT, ErrorBaseT NoErrorVal>
  class ANGLE_NO_DISCARD ErrorOrResultBase
  {
    public:
      ErrorOrResultBase(const ErrorT &error) : mError(error) {}
      ErrorOrResultBase(ErrorT &&error) : mError(std::move(error)) {}
  
      ErrorOrResultBase(ResultT &&result) : mError(NoErrorVal), mResult(std::forward<ResultT>(result))
      {
      }
  
      ErrorOrResultBase(const ResultT &result) : mError(NoErrorVal), mResult(result) {}
  
      bool isError() const { return mError.isError(); }
      const ErrorT &getError() const { return mError; }
      ResultT &&getResult() { return std::move(mResult); }
  
    private:
      ErrorT mError;
      ResultT mResult;
  };
  
  template <typename ErrorT, typename ErrorBaseT, ErrorBaseT NoErrorVal, typename CodeT, CodeT EnumT>
  class ErrorStreamBase : angle::NonCopyable
  {
    public:
      ErrorStreamBase() : mID(EnumT) {}
      ErrorStreamBase(GLuint id) : mID(id) {}
  
      template <typename T>
      ErrorStreamBase &operator<<(T value)
      {
          mErrorStream << value;
          return *this;
      }
  
      operator ErrorT() { return ErrorT(EnumT, mID, mErrorStream.str()); }
  
      template <typename ResultT>
      operator ErrorOrResultBase<ErrorT, ResultT, ErrorBaseT, NoErrorVal>()
      {
          return static_cast<ErrorT>(*this);
      }
  
    private:
      GLuint mID;
      std::ostringstream mErrorStream;
  };
  }  // namespace angle
  
  namespace egl
  {
  class Error;
  }  // namespace egl
  
  namespace gl
  {
  
  class ANGLE_NO_DISCARD Error final
  {
    public:
      explicit inline Error(GLenum errorCode);
      Error(GLenum errorCode, std::string &&message);
      Error(GLenum errorCode, GLuint id, std::string &&message);
      inline Error(const Error &other);
      inline Error(Error &&other);
      inline ~Error() = default;
  
      // automatic error type conversion
      inline Error(egl::Error &&eglErr);
      inline Error(egl::Error eglErr);
  
      inline Error &operator=(const Error &other);
      inline Error &operator=(Error &&other);
  
      inline GLenum getCode() const;
      inline GLuint getID() const;
      inline bool isError() const;
  
      const std::string &getMessage() const;
  
      // Useful for mocking and testing
      bool operator==(const Error &other) const;
      bool operator!=(const Error &other) const;
  
    private:
      void createMessageString() const;
  
      friend std::ostream &operator<<(std::ostream &os, const Error &err);
      friend class egl::Error;
  
      GLenum mCode;
      GLuint mID;
      mutable std::unique_ptr<std::string> mMessage;
  };
  
  template <typename ResultT>
  using ErrorOrResult = angle::ErrorOrResultBase<Error, ResultT, GLenum, GL_NO_ERROR>;
  
  namespace priv
  {
  
  template <GLenum EnumT>
  using ErrorStream = angle::ErrorStreamBase<Error, GLenum, GL_NO_ERROR, GLenum, EnumT>;
  
  }  // namespace priv
  
  using InternalError = priv::ErrorStream<GL_INVALID_OPERATION>;
  
  using InvalidEnum                 = priv::ErrorStream<GL_INVALID_ENUM>;
  using InvalidValue                = priv::ErrorStream<GL_INVALID_VALUE>;
  using InvalidOperation            = priv::ErrorStream<GL_INVALID_OPERATION>;
  using StackOverflow               = priv::ErrorStream<GL_STACK_OVERFLOW>;
  using StackUnderflow              = priv::ErrorStream<GL_STACK_UNDERFLOW>;
  using OutOfMemory                 = priv::ErrorStream<GL_OUT_OF_MEMORY>;
  using InvalidFramebufferOperation = priv::ErrorStream<GL_INVALID_FRAMEBUFFER_OPERATION>;
  
  inline Error NoError()
  {
      return Error(GL_NO_ERROR);
  }
  
  using LinkResult = ErrorOrResult<bool>;
  
  }  // namespace gl
  
  namespace egl
  {
  
  class ANGLE_NO_DISCARD Error final
  {
    public:
      explicit inline Error(EGLint errorCode);
      Error(EGLint errorCode, std::string &&message);
      Error(EGLint errorCode, EGLint id, std::string &&message);
      inline Error(const Error &other);
      inline Error(Error &&other);
      inline ~Error() = default;
  
      // automatic error type conversion
      inline Error(gl::Error &&glErr);
      inline Error(gl::Error glErr);
  
      inline Error &operator=(const Error &other);
      inline Error &operator=(Error &&other);
  
      inline EGLint getCode() const;
      inline EGLint getID() const;
      inline bool isError() const;
  
      const std::string &getMessage() const;
  
    private:
      void createMessageString() const;
  
      friend std::ostream &operator<<(std::ostream &os, const Error &err);
      friend class gl::Error;
  
      EGLint mCode;
      EGLint mID;
      mutable std::unique_ptr<std::string> mMessage;
  };
  
  template <typename ResultT>
  using ErrorOrResult = angle::ErrorOrResultBase<Error, ResultT, EGLint, EGL_SUCCESS>;
  
  namespace priv
  {
  
  template <EGLint EnumT>
  using ErrorStream = angle::ErrorStreamBase<Error, EGLint, EGL_SUCCESS, EGLint, EnumT>;
  
  }  // namespace priv
  
  using EglNotInitialized    = priv::ErrorStream<EGL_NOT_INITIALIZED>;
  using EglBadAccess         = priv::ErrorStream<EGL_BAD_ACCESS>;
  using EglBadAlloc          = priv::ErrorStream<EGL_BAD_ALLOC>;
  using EglBadAttribute      = priv::ErrorStream<EGL_BAD_ATTRIBUTE>;
  using EglBadConfig         = priv::ErrorStream<EGL_BAD_CONFIG>;
  using EglBadContext        = priv::ErrorStream<EGL_BAD_CONTEXT>;
  using EglBadCurrentSurface = priv::ErrorStream<EGL_BAD_CURRENT_SURFACE>;
  using EglBadDisplay        = priv::ErrorStream<EGL_BAD_DISPLAY>;
  using EglBadMatch          = priv::ErrorStream<EGL_BAD_MATCH>;
  using EglBadNativeWindow   = priv::ErrorStream<EGL_BAD_NATIVE_WINDOW>;
  using EglBadParameter      = priv::ErrorStream<EGL_BAD_PARAMETER>;
  using EglBadSurface        = priv::ErrorStream<EGL_BAD_SURFACE>;
  using EglContextLost       = priv::ErrorStream<EGL_CONTEXT_LOST>;
  using EglBadStream         = priv::ErrorStream<EGL_BAD_STREAM_KHR>;
  using EglBadState          = priv::ErrorStream<EGL_BAD_STATE_KHR>;
  using EglBadDevice         = priv::ErrorStream<EGL_BAD_DEVICE_EXT>;
  
  inline Error NoError()
  {
      return Error(EGL_SUCCESS);
  }
  
  }  // namespace egl
  
  #define ANGLE_CONCAT1(x, y) x##y
  #define ANGLE_CONCAT2(x, y) ANGLE_CONCAT1(x, y)
  #define ANGLE_LOCAL_VAR ANGLE_CONCAT2(_localVar, __LINE__)
  
  #define ANGLE_TRY_TEMPLATE(EXPR, FUNC) \
      {                                  \
          auto ANGLE_LOCAL_VAR = EXPR;   \
          if (ANGLE_LOCAL_VAR.isError()) \
          {                              \
              FUNC(ANGLE_LOCAL_VAR);     \
          }                              \
      }                                  \
      ANGLE_EMPTY_STATEMENT
  
  #define ANGLE_RETURN(X) return X;
  #define ANGLE_TRY(EXPR) ANGLE_TRY_TEMPLATE(EXPR, ANGLE_RETURN);
  
  #define ANGLE_TRY_RESULT(EXPR, RESULT)         \
      {                                          \
          auto ANGLE_LOCAL_VAR = EXPR;           \
          if (ANGLE_LOCAL_VAR.isError())         \
          {                                      \
              return ANGLE_LOCAL_VAR.getError(); \
          }                                      \
          RESULT = ANGLE_LOCAL_VAR.getResult();  \
      }                                          \
      ANGLE_EMPTY_STATEMENT
  
  // TODO(jmadill): Introduce way to store errors to a const Context.
  #define ANGLE_SWALLOW_ERR(EXPR)                                       \
      {                                                                 \
          auto ANGLE_LOCAL_VAR = EXPR;                                  \
          if (ANGLE_LOCAL_VAR.isError())                                \
          {                                                             \
              ERR() << "Unhandled internal error: " << ANGLE_LOCAL_VAR; \
          }                                                             \
      }                                                                 \
      ANGLE_EMPTY_STATEMENT
  
  #undef ANGLE_LOCAL_VAR
  #undef ANGLE_CONCAT2
  #undef ANGLE_CONCAT1
  
  #include "Error.inl"
  
  #endif // LIBANGLE_ERROR_H_
  

Download