← Back to branch summary

~ubuntu-branches/ubuntu/vivid/emscripten/vivid-proposed

« back to all changes in this revision

Viewing changes to system/include/libcxx/unordered_set

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2014-01-19 14:12:40 UTC
  • mfrom: (4.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20140119141240-nfiw0p8033oitpfz
Tags: 1.9.0~20140119~7dc8c2f-1
http://bugs.debian.org/733714
http://bugs.debian.org/735903
* New snapshot release (Closes: #733714)
* Provide sources for javascript and flash. Done in orig-tar.sh
  Available in third_party/websockify/include/web-socket-js/src/
  (Closes: #735903)

Show diffs side-by-side

added added

removed removed

Lines of Context:
system/include/libcxx/unordered_set
68
68
    unordered_set(initializer_list<value_type>, size_type n = 0,
69
69
                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
70
70
                  const allocator_type& a = allocator_type());
 
71
    unordered_set(size_type n, const allocator_type& a); // C++14
 
72
    unordered_set(size_type n, const hasher& hf, const allocator_type& a); // C++14
 
73
    template <class InputIterator>
 
74
      unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
 
75
    template <class InputIterator>
 
76
      unordered_set(InputIterator f, InputIterator l, size_type n, 
 
77
                    const hasher& hf,  const allocator_type& a); // C++14
 
78
    unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
 
79
    unordered_set(initializer_list<value_type> il, size_type n,
 
80
                  const hasher& hf,  const allocator_type& a); // C++14
71
81
    ~unordered_set();
72
82
    unordered_set& operator=(const unordered_set&);
73
83
    unordered_set& operator=(unordered_set&&)
207
217
    unordered_multiset(initializer_list<value_type>, size_type n = /see below/,
208
218
                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
209
219
                  const allocator_type& a = allocator_type());
 
220
    unordered_multiset(size_type n, const allocator_type& a); // C++14
 
221
    unordered_multiset(size_type n, const hasher& hf, const allocator_type& a); // C++14
 
222
    template <class InputIterator>
 
223
      unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14
 
224
    template <class InputIterator>
 
225
      unordered_multiset(InputIterator f, InputIterator l, size_type n,
 
226
                         const hasher& hf, const allocator_type& a); // C++14
 
227
    unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14
 
228
    unordered_multiset(initializer_list<value_type> il, size_type n, 
 
229
                       const hasher& hf,  const allocator_type& a); // C++14
210
230
    ~unordered_multiset();
211
231
    unordered_multiset& operator=(const unordered_multiset&);
212
232
    unordered_multiset& operator=(unordered_multiset&&)
313
333
 
314
334
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
315
335
          class _Alloc = allocator<_Value> >
316
 
class _LIBCPP_TYPE_VIS unordered_set
 
336
class _LIBCPP_TYPE_VIS_ONLY unordered_set
317
337
{
318
338
public:
319
339
    // types
353
373
        }
354
374
    explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
355
375
                           const key_equal& __eql = key_equal());
 
376
#if _LIBCPP_STD_VER > 11
 
377
    inline _LIBCPP_INLINE_VISIBILITY
 
378
    unordered_set(size_type __n, const allocator_type& __a)
 
379
        : unordered_set(__n, hasher(), key_equal(), __a) {}
 
380
    inline _LIBCPP_INLINE_VISIBILITY
 
381
    unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a)
 
382
        : unordered_set(__n, __hf, key_equal(), __a) {}
 
383
#endif
356
384
    unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
357
385
                  const allocator_type& __a);
358
386
    template <class _InputIterator>
365
393
        unordered_set(_InputIterator __first, _InputIterator __last,
366
394
                      size_type __n, const hasher& __hf, const key_equal& __eql,
367
395
                      const allocator_type& __a);
 
396
#if _LIBCPP_STD_VER > 11
 
397
    template <class _InputIterator>
 
398
    inline _LIBCPP_INLINE_VISIBILITY
 
399
        unordered_set(_InputIterator __first, _InputIterator __last, 
 
400
                    size_type __n, const allocator_type& __a)
 
401
            : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {}
 
402
    template <class _InputIterator>
 
