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