| ▼Nboost | |
| ►Nicl | |
| Cinterval_bound_type< Harlinn::Common::Core::Interval > | |
| Cinterval_traits< Harlinn::Common::Core::Interval > | |
| ▼NHarlinn | |
| ►NCommon | |
| ►NCore | |
| ►NCom | |
| ►NInterfaces | |
| CInterface | |
| CInterface< IUnknown > | |
| ►NInternal | |
| CISequentialStreamOnStreamImpl | |
| CIStreamOnStreamImpl | |
| CAttached | Disables calls to AddRef and Release |
| CDllModule | |
| CExeModule | |
| CHeapObject | Use this template to instantiate an object with an implementation of IUnknown::Release() that calls the delete operator on itself when its reference count becomes 0. COM objects instantiated using this template must be allocated using the new operator |
| CIStreamOnStreamImpl | |
| CModule | |
| CModuleClassFactory | |
| CModuleClassFactoryBase | |
| CModuleClassFactoryT | |
| CModuleDispatchClassFactory | |
| CModuleObjectBase | |
| CServiceModule | |
| CStackObject | Use this template to instantiate an object with a non-destructive implementation of IUnknown::Release(). COM objects instantiated using this template can be allocated on the stack |
| ►NConcurrency | |
| ►NMessages | |
| CMessage | A template that may be used as a base class for message types that will be posted to the active object |
| CSimpleMessage | A template that may be used to implement whose meaning can be fully determined the value messageId template parameter |
| CSimpleValueMessage | A template that may be used to implement messages that pass a single value to the active object |
| CActiveObject | Extends the ActiveObjectBase template, implementing the message processing thread and the Start and Stop functions |
| CActiveObjectBase | The base template class for the active object type |
| CActiveObjectExceptionEventArgs | |
| CActiveObjectMessageEventArgs | The default implementation of ActiveObjectBase<MessageT,maxQueueSize>::ProcessMessage(const MessageType& message) calls each of the callbacks registered with the OnProcessMessage signal |
| ►NCrypto | |
| CBlob | |
| CBlobT | |
| CCertificateChain | A wrapper for the Windows PCCERT_CHAIN_CONTEXT type which contains an array of simple certificate chains and a trust status structure that indicates summary validity data on all of the connected simple chains |
| CCertificateChainEngine | Represents a chain engine for an application. A chain engine restricts the certificates in the root store that can be used for verification, restricts the certificate stores to be searched for certificates and certificate trust lists (CTLs), sets a time-out limit for searches that involve URLs, and limits the number of certificates checked between checking for a certificate cycle |
| CCertificateContext | A wrapper for the Windows PCCERT_CONTEXT type. provides access to a X.509 certificate |
| CCertificateRevocationList | Contains both the encoded and decoded representations of a certificate revocation list (CRL) |
| CCertificateStore | A storage for certificates, certificate revocation lists (CRLs), and certificate trust lists (CTLs) |
| CCertificateTrustList | A wrapper for the Windows PCCTL_CONTEXT type which contains both the encoded and decoded representations of a CTL. It also contains an opened HCRYPTMSG handle to the decoded, cryptographically signed message containing the CTL_INFO as its inner content |
| CEncodingType | EncodingType represents the eoncoding type for certificates and messages. The idea is just to make it harder to make trivial programming errors |
| CServerOcspResponse | Represents a handle to an OCSP response associated with a server certificate chain |
| CServerOcspResponseContext | Contains an encoded OCSP response |
| ►NCurrentThread | |
| ►NInternal | |
| CClientId | |
| CThreadEnvironmentBlock | |
| ►NData | |
| ►NOracleClient | |
| COracleException | |
| CBaseData | |
| CDbException | |
| CDeleteClearTimeseriesRangeData | |
| CDeletedData | |
| CDeleteFromTimeseriesRangeData | |
| CDeleteOverTimeseriesRangeData | |
| CDeleteTimeseriesRangeData | |
| CDeleteTimeseriesRangeFactory | |
| CDeleteTimeseriesRangeSerializer | |
| CDeleteUntilTimeseriesRangeData | |
| ►NDemangle | |
| ►Ndetail | |
| ►CConverter | |
| CConvStream | |
| CRaw | |
| Ctset_impl | |
| Csave_stack | |
| CVisualStudioDemangler | |
| CDemangledTemplateParameter | |
| CDemangledType | |
| CError | |
| CTextAttributes | |
| ►CTextOutput | |
| CStreamApplyObject | |
| ►Ndetails | |
| C_hash_32_or_64 | |
| C_hash_32_or_64< 1 > | |
| CConcurrentQueueProducerTypelessBase | |
| Cconst_numeric_max | |
| Chash_32_or_64 | |
| Cidentity | |
| Cis_trivially_destructible | |
| Cmax_align_t | |
| Cnomove_if | |
| Cnomove_if< false > | |
| Cstatic_is_lock_free | |
| Cstatic_is_lock_free< bool > | |
| Cstatic_is_lock_free< U * > | |
| Cstatic_is_lock_free_num | |
| Cstatic_is_lock_free_num< int > | |
| Cstatic_is_lock_free_num< long > | |
| Cstatic_is_lock_free_num< long long > | |
| Cstatic_is_lock_free_num< short > | |
| Cstatic_is_lock_free_num< signed char > | |
| Cthread_id_converter | |
| CThreadExitListener | |
| CThreadExitNotifier | |
| ►NDoxygen | |
| ►NInternal | |
| CDocBase | |
| CDocInternalSectionBaseType | |
| CDocInternalSectionType | |
| CDocSectionBaseType | |
| CDocSectionType | |
| ►NStructure | |
| ►NInternal | |
| CBase | |
| CClass | |
| CConcept | |
| CContainer | |
| CDCop | |
| CDefine | |
| CEnum | |
| CEvent | |
| CFriend | |
| CFunction | |
| CInterface | |
| CInterfaceReference | |
| CMember | |
| CMemberDef | |
| CModule | |
| CNamespace | |
| CProperty | |
| CPrototype | |
| CService | |
| CSignal | |
| CSlot | |
| CStruct | |
| CTypeContainer | |
| CTypedef | |
| CTypeSystem | |
| CUnion | |
| CVariable | |
| CChildNodeType | |
| CCodeLineType | |
| CCompoundDefType | |
| CCompoundRefType | |
| CDescriptionType | |
| CDocAnchorType | |
| CDocBaseType | |
| CDocBlockQuoteType | |
| CDocCaptionType | |
| CDocCmdGroupType | |
| CDocCopyType | |
| CDocDetailsType | |
| CDocDotMscType | |
| CDocEmojiType | |
| CDocEmptyType | |
| CDocEntryType | |
| CDocFormulaType | |
| CDocHeadingType | |
| CDocHtmlOnlyType | |
| CDocImageFileType | |
| CDocImageType | |
| CDocIndexEntryType | |
| CDocInternalS1Type | |
| CDocInternalS2Type | |
| CDocInternalS3Type | |
| CDocInternalS4Type | |
| CDocInternalS5Type | |
| CDocInternalS6Type | |
| CDocInternalType | |
| CDocLanguageType | |
| CDocListItemType | |
| CDocListType | |
| CDocMarkupType | |
| CDocParamListItem | |
| CDocParamListType | |
| CDocParamName | |
| CDocParamNameList | |
| CDocParamType | |
| CDocParaType | |
| CDocParBlockType | |
| CDocPlantumlType | |
| CDocRefTextType | |
| CDocRowType | |
| CDocSect1Type | |
| CDocSect2Type | |
| CDocSect3Type | |
| CDocSect4Type | |
| CDocSect5Type | |
| CDocSect6Type | |
| CDocSimpleSectType | |
| CDocSummaryType | |
| CDocTableType | |
| CDocTitleType | |
| CDocTocItemType | |
| CDocTocListType | |
| CDocument | |
| CDocumentCollection | |
| CDocURLLink | |
| CDocVariableListGroup | |
| CDocVariableListType | |
| CDocVarListEntryType | |
| CDocXRefSectType | |
| CEnumvalueType | |
| CExportsType | |
| CExportType | |
| CGraphType | |
| CHighlightType | |
| CIncType | |
| CLinkedTextType | |
| CLinkType | |
| CListingType | |
| CListOfAllMembersType | |
| CLocationType | |
| CMemberDefType | |
| CMemberRefType | |
| CMemberType | |
| CNodeType | |
| CParamType | |
| CReferenceType | |
| CRefTextType | |
| CRefType | |
| CReimplementType | |
| CSectionDefType | |
| CSpType | |
| CTableOfContentsKindType | |
| CTableOfContentsType | |
| CTemplateParamListType | |
| CTextType | |
| CTitleType | |
| ►NEnvironment | |
| ►NInternal | |
| CNetApiBuffer | Memory management for buffers that will be released using the NetApiBufferFree function |
| CComputer | |
| CDomainObject | |
| CEnvironmentStrings | |
| CGroup | Represents a local or domain group |
| CGroups | |
| CModuleEntries | |
| CModuleEntry | |
| CProcessEntries | |
| CProcessEntry | |
| CUser | Represents a local or domain user |
| CUsers | |
| ►NEse | |
| CColumnCreate | Describes a column to create in a database |
| CColumnDefinition | Defines the data that can be stored in a column |
| CColumnList | A system table that provides information about the columns of a table |
| CDatabase | Manages the handle to an Extensible Storage Engine database, providing an API that exposes the operations that can be performed on the database |
| CDatabaseOptions | |
| CException | |
| CGlobalOptions | |
| CIndexCreate | Contains the information needed to create an index |
| CInitializedInstanceOptions | |
| CInstance | An instance of the database engine for use in a single process |
| CInstanceOptions | |
| CObjectInfo | |
| COptions | |
| CRetrieveColumn | Holds input and output parameters for use with the Table::RetrieveColumns function. It describe which column value to retrieve, how to retrieve it, and where to store the results |
| CSession | |
| CSetColumn | Contains input and output parameters for Table::SetColumns describing which column value to set, how to set it, and where to get the column set data |
| CSystemTable | |
| CTable | |
| CTableCreate | Contains the information that is necessary to create a table populated with columns and indexes |
| CTables | |
| CTransaction | A Transaction object for a Session. Will automatically roll back the current transaction if it is not explicitly commited through this object |
| CUninitializedInstanceOptions | |
| ►NFormatting | |
| CFormatStringParser | Splits a format string into sections, a section will either hold text to be copied to the output, or a format specification |
| CFormatStringSection | |
| ►NHtml | |
| CNamedChar | |
| ►NHttp | |
| ►NServer | |
| ►NInternal | |
| CHttpConnectionManager | |
| CHttpReceiveBodyRequest | |
| CHttpReceiveRequest | |
| ►CHttpRequestManager | |
| CReceivingRequestList | |
| CHttpSendRequest | |
| CLinkedList | |
| CLinkedListBase | |
| CCancelRequest | |
| CHttpConnection | |
| CHttpRequest | |
| CHttpRequestDispatcher | |
| CHttpRequestHandler | |
| CHttpResponse | |
| CHttpServer | |
| CHttpServerRequestQueue | |
| CHttpUrlGroup | |
| CReceiveBodyRequest | |
| CReceiveClientCertificateRequest | |
| CReceiveRequest | |
| CRequest | |
| CRequestQueueDispatcher | |
| CRequestQueueHandler | |
| CSendBodyRequest | |
| CSendRequest | |
| CWaitForDemandStartRequest | |
| CWaitForDisconnectExRequest | |
| CWaitForDisconnectRequest | |
| CAnsiServiceBinding | |
| CApiVersion | Api Version. This is used to ensure compatibility between applications and httpapi.dll and http.sys |
| CApplication | HTTP.sys initialization/termination |
| CAuthenticationBasicParams | |
| CAuthenticationDigestParams | |
| CAuthenticationInfo | |
| CBandwidthLimitInfo | |
| CBindingInfo | |
| CByteRange | This structure defines a file byte range |
| CCachePolicy | Only cache unauthorized GETs + HEADs |
| CChannelBindInfo | |
| CConfigSettingSet | |
| CConfigTimeoutSet | |
| CConnectionLimitInfo | |
| CCookedUrl | Structure defining format of cooked URL |
| CDataChunk | This structure describes an individual data chunk |
| CDelegateRequestPropertyInfo | |
| CFlowrateInfo | |
| CHttp2SettingsLimitsParam | |
| CHttp2WindowSizeParam | |
| CKnownHeader | Structure defining format of a known HTTP header |
| CListenEndpointInfo | Controls whether IP-based URLs should listen on the specific IP or wildcard |
| CLogData | |
| CLogFieldsData | The LogFieldsData structure is used to pass the fields that are logged for an HTTP response when WC3 logging is enabled |
| CLoggingInfo | Configuration structure used for setting the logging property |
| CMultipleKnownHeaders | This structure allows the provision of providing multiple known headers |
| CPerformanceParam | |
| CProtectionLevelInfo | Controls whether the associated UrlGroup Namespace should receive edge traversed traffic. By default this parameter is unspecified |
| CQosSettingInfo | |
| CQueryRequestQualifierQuic | |
| CQueryRequestQualifierTcp | |
| CRequestAuthInfo | Authentication request info structure |
| CRequestChannelBindStatus | |
| CRequestHeaders | Structure defining format of request headers |
| CRequestInfo | |
| CRequestPropertySni | |
| CRequestQueue | |
| CRequestSizingInfo | HttpRequestInfoTypeSizeInfo payload. Contains size information filled by each processsing stage |
| CRequestTimingInfo | HttpRequestInfoTypeTiming payload. Contains information about how much time was spent at each request processing stage |
| CRequestTokenBindingInfo | |
| CRequestV1 | |
| CRequestV2 | |
| CResponseHeaders | Structure defining format of response headers |
| CResponseInfo | |
| CResponseV1 | |
| CResponseV2 | |
| CServerSession | |
| CServiceBindingBase | |
| CServiceConfigCacheSet | |
| CServiceConfigIpListenParam | Set/Delete IP Listen-Only List record |
| CServiceConfigIpListenQuery | Query IP Listen-Only List record |
| CServiceConfigSslCcsKey | |
| CServiceConfigSslCcsQuery | |
| CServiceConfigSslCcsQueryEx | |
| CServiceConfigSslCcsSet | |
| CServiceConfigSslCcsSetEx | |
| CServiceConfigSslKey | |
| CServiceConfigSslKeyEx | |
| CServiceConfigSslParam | |
| CServiceConfigSslParamEx | |
| CServiceConfigSslQuery | |
| CServiceConfigSslQueryEx | |
| CServiceConfigSslSet | |
| CServiceConfigSslSetEx | |
| CServiceConfigSslSniKey | |
| CServiceConfigSslSniQuery | |
| CServiceConfigSslSniQueryEx | |
| CServiceConfigSslSniSet | |
| CServiceConfigSslSniSetEx | |
| CServiceConfigUrlaclKey | Url ACL |
| CServiceConfigUrlaclParam | This defines a record for the SSL config store |
| CServiceConfigUrlaclQuery | This data structure is used by HttpQueryServiceConfiguration() for the config ID HttpServiceConfigUrlAclInfo. It's used to query a particular record from the URL ACL store |
| CServiceConfigUrlaclSet | |
| CSSLClientCertInfo | SSL Client certificate information |
| CSSLInfo | |
| CSSLProtocolInfo | |
| CStateInfo | |
| CTimeoutLimitInfo | For manipulating application specific timeout settings. These timers run when there's a request being processed on a connection and HTTPAPI has already associated the request with an application. Setting a timeout value to zero will cause HTTPAPI to revert to default |
| CTransportAddress | Structure defining format of transport address. Use pLocalAddress->sa_family to determine whether this is an IPv4 address (AF_INET) or IPv6 (AF_INET6) |
| CUnknownHeader | Structure defining format of an unknown header |
| CUrlGroup | |
| CVersion | HTTP protocol version information and manipulation |
| CWideServiceBinding | |
| ►NInternal | |
| C_ByteSizeOf | |
| C_ByteSizeOf< Arg > | |
| C_Repeat_for | |
| CAsTuple | |
| CAsTuple< std::array< T, 0 >, Types... > | |
| CAsTuple< std::array< T, N >, Types... > | |
| CAsTuple< std::pair< T1, T2 > > | |
| CAsTuple< std::tuple< Types... > > | |
| CAsTuple< Tuple< Types... > > | |
| CAsTuple< TypeList< Types... > > | |
| CBitVectorLogicalResult | |
| CByteOffsetOf | |
| CByteOffsetOf< 0, Arg, Args... > | |
| CConstPointerIterator | |
| CData | |
| CEseFormatterImpl | |
| CIndexIterator | |
| CLightweightSemaphoreImpl | LightweightSemaphoreImpl |
| CMakeUnsignedHelper | |
| CMakeUnsignedHelper< 1 > | |
| CMakeUnsignedHelper< 2 > | |
| CMakeUnsignedHelper< 4 > | |
| CMakeUnsignedHelper< 8 > | |
| CMergeSequences | |
| CMergeSequences< std::index_sequence< firstIndexes... >, std::index_sequence< secondIndexes... > > | |
| CPointerIterator | |
| CServicesFormatterImpl | |
| CToReferenceIfReferenceWrapper | |
| CToReferenceIfReferenceWrapper< std::reference_wrapper< T > > | |
| CTupleBase | |
| CTupleBase< index, T, types... > | |
| CTupleCat2 | |
| CTupleCat2< Tuple< Types1... >, I_arg, std::index_sequence< J... >, J_next, Tuple< Types2... >, Rest... > | |
| CTupleCatTraits | |
| CTupleTypeFor | |
| CTupleTypeForDecay | |
| CTupleValue | |
| CVariantTypeTraits | |
| ►NIO | |
| ►NBlocks | |
| CBlock | |
| CBlockIterator | |
| CBlockManager | |
| CStream | |
| ►NIsolatedStorage | |
| CIsolatedStorageException | |
| ►NSerialization | |
| ►NInternal | |
| CArrayDataTypeResolver | |
| CArrayDataTypeResolver< bool > | |
| CArrayDataTypeResolver< DateTime > | |
| CArrayDataTypeResolver< double > | |
| CArrayDataTypeResolver< float > | |
| CArrayDataTypeResolver< Guid > | |
| CArrayDataTypeResolver< int > | |
| CArrayDataTypeResolver< long > | |
| CArrayDataTypeResolver< long long > | |
| CArrayDataTypeResolver< short > | |
| CArrayDataTypeResolver< signed char > | |
| CArrayDataTypeResolver< std::span< Byte, size > > | |
| CArrayDataTypeResolver< std::vector< Byte, AllocatorT > > | |
| CArrayDataTypeResolver< std::wstring_view > | |
| CArrayDataTypeResolver< TimeSpan > | |
| CArrayDataTypeResolver< unsigned char > | |
| CArrayDataTypeResolver< unsigned int > | |
| CArrayDataTypeResolver< unsigned long > | |
| CArrayDataTypeResolver< unsigned long long > | |
| CArrayDataTypeResolver< unsigned short > | |
| CArrayDataTypeResolver< wchar_t * > | |
| CArrayDataTypeResolver< wchar_t > | |
| CArrayDataTypeResolver< WideString > | |
| CByteArrayTypeResolver | |
| CFloatDataTypeResolver | |
| CFloatDataTypeResolver< double > | |
| CFloatDataTypeResolver< float > | |
| CSerializationReader | |
| CSerializationWriter | |
| CSignedDataTypeResolver | |
| CSignedDataTypeResolver< char > | |
| CSignedDataTypeResolver< int > | |
| CSignedDataTypeResolver< long > | |
| CSignedDataTypeResolver< long long > | |
| CSignedDataTypeResolver< short > | |
| CSignedDataTypeResolver< signed char > | |
| CStringArrayTypeResolver | |
| CTimeTypeDataTypeResolver | |
| CTimeTypeDataTypeResolver< DateTime > | |
| CTimeTypeDataTypeResolver< TimeSpan > | |
| CUnsignedDataTypeResolver | |
| CUnsignedDataTypeResolver< unsigned char > | |
| CUnsignedDataTypeResolver< unsigned int > | |
| CUnsignedDataTypeResolver< unsigned long > | |
| CUnsignedDataTypeResolver< unsigned long long > | |
| CUnsignedDataTypeResolver< unsigned short > | |
| CUnsignedDataTypeResolver< wchar_t > | |
| CDataReader | |
| CDataWriter | |
| ►NSockets | |
| ►NInernal | |
| CAddressListAdaptor | |
| ►NServer | |
| ►NInternal | |
| CBufferQueue | |
| CBuffer | |
| CBufferedSocketStream | |
| CBufferPool | |
| CTcpConnectionHandler | |
| CTcpConnectionHandlerBase | |
| ►CTcpListener | |
| CConnectionHandlerFactory | |
| CConnectionHandlerFactoryBase | |
| CTcpListenerBase | |
| CTcpSimpleConnectionHandler | |
| CTcpSimpleListener | |
| ►NTcp | |
| ►NClient | |
| CConnectionHandler | |
| ►NServer | |
| CConnectionHandler | |
| CConnectionHandlerFactory | |
| CConnectionHandlerFactoryBase | |
| CConnectionHandlerPool | |
| CConnectionHandlerRequestsPool | |
| CListenerAcceptRequest | |
| CListenerHandler | |
| CAcceptRequest | For use with SocketHandler::BeginAsyncAccept |
| CAddress | Provides a generic mechanism for specifying a transport address |
| ►CAddressInfo | |
| CEntry | |
| CIterator | |
| CConnectRequest | For use with SocketHandler::BeginAsyncConnect |
| CDisconnectRequest | For use with SocketHandler::BeginAsyncDisconnect |
| CIoctlRequest | For use with SocketHandler::BeginAsyncIoctl |
| CLinger | Maintains information about a specific socket that specifies how that socket should behave when data is queued to be sent and the Socket::Close function is called on the socket |
| CNetworkEvents | Used to store a socket's internal information about network events |
| CProtocolChain | The ProtocolChain associated with the protocol. If the length of the chain is 0, this ProtocolInfo entry represents a layered protocol which has Windows Sockets 2 SPI as both its top and bottom edges. If the length of the chain equals 1, this entry represents a base protocol whose Catalog Entry identifier can be retrieved by calling CatalogEntryId() function of the ProtocolInfo object. If the length of the chain is larger than 1, this entry represents a protocol chain which consists of one or more layered protocols on top of a base protocol. The corresponding Catalog Entry identifiers are in the ProtocolChain array starting with the layered protocol at the top (the zero element in the ProtocolChain array) and ending with the base protocol. Refer to the Windows Sockets 2 Service Provider Interface specification for more information on protocol chains |
| CProtocolInfo | Used to store or retrieve complete information for a given protocol |
| CQualityOfService | |
| CReceiveFromRequest | |
| CReceiveMsgRequest | |
| CReceiveRequest | For use with SocketHandler::BeginAsyncReceive |
| CRequestPool | A pool of requests specified by the |
| CRequestsPool | This is the implementation of the default RequestsPool. It delegates all operations to instances of request type specific pool implementations specified by the RequestsPoolTypeParamsT template parameter |
| CRequestsPoolTypeParams | |
| CSendMsgRequest | |
| CSendRequest | |
| CSendToRequest | |
| CSocket | Represents a socket descriptor that is bound to a specific transport-service provider |
| CSocketAddressList | A type that is binary compatible with SOCKET_ADDRESS_LIST |
| CSocketException | |
| CSocketHandler | Classes derived from this template are used to implement asynchronous operations on sockets |
| CSocketRequest | Base class for all asynchronous socket requests |
| CSocketStream | |
| CSocketT | Specializes a Socket for a particular SocketType and a particular ProtocolType |
| CSpan | |
| CTcpInfo | |
| CTcpSocket | Encapsulates a TCP socket descriptor |
| CTransmitFileBuffers | |
| CTransmitFileRequest | |
| CTransmitPacketsElement | |
| CTransmitPacketsRequest | |
| CUdpSocket | |
| CWSAInitTerm | |
| Cabstract | Base class for asynchronous I/O notification handlers |
| CAttachedSystemStream | |
| CBinaryReader | This template is used to implement deserialization of binary data from stream objects that satisfies the IO::StreamReader concept |
| CBinaryReaderBase | |
| CBinaryWriter | This template is used to implement serialization of binary data to stream objects that satisfies the IO::StreamWriter concept |
| CBinaryWriterBase | |
| CBufferedBinaryReader | |
| CBufferedBinaryWriter | |
| CBufferStream | Implements a stream for a buffer |
| CCommConfig | |
| CCommDeviceDispatcher | |
| CCommDeviceHandler | |
| CCommDeviceRequest | |
| CCommDeviceStream | |
| CConnectPipeRequest | |
| ►CContext | Context is an I/O completion port with an attached thread-pool that services I/O completion notifications |
| CAsyncOverlapped | |
| CAsyncOverlappedBase | |
| CDeviceControlBlock | |
| CDirectory | |
| CDirectoryAccessMask | The access mask for a directory |
| CDirectoryNotFoundException | |
| CDriveNotFoundException | |
| CEndOfStreamException | |
| CFile | |
| CFileAccessMask | The access mask for a file |
| CFileDispatcher | |
| CFileHandler | |
| CFileInfo | |
| CFileLoadException | |
| CFileNotFoundException | |
| CFileRequest | |
| CFileStream | |
| CFileSystemEntries | |
| CFileSystemEntry | |
| CFindData | |
| CFindDataBase | |
| CFindDataBase< char > | |
| CFindDataBase< wchar_t > | |
| ►CIOCompletionPort | |
| CMessage | |
| CIOException | |
| CIStreamMemoryStream | |
| CIStreamStream | A stream wrapper for the IStream interface |
| ►CMemoryStream | Creates a stream stored in memory |
| CData | |
| COverlapped | |
| CPathTooLongException | |
| CPipe | |
| CPipeAccessMask | |
| CPipeDispatcher | |
| CPipeException | |
| CPipeHandler | |
| CPipeRequest | |
| CReadCommDeviceRequest | |
| CReadFileRequest | |
| CReadPipeRequest | |
| CRequest | Base class for all asynchronous requests |
| CSerialPort | |
| CSerialPorts | |
| CSplitPath | |
| CSystemStream | |
| CTransactPipeRequest | |
| CWaitEventCommDeviceRequest | |
| CWriteBuffer | |
| CWriteCommDeviceRequest | |
| CWriteFileRequest | |
| CWritePipeRequest | |
| ►NLMDB | |
| CCursor | Cursor objects provides functionality that can be used to navigate, search and modify key/value pairs in the database |
| CDatabase | |
| CEnvironment | |
| CTransaction | |
| CTypedCursor | |
| CValue | Makes it a little easier to initialize an MDB_val structure |
| ►NLMDBEx | |
| CDatabase | |
| CDatabaseBase | |
| CDatabaseOptions | |
| CHashIndex | HashIndex |
| CHashIndexInfo | HashIndexInfo |
| CHashIndexInfoT | |
| CIndex | Index |
| CIndexInfo | IndexInfo |
| CIndexInfoT | |
| CKeyBuffer | |
| CSession | |
| CSessionReference | |
| CTable | Table |
| CTableBase | TableBase |
| CTableInfo | TableInfo |
| CTableInfoBase | TableInfoBase |
| CTableInfoT | |
| ►NLogging | |
| ►NCursors | |
| CBufferCursor | |
| CComputerInfoCursor | |
| CConfigurationFileInfoCursor | |
| CCursor | |
| CExecutableInfoCursor | |
| CLogSiteDataCursor | |
| CProcessInfoCursor | |
| CUserInfoCursor | |
| CWindowsVersionInfoCursor | |
| ►NFormatters | |
| ►CTextFormatter | |
| CThreadData | |
| ►NInternal | |
| CBuffer | The ThreadLogger writes log information to Buffer objects |
| CBufferKey | |
| CBufferManager | |
| CRecordHeader | |
| CRecordStream | RecordStream implements: Int64 Write( const void* buffer, size_t bufferSize ); which is required by IO::BinaryWriter<> in ThreadWriter::WriteLogRecord |
| CThreadKeyData | |
| ►NSinks | |
| ►NStorage | |
| CLogDatabase | LogDatabase |
| CLogDatabaseOptions | LogDatabaseOptions |
| CLogDatabaseStore | |
| CLogDataTable | LogDataTable |
| CLogDataTableInfo | LogDataTableInfo |
| CLogHashIndexInfoT | LogHashIndexInfoT |
| CLogHashIndexT | LogHashIndexT |
| CLogSession | LogSession |
| CLogSiteIndex | LogSiteIndex |
| CLogSiteIndexInfo | LogSiteIndexInfo |
| CLogSiteTable | LogSiteTable |
| CLogSiteTableInfo | LogSiteTableInfo |
| CLogTableInfoT | LogTableInfoT |
| CLogTableT | LogTableT |
| CLMDBSink | |
| CLMDBSinkOptions | |
| CTextSink | |
| CTextSinkOptions | |
| ►NTypes | |
| CConfigurationFileInfo | |
| CDomainObject | |
| CExecutableInfo | |
| CIdentified | |
| CLoggerObject | |
| CLogSiteData | |
| CProcessInfo | |
| CWindowsVersionInfo | |
| CWindowsVersionInfoKey | |
| ►NWriters | |
| CConsoleWriter | |
| CThreadWriter | This is the class that creates log entries for a single thread |
| ►CBufferConverter | BufferConverter processes Buffer objects and converts the log entries in the buffer into LogRecord objects |
| CThreadData | The data for a LogRecord may span multiple Buffer objects |
| CBufferHandler | |
| CBuildOptions | |
| CLogger | |
| CLoggerOptions | |
| ►CLogManager | |
| CThreadData | |
| CLogManagerRetrieveStatisticsMessage | |
| CLogManagerStatistics | |
| CLogRecord | |
| CLogSite | Instances of this class are created with static storage duration inside the functions that call the ThreadLogger API |
| CLogSiteExtractor | |
| CRecordHandler | Base class for record handlers |
| CStorage | |
| CThreadLogger | This is the class that implements the logging API |
| CTrace | |
| ►NMath | |
| ►NInternal | |
| ►NOpenLibM | |
| ►Nfma_internal | |
| Cdd | |
| C__infinity_un | |
| C__nan_un | |
| Cieee_double_shape_type | |
| Cieee_extended_shape_type | |
| Cieee_float_shape_type | |
| Cieee_quad_shape_type | |
| CIEEEd2bits | |
| CIEEEf2bits | |
| CDistanceType | |
| CDistanceType< double > | |
| CDistanceType< Int64 > | |
| CDistanceType< UInt64 > | |
| CExponentBias | |
| CExponentBias< double > | |
| CExponentBias< float > | |
| CExponentWidth | |
| CExponentWidth< double > | |
| CExponentWidth< float > | |
| CFastPowImpl | |
| CFractionWidth | |
| CFractionWidth< double > | |
| CFractionWidth< float > | |
| CInfinityUnsignedValue | |
| CInfinityUnsignedValue< double > | |
| CInfinityUnsignedValue< float > | |
| CMatrixBase | |
| CMatrixSimdBase | |
| CNegativeInfinityUnsignedValue | |
| CNegativeInfinityUnsignedValue< double > | |
| CNegativeInfinityUnsignedValue< float > | |
| CNormalBase | |
| CPointBase | |
| CQuaternionBase | |
| CQuaternionSimdBase | |
| CQuietNaNUnsignedValue | |
| CQuietNaNUnsignedValue< double > | |
| CQuietNaNUnsignedValue< float > | |
| CRangeReduction | |
| CRangeReduction< double > | |
| CRangeReduction< float > | |
| CScalarBase | |
| CStorageType | |
| CStorageType< double > | |
| CStorageType< float > | |
| CTupleBase | |
| CTupleSimdBase | |
| CVectorBase | |
| CBiasedExponent | Holds the value of the biased exponent part of a floating point value |
| CCompensatedFloat | |
| CCompensatedSum | |
| CConstants | |
| CConstants< double > | |
| CConstants< float > | |
| CExponent | Holds the value of the exponent part of a floating point value |
| CFloatingPoint | A template for encoding and decoding floating point values |
| CInterval | |
| CNormal3f | |
| CNormalizedFloat | |
| CPoint2f | |
| CPoint2i | |
| CPoint3f | |
| CPoint3i | |
| ►CQuaternion | |
| CAxisAngle | |
| CQuaternionSimd | |
| CScalar | |
| CScalar< double, 2 > | |
| CScalar< double, 3 > | |
| CScalar< double, 4 > | |
| CScalar< float, 2 > | |
| CScalar< float, 3 > | |
| CScalar< float, 4 > | |
| CSignificand | Holds the value of the significand part of a floating point value |
| CSquareMatrix | |
| CSquareMatrixSimd | |
| CSquareMatrixSimd< MatrixT, 1 > | |
| CSquareMatrixSimd< MatrixT, 2 > | |
| CSquareMatrixSimd< MatrixT, 3 > | |
| CSquareMatrixSimd< MatrixT, 4 > | |
| CTransformation | |
| CTuple2 | A tuple holding two numbers |
| CTuple3 | |
| CTuple4 | |
| CTupleSimd | |
| CVector | |
| CVector< double, 2 > | |
| CVector< double, 3 > | |
| CVector< double, 4 > | |
| CVector< float, 2 > | |
| CVector< float, 3 > | |
| CVector< float, 4 > | |
| CVector< Int32, 2 > | |
| CVector< Int32, 3 > | |
| CVector< Int32, 4 > | |
| CVector< UInt32, 2 > | |
| CVector< UInt32, 3 > | |
| CVector< UInt32, 4 > | |
| ►NMessaging | |
| CMessageQueueException | |
| ►NNet | |
| ►NCollections | |
| ►NGeneric | |
| ►CSortedListEx | |
| CEnumerator | |
| CKeyList | |
| CSortedListKeyEnumerator | |
| CSortedListValueEnumerator | |
| CValueList | |
| CSortedWeakReferenceList | |
| ►NData | |
| ►NSqlClient | |
| CDataReaderWrapper | |
| CSqlParameterCollectionExtensions | Useful extensions to the SqlParameterCollection class |
| ►NUpdates | |
| CIStoredProcedures | |
| CIUpdateNodeFactory | |
| CSqlServerUpdateHandlerBase | |
| CSqlServerUpdateNodeBase | |
| CBaseData | |
| CBaseDataGuid | |
| CBaseDataInt64 | |
| CDeleteClearTimeseriesRangeData | |
| CDeleteFromTimeseriesRangeData | |
| CDeleteOverTimeseriesRangeData | |
| CDeleteTimeseriesRangeData | |
| CDeleteTimeseriesRangeFactory | |
| CDeleteUntilTimeseriesRangeData | |
| CIBaseDataFactory | |
| CIDataContextBase | |
| CUpdateData | |
| ►NEntities | |
| CBaseEntity | |
| CEntityContextBase | |
| CEntityContextEventArgs | |
| CEntityContextExceptionEventArgs | |
| CEventContextAfterCommitEventArgs | |
| CEventContextBeforeCommitEventArgs | |
| CEventContextEntityPropertyChangedEventArgs | |
| CEventContextUpdatedEventArgs | |
| CIBaseEntityFactory | |
| ►NGenerators | |
| CGenerator | |
| CSineGenerator | |
| ►NIO | |
| CBinaryReaderExtensions | Useful extensions to the BinaryReader class |
| CBinaryWriterExtensions | Useful extensions to the BinaryWriter class |
| CIReadWrite | |
| ►NSync | |
| CMultimediaTimer | |
| CWaitableTimer | |
| CArrayExtensions | |
| CCurrency | A Currency number stored as a long, scaled by 10,000 to give a fixed-point number with 15 digits to the left of the decimal point and 4 digits to the right |
| CNativeFunctions | |
| ►NNetwork | |
| CInterfaceInfo | |
| CInterfaceTable | |
| ►NPersistent | |
| ►NInternal | |
| CAdaptedFormatTraits | |
| CArrayContainerFormatTraits | |
| CArrayFormatTraits | |
| CBasicArrayFormatTraits | |
| CBasicFormatTraits | |
| CConstantFormatTraits | |
| CContainerFormatTraits | |
| CContainerFormatTraitsBase | |
| CFormatTraits | |
| CFormatTraitsBase | |
| CFormatTypeImpl | |
| CFormatTypeImpl< std::pair< Types... > > | |
| CFormatTypeImpl< std::tuple< Types... > > | |
| CFormatTypeImpl< Tuple< Types... > > | |
| CFormatTypeImpl< TypeList< Types... > > | |
| CFormatTypeImplHelper | |
| CFormatTypeImplHelper< 0, T, Types... > | |
| CFormatTypeImplHelper< 1, T, Types... > | |
| COptionalFormatTraits | |
| CPointerFormatTraits | |
| CPointerFormatTraitsBase | |
| CSevenBitEncodedValue | |
| CSharedPtrFormatTraits | |
| CStringContainerFormatTraits | |
| CStringPointerFormatTraits | |
| CTupleFormatTraits | |
| CTupleFormatTraits< std::tuple<>, RT > | |
| CTupleFormatTraits< Tuple<>, RT > | |
| CTypeListFormatTraits | |
| CUniquePtrFormatTraits | |
| CUnknownPointerFormatTraits | |
| CUnsupportedFormatTraits | |
| CVariantFormatTraits | |
| CVectorContainerFormatTraits | |
| CAdaptedDecoder | |
| CAdaptedType | |
| CArrayDecoder | |
| CArrayType | |
| CBasicArrayType | |
| CBasicType | |
| CConstant | |
| CDecoder | |
| CDescriptorType | |
| CDescriptorType<> | |
| CFixedSizeArrayDecoder | |
| CFixedSizeArrayType | |
| CFixedSizeBasicArrayDecoder | |
| CFixedSizeBasicArrayType | |
| CPrinter | Uses a format string, a type descriptor generated by Persistent::Describe and serialized data written by Persistent::Write to generate a formatted text representation of the serialized data |
| CTupleDecoder | |
| CTupleType | |
| CType | |
| CTypeDescriptorCursor | |
| CTypeListDecoder | |
| CTypeListType | |
| ►NRapidXml | |
| CXmlAttribute | |
| CXmlBase | |
| CXmlDocument | |
| CXmlNode | |
| CXmlParser | |
| ►NReflection | |
| CCustomAttributeFormatException | |
| CInvalidFilterCriteriaException | |
| CReflectionTypeLoadException | |
| CTargetException | |
| CTargetInvocationException | |
| CTargetParameterCountException | |
| ►NResources | |
| CMissingManifestResourceException | |
| ►NRtWorkQ | |
| CPlatform | |
| CWorkQueue | |
| ►NRuntime | |
| ►NInteropServices | |
| CCOMException | |
| CExternalException | |
| CInvalidComObjectException | |
| CInvalidOleVariantTypeException | |
| CMarshalDirectiveException | |
| CSafeArrayRankMismatchException | |
| CSafeArrayTypeMismatchException | |
| CSEHException | |
| ►NRemoting | |
| ►NMetadataServices | |
| CSUDSGeneratorException | |
| CSUDSParserException | |
| CRemotingException | |
| CRemotingTimeoutException | |
| CServerException | |
| ►NSerialization | |
| CSerializationException | |
| ►NSecurity | |
| ►NCryptography | |
| CCryptographicException | |
| CCryptographicUnexpectedOperationException | |
| ►NPolicy | |
| CPolicyException | |
| CAccessAllowedAccessControlEntry | |
| CAccessAllowedCallbackAccessControlEntry | |
| CAccessAllowedCallbackObjectAccessControlEntry | |
| CAccessAllowedObjectAccessControlEntry | |
| CAccessControlEntry | Base class for the various ACE wrappers |
| CAccessControlEntryBase | |
| CAccessControlList | A wrapper class for Windows ACLs |
| CAccessDeniedAccessControlEntry | |
| CAccessDeniedCallbackAccessControlEntry | |
| CAccessDeniedCallbackObjectAccessControlEntry | |
| CAccessDeniedObjectAccessControlEntry | |
| CAccessMask | An ACCESS_MASK wrapper class. The ACCESS_MASK data type is a DWORD value that defines standard, specific, and generic rights. These rights are used in access control entries (ACEs) and are the primary means of specifying the requested or granted access to an object |
| CAccessMaskT | |
| CAuthenticationIdentity | A tiny wrapper for the Windows SEC_WINNT_AUTH_IDENTITY_W type |
| CClaimSecurityAttributesInformation | A wrapper for the Windows CLAIM_SECURITY_ATTRIBUTES_INFORMATION type |
| CCloudAPClientSecurityContext | A client security context for CloudAP SSPI |
| CCloudAPSecurityContext | A security context for CloudAP SSPI |
| CCloudAPServerSecurityContext | A server security context for CloudAP SSPI |
| CCredentialsHandle | A wrapper for the Windows CredHandle type |
| CCredSSPClientSecurityContext | A client security context for CredSSP SSPI |
| CCredSSPSecurityContext | A security context for CredSSP SSPI |
| CCredSSPServerSecurityContext | A server security context for CredSSP SSPI |
| CExplicitAccess | An ExplicitAccess object defines access control information for a specified trustee |
| CGenericMapping | |
| CKerberosClientSecurityContext | A client security context for Kerberos SSPI |
| CKerberosSecurityContext | A security context for Kerberos SSPI |
| CKerberosServerSecurityContext | A server security context for Kerberos SSPI |
| CLocalUniqueId | An LocalUniqueId is a 64-bit value guaranteed to be unique only on the system on which it was generated. The uniqueness of a locally unique identifier (LUID) is guaranteed only until the system is restarted |
| CNegotiateClientSecurityContext | A client security context for Negotiate SSPI |
| CNegotiateSecurityContext | A security context for Negotiate SSPI |
| CNegotiateServerSecurityContext | A server security context for Negotiate SSPI |
| CNTLMClientSecurityContext | A client security context for NTLM SSPI |
| CNTLMSecurityContext | A security context for NTLM SSPI |
| CNTLMServerSecurityContext | A server security context for NTLM SSPI |
| CObjectAccessControlEntryBase | |
| CPKU2UClientSecurityContext | A client security context for PKU2U SSPI |
| CPKU2USecurityContext | A security context for PKU2U SSPI |
| CPKU2UServerSecurityContext | A server security context for PKU2U SSPI |
| CPrivilegeSet | A wrapper for the Windows PRIVILEGE_SET data type with a C++ container style interface |
| CSchannelClientSecurityContext | A client security context for Schannel SSPI |
| CSchannelSecurityContext | A security context for Schannel SSPI |
| CSchannelServerSecurityContext | A server security context for Schannel SSPI |
| CSecurityAttributes | A wrapper for the Windows SECURITY_ATTRIBUTES struc |
| CSecurityBuffer | A wrapper for the Windows SecBuffer type |
| CSecurityBufferArray | A wrapper for the Windows SecBufferDesc type |
| CSecurityContext | A wrapper for the Windows CtxtHandle type |
| CSecurityDescriptor | A wrapper for the Windows SECURITY_DESCRIPTOR/SECURITY_DESCRIPTOR_RELATIVE structures |
| CSecurityException | |
| ►CSecurityId | A security identifier (SID) is a unique value of variable length used to identify a trustee. The SecurityId class is used to manage SIDs |
| CIdentifierAuthority | IdentifierAuthority represents the top-level authority of a SecurityId |
| CSecurityIdAndDomain | |
| CSecurityIdAndFlags | |
| CSecurityIdInfo | |
| CSecurityIdsAndFlagsWithHash | A wrapper for the Windows PSID_AND_ATTRIBUTES_HASH type |
| CSecurityPackage | Provides access to information about a Windows security package |
| CSecurityPackages | An std::unordered_map of information about the security packages installed on the system |
| CSystemAccessFilterAccessControlEntry | |
| CSystemAlarmAccessControlEntry | |
| CSystemAlarmCallbackAccessControlEntry | |
| CSystemAlarmCallbackObjectAccessControlEntry | |
| CSystemAlarmObjectAccessControlEntry | |
| CSystemAuditAccessControlEntry | |
| CSystemAuditCallbackAccessControlEntry | |
| CSystemAuditCallbackObjectAccessControlEntry | |
| CSystemAuditObjectAccessControlEntry | |
| CSystemMandatoryLabelAccessControlEntry | |
| CSystemProcessTrustLabelAccessControlEntry | |
| CSystemResourceAttributeAccessControlEntry | |
| CSystemScopedPolicyIdAccessControlEntry | |
| CToken | Represents a Windows access token |
| ►CTokenAccessInformation | A wrapper/binary compatible replacement for the Windows TOKEN_ACCESS_INFORMATION type |
| CData | |
| CTokenAccessMask | An access mask implmentation for the access rights of a Windows access token |
| CTokenGroup | A binary compatible replacement for SID_AND_ATTRIBUTES for the TokenGroups implementation |
| ►CTokenGroups | A wrapper/binary compatible replacement for the Windows TOKEN_GROUPS type with a C++ container style interface |
| CData | |
| ►CTokenGroupsAndPrivileges | A Wrapper/binary compatible replacement for the Windows TOKEN_GROUPS_AND_PRIVILEGES type |
| CData | |
| CTokenMandatoryLabel | A wrapper for the Windows TOKEN_MANDATORY_LABEL type |
| CTokenPrivilege | A binary compatible replacement for the Windows LUID_AND_ATTRIBUTES for use with the TokenPrivileges class |
| ►CTokenPrivileges | A wrapper/binary compatible replacement for the TOKEN_PRIVILEGES type with a C++ container style interface |
| CData | |
| CTokenSource | |
| CTokenStatistics | A binary compatible replacement for the Windows TOKEN_STATISTICS type using the types defined here |
| CTokenUser | |
| CTrustee | A Trustee object identifies a user account, group account, or logon session to which an access control entry (ACE) applies. The object can use a name or a security identifier (SecurityId/SID) to identify the trustee |
| CVerificationException | |
| ►NServices | |
| ►NInternal | |
| CServiceEntry | |
| CApplication | |
| CDebugServiceHost | |
| CIServiceHost | |
| CService | Derived classes must: |
| CServiceAccessMask | The access mask for a service |
| CServiceBase | |
| CServiceControlManager | |
| CServiceControlManagerAccessMask | The access mask for the service control manager |
| CServiceHandle | |
| ►CServiceRunner | |
| COptions | |
| CServiceStatus | |
| CServiceStatusEntries | |
| CServiceStatusEntry | |
| CServiceStatusProcess | |
| CWindowsServiceHost | |
| ►NSIMD | |
| ►NInternal | |
| CConstants | |
| Cm128Constants | |
| Cm256Constants | |
| CTraitLimitsImpl | |
| CTraitsBase | |
| CDataTypeTraits | |
| CDataTypeTraits< DataType::m128 > | |
| CDataTypeTraits< DataType::m128d > | |
| CDataTypeTraits< DataType::m128i > | |
| CDataTypeTraits< DataType::m256 > | |
| CDataTypeTraits< DataType::m256d > | |
| CDataTypeTraits< DataType::m256i > | |
| CDataTypeTraits< DataType::m512 > | |
| CDataTypeTraits< DataType::m512d > | |
| CDataTypeTraits< DataType::m512i > | |
| CDataTypeTraits< DataType::m64 > | |
| CTraitLimits | |
| CTraitLimits< Byte > | |
| CTraitLimits< char > | |
| CTraitLimits< double > | |
| CTraitLimits< float > | |
| CTraitLimits< Int16 > | |
| CTraitLimits< Int32 > | |
| CTraitLimits< Int64 > | |
| CTraitLimits< SByte > | |
| CTraitLimits< UInt16 > | |
| CTraitLimits< UInt32 > | |
| CTraitLimits< UInt64 > | |
| CTraits | |
| CTraits16Bit | |
| CTraits32Bit | |
| CTraits64Bit | |
| CTraits8Bit | |
| CTraits< Byte, N > | |
| CTraits< char, N > | |
| CTraits< double, N > | |
| ►CTraits< float, N > | |
| Cm128Permute | |
| Cm128Select | |
| Cm256Select | |
| CPermuteImpl | |
| CPermuteImpl< shuffle, false, false, false, false > | |
| CPermuteImpl< shuffle, false, false, true, true > | |
| CPermuteImpl< shuffle, true, true, false, false > | |
| CPermuteImpl< shuffle, true, true, true, true > | |
| CTraits< Int16, N > | |
| CTraits< Int32, N > | |
| CTraits< Int64, N > | |
| CTraits< SByte, N > | |
| CTraits< UInt16, N > | |
| CTraits< UInt32, N > | |
| CTraits< UInt64, N > | |
| ►NTest | |
| ►NGenerators | |
| CRandomGenerator | Precomputes N random values |
| CRandomGeneratorBase | |
| CRangeGenerator | |
| CRangeGeneratorBase | |
| CNumericTest | |
| ►NThreading | |
| CSynchronizationLockException | |
| CThreadAbortException | |
| CThreadInterruptedException | |
| CThreadStateException | |
| CThreadStopException | |
| CWaitHandleCannotBeOpenedException | |
| ►NTypes | |
| ►NAdapters | |
| CTypeAdapter | |
| ►NInternal | |
| CAdaptedTypeTraits | |
| CAdaptedTypeTraitsBase | |
| CArrayTypeTraits | |
| CArrayTypeTraitsBase | |
| CBasicTypeTraits | |
| CBasicTypeTraits< bool, RT > | |
| CBasicTypeTraits< Byte, RT > | |
| CBasicTypeTraits< char, RT > | |
| CBasicTypeTraits< Currency, RT > | |
| CBasicTypeTraits< DateTime, RT > | |
| CBasicTypeTraits< double, RT > | |
| CBasicTypeTraits< float, RT > | |
| CBasicTypeTraits< Guid, RT > | |
| CBasicTypeTraits< Int16, RT > | |
| CBasicTypeTraits< Int32, RT > | |
| CBasicTypeTraits< Int64, RT > | |
| CBasicTypeTraits< long, RT > | |
| CBasicTypeTraits< SByte, RT > | |
| CBasicTypeTraits< TimeSpan, RT > | |
| CBasicTypeTraits< UInt16, RT > | |
| CBasicTypeTraits< UInt32, RT > | |
| CBasicTypeTraits< UInt64, RT > | |
| CBasicTypeTraits< unsigned long, RT > | |
| CBasicTypeTraits< wchar_t, RT > | |
| CBasicTypeTraitsBase | |
| CContainerTypeTraits | |
| CContainerTypeTraits< RT, BasicString< T > > | |
| CContainerTypeTraits< RT, BasicStringView< T > > | |
| CContainerTypeTraits< RT, ByteArray< N > > | |
| CContainerTypeTraits< RT, std::array< T, N > > | |
| CContainerTypeTraits< RT, std::basic_string< T, TR, A > > | |
| CContainerTypeTraits< RT, std::basic_string_view< T, TR > > | |
| CContainerTypeTraits< RT, std::deque< T, A > > | |
| CContainerTypeTraits< RT, std::forward_list< T, A > > | |
| CContainerTypeTraits< RT, std::list< T, A > > | |
| CContainerTypeTraits< RT, std::map< K, V, C, A > > | |
| CContainerTypeTraits< RT, std::multimap< K, V, C, A > > | |
| CContainerTypeTraits< RT, std::multiset< T, C, A > > | |
| CContainerTypeTraits< RT, std::priority_queue< T, Cnr, Cmp > > | |
| CContainerTypeTraits< RT, std::queue< T, Cnr > > | |
| CContainerTypeTraits< RT, std::set< T, C, A > > | |
| CContainerTypeTraits< RT, std::span< T, N > > | |
| CContainerTypeTraits< RT, std::stack< T, Cnr > > | |
| CContainerTypeTraits< RT, std::unordered_map< K, V, H, C, A > > | |
| CContainerTypeTraits< RT, std::unordered_multimap< K, V, H, C, A > > | |
| CContainerTypeTraits< RT, std::unordered_multiset< K, H, C, A > > | |
| CContainerTypeTraits< RT, std::unordered_set< K, H, C, A > > | |
| CContainerTypeTraits< RT, std::vector< T, A > > | |
| CContainerTypeTraits< RT, Vector< T > > | |
| CContainerTypeTraitsBase | |
| COptionalTypeTraits | |
| COptionalTypeTraits< std::optional< T >, RT > | |
| COptionalTypeTraitsBase | |
| CPointerTypeTraits | |
| CPointerTypeTraitsBase | |
| CSharedPtrTypeTraits | |
| CSharedPtrTypeTraits< std::shared_ptr< T >, RT > | |
| CSharedPtrTypeTraitsBase | |
| CTupleTypeTraits | |
| CTupleTypeTraits< RT, std::pair< T... > > | |
| CTupleTypeTraits< RT, std::tuple< T... > > | |
| CTupleTypeTraits< RT, Tuple< T... > > | |
| CTupleTypeTraitsBase | |
| CTypeListOf | |
| CTypeListTypeTraits | |
| CTypeListTypeTraits< RT, TypeList< T... > > | |
| CTypeListTypeTraitsBase | |
| CTypeTraitsBase | |
| CUniquePtrTypeTraits | |
| CUniquePtrTypeTraits< std::unique_ptr< T >, RT > | |
| CUniquePtrTypeTraitsBase | |
| CUnsupportedTypeTraits | |
| CVariadicStructureTypeIsFixedSize | |
| CVariadicStructureTypeIsFixedSize< 0, T > | |
| CVariadicStructureTypePackedSizeOf | |
| CVariadicStructureTypePackedSizeOf< 0, T > | |
| CVariadicTemplateTypeIsSupportedType | |
| CVariadicTemplateTypeIsSupportedType< 0, T > | |
| CVariantTypeTraits | |
| CVariantTypeTraits< RT, std::variant< T... > > | |
| CVariantTypeTraitsBase | |
| CIsFixedSize | |
| CIsFixedSize< T > | |
| CIsSupportedType | |
| CIsSupportedType< T > | |
| CPackedSizeOf | |
| CPackedSizeOf< T > | |
| CTypeTraits | |
| ►NUtf | |
| ►NInternal | |
| CUtf16Traits | |
| CUtf8Traits | |
| CTraits | |
| CTraits< char > | |
| CTraits< char16_t > | |
| CTraits< char8_t > | |
| CTraits< signed char > | |
| CTraits< unsigned char > | |
| CTraits< wchar_t > | |
| ►NXml | |
| ►NDom | |
| CAttribute | |
| CCDATASection | |
| CCharacterData | |
| CComment | |
| CDocument | |
| CDocumentFragment | |
| CDocumentType | |
| CElement | |
| CEntity | |
| CEntityReference | |
| CImplementation | Provides methods that are independent of any particular instance of the Document Object Model (DOM) |
| CNamedNodeMap | |
| CNode | Represents a single node in the XML document |
| CNodeIterator | |
| CNodeList | |
| CNotation | |
| CParseError | |
| CParseError2 | |
| CParseErrorCollection | |
| CProcessingInstruction | |
| CSchemaCollection | |
| CText | |
| CXTLRuntime | |
| ►NZeroMq | |
| CContext | |
| CMessage | |
| CSocket | |
| CZMQNotification | |
| CZMQNotificationClient | |
| CZMQNotificationClientEndPoint | |
| CZMQNotificationMemoryStream | |
| ►CZMQNotificationServer | |
| ►CNotificationEntry | |
| CNotificationMessage | |
| CZMQReadStream | |
| CZMQServer | |
| CZMQStreamBase | |
| CZMQWriteStream | |
| C_ICivicAddressReportFactoryEvents_Sink | |
| C_ILatLongReportFactoryEvents_Sink | |
| CAccessViolationException | |
| CAdviseSink | |
| CAdviseSink2 | The IAdviseSink2 interface is an extension of the IAdviseSink interface, adding the method OnLinkSrcChange to the contract to handle a change in the moniker of a linked object. This avoids overloading the implementation IAdviseSink::OnRename to handle the renaming of both embedded objects and linked objects. In applications where different blocks of code might execute depending on which of these two similar events has occurred, using the same method for both events complicates testing and debugging |
| CAdviseSinkEx | This interface is derived from IAdviseSink to provide extensions for notifying the sink of changes in an object's view status |
| CAggregateException | |
| CAllocator | |
| CAlwaysFalse | |
| CAppDomainUnloadedException | |
| CApplication | |
| CApplicationDirectories | |
| CApplicationException | |
| CApplicationOptions | |
| CArgumentException | |
| CArgumentNullException | |
| CArgumentOutOfRangeException | |
| CArithmeticException | |
| CArrayReader | |
| CArrayTypeMismatchException | |
| CArrayWriter | |
| CAsyncAdviseSink | Asynchronous implementation of IAdviseSink |
| CAsyncAdviseSink2 | Asynchronous implementation of IAdviseSink2 |
| CAsyncUnknown | |
| CAtomicReferenceCount | |
| CAttachedSafeArray | |
| CAttachedSysString | |
| CBadImageFormatException | |
| CBasicString | This is a reference counted string class |
| CBasicStringView | |
| ►CBinary | A reference counted buffer, primarily intended for binary data |
| CData | |
| CBindCtx | Provides access to a bind context, which is an object that stores information about a particular moniker binding operation |
| CBitMask | |
| ►CBits | A type that holds a fixed number of bits |
| Creference | |
| CBits16 | |
| CBits32 | |
| CBits64 | |
| CBits8 | |
| CBitTraits | |
| CBitTraits< bool > | |
| CBitTraits< Byte > | |
| CBitTraits< char > | |
| CBitTraits< Int16 > | |
| CBitTraits< Int32 > | |
| CBitTraits< Int64 > | |
| CBitTraits< SByte > | |
| CBitTraits< UInt16 > | |
| CBitTraits< UInt32 > | |
| CBitTraits< UInt64 > | |
| CBitTraits< wchar_t > | |
| CBitTraitsBase | |
| ►CBitVector | A resizeable bit-vector |
| Creference | |
| CBlockingConcurrentQueue | |
| CBlockingLock | Provides a semaphore that can be used to provide temporarily exclusive access to a shared resource such as a file |
| CBooleanBitTraits | |
| CBooleanSafeArray | |
| CByteArray | A Byte array for compile-time serialization of data |
| CByteBitTraits | |
| CCannotUnloadAppDomainException | |
| CCharBitTraits | |
| CCivicAddressReport | |
| CCivicAddressReportFactory | |
| CClassActivator | Specifies a method that retrieves a class object |
| CClassFactory | Enables a class of objects to be created |
| CClassFactory2 | |
| CComAllocator | A C++ allocator that uses CoTaskMemAlloc and CoTaskMemFree |
| CComBuffer | A movable buffer class the handles memory management using CoTaskMemAlloc, CoTaskMemFree and CoTaskMemRealloc
|
| CComInitialize | Initializes the COM library for use by the calling thread, sets the thread's concurrency model, and creates a new apartment for the thread if one is required. Calls CoUninitialize() in the destructor |
| CComPtr | A generic smart pointer for managing COM interfaces |
| CComString | A simple string class that uses CoTaskMemAlloc and CoTaskMemFree |
| ►CConcurrentQueue | |
| CBlock | |
| ►CExplicitProducer | |
| CBlockIndexEntry | |
| CBlockIndexHeader | |
| CFreeList | |
| CFreeListNode | |
| ►CImplicitProducer | |
| CBlockIndexEntry | |
| CBlockIndexHeader | |
| CImplicitProducerHash | |
| CImplicitProducerKVP | |
| CProducerBase | |
| CConcurrentQueueDefaultTraits | |
| CConditionVariable | Condition variables are synchronization primitives that enable threads to wait until a particular condition occurs. Condition variables are user-mode objects that cannot be shared across processes |
| ►CConnectData | Describes a connection that exists to a given connection point |
| CData | |
| CConnectionPoint | Supports connection points for connectable objects |
| CConnectionPointContainer | Supports connection points for connectable objects |
| CConsole | |
| CConsumerToken | |
| CContextMarshalException | |
| CContinue | Indicates whether or not to continue an operation. Used with remote procedure calls |
| CCreateErrorInfo | Returns error information |
| CCreateObject_ | |
| CCreateTypeInfo | Provides the tools for creating and administering the type information defined through the type description |
| CCreateTypeInfo2 | |
| CCreateTypeLib | Provides the methods for creating and managing the component or file that contains type information. Type libraries are created from type descriptions using the MIDL compiler. These type libraries are accessed through the ITypeLib interface |
| CCreateTypeLib2 | Provides the methods for creating and managing the component or file that contains type information. Derives from ICreateTypeLib. The ICreateTypeInfo instance returned from ICreateTypeLib can be accessed through a QueryInterface call to ICreateTypeInfo2 |
| CCriticalSection | A critical section object provides synchronization similar to that provided by a mutex object, except that a critical section can be used only by the threads of a single process. Critical section objects cannot be shared across processes |
| CCurrency | Currency are stored as 64-bit integer, scaled by 10,000 to give a fixed-point number with 15 digits to the left of the decimal point and 4 digits to the right |
| CDataAdviseHolder | |
| CDataMisalignedException | |
| CDataObject | |
| CDataSource | |
| CDataSourceColumn | |
| CDateTime | |
| CDefaultExceptionReporter | The default exception reporter implementation |
| CDefaultLocation | |
| CDelayedPropertyStoreFactory | |
| CDirectWriterLock | The IDirectWriterLock interface enables a single writer to obtain exclusive write access to a root storage object opened in direct mode while allowing concurrent access by multiple readers. This single-writer, multiple-reader mode does not require the overhead of making a snapshot copy of the storage for the readers |
| CDispatch | Exposes objects, methods and properties to programming tools and other applications that support Automation. COM components implement the IDispatch interface to enable access by Automation clients |
| CDispatchEx | Extends Dispatch with enhanced support for dynamic scripting languages |
| CDispCivicAddressReport | |
| CDispLatLongReport | |
| CDivideByZeroException | |
| CDllNotFoundException | |
| CDropSource | |
| CDropSourceNotify | The IDropSourceNotify interface is implemented on an IDropSource object to receive notifications from OLE when a user drags the mouse into or out of a potential drop target window |
| CDropTarget | |
| CDuplicateWaitObjectException | |
| CEnterpriseDropTarget | When implemented by the drop target application, this interface gives the OLE drag and drop engine the ability to determine whether the drop target application intends to evaluate enterprise protection policy and gives the OLE drag and drop engine a way to provide the enterprise ID of the drop source application to the drop target application |
| CEntryPointNotFoundException | |
| CEnum | |
| ►CEnumBase | |
| CEntry | |
| CEnumConnectionPoints | Enumerates connection points |
| CEnumConnections | Enumerates the current connections for a connectable object |
| CEnumFORMATETC | Enumerates the FORMATETC structures that define the formats and media supported by a given data object |
| CEnumMoniker | Enumerates the components of a moniker or the monikers in a table of monikers |
| CEnumOleUndoUnits | Enumerates the undo units on the undo or redo stack |
| CEnumOLEVERB | Enumerates the different verbs available for an object in order of ascending verb number. An enumerator that implements the IEnumOLEVERB interface is returned by IOleObject::EnumVerbs |
| CEnumShellItems | |
| CEnumSTATDATA | Enumerates the advisory connection information for a data object |
| CEnumSTATSTG | The IEnumSTATSTG interface enumerates an array of STATSTG structures. These structures contain statistical data about open storage, stream, or byte array objects |
| CEnumString | Enumerate strings. LPOLESTR is the type that indicates a pointer to a zero-terminated string of wide, or Unicode, characters |
| CEnumUnknown | |
| CEnumVARIANT | |
| CEnumWbemClassObject | |
| CErrorInfo | Provides detailed contextual error information |
| CErrorLog | Communicates detailed error information between a client and an object |
| CEventWaitHandle | |
| CEventWaitHandleAccessMask | |
| CException | |
| CExceptionData | |
| CExceptionLocation | |
| CExceptionLocationData | |
| CExceptionReporter | Mandatory base class for exception reporters |
| CExecutionEngineException | |
| CFieldAccessException | |
| ►CFileMapping | A file mapping is the association of a file's contents with a portion of the virtual address space of a process |
| CView | |
| CFillLockBytes | The IFillLockBytes interface enables downloading code to write data asynchronously to a structured storage byte array. When the downloading code has new data available, it calls IFillLockBytes::FillAppend or IFillLockBytes::FillAt to write the data to the byte array. An application attempting to access this data, through calls to the ILockBytes interface, can do so even as the downloader continues to make calls to IFillLockBytes. If the application attempts to access data that has not already been downloaded through a call to IFillLockBytes, then ILockBytes returns a new error, E_PENDING |
| CFilterSpecification | |
| CFixedBinary | |
| CFixedSizeMemoryManager | |
| CFixedSizeMemoryManagerStatistics | |
| CFixedString | |
| CFlags | |
| CFont | |
| CFontDisp | |
| CFontEventsDisp | |
| CForegroundTransfer | Transfers the foreground window to the process hosting the COM server |
| CFormatException | |
| ►CGuid | Represents a globally unique identifier (GUID) |
| CDataT | |
| CHandle | |
| CIndexOutOfRangeException | |
| CInitializeWithFile | |
| CInitializeWithStream | |
| CInsufficientExecutionStackException | |
| CInsufficientMemoryException | |
| CInt16BitTraits | |
| CInt32BitTraits | |
| CInt64BitTraits | |
| CInteger | A typed wrapper for integral types |
| CInterlockedLinkedList | |
| CInterval | A closed/open interval that works well with the boost Interval Container Library |
| CInvalidCastException | |
| CInvalidOperationException | |
| CInvalidProgramException | |
| CInvalidTimeZoneException | |
| CIWbemObjectSinkDispatcher | |
| CIWbemObjectSinkDispatcherBase | |
| CIWbemObjectSinkImplementationBase | |
| CLatLongReport | |
| CLatLongReportFactory | |
| CLayoutStorage | |
| CLightweightSemaphore | |
| ►CList | |
| CNode | |
| CListConstIterator | |
| CListIterator | |
| CLocation | |
| CLocationEventsSinkImpl | |
| CLocationPermissions | |
| CLocationPower | |
| CLocationReport | |
| CLocationReportFactory | |
| CLockBytes | The ILockBytes interface is implemented on a byte array object that is backed by some physical storage, such as a disk file, global memory, or a database. It is used by a COM compound file storage object to give its root storage access to the physical device, while isolating the root storage from the details of accessing the physical storage |
| CMalloc | |
| CMallocaDeleter | |
| CMallocAllocator | |
| CMarshal | |
| CMemberAccessException | |
| CMessageFilter | Provides COM servers and applications with the ability to selectively handle incoming and outgoing COM messages while waiting for responses from synchronous calls. Filtering messages helps to ensure that calls are handled in a manner that improves performance and avoids deadlocks. COM messages can be synchronous, asynchronous, or input-synchronized; the majority of interface calls are synchronous |
| CMethodAccessException | |
| CMissingFieldException | |
| CMissingMemberException | |
| CMissingMethodException | |
| CModuleHandle | |
| CMofCompiler | |
| CMoniker | |
| CMulticastNotSupportedException | |
| CMutex | |
| CMutexAccessMask | |
| CNamedPropertyStore | |
| CNotFiniteNumberException | |
| CNotImplementedException | |
| CNotSupportedException | |
| CNullReferenceException | |
| CObjectWithPropertyKey | |
| CObjectWithSite | |
| CObservable | |
| COldVector | |
| COleAdviseHolder | Manages advisory connections and compound document notifications in an object server. Its methods are intended to be used to implement the advisory methods of IOleObject. IOleAdviseHolder is implemented on an advise holder object. Its methods establish and delete advisory connections from the object managed by the server to the object's container, which must contain an advise sink (support the IAdviseSink interface). The advise holder object must also keep track of which advise sinks are interested in which notifications and pass along the notifications as appropriate |
| COleCache | Provides control of the presentation data that gets cached inside of an object. Cached presentation data is available to the container of the object even when the server application is not running or is unavailable |
| COleCache2 | Enables object clients to selectively update each cache that was created with IOleCache::Cache |
| COleCacheControl | Provides proper maintenance of caches. It maintains the caches by connecting the running object's IDataObject implementation to the cache, allowing the cache to receive notifications from the running object |
| COleClientSite | Provides the primary means by which an embedded object obtains information about the location and extent of its display site, its moniker, its user interface, and other resources provided by its container. An object server calls IOleClientSite to request services from the container. A container must provide one instance of IOleClientSite for every compound-document object it contains |
| COleContainer | Enumerates objects in a compound document or lock a container in the running state. Container and object applications both implement this interface |
| COleControl | Provides the features for supporting keyboard mnemonics, ambient properties, and events in control objects |
| COleControlSite | Provides the methods that enable a site object to manage each embedded control within a container. A site object provides IOleControlSite as well as other site interfaces such as IOleClientSite and IOleInPlaceSite. When a control requires the services expressed through this interface, it will query one of the other client site interfaces for IOleControlSite |
| COleInPlaceActiveObject | Provides a direct channel of communication between an in-place object and the associated application's outer-most frame window and the document window within the application that contains the embedded object. The communication involves the translation of messages, the state of the frame window (activated or deactivated), and the state of the document window (activated or deactivated). Also, it informs the object when it needs to resize its borders, and manages modeless dialog boxes |
| COleInPlaceFrame | Controls the container's top-level frame window. This control involves allowing the container to insert its menu group into the composite menu, install the composite menu into the appropriate window frame, and remove the container's menu elements from the composite menu. It sets and displays status text relevant to the in-place object. It also enables or disables the frame's modeless dialog boxes, and translates accelerator keystrokes intended for the container's frame |
| COleInPlaceObject | |
| COleInPlaceObjectWindowless | |
| COleInPlaceSite | |
| COleInPlaceSiteEx | |
| COleInPlaceSiteWindowless | |
| COleInPlaceUIWindow | Implemented by container applications and used by object applications to negotiate border space on the document or frame window. The container provides a RECT structure in which the object can place toolbars and other similar controls, determines if tools can in fact be installed around the object's window frame, allocates space for the border, and establishes a communication channel between the object and each frame and document window |
| COleItemContainer | |
| COleLink | |
| COleObject | Serves as the principal means by which an embedded object provides basic functionality to, and communicates with, its container |
| COleParentUndoUnit | |
| COleUndoManager | The IOleUndoManager interface enables containers to implement multi-level undo and redo operations for actions that occur within contained controls |
| COleUndoUnit | |
| COleWindow | The IOleWindow interface provides methods that allow an application to obtain the handle to the various windows that participate in in-place activation, and also to enter and exit context-sensitive help mode |
| COperationCanceledException | |
| COutOfMemoryException | |
| COverflowException | |
| COwnerVector | |
| CParseDisplayName | Parses a displayable name string to convert it into a moniker for custom moniker implementations |
| CPerPropertyBrowsing | Retrieves the information in the property pages offered by an object |
| CPersist | Wrapper for the IPersist interface. IPersist provides the CLSID of an object that can be stored persistently in the system. Allows the object to specify which object handler to use in the client process, as it is used in the default implementation of marshaling |
| CPersistFile | Enables an object to be loaded from or saved to a disk file, rather than a storage object or stream. Because the information needed to open a file varies greatly from one application to another, the implementation of IPersistFile::Load on the object must also open its disk file |
| CPersistMemory | Saves and loads objects from a stream |
| CPersistPropertyBag | Works with IPropertyBag and IErrorlog to define an individual property-based persistence mechanism |
| CPersistPropertyBag2 | Works with the IPropertyBag2 interface and the IErrorlog interface to define an individual property-based persistence mechanism |
| CPersistSerializedPropStorage | |
| CPersistSerializedPropStorage2 | |
| CPersistStorage | Enables a container application to pass a storage object to one of its contained objects and to load and save the storage object. This interface supports the structured storage model, in which each contained object has its own storage that is nested within the container's storage |
| CPersistStream | Wrapper for the IPersistStream interface. IPersistStream enables the saving and loading of objects that use a simple serial stream for their storage needs |
| CPersistStreamInit | |
| CPicture | |
| CPicture2 | |
| CPictureDisp | |
| CPlatformNotSupportedException | |
| CPointerInactive | |
| CPortableDeviceKeyCollection | |
| CPortableDevicePropVariantCollection | |
| CPortableDeviceValues | |
| CPortableDeviceValuesCollection | |
| CProcess | |
| CProcessAccessMask | |
| CProcessLock | Used by ISurrogateService to prevent the process from terminating due to a time-out |
| CProcessOptions | |
| CProducerToken | |
| CProgressNotify | Enables applications and other objects to receive notifications of changes in the progress of a downloading operation |
| CPropertyBag | |
| CPropertyBag2 | Provides an object with a property bag in which the object can save its properties persistently |
| CPropertyChange | |
| CPropertyChangeArray | |
| CPropertyDescription | |
| CPropertyDescription2 | |
| CPropertyDescriptionAliasInfo | |
| CPropertyDescriptionList | |
| CPropertyDescriptionRelatedPropertyInfo | |
| CPropertyDescriptionSearchInfo | |
| CPropertyEnumType | |
| CPropertyEnumType2 | |
| CPropertyEnumTypeList | |
| CPropertyNotifySink | |
| CPropertyPage | |
| CPropertyPage2 | |
| CPropertyPageSite | Provides the main features for a property page site object |
| CPropertyStore | |
| CPropertyStoreCache | |
| CPropertyStoreCapabilities | |
| CPropertyStoreFactory | |
| CPropertySystem | |
| CPropertySystemChangeNotify | |
| CPropertyVariant | |
| CProvideClassInfo | Provides access to the type information for an object's coclass entry in its type library |
| CProvideClassInfo2 | An extension to ProvideClassInfo (IProvideClassInfo) that makes is faster and easier to retrieve an object's outgoing interface IID for its default event set |
| CProvideMultipleClassInfo | An extension to IProvideClassInfo2 that makes it faster and easier to retrieve type information from a component that may have multiple coclasses that determine its behavior |
| CQuickActivate | Enables controls and containers to avoid performance bottlenecks on loading controls. It combines the load-time or initialization-time handshaking between the control and its container into a single call |
| CRankException | |
| CRdtscConverter | |
| CRecordInfo | Describes the structure of a particular UDT. You can use IRecordInfo any time you need to access the description of UDTs contained in type libraries. IRecordInfo can be reused as needed; there can be many instances of the UDT for a single IRecordInfo pointer |
| CReferenceCounted | |
| CReferenceCountedData | |
| CReferenceCountedPtr | |
| CReferenceCountedThreadSafe | |
| CRegistryHandle | |
| CRootStorage | The IRootStorage interface contains a single method that switches a storage object to a different underlying file and saves the storage object to that file. The save operation occurs even with low-memory conditions and uncommitted changes to the storage object. A subsequent call to IStorage::Commit is guaranteed to not consume additional memory |
| CROTData | Implemented by monikers to enable the running object table (ROT) to compare monikers against each other |
| CRtwqAsyncCallback | |
| CRtwqAsyncResult | |
| CRtwqPlatformEvents | |
| CRunnableObject | Enables a container to control the running of its embedded objects. In the case of an object implemented with a local server, calling the Run method launches the server's .EXE file. In the case of an object implemented with an in-process server, calling Run causes the object .DLL file to transition into the running state |
| CRunningObjectTable | Manages access to the running object table (ROT), a globally accessible look-up table on each workstation. A workstation's ROT keeps track of those objects that can be identified by a moniker and that are currently running on the workstation. When a client tries to bind a moniker to an object, the moniker checks the ROT to see if the object is already running; this allows the moniker to bind to the current instance instead of loading a new one |
| ►CSafeArray | |
| CBound | |
| CDataLock | |
| CSafeArrayLock | |
| CSafeArrayT | |
| CSByteBitTraits | |
| CSemaphore | |
| CSemaphoreAccessMask | |
| CSemaphoreEx | |
| CSensor | Represents a sensor |
| CSensorCollection | |
| CSensorDataReport | |
| CSensorEventSink | |
| CSensorEventSinkBase | |
| CSensorManager | Provides methods for discovering and retrieving available sensors and a method to request sensor manager events |
| CSensorManagerEventSink | |
| CSensorManagerEventSinkBase | |
| CSequentialStream | |
| CServiceProvider | Provides a generic access mechanism to locate a GUID-identified service |
| CSevenBitDecode | |
| CSevenBitEncode | |
| CShellItem | |
| CShellItemArray | |
| CSign | Represents the sign of a signed arithmetic type |
| CSimpleConcurrentQueue | Simple blocking fixed size queue |
| CSimpleFrameSite | |
| CSlimReaderWriterLock | Slim reader/writer (SRW) locks enable the threads of a single process to access shared resources; they are optimized for speed and occupy very little memory. Slim reader-writer locks cannot be shared across processes |
| CSpecifyPropertyPages | Indicates that an object supports property pages. OLE property pages enable an object to display its properties in a tabbed dialog box known as a property sheet. An end user can then view and change the object's properties. An object can display its property pages independent of its client, or the client can manage the display of property pages from a number of contained objects in a single property sheet. Property pages also provide a means for notifying a client of changes in an object's properties |
| CSpinlock | |
| CStackOverflowException | |
| CStartupInfo | |
| CStgMedium | Represents a generalized global memory handle used for data transfer operations by the IAdviseSink, IDataObject, and IOleCache interfaces |
| CStopwatch | |
| CStorage | |
| CStream | |
| CStringBuilder | |
| CSupportErrorInfo | Ensures that error information can be propagated up the call chain correctly. Automation objects that use the error handling interfaces must implement ISupportErrorInfo |
| CSurrogateService | Used to initialize, launch, and release a COM+ application. You can also refresh the catalog and shut down the process |
| CSynchronizationBarrier | A synchronization barrier enables multiple threads to wait until all threads have all reached a particular point of execution before any thread continues. Synchronization barriers cannot be shared across processes |
| CSysString | |
| CSystemException | |
| CThread | |
| CThreadAbortException | Thrown by Thread::Exit |
| CThreadAccessMask | |
| CThreadGroup | |
| CTimeBase | |
| CTimeoutException | |
| CTimerQueue | |
| ►CTimerQueueTimer | |
| CArgs | |
| CArgsTuple | |
| CTimeSpan | Represents a time interval |
| CTuple | |
| CTuple< T, Types... > | |
| CTuple<> | |
| CTupleElement | |
| CTypeAttributes | |
| CTypeChangeEvents | Enables clients to subscribe to type change notifications on objects that implement the ITypeInfo, ITypeInfo2, ICreateTypeInfo, and ICreateTypeInfo2 interfaces. When ITypeChangeEvents is implemented on an object, it acts as an incoming interface that enables the object to receive calls from external clients and engage in bidirectional communication with those clients |
| CTypeComp | The ITypeComp interface provides a fast way to access information that compilers need when binding to and instantiating structures and interfaces. Binding is the process of mapping names to types and type members |
| CTypeFactory | |
| CTypeInfo | ITypeInfo is an interface used for reading information about objects. For example, an object browser tool can use ITypeInfo to extract information about the characteristics and capabilities of objects from type libraries |
| CTypeInfo2 | Used for reading information about objects. Can be cast to an ITypeInfo instead of using the calls QueryInterface and Release to allow quick opens and allocs. This only works for in-process cases |
| CTypeInitializationException | |
| CTypeLib | Represents a type library, the data that describes a set of objects. A type library can be a stand-alone binary file (.TLB), a resource in a dynamic link library or executable file (.DLL, .OLB, or .EXE) |
| CTypeLib2 | Represents a type library, the data that describes a set of objects |
| CTypeLibAttributes | |
| CTypeLibEntry | |
| CTypeLibRegistration | |
| CTypeLibRegistrationReader | |
| CTypeLoadException | |
| CTypeMarshal | |
| CTypeUnloadedException | |
| CUInt16BitTraits | |
| CUInt32BitTraits | |
| CUInt64BitTraits | |
| CUnauthorizedAccessException | |
| CUnknown | Base class for COM interface wrappers |
| CUnsecuredApartment | |
| CUriFormatException | |
| CUriTemplateMatchException | |
| CVariant | |
| CVariantTypeTraits | |
| CVariantTypeTraits< bool > | |
| CVariantTypeTraits< double > | |
| CVariantTypeTraits< float > | |
| CVariantTypeTraits< int > | |
| CVariantTypeTraits< long > | |
| CVariantTypeTraits< long long > | |
| CVariantTypeTraits< short > | |
| CVariantTypeTraits< signed char > | |
| CVariantTypeTraits< unsigned char > | |
| CVariantTypeTraits< unsigned int > | |
| CVariantTypeTraits< unsigned long > | |
| CVariantTypeTraits< unsigned long long > | |
| CVariantTypeTraits< unsigned short > | |
| CVariantTypeTraits< wchar_t > | |
| CVariantTypeTraits< WideString > | |
| CVector | |
| ►CVectorBase | |
| CDataPtr | |
| CVectorConstIterator | |
| CVectorIterator | |
| CViewObject | |
| CViewObject2 | |
| CViewObjectEx | |
| CWaitableHandle | |
| CWaitableTimer | |
| CWaitableTimerAccessMask | |
| CWbemAddressResolution | |
| CWbemBackupRestore | |
| CWbemBackupRestoreEx | |
| CWbemCallResult | |
| CWbemClassObject | The WbemClassObject contains and manipulates both class definitions and class object instances |
| CWbemClientConnectionTransport | |
| CWbemClientTransport | |
| CWbemConfigureRefresher | |
| CWbemConnectorLogin | |
| CWbemConstructClassObject | |
| CWbemContext | |
| CWbemDecoupledBasicEventProvider | |
| CWbemDecoupledRegistrar | |
| CWbemEventConsumerProvider | |
| CWbemEventProvider | |
| CWbemEventProviderQuerySink | |
| CWbemEventProviderSecurity | |
| CWbemEventSink | |
| CWbemHiPerfEnum | |
| CWbemHiPerfProvider | |
| CWbemLevel1Login | |
| CWbemLocator | |
| ►CWbemMethod | |
| CData | |
| ►CWbemMethodSignature | |
| CData | |
| CWbemObjectAccess | |
| CWbemObjectSink | The IWbemObjectSink interface creates a sink interface that can receive all types of notifications within the WMI programming model. Clients must implement this interface to receive both the results of the asynchronous methods of WbemServices, and specific types of event notifications. Providers use, but do not implement this interface to provide events and objects to WMI |
| CWbemObjectSinkEx | |
| CWbemObjectTextSrc | |
| ►CWbemProperty | |
| CData | |
| CWbemPropertyProvider | |
| CWbemProviderIdentity | |
| CWbemProviderInit | |
| CWbemProviderInitSink | |
| CWbemQualifierSet | |
| CWbemRefresher | |
| CWbemServices | The WbemServices is used by clients and providers to access WMI services. The interface is implemented by WMI and WMI providers, and is the primary WMI interface |
| CWbemShutdown | |
| CWbemStatusCodeText | |
| CWbemTransport | |
| CWbemUnboundObjectSink | |
| CWbemUnsecuredApartment | |
| CWideCharBitTraits | |
| CWpdSerializer | Used by the device driver to serialize IPortableDeviceValues interfaces to and from the raw data buffers used to communicate with the application |
| CXXH64Hasher | |
| ►NOCI | |
| ►NInternal | |
| CLongVarBinaryDataType | |
| CScalarDataReader | |
| CTraits | |
| CTraits< bool > | |
| CTraits< Byte > | |
| CTraits< DateTime > | |
| CTraits< Double > | |
| CTraits< Guid > | |
| CTraits< Int16 > | |
| CTraits< Int32 > | |
| CTraits< Int64 > | |
| CTraits< SByte > | |
| CTraits< Single > | |
| CTraits< UInt16 > | |
| CTraits< UInt32 > | |
| CTraits< UInt64 > | |
| CTraits< wchar_t * > | |
| CTraits< WideString > | |
| CTraitsImpl | |
| CVarBinaryDataType | |
| ►NMetadata | |
| CArgument | |
| CArgumentOrResult | |
| CColumn | |
| CDatabase | |
| CFunction | |
| CMetadataObject | |
| CPackage | |
| CProcedure | |
| CProcedureOrFunction | |
| CResult | |
| CSchema | |
| CSchemaObject | |
| CSequence | |
| CSynonym | |
| CTable | |
| CTableOrView | |
| CType | |
| CTypeAttribute | |
| CTypeObject | |
| CView | |
| CArgumentDescriptor | ArgumentDescriptor |
| CArrayBind | ArrayBind, base class for binding an array of values |
| CArrayDataReader | Provides access to the column values within each row |
| CArrayDefine | ArrayDefine, base class for defines for use with the ArrayDataReader class |
| CBFILELocator | BFILELocator |
| CBinaryArrayDefine | BinaryArrayDefine |
| CBinaryBind | BinaryBind |
| CBinaryDefine | BinaryDefine |
| ►CBinaryDynamicBind | BinaryDynamicBind |
| CInfo | |
| CBind | Bind, base class for binding a single value |
| CBindBase | BindBase, base class for binds |
| CBlobBind | BlobBind |
| CCLobArrayBaseDefine | |
| CCLobBaseArrayBind | CLobBaseBind |
| CCLobBaseBind | CLobBaseBind |
| CCLobBaseDefine | CLobBaseDefine |
| CCollection | Collection |
| CCollectionDefine | CollectionDefine |
| CCollectionDescriptor | CollectionDescriptor |
| CColumnDescriptor | ColumnDescriptor |
| CCStringArrayBind | CStringArrayBind |
| CCStringArrayDefine | CStringArrayDefine |
| CCStringBind | CStringBind, a bind type for a zero terminated wide c string |
| CCStringDefine | CStringDefine |
| CDatabaseDescriptor | DatabaseDescriptor |
| CDataReader | Provides access to the column values within each row |
| CDataReaderBase | DataReaderBase Implements functionality common to DataReader and ArrayDataReader |
| CDate | Binary compatible with OCIDate |
| CDateArrayBind | DateArrayBind |
| CDateArrayDefine | DateArrayDefine |
| CDateBind | DateBind |
| CDateDefine | DateDefine |
| CDefine | Define, base class for defines for use with the DataReader class |
| CDefineBase | DefineBase, base class for all defines |
| CDescribe | Describe |
| CDescriptor | Descriptor, base class for all the descriptors |
| CDescriptorArrayBaseBind | DescriptorArrayBaseBind |
| CDescriptorArrayBind | DescriptorArrayBind |
| CDescriptorArrayDefine | DescriptorArrayDefine, maintains a vector of descriptors on behalf of derived types |
| CDescriptorBaseArrayDefine | DescriptorBaseDefine |
| CDescriptorBaseBind | DescriptorBaseBind |
| CDescriptorBaseDefine | DescriptorBaseDefine |
| CDescriptorBind | DescriptorBind |
| CDescriptorDefine | DescriptorDefine, maintains the descriptor for derived types |
| CDynamicBind | DynamicBind |
| CDynamicDefine | DynamicDefine |
| CDynamicLongRawDefine | DynamicLongRawDefine |
| CEnvironment | The environment handle defines a context in which all OCI functions are invoked |
| CEnvironmentOptions | EnvironmentOptions |
| CErrorHandle | The error handle is passed as a parameter to most OCI calls |
| CEvaluationContextDescriptor | EvaluationContextDescriptor |
| CFailoverCallback | |
| CFixedBinaryArrayBind | FixedBinaryArrayBind |
| CFixedBinaryArrayDefine | FixedBinaryArrayDefine |
| CFixedBinaryBind | FixedBinaryBind |
| CFixedBinaryDefine | FixedBinaryDefine |
| CFixedStringArrayDefine | FixedStringArrayDefine |
| CFixedStringDefine | FixedStringDefine |
| CFunctionDescriptor | FunctionDescriptor |
| CGuidArrayBind | GuidArrayBind |
| CGuidArrayDefine | GuidArrayDefine |
| CGuidBind | GuidBind |
| CGuidDefine | GuidDefine |
| CHandleBase | Base class for OCI handle wrappers |
| CIntervalBaseArrayDefine | IntervalBaseArrayDefine - template used to implement IntervalDSArrayDefine and IntervalYMArrayDefine |
| CIntervalBaseDefine | IntervalBaseDefine, template used to implement IntervalDSDefine and IntervalYMDefine |
| CIntervalBaseDescriptor | IntervalBaseDescriptor |
| CIterator | Iterator |
| CLargeBinaryRefBind | LargeBinaryRefBind |
| CListDescriptor | ListDescriptor |
| CLobArrayBaseDefine | LobArrayBaseDefine |
| CLobBaseArrayBind | LobBaseArrayBind |
| CLobBaseBind | LobBaseBind |
| CLobBaseDefine | LobDefine |
| CLOBLocator | LOBLocator |
| CLOBLocatorBase | LOBLocatorBase |
| CLobStream | LobStream |
| CLongVarBinaryDefine | LongVarBinaryDefine |
| CMethodArgumentDescriptor | MethodArgumentDescriptor |
| CMethodDescriptor | MethodDescriptor |
| CMethodResultDescriptor | MethodResultDescriptor |
| CNameValuePairDescriptor | NameValuePairDescriptor |
| CNumber | Number |
| CNumberArrayBaseDefine | NumberArrayBaseDefine |
| CNumberBaseDefine | NumberBaseDefine |
| CObject | Object |
| CObjectBase | ObjectBase |
| CObjectDefine | ObjectDefine |
| CPackageDescriptor | PackageDescriptor |
| CParameterDescriptor | ParameterDescriptor |
| CProcedureDescriptor | ProcedureDescriptor |
| CProcedureOrFunctionDescriptor | ProcedureOrFunctionDescriptor |
| CRef | Ref |
| CRefCursorBind | RefCursorBind |
| CResultSetDescriptor | ResultSetDescriptor |
| CRowIdDescriptor | RowIdDescriptor |
| CRuleDescriptor | RuleDescriptor |
| CRuleSetDescriptor | RuleSetDescriptor |
| CSchemaDescriptor | SchemaDescriptor |
| CSequenceDescriptor | SequenceDescriptor |
| CServer | A server handle represents a connection between the client application and the Oracle database server |
| CServiceContext | ServiceContext - A service context handle defines attributes that determine the operational context for OCI calls to a server |
| CSession | Session |
| CSimpleArrayBind | SimpleArrayBind, template for binding an array of a basic data type |
| CSimpleArrayDefine | SimpleArrayDefine, template used to implement defines for basic data types for the ArrayDataReader |
| CSimpleBind | SimpleBind, template for binding a single basic data type
|
| CSimpleDefine | SimpleDefine, template used to implement defines for basic data types for the DataReader |
| CSnapshotDescriptor | SnapshotDescriptor |
| CStatement | Statement, the context that identifies a SQL or PL/SQL statement and its associated attributes |
| CStringBind | StringBind |
| CSubscription | Subscription |
| CSynonymDescriptor | SynonymDescriptor |
| CTableAliasDescriptor | TableAliasDescriptor |
| CTableDescriptor | TableDescriptor |
| CTableViewBaseDescriptor | TableViewBaseDescriptor |
| CTime | Binary compatible with OCITime |
| CTimestampBaseArrayBind | |
| CTimestampBaseArrayDefine | TimestampBaseArrayDefine, template used to implement TimestampArrayDefine, TimestampTZArrayDefine and TimestampLTZArrayDefine |
| CTimestampBaseBind | TimeStampBaseBind |
| CTimestampBaseDefine | TimestampBaseDefine, template used to implement TimestampDefine, TimestampTZDefine and TimestampLTZDefine |
| CTimestampBaseDescriptor | TimestampBaseDescriptor |
| CTransaction | Represents a transaction |
| CTransactionHandle | TransactionHandle |
| CType | Type |
| CTypeAttributeDescriptor | TypeAttributeDescriptor |
| CTypeAttributeInfo | TypeAttributeInfo |
| CTypeDescriptor | TypeDescriptor |
| CTypeInfo | TypeInfo |
| CVarBinaryArrayDefine | VarBinaryArrayDefine |
| CVarBinaryDefine | VarBinaryDefine |
| CVariableTypeDescriptor | VariableTypeDescriptor |
| CViewDescriptor | ViewDescriptor |
| ►NODBC | |
| ►NInternal | |
| CDBValue | |
| ►NMsSql | |
| Cdbdatetime | |
| Cdbdatetime4 | |
| Cdbmoney | |
| CtagDBTIME2 | |
| CtagDBTIMESTAMPOFFSET | |
| CtagSS_TIME2_STRUCT | |
| CtagSS_TIMESTAMPOFFSET_STRUCT | |
| CConnection | |
| CDataReader | |
| CDataSource | |
| CDate | |
| CDescriptor | A descriptor is a collection of metadata that describes the parameters of an SQL statement or the columns of a result set, as seen by the application or driver |
| CDiagnosticRecord | |
| CDriver | |
| CEnvironment | |
| CFixedDBBinary | |
| CFixedDBString | |
| CInterval | |
| CMoney | |
| CNumeric | |
| CParameterDescription | |
| CRowVersion | |
| CSqlHandle | This template implements functionality common to the ODBC handle wrapper classes |
| CSqlState | |
| CStatement | |
| CTime | |
| CTime2 | |
| CTimeStamp | |
| CTimeStampOffset | |
| ►NWindows | |
| ►NDirectShow | |
| CAMAnalogVideoDecoder | |
| CAMAudioInputMixer | |
| CAMBufferNegotiation | |
| ►CAMCameraControl | |
| CExposure | |
| CFocus | |
| CIris | |
| CPan | |
| CPrivacy | |
| CRoll | |
| CScanMode | |
| CTilt | |
| CZoom | |
| CAMCopyCaptureFileProgress | |
| CAMCrossbar | |
| CAMDroppedFrames | |
| CAMovieSetup | |
| CAMStreamConfig | |
| CAMStreamControl | |
| CAMTuner | |
| CAMTunerNotification | |
| CAMTVTuner | |
| CAMVfwCaptureDialogs | |
| CAMVfwCompressDialogs | |
| CAMVideoCompression | |
| CAMVideoControl | |
| CAMVideoProcAmp | |
| CAsyncReader | |
| CBaseFilter | |
| CBPCSatelliteTuner | |
| CCameraControlPropertyRange | |
| CCameraControlPropertySetting | |
| CCameraControlSettings | |
| CCaptureGraphBuilder | |
| CCaptureGraphBuilder2 | |
| CCodecAPI | |
| CConfigAviMux | |
| CConfigInterleaving | |
| CCreateDevEnum | |
| CDistributorNotify | |
| CEnumFilters | |
| CEnumMediaTypes | |
| CEnumPins | |
| CEnumRegFilters | |
| CFileSinkFilter | |
| CFileSinkFilter2 | |
| CFileSourceFilter | |
| CFilterGraph | |
| CFilterGraph2 | |
| CFilterGraph3 | |
| CFilterMapper | |
| CFilterMapper2 | |
| CFilterMapper3 | |
| CGraphBuilder | |
| CGraphVersion | |
| CMediaEventSink | |
| CMediaFilter | |
| CMediaSample | |
| CMediaSample2 | |
| CMediaSample2Config | |
| CMediaSeeking | |
| CMemAllocator | |
| CMemAllocatorCallbackTemp | |
| CMemAllocatorNotifyCallbackTemp | |
| CMemInputPin | |
| COverlay | |
| COverlayNotify | |
| COverlayNotify2 | |
| CPin | |
| CQualityControl | |
| CReferenceClock | |
| CReferenceClock2 | |
| CReferenceClockTimerControl | |
| CResourceConsumer | |
| CResourceManager | |
| CSeekingPassThru | |
| CStreamBuilder | |
| ►NDocumentTarget | |
| CPrintDocumentPackageStatusEvent | |
| CPrintDocumentPackageTarget | |
| CPrintDocumentPackageTargetFactory | |
| ►NFonts | |
| ►CFont | |
| CData | |
| CTypeFaceList | |
| ►CTypesFace | |
| CData | |
| ►NGraphics | |
| ►ND3D11 | |
| CAsynchronous | This object encapsulates methods for retrieving data from the GPU asynchronously |
| CAuthenticatedChannel | Provides a communication channel with the graphics driver or the Microsoft Direct3D runtime |
| CBlendState | The blend-state object holds a description for blending state that you can bind to the output-merger stage |
| CBlendState1 | The blend-state object holds a description for blending state that you can bind to the output-merger stage. This blend-state object supports logical operations as well as blending operations |
| CBuffer | A buffer object accesses a buffer resource, which is unstructured memory. Buffers typically store vertex or index data |
| CClassInstance | This object encapsulates an HLSL class |
| CClassLinkage | This object encapsulates an HLSL dynamic linkage |
| CCommandList | This object encapsulates a list of graphics commands for play back |
| CComputeShader | A compute-shader object manages an executable program (a compute shader) that controls the compute-shader stage |
| CCounter | This object encapsulates methods for measuring GPU performance |
| CCryptoSession | Represents a cryptographic session |
| CDepthStencilState | The depth-stencil-state object holds a description for depth-stencil state that you can bind to the output-merger stage |
| CDepthStencilView | A depth-stencil-view object accesses a texture resource during depth-stencil testing |
| CDevice | The device object represents a virtual adapter; it is used to create resources |
| CDevice1 | The device interface represents a virtual adapter; it is used to create resources |
| CDevice2 | Virtual adapter; it is used to create resources |
| CDevice3 | The device interface represents a virtual adapter; it is used to create resources |
| CDevice4 | The device class represents a virtual adapter; it is used to create resources |
| CDevice5 | The device class represents a virtual adapter; it is used to create resources |
| CDeviceChild | A device-child object accesses data used by a device |
| CDeviceContext | Represents a device context which generates rendering commands |
| CDeviceContext1 | Represents a device context; it is used to render commands |
| CDeviceContext2 | The device context interface represents a device context; it is used to render commands |
| CDeviceContext3 | The device context class represents a device context; it is used to render commands |
| CDeviceContext4 | The device context interface represents a device context; it is used to render commands |
| CDeviceContextState | Represents a context state object, which holds state and behavior information about a Microsoft Direct3D device |
| CDomainShader | A domain-shader object manages an executable program (a domain shader) that controls the domain-shader stage |
| CFence | Represents a fence, an object used for synchronization of the CPU and one or more GPUs |
| CGeometryShader | A geometry-shader object manages an executable program (a geometry shader) that controls the geometry-shader stage |
| CHullShader | A hull-shader object manages an executable program (a hull shader) that controls the hull-shader stage |
| CInputLayout | An input-layout interface holds a definition of how to feed vertex data that is laid out in memory into the input-assembler stage of the graphics pipeline |
| CMultithread | Provides threading protection for critical sections of a multi-threaded application |
| CPixelShader | A pixel-shader object manages an executable program (a pixel shader) that controls the pixel-shader stage |
| CPredicate | A predicate object determines whether geometry should be processed depending on the results of a previous draw call |
| CQuery | A query object queries information from the GPU |
| CQuery1 | Represents a query object for querying information from the graphics processing unit (GPU) |
| CRasterizerState | The rasterizer-state object holds a description for rasterizer state that you can bind to the rasterizer stage |
| CRasterizerState1 | The rasterizer-state object holds a description for rasterizer state that you can bind to the rasterizer stage. This rasterizer-state class supports forced sample count |
| CRasterizerState2 | The rasterizer-state object holds a description for rasterizer state that you can bind to the rasterizer stage. This rasterizer-state class supports forced sample count and conservative rasterization mode |
| CRenderTargetView | A render-target-view object identifies the render-target sub-resources that can be accessed during rendering |
| CRenderTargetView1 | A render-target-view object represents the render-target subresources that can be accessed during rendering |
| CResource | A resource object provides common actions on all resources |
| CSamplerState | The sampler-state object holds a description for sampler state that you can bind to any shader stage of the pipeline for reference by texture sample operations |
| CShaderResourceView | A shader-resource-view object specifies the sub-resources a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, and a texture |
| CShaderResourceView1 | A shader-resource-view object represents the subresources a shader can access during rendering. Examples of shader resources include a constant buffer, a texture buffer, and a texture |
| CTexture1D | A 1D texture object accesses texel data, which is structured memory |
| CTexture2D | A 2D texture object manages texel data, which is structured memory |
| CTexture2D1 | Represents texel data, which is structured memory |
| CTexture3D | A 3D texture object accesses texel data, which is structured memory |
| CTexture3D1 | A 3D texture object represents texel data, which is structured memory |
| CUnorderedAccessView | A view object specifies the parts of a resource the pipeline can access during rendering |
| CUnorderedAccessView1 | An unordered-access-view object represents the parts of a resource the pipeline can access during rendering |
| CUserDefinedAnnotation | Enables an application to describe conceptual sections and markers within the application's code flow |
| CVertexShader | A vertex-shader object manages an executable program (a vertex shader) that controls the vertex-shader stage |
| CVideoContext | Provides the video functionality of a Microsoft Direct3D 11 device |
| CVideoContext1 | Provides the video functionality of a Microsoft Direct3D 11 device |
| CVideoContext2 | Provides the video functionality of a Microsoft Direct3D 11 device |
| CVideoContext3 | Provides the video functionality of a Microsoft Direct3D 11 device. This class provides the DecoderBeginFrame1 method, which provides support for decode histograms |
| CVideoDecoder | Represents a hardware-accelerated video decoder for Microsoft Direct3D 11 |
| CVideoDecoderOutputView | Identifies the output surfaces that can be accessed during video decoding |
| CVideoDevice | Provides the video decoding and video processing capabilities of a Microsoft Direct3D 11 device |
| CVideoDevice1 | Provides the video decoding and video processing capabilities of a Microsoft Direct3D 11 device |
| CVideoDevice2 | Provides the video decoding and video processing capabilities of a Microsoft Direct3D 11 device. Adds the CheckFeatureSupport method for querying for decoding capabilities |
| CVideoProcessor | Represents a video processor for Microsoft Direct3D 11 |
| CVideoProcessorEnumerator | Enumerates the video processor capabilities of a Microsoft Direct3D 11 device |
| CVideoProcessorEnumerator1 | Enumerates the video processor capabilities of a Microsoft Direct3D 11 device |
| CVideoProcessorInputView | Identifies the input surfaces that can be accessed during video processing |
| CVideoProcessorOutputView | Identifies the output surfaces that can be accessed during video processing |
| CView | A view object specifies the parts of a resource the pipeline can access during rendering |
| ►ND3D11On12 | |
| CDevice | |
| CDevice1 | |
| CDevice2 | |
| ►ND3D12 | |
| ►NVideo | |
| CD3D12VideoDecodeCommandList | Encapsulates a list of graphics commands for video decoding |
| CD3D12VideoDecodeCommandList1 | Encapsulates a list of graphics commands for video decoding. This class inherits from D3D12VideoDecodeCommandList and adds support for video decode histograms |
| CD3D12VideoDecodeCommandList2 | Encapsulates a list of graphics commands for video decoding. This class inherits from D3D12VideoDecodeCommandList1 and adds support for video extension commands |
| CD3D12VideoDecoder | |
| CD3D12VideoDecoder1 | Represents a Direct3D 12 video decoder that contains resolution-independent resources and state for performing the decode operation. Inherits from D3D12VideoDecoder and adds support for protected resources |
| CD3D12VideoDecoderHeap | |
| CD3D12VideoDecoderHeap1 | Represents a Direct3D 12 video decoder heap that contains resolution-dependent resources and state for performing the decode operation. Inherits from D3D12VideoDecoderHeap and adds support for protected resources |
| CD3D12VideoDevice | |
| CD3D12VideoDevice1 | Provides video decoding and processing capabilities of a Microsoft Direct3D 12 device including the ability to query video capabilities and instantiating video decoders and processors. This interface adds support for motion estimation |
| CD3D12VideoDevice2 | Provides video decoding and processing capabilities of a Microsoft Direct3D 12 device including the ability to query video capabilities and instantiating video decoders and processors. This class adds support for protected resources and video extension commands |
| CD3D12VideoDevice3 | Extends the D3D12VideoDevice2 class to add support video encoding capabilities |
| CD3D12VideoEncodeCommandList | Encapsulates a list of graphics commands for video encoding, including motion estimation |
| CD3D12VideoEncodeCommandList1 | Encapsulates a list of graphics commands for video encoding. This class inherits from D3D12VideoEncodeCommandList and adds support for video extension commands |
| CD3D12VideoEncodeCommandList2 | Encapsulates a list of graphics commands for video encoding. This class inherits from D3D12VideoEncodeCommandList1 and adds methods for encoding video and resolving encode operation metadata |
| CD3D12VideoEncoder | Represents a Direct3D 12 video encoder |
| CD3D12VideoEncoderHeap | Represents a Direct3D 12 video encoder heap |
| CD3D12VideoExtensionCommand | Represents a video extension command |
| CD3D12VideoMotionEstimator | This interface maintains context for video motion estimation operations |
| CD3D12VideoMotionVectorHeap | Represents the storage of the motion vector output of a motion estimation operation in an IHV-dependent layout. Call D3D12VideoEncodeCommandList::EstimateMotion to calculate and store motion vectors. Use D3D12VideoEncodeCommandList::ResolveMotionVectorHeap to copy and translate these results into the API-defined layout in a Texture 2D |
| CD3D12VideoProcessCommandList | Encapsulates a list of graphics commands for video processing |
| CD3D12VideoProcessCommandList1 | Encapsulates a list of graphics commands for video processing. Adds the ProcessFrames1 method which supports changing the D3D12_VIDEO_FIELD_TYPE for each call, unlike D3D12VideoProcessCommandList::ProcessFrames |
| CD3D12VideoProcessCommandList2 | Encapsulates a list of graphics commands for video processing. This class inherits from D3D12VideoProcessCommandList1 and adds support for video extension commands |
| CD3D12VideoProcessor | |
| CD3D12VideoProcessor1 | Provides methods for getting information about the parameters to the call to D3D12VideoDevice2::CreateVideoProcessor1 that created the video processor |
| CBlendDesc | Describes the blend state |
| CBox | Describes a 3D box |
| CCachedPipelineState | Stores a pipeline state |
| CClearValue | |
| CCommandAllocator | Represents the allocations of storage for graphics processing unit (GPU) commands |
| CCommandList | The base class for the GraphicsCommandList class. It represents an ordered set of commands that the GPU executes, while allowing for extension to support other command lists than just those for graphics (such as compute and copy) |
| CCommandQueue | Provides methods for submitting command lists, synchronizing command list execution, instrumenting the command queue, and updating resource tile mappings |
| CCommandQueueDesc | Describes a command queue |
| CCommandSignature | A command signature object enables apps to specify indirect drawing, including the buffer format, command type and resource bindings to be used |
| CComputePipelineStateDesc | |
| CD3D12_FEATURE_DATA_D3D12_OPTIONS4 | |
| CD3D12Debug | A wrapper class for the ID3D12Debug interface. This interface is used to turn on the debug layer |
| CD3D12Debug1 | Adds GPU-Based Validation and Dependent Command Queue Synchronization to the debug layer |
| CD3D12Debug2 | Adds configurable levels of GPU-based validation to the debug layer |
| CD3D12Debug3 | Adds configurable levels of GPU-based validation to the debug layer |
| CD3D12Debug4 | Adds the ability to disable the debug layer |
| CD3D12Debug5 | Adds to the debug layer the ability to configure the auto-naming of objects |
| CD3D12Debug6 | A debug interface controls debug settings |
| CD3D12DebugCommandList | Provides methods to monitor and debug a command list |
| CD3D12DebugCommandList1 | Enables modification of additional command list debug layer settings |
| CD3D12DebugCommandList2 | |
| CD3D12DebugCommandQueue | Provides methods to monitor and debug a command queue |
| CD3D12DebugDevice | This interface represents a graphics device for debugging |
| CD3D12DebugDevice1 | Specifies device-wide debug layer settings |
| CD3D12DebugDevice2 | |
| CD3D12InfoQueue | An information-queue stores, retrieves, and filters debug messages. The queue consists of a message queue, an optional storage filter stack, and a optional retrieval filter stack |
| CD3D12InfoQueue1 | D3D12InfoQueue1 adds support for message callback with the RegisterMessageCallback and UnregisterMessageCallback functions |
| CD3D12SharingContract | Facilitates diagnostics tools to capture information at a lower level than the DXGI swapchain |
| CDepthStencilDesc | Describes depth-stencil state |
| CDepthStencilDesc1 | Describes depth-stencil state |
| CDepthStencilValue | |
| CDescriptorHeap | A descriptor heap is a collection of contiguous allocations of descriptors, one allocation for every descriptor. Descriptor heaps contain many object types that are not part of a Pipeline State Object (PSO), such as Shader Resource Views (SRVs), Unordered Access Views (UAVs), Constant Buffer Views (CBVs), and Samplers |
| CDevice | Represents a virtual adapter; it is used to create command allocators, command lists, command queues, fences, resources, pipeline state objects, heaps, root signatures, samplers, and many resource views |
| CDevice1 | Represents a virtual adapter, and expands on the range of methods provided by the Device class |
| CDevice2 | Represents a virtual adapter. This class extends the Device1 class to create pipeline state objects from pipeline state stream descriptions |
| CDevice3 | Represents a virtual adapter. This class extends the Device2 class to support the creation of special-purpose diagnostic heaps in system memory that persist even in the event of a GPU-fault or device-removed scenario |
| CDevice4 | Represents a virtual adapter |
| CDevice5 | Represents a virtual adapter |
| CDevice6 | Represents a virtual adapter |
| CDevice7 | Represents a virtual adapter |
| CDevice8 | Represents a virtual adapter |
| CDeviceChild | Adds the ability to get the device used to create it |
| CDeviceRemovedExtendedData | Provides runtime access to Device Removed Extended Data (DRED) data |
| CDeviceRemovedExtendedData1 | |
| CDeviceRemovedExtendedDataSettings | This class controls Device Removed Extended Data (DRED) settings |
| CDeviceRemovedExtendedDataSettings1 | |
| CFeatureDataArchitecture | |
| CFeatureDataArchitecture1 | |
| CFeatureDataCommandQueuePriority | |
| CFeatureDataCrossNode | |
| CFeatureDataD3D12Options | |
| CFeatureDataD3D12Options1 | |
| CFeatureDataD3D12Options10 | |
| CFeatureDataD3D12Options11 | |
| CFeatureDataD3D12Options12 | |
| CFeatureDataD3D12Options13 | |
| CFeatureDataD3D12Options2 | |
| CFeatureDataD3D12Options3 | |
| CFeatureDataD3D12Options5 | |
| CFeatureDataD3D12Options6 | |
| CFeatureDataD3D12Options7 | |
| CFeatureDataD3D12Options8 | |
| CFeatureDataD3D12Options9 | |
| CFeatureDataDisplayable | |
| CFeatureDataExistingHeaps | |
| CFeatureDataFeatureLevels | |
| CFeatureDataFormatInfo | |
| CFeatureDataFormatSupport | |
| CFeatureDataGpuVirtualAddressSupport | |
| CFeatureDataMultiSampleQualityLevels | |
| CFeatureDataQueryMetaCommand | |
| CFeatureDataRootSignature | |
| CFeatureDataSerialization | |
| CFeatureDataShaderCache | |
| CFence | Represents a fence, an object used for synchronization of the CPU and one or more GPUs |
| CFence1 | Adds the ability to retrie the flags used to create the fence. This feature is useful primarily for opening shared fences |
| CGraphicsCommandList | Encapsulates a list of graphics commands for rendering. Includes APIs for instrumenting the command list execution, and for setting and clearing the pipeline state |
| CGraphicsCommandList1 | Encapsulates a list of graphics commands for rendering, extending the GraphicsCommandList class to support programmable sample positions, atomic copies for implementing late-latch techniques, and optional depth-bounds testing |
| CGraphicsCommandList2 | Encapsulates a list of graphics commands for rendering, extending the GraphicsCommandList1 class to support writing immediate values directly to a buffer |
| CGraphicsCommandList3 | Encapsulates a list of graphics commands for rendering |
| CGraphicsCommandList4 | Encapsulates a list of graphics commands for rendering, extending the GraphicsCommandList3 class to support ray tracing and render passes |
| CGraphicsCommandList5 | Encapsulates a list of graphics commands for rendering, extending the GraphicsCommandList4 class to support variable-rate shading (VRS) |
| CGraphicsCommandList6 | |
| CGraphicsPipelineStateDesc | |
| CHeap | A heap is an abstraction of contiguous memory allocation, used to manage physical memory. This heap can be used with Resource objects to support placed resources or reserved resources |
| CHeap1 | |
| CHeapDesc | |
| CHeapProperties | |
| CInputElementDesc | Describes a single element for the input-assembler stage of the graphics pipeline |
| CInputLayoutDesc | Describes the input-buffer data for the input-assembler stage |
| CLifetimeOwner | Represents an application-defined callback used for being notified of lifetime changes of an object |
| CLifetimeTracker | Represents facilities for controlling the lifetime a lifetime-tracked object |
| CMetaCommand | |
| CMipRegion | |
| CObject | A base class from which Device and DeviceChild inherit from. It provides methods to associate private data and annotate object names |
| CPackedMipInfo | |
| CPageable | Classes derived from Pageable encapsulates some amount of GPU-accessible memory |
| CPipelineLibrary | Manages a pipeline library, in particular loading and retrieving individual PSOs |
| CPipelineLibrary1 | Manages a pipeline library. This class extends the PipelineLibrary class to load PSOs from a pipeline state stream description |
| CPipelineState | Represents the state of all currently set shaders as well as certain fixed function state objects |
| CPipelineStateStreamDesc | Describes a pipeline state stream |
| CPlacedSubresourceFootprint | |
| CProtectedResourceSession | Monitors the validity of a protected resource session |
| CProtectedResourceSession1 | Monitors the validity of a protected resource session |
| CProtectedSession | Offers base functionality that allows for a consistent way to monitor the validity of a session across the different types of sessions. The only type of session currently available is of type ProtectedResourceSession |
| CQueryHeap | Manages a query heap. A query heap holds an array of queries, referenced by indexes |
| CRange | |
| CRangeUInt64 | |
| CRasterizerDesc | Describes rasterizer state |
| CRenderTargetBlendDesc | Describes the blend state for a render target |
| CRenderTargetFormatArray | Wraps an array of render target formats |
| CResource | Encapsulates a generalized ability of the CPU and GPU to read and write to physical memory, or heaps. It contains abstractions for organizing and manipulating simple arrays of data as well as multidimensional data optimized for shader sampling |
| CResource1 | |
| CResource2 | |
| CResourceAliasingBarrier | |
| CResourceAllocationInfo | |
| CResourceAllocationInfo1 | |
| CResourceBarrier | |
| CResourceDesc | |
| CResourceDesc1 | |
| CResourceTransitionBarrier | |
| CResourceUavBarrier | |
| CRootSignature | The root signature defines what resources are bound to the graphics pipeline. A root signature is configured by the app and links command lists to the resources the shaders require. Currently, there is one graphics and one compute root signature per app |
| CRootSignatureDeserializer | Contains a method to return the deserialized D3D12_ROOT_SIGNATURE_DESC data structure, of a serialized root signature version 1.0 |
| CSamplePosition | |
| CShaderBytecode | Describes shader data |
| CStateObject | Represents a variable amount of configuration state, including shaders, that an application manages as a single unit and which is given to a driver atomically to process, such as compile or optimize. Create a state object by calling Device5::CreateStateObject |
| CStateObjectProperties | Provides methods for getting and setting the properties of an StateObject. To retrieve an instance of this type, call StateObject::As<StateObjectProperties>() |
| CStencilOperationsDesc | Describes stencil operations that can be performed based on the results of stencil test |
| CStreamOutputDeclarationEntry | Describes a vertex element in a vertex buffer in an output slot |
| CStreamOutputDesc | Describes a streaming output buffer |
| CSubresourceFootprint | |
| CSubresourceInfo | |
| CSubresourceRangeUInt64 | |
| CSubresourceTiling | |
| CSwapChainAssistant | |
| CTextureCopyLocation | |
| CTiledResourceCoordinate | |
| CTileRegionSize | |
| CTileShape | |
| CTools | This class is used to configure the runtime for tools such as PIX. Its not intended or supported for any other scenario |
| CVersionedRootSignatureDeserializer | Contains methods to return the deserialized D3D12_ROOT_SIGNATURE_DESC1 data structure, of any version of a serialized root signature |
| CViewInstanceLocation | |
| CViewInstancingDesc | |
| CViewport | Describes the dimensions of a viewport |
| ►NDirectComposition | |
| CAffineTransform2DEffect | The arithmetic composite effect is used to combine 2 images using a weighted sum of pixels from the input images |
| CAnimation | Represents a function for animating one or more properties of one or more Microsoft DirectComposition objects. Any object property that takes a scalar value can be animated |
| CArithmeticCompositeEffect | The arithmetic composite effect is used to combine 2 images using a weighted sum of pixels from the input images |
| CBlendEffect | The Blend Effect is used to combine 2 images |
| CBrightnessEffect | The brightness effect controls the brightness of the image |
| CClip | Represents a clip object that is used to restrict the rendering of a visual subtree to a rectangular area |
| CColorMatrixEffect | The color matrix effect alters the RGBA values of a bitmap |
| CCompositeEffect | The composite effect is used to combine 2 or more images. This effect has 13 different composite modes. The composite effect accepts 2 or more inputs. When you specify 2 images, destination is the first input (index 0) and the source is the second input (index 1). If you specify more than 2 inputs, the images are composited starting with the first input and the second and so on |
| CDelegatedInkTrail | |
| CDesktopDevice | An application must use the DesktopDevice class in order to use DirectComposition in a Windows desktop application. This interface allows the application to connect a visual tree to a window and to host layered child windows for composition |
| CDevice | Serves as a factory for all other Microsoft DirectComposition objects and provides methods to control transactional composition |
| CDevice2 | Serves as a factory for all other Microsoft DirectComposition objects and provides methods to control transactional composition |
| CDevice3 | Serves as a factory for all other Microsoft DirectComposition objects and provides methods to control transactional composition |
| CDeviceDebug | Provides access to rendering features that help with application debugging and performance tuning. This interface can be queried from the DirectComposition device interface |
| CEffect | Represents a bitmap effect that modifies the rasterization of a visual's subtree |
| CEffectGroup | Represents a group of bitmap effects that are applied together to modify the rasterization of a visual's subtree |
| CFilterEffect | FilterEffect exposes a subset of Direct2D's image effects through DirectComposition for use in CSS filters in the browser platform |
| CGaussianBlurEffect | The Gaussian blur effect is used to blur an image by a Gaussian function, typically to reduce image noise and reduce detail |
| CHueRotationEffect | The hue rotate effect alters the hue of an image by applying a color matrix based on the rotation angle |
| CInkTrailDevice | |
| CLinearTransferEffect | The linear transfer effect is used to map the color intensities of an image using a linear function created from a list of values you provide for each channel |
| CMatrixTransform | Represents an arbitrary affine 2D transformation defined by a 3-by-2 matrix |
| CMatrixTransform3D | Represents an arbitrary 3D transformation defined by a 4-by-4 matrix |
| CRectangleClip | Represents a clip object that restricts the rendering of a visual subtree to the specified rectangular region. Optionally, the clip object may have rounded corners specified |
| CRotateTransform | Represents a 2D transformation that affects the rotation of a visual around the z-axis. The coordinate system is rotated around the specified center point |
| CRotateTransform3D | Represents a 3D transformation that affects the rotation of a visual along an arbitrary axis in 3D space. The coordinate system is rotated around the specified center point |
| CSaturationEffect | This effect is used to alter the saturation of an image. The saturation effect is a specialization of the color matrix effect |
| CScaleTransform | Represents a 2D transformation that affects the scale of a visual along the x-axis and y-axis. The coordinate system is scaled from the specified center point |
| CScaleTransform3D | Represents a 3D transformation effect that affects the scale of a visual along the x-axis, y-axis, and z-axis. The coordinate system is scaled from the specified center point |
| CShadowEffect | The shadow effect is used to generate a shadow from the alpha channel of an image. The shadow is more opaque for higher alpha values and more transparent for lower alpha values. You can set the amount of blur and the color of the shadow |
| CSkewTransform | Represents a 2D transformation that affects the skew of a visual along the x-axis and y-axis. The coordinate system is skewed around the specified center point |
| CSurface | Represents a physical bitmap that can be associated with a visual for composition in a visual tree. This interface can also be used to update the bitmap contents |
| CSurfaceFactory | Creates surface and virtual surface objects associated with an application-provided rendering device |
| CTableTransferEffect | The table transfer effect is used to map the color intensities of an image using a transfer function created from interpolating a list of values you provide |
| CTarget | Represents a binding between a Microsoft DirectComposition visual tree and a destination on top of which the visual tree should be composed |
| CTransform | Represents a 2D transformation that can be used to modify the coordinate space of a visual subtree |
| CTransform3D | Represents a 3D transformation effect that can be used to modify the rasterization of a visual subtree |
| CTranslateTransform | Represents a 2D transformation that affects only the offset of a visual along the x-axis and y-axis |
| CTranslateTransform3D | Represents a 3D transformation that affects the offset of a visual along the x-axis, y-axis, and z-axis |
| CTurbulenceEffect | The turbulence effect is used to generate a bitmap based on the Perlin noise function. The turbulence effect has no input image |
| CVirtualSurface | Represents a sparsely allocated bitmap that can be associated with a visual for composition in a visual tree |
| CVisual | Represents a Microsoft DirectComposition visual |
| CVisual2 | Represents a single DirectComposition visual in a visual tree |
| CVisual3 | Represents a single DirectComposition visual in a visual tree |
| CVisualDebug | Introduces debug related functions for a visual |
| ►NDirectWrite | |
| CBitmapRenderTarget | Encapsulates a 32-bit device independent bitmap and device context, which can be used for rendering glyphs |
| CFactory | Used to create all subsequent DirectWrite objects. This class is the root factory for all DirectWrite objects |
| CFont | Represents a physical font in a font collection. This interface is used to create font faces from physical fonts, or to retrieve information such as font face metrics or face names from existing font faces |
| CFontCollection | An object that encapsulates a set of fonts, such as the set of fonts installed on the system, or the set of fonts in a particular directory. The font collection API can be used to discover what font families and fonts are available, and to obtain some metadata about the fonts |
| CFontCollectionLoader | Used to construct a collection of fonts given a particular type of key |
| CFontFace | Exposes various font data such as metrics, names, and glyph outlines. It contains font face type, appropriate file references, and face identification data |
| CFontFamily | Represents a family of related fonts |
| CFontFile | Represents a font file. Applications such as font managers or font viewers can call FontFile::Analyze to find out if a particular file is a font file, and whether it is a font type that is supported by the font system |
| CFontFileEnumerator | Encapsulates a collection of font files. The font system uses this interface to enumerate font files when building a font collection |
| CFontFileLoader | Handles loading font file resources of a particular type from a font file reference key into a font file stream object |
| CFontFileStream | Loads font file data from a custom font file loader |
| CFontList | Represents a list of fonts |
| CGdiInterop | Provides interoperability with GDI, such as methods to convert a font face to a LOGFONT structure, or to convert a GDI font description into a font face. It is also used to create bitmap render target objects |
| CGlyphRunAnalysis | Contains low-level information used to render a glyph run |
| CInlineObject | Wraps an application-defined inline graphic, allowing DWrite to query metrics as if the graphic were a glyph inline with the text |
| CLocalFontFileLoader | A built-in implementation of the IDWriteFontFileLoader interface, that operates on local font files and exposes local font file information from the font file reference key. Font file references created using CreateFontFileReference use this font file loader |
| CLocalizedStrings | Represents a collection of strings indexed by locale name |
| CPixelSnapping | Defines the pixel snapping properties such as pixels per DIP(device-independent pixel) and the current transform matrix of a text renderer |
| CRenderingParams | Represents text rendering settings such as ClearType level, enhanced contrast, and gamma correction for glyph rasterization and filtering |
| CTextAnalysisSink | This interface is implemented by the text analyzer's client to receive the output of a given text analysis |
| CTextAnalysisSource | Implemented by the text analyzer's client to provide text to the analyzer. It allows the separation between the logical view of text as a continuous stream of characters identifiable by unique text positions, and the actual memory layout of potentially discrete blocks of text in the client's backing store |
| CTextAnalyzer | Analyzes various text properties for complex script processing such as bidirectional (bidi) support for languages like Arabic, determination of line break opportunities, glyph placement, and number substitution |
| CTextFormat | Describes the font and paragraph properties used to format text, and it describes locale information |
| CTextLayout | Block of text after it has been fully analyzed and formatted |
| CTextRenderer | Represents a set of application-defined callbacks that perform rendering of text, inline objects, and decorations such as underlines |
| CTypography | Represents a font typography setting |
| ►NDXGI | |
| CAdapter | Display subsystem (including one or more GPUs, DACs and video memory) |
| CAdapter1 | Display sub-system (including one or more GPU's, DACs and video memory) |
| CAdapter2 | Display subsystem, which includes one or more GPUs, DACs, and video memory |
| CAdapter3 | This class adds some memory residency methods, for budgeting and reserving physical memory |
| CAdapter4 | This class represents a display subsystem, and extends Adapter3 to introduce a method to check for an adapter's compatibility with Arbitrary Code Guard (ACG) |
| CDecodeSwapChain | Represents a swap chain that is used by desktop media apps to decode video data and show it on a DirectComposition surface |
| CDevice | An Device class implements a derived class for DXGI objects that produce image data |
| CDevice1 | Implements a derived class for DXGI objects that produce image data |
| CDevice2 | Implements a derived class for DXGI objects that produce image data. The class exposes methods to block CPU processing until the GPU completes processing, and to offer resources to the operating system |
| CDevice3 | Implements a derived class for DXGI objects that produce image data. The class exposes a method to trim graphics memory usage by the DXGI device |
| CDevice4 | This class provides updated methods to offer and reclaim resources |
| CDeviceSubObject | Base class for objects that are tied to the device so that they can retrieve a pointer to it |
| CDisplayControl | Exposes methods to indicate user preference for the operating system's stereoscopic 3D display behavior and to set stereoscopic 3D display status to enable or disable |
| CFactory | Implements methods for generating DXGI objects (which handle full screen transitions) |
| CFactory1 | Implements methods for generating DXGI objects |
| CFactory2 | Includes methods to create a newer version swap chain with more features than SwapChain and to monitor stereoscopic 3D capabilities |
| CFactory3 | Enables creating Microsoft DirectX Graphics Infrastructure (DXGI) objects |
| CFactory4 | Enables creating Microsoft DirectX Graphics Infrastructure (DXGI) objects |
| CFactory5 | This class introduces a single method to support variable refresh rate displays |
| CFactory6 | This class introduces a single method that enumerates graphics adapters based on a given GPU preference |
| CFactory7 | This class enables registration for notifications to detect adapter enumeration state changes |
| CFactoryMedia | Creates swap chains for desktop media apps that use DirectComposition surfaces to decode and display video |
| CKeyedMutex | Represents a keyed mutex, which allows exclusive access to a shared resource that is used by multiple devices |
| CObject | This is the base class for all DXGI objects; DXGI::Object supports associating caller-defined (private data) with an object and retrieval of an interface to the parent object |
| COutput | An Output object represents an adapter output (such as a monitor) |
| COutput1 | An Output1 object represents an adapter output (such as a monitor) |
| COutput2 | Represents an adapter output (such as a monitor). The Output2 class exposes a method to check for multiplane overlay support on the primary output adapter |
| COutput3 | Represents an adapter output (such as a monitor). The Output3 class exposes a method to check for overlay support |
| COutput4 | Represents an adapter output (such as a monitor). The Output4 class exposes a method to check for overlay color space support |
| COutput5 | Represents an adapter output (such as a monitor). The Output5 class exposes a single method to specify a list of supported formats for full screen surfaces |
| COutput6 | Represents an adapter output (such as a monitor). The Output6 class introduces methods to provide specific monitor capabilities |
| COutputDuplication | Accesses and manipulates the duplicated desktop image |
| CResource | Allows resource sharing and identifies the memory that a resource resides in |
| CResource1 | Extends the Resource class by adding support for creating a subresource surface object and for creating a handle to a shared resource |
| CSampleDesc | Describes multi-sampling parameters for a resource |
| CSurface | Implements methods for image-data objects |
| CSurface1 | Extends the Surface class by adding support for using Windows Graphics Device Interface (GDI) to render to a Microsoft DirectX Graphics Infrastructure (DXGI) surface |
| CSurface2 | Extends the Surface1 class by adding support for subresource surfaces and getting a handle to a shared resource |
| CSwapChain | A SwapChain object implements one or more surfaces for storing rendered data before presenting it to an output |
| CSwapChain1 | Provides presentation capabilities that are enhanced from SwapChain. These presentation capabilities consist of specifying dirty rectangles and scroll rectangle to optimize the presentation |
| CSwapChain2 | Extends SwapChain1 with methods to support swap back buffer scaling and lower-latency swap chains |
| CSwapChain3 | Extends SwapChain2 with methods to support getting the index of the swap chain's current back buffer and support for color space |
| CSwapChain4 | This class exposes a single method for setting video metadata |
| CSwapChainMedia | This swap chain class allows desktop media applications to request a seamless change to a specific refresh rate |
| ►NImaging | |
| CBitmap | Defines methods that add the concept of writeability and static in-memory representations of bitmaps to BitmapSource |
| CBitmapClipper | Exposes methods that produce a clipped version of the input bitmap for a specified rectangular region of interest |
| CBitmapCodecInfo | Exposes methods that provide information about a particular codec |
| CBitmapCodecProgressNotification | Exposes methods used for progress notification for encoders and decoders |
| CBitmapDecoder | Exposes methods that represent a decoder. The class provides access to the decoder's properties such as global thumbnails (if supported), frames, and palette |
| CBitmapDecoderInfo | Exposes methods that provide information about a decoder |
| CBitmapEncoder | Defines methods for setting an encoder's properties such as thumbnails, frames, and palettes |
| CBitmapEncoderInfo | Exposes methods that provide information about an encoder |
| CBitmapFlipRotator | Exposes methods that produce a flipped (horizontal or vertical) and/or rotated (by 90 degree increments) bitmap source. The flip is done before the rotation |
| CBitmapFrameDecode | Defines methods for decoding individual image frames of an encoded file |
| CBitmapFrameEncode | Represents an encoder's individual image frames |
| CBitmapLock | Exposes methods that support the Lock method |
| CBitmapPattern | |
| CBitmapScaler | Represents a resized version of the input bitmap using a resampling or filtering algorithm |
| CBitmapSource | Exposes methods that refers to a source from which pixels are retrieved, but cannot be written back to |
| CBitmapSourceTransform | Exposes methods for offloading certain operations to the underlying BitmapSource implementation |
| CColorContext | Exposes methods for color management |
| CColorTransform | Exposes methods that transforms a BitmapSource from one color context to another |
| CComponentInfo | Exposes methods that provide component information |
| CEnumMetadataItem | Exposes methods that provide enumeration services for individual metadata items |
| CFastMetadataEncoder | Exposes methods used for in-place metadata editing. A fast metadata encoder enables you to add and remove metadata to an image without having to fully re-encode the image |
| CFormatConverter | Represents a BitmapSource that converts the image data from one pixel format to another, handling dithering and halftoning to indexed formats, palette translation and alpha thresholding |
| CFormatConverterInfo | Exposes methods that provide information about a pixel format converter |
| CImageEncoder | Encodes ID2D1Image interfaces to an BitmapEncoder. The input images can be larger than the maximum device texture size |
| CImageParameters | |
| CImagingFactory | Exposes methods used to create components for the Windows Imaging Component (WIC) such as decoders, encoders and pixel format converters |
| CImagingObject | |
| CMetadataQueryReader | Exposes methods for retrieving metadata blocks and items from a decoder or its image frames using a metadata query expression |
| CMetadataQueryWriter | Exposes methods for setting or removing metadata blocks and items to an encoder or its image frames using a metadata query expression |
| CPalette | Exposes methods for accessing and building a color table, primarily for indexed pixel formats |
| CPixelFormatInfo | Exposes methods that provide information about a pixel format |
| CProgressCallback | |
| CProgressiveLevelControl | Exposes methods for obtaining information about and controlling progressive decoding |
| CRectangle | Represents a rectangle for Windows Imaging Component (WIC) API |
| CResolution | |
| CSize | |
| CStream | Represents a Windows Imaging Component (WIC) stream for referencing imaging and metadata content |
| CBitmap | Represents a bitmap that has been bound to a RenderTarget |
| CBitmap1 | Represents a bitmap that can be used as a surface for a DeviceContext or mapped into system memory, and can contain additional color context information |
| CBitmapBrush | Paints an area with a bitmap |
| CBitmapBrush1 | Paints an area with a bitmap |
| CBitmapRenderTarget | Renders to an intermediate texture created by the CreateCompatibleRenderTarget function |
| CBrush | Defines an object that paints an area. Interfaces that derive from ID2D1Brush describe how the area is painted |
| CColor | |
| CColorContext | Represents a color context that can be used with an Bitmap object |
| CColorContext1 | Represents a color context to be used with the Color Management Effect |
| CCommandList | Represents a sequence of commands that can be recorded and played back |
| CCommandSink | |
| CCommandSink1 | This class performs all the same functions as the existing CommandSink (ID2D1CommandSink) class. It also enables access to the new primitive blend modes, MIN and ADD, through its SetPrimitiveBlend1 method |
| CCommandSink2 | This interface performs all the same functions as the existing ID2D1CommandSink1 interface. It also enables access to ink rendering and gradient mesh rendering |
| CCommandSink3 | This class performs all the same functions as the existing CommandSink2 class. It also enables access to sprite batch rendering |
| CCommandSink4 | |
| CCommandSink5 | This class performs all the same functions as the existing CommandSink4 (ID2D1CommandSink4) class, plus it enables access to the BlendImage method |
| CControlRenderTarget | Renders drawing instructions to a window |
| CD3D10Blob | Used to return arbitrary-length data |
| CDevice | Represents a resource domain whose objects and device contexts can be used together |
| CDevice1 | Represents a resource domain whose objects and device contexts can be used together. This interface performs all the same functions as the existing Device class. It also enables control of the device's rendering priority |
| CDevice2 | Represents a resource domain whose objects and device contexts can be used together. This interface performs all the same functions as the existing ID2D1Device1 interface. It also enables the creation of ID2D1DeviceContext2 objects |
| CDevice3 | Represents a resource domain whose objects and device contexts can be used together. This class performs all the same functions as the Device2 class. It also enables the creation of DeviceContext3 (ID2D1DeviceContext3) objects |
| CDevice4 | Represents a resource domain whose objects and device contexts can be used together. This class performs all the same functions as the Device3 class. It also enables the creation of DeviceContext4 (ID2D1DeviceContext4) objects |
| CDevice5 | Represents a resource domain whose objects and device contexts can be used together. This class performs all the same functions as the Device4 (ID2D1Device4) class. It also enables the creation of ID2D1DeviceContext5 objects |
| CDevice6 | Represents a resource domain whose objects and device contexts can be used together. This class performs all the same functions as the Device5 (ID2D1Device5) class, plus it enables the creation of ID2D1DeviceContext6 objects |
| CDeviceContext | |
| CDeviceContext1 | Enables creation and drawing of geometry realization objects |
| CDeviceContext2 | This interface performs all the same functions as the ID2D1DeviceContext1 interface, plus it enables functionality such as ink rendering, gradient mesh rendering, and improved image loading |
| CDeviceContext3 | This class performs all the same functions as the DeviceContext2 class, plus it enables functionality for creating and drawing sprite batches |
| CDeviceContext4 | This class performs all the same functions as the DeviceContext3 class, plus it adds the functionality for requires for handling new types of color font glyphs |
| CDeviceContext5 | This class performs all the same functions as the DeviceContext4 (ID2D1DeviceContext4) class, plus it enables the creation of color contexts and Svg documents |
| CDeviceContext6 | This class performs all the same functions as the existing DeviceContext5 (ID2D1DeviceContext5) class, plus it provides access to the BlendImage method |
| CDeviceContextRenderTarget | Issues drawing commands to a GDI device context |
| CDrawingStateBlock | Represents the drawing state of a render target: the anti-aliasing mode, transform, tags, and text-rendering options |
| CDrawingStateBlock1 | Implementation of a drawing state block that adds the functionality of primitive blend in addition to already existing anti-alias mode, transform, tags and text rendering mode |
| CEffect | Represents a basic image-processing construct in Direct2D |
| CEllipseGeometry | Represents an ellipse |
| CFactory | Creates Direct2D resources |
| CFactory1 | Creates Direct2D resources |
| CFactory2 | This factory enables the creation of Device1 (ID2D1Device1) objects |
| CFactory3 | Creates Direct2D resources. This interface also enables the creation of ID2D1Device2 objects |
| CFactory4 | Creates Direct2D resources. This class also adds the ability to create ID2D1Device3 objects |
| CFactory5 | |
| CFactory6 | |
| CFactory7 | Creates Direct2D resources. This class performs all the same functions as the Factory6 (ID2D1Factory6) class, plus it enables the creation of ID2D1Device6 objects |
| CGdiInteropRenderTarget | Provides access to a device context that can accept GDI drawing commands |
| CGdiMetafile | A Direct2D resource that wraps a WMF, EMF, or EMF+ metafile |
| CGdiMetafile1 | Interface encapsulating a GDI/GDI+ metafile |
| CGdiMetafileSink | A developer implemented interface that allows a meta-file to be replayed |
| CGdiMetafileSink1 | This interface performs all the same functions as the existing ID2D1GdiMetafileSink interface. It also enables access to metafile records |
| CGeometry | Represents a geometry resource and defines a set of helper methods for manipulating and measuring geometric shapes. Interfaces that inherit from ID2D1Geometry define specific shapes |
| CGeometryGroup | Represents a composite geometry, composed of other Geometry (ID2D1Geometry) objects |
| CGeometryRealization | Encapsulates a device- and transform-dependent representation of a filled or stroked geometry. Callers should consider creating a geometry realization when they wish to accelerate repeated rendering of a given geometry. This interface exposes no methods |
| CGeometrySink | Describes a geometric path that can contain lines, arcs, cubic Bezier curves, and quadratic Bezier curves |
| CGradientMesh | Represents a device-dependent representation of a gradient mesh composed of patches. Use the DeviceContext2::CreateGradientMesh function to create an instance of GradientMesh |
| CGradientStopCollection | Represents a collection of D2D1_GRADIENT_STOP objects for linear and radial gradient brushes |
| CGradientStopCollection1 | Represents a collection of D2D1_GRADIENT_STOP objects for linear and radial gradient brushes. It provides get methods for all the new parameters added to the gradient stop collection |
| CID2D1CommandSinkImplementationBase | |
| CID2D1GdiMetafileSinkImplementationBase | Basic implementation of ID2D1GdiMetafileSink |
| CID2D1GeometrySinkImplementationBase | Basic implementation of ID2D1GeometrySink |
| CID2D1SimplifiedGeometrySinkImplementationBase | Basic implementation of ID2D1SimplifiedGeometrySink |
| CID2D1TessellationSinkImplementationBase | |
| CImage | Represents a producer of pixels that can fill an arbitrary 2D plane |
| CImageBrush | Represents a brush based on an ID2D1Image |
| CImageSource | Represents a producer of pixels that can fill an arbitrary 2D plane |
| CImageSourceFromWic | Produces 2D pixel data that has been sourced from WIC |
| CInk | Represents a single continuous stroke of variable-width ink, as defined by a series of Bezier segments and widths |
| CInkStyle | Represents a collection of style properties to be used by methods like ID2D1DeviceContext2::DrawInk when rendering ink. The ink style defines the nib (pen tip) shape and transform |
| CLayer | Represents the backing store required to render a layer |
| CLinearGradientBrush | Paints an area with a linear gradient |
| CLookupTable3D | A container for 3D lookup table data that can be passed to the LookupTable3D effect |
| CMesh | Represents a set of vertices that form a list of triangles |
| CMultithread | A locking mechanism from a Direct2D factory that Direct2D uses to control exclusive resource access in an application that is uses multiple threads |
| CPathGeometry | Represents a complex shape that may be composed of arcs, curves, and lines |
| CPathGeometry1 | The PathGeometry1 adds functionality to PathGeometry. In particular, it provides the path geometry-specific ComputePointAndSegmentAtLength method |
| CPrintControl | Converts Direct2D primitives stored in an ID2D1CommandList into a fixed page representation. The print sub-system then consumes the primitives |
| CProperties | Represents a set of run-time bindable and discoverable properties that allow a data-driven application to modify the state of a Direct2D effect |
| CRadialGradientBrush | Paints an area with a radial gradient |
| CRectangleGeometry | Describes a two-dimensional rectangle |
| CRenderTarget | Represents an object that can receive drawing commands. Interfaces that inherit from RenderTarget (ID2D1RenderTarget) render the drawing commands they receive in different ways |
| CResource | Represents a Direct2D drawing resource |
| CRoundedRectangleGeometry | Describes a rounded rectangle |
| CSimplifiedGeometrySink | Describes a geometric path that does not contain quadratic bezier curves or arcs |
| CSolidColorBrush | Paints an area with a solid color |
| CSpriteBatch | Represents a single group of sprites with their associated drawing properties |
| CStrokeStyle | Describes the caps, miter limit, line join, and dash information for a stroke |
| CStrokeStyle1 | Describes the caps, miter limit, line join, and dash information for a stroke |
| CSvgAttribute | |
| CSvgDocument | |
| CSvgElement | |
| CSvgGlyphStyle | This object supplies the values for context-fill, context-stroke, and context-value that are used when rendering SVG glyphs |
| CSvgPaint | |
| CSvgPathData | |
| CSvgPointCollection | |
| CSvgStrokeDashArray | |
| CTessellationSink | Populates an ID2D1Mesh object with triangles |
| CTransformedGeometry | Represents a geometry that has been transformed |
| CTransformedImageSource | Represents an image source which shares resources with an original image source |
| ►NImGui | |
| CApplication | |
| CForm | |
| ►NInternal | |
| CTraits | |
| CTraits< D2D1_RECT_F > | |
| CTraits< D2D1_RECT_U > | |
| CTraits< D2D1_SIZE_F > | |
| CTraits< D2D1_SIZE_U > | |
| CTraits< D2D_POINT_2F > | |
| CTraits< D2D_POINT_2U > | |
| CTraits< POINT > | |
| CTraits< POINTL > | |
| CTraits< RECT > | |
| CTraits< SIZE > | |
| ►NMedia | |
| ►NInternal | |
| CAttributeImpl | |
| CIMFAsyncCallbackFunctionImpl | |
| ►NLiveMedia | |
| CMediaFoundationH264LiveSource | |
| CMediaFoundationMediaSubsession | |
| CMediaFoundationRTSPServer | |
| Cabstract | |
| CActivateAudioInterfaceAsyncOperation | |
| CActivateAudioInterfaceCompletionHandler | |
| CAttribute | |
| CAttributes | |
| CAudioSystemEffectsPropertyChangeNotificationClient | |
| CAudioSystemEffectsPropertyStore | |
| CBlobValue | |
| CCameraExtrinsics | |
| CCameraUIControl | |
| CCameraUIControlEventCallback | |
| CCodecAPI | Sets and retrieves settings on an encoder or decoder filter |
| CDeviceSources | |
| CDMOQualityControl | Supports quality control on a Microsoft DirectX Media Object (DMO) |
| CDMOVideoOutputOptimizations | Supports video optimizations on a Microsoft DirectX Media Object (DMO) |
| CEncryptionSubSampleMappingSplit | |
| CEnumDMO | This class provides methods for enumerating Microsoft DirectX Media Objects (DMOs) |
| CEVRFilterConfig | |
| CEVRFilterConfigEx | |
| CEVRTrustedVideoPlugin | |
| CMediaBuffer | Wrapper for the IMediaBuffer interface which provides methods for manipulating a data buffer. Buffers passed to the IMediaObject::ProcessInput and ProcessOutput methods must implement this interface |
| CMediaFoundation | |
| ►CMediaObject | Functions for manipulating a Microsoft DirectX Media Object |
| CMediaType | |
| CStreamCount | |
| CMediaObjectInPlace | Methods for processing data in place |
| ►CMF2DBuffer | Represents a buffer that contains a two-dimensional surface, such as a video frame |
| CScanline0AndPitch | |
| CMF2DBuffer2 | Represents a buffer that contains a two-dimensional surface, such as a video frame |
| CMFActivate | Enables the application to defer the creation of an object. This functionality is exposed by activation objects |
| CMFAsyncCallback | Callback interface to notify the application when an asynchronous method completes |
| CMFAsyncCallbackLogging | Provides logging information about the parent object the async callback is associated with |
| CMFAsyncResult | Provides information about the result of an asynchronous operation |
| CMFAttributes | |
| CMFAudioMediaType | |
| CMFAudioPolicy | |
| CMFAudioStreamVolume | |
| CMFByteStream | Represents a byte stream from some data source, which might be a local file, a network file, or some other source. The MFByteStream class supports the typical stream operations, such as reading, writing, and seeking |
| CMFByteStreamBuffering | |
| CMFByteStreamCacheControl | |
| CMFByteStreamCacheControl2 | Controls how a network byte stream transfers data to a local cache |
| CMFByteStreamHandler | Creates a media source from a byte stream |
| CMFByteStreamProxyClassFactory | Creates a proxy to a byte stream |
| CMFByteStreamTimeSeek | Seeks a byte stream by time position |
| CMFCameraOcclusionStateMonitor | Implemented by applications to receive camera occlusion state change notifications |
| CMFCameraOcclusionStateReport | Provides the camera occlusion state associated with a state change detected by a MFCameraOcclusionStateMonitor |
| CMFCameraOcclusionStateReportCallback | |
| CMFCapturePhotoConfirmation | |
| CMFClock | Provides timing information from a clock in Microsoft Media Foundation |
| CMFClockConsumer | |
| CMFClockStateSink | Receives state-change notifications from the presentation clock |
| CMFCollection | Represents a generic collection of IUnknown pointers |
| CMFCollectionT | |
| CMFContentDecryptorContext | Allows a decryptor to manage hardware keys and decrypt hardware samples |
| CMFContentEnabler | Implements one step that must be performed for the user to access media content. For example, the steps might be individualization followed by license acquisition. Each of these steps would be encapsulated by a content enabler object that exposes the IMFContentEnabler interface |
| CMFContentProtectionDevice | Allows a decryptor to communicate with the security processor that implements the hardware decryption for a protection system |
| CMFContentProtectionManager | |
| CMFDesiredSample | |
| CMFDeviceTransform | |
| CMFDeviceTransformCallback | |
| CMFDXGIBuffer | Represents a buffer that contains a Microsoft DirectX Graphics Infrastructure (DXGI)surface |
| CMFDXGIDeviceManager | Enables two threads to share the same Microsoft Direct3D 11 device |
| CMFDXGIDeviceManagerSource | Provides functionality for getting the MFDXGIDeviceManager from the Microsoft Media Foundation video rendering sink |
| CMFExtendedCameraControl | This class is used to configure a capture device's extended properties. Supported properties and capabilities are defined in the header file defined in ksmedia.h as constants with the naming convention KSCAMERA_EXTENDEDPROP_ |
| CMFExtendedCameraController | Allows apps to retrieve an instance of MFExtendedCameraControl, which is used to configure a capture device's extended properties |
| CMFExtendedCameraIntrinsicModel | |
| CMFExtendedCameraIntrinsics | |
| CMFExtendedCameraIntrinsicsDistortionModel6KT | |
| CMFExtendedCameraIntrinsicsDistortionModelArcTan | |
| CMFFieldOfUseMFTUnlock | Enables an application to use a Media Foundation transform (MFT) that has restrictions on its use |
| CMFFinalizableMediaSink | |
| CMFGetService | Queries an object for a specified service interface |
| CMFHttpDownloadRequest | Applications implement this interface to override the default implementation of the HTTP and HTTPS protocols used by Microsoft Media Foundation. Applications provide the IMFHttpDownloadRequest interface to Media Foundation through the CreateRequest method on the MFHttpDownloadSession interface |
| CMFHttpDownloadSession | Applications implement this interface to override the default implementation of the HTTP and HTTPS protocols used by Microsoft Media Foundation |
| CMFHttpDownloadSessionProvider | Applications implement this interface in order to provide custom a custom HTTP or HTTPS download implementation |
| CMFInputTrustAuthority | Enables other components in the protected media path (PMP) to use the input protection system provided by an input trust authorities (ITA). An ITA is a component that implements an input protection system for media content |
| CMFLocalMFTRegistration | |
| CMFMediaBuffer | Represents a block of memory that contains media data. Use this interface to access the data in the buffer |
| CMFMediaEvent | |
| CMFMediaEventGenerator | Retrieves events from any Media Foundation object that generates events |
| CMFMediaEventQueue | |
| CMFMediaSession | Provides playback controls for protected and unprotected content. The Media Session and the protected media path (PMP) session objects expose this interface. This interface is the primary interface that applications use to control the Media Foundation pipeline |
| CMFMediaSink | This class is the base class for all Media Foundation media sinks. Stream sinks handle the actual processing of data on each stream |
| CMFMediaSinkPreroll | |
| CMFMediaSource | Base class for media source objects |
| CMFMediaSource2 | |
| CMFMediaSourceEx | |
| CMFMediaSourcePresentationProvider | Provides notifications to the sequencer source |
| CMFMediaSourceTopologyProvider | Enables an application to get a topology from the sequencer source. This interface is exposed by the sequencer source object |
| CMFMediaStream | Represents one stream in a media source |
| CMFMediaStream2 | |
| CMFMediaStreamSourceSampleRequest | Represents a request for a sample from a MediaStreamSource |
| CMFMediaType | Represents a description of a media format |
| CMFMediaTypeHandler | Gets and sets media types on an object, such as a media source or media sink |
| CMFMetadata | Manages metadata for an object. Metadata is information that describes a media file, stream, or other content. Metadata consists of individual properties, where each property contains a descriptive name and a value. A property may be associated with a particular language |
| CMFMetadataProvider | |
| CMFMuxStreamAttributesManager | Provides access to the MFAttributes of the substreams of a multiplexed media source |
| CMFMuxStreamMediaTypeManager | Enables the management of stream configurations for a multiplexed media source. A stream configuration defines a set of substreams that can be included the multiplexed output |
| CMFMuxStreamSampleManager | Provides the ability to retrieve MFSample objects for individual substreams within the output of a multiplexed media source |
| CMFNetCredential | Sets and retrieves user-name and password information for authentication purposes |
| CMFNetCredentialCache | |
| CMFNetCredentialManager | |
| CMFNetCrossOriginSupport | Implemented by clients that want to enforce a cross origin policy for HTML5 media downloads |
| CMFNetProxyLocator | Determines the proxy to use when connecting to a server. The network source uses this interface |
| CMFNetProxyLocatorFactory | Creates a proxy locator object, which determines the proxy to use |
| CMFNetResourceFilter | Notifies the application when a byte stream requests a URL, and enables the application to block URL redirection |
| CMFNetSchemeHandlerConfig | Configures a network scheme plug-in |
| CMFObjectReferenceStream | |
| CMFOutputPolicy | Encapsulates a usage policy from an input trust authority (ITA). Output trust authorities (OTAs) use this interface to query which protection systems they are required to enforce by the ITA |
| CMFOutputSchema | Encapsulates information about an output protection system and its corresponding configuration data |
| CMFOutputTrustAuthority | Encapsulates the functionality of one or more output protection systems that a trusted output supports. This functionality is exposed by output trust authority (OTA) objects. Each OTA represents a single action that the trusted output can perform, such as play, copy, or transcode. An OTA can represent more than one physical output if each output performs the same action |
| CMFPluginControl | |
| CMFPluginControl2 | Controls how media sources and transforms are enumerated in Microsoft Media Foundation |
| CMFPMPClient | Enables a media source to receive an instance of the MFPMPHost class |
| CMFPMPClientApp | Provides a mechanism for a media source to implement content protection functionality in a Windows Store apps |
| CMFPMPHost | Enables a media source in the application process to create objects in the protected media path (PMP) process |
| CMFPMPHostApp | Allows a media source to create a Windows Runtime object in the Protected Media Path (PMP) process |
| CMFPMPServer | Enables two instances of the Media Session to share the same protected media path (PMP) process |
| CMFPresentationClock | Represents a presentation clock, which is used to schedule when samples are rendered and to synchronize multiple streams |
| CMFPresentationDescriptor | Describes the details of a presentation. A presentation is a set of related media streams that share a common presentation time |
| CMFPresentationTimeSource | Provides the clock times for the presentation clock |
| CMFProtectedEnvironmentAccess | Provides a method that allows content protection systems to perform a handshake with the protected environment. This is needed because the CreateFile and DeviceIoControl APIs are not available to Windows Store apps |
| CMFQualityAdvise | |
| CMFQualityAdvise2 | Enables a pipeline object to adjust its own audio or video quality, in response to quality messages |
| CMFQualityAdviseLimits | |
| CMFQualityManager | Adjusts playback quality |
| CMFRateControl | Gets or sets the playback rate |
| CMFRateSupport | |
| CMFReadWriteClassFactory | Creates an instance of either the sink writer or the source reader |
| CMFRealTimeClient | |
| CMFRealTimeClientEx | Notifies a pipeline object to register itself with the Multimedia Class Scheduler Service (MMCSS) |
| CMFRelativePanelReport | This class is used to retrieve the current relative panel location for a display region |
| CMFRelativePanelWatcher | Monitors the panel associated with a display, so that the app receives notifications when the relative location of the panel changes |
| CMFRemoteAsyncCallback | |
| CMFRemoteDesktopPlugin | Modifies a topology for use in a Terminal Services environment |
| CMFRemoteProxy | Exposed by objects that act as a proxy for a remote object. To obtain an instance of this class, call MFGetService::GetService with the service identifier MF_REMOTE_PROXY |
| CMFSAMIStyle | Sets and retrieves Synchronized Accessible Media Interchange (SAMI) styles on the SAMI Media Source |
| CMFSample | |
| CMFSampleAllocatorControl | Implemented by video capture sources and transforms. Allows the system to provide components with a sample allocator to allocate samples using memory that is accessible from within a container |
| CMFSampleGrabberSinkCallback | Callback interface to get media data from the sample-grabber sink |
| CMFSampleGrabberSinkCallback2 | Extends the IMFSampleGrabberSinkCallback interface |
| CMFSampleOutputStream | Writes media samples to a byte stream |
| CMFSampleProtection | Provides encryption for media data inside the protected media path (PMP) |
| CMFSaveJob | Persists media data from a source byte stream to an application-provided byte stream |
| CMFSchemeHandler | Creates a media source or a byte stream from a URL |
| CMFSecureBuffer | |
| CMFSecureChannel | Establishes a one-way secure channel between two objects |
| CMFSeekInfo | For a particular seek position, gets the two nearest key frames |
| CMFSensorActivitiesReport | Provides access to IMFSensorActivityReport objects that describe the current activity of a sensor |
| CMFSensorActivitiesReportCallback | Interface implemented by the client to receive callbacks when sensor activity reports are available |
| CMFSensorActivityMonitor | Provides methods for controlling a sensor activity monitor |
| CMFSensorActivityReport | Represents an activity report for a sensor |
| CMFSensorDevice | Represents a sensor device that can belong to a sensor group, which is represented by the MFSensorGroup class. The term "device" in this context could refer to a physical device, a custom media source, or a frame provider |
| CMFSensorGroup | Represents a group of sensor devices from which an MFMediaSource can be created. The term "device" in this context could refer to a physical device, a custom media source, or a frame provider. A sensor group may actually contain multiple sensor devices, or it could contain only a single device, but it still behaves as a sensor group |
| CMFSensorProcessActivity | Represents the activity of a process associated with a sensor |
| CMFSensorProfile | Describes a media foundation sensor profile |
| CMFSensorProfileCollection | Contains a collection of media foundation sensor profile objects |
| CMFSensorStream | Provides methods for cloning and querying the properties of a sensor stream |
| CMFSensorTransformFactory | The interface implemented by sensor transforms to allow the media pipeline to query requirements of the sensor transform and to create a runtime instance of the sensor transform |
| CMFSequencerSource | Implemented by the Sequencer Source. The sequencer source enables an application to create a sequence of topologies |
| CMFShutdown | Exposed by some Media Foundation objects that must be explicitly shut down |
| CMFSignedLibrary | Provides a method that allows content protection systems to get the procedure address of a function in the signed library. This method provides the same functionality as GetProcAddress which is not available to Windows Store apps |
| CMFSimpleAudioVolume | |
| CMFSinkWriter | Microsoft Media Foundation sink writer |
| CMFSinkWriterCallback | Callback interface for the Microsoft Media Foundation sink writer |
| CMFSinkWriterCallback2 | Extends the MFSinkWriterCallback class |
| CMFSinkWriterEncoderConfig | Provides additional functionality on the sink writer for dynamically changing the media type and encoder configuration |
| CMFSinkWriterEx | Extends the MFSinkWriter class |
| CMFSourceOpenMonitor | Callback interface to receive notifications from a network source on the progress of an asynchronous open operation |
| CMFSourceReader | Microsoft Media Foundation source reader object |
| CMFSourceReaderCallback | Callback interface for the Microsoft Media Foundation source reader |
| CMFSourceReaderCallback2 | Extends the MFSourceReaderCallback class |
| CMFSourceReaderEx | Extends the MFSourceReader class |
| CMFSourceResolver | Creates a media source from a URL or a byte stream |
| CMFSSLCertificateManager | Implemented by a client and called by Microsoft Media Foundation to get the client Secure Sockets Layer (SSL) certificate requested by the server |
| CMFStreamDescriptor | Gets information about one stream in a media source |
| CMFStreamingSinkConfig | Passes configuration information to the media sinks that are used for streaming the content. Optionally, this functionality is supported by media sinks. The built-in ASF streaming media sink and the MP3 media sink implement this interface |
| CMFStreamSink | Represents a stream on a media sink object |
| CMFSystemId | Provides a method that retrieves system id data |
| CMFTimecodeTranslate | Converts between Society of Motion Picture and Television Engineers (SMPTE) time codes and 100-nanosecond time units |
| CMFTimer | Provides a timer that invokes a callback at a specified time |
| CMFTopoLoader | Converts a partial topology into a full topology. The topology loader exposes this interface |
| CMFTopology | Represents a topology. A topology describes a collection of media sources, sinks, and transforms that are connected in a certain order. These objects are represented within the topology by topology nodes, which expose the IMFTopologyNode interface. A topology describes the path of multimedia data through these nodes |
| CMFTopologyNode | Represents a node in a topology. The following node types are supported: |
| CMFTopologyNodeAttributeEditor | |
| CMFTopologyServiceLookup | |
| CMFTopologyServiceLookupClient | |
| CMFTrackedSample | Tracks the reference counts on a video media sample. Call MFTrackedSample::Create to create objects of this class |
| CMFTranscodeProfile | |
| CMFTranscodeSinkInfoProvider | Implemented by the transcode sink activation object |
| ►CMFTransform | |
| CStreamCount | |
| CStreamLimits | |
| CMFTrustedInput | Implemented by components that provide input trust authorities (ITAs). This class is used to get the ITA for each of the component's streams |
| CMFTrustedOutput | Implemented by components that provide output trust authorities (OTAs). Any Media Foundation transform (MFT) or media sink that is designed to work within the protected media path (PMP) and also sends protected content outside the Media Foundation pipeline must implement this interface |
| CMFVideoCaptureSampleAllocator | Allocates video samples for a video media sink with specialized functionality for video capture devices |
| CMFVideoDeviceID | |
| CMFVideoDisplayControl | |
| CMFVideoMediaType | Represents a description of a video format |
| CMFVideoMixerControl | |
| CMFVideoMixerControl2 | |
| CMFVideoPositionMapper | |
| CMFVideoPresenter | |
| CMFVideoProcessorControl | Configures the Video Processor MFT |
| CMFVideoProcessorControl2 | Configures the Video Processor MFT |
| CMFVideoProcessorControl3 | |
| CMFVideoRenderer | |
| CMFVideoRendererEffectControl | |
| CMFVideoSampleAllocator | |
| CMFVideoSampleAllocatorCallback | Enables an application to track video samples allocated by the enhanced video renderer (EVR) |
| CMFVideoSampleAllocatorEx | Allocates video samples that contain Microsoft Direct3D 11 texture surfaces |
| CMFVideoSampleAllocatorNotify | The callback for the IMFVideoSampleAllocatorCallback interface |
| CMFVideoSampleAllocatorNotifyEx | The callback for the IMFVideoSampleAllocatorCallback interface |
| CMFWorkQueueServices | Controls the work queues created by the Media Session |
| CMFWorkQueueServicesEx | Extends the MFWorkQueueServices class |
| CMMDevice | |
| CMMDeviceActivator | |
| CMMDeviceCollection | |
| CMMDeviceEnumerator | |
| CMMEndpoint | |
| CMMNotificationClient | |
| CPacketCrossOffsets | |
| CStreamingMediaSink | |
| CStreamingStreamSink | |
| CStreamingStreamSinkData | |
| CTransformOutputDataBuffer | This class is binary compatible with MFT_OUTPUT_DATA_BUFFER |
| CTransforms | |
| CAccessTimeOut | |
| CApplication | |
| CApplicationOptions | |
| CBitmapHandle | |
| CBitmapSelection | |
| CBrushHandle | |
| CBrushSelection | |
| CButton | |
| CButtonBase | |
| CButtonWindowClass | |
| CCheckBox | |
| CCheckedListBox | |
| CColorRef | |
| CComboBox | |
| CComboBoxWindowClass | |
| CCommandButton | |
| CContainerControl | |
| CControl | |
| CControlMessageDispatcher | |
| CControls | |
| CControlWindowClass | |
| CCursorHandle | |
| CDateTimePicker | |
| CDateTimePickerWindowClass | |
| CDeviceContextHandle | |
| CDirect3DDeviceManager9 | |
| CDirectXVideoAccelerationService | |
| CDirectXVideoDecoder | |
| CDirectXVideoDecoderService | |
| CDirectXVideoMemoryConfiguration | |
| CDirectXVideoProcessor | |
| CDirectXVideoProcessorService | |
| CDropDownButton | |
| CDXApplication | |
| ►CDXContext | |
| CFrameContext | |
| CDXForm | |
| CDXMessageLoop | A message loop implementation that uses idle time to perform rendering |
| CDXPipelineState | |
| CDXRootParameter | |
| CDXRootSignature | |
| CEditBase | |
| CFileDialog | |
| CFileDialogEvents | |
| CFileDialogEventsImplementation | |
| CFileOpenDialog | |
| CFileSaveDialog | |
| CFilterKeys | |
| CFontHandle | |
| CFontSelection | |
| CForm | |
| CFormWindowClass | |
| CGroupBox | |
| CGroupBoxWindowClass | |
| CHeaderControl | |
| CHeaderControlItem | |
| CHeaderControlItems | |
| CHeaderControlWindowClass | |
| CHighContrast | |
| CHotKey | |
| CHotKeyWindowClass | |
| CHScrollBar | |
| CIconHandle | |
| CIContainerControl | |
| CImageList | |
| CLabel | |
| CLabelWindowClass | |
| CLinkLabel | |
| CLinkLabelWindowClass | |
| CListBox | |
| CListBoxWindowClass | |
| CListControl | |
| CListView | |
| CListViewWindowClass | |
| CMemoEdit | |
| CMemoryDeviceContextHandle | |
| CMenu | |
| CMenuBar | |
| CMenuHandle | |
| CMenuItem | |
| CMenuItems | |
| CMessage | |
| CMessageDispatcherBase | |
| CMessageLoop | |
| CModalWindow | |
| CMonthCalendar | |
| CMonthCalendarWindowClass | |
| CMouseKeys | |
| CNonClientMetrics | |
| CPaintDeviceContextHandle | |
| CPaletteHandle | |
| CPenHandle | |
| CPenSelection | |
| CPointT | Provides a unified api for point types |
| CPopupMenu | |
| CPushButtonBase | |
| CRadioButton | |
| CRange | |
| CRectangleT | Provides a unified api for rectangle types |
| CRegionHandle | |
| CScrollableControl | |
| CScrollBar | |
| CScrollBarWindowClass | |
| CSeparatorMenuItem | |
| CSizeT | Provides a unified api for size types |
| CSkiaContext | |
| CSkiaControl | |
| CSkiaDisplayParams | |
| CStateButton | |
| CSubMenuItem | |
| CSuperClassMessageDispatcher | |
| CTextEdit | |
| CTextEditBase | |
| CTextEditWindowClass | |
| CTextMenuItem | |
| ►CTimer | |
| CTimerControl | |
| CTreeEditBase | |
| CTreeView | |
| CTreeViewItem | |
| CTreeViewWindowClass | |
| CVScrollBar | |
| CWindowClass | |
| CWindowClasses | |
| CWindowDeviceContextHandle | |
| ▼Nstd | STL namespace |
| Cformatter< Harlinn::Common::Core::BasicString< CharT >, CharT > | |
| Cformatter< Harlinn::Common::Core::BasicStringView< CharT >, CharT > | |
| Cformatter< Harlinn::Common::Core::DateTime, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::AttachDatabaseFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::BackupFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::ColumnFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::ColumnInfoLevel, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::ColumnType, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::CreateDatabaseFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::DetachDatabaseFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::ExceptionAction, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::IndexFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::IndexRangeFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::InitFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::KeyFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::ObjectFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::OnlineDefragFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::OpenDatabaseFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::OpenTableFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::PrepareUpdateOptions, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::RetrieveFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::SeekFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::SequentialFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::SetCurrentIndexFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::SetFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::TableOptions, CharT > | |
| Cformatter< Harlinn::Common::Core::Ese::TransactionFlags, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::DeviceEventType, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::HardwareProfileChangeEventType, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::PowerEventType, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceAccessRights, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceControl, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceControlAccepted, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceControlManagerAccessRights, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceEnumerationState, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceStartType, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceState, CharT > | |
| Cformatter< Harlinn::Common::Core::Services::ServiceType, CharT > | |
| Cformatter< Harlinn::Common::Core::SysString, CharT > | |
| Cformatter< Harlinn::Common::Core::TimeSpan, CharT > | |
| Chash< Harlinn::Common::Core::AnsiString > | |
| Chash< Harlinn::Common::Core::AnsiStringView > | |
| Chash< Harlinn::Common::Core::DateTime > | |
| Chash< Harlinn::Common::Core::Guid > | This specialization of std::hash for Harlinn::Common::Core::Guid assumes that the distribution of values for the 8 last bytes of the Guid is random enough to be used as a hash value |
| Chash< Harlinn::Common::Core::LMDB::Database > | |
| Chash< Harlinn::Common::Core::Logging::Internal::ThreadKeyData > | |
| Chash< Harlinn::Common::Core::SysString > | |
| Chash< Harlinn::Common::Core::TimeSpan > | |
| Chash< Harlinn::Common::Core::WideString > | |
| Chash< Harlinn::Common::Core::WideStringView > | |
| Cpointer_traits< Harlinn::Common::Core::Internal::ConstPointerIterator< ContainerT > > | |
| Cpointer_traits< Harlinn::Common::Core::Internal::PointerIterator< ContainerT > > | |
| ▼Nxxhash | Xxhash namespace |
| Chash | XxHash |
| Chash< 32 > | XxHash32 |
| Chash< 64 > | XxHash64 |
| C_caldatetime | |
| CIEEEl2bits | |
| CXXH128_canonical_t | |
| CXXH128_hash_t | The return value from 128-bit hashes |
| CXXH32_canonical_t | Canonical (big endian) representation of XXH32_hash_t |
| CXXH64_canonical_t | |
| CXXH_dispatch128Functions_s | |
| CXXH_dispatchFunctions_s | |
1.12.0