Add map list initialization and at() methods

Also add ErrnoToString() as a test which is a functionality
ported from p8

Change-Id: Ia6dd9b37638af2634267e224d9b97133bf984fb4
Reviewed-on: http://ralgit01.raleigh.ibm.com/gerrit1/38956
Tested-by: Jenkins Server <pfd-jenkins+hostboot@us.ibm.com>
Reviewed-by: Nicholas E. Bofferding <bofferdn@us.ibm.com>
Reviewed-by: Martin Gloff <mgloff@us.ibm.com>
Tested-by: Jenkins OP Build CI <op-jenkins+hostboot@us.ibm.com>
Tested-by: FSP CI Jenkins <fsp-CI-jenkins+hostboot@us.ibm.com>
Reviewed-by: Daniel M. Crowell <dcrowell@us.ibm.com>

1 files changed, 71 insertions, 23 deletions

diff --git a/src/include/map b/src/include/map
index 19989f594..ddfa17ea7 100644
--- a/src/include/map
+++ b/src/include/map
@@ -5,7 +5,9 @@
 /*                                                                        */
 /* OpenPOWER HostBoot Project                                             */
 /*                                                                        */
-/* COPYRIGHT International Business Machines Corp. 2011,2014              */
+/* 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.       */
@@ -35,6 +37,7 @@
 #include <functional>
 
 #include <util/impl/stlmap.H>
+#include <initializer_list>
 
 #ifndef __UTIL_STLMAP_NS
 #define __UTIL_STLMAP_NS ::Util::__Util_StlMap_Impl
@@ -45,11 +48,11 @@ 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 
+     * 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> >
@@ -92,21 +95,36 @@ namespace std
              * Copies all of the elements from [first, last) into the map.
              */
             template <typename InputIterator> __attribute__ ((always_inline))
-                map( InputIterator first, InputIterator last, 
+                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))
@@ -129,7 +147,7 @@ namespace std
              * @return iterator
              */
             __attribute__ ((always_inline))
-            iterator begin() 
+            iterator begin()
                     { return submap::begin(); }
 
             /**
@@ -193,7 +211,7 @@ namespace std
              * @return true if container is empty otherwise false
              */
             __attribute__ ((always_inline))
-            bool empty() const 
+            bool empty() const
                     { return submap::empty(); }
 
             /**
@@ -201,7 +219,7 @@ namespace std
              * @return number of elements in the container
              */
             __attribute__ ((always_inline))
-            size_type size() const 
+            size_type size() const
                     { return submap::size(); }
 
             /**
@@ -209,7 +227,7 @@ namespace std
              * @return theoretical maximum size based on cpu word size
              */
             __attribute__ ((always_inline))
-            size_type max_size() const 
+            size_type max_size() const
                     { return UINT64_MAX/sizeof(T); }
 
             /**
@@ -218,28 +236,58 @@ namespace std
              * @return a reference to the element whos key is x
              */
             __attribute__ ((always_inline))
-            T& operator[] (const key_type& k) 
+            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 
+             * @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 ) 
+            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 
+             * @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.
@@ -249,7 +297,7 @@ namespace std
                     { return submap::insert(hint, x); }
 
             /**
-             * Insert a range of new elements 
+             * Insert a range of new elements
              *
              * (optimized function for iterator)
              *
@@ -261,7 +309,7 @@ namespace std
                     { return submap::insert(first, last); }
 
             /**
-             * Insert a range of new elements 
+             * Insert a range of new elements
              *
              * (optimized function for const_iterator)
              *
@@ -309,7 +357,7 @@ namespace std
              * @param last iterator of element to remove + 1
              */
             __attribute__ ((always_inline))
-            void erase (iterator first, iterator last) 
+            void erase (iterator first, iterator last)
                     { submap::erase(first,last); }
 
             /**
@@ -318,7 +366,7 @@ namespace std
              */
             __attribute__ ((always_inline))
             void swap(map<Key,T, Compare>& mp)
-                    { submap::swap(mp); }                
+                    { submap::swap(mp); }
 
             /**
              * clear the map
@@ -326,10 +374,10 @@ namespace std
             __attribute__ ((always_inline))
             void clear()
                     { submap::clear();; }
-            
+
             //Observers
             /**
-             * Returns the key comparison object from which the map was 
+             * Returns the key comparison object from which the map was
              * constructed
              * @return Compare
              */
@@ -357,7 +405,7 @@ namespace std
              * @return const_iterator to element or end() if not found
              */
             __attribute__ ((always_inline))
-            const_iterator find( const key_type& k) const 
+            const_iterator find( const key_type& k) const
                     { return submap::find(k); }
 
             /**
@@ -421,7 +469,7 @@ namespace std
             /**
              * Const verstion of equal_range - see equal_range above
              */
-            pair<const_iterator, const_iterator> 
+            pair<const_iterator, const_iterator>
                 equal_range( const key_type& k) const
                     { return submap::equal_range(k); }
     };