#include <inspectable.h>
#include <roapi.h>
#include <activation.h>
#include <WinString.h>
#include <new.h>
#include <weakreference.h>
#include <objbase.h>
#include <cguid.h>
#include <intrin.h>
#include <wrl\internal.h>
#include <wrl\def.h>
#include <wrl\client.h>

Include dependency graph for implements.h:

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

Go to the source code of this file.

Classes
struct	Microsoft::WRL::CloakedIid< T >

struct	Microsoft::WRL::RuntimeClassFlags< flags >

struct	Microsoft::WRL::Details::ImplementsBase

struct	Microsoft::WRL::MixIn< Derived, MixInType, hasImplements >

class	Microsoft::WRL::ComposableBase< FactoryInterface >

struct	Microsoft::WRL::ErrorHelper< RuntimeClassTypeT >

struct	Microsoft::WRL::ErrorHelper< InhibitRoOriginateError >

class	Microsoft::WRL::Details::ModuleBase

class	Microsoft::WRL::Details::Nil

class	Microsoft::WRL::Details::DontUseNewUseMake

class	Microsoft::WRL::Details::RuntimeClassBase

class	Microsoft::WRL::Details::RuntimeClassBaseT< RuntimeClassTypeT >

class	Microsoft::WRL::Details::FtmBaseMarker

struct	Microsoft::WRL::Details::VerifyInterfaceHelper< ClassicCom, I, doStrictCheck, false >

struct	Microsoft::WRL::Details::VerifyInterfaceHelper< WinRtClassicComMix, I, doStrictCheck, false >

struct	Microsoft::WRL::Details::VerifyInterfaceHelper< WinRt, I, doStrictCheck, false >

struct	Microsoft::WRL::Details::VerifyInterfaceHelper< type, I, true, true >

struct	Microsoft::WRL::Details::VerifyInterfaceHelper< type, I, false, true >

struct	Microsoft::WRL::Details::InterfaceTraits< I0 >

struct	Microsoft::WRL::Details::InterfaceTraits< CloakedIid< CloakedType > >

struct	Microsoft::WRL::Details::InterfaceTraits< Nil >

struct	Microsoft::WRL::Details::VerifyInheritanceHelper< I, Base >

struct	Microsoft::WRL::Details::VerifyInheritanceHelper< I, Nil >

struct	Microsoft::WRL::ChainInterfaces< I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 >

struct	Microsoft::WRL::ChainInterfaces< MixIn< DerivedType, BaseType, hasImplements >, I1, I2, I3, I4, I5, I6, I7, I8, I9 >

struct	Microsoft::WRL::Details::ImplementsMarker< T >

struct	Microsoft::WRL::Details::MarkImplements< I0, false >

struct	Microsoft::WRL::Details::MarkImplements< I0, true >

struct	Microsoft::WRL::Details::MarkImplements< CloakedIid< I0 >, true >

struct	Microsoft::WRL::Details::MarkImplements< MixIn< DerivedType, BaseType, hasImplements >, true >

struct	Microsoft::WRL::Details::AdjustImplements< RuntimeClassFlagsT, doStrictCheck, I0, Bases... >

struct	Microsoft::WRL::Details::AdjustImplements< RuntimeClassFlagsT, doStrictCheck, Details::Nil, Bases... >

struct	Microsoft::WRL::Details::AdjustImplements< RuntimeClassFlagsT, doStrictCheck >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, I0, TInterfaces... >

struct	Microsoft::WRL::Details::Selector< base, disciminator >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, ImplementsMarker< I0 >, TInterfaces... >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, CloakedIid< I0 >, I1, TInterfaces... >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, CloakedIid< I0 > >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, ChainInterfaces< C0, C1, C2, C3, C4, C5, C6, C7, C8, C9 >, TInterfaces... >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, MixIn< DerivedType, BaseMixInType, hasImplements >, TInterfaces... >

struct	Microsoft::WRL::Details::AreAllNil< I0,... >

struct	Microsoft::WRL::Details::AreAllNil< Microsoft::WRL::Details::Nil, TInterfaces... >

struct	Microsoft::WRL::Details::AreAllNil< Microsoft::WRL::Details::Nil >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, ComposableBase< FactoryInterface >, TInterfaces... >

