MappedVector.hpp

Go to the documentation of this file.

/*
 * ------------------------------------------------------------------------------------------------------------
 * SPDX-License-Identifier: LGPL-2.1-only
 *
 * Copyright (c) 2018-2020 Lawrence Livermore National Security LLC
 * Copyright (c) 2018-2020 The Board of Trustees of the Leland Stanford Junior University
 * Copyright (c) 2018-2020 Total, S.A
 * Copyright (c) 2019-     GEOSX Contributors
 * All rights reserved
 *
 * See top level LICENSE, COPYRIGHT, CONTRIBUTORS, NOTICE, and ACKNOWLEDGEMENTS files for details.
 * ------------------------------------------------------------------------------------------------------------
 */

#ifndef GEOSX_DATAREPOSITORY_MAPPEDVECTOR_HPP_
#define GEOSX_DATAREPOSITORY_MAPPEDVECTOR_HPP_

// Source includes
#include "KeyIndexT.hpp"
#include "common/GeosxMacros.hpp"
#include "common/Logger.hpp"
#include "LvArray/src/limits.hpp"

// System includes
#include <vector>

namespace geosx
{
template< typename T,
          typename T_PTR=T *,
          typename KEY_TYPE=std::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          = std::unordered_map< 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         = std::vector< value_type >;

  using constKeyValueContainer = std::vector< const_key_value_type >;

  using constValueContainer    = std::vector< 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( index ) );
      m_constValues.emplace_back( m_values[i].first, rawPtr( index ) );
    }

    // 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 GEOSX_UNUSED_PARAM( index ) )
  {}

  valueContainer m_values;

  constKeyValueContainer m_constKeyValues;

  constValueContainer m_constValues;

  LookupMapType m_keyLookup;

  std::vector< 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( source->get_typeid() != m_values[index].second->get_typeid() )
      {
        GEOSX_ERROR( "MappedVector::insert(): Tried to insert existing key ("<<keyName<<
                     ") with a different type without overwrite flag\n"<<" "<<source->get_typeid().name()<<" != "<<
                     m_values[index].second->get_typeid().name() );
      }
      else
      {
        delete source;
      }
    }
  }

  return &(*(m_values[index].second));
}
}

#endif /* GEOSX_DATAREPOSITORY_MAPPEDVECTOR_HPP_ */