Platform::Agile< T, TIsNotAgile > Class Template Reference

#include <agile.h>

Public Member Functions
	Agile () throw ()
	Agile (nullptr_t) throw ()
	Agile (TypeT object) throw ()
	Agile (const Agile &object) throw ()
	Agile (Agile &&object) throw ()
	~Agile () throw ()
TypeT	Get () const
TypeT *	GetAddressOf () throw ()
TypeT *	GetAddressOfForInOut () throw ()
TypeT	operator-> () const throw ()
Agile &	operator= (nullptr_t) throw ()
Agile &	operator= (TypeT object) throw ()
Agile &	operator= (Agile object) throw ()
void	Swap (Agile &object)
void	Release () throw ()
bool	operator== (nullptr_t) const throw ()
bool	operator== (const Agile &other) const throw ()
bool	operator< (const Agile &other) const throw ()

Private Types
enum	AgileState { AgileState::NonAgilePointer = 0, AgileState::AgilePointer = 1, AgileState::Unknown = 2 }
typedef Details::AgileTypeHelper< T >::agileMemberType	TypeT

Private Member Functions
void	CaptureContext ()
void	SetObject (TypeT object)

Private Attributes
TypeT	_object
::Microsoft::WRL::ComPtr< ::IUnknown >	_contextCallback
ULONG_PTR	_contextToken
AgileState	_agileState

Member Typedef Documentation

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

typedef Details::AgileTypeHelper<T>::agileMemberType Platform::Agile< T, TIsNotAgile >::TypeT

private

Member Enumeration Documentation

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

enum Platform::Agile::AgileState

strongprivate

Enumerator
NonAgilePointer
AgilePointer
Unknown

        {
            NonAgilePointer = 0,
            AgilePointer = 1,
            Unknown = 2
        };

Constructor & Destructor Documentation

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Platform::Agile< T, TIsNotAgile >::Agile ( ) throw ( )

