ReferenceWrapper.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_REFERENCEWRAPPER_HPP_
#define GEOSX_DATAREPOSITORY_REFERENCEWRAPPER_HPP_

// System includes
#include <type_traits>

namespace geosx
{

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::result_of< T & (ARGS&&...) >::type
  operator()( ARGS && ... args )
  {
    return m_ref->operator()( std::forward< ARGS >(args)... );
  }

  template< typename ... ARGS >
  inline typename std::result_of< T const&(ARGS&&...) >::type
  operator()( ARGS && ... args ) const
  {
    return m_ref->operator()( std::forward< ARGS >(args)... );
  }


private:
  T * m_ref;
};



} /* namespace geosx */

#endif /* GEOSX_DATAREPOSITORY_REFERENCEWRAPPER_HPP_ */