| blob | 2ea2f9c4d1bdce8065367ec6a8ae053e94039427 |
1 // { dg-do compile }
3 namespace 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 }
10 namespace std __attribute__ ((__visibility__ ("default"))) {
11 }
12 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
13 }
14 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
15 template<typename _Tp> class new_allocator {
16 };
17 }
18 namespace 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 }
26 namespace std {
27 }
28 namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) {
29 }
30 namespace 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 }
44 extern "C" {
45 }
46 namespace 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 }
124 namespace gloox {
125 class Tag {
126 };
127 class StanzaExtension {
128 };
129 }
130 namespace gloox {
131 }
132 using namespace gloox;
133 class AbstractPurpleRequest {
134 };
135 class AdhocCommandHandler : public AbstractPurpleRequest {
136 };
137 class AdhocTag : public Tag {
138 };
139 class AbstractConfigInterfaceHandler {
140 };
141 namespace 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 }
156 enum {
157 SORT_BY_JID, SORT_BY_UIN, SORT_BY_BUDDIES, };
158 struct SortData {
159 };
160 struct ListData {
161 std::list<SortData> output;
162 int sort_by;
163 };
164 class 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 };
170 namespace gloox {
171 }
172 static bool compareIDataASC(SortData &a, SortData &b) {
173 }
174 AdhocTag *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 }