00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00039 #ifndef BLOCXX_MAP_HPP_INCLUDE_GUARD_
00040 #define BLOCXX_MAP_HPP_INCLUDE_GUARD_
00041 #include "blocxx/BLOCXX_config.h"
00042 #include "blocxx/COWReference.hpp"
00043 #include <map>
00044 #include <functional>
00045
00046
00047 namespace BLOCXX_NAMESPACE
00048 {
00049
00050
00051
00052 template<class Key, class T, class Compare > class Map;
00053
00054 template<class Key, class T, class Compare>
00055 inline bool operator==(const Map<Key, T, Compare>& x,
00056 const Map<Key, T, Compare>& y);
00057
00058 template<class Key, class T, class Compare>
00059 inline bool operator<(const Map<Key, T, Compare>& x,
00060 const Map<Key, T, Compare>& y);
00061
00062
00063 template<class Key, class T, class Compare = std::less<Key> > class Map
00064 {
00065 typedef std::map<Key, T, Compare > M;
00066 COWReference<M> m_impl;
00067 public:
00068 typedef typename M::key_type key_type;
00069 typedef typename M::mapped_type mapped_type;
00070 typedef typename M::value_type value_type;
00071 typedef typename M::key_compare key_compare;
00072 typedef typename M::value_compare value_compare;
00073 typedef typename M::pointer pointer;
00074 typedef typename M::const_pointer const_pointer;
00075 typedef typename M::reference reference;
00076 typedef typename M::const_reference const_reference;
00077 typedef typename M::iterator iterator;
00078 typedef typename M::const_iterator const_iterator;
00079 typedef typename M::reverse_iterator reverse_iterator;
00080 typedef typename M::const_reverse_iterator const_reverse_iterator;
00081 typedef typename M::size_type size_type;
00082 typedef typename M::difference_type difference_type;
00083 Map() : m_impl(new M) { }
00084 explicit Map(M* toWrap) : m_impl(toWrap)
00085 { }
00086 explicit Map(const Compare& comp)
00087 : m_impl(new M(comp)) { }
00088 template <class InputIterator>
00089 Map(InputIterator first, InputIterator last) :
00090 m_impl(new M(first, last))
00091 {
00092 }
00093 template <class InputIterator>
00094 Map(InputIterator first, InputIterator last, const Compare& comp) :
00095 m_impl(new M(first, last, comp))
00096 {
00097 }
00098 M* getImpl()
00099 {
00100 return &*m_impl;
00101 }
00102 key_compare key_comp() const
00103 {
00104 return m_impl->key_comp();
00105 }
00106 value_compare value_comp() const
00107 {
00108 return m_impl->value_comp();
00109 }
00110 iterator begin()
00111 {
00112 return m_impl->begin();
00113 }
00114 const_iterator begin() const
00115 {
00116 return m_impl->begin();
00117 }
00118 iterator end()
00119 {
00120 return m_impl->end();
00121 }
00122 const_iterator end() const
00123 {
00124 return m_impl->end();
00125 }
00126 reverse_iterator rbegin()
00127 {
00128 return m_impl->rbegin();
00129 }
00130 const_reverse_iterator rbegin() const
00131 {
00132 return m_impl->rbegin();
00133 }
00134 reverse_iterator rend()
00135 {
00136 return m_impl->rend();
00137 }
00138 const_reverse_iterator rend() const
00139 {
00140 return m_impl->rend();
00141 }
00142 bool empty() const
00143 {
00144 return m_impl->empty();
00145 }
00146 size_type size() const
00147 {
00148 return m_impl->size();
00149 }
00150 size_type max_size() const
00151 {
00152 return m_impl->max_size();
00153 }
00154 T& operator[](const key_type& k)
00155 {
00156 return m_impl->operator[](k);
00157 }
00158 void swap(Map<Key, T, Compare>& x)
00159 {
00160 m_impl.swap(x.m_impl);
00161 }
00162 std::pair<iterator, bool> insert(const value_type& x)
00163 {
00164 return m_impl->insert(x);
00165 }
00166 iterator insert(iterator position, const value_type& x)
00167 {
00168 return m_impl->insert(position, x);
00169 }
00170 template <class InputIterator>
00171 void insert(InputIterator first, InputIterator last)
00172 {
00173 m_impl->insert(first, last);
00174 }
00175 void erase(iterator position)
00176 {
00177 m_impl->erase(position);
00178 }
00179 size_type erase(const key_type& x)
00180 {
00181 return m_impl->erase(x);
00182 }
00183 void erase(iterator first, iterator last)
00184 {
00185 m_impl->erase(first, last);
00186 }
00187 void clear()
00188 {
00189 m_impl->clear();
00190 }
00191 iterator find(const key_type& x)
00192 {
00193 return m_impl->find(x);
00194 }
00195 const_iterator find(const key_type& x) const
00196 {
00197 return m_impl->find(x);
00198 }
00199 size_type count(const key_type& x) const
00200 {
00201 return m_impl->count(x);
00202 }
00203 iterator lower_bound(const key_type& x)
00204 {
00205 return m_impl->lower_bound(x);
00206 }
00207 const_iterator lower_bound(const key_type& x) const
00208 {
00209 return m_impl->lower_bound(x);
00210 }
00211 iterator upper_bound(const key_type& x)
00212 {
00213 return m_impl->upper_bound(x);
00214 }
00215 const_iterator upper_bound(const key_type& x) const
00216 {
00217 return m_impl->upper_bound(x);
00218 }
00219 std::pair<iterator, iterator> equal_range(const key_type& x)
00220 {
00221 return m_impl->equal_range(x);
00222 }
00223 std::pair<const_iterator, const_iterator>
00224 equal_range(const key_type& x) const
00225 {
00226 return m_impl->equal_range(x);
00227 }
00228 friend bool operator== <>(const Map<Key, T, Compare>& x,
00229 const Map<Key, T, Compare>& y);
00230 friend bool operator< <>(const Map<Key, T, Compare>& x,
00231 const Map<Key, T, Compare>& y);
00232 };
00233 template <class Key, class T, class Compare>
00234 std::map<Key, T, Compare>* COWReferenceClone(std::map<Key, T, Compare>* obj)
00235 {
00236 return new std::map<Key, T, Compare>(*obj);
00237 }
00238 template<class Key, class T, class Compare>
00239 inline bool operator==(const Map<Key, T, Compare>& x,
00240 const Map<Key, T, Compare>& y)
00241 {
00242 return *x.m_impl == *y.m_impl;
00243 }
00244 template<class Key, class T, class Compare>
00245 inline bool operator<(const Map<Key, T, Compare>& x,
00246 const Map<Key, T, Compare>& y)
00247 {
00248 return *x.m_impl < *y.m_impl;
00249 }
00250 template <class Key, class T, class Compare>
00251 inline void swap(Map<Key, T, Compare>& x,
00252 Map<Key, T, Compare>& y)
00253 {
00254 x.swap(y);
00255 }
00256
00257 }
00258
00259 #endif