403
        unordered_set(_InputIterator __first, _InputIterator __last, 
 
404
                      size_type __n, const hasher& __hf, const allocator_type& __a)
 
405
            : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}
 
406
#endif
368
407
    explicit unordered_set(const allocator_type& __a);
369
408
    unordered_set(const unordered_set& __u);
370
409
    unordered_set(const unordered_set& __u, const allocator_type& __a);
381
420
    unordered_set(initializer_list<value_type> __il, size_type __n,
382
421
                  const hasher& __hf, const key_equal& __eql,
383
422
                  const allocator_type& __a);
 
423
#if _LIBCPP_STD_VER > 11
 
424
    inline _LIBCPP_INLINE_VISIBILITY
 
425
    unordered_set(initializer_list<value_type> __il, size_type __n,
 
426
                                                      const allocator_type& __a)
 
427
        : unordered_set(__il, __n, hasher(), key_equal(), __a) {}
 
428
    inline _LIBCPP_INLINE_VISIBILITY
 
429
    unordered_set(initializer_list<value_type> __il, size_type __n, 
 
430
                                  const hasher& __hf, const allocator_type& __a)
 
431
        : unordered_set(__il, __n, __hf, key_equal(), __a) {}
 
432
#endif
384
433
#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
385
434
    // ~unordered_set() = default;
386
435
    _LIBCPP_INLINE_VISIBILITY
819
868
 
820
869
template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
821
870
          class _Alloc = allocator<_Value> >
822
 
class _LIBCPP_TYPE_VIS unordered_multiset
 
871
class _LIBCPP_TYPE_VIS_ONLY unordered_multiset
823
872
{
824
873
public:
825
874
    // types
861
910
                                const key_equal& __eql = key_equal());
862
911
    unordered_multiset(size_type __n, const hasher& __hf,
863
912
                       const key_equal& __eql, const allocator_type& __a);
 
913
#if _LIBCPP_STD_VER > 11
 
914
    inline _LIBCPP_INLINE_VISIBILITY
 
915
    unordered_multiset(size_type __n, const allocator_type& __a)
 
916
        : unordered_multiset(__n, hasher(), key_equal(), __a) {}
 
917
    inline _LIBCPP_INLINE_VISIBILITY
 
918
    unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a)
 
919
        : unordered_multiset(__n, __hf, key_equal(), __a) {}
 
920
#endif
864
921
    template <class _InputIterator>
865
922
        unordered_multiset(_InputIterator __first, _InputIterator __last);
866
923
    template <class _InputIterator>
871
928
        unordered_multiset(_InputIterator __first, _InputIterator __last,
872
929
                      size_type __n , const hasher& __hf,
873
930
                      const key_equal& __eql, const allocator_type& __a);
 
931
#if _LIBCPP_STD_VER > 11
 
932
    template <class _InputIterator>
 
933
    inline _LIBCPP_INLINE_VISIBILITY
 
934
    unordered_multiset(_InputIterator __first, _InputIterator __last, 
 
935
                       size_type __n, const allocator_type& __a)
 
936
        : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {}
 
937
    template <class _InputIterator>
 
938
    inline _LIBCPP_INLINE_VISIBILITY
 
939
    unordered_multiset(_InputIterator __first, _InputIterator __last,
 
940
                       size_type __n, const hasher& __hf, const allocator_type& __a)
 
941
        : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}
 
942
#endif
874
943
    explicit unordered_multiset(const allocator_type& __a);
875
944
    unordered_multiset(const unordered_multiset& __u);
876
945
    unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
887
956
    unordered_multiset(initializer_list<value_type> __il, size_type __n,
888
957
                       const hasher& __hf, const key_equal& __eql,
889
958
                       const allocator_type& __a);
 
959
#if _LIBCPP_STD_VER > 11
 
960
    inline _LIBCPP_INLINE_VISIBILITY
 
961
    unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a)
 
962
      : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {}
 
963
    inline _LIBCPP_INLINE_VISIBILITY
 
964
    unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a)
 
965
      : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}
 
966
#endif
890
967
#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
891
968
    // ~unordered_multiset() = default;
892
969
    _LIBCPP_INLINE_VISIBILITY