File Manager

003 File Manager

Current Path: /usr/src/contrib/llvm-project/llvm/include/llvm/ADT

usr / src / contrib / llvm-project / llvm / include / llvm / ADT /

📁 ..
📄 APFloat.h(48.83 KB)
📄 APInt.h(74.48 KB)
📄 APSInt.h(11.75 KB)
📄 AllocatorList.h(7.53 KB)
📄 Any.h(5.05 KB)
📄 ArrayRef.h(17.92 KB)
📄 BitVector.h(29.74 KB)
📄 Bitfields.h(11.65 KB)
📄 BitmaskEnum.h(5.53 KB)
📄 BreadthFirstIterator.h(4.82 KB)
📄 CachedHashString.h(5.9 KB)
📄 CoalescingBitVector.h(14.91 KB)
📄 DAGDeltaAlgorithm.h(3.13 KB)
📄 DeltaAlgorithm.h(3.54 KB)
📄 DenseMap.h(43.14 KB)
📄 DenseMapInfo.h(11.4 KB)
📄 DenseSet.h(9.33 KB)
📄 DepthFirstIterator.h(10.37 KB)
📄 DirectedGraph.h(9.56 KB)
📄 EnumeratedArray.h(1.6 KB)
📄 EpochTracker.h(3.2 KB)
📄 EquivalenceClasses.h(10.52 KB)
📄 FloatingPointMode.h(5.62 KB)
📄 FoldingSet.h(30.16 KB)
📄 FunctionExtras.h(14.55 KB)
📄 GraphTraits.h(5.71 KB)
📄 Hashing.h(25.12 KB)
📄 ImmutableList.h(7.57 KB)
📄 ImmutableMap.h(10.84 KB)
📄 ImmutableSet.h(37.52 KB)
📄 IndexedMap.h(2.5 KB)
📄 IntEqClasses.h(2.87 KB)
📄 IntervalMap.h(72.88 KB)
📄 IntrusiveRefCntPtr.h(8.1 KB)
📄 MapVector.h(7.79 KB)
📄 None.h(983 B)
📄 Optional.h(10.82 KB)
📄 PackedVector.h(4.17 KB)
📄 PointerEmbeddedInt.h(4.05 KB)
📄 PointerIntPair.h(8.72 KB)
📄 PointerSumType.h(11.61 KB)
📄 PointerUnion.h(10.17 KB)
📄 PostOrderIterator.h(11.05 KB)
📄 PriorityQueue.h(2.69 KB)
📄 PriorityWorklist.h(8.11 KB)
📄 SCCIterator.h(8.02 KB)
📄 STLExtras.h(70.56 KB)
📄 ScopeExit.h(1.83 KB)
📄 ScopedHashTable.h(8.27 KB)
📄 Sequence.h(2.59 KB)
📄 SetOperations.h(2.58 KB)
📄 SetVector.h(9.39 KB)
📄 SmallBitVector.h(20.36 KB)
📄 SmallPtrSet.h(16.93 KB)
📄 SmallSet.h(8.37 KB)
📄 SmallString.h(8.55 KB)
📄 SmallVector.h(32.33 KB)
📄 SparseBitVector.h(26.2 KB)
📄 SparseMultiSet.h(17.83 KB)
📄 SparseSet.h(11.41 KB)
📄 Statistic.h(7.01 KB)
📄 StringExtras.h(13.25 KB)
📄 StringMap.h(15.7 KB)
📄 StringMapEntry.h(4.83 KB)
📄 StringRef.h(31.68 KB)
📄 StringSet.h(1.51 KB)
📄 StringSwitch.h(6.25 KB)
📄 TinyPtrVector.h(10.19 KB)
📄 Triple.h(27.4 KB)
📄 Twine.h(17.48 KB)
📄 TypeSwitch.h(5.82 KB)
📄 UniqueVector.h(3.09 KB)
📄 Waymarking.h(11.96 KB)
📄 bit.h(2.26 KB)
📄 edit_distance.h(3.57 KB)
📄 fallible_iterator.h(8.31 KB)
📄 ilist.h(13.68 KB)
📄 ilist_base.h(2.72 KB)
📄 ilist_iterator.h(7.21 KB)
📄 ilist_node.h(9.84 KB)
📄 ilist_node_base.h(1.7 KB)
📄 ilist_node_options.h(5.07 KB)
📄 iterator.h(13.46 KB)
📄 iterator_range.h(2.22 KB)
📄 simple_ilist.h(10.78 KB)

Editing: Optional.h

//===- Optional.h - Simple variant for passing optional values --*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
//  This file provides Optional, a template class modeled in the spirit of
//  OCaml's 'opt' variant.  The idea is to strongly type whether or not
//  a value can be optional.
//
//===----------------------------------------------------------------------===//

#ifndef LLVM_ADT_OPTIONAL_H
#define LLVM_ADT_OPTIONAL_H

#include "llvm/ADT/None.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/type_traits.h"
#include <cassert>
#include <memory>
#include <new>
#include <utility>

