00001
00002
00003 #ifndef ACE_ARRAY_MAP_CPP
00004 #define ACE_ARRAY_MAP_CPP
00005
00006 #include "ace/Array_Map.h"
00007
00008 #ifndef __ACE_INLINE__
00009 # include "ace/Array_Map.inl"
00010 #endif
00011
00012 #include "ace/checked_iterator.h"
00013
00014 #include <algorithm>
00015
00016 ACE_BEGIN_VERSIONED_NAMESPACE_DECL
00017
00018 #ifndef ACE_LACKS_MEMBER_TEMPLATES
00019 template<typename Key, typename Value, class EqualTo>
00020 template<typename InputIterator>
00021 ACE_Array_Map<Key, Value, EqualTo>::ACE_Array_Map (InputIterator f,
00022 InputIterator l)
00023 : size_ (l - f)
00024 , capacity_ (size_)
00025 , nodes_ (size_ == 0 ? 0 : new value_type[size_])
00026 {
00027 (void) std::copy (f,
00028 l,
00029 ACE_make_checked_array_iterator (this->begin (),
00030 this->size_));
00031
00032
00033
00034
00035
00036 }
00037 #else
00038 template<typename Key, typename Value, class EqualTo>
00039 ACE_Array_Map<Key, Value, EqualTo>::ACE_Array_Map (
00040 typename ACE_Array_Map<Key, Value, EqualTo>::const_iterator f,
00041 typename ACE_Array_Map<Key, Value, EqualTo>::const_iterator l)
00042 : size_ (l - f)
00043 , capacity_ (size_)
00044 , nodes_ (size_ == 0 ? 0 : new value_type[size_])
00045 {
00046 (void) std::copy (f,
00047 l,
00048 ACE_make_checked_array_iterator (this->begin (),
00049 this->size_));
00050
00051
00052
00053
00054
00055 }
00056 #endif
00057
00058 template<typename Key, typename Value, class EqualTo>
00059 ACE_Array_Map<Key, Value, EqualTo>::ACE_Array_Map (
00060 ACE_Array_Map<Key, Value, EqualTo> const & map)
00061 : size_ (map.size_)
00062 , capacity_ (map.size_)
00063 , nodes_ (size_ == 0 ? 0 : new value_type[size_])
00064 {
00065 std::copy (map.begin (),
00066 map.end (),
00067 ACE_make_checked_array_iterator (this->begin (),
00068 this->size_));
00069
00070
00071
00072
00073
00074
00075
00076 }
00077
00078 template<typename Key, typename Value, class EqualTo>
00079 ACE_Array_Map<Key, Value, EqualTo>::~ACE_Array_Map (void)
00080 {
00081 delete[] this->nodes_;
00082 }
00083
00084 template<typename Key, typename Value, class EqualTo>
00085 void
00086 ACE_Array_Map<Key, Value, EqualTo>::swap (
00087 ACE_Array_Map<Key, Value, EqualTo> & map)
00088 {
00089 std::swap (this->size_, map.size_);
00090 std::swap (this->capacity_, map.capacity_);
00091 std::swap (this->nodes_, map.nodes_);
00092 }
00093
00094 template<typename Key, typename Value, class EqualTo>
00095 std::pair<typename ACE_Array_Map<Key, Value, EqualTo>::iterator, bool>
00096 ACE_Array_Map<Key, Value, EqualTo>::insert (
00097 typename ACE_Array_Map<Key, Value, EqualTo>::value_type const & x)
00098 {
00099
00100
00101 bool inserted = false;
00102 iterator i = this->find (x.first);
00103
00104 if (i == this->end ())
00105 {
00106
00107
00108 size_type const old_size = this->size ();
00109 this->grow (1);
00110
00111 i = this->begin () + old_size;
00112 *i = x;
00113
00114 ++this->size_;
00115
00116 inserted = true;
00117 }
00118
00119 return std::make_pair (i, inserted);
00120 }
00121
00122 #ifndef ACE_LACKS_MEMBER_TEMPLATES
00123 template<typename Key, typename Value, class EqualTo>
00124 template<typename InputIterator>
00125 void
00126 ACE_Array_Map<Key, Value, EqualTo>::insert (InputIterator f, InputIterator l)
00127 {
00128 this->grow (l - f);
00129
00130 for (InputIterator i = f; i != l; ++i)
00131 {
00132 (void) this->insert (*i);
00133 }
00134 }
00135 #else
00136 template<typename Key, typename Value, class EqualTo>
00137 void
00138 ACE_Array_Map<Key, Value, EqualTo>::insert (
00139 typename ACE_Array_Map<Key, Value, EqualTo>::const_iterator f,
00140 typename ACE_Array_Map<Key, Value, EqualTo>::const_iterator l)
00141 {
00142 this->grow (l - f);
00143
00144 for (const_iterator i = f; i != l; ++i)
00145 {
00146 (void) this->insert (*i);
00147 }
00148 }
00149 #endif
00150
00151 template<typename Key, typename Value, class EqualTo>
00152 void
00153 ACE_Array_Map<Key, Value, EqualTo>::erase (
00154 typename ACE_Array_Map<Key, Value, EqualTo>::iterator pos)
00155 {
00156 iterator const first = this->begin ();
00157 iterator const last = this->end ();
00158
00159 if (pos >= first && pos < last)
00160 {
00161 if (pos != last - 1)
00162 {
00163
00164
00165
00166 *pos = *(last - 1);
00167 }
00168
00169
00170
00171
00172 *(last - 1) = value_type ();
00173
00174 --this->size_;
00175 }
00176 }
00177
00178 template<typename Key, typename Value, class EqualTo>
00179 typename ACE_Array_Map<Key, Value, EqualTo>::size_type
00180 ACE_Array_Map<Key, Value, EqualTo>::erase (
00181 typename ACE_Array_Map<Key, Value, EqualTo>::key_type const & k)
00182 {
00183 iterator pos = this->find (k);
00184
00185 size_type const old_size = this->size_;
00186
00187 this->erase (pos);
00188
00189 return old_size - this->size_;
00190 }
00191
00192 template<typename Key, typename Value, class EqualTo>
00193 void
00194 ACE_Array_Map<Key, Value, EqualTo>::erase (
00195 typename ACE_Array_Map<Key, Value, EqualTo>::iterator first,
00196 typename ACE_Array_Map<Key, Value, EqualTo>::iterator last)
00197 {
00198 if (this->begin () <= first && first < last && last < this->end ())
00199 for (iterator i = first; i != last; ++i)
00200 this->erase (i);
00201 }
00202
00203 template<typename Key, typename Value, class EqualTo>
00204 void
00205 ACE_Array_Map<Key, Value, EqualTo>::clear (void)
00206 {
00207 this->size_ = 0;
00208 }
00209
00210 template<typename Key, typename Value, class EqualTo>
00211 typename ACE_Array_Map<Key, Value, EqualTo>::iterator
00212 ACE_Array_Map<Key, Value, EqualTo>::find (
00213 typename ACE_Array_Map<Key, Value, EqualTo>::key_type const & k)
00214 {
00215 iterator const the_end = this->end ();
00216
00217 EqualTo eq;
00218
00219 for (iterator i = this->begin (); i != the_end; ++i)
00220 if (eq (k, i->first))
00221 return i;
00222
00223 return this->end ();
00224 }
00225
00226 template<typename Key, typename Value, class EqualTo>
00227 typename ACE_Array_Map<Key, Value, EqualTo>::const_iterator
00228 ACE_Array_Map<Key, Value, EqualTo>::find (
00229 typename ACE_Array_Map<Key, Value, EqualTo>::key_type const & k) const
00230 {
00231 const_iterator const the_end = this->end ();
00232
00233 EqualTo eq;
00234
00235 for (const_iterator i = this->begin (); i != the_end; ++i)
00236 if (eq (k, i->first))
00237 return i;
00238
00239 return this->end ();
00240 }
00241
00242 template<typename Key, typename Value, class EqualTo>
00243 void
00244 ACE_Array_Map<Key, Value, EqualTo>::grow (
00245 typename ACE_Array_Map<Key, Value, EqualTo>::size_type s)
00246 {
00247 if (this->size () + s > this->capacity_)
00248 {
00249
00250
00251
00252
00253
00254 ACE_Array_Map<Key, Value, EqualTo> temp (this->size () + s);
00255
00256 std::copy (this->begin (),
00257 this->end (),
00258 ACE_make_checked_array_iterator (temp.begin (),
00259 temp.capacity_));
00260
00261 size_type const n = this->size ();
00262
00263
00264
00265 this->swap (temp);
00266
00267 this->size_ = n;
00268 }
00269 }
00270
00271
00272
00273 template <typename Key, typename Value, class EqualTo>
00274 bool
00275 operator== (ACE_Array_Map<Key, Value, EqualTo> const & lhs,
00276 ACE_Array_Map<Key, Value, EqualTo> const & rhs)
00277 {
00278
00279
00280
00281 return (lhs.size () == rhs.size ()
00282 && std::equal (lhs.begin (),
00283 lhs.end (),
00284 ACE_make_checked_array_iterator (rhs.begin (),
00285 rhs.size ())));
00286 }
00287
00288 template <typename Key, typename Value, class EqualTo>
00289 bool
00290 operator< (ACE_Array_Map<Key, Value, EqualTo> const & lhs,
00291 ACE_Array_Map<Key, Value, EqualTo> const & rhs)
00292 {
00293 return std::lexicographical_compare (lhs.begin (), lhs.end (),
00294 rhs.begin (), rhs.end ());
00295 }
00296
00297 ACE_END_VERSIONED_NAMESPACE_DECL
00298
00299 #endif