struct	Microsoft::WRL::Details::ImplementsHelper< RuntimeClassFlagsT, doStrictCheck, ComposableBase< FactoryInterface > >

struct	Microsoft::WRL::Implements< I0, TInterfaces >

struct	Microsoft::WRL::Implements< RuntimeClassFlags< flags >, I0, TInterfaces... >

class	Microsoft::WRL::FtmBase

class	Microsoft::WRL::Details::RuntimeClassImpl< RuntimeClassFlagsT, implementsWeakReferenceSource, false, implementsFtmBase, TInterfaces... >

struct	Microsoft::WRL::Details::HasIInspectable< I, false >

struct	Microsoft::WRL::Details::HasIInspectable< I, true >

struct	Microsoft::WRL::Details::IInspectableInjector< I0, true >

struct	Microsoft::WRL::Details::IInspectableInjector< I0, false >

class	Microsoft::WRL::Details::RuntimeClassImpl< RuntimeClassFlagsT, false, true, false, I0, TInterfaces... >

class	Microsoft::WRL::Details::StrongReference

union	Microsoft::WRL::Details::ReferenceCountOrWeakReferencePointer

class	Microsoft::WRL::Details::RuntimeClassImpl< RuntimeClassFlagsT, true, true, false, I0, TInterfaces... >

class	Microsoft::WRL::Details::RuntimeClassImpl< RuntimeClassFlagsT, false, true, true, I0, TInterfaces... >

class	Microsoft::WRL::Details::RuntimeClassImpl< RuntimeClassFlagsT, true, true, true, I0, TInterfaces... >

struct	Microsoft::WRL::Details::InterfaceListHelper< TInterfaces >

class	Microsoft::WRL::Details::RuntimeClass< InterfaceListHelper< TInterfaces... >, RuntimeClassFlagsT, implementsWeakReferenceSource, implementsInspectable, implementsFtmBase >

class	Microsoft::WRL::RuntimeClass< TInterfaces >

class	Microsoft::WRL::RuntimeClass< RuntimeClassFlags< classFlags >, TInterfaces... >

class	Microsoft::WRL::Details::WeakReferenceImpl

class	Microsoft::WRL::Details::MakeAllocator< T >

Namespaces
namespace	Microsoft
	This file has no copyright assigned and is placed in the Public Domain.

namespace	Microsoft::WRL

namespace	Microsoft::WRL::Details

Macros
#define	WRT_NO_VTABLE

#define	DETAILS_RTCLASS_FLAGS_ARGUMENTS(RuntimeClassFlagsT)

#define	InspectableClass(runtimeClassName, trustLevel)

#define	MixInHelper()

#define	WrlCreatorMapIncludePragmaEx(className, group)

#define	WrlCreatorMapIncludePragma(className)

#define	ActivatableClassWithFactoryEx(className, factory, groupId)

#define	ActivatableClassWithFactory(className, factory)

#define	ActivatableClass(className) static_assert(false, "It's required to include 'wrl/module.h' to be able to use 'ActivatableClass' macro");

#define	ActivatableStaticOnlyFactoryEx(factory, serverName)

#define	ActivatableStaticOnlyFactory(factory)

#define	CoCreatableClassWithFactoryEx(className, factory, groupId)

#define	CoCreatableClassWithFactory(className, factory)

#define	CoCreatableClass(className) static_assert(false, "It's required to include 'wrl/module.h' to be able to use 'CoCreatableClass' macro");

#define	CoCreatableClassWrlCreatorMapInclude(className)

#define	CoCreatableClassWrlCreatorMapIncludeEx(className, groupId)

Typedefs
typedef RuntimeClassFlags< WinRt\|InhibitWeakReference >	Microsoft::WRL::InhibitWeakReferencePolicy

Enumerations
enum	Microsoft::WRL::RuntimeClassType { Microsoft::WRL::WinRt = 0x0001 , Microsoft::WRL::ClassicCom = 0x0002 , Microsoft::WRL::WinRtClassicComMix = WinRt \| ClassicCom , Microsoft::WRL::InhibitWeakReference = 0x0004 , Microsoft::WRL::Delegate = ClassicCom , Microsoft::WRL::InhibitFtmBase = 0x0008 , Microsoft::WRL::InhibitRoOriginateError = 0x0010 }

