/* IBM_PROLOG_BEGIN_TAG */
/* This is an automatically generated prolog. */
/* */
/* $Source: src/include/map $ */
/* */
/* OpenPOWER HostBoot Project */
/* */
/* Contributors Listed Below - COPYRIGHT 2011,2017 */
/* [+] International Business Machines Corp. */
/* */
/* */
/* Licensed under the Apache License, Version 2.0 (the "License"); */
/* you may not use this file except in compliance with the License. */
/* You may obtain a copy of the License at */
/* */
/* http://www.apache.org/licenses/LICENSE-2.0 */
/* */
/* Unless required by applicable law or agreed to in writing, software */
/* distributed under the License is distributed on an "AS IS" BASIS, */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or */
/* implied. See the License for the specific language governing */
/* permissions and limitations under the License. */
/* */
/* IBM_PROLOG_END_TAG */
#ifndef __STL_MAP_H
#define __STL_MAP_H
#include <stddef.h>
// Need this to compile outside hostboot env.
#if !defined( __STDC_LIMIT_MACROS)
#define __STDC_LIMIT_MACROS
#endif
#include <stdint.h>
#include <utility>
#include <functional>
#include <util/impl/stlmap.H>
#include <initializer_list>
#ifndef __UTIL_STLMAP_NS
#define __UTIL_STLMAP_NS ::Util::__Util_StlMap_Impl
#endif
namespace std
{
/**
* STL map template class.
*
* @note value_comp not supported.
*
* This class inherits from Util::__Util_StlMap_Impl::Map, which hides all
* of the implementation details of the map. Most of the functions here
* are simply a redirection to the Util::...::Map version.
*/
template <typename Key, typename T, typename Compare = std::less<Key> >
class map : public __UTIL_STLMAP_NS::Map<Key, T, Compare>
{
private:
typedef typename __UTIL_STLMAP_NS::Map<Key, T, Compare> submap;
public:
// Inherit all of the standard typedefs from the Map class.
#define __STLMAP_INHERIT_TYPEDEF(type) \
typedef typename submap::type type
__STLMAP_INHERIT_TYPEDEF(key_type);
__STLMAP_INHERIT_TYPEDEF(data_type);
__STLMAP_INHERIT_TYPEDEF(value_type);
__STLMAP_INHERIT_TYPEDEF(key_compare);
__STLMAP_INHERIT_TYPEDEF(pointer);
__STLMAP_INHERIT_TYPEDEF(reference);
__STLMAP_INHERIT_TYPEDEF(const_reference);
__STLMAP_INHERIT_TYPEDEF(size_type);
__STLMAP_INHERIT_TYPEDEF(difference_type);
__STLMAP_INHERIT_TYPEDEF(iterator);
__STLMAP_INHERIT_TYPEDEF(const_iterator);
__STLMAP_INHERIT_TYPEDEF(reverse_iterator);
__STLMAP_INHERIT_TYPEDEF(const_reverse_iterator);
#undef __STLMAP_INHERIT_TYPEDEF
/**
* Default constructor
*/
explicit map(const key_compare& c = Compare()) : submap(c) {}
/**
* Range-Insert Constructor
* @param[in] first InputIterator
* @param[in] last InputIterator
*
* Copies all of the elements from [first, last) into the map.
*/
template <typename InputIterator> __attribute__ ((always_inline))
map( InputIterator first, InputIterator last,
const key_compare& c = Compare())
: submap(c)
{
this->insert(first, last);
}
/**
* Copy Constructor
* @param i_x Source map
*/
__attribute__ ((always_inline))
map (const map<Key,T,Compare>& i_x) : submap(i_x) {}
/**
* Initializer list constructor"
* @param[in] init_list Initializer list
* @param[in] key_compare A comparison functor.
* @returns None.
* @post map is created with init_list items
*/
__attribute__ ((always_inline))
map ( std::initializer_list<value_type> init_list,
const key_compare& c = Compare())
: submap(c)
{
insert(init_list);
}
/**
* Destructor
*/
__attribute__ ((always_inline))
~map () { }
/**
* operator=
* @param[in] x Source map
*/
__attribute__ ((always_inline))
map<Key,T, Compare>& operator= (const map<Key, T, Compare>& x)
{
submap::iv_comp = x.iv_comp;
submap::iv_tree = x.iv_tree;
return *this;
}
/**
* Get iterator to the beginning element
* @return iterator
*/
__attribute__ ((always_inline))
iterator begin()
{ return submap::begin(); }
/**
* Get iterator to the beginning element
* @return const_iterator
*/
__attribute__ ((always_inline))
const_iterator begin() const
{ return submap::begin(); }
/**
* Get iterator to the last element + 1
* @return iterator
*/
__attribute__ ((always_inline))
iterator end()
{ return submap::end(); }
/**
* Get iterator to the last element + 1
* @return const_iterator
*/
__attribute__ ((always_inline))
const_iterator end() const
{ return submap::end(); }
/**
* Get reverse iterator to the last element
* @return reverse_iterator
*/
__attribute__ ((always_inline))
reverse_iterator rbegin()
{ return submap::rbegin(); }
/**
* Get reverse iterator to the last element
* @return reverse_const_iterator
*/
__attribute__ ((always_inline))
const_reverse_iterator rbegin() const
{ return submap::rbegin(); }
/**
* Get reverse iterator to the first element - 1
* @return reverse_iterator
*/
__attribute__ ((always_inline))
reverse_iterator rend()
{ return submap::rend(); }
/**
* Get reverse iterator to the first element - 1
* @return reverse_const_iterator
*/
__attribute__ ((always_inline))
const_reverse_iterator rend() const
{ return submap::rend(); }
/**
* Query empty container
* @return true if container is empty otherwise false
*/
__attribute__ ((always_inline))
bool empty() const
{ return submap::empty(); }
/**
* Query number of elements in the container
* @return number of elements in the container
*/
__attribute__ ((always_inline))
size_type size() const
{ return submap::size(); }
/**
* Max size of container
* @return theoretical maximum size based on cpu word size
*/
__attribute__ ((always_inline))
size_type max_size() const
{ return UINT64_MAX/sizeof(T); }
/**
* operator[]
* @param[in] x key, if it does not exist the it will be added
* @return a reference to the element whos key is x
*/
__attribute__ ((always_inline))
T& operator[] (const key_type& k)
{ return submap::operator[](k); }
/**
* Access a mutable reference to an element in the container
* @param[in] k - key to map. Asserts if key does not exist
* @return a reference to the element whose key is k
*/
__attribute__ ((always_inline))
T& at( const key_type& k)
{
return submap::at(k);
}
/**
* Get an immutable reference to an element in the container
* @param[in] k key, if it does not exist the it will assert
* @return a const reference to the element whose key is k
*/
__attribute__ ((always_inline))
const T& at( const key_type& k) const
{
return submap::at(k);
}
/**
* Insert element
* @param[in] x map key/value pair
* @return std::pair.first is iterator pointing to new or existing
* element, std::pair.second is true if new element
* inserted, false if already existing.
*
* @note won't add element if it's key already exists in the map
*/
pair<iterator,bool> insert (const value_type& x )
{ return submap::insert(x); }
/**
* Insert element
* @param list A std::initializer_list<value_type> of pairs to be
* inserted.
*/
void insert(std::initializer_list<value_type> list)
{ return submap::insert(list); }
/**
* Insert element
* @param[in] hint bidi iterator that is a hint to where to insert
* the element
* @param[in] x map key/value to insert (copy in)
*
* @return an iterator pointing to either the new or existing
* element
* @note A good hint makes this very efficient. A bad hint slows
* it down. An element will never be inserted out of order.
* Will never insert if key already exists.
*/
iterator insert ( iterator hint, const value_type& x)
{ return submap::insert(hint, x); }
/**
* Insert a range of new elements
*
* (optimized function for iterator)
*
* @param[in] first Beginning of the range
* @param[in] last End of the range.
* @post Elements inserted
*/
void insert( iterator first, iterator last)
{ return submap::insert(first, last); }
/**
* Insert a range of new elements
*
* (optimized function for const_iterator)
*
* @param[in] first Beginning of the range
* @param[in] last End of the range.
* @post Elements inserted
*/
void insert( const_iterator first, const_iterator last)
{ return submap::insert(first, last); }
/**
* Insert a range of new elements
*
* (generic version for any iterator)
*
* @param[in] first InputIterator
* @param[in] last InputIterator
* @post Elements inserted
*/
template <typename InputIterator>
void insert( InputIterator first, InputIterator last )
{ return submap::insert(first, last); }
/**
* Remove an element from the container
* @param position iterator
* @post element pointed to by iterator is removed from the
* container
*/
__attribute__ ((always_inline))
void erase (iterator position )
{ submap::erase(position); }
/**
* Remove an element from the container by key
* @param x key of element to remove
* @return Number of elements removed. For map, 0 or 1.
*/
size_type erase (const key_type& k)
{ return submap:: erase(k); }
/**
* Remove a range of elements from the container
* @param first iterator of elment to remove
* @param last iterator of element to remove + 1
*/
__attribute__ ((always_inline))
void erase (iterator first, iterator last)
{ submap::erase(first,last); }
/**
* Swap this container with another
* @param[in] mp the other container
*/
__attribute__ ((always_inline))
void swap(map<Key,T, Compare>& mp)
{ submap::swap(mp); }
/**
* clear the map
*/
__attribute__ ((always_inline))
void clear()
{ submap::clear();; }
//Observers
/**
* Returns the key comparison object from which the map was
* constructed
* @return Compare
*/
key_compare key_comp() const
{ return submap::key_comp(); }
/**
* returns a value comparison object, built from the key comparison
* @return value_compare
* @note not supported!
*/
// value_compare value_comp () const;
/**
* Find an element
* @param[in] k element key
* @return iterator to element or end() if not found
*/
iterator find (const key_type& k)
{ return submap::find(k); }
/**
* Find an element
* @param[in] k element key
* @return const_iterator to element or end() if not found
*/
__attribute__ ((always_inline))
const_iterator find( const key_type& k) const
{ return submap::find(k); }
/**
* Number of elements in the container with the given key
* @param[in] k key
* @return number of elements that match key. For map this is 0 or 1
*/
__attribute__ ((always_inline))
size_type count (const key_type& k) const
{ return submap::count(k); }
/**
* Return an iterator pointing to the first element in the
* container whose key does not compare less than k.
* @param[in] k key
* @return iterator
*/
iterator lower_bound (const key_type& k)
{ return submap::lower_bound(k); }
/**
* Return a const_iterator pointing to the first element in the
* container whose key does not compare less than k.
* @param[in] k key
* @return const_iterator
*/
__attribute__ ((always_inline))
const_iterator lower_bound (const key_type& k) const
{ return submap::lower_bound(k); }
/**
* Returns an iterator pointing to the first element in the
* container whose key compares > k
* @param[in] k key
* @return iterator
*/
iterator upper_bound (const key_type& k)
{ return submap::upper_bound(k); }
/**
* Returns a const_iterator pointing to the first element in the
* container whose key compares > k
* @param[in] k key
* @return const_iterator
*/
__attribute__ ((always_inline))
const_iterator upper_bound (const key_type& k) const
{ return submap::upper_bound(k); }
/**
* Return the bounds of a range that includes all the elements in
* the continer with a key that compares equal to k.
* @param k key
* @return pair of iterators
* @note map does not allow duplicate keys, so
* the range returned will contain at most one element
*/
pair<iterator,iterator> equal_range( const key_type& k)
{ return submap::equal_range(k); }
/**
* Const verstion of equal_range - see equal_range above
*/
pair<const_iterator, const_iterator>
equal_range( const key_type& k) const
{ return submap::equal_range(k); }
};
/**
* @brief Map equality comparison.
* @param lhs A map.
* @param rhs A map of the same type as lhs.
* @return True iff the size and elements of the maps are equal.
*
* This is an equivalence relation. It is linear in the size of the
* maps. Maps are considered equivalent if their sizes are equal,
* and if corresponding elements compare equal.
*/
template <typename _K, typename _T, typename _C>
inline bool operator==(const map<_K,_T,_C>& lhs,
const map<_K,_T,_C>& rhs)
{
return (lhs.size() == rhs.size()) &&
(std::equal(lhs.begin(), lhs.end(), rhs.begin()));
}
/**
* @brief Map inequality comparison. See operator==
*/
template <typename _K, typename _T, typename _C>
inline bool operator!=(const map<_K,_T,_C>& lhs,
const map<_K,_T,_C>& rhs)
{
return !(lhs == rhs);
}
};
#endif
/* vim: set filetype=cpp : */