namespace llvm {

class raw_ostream;

namespace optional_detail {

struct in_place_t {};

/// Storage for any type.
template <typename T, bool = is_trivially_copyable<T>::value>
class OptionalStorage {
 union {
 char empty;
 T value;
 };
 bool hasVal;

public:
  ~OptionalStorage() { reset(); }

OptionalStorage() noexcept : empty(), hasVal(false) {}

OptionalStorage(OptionalStorage const &other) : OptionalStorage() {
    if (other.hasValue()) {
      emplace(other.value);
    }
  }
  OptionalStorage(OptionalStorage &&other) : OptionalStorage() {
    if (other.hasValue()) {
      emplace(std::move(other.value));
    }
  }

template <class... Args>
 explicit OptionalStorage(in_place_t, Args &&... args)
 : value(std::forward<Args>(args)...), hasVal(true) {}

void reset() noexcept {
    if (hasVal) {
      value.~T();
      hasVal = false;
    }
  }

bool hasValue() const noexcept { return hasVal; }

T &getValue() LLVM_LVALUE_FUNCTION noexcept {
    assert(hasVal);
    return value;
  }
  T const &getValue() const LLVM_LVALUE_FUNCTION noexcept {
    assert(hasVal);
    return value;
  }
#if LLVM_HAS_RVALUE_REFERENCE_THIS
  T &&getValue() && noexcept {
    assert(hasVal);
    return std::move(value);
  }
#endif

template <class... Args> void emplace(Args &&... args) {
 reset();
 ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
 hasVal = true;
 }

OptionalStorage &operator=(T const &y) {
    if (hasValue()) {
      value = y;
    } else {
      ::new ((void *)std::addressof(value)) T(y);
      hasVal = true;
    }
    return *this;
  }
  OptionalStorage &operator=(T &&y) {
    if (hasValue()) {
      value = std::move(y);
    } else {
      ::new ((void *)std::addressof(value)) T(std::move(y));
      hasVal = true;
    }
    return *this;
  }

OptionalStorage &operator=(OptionalStorage const &other) {
    if (other.hasValue()) {
      if (hasValue()) {
        value = other.value;
      } else {
        ::new ((void *)std::addressof(value)) T(other.value);
        hasVal = true;
      }
    } else {
      reset();
    }
    return *this;
  }

OptionalStorage &operator=(OptionalStorage &&other) {
    if (other.hasValue()) {
      if (hasValue()) {
        value = std::move(other.value);
      } else {
        ::new ((void *)std::addressof(value)) T(std::move(other.value));
        hasVal = true;
      }
    } else {
      reset();
    }
    return *this;
  }
};

template <typename T> class OptionalStorage<T, true> {
 union {
 char empty;
 T value;
 };
 bool hasVal = false;

public:
  ~OptionalStorage() = default;

OptionalStorage() noexcept : empty{} {}

OptionalStorage(OptionalStorage const &other) = default;
  OptionalStorage(OptionalStorage &&other) = default;

OptionalStorage &operator=(OptionalStorage const &other) = default;
  OptionalStorage &operator=(OptionalStorage &&other) = default;

template <class... Args>
 explicit OptionalStorage(in_place_t, Args &&... args)
 : value(std::forward<Args>(args)...), hasVal(true) {}

void reset() noexcept {
    if (hasVal) {
      value.~T();
      hasVal = false;
    }
  }

bool hasValue() const noexcept { return hasVal; }

template <class... Args> void emplace(Args &&... args) {
 reset();
 ::new ((void *)std::addressof(value)) T(std::forward<Args>(args)...);
 hasVal = true;
 }

} // namespace optional_detail

template <typename T> class Optional {
 optional_detail::OptionalStorage<T> Storage;

public:
  using value_type = T;

constexpr Optional() {}
  constexpr Optional(NoneType) {}

Optional(const T &y) : Storage(optional_detail::in_place_t{}, y) {}
  Optional(const Optional &O) = default;

Optional(T &&y) : Storage(optional_detail::in_place_t{}, std::move(y)) {}
  Optional(Optional &&O) = default;

Optional &operator=(T &&y) {
    Storage = std::move(y);
    return *this;
  }
  Optional &operator=(Optional &&O) = default;

/// Create a new object by constructing it in place with the given arguments.
 template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
 Storage.emplace(std::forward<ArgTypes>(Args)...);
 }

static inline Optional create(const T *y) {
    return y ? Optional(*y) : Optional();
  }

Optional &operator=(const T &y) {
    Storage = y;
    return *this;
  }
  Optional &operator=(const Optional &O) = default;

void reset() { Storage.reset(); }

const T *getPointer() const { return &Storage.getValue(); }
  T *getPointer() { return &Storage.getValue(); }
  const T &getValue() const LLVM_LVALUE_FUNCTION { return Storage.getValue(); }
  T &getValue() LLVM_LVALUE_FUNCTION { return Storage.getValue(); }

explicit operator bool() const { return hasValue(); }
  bool hasValue() const { return Storage.hasValue(); }
  const T *operator->() const { return getPointer(); }
  T *operator->() { return getPointer(); }
  const T &operator*() const LLVM_LVALUE_FUNCTION { return getValue(); }
  T &operator*() LLVM_LVALUE_FUNCTION { return getValue(); }

template <typename U>
 constexpr T getValueOr(U &&value) const LLVM_LVALUE_FUNCTION {
 return hasValue() ? getValue() : std::forward(value);
 }

/// Apply a function to the value if present; otherwise return None.
 template <class Function>
 auto map(const Function &F) const LLVM_LVALUE_FUNCTION
 -> Optional<decltype(F(getValue()))> {
 if (*this) return F(getValue());
 return None;
 }

#if LLVM_HAS_RVALUE_REFERENCE_THIS
  T &&getValue() && { return std::move(Storage.getValue()); }
  T &&operator*() && { return std::move(Storage.getValue()); }

template <typename U>
 T getValueOr(U &&value) && {
 return hasValue() ? std::move(getValue()) : std::forward(value);
 }

/// Apply a function to the value if present; otherwise return None.
 template <class Function>
 auto map(const Function &F) &&
 -> Optional<decltype(F(std::move(*this).getValue()))> {
 if (*this) return F(std::move(*this).getValue());
 return None;
 }
#endif
};

template <typename T, typename U>
bool operator==(const Optional<T> &X, const Optional &Y) {
 if (X && Y)
 return *X == *Y;
 return X.hasValue() == Y.hasValue();
}

template <typename T, typename U>
bool operator!=(const Optional<T> &X, const Optional &Y) {
 return !(X == Y);
}

template <typename T, typename U>
bool operator<(const Optional<T> &X, const Optional &Y) {
 if (X && Y)
 return *X < *Y;
 return X.hasValue() < Y.hasValue();
}

template <typename T, typename U>
bool operator<=(const Optional<T> &X, const Optional &Y) {
 return !(Y < X);
}

template <typename T, typename U>
bool operator>(const Optional<T> &X, const Optional &Y) {
 return Y < X;
}

template <typename T, typename U>
bool operator>=(const Optional<T> &X, const Optional &Y) {
 return !(X < Y);
}

template<typename T>
bool operator==(const Optional<T> &X, NoneType) {
 return !X;
}

template<typename T>
bool operator==(NoneType, const Optional<T> &X) {
 return X == None;
}

template<typename T>
bool operator!=(const Optional<T> &X, NoneType) {
 return !(X == None);
}

template<typename T>
bool operator!=(NoneType, const Optional<T> &X) {
 return X != None;
}

template <typename T> bool operator<(const Optional<T> &X, NoneType) {
 return false;
}

template <typename T> bool operator<(NoneType, const Optional<T> &X) {
 return X.hasValue();
}

template <typename T> bool operator<=(const Optional<T> &X, NoneType) {
 return !(None < X);
}

template <typename T> bool operator<=(NoneType, const Optional<T> &X) {
 return !(X < None);
}

template <typename T> bool operator>(const Optional<T> &X, NoneType) {
 return None < X;
}

template <typename T> bool operator>(NoneType, const Optional<T> &X) {
 return X < None;
}

template <typename T> bool operator>=(const Optional<T> &X, NoneType) {
 return None <= X;
}

template <typename T> bool operator>=(NoneType, const Optional<T> &X) {
 return X <= None;
}

template <typename T> bool operator==(const Optional<T> &X, const T &Y) {
 return X && *X == Y;
}

template <typename T> bool operator==(const T &X, const Optional<T> &Y) {
 return Y && X == *Y;
}

template <typename T> bool operator!=(const Optional<T> &X, const T &Y) {
 return !(X == Y);
}

template <typename T> bool operator!=(const T &X, const Optional<T> &Y) {
 return !(X == Y);
}

template <typename T> bool operator<(const Optional<T> &X, const T &Y) {
 return !X || *X < Y;
}

template <typename T> bool operator<(const T &X, const Optional<T> &Y) {
 return Y && X < *Y;
}

template <typename T> bool operator<=(const Optional<T> &X, const T &Y) {
 return !(Y < X);
}

template <typename T> bool operator<=(const T &X, const Optional<T> &Y) {
 return !(Y < X);
}

template <typename T> bool operator>(const Optional<T> &X, const T &Y) {
 return Y < X;
}

template <typename T> bool operator>(const T &X, const Optional<T> &Y) {
 return Y < X;
}

template <typename T> bool operator>=(const Optional<T> &X, const T &Y) {
 return !(X < Y);
}

template <typename T> bool operator>=(const T &X, const Optional<T> &Y) {
 return !(X < Y);
}

raw_ostream &operator<<(raw_ostream &OS, NoneType);

template <typename T, typename = decltype(std::declval<raw_ostream &>()
 << std::declval<const T &>())>
raw_ostream &operator<<(raw_ostream &OS, const Optional<T> &O) {
 if (O)
 OS << *O;
 else
 OS << None;
 return OS;
}

} // end namespace llvm

#endif // LLVM_ADT_OPTIONAL_H

003 File Manager

Editing: Optional.h

Upload File

Create Folder