MappedVector.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2016-2024 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2024 TotalEnergies
 * Copyright (c) 2018-2024 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2023-2024 Chevron
 * Copyright (c) 2019-     GEOS/GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */
 
#ifndef GEOS_DATAREPOSITORY_MAPPEDVECTOR_HPP_
#define GEOS_DATAREPOSITORY_MAPPEDVECTOR_HPP_
 
// Source includes
#include "KeyIndexT.hpp"
#include "common/GeosxMacros.hpp"
#include "common/logger/Logger.hpp"
#include "LvArray/src/limits.hpp"
 
// System includes
#include <vector>
 
namespace geos
{
template< typename T,
          typename T_PTR=T *,
          typename KEY_TYPE=string,
          typename INDEX_TYPE = int >
class MappedVector
{
public:
  static_assert( std::is_same< T_PTR, T * >::value || std::is_same< T_PTR, std::unique_ptr< T > >::value,
                 "invalid second template argument for MappedVector<T,T_PTR,KEY_TYPE,INDEX_TYPE>. Allowable types are T * and std::unique_ptr<T>." );
 
  using key_type      = KEY_TYPE;
 
  using mapped_type   = T_PTR;
 
  using LookupMapType          = stdUnorderedMap< KEY_TYPE, INDEX_TYPE >;
 
  using value_type             = typename std::pair< KEY_TYPE, T_PTR >;
 
  using const_key_value_type   = typename std::pair< KEY_TYPE const, T * >;
 
  using const_value_type       = typename std::pair< KEY_TYPE const, T const * >;
 
  using valueContainer         = stdVector< value_type >;
 
  using constKeyValueContainer = stdVector< const_key_value_type >;
 
  using constValueContainer    = stdVector< const_value_type >;
 
  using pointer                = typename valueContainer::pointer;
 
  using const_pointer          = typename valueContainer::const_pointer;
 
  using reference              = typename valueContainer::reference;
 
  using const_reference        = typename valueContainer::const_reference;
 
  using size_type              = typename valueContainer::size_type;
 
  using iterator               = typename constKeyValueContainer::iterator;
 
  using const_iterator         = typename constValueContainer::const_iterator;
 
  using reverse_iterator       = typename constKeyValueContainer::reverse_iterator;
 
  using const_reverse_iterator = typename constValueContainer::const_reverse_iterator;
 
  using KeyIndex = KeyIndexT< KEY_TYPE const, INDEX_TYPE >;
 
 
  MappedVector() = default;
 
  ~MappedVector()
  {
    clear();
  }
 
 
 
  MappedVector( MappedVector const & ) = default;
 
  MappedVector & operator=( MappedVector const & ) = default;
 
  MappedVector( MappedVector && ) = default;
 
  MappedVector & operator=( MappedVector && ) = default;
 
 
 
 
 
  inline T const * operator[]( INDEX_TYPE index ) const
  {
    return ( index>KeyIndex::invalid_index &&
             index<static_cast< INDEX_TYPE >( m_values.size() ) ) ? const_cast< T const * >(&(*(m_values[index].second))) : nullptr;
  }
 
  inline T * operator[]( INDEX_TYPE index )
  { return const_cast< T * >( const_cast< MappedVector< T, T_PTR, KEY_TYPE, INDEX_TYPE > const * >(this)->operator[]( index ) ); }
 
  inline T const * operator[]( KEY_TYPE const & keyName ) const
  {
    typename LookupMapType::const_iterator iter = m_keyLookup.find( keyName );
    return ( iter!=m_keyLookup.end() ? this->operator[]( iter->second ) : nullptr );
  }
 
  inline T * operator[]( KEY_TYPE const & keyName )
  { return const_cast< T * >( const_cast< MappedVector< T, T_PTR, KEY_TYPE, INDEX_TYPE > const * >(this)->operator[]( keyName ) ); }
 
  inline T const * operator[]( KeyIndex const & keyIndex ) const
  {
    INDEX_TYPE index = keyIndex.index();
 
    if( index==KeyIndex::invalid_index )
    {
      index = getIndex( keyIndex.key() );
      keyIndex.setIndex( index );
    }
#ifdef MAPPED_VECTOR_RANGE_CHECKING
    else if( m_values[index].first!=keyIndex.Key() )
    {
      index = getIndex( keyIndex.Key() );
      keyIndex.setIndex( index );
    }
#endif
 
    return this->operator[]( index );
  }
 
  inline T * operator[]( KeyIndex const & keyIndex )
  { return const_cast< T * >( const_cast< MappedVector< T, T_PTR, KEY_TYPE, INDEX_TYPE > const * >(this)->operator[]( keyIndex ) ); }
 
 
 
 
  iterator begin()
  { return m_constKeyValues.begin(); }
 
  const_iterator begin() const
  { return m_constValues.begin(); }
 
  const_iterator cbegin()
  { return m_constValues.begin(); }
 
  iterator end()
  { return m_constKeyValues.end(); }
 
  const_iterator end() const
  { return m_constValues.end(); }
 
  const_iterator cend()
  { return m_constValues.end(); }
 
 
  inline INDEX_TYPE getIndex( KEY_TYPE const & key ) const
  {
    typename LookupMapType::const_iterator iter = m_keyLookup.find( key );
    return ( iter!=m_keyLookup.end() ? iter->second : KeyIndex::invalid_index );
  }
 
 
 
  T * insert( KEY_TYPE const & keyName,
              T_PTR source,
              bool takeOwnership,
              bool overwrite = false );
 
 
 
