FixedMap(std::map<KeyType, ValueType, Comp, Alloc>&& other)
: FixedMap() {
insert(std::begin(other), std::end(other));
other.clear();
}
FixedMap& operator=(std::initializer_list<value_type> init) {
insert(init);
return *this;
}
FixedMap(const std::map<KeyType, ValueType, Comp, Alloc>& other)
: FixedMap() {
insert(std::begin(other), std::end(other));
}
FixedMap& operator=(const FixedMap& other) {
insert(std::begin(other), std::end(other));
return *this;
}
FixedMap& operator=(FixedMap&& other) {
insert(std::begin(other), std::end(other));
other.clear();
return *this;
}
FixedMap(FixedMap&& other) : FixedMap() {
insert(std::begin(other), std::end(other));
other.clear();
}
FixedMap(std::initializer_list<value_type> init) : FixedMap() {
insert(init);
}
FixedMap(InputIterator first, InputIterator last,
const Compare& comp = Compare())
: FixedMap(comp) {
insert(first, last);
}
FixedMap(const FixedMap& other) : FixedMap() {
insert(std::begin(other), std::end(other));
}
FixedMultiMap& operator=(
std::multimap<KeyType, ValueType, Comp, Alloc>&& other) {
insert(std::begin(other), std::end(other));
other.clear();
return *this;
}
FixedMap& operator=(const std::map<KeyType, ValueType, Comp, Alloc>& other) {
insert(std::begin(other), std::end(other));
return *this;
}
void insert(InputIterator start, InputIterator finish)
{_base.insert(start, finish);}
/// If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.
virtual iterator insert(iterator position, const value_type& x)
{return _base.insert(position, x);}
/// If a value_type with the same key as x is not present in the map, then x is inserted into the map. Otherwise, the pair is not inserted. A position may be supplied as a hint regarding where to do the insertion. If the insertion is done right after position, then it takes amortized constant time. Otherwise it takes O(log N) time.
virtual std::pair<iterator, bool> insert(const value_type& x)
{return _base.insert(x);}