text: #ifndef BOOST_CORE_REF_HPP
  #define BOOST_CORE_REF_HPP
  
  // MS compatible compilers support #pragma once
  
  #if defined(_MSC_VER) && (_MSC_VER >= 1020)
  # pragma once
  #endif
  
  #include <boost/config.hpp>
  #include <boost/utility/addressof.hpp>
  #include <boost/detail/workaround.hpp>
  
  //
  //  ref.hpp - ref/cref, useful helper functions
  //
  //  Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
  //  Copyright (C) 2001, 2002 Peter Dimov
  //  Copyright (C) 2002 David Abrahams
  //
  //  Copyright (C) 2014 Glen Joseph Fernandes
  //  glenfe at live dot com
  //  Copyright (C) 2014 Agustin Berge
  //
  // Distributed under the Boost Software License, Version 1.0. (See
  // accompanying file LICENSE_1_0.txt or copy at
  // http://www.boost.org/LICENSE_1_0.txt)
  //
  //  See http://www.boost.org/libs/core/doc/html/core/ref.html for documentation.
  //
  
  /**
   @file
  */
  
  /**
   Boost namespace.
  */
  namespace geofeatures_boost {} namespace boost = geofeatures_boost; namespace geofeatures_boost
  {
  
  #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
  
      struct ref_workaround_tag {};
  
  #endif
  
  // reference_wrapper
  
  /**
   @brief Contains a reference to an object of type `T`.
  
   `reference_wrapper` is primarily used to "feed" references to
   function templates (algorithms) that take their parameter by
   value. It provides an implicit conversion to `T&`, which
   usually allows the function templates to work on references
   unmodified.
  */
  template<class T> class reference_wrapper
  {
  public:
      /**
       Type `T`.
      */
      typedef T type;
  
      /**
       Constructs a `reference_wrapper` object that stores a
       reference to `t`.
  
       @remark Does not throw.
      */
      BOOST_FORCEINLINE explicit reference_wrapper(T& t): t_(geofeatures_boost::addressof(t)) {}
  
  #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
  
      BOOST_FORCEINLINE explicit reference_wrapper( T & t, ref_workaround_tag ): t_( geofeatures_boost::addressof( t ) ) {}
  
  #endif
  
  #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
      /**
       @remark Construction from a temporary object is disabled.
      */
      BOOST_DELETED_FUNCTION(reference_wrapper(T&& t))
  public:
  #endif
  
      /**
       @return The stored reference.
       @remark Does not throw.
      */
      BOOST_FORCEINLINE operator T& () const { return *t_; }
  
      /**
       @return The stored reference.
       @remark Does not throw.
      */
      BOOST_FORCEINLINE T& get() const { return *t_; }
  
      /**
       @return A pointer to the object referenced by the stored
         reference.
       @remark Does not throw.
      */
      BOOST_FORCEINLINE T* get_pointer() const { return t_; }
  
  private:
  
      T* t_;
  };
  
  // ref
  
  /**
   @cond
  */
  #if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT(0x581) )
  #  define BOOST_REF_CONST
  #else
  #  define BOOST_REF_CONST const
  #endif
  /**
   @endcond
  */
  
  /**
   @return `reference_wrapper<T>(t)`
   @remark Does not throw.
  */
  template<class T> BOOST_FORCEINLINE reference_wrapper<T> BOOST_REF_CONST ref( T & t )
  {
  #if defined( BOOST_MSVC ) && BOOST_WORKAROUND( BOOST_MSVC, == 1600 )
  
      return reference_wrapper<T>( t, ref_workaround_tag() );
  
  #else
  
      return reference_wrapper<T>( t );
  
  #endif
  }
  
  // cref
  
  /**
   @return `reference_wrapper<T const>(t)`
   @remark Does not throw.
  */
  template<class T> BOOST_FORCEINLINE reference_wrapper<T const> BOOST_REF_CONST cref( T const & t )
  {
      return reference_wrapper<T const>(t);
  }
  
  #undef BOOST_REF_CONST
  
  #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES)
  
  /**
   @cond
  */
  #if defined(BOOST_NO_CXX11_DELETED_FUNCTIONS)
  #  define BOOST_REF_DELETE
  #else
  #  define BOOST_REF_DELETE = delete
  #endif
  /**
   @endcond
  */
  
  /**
   @remark Construction from a temporary object is disabled.
  */
  template<class T> void ref(T const&&) BOOST_REF_DELETE;
  
  /**
   @remark Construction from a temporary object is disabled.
  */
  template<class T> void cref(T const&&) BOOST_REF_DELETE;
  
  #undef BOOST_REF_DELETE
  
  #endif
  
  // is_reference_wrapper
  
  /**
   @brief Determine if a type `T` is an instantiation of
   `reference_wrapper`.
  
   The value static constant will be true if the type `T` is a
   specialization of `reference_wrapper`.
  */
  template<typename T> struct is_reference_wrapper
  {
      BOOST_STATIC_CONSTANT( bool, value = false );
  };
  
  /**
   @cond
  */
  template<typename T> struct is_reference_wrapper< reference_wrapper<T> >
  {
      BOOST_STATIC_CONSTANT( bool, value = true );
  };
  
  #if !defined(BOOST_NO_CV_SPECIALIZATIONS)
  
  template<typename T> struct is_reference_wrapper< reference_wrapper<T> const >
  {
      BOOST_STATIC_CONSTANT( bool, value = true );
  };
  
  template<typename T> struct is_reference_wrapper< reference_wrapper<T> volatile >
  {
      BOOST_STATIC_CONSTANT( bool, value = true );
  };
  
  template<typename T> struct is_reference_wrapper< reference_wrapper<T> const volatile >
  {
      BOOST_STATIC_CONSTANT( bool, value = true );
  };
  
  #endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
  
  /**
   @endcond
  */
  
  
  // unwrap_reference
  
  /**
   @brief Find the type in a `reference_wrapper`.
  
   The `typedef` type is `T::type` if `T` is a
   `reference_wrapper`, `T` otherwise.
  */
  template<typename T> struct unwrap_reference
  {
      typedef T type;
  };
  
  /**
   @cond
  */
  template<typename T> struct unwrap_reference< reference_wrapper<T> >
  {
      typedef T type;
  };
  
  #if !defined(BOOST_NO_CV_SPECIALIZATIONS)
  
  template<typename T> struct unwrap_reference< reference_wrapper<T> const >
  {
      typedef T type;
  };
  
  template<typename T> struct unwrap_reference< reference_wrapper<T> volatile >
  {
      typedef T type;
  };
  
  template<typename T> struct unwrap_reference< reference_wrapper<T> const volatile >
  {
      typedef T type;
  };
  
  #endif // !defined(BOOST_NO_CV_SPECIALIZATIONS)
  
  /**
   @endcond
  */
  
  // unwrap_ref
  
  /**
   @return `unwrap_reference<T>::type&(t)`
   @remark Does not throw.
  */
  template<class T> BOOST_FORCEINLINE typename unwrap_reference<T>::type& unwrap_ref( T & t )
  {
      return t;
  }
  
  // get_pointer
  
  /**
   @cond
  */
  template<class T> BOOST_FORCEINLINE T* get_pointer( reference_wrapper<T> const & r )
  {
      return r.get_pointer();
  }
  /**
   @endcond
  */
  
  } // namespace geofeatures_boost
  
  #endif // #ifndef BOOST_CORE_REF_HPP
  