inline

                        : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
        {
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Platform::Agile< T, TIsNotAgile >::Agile ( nullptr_t  ) throw ( )

inline

                                 : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
        {
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Platform::Agile< T, TIsNotAgile >::Agile ( TypeT  object ) throw ( )

inlineexplicit

                                             : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
        {
            // Assumes that the source object is from the current context
            SetObject(object);
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Platform::Agile< T, TIsNotAgile >::Agile ( const Agile< T, TIsNotAgile > &  object ) throw ( )

inline

                                           : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
        {
            // Get returns pointer valid for current context
            SetObject(object.Get());
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Platform::Agile< T, TIsNotAgile >::Agile ( Agile< T, TIsNotAgile > &&  object ) throw ( )

inline

                                       : _object(nullptr), _contextToken(0), _agileState(AgileState::Unknown)
        {
            // Assumes that the source object is from the current context
            Swap(object);
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Platform::Agile< T, TIsNotAgile >::~Agile ( ) throw ( )

inline

        {
            Release();
        }

Member Function Documentation

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

void Platform::Agile< T, TIsNotAgile >::CaptureContext ( )

inlineprivate

        {
            _contextCallback = Details::GetObjectContext();
            __abi_ThrowIfFailed(CoGetContextToken(&_contextToken));
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

TypeT Platform::Agile< T, TIsNotAgile >::Get ( ) const

inline

        {
            // Agile object, no proxy required
            if (_agileState == AgileState::AgilePointer || _object == nullptr)
            {
                return _object;
            }

            // Do the check for same context
            ULONG_PTR currentContextToken;
            __abi_ThrowIfFailed(CoGetContextToken(&currentContextToken));
            if (currentContextToken == _contextToken)
            {
                return _object;
            }

            // Different context and holding on to a non agile object
            // Do the costly work of getting a proxy
            TypeT localObject;
            __abi_ThrowIfFailed(Details::GetProxy(_object, _contextCallback.Get(), &localObject));

            if (_agileState == AgileState::Unknown)
            {
                // Object is agile if it implements IAgileObject
                // GetAddressOf captures the context with out knowing the type of object that it will hold
                ::Microsoft::WRL::ComPtr< ::IAgileObject> checkIfAgile;
                HRESULT hr = reinterpret_cast<IUnknown*>(localObject)->QueryInterface(__uuidof(::IAgileObject), &checkIfAgile);
                if (hr == S_OK)
                {
                    auto pThis = const_cast<Agile*>(this);
                    pThis->_agileState = AgileState::AgilePointer;
                    pThis->_contextToken = 0;
                    pThis->_contextCallback = nullptr;
                    return _object;
                }
                else
                {
                    auto pThis = const_cast<Agile*>(this);
                    pThis->_agileState = AgileState::NonAgilePointer;
                }
            }

            return localObject;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

TypeT* Platform::Agile< T, TIsNotAgile >::GetAddressOf ( ) throw ( )

inline

        {
            Release();
            CaptureContext();
            return &_object;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

TypeT* Platform::Agile< T, TIsNotAgile >::GetAddressOfForInOut ( ) throw ( )

inline

        {
            CaptureContext();
            return &_object;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

TypeT Platform::Agile< T, TIsNotAgile >::operator-> ( ) const throw ( )

inline

        {
            return Get();
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

bool Platform::Agile< T, TIsNotAgile >::operator< ( const Agile< T, TIsNotAgile > &  other ) const throw ( )

inline

        {
            if (reinterpret_cast<void*>(_object) < reinterpret_cast<void*>(other._object))
            {
                return true;
            }

            return _object == other._object && _contextToken < other._contextToken;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Agile& Platform::Agile< T, TIsNotAgile >::operator= ( nullptr_t  ) throw ( )

inline

        {
            Release();
            return *this;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Agile& Platform::Agile< T, TIsNotAgile >::operator= ( TypeT  object ) throw ( )

inline

        {
            Agile(object).Swap(*this);
            return *this;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

Agile& Platform::Agile< T, TIsNotAgile >::operator= ( Agile< T, TIsNotAgile >  object ) throw ( )

inline

        {
            // parameter is by copy which gets pointer valid for current context 
            object.Swap(*this);
            return *this;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

bool Platform::Agile< T, TIsNotAgile >::operator== ( nullptr_t  ) const throw ( )

inline

        {
            return _object == nullptr;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

bool Platform::Agile< T, TIsNotAgile >::operator== ( const Agile< T, TIsNotAgile > &  other ) const throw ( )

inline

        {
            return _object == other._object && _contextToken == other._contextToken;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

void Platform::Agile< T, TIsNotAgile >::Release ( ) throw ( )

inline

        {
            if (_object)
            {
                // Cast to IInspectable (no QI)
                IUnknown* pObject = *(::IUnknown**) (&_object);
                // Set ^ to null without release
                *(IUnknown**) (&_object) = nullptr;

                ULONG_PTR currentContextToken;
                __abi_ThrowIfFailed(CoGetContextToken(&currentContextToken));
                if (_contextToken == 0 || _contextCallback == nullptr || _contextToken == currentContextToken)
                {
                    pObject->Release();
                }
                else
                {
                    Details::ReleaseInContext(pObject, _contextCallback.Get());
                }
                _contextCallback = nullptr;
                _contextToken = 0;
                _agileState = AgileState::Unknown;
            }
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

void Platform::Agile< T, TIsNotAgile >::SetObject ( TypeT  object )

inlineprivate

        {
            // Capture context before setting the pointer
            // If context capture fails then nothing to cleanup
            Release();
            if (object != nullptr)
            {
                ::Microsoft::WRL::ComPtr< ::IAgileObject> checkIfAgile;
                HRESULT hr = reinterpret_cast< ::IUnknown*>(object)->QueryInterface(__uuidof(::IAgileObject), &checkIfAgile);
                // Don't Capture context if object is agile
                if (hr != S_OK)
                {
                    _agileState = AgileState::NonAgilePointer;
                    CaptureContext();
                }
                else
                {
                    _agileState = AgileState::AgilePointer;
                }
            }
            _object = object;
        }

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

void Platform::Agile< T, TIsNotAgile >::Swap ( Agile< T, TIsNotAgile > &  object )

inline

        {
            std::swap(_object, object._object);
            std::swap(_contextCallback, object._contextCallback);
            std::swap(_contextToken, object._contextToken);
            std::swap(_agileState, object._agileState);
        }

Member Data Documentation

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

AgileState Platform::Agile< T, TIsNotAgile >::_agileState

private

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

::Microsoft::WRL::ComPtr< ::IUnknown> Platform::Agile< T, TIsNotAgile >::_contextCallback

private

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

ULONG_PTR Platform::Agile< T, TIsNotAgile >::_contextToken

private

template<typename T, bool TIsNotAgile = (__is_win_class(typename Details::AgileTypeHelper<T>::type) && !__is_winrt_agile(typename Details::AgileTypeHelper<T>::type)) || __is_win_interface(typename Details::AgileTypeHelper<T>::type)>

TypeT Platform::Agile< T, TIsNotAgile >::_object

private

---

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

• VS2015/inc/agile.h