folly::DiscriminatedPtr< Types > Class Template Reference

#include <DiscriminatedPtr.h>

Public Member Functions
	DiscriminatedPtr ()
template<typename T >
	DiscriminatedPtr (T *ptr)
template<typename T >
void	set (T *ptr)
template<typename T >
T *	get_nothrow () noexcept
template<typename T >
const T *	get_nothrow () const noexcept
template<typename T >
T *	get ()
template<typename T >
const T *	get () const
bool	empty () const
template<typename T >
bool	hasType () const
void	clear ()
template<typename T >
DiscriminatedPtr &	operator= (T *ptr)
template<typename V >
dptr_detail::VisitorResult< V, Types... >::type	apply (V &&visitor)
template<typename V >
dptr_detail::ConstVisitorResult< V, Types... >::type	apply (V &&visitor) const

Private Member Functions
template<typename T >
uint16_t	typeIndex () const
uint16_t	index () const
void *	ptr () const
void	set (void *p, uint16_t v)

Private Attributes
uintptr_t	data_

Detailed Description

template<typename... Types>
class folly::DiscriminatedPtr< Types >

Discriminated pointer.

Given a list of types, a DiscriminatedPtr<Types...> may point to an object of one of the given types, or may be empty. DiscriminatedPtr is type-safe: you may only get a pointer to the type that you put in, otherwise get throws an exception (and get_nothrow returns nullptr)

This pointer does not do any kind of lifetime management – it's not a "smart" pointer. You are responsible for deallocating any memory used to hold pointees, if necessary.

Definition at line 57 of file DiscriminatedPtr.h.

Constructor & Destructor Documentation

template<typename... Types>

folly::DiscriminatedPtr< Types >::DiscriminatedPtr ( )

inline

Create an empty DiscriminatedPtr.

Definition at line 67 of file DiscriminatedPtr.h.

: data_(0) {}

template<typename... Types>

template<typename T >

folly::DiscriminatedPtr< Types >::DiscriminatedPtr ( T *  ptr )

inlineexplicit

Create a DiscriminatedPtr that points to an object of type T. Fails at compile time if T is not a valid type (listed in Types)

Definition at line 74 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::ptr().

                                    {
    set(ptr, typeIndex<T>());
  }

Member Function Documentation

template<typename... Types>

template<typename V >

dptr_detail::VisitorResult<V, Types...>::type folly::DiscriminatedPtr< Types >::apply ( V &&  visitor )

inline

Apply a visitor to this object, calling the appropriate overload for the type currently stored in DiscriminatedPtr. Throws invalid_argument if the DiscriminatedPtr is empty.

The visitor must meet the following requirements:

• The visitor must allow invocation as a function by overloading operator(), unambiguously accepting all values of type T* (or const T*) for all T in Types...
• All operations of the function object on T* (or const T*) must return the same type (or a static_assert will fire).

Definition at line 174 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::index(), and folly::DiscriminatedPtr< Types >::ptr().

                                                                        {
    size_t n = index();
    if (n == 0) {
      throw std::invalid_argument("Empty DiscriminatedPtr");
    }
    return dptr_detail::ApplyVisitor<V, Types...>()(
        n, std::forward<V>(visitor), ptr());
  }

template<typename... Types>

template<typename V >

dptr_detail::ConstVisitorResult<V, Types...>::type folly::DiscriminatedPtr< Types >::apply ( V &&  visitor ) const

inline

Definition at line 184 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::index(), and folly::DiscriminatedPtr< Types >::ptr().

                         {
    size_t n = index();
    if (n == 0) {
      throw std::invalid_argument("Empty DiscriminatedPtr");
    }
    return dptr_detail::ApplyConstVisitor<V, Types...>()(
        n, std::forward<V>(visitor), ptr());
  }

template<typename... Types>

void folly::DiscriminatedPtr< Types >::clear ( )

inline

Clear this DiscriminatedPtr, making it empty.

Definition at line 147 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::data_.

               {
    data_ = 0;
  }

template<typename... Types>

bool folly::DiscriminatedPtr< Types >::empty ( ) const

inline

Return true iff this DiscriminatedPtr is empty.

Definition at line 130 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::index().

                     {
    return index() == 0;
  }

template<typename... Types>

template<typename T >

T* folly::DiscriminatedPtr< Types >::get ( )

inline

Get a pointer to the object that this DiscriminatedPtr points to, if it is of type T. Fails at compile time if T is not a valid type (listed in Types), and throws std::invalid_argument if this DiscriminatedPtr is empty or points to an object of a different type.

Definition at line 112 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::ptr(), folly::T, and UNLIKELY.

           {
    if (UNLIKELY(!hasType<T>())) {
      throw std::invalid_argument("Invalid type");
    }
    return static_cast<T*>(ptr());
  }

template<typename... Types>

template<typename T >

const T* folly::DiscriminatedPtr< Types >::get ( ) const

