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