reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

unittests/ADT/DirectedGraphTest.cpp
   27 class DGTestEdge;

References

include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/DirectedGraph.h
   32   explicit DGEdge(const DGEdge<NodeType, EdgeType> &E)
   34   DGEdge<NodeType, EdgeType> &operator=(const DGEdge<NodeType, EdgeType> &E) {
   34   DGEdge<NodeType, EdgeType> &operator=(const DGEdge<NodeType, EdgeType> &E) {
   41   bool operator==(const EdgeType &E) const { return getDerived().isEqualTo(E); }
   42   bool operator!=(const EdgeType &E) const { return !operator==(E); }
   53   bool isEqualTo(const EdgeType &E) const { return this == &E; }
   56   EdgeType &getDerived() { return *static_cast<EdgeType *>(this); }
   57   const EdgeType &getDerived() const {
   69   using EdgeListTy = SetVector<EdgeType *>;
   74   explicit DGNode(EdgeType &E) : Edges() { Edges.insert(&E); }
   77   explicit DGNode(const DGNode<NodeType, EdgeType> &N) : Edges(N.Edges) {}
   78   DGNode(DGNode<NodeType, EdgeType> &&N) : Edges(std::move(N.Edges)) {}
   80   DGNode<NodeType, EdgeType> &operator=(const DGNode<NodeType, EdgeType> &N) {
   80   DGNode<NodeType, EdgeType> &operator=(const DGNode<NodeType, EdgeType> &N) {
   84   DGNode<NodeType, EdgeType> &operator=(const DGNode<NodeType, EdgeType> &&N) {
   84   DGNode<NodeType, EdgeType> &operator=(const DGNode<NodeType, EdgeType> &&N) {
   98   const EdgeType &front() const { return *Edges.front(); }
   99   EdgeType &front() { return *Edges.front(); }
  100   const EdgeType &back() const { return *Edges.back(); }
  101   EdgeType &back() { return *Edges.back(); }
  107   bool findEdgesTo(const NodeType &N, SmallVectorImpl<EdgeType *> &EL) const {
  109     for (auto *E : Edges)
  117   bool addEdge(EdgeType &E) { return Edges.insert(&E); }
  120   void removeEdge(EdgeType &E) { Edges.remove(&E); }
  166   using EdgeListTy = SmallVector<EdgeType *, 10>;
  170   using DGraphType = DirectedGraph<NodeType, EdgeType>;
  216   bool findIncomingEdgesToNode(const NodeType &N, SmallVectorImpl<EdgeType*> &EL) const {
  243       for (auto *E : EL)
  255   bool connect(NodeType &Src, NodeType &Dst, EdgeType &E) {
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
unittests/ADT/DirectedGraphTest.cpp
   28 using DGTestNodeBase = DGNode<DGTestNode, DGTestEdge>;
   29 using DGTestEdgeBase = DGEdge<DGTestNode, DGTestEdge>;
   30 using DGTestBase = DirectedGraph<DGTestNode, DGTestEdge>;
   49 using EdgeListTy = SmallVector<DGTestEdge *, 2>;
   58   static DGTestNode *DGTestGetTargetNode(DGEdge<DGTestNode, DGTestEdge> *P) {
   97   DGTestEdge E1(N1), E2(N2), E3(N3);
  142   DGTestEdge E1(N1), E2(N2), E3(N3);
  188   DGTestEdge E1(N1), E2(N2), E3(N3), E4(N1);
  212   DGTestEdge E1(N1), E2(N2), E3(N3);
  250   DGTestEdge E1(N1), E2(N2), E3(N3), E4(N4);
usr/include/c++/7.4.0/type_traits
 1983     { typedef _Up     type; };
utils/unittest/googletest/include/gtest/gtest-printers.h
  140   static void PrintValue(const T& value, ::std::ostream* os) {
  205     ::std::basic_ostream<Char, CharTraits>& os, const T& x) {
  206   TypeWithoutFormatter<T,
  207       (internal::IsAProtocolMessage<T>::value ? kProtobuf :
  208        internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ?
  223 void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) {
  276   static ::std::string Format(const ToPrint& value) {
  351     const T1& value, const T2& /* other_operand */) {
  351     const T1& value, const T2& /* other_operand */) {
  352   return FormatForComparison<T1, T2>::Format(value);
  352   return FormatForComparison<T1, T2>::Format(value);
  366 void UniversalPrint(const T& value, ::std::ostream* os);
  373                     const C& container, ::std::ostream* os) {
  407                     T* p, ::std::ostream* os) {
  416     if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {
  439                     const T& value, ::std::ostream* os) {
  455 void PrintTo(const T& value, ::std::ostream* os) {
  478   DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os);
  699   static void Print(const T& value, ::std::ostream* os) {
  784   static void Print(const T& value, ::std::ostream* os) {
  856   typedef T T1;
  983   internal::UniversalTersePrinter<T>::Print(value, &ss);
utils/unittest/googletest/include/gtest/gtest.h
 1377                                    const T1& lhs, const T2& rhs) {
 1377                                    const T1& lhs, const T2& rhs) {
 1389                             const T1& lhs,
 1390                             const T2& rhs) {
 1419                                  const T1& lhs,
 1420                                  const T2& rhs) {
utils/unittest/googletest/include/gtest/internal/custom/raw-ostream.h
   29   static const T& printable(const T& V) { return V; }
   29   static const T& printable(const T& V) { return V; }
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   35 auto printable(const T &V) -> decltype(StreamSwitch<T>::printable(V)) {
   37   return StreamSwitch<T>::printable(V);
utils/unittest/googletest/include/gtest/internal/gtest-internal.h
   94 ::std::string PrintToString(const T& value);