fml::UniqueObject< T, Traits > Class Template Reference

#include <unique_object.h>

Public Types
using	element_type = T
using	traits_type = Traits

Public Member Functions
	UniqueObject ()
	UniqueObject (const T &value)
	UniqueObject (const T &value, const Traits &traits)
	UniqueObject (UniqueObject &&other)
	~UniqueObject ()
UniqueObject &	operator= (UniqueObject &&other)
void	reset (const T &value=Traits::InvalidValue())
void	swap (UniqueObject &other)
T	release ()
const T &	get () const
bool	is_valid () const
bool	operator== (const T &value) const
bool	operator!= (const T &value) const
Traits &	get_traits ()
const Traits &	get_traits () const

Detailed Description

template<typename T, typename Traits>
class fml::UniqueObject< T, Traits >

Definition at line 28 of file unique_object.h.

Member Typedef Documentation

element_type

template<typename T , typename Traits >

using fml::UniqueObject< T, Traits >::element_type = T

Definition at line 44 of file unique_object.h.

traits_type

template<typename T , typename Traits >

using fml::UniqueObject< T, Traits >::traits_type = Traits

Definition at line 45 of file unique_object.h.

Constructor & Destructor Documentation

UniqueObject() [1/4]

template<typename T , typename Traits >

fml::UniqueObject< T, Traits >::UniqueObject ( )

inline

Definition at line 47 of file unique_object.h.

: data_(Traits::InvalidValue()) {}

UniqueObject() [2/4]

template<typename T , typename Traits >

fml::UniqueObject< T, Traits >::UniqueObject ( const T &  value )

inlineexplicit

Definition at line 48 of file unique_object.h.

: data_(value) {}

UniqueObject() [3/4]

template<typename T , typename Traits >

fml::UniqueObject< T, Traits >::UniqueObject ( const T &  value, const Traits &  traits  )

inline

Definition at line 50 of file unique_object.h.

: data_(value, traits) {}

UniqueObject() [4/4]

template<typename T , typename Traits >

fml::UniqueObject< T, Traits >::UniqueObject ( UniqueObject< T, Traits > &&  other )

inline

Definition at line 52 of file unique_object.h.

      : data_(other.release(), other.get_traits()) {}

~UniqueObject()

template<typename T , typename Traits >

fml::UniqueObject< T, Traits >::~UniqueObject ( )

inline

Definition at line 55 of file unique_object.h.

{ FreeIfNecessary(); }

Member Function Documentation

get()

template<typename T , typename Traits >

const T & fml::UniqueObject< T, Traits >::get ( ) const

inline

Definition at line 87 of file unique_object.h.

{ return data_.generic; }

get_traits() [1/2]

template<typename T , typename Traits >

Traits & fml::UniqueObject< T, Traits >::get_traits ( )

inline

Definition at line 95 of file unique_object.h.

{ return data_; }

get_traits() [2/2]

template<typename T , typename Traits >

const Traits & fml::UniqueObject< T, Traits >::get_traits ( ) const

inline

Definition at line 96 of file unique_object.h.

{ return data_; }

is_valid()

template<typename T , typename Traits >

bool fml::UniqueObject< T, Traits >::is_valid ( ) const

inline

Definition at line 89 of file unique_object.h.

{ return Traits::IsValid(data_.generic); }

operator!=()

template<typename T , typename Traits >

bool fml::UniqueObject< T, Traits >::operator!= ( const T &  value ) const

inline

Definition at line 93 of file unique_object.h.

{ return data_.generic != value; }

operator=()

template<typename T , typename Traits >

UniqueObject & fml::UniqueObject< T, Traits >::operator= ( UniqueObject< T, Traits > &&  other )

inline

Definition at line 57 of file unique_object.h.

                                                {
    reset(other.release());
    return *this;
  }

operator==()

template<typename T , typename Traits >

bool fml::UniqueObject< T, Traits >::operator== ( const T &  value ) const

inline

Definition at line 91 of file unique_object.h.

{ return data_.generic == value; }

release()

template<typename T , typename Traits >

T fml::UniqueObject< T, Traits >::release ( )

inline

Definition at line 81 of file unique_object.h.

                            {
    T old_generic = data_.generic;
    data_.generic = Traits::InvalidValue();
    return old_generic;
  }

reset()

template<typename T , typename Traits >

void fml::UniqueObject< T, Traits >::reset ( const T &  value = Traits::InvalidValue() )

inline

Definition at line 62 of file unique_object.h.

                                                    {
    FML_CHECK(data_.generic == Traits::InvalidValue() ||
              data_.generic != value);
    FreeIfNecessary();
    data_.generic = value;
  }

swap()

template<typename T , typename Traits >

void fml::UniqueObject< T, Traits >::swap ( UniqueObject< T, Traits > &  other )

inline

Definition at line 69 of file unique_object.h.

                                 {
    // Standard swap idiom: 'using std::swap' ensures that std::swap is
    // present in the overload set, but we call swap unqualified so that
    // any more-specific overloads can be used, if available.
    using std::swap;
    swap(static_cast<Traits&>(data_), static_cast<Traits&>(other.data_));
    swap(data_.generic, other.data_.generic);
  }

---

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

• fml/unique_object.h