/* Copyright 2003-2022 Joaquin M Lopez Munoz.

 * 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/multi_index for library home page.

 */

#ifndef BOOST_MULTI_INDEX_MEMBER_HPP

#define BOOST_MULTI_INDEX_MEMBER_HPP

#if defined(_MSC_VER)

#pragma once

#endif

#include <boost/config.hpp> /* keep it first to prevent nasty warns in MSVC */

#include <boost/core/enable_if.hpp>

#include <boost/mpl/if.hpp>

#include <boost/type_traits/is_const.hpp>

#include <cstddef>

#if !defined(BOOST_NO_SFINAE)

#include <boost/type_traits/is_convertible.hpp>

#endif

namespace boost{

template<class T> class reference_wrapper; /* fwd decl. */

namespace multi_index{

namespace detail{

/* member is a read/write key extractor for accessing a given

 * member of a class.

 * Additionally, member is overloaded to support referece_wrappers

 * of T and "chained pointers" to T's. By chained pointer to T we mean

 * a type P  such that, given a p of Type P

 *   *...n...*x is convertible to T&, for some n>=1.

 * Examples of chained pointers are raw and smart pointers, iterators and

 * arbitrary combinations of these (vg. T** or unique_ptr<T*>.)

 */

template<class Class,typename Type,Type Class::*PtrToMember>

struct const_member_base

{

  typedef Type result_type;

  template<typename ChainedPtr>

#if !defined(BOOST_NO_SFINAE)

  typename disable_if<

    is_convertible<const ChainedPtr&,const Class&>,Type&>::type

#else

  Type&

#endif

  operator()(const ChainedPtr& x)const

  {

    return operator()(*x);

  }

  Type& operator()(const Class& x)const

  {

    return x.*PtrToMember;

  }

  Type& operator()(const reference_wrapper<const Class>& x)const

  {

    return operator()(x.get());

  }

  Type& operator()(const reference_wrapper<Class>& x)const

  { 

    return operator()(x.get());

  }

};

template<class Class,typename Type,Type Class::*PtrToMember>

struct non_const_member_base

{

  typedef Type result_type;

  template<typename ChainedPtr>

#if !defined(BOOST_NO_SFINAE)

  typename disable_if<

    is_convertible<const ChainedPtr&,const Class&>,Type&>::type

#else

  Type&

#endif

  operator()(const ChainedPtr& x)const

  {

    return operator()(*x);

  }

  const Type& operator()(const Class& x)const

  {

    return x.*PtrToMember;

  }

  Type& operator()(Class& x)const

  { 

    return x.*PtrToMember;

  }

  const Type& operator()(const reference_wrapper<const Class>& x)const

  {

    return operator()(x.get());

  }

  Type& operator()(const reference_wrapper<Class>& x)const

  { 

    return operator()(x.get());

  }

};

} /* namespace multi_index::detail */

template<class Class,typename Type,Type Class::*PtrToMember>

struct member:

  mpl::if_c<

    is_const<Type>::value,

    detail::const_member_base<Class,Type,PtrToMember>,

    detail::non_const_member_base<Class,Type,PtrToMember>

  >::type

{

};

namespace detail{

/* MSVC++ 6.0 does not support properly pointers to members as

 * non-type template arguments, as reported in

 *   http://support.microsoft.com/default.aspx?scid=kb;EN-US;249045

 * A similar problem (though not identical) is shown by MSVC++ 7.0.

 * We provide an alternative to member<> accepting offsets instead

 * of pointers to members. This happens to work even for non-POD

 * types (although the standard forbids use of offsetof on these),

 * so it serves as a workaround in this compiler for all practical

 * purposes.

 * Surprisingly enough, other compilers, like Intel C++ 7.0/7.1 and

 * Visual Age 6.0, have similar bugs. This replacement of member<>

 * can be used for them too.

 *

 * Support for such old compilers is dropped and

 * [non_]const_member_offset_base is deprecated.

 */

template<class Class,typename Type,std::size_t OffsetOfMember>

struct const_member_offset_base

{

  typedef Type result_type;

  template<typename ChainedPtr>

#if !defined(BOOST_NO_SFINAE)

  typename disable_if<

    is_convertible<const ChainedPtr&,const Class&>,Type&>::type

#else

  Type&

#endif 

  operator()(const ChainedPtr& x)const

  {

    return operator()(*x);

  }

  Type& operator()(const Class& x)const

  {

    return *static_cast<const Type*>(

      static_cast<const void*>(

        static_cast<const char*>(

          static_cast<const void *>(&x))+OffsetOfMember));

  }

  Type& operator()(const reference_wrapper<const Class>& x)const

  {

    return operator()(x.get());

  }

  Type& operator()(const reference_wrapper<Class>& x)const

  {

    return operator()(x.get());

  }

};

template<class Class,typename Type,std::size_t OffsetOfMember>

struct non_const_member_offset_base

{

  typedef Type result_type;

  template<typename ChainedPtr>

#if !defined(BOOST_NO_SFINAE)

  typename disable_if<

    is_convertible<const ChainedPtr&,const Class&>,Type&>::type

#else

  Type&

#endif 

  operator()(const ChainedPtr& x)const

  {

    return operator()(*x);

  }

  const Type& operator()(const Class& x)const

  {

    return *static_cast<const Type*>(

      static_cast<const void*>(

        static_cast<const char*>(

          static_cast<const void *>(&x))+OffsetOfMember));

  }

  Type& operator()(Class& x)const

  { 

    return *static_cast<Type*>(

      static_cast<void*>(

        static_cast<char*>(static_cast<void *>(&x))+OffsetOfMember));

  }

  const Type& operator()(const reference_wrapper<const Class>& x)const

  {

    return operator()(x.get());

  }

  Type& operator()(const reference_wrapper<Class>& x)const

  {

    return operator()(x.get());

  }

};

} /* namespace multi_index::detail */

template<class Class,typename Type,std::size_t OffsetOfMember>

struct member_offset:

  mpl::if_c<

    is_const<Type>::value,

    detail::const_member_offset_base<Class,Type,OffsetOfMember>,

    detail::non_const_member_offset_base<Class,Type,OffsetOfMember>

  >::type

{

};

/* BOOST_MULTI_INDEX_MEMBER resolves to member in the normal cases,

 * and to member_offset as a workaround in those defective compilers for

 * which BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS is defined.

 */

#if defined(BOOST_NO_POINTER_TO_MEMBER_TEMPLATE_PARAMETERS)

#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \

::boost::multi_index::member_offset< Class,Type,offsetof(Class,MemberName) >

#else

#define BOOST_MULTI_INDEX_MEMBER(Class,Type,MemberName) \

::boost::multi_index::member< Class,Type,&Class::MemberName >

#endif

} /* namespace multi_index */

} /* namespace boost */

#endif