1// { dg-do compile }
2
3namespace std {
4    typedef long unsigned int size_t;
5    template<typename>     class allocator;
6    template<class _CharT>     struct char_traits;
7    template<typename _CharT, typename _Traits = char_traits<_CharT>,            typename _Alloc = allocator<_CharT> >     class basic_string;
8    typedef basic_string<char> string;
9}
10namespace std __attribute__ ((__visibility__ ("default"))) {
11}
12namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
13}
14namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
15    template<typename _Tp>     class new_allocator     {
16    };
17}
18namespace std __attribute__ ((__visibility__ ("default"))) {
19    template<typename _Tp>     class allocator: public __gnu_cxx::new_allocator<_Tp>     {
20    public:
21	template<typename _Tp1>         struct rebind         {
22	    typedef allocator<_Tp1> other;
23	};
24    };
25}
26namespace std {
27}
28namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
29}
30namespace std __attribute__ ((__visibility__ ("default"))) {
31    template<typename _CharT, typename _Traits, typename _Alloc>     class basic_string     {
32	struct _Alloc_hider : _Alloc       {
33	    _Alloc_hider(_CharT* __dat, const _Alloc& __a)  : _Alloc(__a), _M_p(__dat) {
34	    }
35	    _CharT* _M_p;
36	};
37	mutable _Alloc_hider _M_dataplus;
38    public:
39	basic_string(const _CharT* __s, const _Alloc& __a = _Alloc());
40    };
41    template<typename _CharT, typename _Traits, typename _Alloc>     inline bool     operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs,         const _CharT* __rhs)     {
42    }
43}
44extern "C" {
45}
46namespace std __attribute__ ((__visibility__ ("default"))) {
47    namespace __detail   {
48	struct _List_node_base     {
49	    _List_node_base* _M_next;
50	};
51    }
52    template<typename _Tp>     struct _List_node : public __detail::_List_node_base     {
53    };
54    template<typename _Tp>     struct _List_iterator     {
55	typedef _List_iterator<_Tp> _Self;
56	typedef _Tp& reference;
57	reference       operator*() const       {
58	}
59	bool       operator!=(const _Self& __x) const       {
60	}
61    };
62    template<typename _Tp, typename _Alloc>     class _List_base     {
63    protected:
64	typedef typename _Alloc::template rebind<_List_node<_Tp> >::other         _Node_alloc_type;
65	struct _List_impl       : public _Node_alloc_type       {
66	    __detail::_List_node_base _M_node;
67	    _List_impl()  : _Node_alloc_type(), _M_node()  {
68	    }
69	    _List_impl(const _Node_alloc_type& __a)  : _Node_alloc_type(__a), _M_node()  {
70	    }
71	};
72	_List_impl _M_impl;
73	~_List_base()       {
74	}
75	void       _M_clear();
76    };
77    template<typename _Tp, typename _Alloc = std::allocator<_Tp> >     class list : protected _List_base<_Tp, _Alloc>     {
78	typedef _List_iterator<_Tp> iterator;
79	typedef size_t size_type;
80    public:
81	iterator       begin()       {
82	}
83	iterator       end()       {
84	}
85	bool       empty() const       {
86	}
87	size_type       size() const       {
88	}
89	void       swap(list& __x)       {
90	}
91	template<typename _StrictWeakOrdering>         void         merge(list& __x, _StrictWeakOrdering __comp);
92	template<typename _StrictWeakOrdering>         void         sort(_StrictWeakOrdering);
93    };
94    template<typename _Tp, typename _Alloc>     template <typename _StrictWeakOrdering>       void       list<_Tp, _Alloc>::       merge(list& __x, _StrictWeakOrdering __comp)       {
95	if (this != &__x)    {
96	    iterator __first1 = begin();
97	    iterator __last1 = end();
98	    iterator __first2 = __x.begin();
99	    iterator __last2 = __x.end();
100	    while (__first1 != __last1 && __first2 != __last2)        if (__comp(*__first2, *__first1))   {
101		iterator __next = __first2;
102		__first2 = __next;
103	    }
104	}
105    }
106    template<typename _Tp, typename _Alloc>     template <typename _StrictWeakOrdering>       void       list<_Tp, _Alloc>::       sort(_StrictWeakOrdering __comp)       {
107	if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node      && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node)    {
108	    list __carry;
109	    list __tmp[64];
110	    list * __fill = &__tmp[0];
111	    list * __counter;
112	    do        {
113		for(__counter = &__tmp[0];
114		    __counter != __fill && !__counter->empty();
115		    ++__counter)     {       __counter->merge(__carry, __comp);       __carry.swap(*__counter);     }
116	    }
117	    while ( !empty() );
118	    for (__counter = &__tmp[1];
119		 __counter != __fill;
120		 ++__counter)        __counter->merge(*(__counter - 1), __comp);
121	}
122    }
123}
124namespace gloox {
125    class Tag   {
126    };
127    class StanzaExtension   {
128    };
129}
130namespace gloox {
131}
132using namespace gloox;
133class AbstractPurpleRequest {
134};
135class AdhocCommandHandler : public AbstractPurpleRequest {
136};
137class AdhocTag : public Tag {
138};
139class AbstractConfigInterfaceHandler {
140};
141namespace gloox {
142    class DataFormField   {
143    public:
144	const std::string& value() const {
145	}
146    };
147    class DataFormFieldContainer   {
148    public:
149	bool hasField( const std::string& field ) const         {
150	}
151	DataFormField* field( const std::string& field ) const;
152    };
153    class DataForm : public StanzaExtension, public DataFormFieldContainer   {
154    };
155}
156enum {
157    SORT_BY_JID,  SORT_BY_UIN,  SORT_BY_BUDDIES, };
158struct SortData {
159};
160struct ListData {
161    std::list<SortData> output;
162    int sort_by;
163};
164class AdhocAdmin : public AdhocCommandHandler, public AbstractConfigInterfaceHandler {
165    AdhocTag *handleAdhocTag(Tag *stanzaTag);
166    AdhocTag *handleUnregisterUserForm(Tag *tag, const DataForm &form);
167    AdhocTag *handleListUsersForm(Tag *tag, const DataForm &form);
168    ListData m_listUsersData;
169};
170namespace gloox {
171}
172static bool compareIDataASC(SortData &a, SortData &b) {
173}
174AdhocTag *AdhocAdmin::handleListUsersForm(Tag *tag, const DataForm &form) {
175    ListData &data = m_listUsersData;
176    if (data.output.size() == 0) {
177	if (!form.hasField("users_vip") || !form.hasField("show_jid") || !form.hasField("show_uin")    || !form.hasField("show_buddies") || !form.hasField("show_sort_by") || !form.hasField("show_sort_order")    || !form.hasField("show_max_per_page")   ) {
178	}
179	bool sort_asc = form.field("show_sort_order")->value() == "asc";
180	if (data.sort_by == SORT_BY_BUDDIES) {
181	    if (sort_asc)     data.output.sort(compareIDataASC);
182	}
183	else {
184	}
185    }
186}
187