1 // { dg-do compile } 2 // { dg-options "-std=c++11 -Wno-return-type" } 3 4 namespace std 5 { 6 template <class, class> 7 struct pair 8 { 9 }; 10 struct input_iterator_tag 11 { 12 }; 13 struct forward_iterator_tag : public input_iterator_tag 14 { 15 }; 16 template <typename, typename _Tp, typename = _Tp> 17 struct iterator 18 { 19 }; 20 } 21 namespace __gnu_cxx 22 { 23 template <typename _Tp> 24 struct new_allocator 25 { 26 typedef _Tp pointer; 27 typedef _Tp value_type; 28 template <typename _Tp1> 29 struct rebind 30 { 31 typedef new_allocator <_Tp1> other; 32 }; 33 }; 34 } 35 namespace std 36 { 37 template <typename _Tp> 38 struct allocator : public __gnu_cxx::new_allocator <_Tp> 39 { 40 }; 41 } 42 extern "C" 43 { 44 struct rtl_String; 45 void rtl_string_release (rtl_String *) throw (); 46 void rtl_string_newFromStr (rtl_String * *, const char *) throw (); 47 } 48 namespace std 49 { 50 template <typename, typename, typename> struct binary_function; 51 template <typename _Tp> 52 struct equal_to : public binary_function <_Tp, _Tp, bool> 53 { 54 }; 55 } 56 namespace rtl 57 { 58 struct OString 59 { 60 rtl_String * pData; OStringOString61 OString (const char *value) 62 { 63 rtl_string_newFromStr (&pData, value); 64 } ~OStringOString65 ~OString () 66 { 67 rtl_string_release (pData); 68 } 69 }; 70 struct OStringHash; 71 } 72 namespace boost 73 { 74 template <class> struct hash; 75 namespace unordered 76 { 77 template <class T, class = boost::hash <T>, class = std::equal_to <T>, class = std::allocator <T>>class unordered_set; 78 } 79 using boost::unordered::unordered_set; 80 namespace detail 81 { 82 template <bool> 83 struct if_true 84 { 85 template <class, class F> 86 struct then 87 { 88 typedef F type; 89 }; 90 }; 91 } 92 template <class, class> struct pointer_to_other; 93 template <class T, class U> 94 struct pointer_to_other <T *, U> 95 { 96 typedef U type; 97 }; 98 namespace unordered 99 { 100 namespace detail 101 { 102 template <typename T, T> struct integral_constant 103 { 104 }; 105 struct choice9 106 { 107 typedef char (&type)[9]; 108 }; 109 struct choice8:choice9 110 { 111 }; 112 struct choice7:choice8 113 { 114 }; 115 struct choice6:choice7 116 { 117 }; 118 struct choice5:choice6 119 { 120 }; 121 struct choice4:choice5 122 { 123 }; 124 struct choice3:choice4 125 { 126 }; 127 struct choice2:choice3 128 { 129 }; 130 struct choice1:choice2 131 { 132 }; 133 choice1 choose (); 134 template <typename Alloc, typename T> 135 struct rebind_wrap 136 { 137 typedef typename Alloc::template rebind <T>::other type; 138 }; 139 template <typename, typename T2> 140 struct sfinae:T2 141 { 142 }; 143 template <typename Tp, typename Default> 144 struct default_type_pointer 145 { 146 template <typename X> 147 static boost::unordered::detail::sfinae <typename X::pointer, choice1> test (choice1); 148 struct DefaultWrap 149 { 150 typedef Default pointer; 151 }; 152 enum { value = (1 == sizeof (test <Tp> (choose ()))) }; 153 typedef typename boost::detail::if_true <value>::template then <Tp, DefaultWrap>::type::pointer type; 154 }; 155 template <typename Tp, typename Default> 156 struct default_type_const_pointer 157 { 158 template <typename> 159 static choice2::type test (choice2); 160 struct DefaultWrap 161 { 162 }; 163 enum { value = (1 == sizeof (test <Tp> (choose ()))) }; 164 typedef typename boost::detail::if_true <value>::template then <Tp, DefaultWrap> type; 165 }; 166 struct default_type_propagate_on_container_swap 167 { 168 struct DefaultWrap 169 { 170 }; 171 }; 172 template <typename Alloc> 173 struct allocator_traits 174 { 175 typedef typename Alloc::value_type value_type; 176 typedef typename default_type_pointer <Alloc, value_type *>::type pointer; 177 template <typename T> 178 struct pointer_to_other : boost::pointer_to_other <pointer, T> 179 { 180 }; 181 typedef typename default_type_const_pointer <Alloc, typename pointer_to_other <value_type>::type>::type const_pointer; 182 }; 183 } 184 namespace detail 185 { 186 struct move_tag 187 { 188 }; 189 template <typename> struct table; 190 template <typename NodeAlloc> 191 struct node_constructor 192 { 193 void construct_value () 194 { 195 } 196 }; 197 struct ptr_bucket 198 { 199 ptr_bucket () 200 { 201 } 202 }; 203 template <typename A, typename Bucket, typename Node> 204 struct buckets 205 { 206 typedef Node node; 207 typedef Bucket bucket; 208 typedef typename boost::unordered::detail::rebind_wrap <A, node>::type node_allocator; 209 typedef typename boost::unordered::detail::rebind_wrap <A, bucket>::type bucket_allocator; 210 typedef boost::unordered::detail::allocator_traits <node_allocator> node_allocator_traits; 211 typedef boost::unordered::detail::allocator_traits <bucket_allocator> bucket_allocator_traits; 212 typedef typename node_allocator_traits::pointer node_pointer; 213 typedef typename node_allocator_traits::const_pointer const_node_pointer; 214 typedef typename bucket_allocator_traits::pointer bucket_pointer; 215 typedef boost::unordered::detail::node_constructor <node_allocator> node_constructor; 216 bucket_pointer buckets_; 217 unsigned size_; 218 template <typename Types> 219 buckets (boost::unordered::detail::table <Types>, boost::unordered::detail::move_tag) : buckets_ (), size_ () 220 { 221 } 222 }; 223 struct functions 224 { 225 }; 226 } 227 } 228 namespace detail 229 { 230 template <class Category, class T, class, class, class> 231 struct iterator_base:std::iterator <Category, T> 232 { 233 }; 234 } 235 template <class Category, class T, class Distance, class Pointer = T, class Reference = T> 236 struct iterator:boost::detail::iterator_base <Category, T, Distance, Pointer, Reference> 237 { 238 }; 239 namespace unordered 240 { 241 namespace iterator_detail 242 { 243 template <typename, typename NodePointer, typename Value> struct c_iterator:public boost::iterator <std::forward_iterator_tag, Value, int> 244 { 245 friend bool operator== (c_iterator, c_iterator) 246 { 247 } 248 }; 249 } 250 namespace detail 251 { 252 template <typename ValueType> 253 struct value_base 254 { 255 typedef ValueType value_type; 256 value_type value () 257 { 258 } 259 }; 260 template <typename Types> 261 struct table:boost::unordered::detail::buckets <typename Types::allocator, typename Types::bucket, typename Types::key_equal> 262 { 263 typedef typename Types::value_type value_type; 264 typedef boost::unordered::detail::buckets <typename Types::allocator, typename Types::bucket, typename Types::node> buckets; 265 typedef typename buckets::node_pointer node_pointer; 266 typedef typename buckets::const_node_pointer const_node_pointer; 267 typedef boost::unordered::iterator_detail::c_iterator <const_node_pointer, node_pointer, value_type> c_iterator; 268 unsigned max_size () 269 { 270 } 271 }; 272 template <typename> struct table_impl; 273 template <typename T> 274 struct ptr_node : boost::unordered::detail::value_base <T>, boost::unordered::detail::ptr_bucket 275 { 276 boost::unordered::detail::ptr_bucket bucket_base; 277 unsigned hash_; 278 ptr_node () : bucket_base (), hash_ () 279 { 280 } 281 }; 282 template <typename A, typename T, typename, typename> struct pick_node2 283 { 284 }; 285 template <typename A, typename T> struct pick_node2 <A, T, boost::unordered::detail::ptr_node <T> *, boost::unordered::detail::ptr_bucket *> 286 { 287 typedef boost::unordered::detail::ptr_node <T> node; 288 typedef boost::unordered::detail::ptr_bucket bucket; 289 }; 290 template <typename A, typename T> struct pick_node 291 { 292 typedef boost::unordered::detail::allocator_traits <typename boost::unordered::detail::rebind_wrap <A, boost::unordered::detail::ptr_node <T>>::type> tentative_node_traits; 293 typedef boost::unordered::detail::allocator_traits <typename boost::unordered::detail::rebind_wrap <A, boost::unordered::detail::ptr_bucket>::type> tentative_bucket_traits; 294 typedef pick_node2 <A, T, typename tentative_node_traits::pointer, typename tentative_bucket_traits::pointer> pick; 295 typedef typename pick::node node; 296 typedef typename pick::bucket bucket; 297 }; 298 template <typename A, typename T, typename H, typename P> 299 struct set 300 { 301 typedef boost::unordered::detail::set <A, T, H, P> types; 302 typedef T value_type; 303 typedef P key_equal; 304 typedef typename boost::unordered::detail::rebind_wrap <A, value_type>::type allocator; 305 typedef boost::unordered::detail::pick_node <allocator, value_type> pick; 306 typedef typename pick::node node; 307 typedef typename pick::bucket bucket; 308 typedef boost::unordered::detail::table_impl <types> table; 309 }; 310 template <typename Types> 311 struct table_impl : boost::unordered::detail::table <Types> 312 { 313 typedef boost::unordered::detail::table <Types> table; 314 typedef typename table::node_constructor node_constructor; 315 table_impl () : table () 316 { 317 } 318 template <class InputIt> 319 void insert_range_impl2 (node_constructor, InputIt) 320 { 321 } 322 }; 323 } 324 template <class T, class H, class P, class A> 325 struct unordered_set 326 { 327 typedef T key_type; 328 typedef T value_type; 329 typedef boost::unordered::detail::set <A, T, H, P> types; 330 typedef typename types::table table; 331 typedef typename table::c_iterator const_iterator; 332 typedef typename table::c_iterator iterator; 333 table table_; 334 bool empty () 335 { 336 return table_.size_; 337 } 338 iterator end () 339 { 340 } 341 std::pair <iterator, bool> insert (value_type) 342 { 343 } 344 unsigned erase (const key_type &); 345 const_iterator find (const key_type); 346 }; 347 template <class T, class H, class P, class A> 348 unsigned unordered_set <T, H, P, A>::erase (const key_type &) 349 { 350 } 351 } 352 } 353 using namespace::rtl; 354 namespace skeletonmaker 355 { 356 void 357 checkDefaultInterfaces (boost::unordered_set <OString, OStringHash> interfaces, 358 boost::unordered_set <OStringHash> services, OString) 359 { 360 if (services.empty ()) 361 interfaces.erase ("com.sun.star.lang.XServiceInfo"); 362 else if (interfaces.find ("com.sun.star.lang.XServiceInfo") == interfaces.end ()) 363 interfaces.insert ("com.sun.star.lang.XServiceInfo"); 364 } 365 } 366