Map.h

Go to the documentation of this file.

/***********************************************************************************\
* (c) Copyright 1998-2025 CERN for the benefit of the LHCb and ATLAS collaborations *
*                                                                                   *
* This software is distributed under the terms of the Apache version 2 licence,     *
* copied verbatim in the file "LICENSE".                                            *
*                                                                                   *
* In applying this licence, CERN does not waive the privileges and immunities       *
* granted to it by virtue of its status as an Intergovernmental Organization        *
* or submit itself to any jurisdiction.                                             *
\***********************************************************************************/
#pragma once
 
#include <GaudiKernel/MapBase.h>
#include <GaudiKernel/SerializeSTL.h>
#include <map>
 
namespace GaudiUtils {
  template <typename K, typename T, typename M = std::map<K, T>>
  class Map : public Gaudi::Utils::MapBase {
  public:
    // ---- types
    typedef M map_type;
    typedef K key_type;
    typedef T mapped_type;
 
    // -- from unary_function
    typedef K                     argument_type;
    typedef T                     result_type;
    typedef std::pair<const K, T> value_type;
    typedef const value_type&     const_reference;
 
    typedef typename map_type::size_type size_type;
 
    typedef typename map_type::iterator       iterator;
    typedef typename map_type::const_iterator const_iterator;
 
  protected:
    map_type                 m_map;
    static const result_type s_null_value;
 
  public:
    Map() = default;

    Map( const map_type& other ) : m_map( other ) {}

    template <typename In>
    Map( In&& first, In&& last ) : m_map( std::forward<In>( first ), std::forward<In>( last ) ) {}

    virtual ~Map() = default;
 
    // ---- std::map interface
 
    //    -- iterators
 
    inline iterator begin() { return m_map.begin(); }
    inline iterator end() { return m_map.end(); }
 
    inline const_iterator begin() const { return m_map.begin(); }
    inline const_iterator end() const { return m_map.end(); }
 
    //    -- subscription
 
    inline mapped_type& operator[]( const key_type& key ) { return m_map[key]; }
 
    //    -- map operations
 
    inline iterator       find( const key_type& key ) { return m_map.find( key ); }
    inline const_iterator find( const key_type& key ) const { return m_map.find( key ); }
 
    inline size_type count( const key_type& key ) const { return m_map.count( key ); }
 
    inline iterator       lower_bound( const key_type& key ) { return m_map.lower_bound( key ); }
    inline const_iterator lower_bound( const key_type& key ) const { return m_map.lower_bound( key ); }
    inline iterator       upper_bound( const key_type& key ) { return m_map.upper_bound( key ); }
    inline const_iterator upper_bound( const key_type& key ) const { return m_map.upper_bound( key ); }
 
    inline std::pair<iterator, iterator> equal_range( const key_type& key ) { return m_map.equal_range( key ); }
    inline std::pair<const_iterator, const_iterator> equal_range( const key_type& key ) const {
      return m_map.equal_range( key );
    }
 
    //    -- list operations
    template <class... Args>
    std::pair<iterator, bool> emplace( Args&&... args ) {
      return m_map.emplace( std::forward<Args>( args )... );
    }
    template <typename ValueType>
    inline std::pair<iterator, bool> insert( ValueType&& val ) {
      return m_map.insert( std::forward<ValueType>( val ) );
    }
    inline std::pair<iterator, bool> insert( value_type&& val ) {
      return m_map.insert( std::forward<value_type>( val ) );
    }
    template <typename In>
    inline void insert( In&& first, In&& last ) {
      m_map.insert( std::forward<In>( first ), std::forward<In>( last ) );
    }
    template <typename ValueType>
    inline iterator insert( iterator /* pos */, ValueType&& val ) {
      return m_map.insert( /* pos, */ std::forward<ValueType>( val ) ).first;
    }
    inline iterator  erase( const_iterator pos ) { return m_map.erase( pos ); }
    inline size_type erase( const key_type& key ) { return m_map.erase( key ); }
    inline iterator  erase( const_iterator first, const_iterator last ) { return m_map.erase( first, last ); }
    inline void      clear() { m_map.clear(); }
 
    //    -- container operations
 
    inline size_type size() const { return m_map.size(); }
    inline size_type max_size() const { return m_map.max_size(); }
    inline bool      empty() const { return size() == 0; }
    inline void      swap( map_type& other ) { m_map.swap( other ); }
 
    // ---- extra functionalities

    inline const result_type& operator()( const argument_type& key ) const {
      // static const result_type s_null_value;
      auto it = m_map.find( key );
      return it != m_map.end() ? it->second : s_null_value;
    }

    inline const mapped_type& operator[]( const key_type& key ) const { return ( *this )( key ); }
    inline const result_type& at( const argument_type& key ) const { return m_map.at( key ); }
    inline Map& merge( const map_type& other ) {
      m_map.insert( std::begin( other ), std::end( other ) );
      return *this;
    }

    inline Map& merge( const Map& other ) {
      m_map.insert( std::begin( other ), std::end( other ) );
      return *this;
    }

    template <class K1, class K2, class K3>
    inline Map& merge( const Map<K1, K2, K3>& other ) {
      m_map.insert( std::begin( other ), std::end( other ) );
      return *this;
    }
    // update the key
    void update( const key_type& key, const mapped_type& mapped ) { ( *this )[key] = mapped; }
 
  public:
    inline operator map_type&() { return m_map; }
    inline operator const map_type&() const { return m_map; }
    const key_type& key_at( const size_type index ) const {
      if ( index >= size() ) { this->throw_out_of_range_exception(); }
      return std::next( this->begin(), index )->first;
    }

    const mapped_type& value_at( const size_type index ) const {
      if ( index >= size() ) { this->throw_out_of_range_exception(); }
      return std::next( this->begin(), index )->second;
    }

    friend std::ostream& operator<<( std::ostream& s, const GaudiUtils::Map<K, T, M>& m ) {
      return s << static_cast<const M&>( m );
    }
  };
  template <typename K, typename T, typename M>
  const typename Map<K, T, M>::result_type Map<K, T, M>::s_null_value = typename Map<K, T, M>::result_type();
 
} // namespace GaudiUtils