| Server IP : 209.209.40.120 / Your IP : 216.73.217.112 Web Server : Microsoft-IIS/10.0 System : Windows NT NEWWWW 10.0 build 17763 (Windows Server 2019) i586 User : NEWWWW$ ( 0) PHP Version : 8.3.30 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : OFF | Perl : OFF | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : C:/Program Files (x86)/Windows Kits/10/Include/10.0.19041.0/winrt/ |
Upload File : |
/*******************************************************************************
** **
** windows.foundation.collections.h - Common collection-related types. **
** **
** Copyright (c) Microsoft Corporation. All rights reserved. **
** **
** Contains definitions of C++ class templates used by **
** MIDL for generating parameter interface instances. **
** **
** Known Limitations **
** Midl does not import other IDL files that the IObservable* **
** interfaces depend on. If you instantiate either IObservableMap or **
** IObservableVector in your IDL file, you will need to explicitly **
** import "eventtoken.idl" at the top of your IDL file. **
** **
** Notes on design: **
** The bodies of each of these interface templates are each **
** defined once, with the postfix "_impl", defining each of **
** the members. MIDL will then hook up the "_impl" with **
** the method definitions to the real template, and assign it **
** a guid. **
** **
** For instance, it might generate: **
** **
** template <> **
** struct **
** __declspec(uuid("77e5b300-6a88-4f63-b490-e25b414bed4e")) **
** IVectorView<int> : IVectorView_impl<int> **
** { **
** }; **
** **
** In this fashion, IVectorView<int> is assigned an IID. **
** As well, for each parameterized type, the original template is **
** not just forward declared, but defined and derives from the "_impl" **
** form. This is done as it was found to generate usable autocomplete **
** in IDEs. **
** The original unspecialized template also is made to static_assert **
** if the user attempts to use it. This is to avoid ODR violations, **
** and the scenario that the user forgot to mention a 'declare' **
** clause in the MIDL input. **
*******************************************************************************/
#ifndef WINDOWS_FOUNDATION_COLLECTIONS_H
#define WINDOWS_FOUNDATION_COLLECTIONS_H
#ifdef _MSC_VER
#pragma once
#endif /* _MSC_VER */
#include <inspectable.h>
#include <rpcndr.h> // used for boolean
#include <eventtoken.h> // used for EventRegistrationToken
#include <winstring.h> // needed for WindowsDeleteString
/* Use of templates and namespaces */
#ifdef __cplusplus
#include <asyncinfo.h>
// metafunctions for handling Interface Groups and Runtime Types in parameterized interfaces
namespace ABI {
namespace Windows { namespace Foundation { namespace Internal
{
// LogicalType - the Windows Runtime type (eg, runtime class, inteface group, etc)
// being provided as an argument to an _impl template, when that type
// cannot be represented at the ABI.
// AbiType - the type used for marshalling, ie "at the ABI", for the logical type.
template <class LogicalType, class AbiType>
struct AggregateType
{
};
// Gets the ABI type. See AggregateType for description.
template <class T>
struct GetAbiType
{
typedef T type;
};
template <class L, class A>
struct GetAbiType<AggregateType<L, A> >
{
typedef A type;
};
// Gets the LogicalType. See AggregateType for description.
template <class T>
struct GetLogicalType
{
typedef T type;
};
template <class L, class A>
struct GetLogicalType<AggregateType<L, A> >
{
typedef L type;
};
}}} // namespace Windows::Foundation::Internal
} // ABI
namespace ABI {
namespace Windows { namespace Foundation
{
//forward delcare the known structs
struct DateTime;
struct TimeSpan;
struct Point;
struct Size;
struct Rect;
} }
} // ABI
namespace ABI {
namespace Windows { namespace Foundation { namespace Collections
{
template <class T>
struct is_pointer { enum { value = false };};
template <class T>
struct is_pointer<T*> { enum { value = true};};
template <class T>
struct is_foundation_struct { enum {value = false};};
template <>
struct is_foundation_struct<GUID> { enum { value = true};};
template <>
struct is_foundation_struct<Windows::Foundation::DateTime> { enum { value = true};};
template <>
struct is_foundation_struct<Windows::Foundation::TimeSpan> { enum { value = true};};
template <>
struct is_foundation_struct<Windows::Foundation::Point> { enum { value = true};};
template <>
struct is_foundation_struct<Windows::Foundation::Size> { enum { value = true};};
template <>
struct is_foundation_struct<Windows::Foundation::Rect> { enum { value = true};};
template <class T>
struct supports_cleanup {
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type _abi_type;
enum { value = is_pointer< _abi_type >::value || is_foundation_struct< _abi_type >::value || !__is_class(_abi_type) };
};
template <class T, bool isStruct = supports_cleanup<T>::value>
struct IIterator_impl;
template <class T>
struct IIterable_impl;
template <class T, bool isStruct = supports_cleanup<T>::value>
struct IVectorView_impl;
template <class T, bool isStruct = supports_cleanup<T>::value>
struct IVector_impl;
template <class K, class V>
struct IKeyValuePair_impl;
template <class K, class V>
struct IMapView_impl;
template <class K, class V>
struct IMap_impl;
enum CollectionsChange : int;
struct IVectorChangedEventArgs;
template <class T>
/*delegate*/ struct VectorChangedEventHandler_impl;
template <class T>
struct IObservableVector_impl;
template <class K>
struct IMapChangedEventArgs_impl;
template <class K, class V>
struct /*delegate*/ MapChangedEventHandler_impl;
template <class K, class V>
struct IObservableMap_impl;
namespace detail
{
template <class T>
struct not_yet_specialized_placeholder
{
enum { value = false };
};
template <class WasNotSpecialized>
struct not_yet_specialized
{
static_assert(
not_yet_specialized_placeholder<WasNotSpecialized>::value,
"This interface instance has not been specialized by MIDL."
" This may be caused by forgetting a '*' pointer on an interface"
" type, by omitting a necessary 'declare' clause in your idl"
" file, by forgetting to include one of the necessary MIDL"
" generated headers.");
};
}
template <class T>
struct IIterator
: IIterator_impl<T>
, detail::not_yet_specialized<IIterator<T>>
{
};
template <class T>
struct IIterable
: IIterable_impl<T>
, detail::not_yet_specialized<IIterable<T>>
{
};
template <class T>
struct IVectorView
: IVectorView_impl<T>
, detail::not_yet_specialized<IVectorView<T>>
{
};
template <class T>
struct IVector
: IVector_impl<T>
, detail::not_yet_specialized<IVector<T>>
{
};
template <class K, class V>
struct IKeyValuePair
: IKeyValuePair_impl<K, V>
, detail::not_yet_specialized<IKeyValuePair<K, V>>
{
};
template <class K, class V>
struct IMapView
: IMapView_impl<K, V>
, detail::not_yet_specialized<IMapView<K, V>>
{
};
template <class K, class V>
struct IMap
: IMap_impl<K, V>
, detail::not_yet_specialized<IMap<K, V>>
{
};
template <class T>
/*delegate*/ struct VectorChangedEventHandler
: VectorChangedEventHandler_impl<T>
, detail::not_yet_specialized<VectorChangedEventHandler<T>>
{
};
template <class T>
struct IObservableVector
: IObservableVector_impl<T>
, detail::not_yet_specialized<IObservableVector<T>>
{
};
template <class K>
struct IMapChangedEventArgs
: IMapChangedEventArgs_impl<K>
, detail::not_yet_specialized<IMapChangedEventArgs<K>>
{
};
template <class K, class V>
/*delegate*/ struct MapChangedEventHandler
: MapChangedEventHandler_impl<K, V>
, detail::not_yet_specialized<MapChangedEventHandler<K, V>>
{
};
template <class K, class V>
struct IObservableMap
: IObservableMap_impl<K, V>
, detail::not_yet_specialized<IObservableMap<K, V>>
{
};
// Template definitions duplicate the members that MIDL generates, without the name redirection.
template <class T>
struct IIterable_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef T T_complex;
virtual HRESULT STDMETHODCALLTYPE First(_Outptr_result_maybenull_ IIterator<T_logical> **first) = 0;
};
namespace Detail
{
// known struct types get no-op cleanup
#define XWINRT_DEF_CLEANUP(type) \
inline void _Cleanup(type * /* values[] */, unsigned /* actual */) {}
XWINRT_DEF_CLEANUP(GUID);
XWINRT_DEF_CLEANUP(Windows::Foundation::DateTime);
XWINRT_DEF_CLEANUP(Windows::Foundation::TimeSpan);
XWINRT_DEF_CLEANUP(Windows::Foundation::Point);
XWINRT_DEF_CLEANUP(Windows::Foundation::Size);
XWINRT_DEF_CLEANUP(Windows::Foundation::Rect);
#undef XWINRT_DEF_CLEANUP
// Template magic for number and enums
template <bool condition, class T = void*>
struct enable_if { };
template <class T>
struct enable_if<true, T> { typedef T type;};
// numbers, enums get no-op cleanup.
template <class T>
void _Cleanup(T* /*values*/, unsigned /*actual*/, typename enable_if<!__is_class(T) && !(is_pointer<T>::value)>::type = 0) {}
template <class I, class Number>
void _Cleanup(_Inout_updates_(actual) I* values[], Number actual)
{
for (unsigned i = 0; i < actual; ++i)
{
values[i]->Release();
values[i] = nullptr;
}
}
// make this a template so that we don't deptend on WindowsDeleteString in this file
template <class Number>
inline void _Cleanup(_Inout_updates_(actual) HSTRING* values, Number actual)
{
for (unsigned i = 0; i < actual; ++i)
{
::WindowsDeleteString(values[i]);
values[i] = nullptr;
}
}
// Note: Because structs require custom cleanup, the default implementation will not be
// available to custom collections of structs. They will need to provide their own
// implementations.
template <class U, class T>
HRESULT _VectorGetMany(
_In_ U* pThis,
_In_ unsigned startIndex,
_In_ unsigned capacity,
_Out_writes_to_(capacity,*actual) T *value,
_Out_ unsigned *actual)
{
unsigned index = 0;
HRESULT hr = S_OK;
unsigned size = 0;
unsigned copied = 0;
ZeroMemory(value, sizeof(*value) * capacity);
*actual = 0;
// Get the size of the vector so that we can do bounds checking
hr = pThis->get_Size(&size);
if (SUCCEEDED(hr))
{
if (startIndex > size)
{
// If we are more than one past the end, then we return E_BOUNDS;
hr = E_BOUNDS;
}
else
{
// we are guarenteed to be one past the end or less. If we are one past the end
// we won't enter the for loop, and we'll get S_OK but nothing returned.
// If we are at the end or earlier, we'll actually get something in the output
for (index = 0; (index < capacity) && (index + startIndex < size) ; index++)
{
hr = pThis->GetAt(index + startIndex, &value[index] );
if (SUCCEEDED(hr))
{
copied += 1;
}
else
{
break;
}
}
}
}
if (SUCCEEDED(hr))
{
*actual = index;
}
if (FAILED(hr))
{
Detail::_Cleanup(value, copied);
}
return hr;
}
template <class U, class T>
HRESULT _IteratorGetMany(_In_ U* pThis, _In_ unsigned capacity, _Out_writes_to_(capacity,*actual) T *value, _Out_ unsigned *actual)
{
HRESULT hr = S_OK;
::boolean fHasCurrent = false;
unsigned count = 0;
ZeroMemory(value, sizeof(*value) * capacity);
*actual = 0;
hr = pThis->get_HasCurrent(&fHasCurrent);
while (SUCCEEDED(hr) && (fHasCurrent) && (count < capacity))
{
hr = pThis->get_Current(&value[count]);
if (SUCCEEDED(hr))
{
count++;
hr = pThis->MoveNext(&fHasCurrent);
}
}
if (SUCCEEDED(hr))
{
*actual = count;
}
else
{
// cleanup output paremeters on failure
// no need to zero out *actual as it is still
// initialized to zero.
Detail::_Cleanup(value, *actual);
}
return hr;
}
template<class U, class T>
HRESULT _VectorReplaceAll(_In_ U* pThis, _In_ unsigned count, _In_reads_(count) T *value)
{
HRESULT hr = S_OK;
hr = pThis->Clear();
if (SUCCEEDED(hr))
{
for(unsigned index = 0; index < count; index++)
{
hr = pThis->Append(value[index]);
if (FAILED(hr))
{
// intentionally ignoring the return value here so that hr
// can be passed through;
pThis->Clear();
break;
}
}
}
return hr;
}
}
// Note: There are two versions of this template. The second will compile where T is a struct and the
// first will compile in all other cases. This approach is used to ensure that if T is a struct that
// GetMany will be pure virtual (and must be overloaded), but in the other cases GetMany will
// be handed by the default implementation.
// Important Note!: Both of these templates must have the same vtable!!! Change one and you
// must change the other
template <class T, bool isStruct>
struct IIterator_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_Current(_Out_ T_abi *current) = 0;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_HasCurrent(_Out_ boolean *hasCurrent) = 0;
virtual HRESULT STDMETHODCALLTYPE MoveNext(_Out_ boolean *hasCurrent) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMany(_In_ unsigned capacity, _Out_writes_to_(capacity,*actual) T_abi *value, _Out_ unsigned *actual)
{
return Detail::_IteratorGetMany(this, capacity, value, actual);
}
};
template <class T>
struct IIterator_impl<T, false> : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_Current(_Out_ T_abi *current) = 0;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_HasCurrent(_Out_ boolean *hasCurrent) = 0;
virtual HRESULT STDMETHODCALLTYPE MoveNext(_Out_ boolean *hasCurrent) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMany(_In_ unsigned capacity, _Out_writes_to_(capacity,*actual) T_abi *value, _Out_ unsigned *actual) = 0;
};
// Note: There are two versions of this template. The second will compile where T is a struct and the
// first will compile in all other cases. This approach is used to ensure that if T is a struct that
// GetMany will be pure virtual (and must be overloaded), but in the other cases GetMany will
// be handed by the default implementation.
// Important Note!: Both of these templates must have the same vtable!!! Change one and you
// must change the other
template <class T, bool isStruct>
struct IVectorView_impl : IInspectable /* requires IIterable<T> */
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
virtual HRESULT STDMETHODCALLTYPE GetAt(_In_ unsigned index, _Out_ T_abi *item) = 0;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_Size(_Out_ unsigned *size) = 0;
virtual HRESULT STDMETHODCALLTYPE IndexOf(_In_opt_ T_abi value, _Out_ unsigned *index, _Out_ boolean *found) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMany(_In_ unsigned startIndex, _In_ unsigned capacity, _Out_writes_to_(capacity,*actual) T_abi *value, _Out_ unsigned *actual)
{
return Detail::_VectorGetMany(this, startIndex, capacity, value, actual);
}
};
template <class T>
struct IVectorView_impl<T, false> : IInspectable /* requires IIterable<T> */
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
virtual HRESULT STDMETHODCALLTYPE GetAt(_In_ unsigned index, _Out_ T_abi *item) = 0;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_Size(_Out_ unsigned *size) = 0;
virtual HRESULT STDMETHODCALLTYPE IndexOf(_In_opt_ T_abi value, _Out_ unsigned *index, _Out_ boolean *found) = 0;
virtual HRESULT STDMETHODCALLTYPE GetMany(_In_ unsigned startIndex, _In_ unsigned capacity, _Out_writes_to_(capacity,*actual) T_abi *value, _Out_ unsigned *actual) = 0;
};
// Note: There are two versions of this template. The second will compile where T is a struct and the
// first will compile in all other cases. This approach is used to ensure that if T is a struct that
// GetMany and ReplaceAllwill be pure virtual (and must be overloaded), but in the other cases GetMany will
// be handed by the default implementation.
// Important Note!: Both of these templates must have the same vtable!!! Change one and you
// must change the other
template <class T, bool isStruct>
struct IVector_impl : IInspectable /* requires IIterable<T> */
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
// read methods
virtual HRESULT STDMETHODCALLTYPE GetAt(_In_opt_ unsigned index, _Out_ T_abi *item) = 0;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_Size(_Out_ unsigned *size) = 0;
virtual HRESULT STDMETHODCALLTYPE GetView(_Outptr_result_maybenull_ IVectorView<T_logical> **view) = 0;
virtual HRESULT STDMETHODCALLTYPE IndexOf(_In_opt_ T_abi value, _Out_ unsigned *index, _Out_ boolean *found) = 0;
// write methods
virtual HRESULT STDMETHODCALLTYPE SetAt(_In_ unsigned index, _In_opt_ T_abi item) = 0;
virtual HRESULT STDMETHODCALLTYPE InsertAt(_In_ unsigned index, _In_opt_ T_abi item) = 0;
virtual HRESULT STDMETHODCALLTYPE RemoveAt(_In_ unsigned index) = 0;
virtual HRESULT STDMETHODCALLTYPE Append(_In_opt_ T_abi item) = 0;
virtual HRESULT STDMETHODCALLTYPE RemoveAtEnd() = 0;
virtual HRESULT STDMETHODCALLTYPE Clear() = 0;
// bulk transfer methods
virtual HRESULT STDMETHODCALLTYPE GetMany(_In_ unsigned startIndex, _In_ unsigned capacity, _Out_writes_to_(capacity,*actual) T_abi *value, _Out_ unsigned *actual)
{
return Detail::_VectorGetMany(this, startIndex, capacity, value, actual);
}
virtual HRESULT STDMETHODCALLTYPE ReplaceAll(_In_ unsigned count, _In_reads_(count) T_abi *value)
{
return Detail::_VectorReplaceAll(this, count, value);
}
};
template <class T>
struct IVector_impl<T, false> : IInspectable /* requires IIterable<T> */
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
// read methods
virtual HRESULT STDMETHODCALLTYPE GetAt(_In_opt_ unsigned index, _Out_ T_abi *item) = 0;
virtual /* propget */ HRESULT STDMETHODCALLTYPE get_Size(_Out_ unsigned *size) = 0;
virtual HRESULT STDMETHODCALLTYPE GetView(_Outptr_result_maybenull_ IVectorView<T_logical> **view) = 0;
virtual HRESULT STDMETHODCALLTYPE IndexOf(_In_opt_ T_abi value, _Out_ unsigned *index, _Out_ boolean *found) = 0;
// write methods
virtual HRESULT STDMETHODCALLTYPE SetAt(_In_ unsigned index, _In_opt_ T_abi item) = 0;
virtual HRESULT STDMETHODCALLTYPE InsertAt(_In_ unsigned index, _In_opt_ T_abi item) = 0;
virtual HRESULT STDMETHODCALLTYPE RemoveAt(_In_ unsigned index) = 0;
virtual HRESULT STDMETHODCALLTYPE Append(_In_opt_ T_abi item) = 0;
virtual HRESULT STDMETHODCALLTYPE RemoveAtEnd() = 0;
virtual HRESULT STDMETHODCALLTYPE Clear() = 0;
// bulk transfer methods
virtual HRESULT STDMETHODCALLTYPE GetMany(_In_ unsigned startIndex, _In_ unsigned capacity, _Out_writes_to_(capacity,*actual) T_abi *value, _Out_ unsigned *actual) = 0;
virtual HRESULT STDMETHODCALLTYPE ReplaceAll(_In_ unsigned count, _In_reads_(count) T_abi *value) = 0;
};
template <class K, class V>
struct IKeyValuePair_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<K>::type K_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<K>::type K_logical;
typedef typename Windows::Foundation::Internal::GetAbiType<V>::type V_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<V>::type V_logical;
public:
typedef K K_complex;
typedef V V_complex;
virtual HRESULT STDMETHODCALLTYPE get_Key(_Out_ K_abi *key) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Value(_Out_ V_abi *value) = 0;
};
template <class K, class V>
struct IMapView_impl : IInspectable /* requires IIterable< IKeyValuePair<GetLogicalType<TKey>::type,GetLogicalType<TValue>::type> *> */
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<K>::type K_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<K>::type K_logical;
typedef typename Windows::Foundation::Internal::GetAbiType<V>::type V_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<V>::type V_logical;
public:
typedef K K_complex;
typedef V V_complex;
virtual HRESULT STDMETHODCALLTYPE Lookup(_In_opt_ K_abi key, _Out_ V_abi *value) = 0;
virtual/*propget*/ HRESULT STDMETHODCALLTYPE get_Size(_Out_ unsigned int *size) = 0;
virtual HRESULT STDMETHODCALLTYPE HasKey(_In_opt_ K_abi key, _Out_ boolean *found) = 0;
virtual HRESULT STDMETHODCALLTYPE Split(_Outptr_result_maybenull_ IMapView<K_logical,V_logical> **firstPartition, _Outptr_result_maybenull_ IMapView<K_logical,V_logical> **secondPartition) = 0;
};
template <class K, class V>
struct IMap_impl : IInspectable /* requires IIterable< IKeyValuePair<K_logical,V_logical> *> */
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<K>::type K_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<K>::type K_logical;
typedef typename Windows::Foundation::Internal::GetAbiType<V>::type V_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<V>::type V_logical;
public:
typedef K K_complex;
typedef V V_complex;
// read methods
virtual HRESULT STDMETHODCALLTYPE Lookup(_In_opt_ K_abi key, _Out_ V_abi *value) = 0;
virtual /*propget*/ HRESULT STDMETHODCALLTYPE get_Size(_Out_ unsigned int *size) = 0;
virtual HRESULT STDMETHODCALLTYPE HasKey(_In_opt_ K_abi key, _Out_ boolean *found) = 0;
virtual HRESULT STDMETHODCALLTYPE GetView(_Outptr_result_maybenull_ IMapView<K_logical,V_logical> **view) = 0;
// write methods
virtual HRESULT STDMETHODCALLTYPE Insert(_In_opt_ K_abi key, _In_opt_ V_abi value, _Out_ boolean *replaced) = 0;
virtual HRESULT STDMETHODCALLTYPE Remove(_In_opt_ K_abi key) = 0;
virtual HRESULT STDMETHODCALLTYPE Clear() = 0;
};
}}} // namespace Windows::Foundation::Collections
namespace Windows { namespace Foundation
{
template <class TResult, class TProgress>
struct IAsyncOperationProgressHandler_impl;
template <class TResult, class TProgress>
struct IAsyncOperationWithProgressCompletedHandler_impl;
template <class TResult>
struct IAsyncOperationCompletedHandler_impl;
template <class TResult, class TProgress>
struct IAsyncOperationWithProgress_impl;
template <class TProgress>
struct IAsyncActionWithProgress_impl;
template <class TProgress>
struct IAsyncOperation_impl;
template <class TProgress>
struct IAsyncActionProgressHandler_impl;
template <class TProgress>
struct IAsyncActionWithProgressCompletedHandler_impl;
template <class T>
struct IReference_impl;
template <class T>
struct IReferenceArray_impl;
template <class T>
struct IEventHandler_impl;
template <class TSender, class TArgs>
struct ITypedEventHandler_impl;
template <class TResult, class TProgress>
struct IAsyncOperationProgressHandler
: IAsyncOperationProgressHandler_impl<TResult, TProgress>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncOperationProgressHandler<TResult, TProgress>>
{
};
template <class TResult>
struct IAsyncOperationCompletedHandler
: IAsyncOperationCompletedHandler_impl<TResult>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncOperationCompletedHandler<TResult>>
{
};
template <class TResult, class TProgress>
struct IAsyncOperationWithProgressCompletedHandler
: IAsyncOperationWithProgressCompletedHandler_impl<TResult, TProgress>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncOperationWithProgressCompletedHandler<TResult, TProgress>>
{
};
template <class TProgress>
struct IAsyncActionProgressHandler
: IAsyncActionProgressHandler_impl<TProgress>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncActionProgressHandler<TProgress>>
{
};
template <class TProgress>
struct IAsyncActionWithProgressCompletedHandler
: IAsyncActionWithProgressCompletedHandler_impl<TProgress>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncActionWithProgressCompletedHandler<TProgress>>
{
};
template <class TResult>
struct IAsyncOperation
: IAsyncOperation_impl<TResult>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncOperation<TResult>>
{
};
template <class TResult, class TProgress>
struct IAsyncOperationWithProgress
: IAsyncOperationWithProgress_impl<TResult, TProgress>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncOperationWithProgress<TResult, TProgress>>
{
};
template <class TProgress>
struct IAsyncActionWithProgress
: IAsyncActionWithProgress_impl<TProgress>
, Windows::Foundation::Collections::detail::not_yet_specialized<IAsyncActionWithProgress<TProgress>>
{
};
template <class T>
struct IReference
: IReference_impl<T>
, Windows::Foundation::Collections::detail::not_yet_specialized<IReference<T>>
{
};
template <class T>
struct IReferenceArray
: IReferenceArray_impl<T>
, Windows::Foundation::Collections::detail::not_yet_specialized<IReferenceArray<T>>
{
};
template <class T>
struct IEventHandler
: IEventHandler_impl<T>
, Windows::Foundation::Collections::detail::not_yet_specialized<IEventHandler<T>>
{
};
template <class TSender, class TArgs>
struct ITypedEventHandler
: ITypedEventHandler_impl<TSender, TArgs>
, Windows::Foundation::Collections::detail::not_yet_specialized<ITypedEventHandler<TSender, TArgs>>
{
};
template <class TResult, class TProgress>
struct IAsyncOperationProgressHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TProgress>::type TProgress_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TProgress>::type TProgress_logical;
typedef typename Windows::Foundation::Internal::GetAbiType<TResult>::type TResult_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TResult>::type TResult_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TProgress TProgress_complex;
typedef TResult TResult_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke(IAsyncOperationWithProgress<TResult_logical, TProgress_logical> *asyncInfo, TProgress_abi progressInfo) = 0;
};
template <class TResult, class TProgress>
struct IAsyncOperationWithProgressCompletedHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TProgress>::type TProgress_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TProgress>::type TProgress_logical;
typedef typename Windows::Foundation::Internal::GetAbiType<TResult>::type TResult_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TResult>::type TResult_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TProgress TProgress_complex;
typedef TResult TResult_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke(IAsyncOperationWithProgress<TResult_logical, TProgress_logical> *asyncInfo, Windows::Foundation::AsyncStatus status) = 0;
};
template <class TResult>
struct IAsyncOperationCompletedHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TResult>::type TResult_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TResult>::type TResult_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TResult TResult_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke(IAsyncOperation<TResult_logical> *asyncInfo, Windows::Foundation::AsyncStatus status) = 0;
};
template <class TProgress>
struct IAsyncActionProgressHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TProgress>::type TProgress_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TProgress>::type TProgress_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TProgress TProgress_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke(IAsyncActionWithProgress<TProgress_logical> *asyncInfo, TProgress_abi progressInfo) = 0;
};
template <class TProgress>
struct IAsyncActionWithProgressCompletedHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TProgress>::type TProgress_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TProgress>::type TProgress_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TProgress TProgress_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke(IAsyncActionWithProgress<TProgress_logical> *asyncInfo, Windows::Foundation::AsyncStatus status) = 0;
};
template <class TResult, class TProgress>
struct IAsyncOperationWithProgress_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TProgress>::type TProgress_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TProgress>::type TProgress_logical;
typedef typename Windows::Foundation::Internal::GetAbiType<TResult>::type TResult_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TResult>::type TResult_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TProgress TProgress_complex;
typedef TResult TResult_complex;
virtual HRESULT STDMETHODCALLTYPE put_Progress( IAsyncOperationProgressHandler<TResult_logical, TProgress_logical> *handler) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Progress( IAsyncOperationProgressHandler<TResult_logical, TProgress_logical> **handler) = 0;
virtual HRESULT STDMETHODCALLTYPE put_Completed( IAsyncOperationWithProgressCompletedHandler<TResult_logical, TProgress_logical> *handler) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Completed( IAsyncOperationWithProgressCompletedHandler<TResult_logical, TProgress_logical> **handler) = 0;
virtual HRESULT STDMETHODCALLTYPE GetResults( TResult_abi *results) = 0;
};
template <class TResult>
struct IAsyncOperation_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TResult>::type TResult_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TResult>::type TResult_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TResult TResult_complex;
virtual HRESULT STDMETHODCALLTYPE put_Completed( IAsyncOperationCompletedHandler<TResult_logical> *handler) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Completed( IAsyncOperationCompletedHandler<TResult_logical> **handler) = 0;
virtual HRESULT STDMETHODCALLTYPE GetResults( TResult_abi *results) = 0;
};
template <class TProgress>
struct IAsyncActionWithProgress_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TProgress>::type TProgress_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TProgress>::type TProgress_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TProgress TProgress_complex;
virtual HRESULT STDMETHODCALLTYPE put_Progress( IAsyncActionProgressHandler<TProgress_logical> *handler) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Progress( IAsyncActionProgressHandler<TProgress_logical> **handler) = 0;
virtual HRESULT STDMETHODCALLTYPE put_Completed( IAsyncActionWithProgressCompletedHandler<TProgress_logical> *handler) = 0;
virtual HRESULT STDMETHODCALLTYPE get_Completed( IAsyncActionWithProgressCompletedHandler<TProgress_logical> **handler) = 0;
virtual HRESULT STDMETHODCALLTYPE GetResults( ) = 0;
};
template <class T>
struct IReference_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef T T_complex;
virtual HRESULT STDMETHODCALLTYPE get_Value( _Out_ T_abi *value) = 0;
};
template <class T>
struct IReferenceArray_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef T T_complex;
virtual HRESULT STDMETHODCALLTYPE get_Value(_Out_ UINT32 *length, _Outptr_result_buffer_(*length) T_abi **value) = 0;
};
template <class T>
struct IEventHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<T>::type T_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef T T_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke( _In_ IInspectable *sender, _In_ T_abi args) = 0;
};
template <class TSender, class TArgs>
struct ITypedEventHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<TSender>::type TSender_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TSender>::type TSender_logical;
typedef typename Windows::Foundation::Internal::GetAbiType<TArgs>::type TArgs_abi;
typedef typename Windows::Foundation::Internal::GetLogicalType<TArgs>::type TArgs_logical;
public:
// For all types which are neither InterfaceGroups nor RuntimeClasses, the
// following three typedefs are synonyms for a single C++ type. But for
// InterfaceGroups and RuntimeClasses, they are different types:
// T_logical: The C++ Type for the InterfaceGroup or RuntimeClass, when
// used as a template parameter. Eg "RCFoo*"
// T_abi: The C++ type for the default interface used to represent the
// InterfaceGroup or RuntimeClass when passed as a method parameter.
// Eg "IFoo*"
// T_complex: An instantiation of the Internal "AggregateType" template that
// combines T_logical with T_abi. Eg "AggregateType<RCFoo*,IFoo*>"
// See the declaration above of Windows::Foundation::Internal::AggregateType
// for more details.
typedef TSender TSender_complex;
typedef TArgs TArgs_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke( _In_ TSender_abi sender, _In_ TArgs_abi args) = 0;
};
}} // namespace Windows::Foundation
} // namespace ABI
#endif /*ifdef __cplusplus*/
// Definitions of the CollectionChange enum and IVectorChangedEventArgs
// interface.
#include <IVectorChangedEventArgs.h>
#ifdef __cplusplus
namespace ABI {
namespace Windows { namespace Foundation { namespace Collections {
template <class T>
/*delegate*/ struct VectorChangedEventHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke(_In_opt_ IObservableVector<T_logical>* sender, _In_opt_ IVectorChangedEventArgs* e) = 0;
};
template <class T>
struct IObservableVector_impl : IInspectable /* requires IVector<T> */
{
private:
typedef typename Windows::Foundation::Internal::GetLogicalType<T>::type T_logical;
public:
typedef T T_complex;
virtual /*eventadd*/ HRESULT STDMETHODCALLTYPE add_VectorChanged (_In_opt_ VectorChangedEventHandler<T_logical>* handler, _Out_ EventRegistrationToken* token) = 0;
virtual /*eventremove*/ HRESULT STDMETHODCALLTYPE remove_VectorChanged(_In_ EventRegistrationToken token) = 0;
};
template <class K>
struct IMapChangedEventArgs_impl : IInspectable
{
private:
typedef typename Windows::Foundation::Internal::GetAbiType<K>::type K_abi;
public:
typedef K K_complex;
virtual /*propget*/ HRESULT STDMETHODCALLTYPE get_CollectionChange (_Out_ CollectionChange* value) = 0;
virtual /*propget*/ HRESULT STDMETHODCALLTYPE get_Key (_Out_ K_abi* value) = 0;
};
template <class K, class V>
/*delegate*/ struct MapChangedEventHandler_impl : IUnknown
{
private:
typedef typename Windows::Foundation::Internal::GetLogicalType<K>::type K_logical;
typedef typename Windows::Foundation::Internal::GetLogicalType<V>::type V_logical;
public:
typedef K K_complex;
typedef V V_complex;
virtual HRESULT STDMETHODCALLTYPE Invoke(_In_opt_ IObservableMap<K_logical, V_logical>* sender, _In_opt_ IMapChangedEventArgs<K_logical>* e) = 0;
};
template <class K, class V>
struct IObservableMap_impl : IInspectable /* requires IMap<K,V> */
{
private:
typedef typename Windows::Foundation::Internal::GetLogicalType<K>::type K_logical;
typedef typename Windows::Foundation::Internal::GetLogicalType<V>::type V_logical;
public:
typedef K K_complex;
typedef V V_complex;
virtual /*eventadd*/ HRESULT STDMETHODCALLTYPE add_MapChanged (_In_opt_ MapChangedEventHandler<K_logical, V_logical>* handler, _Out_ EventRegistrationToken* token) = 0;
virtual /*eventremove*/ HRESULT STDMETHODCALLTYPE remove_MapChanged(_In_ EventRegistrationToken token) = 0;
};
}}} // namespace Windows::Foundation::Collections
} // namespace ABI
#endif /* __cplusplus */
#endif /* WINDOWS_FOUNDATION_COLLECTIONS_H */