inline

Definition at line 120 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::ptr(), folly::T, and UNLIKELY.

                       {
    if (UNLIKELY(!hasType<T>())) {
      throw std::invalid_argument("Invalid type");
    }
    return static_cast<const T*>(ptr());
  }

template<typename... Types>

template<typename T >

T* folly::DiscriminatedPtr< Types >::get_nothrow ( )

inlinenoexcept

Get a pointer to the object that this DiscriminatedPtr points to, if it is of type T. Fails at compile time if T is not a valid type (listed in Types), and returns nullptr if this DiscriminatedPtr is empty or points to an object of a different type.

Definition at line 94 of file DiscriminatedPtr.h.

References LIKELY, folly::DiscriminatedPtr< Types >::ptr(), and folly::T.

                            {
    void* p = LIKELY(hasType<T>()) ? ptr() : nullptr;
    return static_cast<T*>(p);
  }

template<typename... Types>

template<typename T >

const T* folly::DiscriminatedPtr< Types >::get_nothrow ( ) const

inlinenoexcept

Definition at line 100 of file DiscriminatedPtr.h.

References LIKELY, folly::DiscriminatedPtr< Types >::ptr(), and folly::T.

                                        {
    const void* p = LIKELY(hasType<T>()) ? ptr() : nullptr;
    return static_cast<const T*>(p);
  }

template<typename... Types>

template<typename T >

bool folly::DiscriminatedPtr< Types >::hasType ( ) const

inline

Return true iff the object pointed by this DiscriminatedPtr has type T, false otherwise. Fails at compile time if T is not a valid type (listed in Types...)

Definition at line 140 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::index().

                       {
    return index() == typeIndex<T>();
  }

template<typename... Types>

uint16_t folly::DiscriminatedPtr< Types >::index ( ) const

inlineprivate

Definition at line 203 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::data_.

Referenced by folly::DiscriminatedPtr< Types >::apply(), folly::DiscriminatedPtr< Types >::empty(), and folly::DiscriminatedPtr< Types >::hasType().

                         {
    return data_ >> 48;
  }

template<typename... Types>

template<typename T >

DiscriminatedPtr& folly::DiscriminatedPtr< Types >::operator= ( T *  ptr )

inline

Assignment operator from a pointer of type T.

Definition at line 155 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::ptr().

                                      {
    set(ptr);
    return *this;
  }

template<typename... Types>

void* folly::DiscriminatedPtr< Types >::ptr ( ) const

inlineprivate

Definition at line 206 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::data_.

Referenced by folly::DiscriminatedPtr< Types >::apply(), folly::DiscriminatedPtr< Types >::DiscriminatedPtr(), folly::DiscriminatedPtr< Types >::get(), folly::DiscriminatedPtr< Types >::get_nothrow(), folly::DiscriminatedPtr< Types >::operator=(), and folly::DiscriminatedPtr< Types >::set().

                    {
    return reinterpret_cast<void*>(data_ & ((1ULL << 48) - 1));
  }

template<typename... Types>

template<typename T >

void folly::DiscriminatedPtr< Types >::set ( T *  ptr )

inline

Set this DiscriminatedPtr to point to an object of type T. Fails at compile time if T is not a valid type (listed in Types)

Definition at line 83 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::ptr().

                   {
    set(ptr, typeIndex<T>());
  }

template<typename... Types>

void folly::DiscriminatedPtr< Types >::set ( void *  p, uint16_t  v  )

inlineprivate

Definition at line 210 of file DiscriminatedPtr.h.

References folly::DiscriminatedPtr< Types >::data_, and v.

                                {
    uintptr_t ip = reinterpret_cast<uintptr_t>(p);
    CHECK(!(ip >> 48));
    ip |= static_cast<uintptr_t>(v) << 48;
    data_ = ip;
  }

template<typename... Types>

template<typename T >

uint16_t folly::DiscriminatedPtr< Types >::typeIndex ( ) const

inlineprivate

Get the 1-based type index of T in Types.

Definition at line 199 of file DiscriminatedPtr.h.

References uint16_t.

                             {
    return uint16_t(dptr_detail::GetTypeIndex<T, Types...>::value);
  }

Member Data Documentation

template<typename... Types>

uintptr_t folly::DiscriminatedPtr< Types >::data_

private

We store a pointer in the least significant 48 bits of data_, and a type index (0 = empty, or 1-based index in Types) in the most significant 16 bits. We rely on the fact that pointers have their most significant 16 bits clear on x86_64.

Definition at line 223 of file DiscriminatedPtr.h.

Referenced by folly::DiscriminatedPtr< Types >::clear(), folly::DiscriminatedPtr< Types >::index(), folly::DiscriminatedPtr< Types >::ptr(), and folly::DiscriminatedPtr< Types >::set().

---

The documentation for this class was generated from the following file:

• proxygen/folly/folly/DiscriminatedPtr.h