  void erase( INDEX_TYPE index )
  {
    // delete the pointed-to value, if owned
    deleteValue( index );
 
    // delete lookup entry
    m_keyLookup.erase( m_values[index].first );
 
    // delete and shift vector entries
    m_values.erase( m_values.begin() + index );
    m_ownsValues.erase( m_ownsValues.begin() + index );
 
    // rebuild parts of const key vectors after deleted entry
    m_constKeyValues.resize( index );
    m_constValues.resize( index );
    for( typename valueContainer::size_type i = index; i < m_values.size(); ++i )
    {
      m_constKeyValues.emplace_back( m_values[i].first, rawPtr( i ) );
      m_constValues.emplace_back( m_values[i].first, rawPtr( i ) );
    }
 
    // adjust lookup map indices
    for( typename valueContainer::size_type i = index; i < m_values.size(); ++i )
    {
      m_keyLookup[m_values[i].first] = i;
    }
  }
 
  void erase( KEY_TYPE const & key )
  {
    typename LookupMapType::const_iterator iter = m_keyLookup.find( key );
    if( iter!=m_keyLookup.end() )
    {
      erase( iter->second );
    }
  }
 
  void erase( KeyIndex & keyIndex )
  {
    INDEX_TYPE index = keyIndex.Index();
 
    if( (index==KeyIndex::invalid_index) || (m_values[index].first!=keyIndex.Key()) )
    {
      index = getIndex( keyIndex.Key() );
      keyIndex.setIndex( index );
    }
    erase( index );
  }
 
  void clear()
  {
    for( typename valueContainer::size_type a = 0; a < m_values.size(); ++a )
    {
      deleteValue( LvArray::integerConversion< INDEX_TYPE >( a ) );
    }
    m_constKeyValues.clear();
    m_constValues.clear();
    m_values.clear();
    m_ownsValues.clear();
    m_keyLookup.clear();
  }
 
 
 
  inline INDEX_TYPE size() const
  {
    return LvArray::integerConversion< INDEX_TYPE >( m_values.size() );
  }
 
  inline valueContainer const & values()
  { return this->m_values; }
 
  inline constValueContainer const & values() const
  { return this->m_constValues; }
 
  inline LookupMapType const & keys() const
  { return m_keyLookup; }
 
 
private:
 
  T * rawPtr( INDEX_TYPE index )
  {
    return &(*(m_values[index].second));
  }
 
  template< typename U = T_PTR >
  typename std::enable_if< std::is_same< U, T * >::value, void >::type
  deleteValue( INDEX_TYPE index )
  {
    if( m_ownsValues[index] )
    {
      delete m_values[index].second;
    }
  }
 
  template< typename U = T_PTR >
  typename std::enable_if< !std::is_same< U, T * >::value, void >::type
  deleteValue( INDEX_TYPE GEOS_UNUSED_PARAM( index ) )
  {}
 
  valueContainer m_values;
 
  constKeyValueContainer m_constKeyValues;
 
  constValueContainer m_constValues;
 
  LookupMapType m_keyLookup;
 
  stdVector< int > m_ownsValues;
};
 
template< typename T, typename T_PTR, typename KEY_TYPE, typename INDEX_TYPE >
T * MappedVector< T, T_PTR, KEY_TYPE, INDEX_TYPE >::insert( KEY_TYPE const & keyName,
                                                            T_PTR source,
                                                            bool takeOwnership,
                                                            bool overwrite )
{
  INDEX_TYPE index = KeyIndex::invalid_index;
  typename LookupMapType::iterator iterKeyLookup = m_keyLookup.find( keyName );
 
 
  // if the key was not found, make DataObject<T> and insert
  if( iterKeyLookup == m_keyLookup.end() )
  {
    value_type newEntry = std::make_pair( keyName, std::move( source ) );
    m_values.push_back( std::move( newEntry ) );
    //TODO this needs to be a safe conversion
    index = static_cast< INDEX_TYPE >(m_values.size()) - 1;
    m_ownsValues.resize( index + 1 );
    if( takeOwnership )
    {
      m_ownsValues[index] = true;
    }
 
    m_keyLookup.insert( std::make_pair( keyName, index ) );
    m_constKeyValues.emplace_back( keyName, rawPtr( index ) );
    m_constValues.emplace_back( keyName, rawPtr( index ) );
 
  }
  // if key was found
  else
  {
    index = iterKeyLookup->second;
 
    if( takeOwnership )
    {
      m_ownsValues[index] = true;
    }
 
    // if value is empty, then move source into value slot
    if( m_values[index].second==nullptr )
    {
      m_values[index].second = std::move( source );
      m_constKeyValues[index].second = rawPtr( index );
      m_constValues[index].second = rawPtr( index );
    }
    else
    {
      if( overwrite )
      {
        deleteValue( index );
        m_values[index].second = std::move( source );
        m_constKeyValues[index].second = rawPtr( index );
        m_constValues[index].second = rawPtr( index );
      }
      else if( typeid( source ) != typeid( m_values[index].second ) )
      {
        GEOS_ERROR( "MappedVector::insert(): Tried to insert existing key (" << keyName <<
                    ") with a different type without overwrite flag\n " << " " << LvArray::system::demangleType( source ) <<
                    " != " << LvArray::system::demangleType( m_values[ index ].second ) );
      }
      else
      {
        delete source;
      }
    }
  }
 
  return &(*(m_values[index].second));
}
}
 
#endif /* GEOS_DATAREPOSITORY_MAPPEDVECTOR_HPP_ */