ScopedTypeRef<> is patterned after std::unique_ptr<>, but maintains ownership of a reference to any type that is maintained by Retain and Release methods. More...

#include "include/base/cef_scoped_typeref_mac.h"

Public Types
using	element_type = T

Public Member Functions
constexpr	ScopedTypeRef (element_type object=Traits::InvalidValue(), base::scoped_policy::OwnershipPolicy policy=base::scoped_policy::ASSUME)

	ScopedTypeRef (const ScopedTypeRef< T, Traits > &that)

template<typename R , typename RTraits >
	ScopedTypeRef (const ScopedTypeRef< R, RTraits > &that_as_subclass)

	ScopedTypeRef (ScopedTypeRef< T, Traits > &&that)

	~ScopedTypeRef ()

ScopedTypeRef &	operator= (const ScopedTypeRef< T, Traits > &that)

element_type *	InitializeInto ()

void	reset (const ScopedTypeRef< T, Traits > &that)

void	reset (element_type object=Traits::InvalidValue(), base::scoped_policy::OwnershipPolicy policy=base::scoped_policy::ASSUME)

bool	operator== (const element_type &that) const

bool	operator!= (const element_type &that) const

	operator element_type () const

element_type	get () const

void	swap (ScopedTypeRef &that)

element_type	release ()

Detailed Description

template<typename T, typename Traits = ScopedTypeRefTraits<T>>
class base::ScopedTypeRef< T, Traits >

ScopedTypeRef<> is patterned after std::unique_ptr<>, but maintains ownership of a reference to any type that is maintained by Retain and Release methods.

The Traits structure must provide the Retain and Release methods for type T. A default ScopedTypeRefTraits is used but not defined, and should be defined for each type to use this interface. For example, an appropriate definition of ScopedTypeRefTraits for CGLContextObj would be:

  template<>
  struct ScopedTypeRefTraits<CGLContextObj> {
    static CGLContextObj InvalidValue() { return nullptr; }
    static CGLContextObj Retain(CGLContextObj object) {
      CGLContextRetain(object);
      return object;
    }
    static void Release(CGLContextObj object) { CGLContextRelease(object); }
  };

For the many types that have pass-by-pointer create functions, the function InitializeInto() is provided to allow direct initialization and assumption of ownership of the object. For example, continuing to use the above CGLContextObj specialization:

  base::ScopedTypeRef<CGLContextObj> context;
  CGLCreateContext(pixel_format, share_group, context.InitializeInto());

For initialization with an existing object, the caller may specify whether the ScopedTypeRef<> being initialized is assuming the caller's existing ownership of the object (and should not call Retain in initialization) or if it should not assume this ownership and must create its own (by calling Retain in initialization). This behavior is based on the |policy| parameter, with |ASSUME| for the former and |RETAIN| for the latter. The default policy is to |ASSUME|.