clang/test/Sema/Inputs/lifetime-analysis.h

   1
   2 namespace __gnu_cxx {
   3 template <typename T>
   4 struct basic_iterator {
   5   basic_iterator operator++();
   6   T& operator*() const;
   7   T* operator->() const;
   8 };
   9
  10 template<typename T>
  11 bool operator!=(basic_iterator<T>, basic_iterator<T>);
  12 }
  13
  14 namespace std {
  15 template<typename T> struct remove_reference       { typedef T type; };
  16 template<typename T> struct remove_reference<T &>  { typedef T type; };
  17 template<typename T> struct remove_reference<T &&> { typedef T type; };
  18
  19 template<typename T>
  20 typename remove_reference<T>::type &&move(T &&t) noexcept;
  21
  22 template <typename C>
  23 auto data(const C &c) -> decltype(c.data());
  24
  25 template <typename C>
  26 auto begin(C &c) -> decltype(c.begin());
  27
  28 template<typename T, int N>
  29 T *begin(T (&array)[N]);
  30
  31 using size_t = decltype(sizeof(0));
  32
  33 template<typename T>
  34 struct initializer_list {
  35   const T* ptr; size_t sz;
  36 };
  37 template<typename T> class allocator {};
  38 template <typename T, typename Alloc = allocator<T>>
  39 struct vector {
  40   typedef __gnu_cxx::basic_iterator<T> iterator;
  41   iterator begin();
  42   iterator end();
  43   const T *data() const;
  44   vector();
  45   vector(initializer_list<T> __l,
  46          const Alloc& alloc = Alloc());
  47
  48   template<typename InputIterator>
  49         vector(InputIterator first, InputIterator __last);
  50
  51   T &at(int n);
  52
  53   void push_back(const T&);
  54   void push_back(T&&);
  55
  56   void insert(iterator, T&&);
  57 };
  58
  59 template<typename T>
  60 struct basic_string_view {
  61   basic_string_view();
  62   basic_string_view(const T *);
  63   const T *begin() const;
  64 };
  65 using string_view = basic_string_view<char>;
  66
  67 template<class _Mystr> struct iter {
  68     iter& operator-=(int);
  69
  70     iter operator-(int _Off) const {
  71         iter _Tmp = *this;
  72         return _Tmp -= _Off;
  73     }
  74 };
  75
  76 template<typename T>
  77 struct basic_string {
  78   basic_string();
  79   basic_string(const T *);
  80   const T *c_str() const;
  81   operator basic_string_view<T> () const;
  82   using const_iterator = iter<T>;
  83 };
  84 using string = basic_string<char>;
  85
  86 template<typename T>
  87 struct unique_ptr {
  88   T &operator*();
  89   T *get() const;
  90 };
  91
  92 template<typename T>
  93 struct optional {
  94   optional();
  95   optional(const T&);
  96
  97   template<typename U = T>
  98   optional(U&& t);
  99
 100   template<typename U>
 101   optional(optional<U>&& __t);
 102
 103   T &operator*() &;
 104   T &&operator*() &&;
 105   T &value() &;
 106   T &&value() &&;
 107 };
 108 template<typename T>
 109 optional<__decay(T)> make_optional(T&&);
 110
 111
 112 template<typename T>
 113 struct stack {
 114   T &top();
 115 };
 116
 117 struct any {};
 118
 119 template<typename T>
 120 T any_cast(const any& operand);
 121
 122 template<typename T>
 123 struct reference_wrapper {
 124   template<typename U>
 125   reference_wrapper(U &&);
 126 };
 127
 128 template<typename T>
 129 reference_wrapper<T> ref(T& t) noexcept;
 130
 131 struct false_type {
 132     static constexpr bool value = false;
 133     constexpr operator bool() const noexcept { return value; }
 134 };
 135 struct true_type {
 136     static constexpr bool value = true;
 137     constexpr operator bool() const noexcept { return value; }
 138 };
 139
 140 template<class T> struct is_pointer : false_type {};
 141 template<class T> struct is_pointer<T*> : true_type {};
 142 template<class T> struct is_pointer<T* const> : true_type {};
 143 }