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

Branch : - branch - main - tag -

• Show log

  Commit

• Author : Jamie Madill
  Date : 2016-06-02 13:04:10
  Hash : e2e406c3
  Message : Add base::numerics for safe math and conversions. This replaces are "IsUnsignedXXXSafe" family of methods. Also add overflow checks to unpack block sizes. BUG=angleproject:1397 Change-Id: Ib47be149b0486c70f795b0d0f8899441faac9340 Reviewed-on: https://chromium-review.googlesource.com/348062 Reviewed-by: Geoff Lang <geofflang@chromium.org> Commit-Queue: Jamie Madill <jmadill@chromium.org>

• src/common/Optional.h

• //
  // Copyright (c) 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_
  
  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;
      }
  
      static Optional Invalid() { return Optional(); }
  
      bool valid() const { return mValid; }
      const T &value() const { return mValue; }
  
      bool operator==(const Optional &other) const
      {
          return ((mValid == other.mValid) && (!mValid || (mValue == other.mValue)));
      }
  
      bool operator!=(const Optional &other) const
      {
          return !(*this == other);
      }
  
    private:
      bool mValid;
      T mValue;
  };
  
  #endif // COMMON_OPTIONAL_H_