kc3-lang/angle/src/common/Optional.h

• Show log

  Commit

• Hash : 18657894
  Author :
  Date : 2023-01-25T13:05:56
  

  Add features to dump and replace shader source.
  
  dump_shader_source writes shader source strings to files named
  with the hash of the source and shader type.
  
  enable_shader_substitution allows subsituting the shader source
  with the strings contained in a file. The same file naming scheme
  as dump_shader_source is used so shaders can be dumped in one run,
  modified and subsititued in the next run.
  
  Use the ANGLE_SHADER_DUMP_PATH and debug.angle.shader_dump_path
  environment variables to control where files are written. If they
  are unspecified, write to the temp directory.
  
  Based upon Cody's CLs:
  https://chromium-review.googlesource.com/c/angle/angle/+/2755841
  https://chromium-review.googlesource.com/c/angle/angle/+/3961670
  
  Bug: angleproject:7760, chromium:1385510
  Change-Id: I43b9827b977079b88daa794e867637f7a126b080
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/4192347
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Reviewed-by: Cody Northrop <cnorthrop@google.com>
  Commit-Queue: Geoff Lang <geofflang@chromium.org>
  

Download

• src/common/Optional.h

• //
  // Copyright 2015 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.
  //
  // Optional.h:
  //   Represents a type that may be invalid, similar to std::optional.
  //
  
  #ifndef COMMON_OPTIONAL_H_
  #define COMMON_OPTIONAL_H_
  
  #include <utility>
  
  template <class T>
  struct Optional
  {
      Optional() : mValid(false), mValue(T()) {}
  
      Optional(const T &valueIn) : mValid(true), mValue(valueIn) {}
  
      Optional(const Optional &other) : mValid(other.mValid), mValue(other.mValue) {}
  
      Optional &operator=(const Optional &other)
      {
          this->mValid = other.mValid;
          this->mValue = other.mValue;
          return *this;
      }
  
      Optional &operator=(const T &value)
      {
          mValue = value;
          mValid = true;
          return *this;
      }
  
      Optional &operator=(T &&value)
      {
          mValue = std::move(value);
          mValid = true;
          return *this;
      }
  
      void reset() { mValid = false; }
      T &&release()
      {
          mValid = false;
          return std::move(mValue);
      }
  
      static Optional Invalid() { return Optional(); }
  
      bool valid() const { return mValid; }
      T &value() { return mValue; }
      const T &value() const { return mValue; }
      const T &valueOr(const T &defaultValue) const { return mValid ? mValue : defaultValue; }
  
      bool operator==(const Optional &other) const
      {
          return ((mValid == other.mValid) && (!mValid || (mValue == other.mValue)));
      }
  
      bool operator!=(const Optional &other) const { return !(*this == other); }
  
      bool operator==(const T &value) const { return mValid && (mValue == value); }
  
      bool operator!=(const T &value) const { return !(*this == value); }
  
    private:
      bool mValid;
      T mValue;
  };
  
  #endif  // COMMON_OPTIONAL_H_
  

Download