ReferenceWrapper.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_REFERENCEWRAPPER_HPP_
#define GEOS_DATAREPOSITORY_REFERENCEWRAPPER_HPP_
 
// System includes
#include <type_traits>
#include <utility>
 
namespace geos
{
 
template< typename T >
class ReferenceWrapper
{
public:
 
  ReferenceWrapper():
    m_ref( nullptr )
  {}
 
 
  ReferenceWrapper( T & source ) noexcept:
    m_ref( &source )
  {}
 
 
  ~ReferenceWrapper() = default;
 
  ReferenceWrapper( ReferenceWrapper const & source ):
    m_ref( source.m_ref )
  {}
 
 
  ReferenceWrapper( ReferenceWrapper && source ):
    m_ref( source.m_ref )
  {
    source.m_ref = nullptr;
  }
 
  ReferenceWrapper & operator=( ReferenceWrapper const & source )
  {
    m_ref = source.m_ref;
    return *this;
  }
 
 
  template< typename T_RHS, typename U=T >
  inline
  typename std::enable_if< !std::is_const< U >::value, ReferenceWrapper & >::type
  operator=( T_RHS const & rhs )
  {
    *m_ref = rhs;
    return *this;
  }
 
  inline ReferenceWrapper & operator=( T && source )
  {
    *m_ref = std::move( source );
    return *this;
  }
 
  inline operator T & ()
  {
    return *m_ref;
  }
 
  inline operator T const & () const
  {
    return *m_ref;
  }
 
  inline void set( T & source )
  {
    m_ref = &source;
  }
 
  inline void set( T * source )
  {
    m_ref = source;
  }
 
  inline T & get()
  {
    return *m_ref;
  }
 
  inline T const & get() const
  {
    return *m_ref;
  }
 
  inline bool isValid() const
  {
    return m_ref;
  }
 
  inline T const * getPtr() const
  {
    return m_ref;
  }
 
  /*
   * Unfortunately, Doxygen does not understand decltype in function return types.
   * It does not generate documentation for the following two functions, but still
   * emits a warning. So we just disable docs for these until issue fixed in Doxygen.
   */
 
  template< typename INDEX_TYPE, typename U = T >
  inline decltype( std::declval< U >()[1] )
  operator[]( INDEX_TYPE const i )
  {
    return (*m_ref)[i];
  }
 
  template< typename INDEX_TYPE, typename U = T >
  inline decltype( std::declval< U const >()[1] )
  operator[]( INDEX_TYPE const i ) const
  {
    return (*m_ref)[i];
  }
 
 
  template< typename ... ARGS >
  inline typename std::invoke_result< T &, ARGS &&... >::type
  operator()( ARGS && ... args )
  {
    return m_ref->operator()( std::forward< ARGS >(args)... );
  }
 
  template< typename ... ARGS >
  inline typename std::invoke_result< T const &, ARGS &&... >::type
  operator()( ARGS && ... args ) const
  {
    return m_ref->operator()( std::forward< ARGS >(args)... );
  }
 
 
private:
  T * m_ref;
};
 
 
 
} /* namespace geos */
 
#endif /* GEOS_DATAREPOSITORY_REFERENCEWRAPPER_HPP_ */