StdContainerWrappers.hpp

Go to the documentation of this file.

#ifndef GEOS_COMMON_STD_CONTAINER_WRAPPERS_HPP
#define GEOS_COMMON_STD_CONTAINER_WRAPPERS_HPP
 
#include <array>
#include <cstddef>
#include <vector>
#include <map>
#include <unordered_map>
#include <memory>
 
#include <iostream>
 
namespace geos
{
 
#ifdef GEOS_USE_BOUNDS_CHECK
#define USE_STD_CONTAINER_BOUNDS_CHECKING true
#else
#define USE_STD_CONTAINER_BOUNDS_CHECKING false
#endif
 
 
namespace internal
{
 
 
 
template< typename T >
using DefaultAllocator = std::allocator< T >;
 
template< typename T,
          typename Allocator  = DefaultAllocator< T >,
          bool USE_BOUNDS_CHECKING = false >
class StdVectorWrapper : public std::vector< T, Allocator >
{
public:
  using Base = std::vector< T, Allocator >;
 
  StdVectorWrapper() noexcept(noexcept(Allocator())): Base( Allocator()) {}
 
  explicit StdVectorWrapper( const Allocator & alloc ) noexcept: Base( alloc ) {}
 
  explicit StdVectorWrapper( size_t count, const Allocator & alloc = Allocator())
    : Base( count, alloc ) {}
 
  explicit StdVectorWrapper( size_t count, const T & value,
                             const Allocator & alloc = Allocator())
    : Base( count, value, alloc ) {}
 
  template< class InputIt >
  StdVectorWrapper( InputIt first, InputIt last,
                    const Allocator & alloc = Allocator())
    : Base( first, last, alloc ) {}
 
  StdVectorWrapper( const Base & other ): Base( other ) {}
 
  StdVectorWrapper( Base && other ): Base( other ) {}
 
  StdVectorWrapper( const Base & other, const Allocator & alloc )
    : Base( other, alloc ) {}
 
  StdVectorWrapper( Base && other, const Allocator & alloc )
    : Base( other, alloc ) {}
 
  StdVectorWrapper( std::initializer_list< T > init,
                    const Allocator & alloc = Allocator())
    : Base( init, alloc ) {}
 
 
 
  T const & operator[]( size_t const index ) const
  {
    if constexpr (USE_BOUNDS_CHECKING)
    {
      if( index >= this->size() )
      {
        std::cout<< "Index out of bounds in StdVectorWrapper::operator[]: index = " + std::to_string( index ) + ", size = " + std::to_string( this->size());
      }
      return Base::at( index );  // Throws std::out_of_range if out of bounds.
    }
    else
    {
      return Base::operator[]( index );
    }
  }
 
  T & operator[]( size_t const index )
  {
    if constexpr (USE_BOUNDS_CHECKING)
    {
      if( index >= this->size() )
      {
        std::cout<< "Index out of bounds in StdVectorWrapper::operator[]: index = " + std::to_string( index ) + ", size = " + std::to_string( this->size());
      }
      return Base::at( index );  // Throws std::out_of_range if out of bounds.
    }
    else
    {
      return Base::operator[]( index );  // No bounds checking
    }
  }
};
}
 
template< typename T, typename Allocator = std::allocator< T > >
using stdVector = internal::StdVectorWrapper< T, Allocator, USE_STD_CONTAINER_BOUNDS_CHECKING >;
 
 
 
namespace internal
{
 
template< typename MapType,
          bool USE_BOUNDS_CHECKING = false >
class StdMapWrapper : public MapType
{
public:
  using Base = MapType;
  using KeyType = typename Base::key_type;
  using MappedType = typename Base::mapped_type;
  using ValueType = typename Base::value_type;
 
  using Base::Base;
 
  MappedType & operator[]( KeyType const & key )
  {
    if constexpr (USE_BOUNDS_CHECKING)
    {
      return this->at( key );  // Throws std::out_of_range if key is missing
    }
    else
    {
      return Base::operator[]( key );  // Inserts default-constructed value if missing
    }
  }
 