Functions
Details::ModuleBase *	Microsoft::WRL::GetModuleBase () throw ()

unsigned long	Microsoft::WRL::Details::SafeUnknownIncrementReference (long volatile &refcount) throw ()

unsigned long	Microsoft::WRL::Details::SafeUnknownDecrementReference (long volatile &refcount) throw ()

bool	Microsoft::WRL::Details::IsValueAPointerToWeakReference (INT_PTR value)

INT_PTR	Microsoft::WRL::Details::EncodeWeakReferencePointer (Microsoft::WRL::Details::WeakReferenceImpl *value)

Microsoft::WRL::Details::WeakReferenceImpl *	Microsoft::WRL::Details::DecodeWeakReferencePointer (INT_PTR value)

template<typename T >
T	Microsoft::WRL::Details::ReadValueFromPointerNoFence (const volatile T *value)

WeakReferenceImpl *	Microsoft::WRL::Details::CreateWeakReference (IUnknown *)

Variables
const CreatorMap *	Microsoft::WRL::Details::__pobjectentryfirst = nullptr

const CreatorMap *	Microsoft::WRL::Details::__pobjectentrymid = nullptr

const CreatorMap *	Microsoft::WRL::Details::__pobjectentrylast = nullptr

template<typename RuntimeClassFlagsT , bool doStrictCheck, typename... TInterfaces>
struct WRT_NO_VTABLE	Microsoft::WRL::Details::ImplementsHelper

template<typename I0 , bool isImplements>
struct WRT_NO_VTABLE	Microsoft::WRL::Details::MarkImplements

template<typename RuntimeClassFlagsT , bool doStrictCheck, typename... Bases>
struct WRT_NO_VTABLE	Microsoft::WRL::Details::AdjustImplements

template<class RuntimeClassFlagsT , bool implementsWeakReferenceSource, bool implementsInspectable, bool implementsFtmBase, typename... TInterfaces>
class WRT_NO_VTABLE	Microsoft::WRL::Details::RuntimeClassImpl

const UINT_PTR	Microsoft::WRL::Details::EncodeWeakReferencePointerFlag = static_cast<UINT_PTR>(1) << ((sizeof(UINT_PTR) * 8) - 1)

Macro Definition Documentation

◆ ActivatableClass

#define ActivatableClass ( className ) static_assert(false, "It's required to include 'wrl/module.h' to be able to use 'ActivatableClass' macro");

◆ ActivatableClassWithFactory

#define ActivatableClassWithFactory	(	className,
		factory
	)

Value:

static_assert( \

false, "It's required to include 'wrl/module.h' to be able to use 'ActivatableClassWithFactory' macro");

◆ ActivatableClassWithFactoryEx

#define ActivatableClassWithFactoryEx	(	className,
		factory,
		groupId
	)

Value:

static_assert( \

false, "It's required to include 'wrl/module.h' to be able to use 'ActivatableClassWithFactoryEx' macro");

◆ ActivatableStaticOnlyFactory

#define ActivatableStaticOnlyFactory ( factory )

Value:

static_assert( \

false, "It's required to include 'wrl/module.h' to be able to use 'ActivatableStaticOnlyFactory' macro");

◆ ActivatableStaticOnlyFactoryEx

#define ActivatableStaticOnlyFactoryEx	(	factory,
		serverName
	)

Value:

        static_assert( \
            false, \
            "It's required to include 'wrl/module.h' to be able to use 'ActivatableStaticOnlyFactoryEx' macro");

◆ CoCreatableClass

#define CoCreatableClass ( className ) static_assert(false, "It's required to include 'wrl/module.h' to be able to use 'CoCreatableClass' macro");

◆ CoCreatableClassWithFactory

#define CoCreatableClassWithFactory	(	className,
		factory
	)

Value:

static_assert( \

false, "It's required to include 'wrl/module.h' to be able to use 'CoCreatableClassWithFactory' macro");

◆ CoCreatableClassWithFactoryEx

#define CoCreatableClassWithFactoryEx	(	className,
		factory,
		groupId
	)

Value:

