mirror of
https://gitee.com/mirrors_PX4/PX4-Autopilot.git
synced 2026-07-01 03:00:35 +08:00
patacongo
23e8d5321a
git-svn-id: http://svn.code.sf.net/p/nuttx/code/trunk@5300 42af7a65-404d-4744-a932-0658087f49c3
270 lines
9.5 KiB
Plaintext
270 lines
9.5 KiB
Plaintext
/* Copyright (C) 2004-2007 Garrett A. Kajmowicz
|
|
* This file is part of the uClibc++ Library.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
*Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
|
|
#include <memory>
|
|
#include <utility>
|
|
#include <iterator>
|
|
#include <associative_base>
|
|
#ifndef __STD_HEADER_MAP
|
|
#define __STD_HEADER_MAP
|
|
|
|
#pragma GCC visibility push(default)
|
|
|
|
extern "C++"
|
|
{
|
|
namespace std
|
|
{
|
|
|
|
template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<T> > class map;
|
|
template<class Key, class T, class Compare = less<Key>, class Allocator = allocator<T> > class multimap;
|
|
|
|
//Compare the keys of the two items
|
|
|
|
/* template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT
|
|
__base_map<Key, T, Compare, Allocator>::value_compare : public binary_function<
|
|
typename map<Key, T, Compare, Allocator>::value_type,
|
|
typename map<Key, T, Compare, Allocator>::value_type,
|
|
bool>
|
|
{
|
|
friend class __base_map<Key, T, Compare, Allocator>;
|
|
protected:
|
|
Compare comp;
|
|
value_compare(Compare c) : comp(c) { }
|
|
~value_compare() { }
|
|
public:
|
|
bool operator()(const value_type& x, const value_type& y) const
|
|
{
|
|
return comp(x.first, y.first);
|
|
}
|
|
};
|
|
*/
|
|
|
|
// value_compare value_comp() const;
|
|
|
|
/* This is the implementation for the map container. As noted above, it deviates
|
|
* from ISO spec by deriving from a base class in order to reduce code redundancy.
|
|
* More code could be reduced by convirting to virtual functions (thus allowing
|
|
* much of the erase and insert code to be duplicated), but that would deviate from
|
|
* the specifications too much to be worth the risk.
|
|
*/
|
|
|
|
//Implementation of map
|
|
|
|
template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT map
|
|
: public __single_associative<Key, pair<Key, T>, Compare, Allocator>
|
|
{
|
|
// Default value of allocator does not meet C++ standard specs, but it works for this library
|
|
// Deal with it
|
|
|
|
public:
|
|
|
|
typedef __single_associative<Key, pair<Key, T>, Compare, Allocator> base;
|
|
typedef T mapped_type;
|
|
typedef typename base::key_type key_type;
|
|
typedef typename base::value_type value_type;
|
|
typedef typename base::key_compare key_compare;
|
|
typedef typename base::allocator_type allocator_type;
|
|
typedef typename base::reference reference;
|
|
typedef typename base::const_reference const_reference;
|
|
typedef typename base::iterator iterator;
|
|
typedef typename base::const_iterator const_iterator;
|
|
typedef typename base::size_type size_type;
|
|
typedef typename base::difference_type difference_type;
|
|
typedef typename base::pointer pointer;
|
|
typedef typename base::const_pointer const_pointer;
|
|
typedef typename base::reverse_iterator reverse_iterator;
|
|
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
|
|
|
static const key_type v_t_k(const value_type v)
|
|
{
|
|
return v.first;
|
|
}
|
|
|
|
// using base::value_compare;
|
|
|
|
explicit map(const Compare& comp = Compare(), const Allocator& al = Allocator())
|
|
: base(comp, al, v_t_k) { }
|
|
|
|
template <class InputIterator> map(InputIterator first, InputIterator last,
|
|
const Compare& comp = Compare(), const Allocator& al = Allocator())
|
|
: base(first, last, comp, al, v_t_k) { }
|
|
|
|
map(const map<Key,T,Compare,Allocator>& x) : base(x) { }
|
|
~map() { }
|
|
|
|
using base::operator=;
|
|
using base::operator==;
|
|
using base::operator!=;
|
|
|
|
using base::insert;
|
|
using base::erase;
|
|
|
|
using base::begin;
|
|
using base::end;
|
|
using base::rbegin;
|
|
using base::rend;
|
|
|
|
using base::empty;
|
|
using base::size;
|
|
using base::max_size;
|
|
|
|
using base::find;
|
|
using base::count;
|
|
using base::lower_bound;
|
|
using base::upper_bound;
|
|
using base::equal_range;
|
|
using base::swap;
|
|
|
|
reference operator[](const key_type& k)
|
|
{
|
|
iterator i = lower_bound(k);
|
|
if (i == end() || base::c(k, i->first))
|
|
{
|
|
i = insert(make_pair(k, T())).first;
|
|
}
|
|
|
|
return i->second;
|
|
}
|
|
|
|
protected:
|
|
using base::backing;
|
|
};
|
|
|
|
// Implementation of multimap
|
|
|
|
template<class Key, class T, class Compare, class Allocator> class _UCXXEXPORT multimap
|
|
: public __multi_associative<Key, pair<Key, T>, Compare, Allocator>
|
|
{
|
|
// Default value of allocator does not meet C++ standard specs, but it works for this library
|
|
// Deal with it
|
|
|
|
public:
|
|
|
|
typedef __multi_associative<Key, pair<Key, T>, Compare, Allocator> base;
|
|
typedef T mapped_type;
|
|
typedef typename base::key_type key_type;
|
|
typedef typename base::value_type value_type;
|
|
typedef typename base::key_compare key_compare;
|
|
typedef typename base::allocator_type allocator_type;
|
|
typedef typename base::reference reference;
|
|
typedef typename base::const_reference const_reference;
|
|
typedef typename base::iterator iterator;
|
|
typedef typename base::const_iterator const_iterator;
|
|
typedef typename base::size_type size_type;
|
|
typedef typename base::difference_type difference_type;
|
|
typedef typename base::pointer pointer;
|
|
typedef typename base::const_pointer const_pointer;
|
|
typedef typename base::reverse_iterator reverse_iterator;
|
|
typedef typename base::const_reverse_iterator const_reverse_iterator;
|
|
|
|
static const key_type v_t_k(const value_type v)
|
|
{
|
|
return v.first;
|
|
}
|
|
|
|
explicit multimap(const Compare& comp = Compare(), const Allocator& al = Allocator())
|
|
: base(comp, al, v_t_k) { }
|
|
|
|
template <class InputIterator> multimap(InputIterator first, InputIterator last,
|
|
const Compare& comp = Compare(), const Allocator& al = Allocator())
|
|
: base(first, last, comp, al, v_t_k) { }
|
|
|
|
multimap(const multimap<Key,T,Compare,Allocator>& x) : base(x) { }
|
|
~multimap() { }
|
|
|
|
using base::operator=;
|
|
using base::operator==;
|
|
using base::operator!=;
|
|
|
|
using base::insert;
|
|
using base::erase;
|
|
|
|
using base::begin;
|
|
using base::end;
|
|
using base::rbegin;
|
|
using base::rend;
|
|
|
|
using base::empty;
|
|
using base::size;
|
|
using base::max_size;
|
|
|
|
using base::find;
|
|
using base::count;
|
|
using base::lower_bound;
|
|
using base::upper_bound;
|
|
using base::equal_range;
|
|
using base::swap;
|
|
|
|
protected:
|
|
|
|
using base::c;
|
|
};
|
|
|
|
/* Non-member functions. These are at the end because they are not associated with any
|
|
* particular class. These will be implemented as I figure out exactly what all of
|
|
* them are supposed to do, and I have time.
|
|
*/
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<
|
|
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator!=
|
|
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>
|
|
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>=
|
|
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<=
|
|
(const map<Key,T,Compare,Allocator>& x, const map<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT void swap
|
|
(map<Key,T,Compare,Allocator>& x, map<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator==
|
|
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<
|
|
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator!=
|
|
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>
|
|
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator>=
|
|
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT bool operator<=
|
|
(const multimap<Key,T,Compare,Allocator>& x, const multimap<Key,T,Compare,Allocator>& y);
|
|
|
|
template <class Key, class T, class Compare, class Allocator> _UCXXEXPORT void swap
|
|
(multimap<Key,T,Compare,Allocator>& x, multimap<Key,T,Compare,Allocator>& y);
|
|
|
|
} // namespace
|
|
} // extern "C++"
|
|
|
|
#pragma GCC visibility pop
|
|
|
|
#endif
|
|
|
|
|