  MappedType const & operator[]( KeyType const & key ) const
  {
    if constexpr (USE_BOUNDS_CHECKING)
    {
      return this->at( key );
    }
    else
    {
      return Base::operator[]( key );
    }
  }
 
  auto & get_inserted( KeyType && k )
  {
    return this->try_emplace( k ).first->second;
  }
 
  auto & get_inserted( KeyType const & k )
  {
    return this->try_emplace( k ).first->second;
  }
 
};
 
} //namespace internal
 
template< typename Key,
          typename T,
          typename Compare = std::less< Key >,
          typename Allocator = std::allocator< std::pair< const Key, T > > >
using stdMap = internal::StdMapWrapper< std::map< Key, T, Compare, Allocator >,
                                        USE_STD_CONTAINER_BOUNDS_CHECKING >;
 
template< typename Key,
          typename T,
          typename Hash = std::hash< Key >,
          typename KeyEqual = std::equal_to< Key >,
          typename Allocator = std::allocator< std::pair< const Key, T > > >
using stdUnorderedMap = internal::StdMapWrapper< std::unordered_map< Key, T, Hash, KeyEqual, Allocator >,
                                                 USE_STD_CONTAINER_BOUNDS_CHECKING >;
 
 
 
 
template< typename TKEY, typename TVAL, typename SORTED >
class mapType
{};
 
template< typename TKEY, typename TVAL >
class mapType< TKEY, TVAL, std::integral_constant< bool, true > > : public stdMap< TKEY, TVAL >
{
  using stdMap< TKEY, TVAL >::stdMap; // enable list initialization
};
 
template< typename TKEY, typename TVAL >
class mapType< TKEY, TVAL, std::integral_constant< bool, false > > : public stdUnorderedMap< TKEY, TVAL >
{
  using stdUnorderedMap< TKEY, TVAL >::stdUnorderedMap; // enable list initialization
};
 
 
 
template< typename TKEY, typename TVAL, typename SORTED >
class mapBase
{};
 
template< typename TKEY, typename TVAL >
class mapBase< TKEY, TVAL, std::integral_constant< bool, true > > : public std::map< TKEY, TVAL >
{
  using std::map< TKEY, TVAL >::map; // enable list initialization
};
 
template< typename TKEY, typename TVAL >
class mapBase< TKEY, TVAL, std::integral_constant< bool, false > > : public std::unordered_map< TKEY, TVAL >
{
  using std::unordered_map< TKEY, TVAL >::unordered_map; // enable list initialization
};
 
namespace internal
{
 
template< class T,
          std::size_t N,
          bool USE_BOUNDS_CHECKING = false >
struct StdArrayWrapper : public std::array< T, N >
{
public:
  using Base = std::array< T, N >;
 
  constexpr T & operator[]( size_t const index )
  {
    if constexpr (USE_BOUNDS_CHECKING)
    {
      return this->at( index );
    }
    else
    {
      return Base::operator[]( index );
    }
  }
 
  constexpr T const & operator[]( size_t const index ) const
  {
    if constexpr (USE_BOUNDS_CHECKING)
    {
      return this->at( index );
    }
    else
    {
      return Base::operator[]( index );
    }
  }
 
};
} //namespace internal
 
template< class T, std::size_t N >
struct stdArray : public internal::StdArrayWrapper< T, N, true >
{};
 
template< typename _Tp, typename ... _Up >
stdArray( _Tp, _Up ... )
  ->stdArray< std::enable_if_t< (std::is_same_v< _Tp, _Up > && ...), _Tp >,
              1 + sizeof...(_Up) >;
 
template< typename T, std::size_t N, std::size_t... Is >
constexpr stdArray< T, N > to_stdArray_impl( std::array< T, N > const & arr, std::index_sequence< Is... > )
{
  return {{arr[Is] ...}};
}
 
template< typename T, std::size_t N >
constexpr stdArray< T, N > to_stdArray( std::array< T, N > const & arr )
{
  return to_stdArray_impl( arr, std::make_index_sequence< N >{} );
}
 
 
} // namespace geos
 
#endif /* GEOS_COMMON_STD_CONTAINER_WRAPPERS_HPP */