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