static_assert( \

false, "It's required to include 'wrl/module.h' to be able to use 'CoCreatableClassWithFactory' macro");

◆ CoCreatableClassWrlCreatorMapInclude

#define CoCreatableClassWrlCreatorMapInclude ( className )

Value:

        static_assert( \
            false, \
            "It's required to include 'wrl/module.h' to be able to use 'CoCreatableClassWrlCreatorMapInclude' macro");

◆ CoCreatableClassWrlCreatorMapIncludeEx

#define CoCreatableClassWrlCreatorMapIncludeEx	(	className,
		groupId
	)

Value:

        static_assert( \
            false, \
            "It's required to include 'wrl/module.h' to be able to use 'CoCreatableClassWrlCreatorMapInclude' macro");

◆ DETAILS_RTCLASS_FLAGS_ARGUMENTS

#define DETAILS_RTCLASS_FLAGS_ARGUMENTS ( RuntimeClassFlagsT )

Value:

RuntimeClassFlagsT, (RuntimeClassFlagsT::value & InhibitWeakReference) == 0, \

(RuntimeClassFlagsT::value & WinRt) == WinRt, __WRL_IMPLEMENTS_FTM_BASE__(RuntimeClassFlagsT::value)

__WRL_IMPLEMENTS_FTM_BASE__

#define __WRL_IMPLEMENTS_FTM_BASE__(flags)

Definition internal.h:21

◆ InspectableClass

#define InspectableClass	(	runtimeClassName,
		trustLevel
	)

◆ MixInHelper

#define MixInHelper ( )

Value:

\
  public: \
    STDMETHOD(QueryInterface)(REFIID riid, void** ppvObject) \
    { \
        static_assert( \
            (RuntimeClassT::ClassFlags::value & ::Microsoft::WRL::WinRt) == 0, \
            "'MixInClass' macro must not be used with WinRt clasess."); \
        static_assert( \
            __is_base_of(::Microsoft::WRL::Details::RuntimeClassBase, RuntimeClassT), \
            "'MixInHelper' macro can only be used with ::Windows::WRL::RuntimeClass types"); \
        static_assert( \
            !__is_base_of(IClassFactory, RuntimeClassT), \
            "Incorrect usage of IClassFactory interface. Make sure that your RuntimeClass doesn't implement " \
            "IClassFactory interface use ::Windows::WRL::ClassFactory instead or 'MixInHelper' macro is not used on " \
            "::Windows::WRL::ClassFactory"); \
        return RuntimeClassT::QueryInterface(riid, ppvObject); \
    } \
    STDMETHOD_(ULONG, Release)() \
    { \
        return RuntimeClassT::Release(); \
    } \
    STDMETHOD_(ULONG, AddRef)() \
    { \
        return RuntimeClassT::AddRef(); \
    } \
\
  private:

◆ WrlCreatorMapIncludePragma

#define WrlCreatorMapIncludePragma ( className )

Value:

static_assert( \

false, "It's required to include 'wrl/module.h' to be able to use 'WrlCreatorMapIncludePragma' macro");

◆ WrlCreatorMapIncludePragmaEx

#define WrlCreatorMapIncludePragmaEx	(	className,
		group
	)

Value:

static_assert( \

false, "It's required to include 'wrl/module.h' to be able to use 'WrlCreatorMapIncludePragmaEx' macro");

◆ WRT_NO_VTABLE

#define WRT_NO_VTABLE

Classes

Namespaces

Macros

Typedefs

Enumerations

Functions

Variables

Macro Definition Documentation

◆ ActivatableClass

◆ ActivatableClassWithFactory

◆ ActivatableClassWithFactoryEx

◆ ActivatableStaticOnlyFactory

◆ ActivatableStaticOnlyFactoryEx

◆ CoCreatableClass

◆ CoCreatableClassWithFactory

◆ CoCreatableClassWithFactoryEx

◆ CoCreatableClassWrlCreatorMapInclude

◆ CoCreatableClassWrlCreatorMapIncludeEx

◆ DETAILS_RTCLASS_FLAGS_ARGUMENTS

◆ InspectableClass

◆ MixInHelper

◆ WrlCreatorMapIncludePragma

◆ WrlCreatorMapIncludePragmaEx

◆ WRT_NO_VTABLE