p9rs7xtfl
/
p3elvfktj
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'af0933a8ae'
${ noResults }
p3elvfktj/AES/include/set

613 lines
19 KiB
Raw Blame History

// -*- C++ -*-
/***************************************************************************
*
* set - declarations for the Standard Library set class
*
* $Id: set 172106 2011-11-02 17:04:12Z statham $
*
***************************************************************************
*
* Copyright (c) 1994
* Hewlett-Packard Company
*
* Permission to use, copy, modify, distribute and sell this software
* and its documentation for any purpose is hereby granted without fee,
* provided that the above copyright notice appear in all copies and
* that both that copyright notice and this permission notice appear
* in supporting documentation. Hewlett-Packard Company makes no
* representations about the suitability of this software for any
* purpose. It is provided "as is" without express or implied warranty.
*
***************************************************************************
*
* Copyright (c) 1994-2001 Rogue Wave Software, Inc. All Rights Reserved.
*
* This computer software is owned by Rogue Wave Software, Inc. and is
* protected by U.S. copyright laws and other laws and by international
* treaties. This computer software is furnished by Rogue Wave Software,
* Inc. pursuant to a written license agreement and may be used, copied,
* transmitted, and stored only in accordance with the terms of such
* license and with the inclusion of the above copyright notice. This
* computer software or any other copies thereof may not be provided or
* otherwise made available to any other person.
*
* U.S. Government Restricted Rights. This computer software is provided
* with Restricted Rights. Use, duplication, or disclosure by the
* Government is subject to restrictions as set forth in subparagraph (c)
* (1) (ii) of The Rights in Technical Data and Computer Software clause
* at DFARS 252.227-7013 or subparagraphs (c) (1) and (2) of the
* Commercial Computer Software--Restricted Rights at 48 CFR 52.227-19,
* as applicable. Manufacturer is Rogue Wave Software, Inc., 5500
* Flatiron Parkway, Boulder, Colorado 80301 USA.
*
**************************************************************************/
#ifndef _RWSTD_SET_INCLUDED
#define _RWSTD_SET_INCLUDED
#include <memory>
#include <functional>
#include <rw/_tree.h>
#include <rw/_defs.h>
_RWSTD_NAMESPACE_BEGIN (__rw)
//
// This is used in the implementation of set and multiset.
//
template <class _TypeT, class _TypeU>
struct __ident : public _STD::unary_function<_TypeT, _TypeU>
{
const _TypeU& operator() (const _TypeT& __x) const { return __x; }
};
_RWSTD_NAMESPACE_END // __rw
_RWSTD_NAMESPACE_BEGIN (std)
template <class _Key,
class _Compare _RWSTD_COMPLEX_DEFAULT(less<_Key>),
class _Allocator _RWSTD_COMPLEX_DEFAULT(allocator<_Key>) >
class set
{
public:
//
// Types
//
typedef _Key key_type;
typedef _Key value_type;
typedef _Compare key_compare;
typedef _Compare value_compare;
typedef _Allocator allocator_type;
private:
typedef _RW::__rb_tree<key_type, value_type,
_RW::__ident<value_type, key_type>,
key_compare, allocator_type> __rep_type;
__rep_type _C_t;
public:
//
// Types
//
// Note that iterator and reverse_iterator are typedefed to
// const iterators. This is intentional, the purpose is to
// prevent the modification of a set element after it has
// been inserted.
typedef _TYPENAME __rep_type::reference reference;
typedef _TYPENAME __rep_type::const_reference const_reference;
typedef _TYPENAME __rep_type::const_iterator iterator;
typedef _TYPENAME __rep_type::const_iterator const_iterator;
typedef _TYPENAME __rep_type::size_type size_type;
typedef _TYPENAME __rep_type::difference_type difference_type;
typedef _TYPENAME __rep_type::pointer pointer;
typedef _TYPENAME __rep_type::const_pointer const_pointer;
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
typedef _TYPENAME __rep_type::const_reverse_iterator reverse_iterator;
#else
typedef _TYPENAME __rep_type::reverse_iterator reverse_iterator;
#endif
typedef _TYPENAME __rep_type::const_reverse_iterator
const_reverse_iterator;
//
// construct/copy/destroy
//
_EXPLICIT set (const key_compare &__cmp = key_compare (),
const allocator_type &__alloc = allocator_type ())
: _C_t (__cmp, false, __alloc) { }
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class _InputIter>
set (_InputIter __first, _InputIter __last,
const key_compare& __cmp = key_compare(),
const allocator_type& __al = allocator_type())
: _C_t (__cmp, false, __al)
{
for ( ; __first != __last; ++__first)
_C_t.insert(*__first);
}
#else
set (const value_type* __first, const value_type* __last,
const key_compare &__cmp = key_compare (),
const allocator_type& __alloc = allocator_type())
: _C_t (__cmp, false, __alloc)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
set (const_iterator __first, const_iterator __last,
const key_compare &__cmp = key_compare (),
const allocator_type &__alloc = allocator_type())
: _C_t (__cmp, false, __alloc)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
#endif
set (const set &__x)
: _C_t (__x._C_t, false) { }
set& operator= (const set &__x) {
_C_t = __x._C_t; return *this;
}
allocator_type get_allocator() const
{
return _C_t.get_allocator();
}
//
// iterators
//
iterator begin () { return _C_t.begin(); }
const_iterator begin () const { return _C_t.begin(); }
iterator end () { return _C_t.end(); }
const_iterator end () const { return _C_t.end(); }
reverse_iterator rbegin () { return _C_t.rbegin(); }
const_reverse_iterator rbegin () const { return _C_t.rbegin(); }
reverse_iterator rend () { return _C_t.rend(); }
const_reverse_iterator rend () const { return _C_t.rend(); }
//
// capacity
//
bool empty () const { return _C_t.empty(); }
size_type size () const { return _C_t.size(); }
size_type max_size () const { return _C_t.max_size(); }
//
// modifiers
//
pair<iterator, bool> insert (const value_type& __x) {
pair<_TYPENAME __rep_type::iterator, bool> __p = _C_t.insert(__x);
return pair<iterator, bool>(__p.first, __p.second);
}
iterator insert (iterator __it, const value_type& __x)
{
return _C_t.insert (_RWSTD_REINTERPRET_CAST(
_TYPENAME __rep_type::iterator&, __it), __x);
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class _InputIter>
void insert (_InputIter __first, _InputIter __last)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
#else
void insert (const value_type* __first, const value_type* __last)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
void insert (const_iterator __first, const_iterator __last)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
#endif
void erase (iterator __it) {
_C_t.erase(_RWSTD_REINTERPRET_CAST(_TYPENAME __rep_type::iterator&,
__it));
}
size_type erase (const key_type& __x) {
return _C_t.erase(__x);
}
void erase (iterator __first, iterator __last) {
_C_t.erase(_RWSTD_REINTERPRET_CAST(_TYPENAME __rep_type::iterator&,
__first),
_RWSTD_REINTERPRET_CAST(_TYPENAME __rep_type::iterator&,
__last));
}
void swap (set& __x) {
_C_t.swap(__x._C_t);
}
void clear () {
erase(begin(),end());
}
key_compare key_comp () const {
return _C_t.key_comp();
}
value_compare value_comp () const {
return _C_t.key_comp();
}
// follows proposed resolution of lwg issue 214
iterator find (const key_type& __x) {
return _C_t.find (__x);
}
const_iterator find (const key_type& __x) const {
return _C_t.find(__x);
}
size_type count (const key_type& __x) const {
return _C_t.count(__x);
}
// follows proposed resolution of lwg issue 214
iterator lower_bound (const key_type& __x) {
return _C_t.lower_bound(__x);
}
const_iterator lower_bound (const key_type& __x) const {
return _C_t.lower_bound(__x);
}
// follows proposed resolution of lwg issue 214
iterator upper_bound (const key_type& __x) {
return _C_t.upper_bound(__x);
}
const_iterator upper_bound (const key_type& __x) const {
return _C_t.upper_bound(__x);
}
// follows proposed resolution of lwg issue 214
pair<iterator, iterator> equal_range (const key_type& __x) {
return
_RWSTD_REINTERPRET_CAST(const set*,this)->_C_t.equal_range(__x);
}
pair<const_iterator, const_iterator>
equal_range (const key_type& __x) const {
return _C_t.equal_range (__x);
}
};
template <class _Key,
class _Compare _RWSTD_COMPLEX_DEFAULT(less<_Key>),
class _Allocator _RWSTD_COMPLEX_DEFAULT(allocator<_Key>) >
class multiset
{
public:
//
// types
//
typedef _Key key_type;
typedef _Key value_type;
typedef _Compare key_compare;
typedef _Compare value_compare;
typedef _Allocator allocator_type;
private:
typedef _RW::__rb_tree<key_type, value_type,
_RW::__ident<value_type, key_type>,
key_compare, allocator_type> __rep_type;
__rep_type _C_t;
public:
//
// types
//
typedef _TYPENAME __rep_type::reference reference;
typedef _TYPENAME __rep_type::const_reference const_reference;
typedef _TYPENAME __rep_type::iterator iterator;
typedef _TYPENAME __rep_type::const_iterator const_iterator;
typedef _TYPENAME __rep_type::size_type size_type;
typedef _TYPENAME __rep_type::difference_type difference_type;
typedef _TYPENAME __rep_type::pointer pointer;
typedef _TYPENAME __rep_type::const_pointer const_pointer;
typedef _TYPENAME __rep_type::reverse_iterator reverse_iterator;
typedef _TYPENAME __rep_type::const_reverse_iterator
const_reverse_iterator;
//
// construct/copy/destroy
//
_EXPLICIT multiset (const key_compare &__cmp = key_compare (),
const allocator_type &__alloc = allocator_type ())
: _C_t (__cmp, true, __alloc) {}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class _InputIter>
multiset (_InputIter __first, _InputIter __last,
const key_compare &__cmp = key_compare (),
const allocator_type &__alloc = allocator_type ())
: _C_t (__cmp, true, __alloc)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
#else
multiset (const value_type* __first, const value_type* __last,
const key_compare &__cmp = key_compare (),
const allocator_type &__alloc = allocator_type ())
: _C_t (__cmp, true, __alloc)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
multiset (const_iterator __first, const_iterator __last,
const key_compare &__cmp = key_compare (),
const allocator_type &__alloc = allocator_type ())
: _C_t (__cmp, true, __alloc)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
#endif
multiset (const multiset &__x)
: _C_t(__x._C_t, true) { }
multiset& operator= (const multiset &__x) {
_C_t = __x._C_t; return *this;
}
allocator_type get_allocator() const {
return _C_t.get_allocator();
}
//
// iterators
//
iterator begin () { return _C_t.begin(); }
const_iterator begin () const { return _C_t.begin(); }
iterator end () { return _C_t.end(); }
const_iterator end () const { return _C_t.end(); }
reverse_iterator rbegin () { return _C_t.rbegin(); }
const_reverse_iterator rbegin () const { return _C_t.rbegin(); }
reverse_iterator rend () { return _C_t.rend(); }
const_reverse_iterator rend () const { return _C_t.rend(); }
//
// capacity
//
bool empty () const { return _C_t.empty(); }
size_type size () const { return _C_t.size(); }
size_type max_size () const { return _C_t.max_size(); }
//
// modifiers
//
iterator insert (const value_type& __x) { return _C_t.insert(__x).first; }
iterator insert (iterator __it, const value_type& __x)
{
return _C_t.insert(_RWSTD_REINTERPRET_CAST(
_TYPENAME __rep_type::iterator&,__it), __x);
}
#ifndef _RWSTD_NO_MEMBER_TEMPLATES
template<class _InputIter>
void insert (_InputIter __first, _InputIter __last)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
#else
void insert (const value_type* __first, const value_type* __last)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
void insert (const_iterator __first, const_iterator __last)
{
for ( ;__first != __last; ++__first)
_C_t.insert(*__first);
}
#endif
void erase (iterator __it) {
_C_t.erase(_RWSTD_REINTERPRET_CAST(_TYPENAME __rep_type::iterator&,
__it));
}
size_type erase (const key_type& __x) { return _C_t.erase(__x); }
void erase (iterator __first, iterator __last)
{
_C_t.erase(_RWSTD_REINTERPRET_CAST(_TYPENAME __rep_type::iterator&,
__first),
_RWSTD_REINTERPRET_CAST(_TYPENAME __rep_type::iterator&,
__last));
}
void swap (multiset &__x) {
_C_t.swap(__x._C_t);
}
void clear () { erase(begin(),end()); }
//
// observers
//
key_compare key_comp () const { return _C_t.key_comp(); }
value_compare value_comp () const { return _C_t.key_comp(); }
// follows proposed resolution of lwg issue 214
iterator find (const key_type& __x) {
return _C_t.find(__x);
}
const_iterator find (const key_type& __x) const {
return _C_t.find(__x);
}
size_type count (const key_type& __x) const {
return _C_t.count(__x);
}
// follows proposed resolution of lwg issue 214
iterator lower_bound (const key_type& __x) {
return _C_t.lower_bound(__x);
}
const_iterator lower_bound (const key_type& __x) const {
return _C_t.lower_bound(__x);
}
// follows proposed resolution of lwg issue 214
iterator upper_bound (const key_type& __x) {
return _C_t.upper_bound(__x);
}
const_iterator upper_bound (const key_type& __x) const {
return _C_t.upper_bound(__x);
}
// follows proposed resolution of lwg issue 214
pair<iterator, iterator> equal_range (const key_type& __x) {
return _C_t.equal_range(__x);
}
pair<const_iterator,const_iterator> equal_range (const key_type& __x) const {
return _C_t.equal_range(__x);
}
};
template <class _Key, class _Compare, class _Allocator>
inline bool operator== (const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
{
return __x.size() == __y.size() && equal(__x.begin(), __x.end(),
__y.begin());
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator< (const set<_Key, _Compare, _Allocator>& __x,
const set<_Key, _Compare, _Allocator>& __y)
{
return lexicographical_compare(__x.begin(), __x.end(), __y.begin(),
__y.end());
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator!= (const set<_Key,_Compare,_Allocator>& __x,
const set<_Key,_Compare,_Allocator>& __y)
{
return !(__x == __y);
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator> (const set<_Key,_Compare,_Allocator>& __x,
const set<_Key,_Compare,_Allocator>& __y)
{
return __y < __x;
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator>= (const set<_Key,_Compare,_Allocator>& __x,
const set<_Key,_Compare,_Allocator>& __y)
{
return !(__x < __y);
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator<= (const set<_Key,_Compare,_Allocator>& __x,
const set<_Key,_Compare,_Allocator>& __y)
{
return !(__y < __x);
}
#ifndef _RWSTD_NO_PART_SPEC_OVERLOAD
template <class _Key, class _Compare, class _Allocator>
void swap(set<_Key,_Compare,_Allocator>& __a,
set<_Key,_Compare,_Allocator>& __b)
{
__a.swap(__b);
}
#endif
template <class _Key, class _Compare, class _Allocator>
inline bool operator== (const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
{
return __x.size() == __y.size() && equal(__x.begin(), __x.end(),
__y.begin());
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator< (const multiset<_Key, _Compare, _Allocator>& __x,
const multiset<_Key, _Compare, _Allocator>& __y)
{
return lexicographical_compare(__x.begin(), __x.end(), __y.begin(),
__y.end());
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator!= (const multiset<_Key,_Compare,_Allocator>& __x,
const multiset<_Key,_Compare,_Allocator>& __y)
{
return !(__x == __y);
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator> (const multiset<_Key,_Compare,_Allocator>& __x,
const multiset<_Key,_Compare,_Allocator>& __y)
{
return __y < __x;
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator>= (const multiset<_Key,_Compare,_Allocator>& __x,
const multiset<_Key,_Compare,_Allocator>& __y)
{
return !(__x < __y);
}
template <class _Key, class _Compare, class _Allocator>
inline bool operator<= (const multiset<_Key,_Compare,_Allocator>& __x,
const multiset<_Key,_Compare,_Allocator>& __y)
{
return !(__y < __x);
}
#if !defined(_RWSTD_NO_PART_SPEC_OVERLOAD)
template <class _Key, class _Compare, class _Allocator>
void swap(multiset<_Key,_Compare,_Allocator>& __a,
multiset<_Key,_Compare,_Allocator>& __b)
{
__a.swap(__b);
}
#endif
_RWSTD_NAMESPACE_END // std
#endif // _RWSTD_SET_INCLUDED
Reference in new issue View Git Blame Copy Permalink