AccessPrivate.h File Reference

#include <utility>
#include <type_traits>

Include dependency graph for AccessPrivate.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Namespaces
namespace	private_access_detail

Macros
#define	PRIVATE_ACCESS_DETAIL_CONCATENATE_IMPL(x, y)
#define	PRIVATE_ACCESS_DETAIL_CONCATENATE(x, y)
#define	PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE(Tag, Class, Type, Name, PtrTypeKind)
#define	PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FIELD(Tag, Class, Type, Name)
#define	PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FUN(Tag, Class, Type, Name)
#define	PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FIELD(Tag, Class, Type, Name)
#define	PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FUN(Tag, Class, Type, Name)
#define	PRIVATE_ACCESS_DETAIL_UNIQUE_TAG    PRIVATE_ACCESS_DETAIL_CONCATENATE(PrivateAccessTag, __COUNTER__)
#define	ACCESS_PRIVATE_FIELD(Class, Type, Name)
#define	ACCESS_PRIVATE_FUN(Class, Type, Name)
#define	ACCESS_PRIVATE_STATIC_FIELD(Class, Type, Name)
#define	ACCESS_PRIVATE_STATIC_FUN(Class, Type, Name)

Macro Definition Documentation

ACCESS_PRIVATE_FIELD

#define ACCESS_PRIVATE_FIELD	(		Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FIELD(PRIVATE_ACCESS_DETAIL_UNIQUE_TAG, \
                                             Class, Type, Name)

ACCESS_PRIVATE_FUN

#define ACCESS_PRIVATE_FUN	(		Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FUN(PRIVATE_ACCESS_DETAIL_UNIQUE_TAG,   \
                                           Class, Type, Name)

ACCESS_PRIVATE_STATIC_FIELD

#define ACCESS_PRIVATE_STATIC_FIELD	(		Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FIELD(                           \
      PRIVATE_ACCESS_DETAIL_UNIQUE_TAG, Class, Type, Name)

ACCESS_PRIVATE_STATIC_FUN

#define ACCESS_PRIVATE_STATIC_FUN	(		Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FUN(                             \
      PRIVATE_ACCESS_DETAIL_UNIQUE_TAG, Class, Type, Name)

PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE

#define PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE	(		Tag,
			Class,
			Type,
			Name,
			PtrTypeKind )

Value:

  namespace {                                                                  \
    namespace private_access_detail {                                          \
      /* Tag type, used to declare different get funcitons for different       \
       * members                                                               \
       */                                                                      \
      struct Tag {};                                                           \
      /* Explicit instantiation */                                             \
      template struct private_access<decltype(&Class::Name), &Class::Name,     \
                                     Tag>;                                     \
      /* We can build the PtrType only with two aliases */                     \
      /* E.g. using PtrType = int(int) *; would be illformed */                \
      using PRIVATE_ACCESS_DETAIL_CONCATENATE(Alias_, Tag) = Type;             \
      using PRIVATE_ACCESS_DETAIL_CONCATENATE(PtrType_, Tag) =                 \
          PRIVATE_ACCESS_DETAIL_CONCATENATE(Alias_, Tag) PtrTypeKind;          \
      /* Declare the friend function, now it is visible in namespace scope.    \
       * Note,                                                                 \
       * we could declare it inside the Tag type too, in that case ADL would   \
       * find                                                                  \
       * the declaration. By choosing to declare it here, the Tag type remains \
       * a                                                                     \
       * simple tag type, it has no other responsibilities. */                 \
      PRIVATE_ACCESS_DETAIL_CONCATENATE(PtrType_, Tag) get(Tag);               \
    }                                                                          \
  }

PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FIELD

#define PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FIELD	(		Tag,
			Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE(Tag, Class, Type, Name, Class::*)       \
  namespace {                                                                  \
    namespace access_private {                                                 \
      Type &Name(Class &&t) { return t.*get(private_access_detail::Tag{}); }   \
      Type &Name(Class &t) { return t.*get(private_access_detail::Tag{}); }    \
      /* The following usings are here to avoid duplicate const qualifier      \
       * warnings                                                              \
       */                                                                      \
      using PRIVATE_ACCESS_DETAIL_CONCATENATE(X, Tag) = Type;                  \
      using PRIVATE_ACCESS_DETAIL_CONCATENATE(Y, Tag) =                        \
          const PRIVATE_ACCESS_DETAIL_CONCATENATE(X, Tag);                     \
      PRIVATE_ACCESS_DETAIL_CONCATENATE(Y, Tag) & Name(const Class &t) {       \
        return t.*get(private_access_detail::Tag{});                           \
      }                                                                        \
    }                                                                          \
  }

PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FUN

#define PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_FUN	(		Tag,
			Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE(Tag, Class, Type, Name, Class::*)       \
  namespace {                                                                  \
    namespace call_private {                                                   \
      /* We do perfect forwarding, but we want to restrict the overload set    \
       * only for objects which have the type Class. */                        \
      template <typename Obj,                                                  \
                std::enable_if_t<std::is_same<std::remove_reference_t<Obj>,    \
                                              Class>::value> * = nullptr,      \
                typename... Args>                                              \
      auto Name(Obj &&o, Args &&... args) -> decltype(                         \
          (std::forward<Obj>(o).*                                              \
           get(private_access_detail::Tag{}))(std::forward<Args>(args)...)) {  \
        return (std::forward<Obj>(o).*get(private_access_detail::Tag{}))(      \
            std::forward<Args>(args)...);                                      \
      }                                                                        \
    }                                                                          \
  }

PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FIELD

#define PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FIELD	(		Tag,
			Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE(Tag, Class, Type, Name, *)              \
  namespace {                                                                  \
    namespace access_private_static {                                          \
      namespace Class {                                                        \
        Type &Name() { return *get(private_access_detail::Tag{}); }            \
      }                                                                        \
    }                                                                          \
  }

PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FUN

#define PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE_STATIC_FUN	(		Tag,
			Class,
			Type,
			Name )

Value:

  PRIVATE_ACCESS_DETAIL_ACCESS_PRIVATE(Tag, Class, Type, Name, *)              \
  namespace {                                                                  \
    namespace call_private_static {                                            \
      namespace Class {                                                        \
        template <typename... Args>                                            \
        auto Name(Args &&... args) -> decltype(                                \
            get(private_access_detail::Tag{})(std::forward<Args>(args)...)) {  \
          return get(private_access_detail::Tag{})(                            \
              std::forward<Args>(args)...);                                    \
        }                                                                      \
      }                                                                        \
    }                                                                          \
  }

PRIVATE_ACCESS_DETAIL_CONCATENATE

#define PRIVATE_ACCESS_DETAIL_CONCATENATE	(		x,
			y )

Value:

  PRIVATE_ACCESS_DETAIL_CONCATENATE_IMPL(x, y)

PRIVATE_ACCESS_DETAIL_CONCATENATE_IMPL

#define PRIVATE_ACCESS_DETAIL_CONCATENATE_IMPL	(		x,
			y )

Value:

x##y

PRIVATE_ACCESS_DETAIL_UNIQUE_TAG

#define PRIVATE_ACCESS_DETAIL_UNIQUE_TAG    PRIVATE_ACCESS_DETAIL_CONCATENATE(PrivateAccessTag, __COUNTER__)