WinStd
Windows Win32 API using Standard C++
Loading...
Searching...
No Matches
COM.h
1/*
2 SPDX-License-Identifier: MIT
3 Copyright © 1991-2023 Amebis
4 Copyright © 2016 GÉANT
5*/
6
8
9#pragma once
10
11#include "Common.h"
12#include <unknwn.h>
13#include <string>
14
15namespace winstd
16{
19
25 class com_runtime_error : public num_runtime_error<HRESULT>
26 {
27 public:
34 com_runtime_error(_In_ error_type num, _In_ const std::string& msg) : num_runtime_error<HRESULT>(num, msg)
35 {}
36
43 com_runtime_error(_In_ error_type num, _In_opt_z_ const char *msg = nullptr) : num_runtime_error<HRESULT>(num, msg)
44 {}
45 };
46
48
51
56 {
61
67 template <class _T>
68 void operator()(_T *_Ptr) const
69 {
70 CoTaskMemFree(_Ptr);
71 }
72 };
73
79 template <class T>
80 class com_obj : public dplhandle<T*, NULL>
81 {
83
84 public:
91 _In_ REFCLSID rclsid,
92 _In_opt_ LPUNKNOWN pUnkOuter,
93 _In_ DWORD dwClsContext)
94 {
95 HRESULT hr = CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (LPVOID*)&m_h);
96 if (FAILED(hr))
97 throw com_runtime_error(hr, "CoCreateInstance failed");
98 }
99
105 template <class _Other>
106 com_obj(_In_ _Other *other)
107 {
108 assert(other);
109 HRESULT hr = other->QueryInterface(__uuidof(T), (void**)&m_h);
110 if (FAILED(hr))
111 throw com_runtime_error(hr, "QueryInterface failed");
112 }
113
119 template <class _Other>
121 {
122 HRESULT hr = other->QueryInterface(__uuidof(T), (void**)&m_h);
123 if (FAILED(hr))
124 throw com_runtime_error(hr, "QueryInterface failed");
125 }
126
130 virtual ~com_obj()
131 {
132 if (m_h != invalid)
134 }
135
141 template <class _Other>
142 HRESULT query_interface(_Out_ _Other **h) const
143 {
144 assert(h);
145 assert(m_h);
146 return m_h->QueryInterface(__uuidof(_Other), (void**)h);
147 }
148
154 template <class _Other>
155 HRESULT query_interface(_Out_ com_obj<_Other> &h) const
156 {
157 assert(m_h);
158 _Other *_h;
159 HRESULT hr = m_h->QueryInterface(__uuidof(_Other), (void**)&_h);
160 if (SUCCEEDED(hr))
161 h.attach(_h);
162 return hr;
163 }
164
165 protected:
171 void free_internal() noexcept override
172 {
173 m_h->Release();
174 }
175
185 T* duplicate_internal(_In_ T* h) const override
186 {
187 h->AddRef();
188 return h;
189 }
190 };
191
195 class bstr : public dplhandle<BSTR, NULL>
196 {
197 WINSTD_DPLHANDLE_IMPL(bstr, BSTR, NULL)
198
199 public:
203 bstr(_In_opt_z_ LPCOLESTR src)
204 {
205 m_h = SysAllocString(src);
206 if (!m_h)
207 throw std::bad_alloc();
208 }
209
213 bstr(_In_reads_opt_(len) LPCOLESTR src, _In_ UINT len)
214 {
215 m_h = SysAllocStringLen(src, len);
216 if (!m_h)
217 throw std::bad_alloc();
218 }
219
223 template<class _Traits, class _Ax>
224 bstr(_In_ const std::basic_string<OLECHAR, _Traits, _Ax> &src)
225 {
226 size_t len = src.length();
227 if (len > UINT_MAX)
228 throw std::invalid_argument("string too long");
229 m_h = SysAllocStringLen(src.c_str(), static_cast<UINT>(len));
230 if (!m_h)
231 throw std::bad_alloc();
232 }
233
239 virtual ~bstr()
240 {
241 if (m_h != invalid)
243 }
244
250 UINT length() const noexcept
251 {
252 return SysStringLen(m_h);
253 }
254
255 protected:
261 void free_internal() noexcept override
262 {
263 SysFreeString(m_h);
264 }
265
276 {
277 handle_type h_new = SysAllocStringLen(h, SysStringLen(h));
278 if (h_new != invalid)
279 return h_new;
280 throw std::bad_alloc();
281 }
282 };
283
287 #pragma warning(push)
288 #pragma warning(disable: 26432) // Copy constructor and assignment operator are also present, but not detected by code analysis as they are using base type source object reference.
289 class variant : public VARIANT
290 {
291 public:
295 variant() noexcept
296 {
297 VariantInit(this);
298 }
299
303 variant(_In_ const VARIANT& varSrc)
304 {
305 vt = VT_EMPTY;
306 const HRESULT hr = VariantCopy(this, &varSrc);
307 if (FAILED(hr))
308 throw winstd::com_runtime_error(hr, "VariantCopy failed");
309 }
310
314 #pragma warning(suppress: 26495) // vt member is initialized as a result of memcpy()
315 variant(_Inout_ VARIANT&& varSrc) noexcept
316 {
317 memcpy(this, &varSrc, sizeof(VARIANT));
318 varSrc.vt = VT_EMPTY;
319 }
320
324 variant(_In_ bool bSrc) noexcept
325 {
326 vt = VT_BOOL;
327 boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
328 }
329
333 variant(_In_ char cSrc) noexcept
334 {
335 vt = VT_I1;
336 cVal = cSrc;
337 }
338
342 variant(_In_ unsigned char nSrc) noexcept
343 {
344 vt = VT_UI1;
345 bVal = nSrc;
346 }
347
351 variant(_In_ short nSrc) noexcept
352 {
353 vt = VT_I2;
354 iVal = nSrc;
355 }
356
360 variant(_In_ unsigned short nSrc) noexcept
361 {
362 vt = VT_UI2;
363 uiVal = nSrc;
364 }
365
369 variant(_In_ int nSrc, _In_ VARTYPE vtSrc = VT_I4) noexcept
370 {
371 assert(vtSrc == VT_I4 || vtSrc == VT_INT);
372 vt = vtSrc;
373 intVal = nSrc;
374 }
375
379 variant(_In_ unsigned int nSrc, _In_ VARTYPE vtSrc = VT_UI4) noexcept
380 {
381 assert(vtSrc == VT_UI4 || vtSrc == VT_UINT);
382 vt = vtSrc;
383 uintVal= nSrc;
384 }
385
389 variant(_In_ long nSrc, _In_ VARTYPE vtSrc = VT_I4) noexcept
390 {
391 assert(vtSrc == VT_I4 || vtSrc == VT_ERROR);
392 vt = vtSrc;
393 lVal = nSrc;
394 }
395
399 variant(_In_ unsigned long nSrc) noexcept
400 {
401 vt = VT_UI4;
402 ulVal = nSrc;
403 }
404
408 variant(_In_ float fltSrc) noexcept
409 {
410 vt = VT_R4;
411 fltVal = fltSrc;
412 }
413
417 variant(_In_ double dblSrc, _In_ VARTYPE vtSrc = VT_R8) noexcept
418 {
419 assert(vtSrc == VT_R8 || vtSrc == VT_DATE);
420 vt = vtSrc;
421 dblVal = dblSrc;
422 }
423
427 variant(_In_ long long nSrc) noexcept
428 {
429 vt = VT_I8;
430 llVal = nSrc;
431 }
432
436 variant(_In_ unsigned long long nSrc) noexcept
437 {
438 vt = VT_UI8;
439 ullVal = nSrc;
440 }
441
445 variant(_In_ CY cySrc) noexcept
446 {
447 vt = VT_CY;
448 cyVal.Hi = cySrc.Hi;
449 cyVal.Lo = cySrc.Lo;
450 }
451
455 variant(_In_z_ LPCOLESTR lpszSrc) noexcept
456 {
457 vt = VT_EMPTY;
458 *this = lpszSrc;
459 }
460
464 variant(_In_z_ BSTR bstr) noexcept
465 {
466 vt = VT_EMPTY;
467 *this = bstr;
468 }
469
473 variant(_In_opt_ IDispatch* pSrc)
474 {
475 vt = VT_DISPATCH;
476 pdispVal = pSrc;
477
478 if (pdispVal != NULL)
479 pdispVal->AddRef();
480 }
481
485 variant(_In_opt_ IUnknown* pSrc)
486 {
487 vt = VT_UNKNOWN;
488 punkVal = pSrc;
489
490 if (punkVal != NULL)
491 punkVal->AddRef();
492 }
493
497 variant(_In_ const SAFEARRAY *pSrc)
498 {
499 assert(pSrc != NULL);
500
501 LPSAFEARRAY pCopy;
502 const HRESULT hr = SafeArrayCopy(const_cast<LPSAFEARRAY>(pSrc), &pCopy);
503 if (FAILED(hr))
504 throw winstd::com_runtime_error(hr, "SafeArrayCopy failed");
505
506 SafeArrayGetVartype(const_cast<LPSAFEARRAY>(pSrc), &vt);
507 vt |= VT_ARRAY;
508 parray = pCopy;
509 }
510
514 virtual ~variant()
515 {
516 VariantClear(this);
517 }
518
522 variant& operator=(_In_ const VARIANT& varSrc)
523 {
524 if (this != &varSrc) {
525 const HRESULT hr = VariantCopy(this, &varSrc);
526 if (FAILED(hr))
527 throw winstd::com_runtime_error(hr, "VariantCopy failed");
528 }
529 return *this;
530 }
531
535 variant& operator=(_Inout_ VARIANT&& varSrc) noexcept
536 {
537 if (this != &varSrc) {
538 VariantClear(this);
539 memcpy(this, &varSrc, sizeof(VARIANT));
540 varSrc.vt = VT_EMPTY;
541 }
542 return *this;
543 }
544
548 variant& operator=(_In_ bool bSrc) noexcept
549 {
550 if (vt != VT_BOOL) {
551 VariantClear(this);
552 vt = VT_BOOL;
553 }
554 boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
555 return *this;
556 }
557
561 variant& operator=(_In_ char cSrc) noexcept
562 {
563 if (vt != VT_I1) {
564 VariantClear(this);
565 vt = VT_I1;
566 }
567 cVal = cSrc;
568 return *this;
569 }
570
574 variant& operator=(_In_ unsigned char nSrc) noexcept
575 {
576 if (vt != VT_UI1) {
577 VariantClear(this);
578 vt = VT_UI1;
579 }
580 bVal = nSrc;
581 return *this;
582 }
583
587 variant& operator=(_In_ short nSrc) noexcept
588 {
589 if (vt != VT_I2) {
590 VariantClear(this);
591 vt = VT_I2;
592 }
593 iVal = nSrc;
594 return *this;
595 }
596
600 variant& operator=(_In_ unsigned short nSrc) noexcept
601 {
602 if (vt != VT_UI2) {
603 VariantClear(this);
604 vt = VT_UI2;
605 }
606 uiVal = nSrc;
607 return *this;
608 }
609
613 variant& operator=(_In_ int nSrc) noexcept
614 {
615 if (vt != VT_I4) {
616 VariantClear(this);
617 vt = VT_I4;
618 }
619 intVal = nSrc;
620 return *this;
621 }
622
626 variant& operator=(_In_ unsigned int nSrc) noexcept
627 {
628 if (vt != VT_UI4) {
629 VariantClear(this);
630 vt = VT_UI4;
631 }
632 uintVal= nSrc;
633 return *this;
634 }
635
639 variant& operator=(_In_ long nSrc) noexcept
640 {
641 if (vt != VT_I4) {
642 VariantClear(this);
643 vt = VT_I4;
644 }
645 lVal = nSrc;
646 return *this;
647 }
648
652 variant& operator=(_In_ unsigned long nSrc) noexcept
653 {
654 if (vt != VT_UI4) {
655 VariantClear(this);
656 vt = VT_UI4;
657 }
658 ulVal = nSrc;
659 return *this;
660 }
661
665 variant& operator=(_In_ long long nSrc) noexcept
666 {
667 if (vt != VT_I8) {
668 VariantClear(this);
669 vt = VT_I8;
670 }
671 llVal = nSrc;
672 return *this;
673 }
674
678 variant& operator=(_In_ unsigned long long nSrc) noexcept
679 {
680 if (vt != VT_UI8) {
681 VariantClear(this);
682 vt = VT_UI8;
683 }
684 ullVal = nSrc;
685
686 return *this;
687 }
688
692 variant& operator=(_In_ float fltSrc) noexcept
693 {
694 if (vt != VT_R4) {
695 VariantClear(this);
696 vt = VT_R4;
697 }
698 fltVal = fltSrc;
699 return *this;
700 }
701
705 variant& operator=(_In_ double dblSrc) noexcept
706 {
707 if (vt != VT_R8) {
708 VariantClear(this);
709 vt = VT_R8;
710 }
711 dblVal = dblSrc;
712 return *this;
713 }
714
718 variant& operator=(_In_ CY cySrc) noexcept
719 {
720 if (vt != VT_CY) {
721 VariantClear(this);
722 vt = VT_CY;
723 }
724 cyVal.Hi = cySrc.Hi;
725 cyVal.Lo = cySrc.Lo;
726 return *this;
727 }
728
732 variant& operator=(_In_z_ LPCOLESTR lpszSrc) noexcept
733 {
734 VariantClear(this);
735 vt = VT_BSTR;
736 bstrVal = SysAllocString(lpszSrc);
737 return *this;
738 }
739
743 variant& operator=(_Inout_opt_ IDispatch* pSrc)
744 {
745 VariantClear(this);
746 vt = VT_DISPATCH;
747 pdispVal = pSrc;
748 if (pdispVal != NULL)
749 pdispVal->AddRef();
750 return *this;
751 }
752
756 variant& operator=(_Inout_opt_ IUnknown* pSrc)
757 {
758 VariantClear(this);
759 vt = VT_UNKNOWN;
760 punkVal = pSrc;
761 if (punkVal != NULL)
762 punkVal->AddRef();
763 return *this;
764 }
765
769 variant& operator=(_In_ unsigned char* pbSrc) noexcept
770 {
771 if (vt != (VT_UI1|VT_BYREF)) {
772 VariantClear(this);
773 vt = VT_UI1|VT_BYREF;
774 }
775 pbVal = pbSrc;
776 return *this;
777 }
778
782 variant& operator=(_In_ short* pnSrc) noexcept
783 {
784 if (vt != (VT_I2|VT_BYREF)) {
785 VariantClear(this);
786 vt = VT_I2|VT_BYREF;
787 }
788 piVal = pnSrc;
789 return *this;
790 }
791
795 variant& operator=(_In_ unsigned short* pnSrc) noexcept
796 {
797 if (vt != (VT_UI2|VT_BYREF)) {
798 VariantClear(this);
799 vt = VT_UI2|VT_BYREF;
800 }
801 puiVal = pnSrc;
802 return *this;
803 }
804
808 variant& operator=(_In_ int* pnSrc) noexcept
809 {
810 if (vt != (VT_I4|VT_BYREF)) {
811 VariantClear(this);
812 vt = VT_I4|VT_BYREF;
813 }
814 pintVal = pnSrc;
815 return *this;
816 }
817
821 variant& operator=(_In_ unsigned int* pnSrc) noexcept
822 {
823 if (vt != (VT_UI4|VT_BYREF)) {
824 VariantClear(this);
825 vt = VT_UI4|VT_BYREF;
826 }
827 puintVal = pnSrc;
828 return *this;
829 }
830
834 variant& operator=(_In_ long* pnSrc) noexcept
835 {
836 if (vt != (VT_I4|VT_BYREF)) {
837 VariantClear(this);
838 vt = VT_I4|VT_BYREF;
839 }
840 plVal = pnSrc;
841 return *this;
842 }
843
847 variant& operator=(_In_ unsigned long* pnSrc) noexcept
848 {
849 if (vt != (VT_UI4|VT_BYREF)) {
850 VariantClear(this);
851 vt = VT_UI4|VT_BYREF;
852 }
853 pulVal = pnSrc;
854 return *this;
855 }
856
860 variant& operator=(_In_ long long* pnSrc) noexcept
861 {
862 if (vt != (VT_I8|VT_BYREF)) {
863 VariantClear(this);
864 vt = VT_I8|VT_BYREF;
865 }
866 pllVal = pnSrc;
867 return *this;
868 }
869
873 variant& operator=(_In_ unsigned long long* pnSrc) noexcept
874 {
875 if (vt != (VT_UI8|VT_BYREF)) {
876 VariantClear(this);
877 vt = VT_UI8|VT_BYREF;
878 }
879 pullVal = pnSrc;
880 return *this;
881 }
882
886 variant& operator=(_In_ float* pfSrc) noexcept
887 {
888 if (vt != (VT_R4|VT_BYREF)) {
889 VariantClear(this);
890 vt = VT_R4|VT_BYREF;
891 }
892 pfltVal = pfSrc;
893 return *this;
894 }
895
899 variant& operator=(_In_ double* pfSrc) noexcept
900 {
901 if (vt != (VT_R8|VT_BYREF)) {
902 VariantClear(this);
903 vt = VT_R8|VT_BYREF;
904 }
905 pdblVal = pfSrc;
906 return *this;
907 }
908
912 variant& operator=(_In_ const SAFEARRAY *pSrc)
913 {
914 assert(pSrc != NULL);
915 VariantClear(this);
916
917 LPSAFEARRAY pCopy;
918 const HRESULT hr = SafeArrayCopy(const_cast<LPSAFEARRAY>(pSrc), &pCopy);
919 if (SUCCEEDED(hr)) {
920 SafeArrayGetVartype(const_cast<LPSAFEARRAY>(pSrc), &vt);
921 vt |= VT_ARRAY;
922 parray = pCopy;
923 return *this;
924 }
925 throw com_runtime_error(hr, "SafeArrayCopy failed");
926 }
927
928 public:
937 bool operator==(_In_ const VARIANT& varSrc) const noexcept
938 {
939 if (vt == VT_NULL && varSrc.vt == VT_NULL) return true;
940 if (vt != varSrc.vt) return false;
941 return compare(static_cast<const VARIANT&>(*this), varSrc, LOCALE_USER_DEFAULT, 0) == static_cast<HRESULT>(VARCMP_EQ);
942 }
943
952 bool operator!=(_In_ const VARIANT& varSrc) const noexcept
953 {
954 return !operator==(varSrc);
955 }
956
965 bool operator<(_In_ const VARIANT& varSrc) const noexcept
966 {
967 if (vt == VT_NULL && varSrc.vt == VT_NULL) return false;
968 return compare(static_cast<const VARIANT&>(*this), varSrc, LOCALE_USER_DEFAULT, 0)== static_cast<HRESULT>(VARCMP_LT);
969 }
970
979 bool operator>(_In_ const VARIANT& varSrc) const noexcept
980 {
981 if (vt == VT_NULL && varSrc.vt == VT_NULL) return false;
982 return compare(static_cast<const VARIANT&>(*this), varSrc, LOCALE_USER_DEFAULT, 0)== static_cast<HRESULT>(VARCMP_GT);
983 }
984
993 bool operator<=(_In_ const VARIANT& varSrc) const noexcept
994 {
995 return !operator>(varSrc);
996 }
997
1006 bool operator>=(_In_ const VARIANT& varSrc) const noexcept
1007 {
1008 return !operator<(varSrc);
1009 }
1010
1016 HRESULT change_type(_In_ VARTYPE _vt, _In_opt_ USHORT wFlags = 0) noexcept
1017 {
1018 return VariantChangeType(this, this, wFlags, _vt);
1019 }
1020
1021 private:
1023 HRESULT compare(_In_ const VARIANT &varLeft, _In_ const VARIANT &varRight, _In_ LCID lcid, _In_ ULONG dwFlags) const noexcept
1024 {
1025 switch(vt) {
1026 case VT_I1: return varLeft.cVal == varRight.cVal ? VARCMP_EQ : varLeft.cVal > varRight.cVal ? VARCMP_GT : VARCMP_LT;
1027 case VT_UI2: return varLeft.uiVal == varRight.uiVal ? VARCMP_EQ : varLeft.uiVal > varRight.uiVal ? VARCMP_GT : VARCMP_LT;
1028 case VT_UI4: return varLeft.uintVal == varRight.uintVal ? VARCMP_EQ : varLeft.uintVal > varRight.uintVal ? VARCMP_GT : VARCMP_LT;
1029 case VT_UI8: return varLeft.ullVal == varRight.ullVal ? VARCMP_EQ : varLeft.ullVal > varRight.ullVal ? VARCMP_GT : VARCMP_LT;
1030 default: return VarCmp(const_cast<LPVARIANT>(&varLeft), const_cast<LPVARIANT>(&varRight), lcid, dwFlags);
1031 }
1032 }
1034 };
1035 #pragma warning(pop)
1036
1040 class safearray : public dplhandle<SAFEARRAY*, NULL>
1041 {
1042 WINSTD_DPLHANDLE_IMPL(safearray, SAFEARRAY*, NULL)
1043
1044 public:
1050 virtual ~safearray()
1051 {
1052 if (m_h != invalid)
1053 free_internal();
1054 }
1055
1056 protected:
1062 void free_internal() noexcept override
1063 {
1064 SafeArrayDestroy(m_h);
1065 }
1066
1077 {
1078 handle_type h_new;
1079 HRESULT hr = SafeArrayCopy(h, &h_new);
1080 if (SUCCEEDED(hr))
1081 return h_new;
1082 throw com_runtime_error(hr, "SafeArrayCopy failed");
1083 }
1084 };
1085
1089 template <class T>
1091 {
1094
1095 public:
1101 safearray_accessor(_In_ SAFEARRAY* psa) : m_sa(psa)
1102 {
1103 HRESULT hr = SafeArrayAccessData(psa, (void HUGEP**)&m_data);
1104 if (FAILED(hr))
1105 throw com_runtime_error(hr, "SafeArrayAccessData failed");
1106 }
1107
1114 {
1115 SafeArrayUnaccessData(m_sa);
1116 }
1117
1121 T HUGEP* data() const noexcept
1122 {
1123 return m_data;
1124 }
1125
1126 protected:
1127 SAFEARRAY* m_sa;
1128 T HUGEP* m_data;
1129 };
1130
1135 {
1138
1139 public:
1145 com_initializer(_In_opt_ LPVOID pvReserved)
1146 {
1147 HRESULT hr = CoInitialize(pvReserved);
1148 if (FAILED(hr))
1149 throw com_runtime_error(hr, "CoInitialize failed");
1150 }
1151
1157 com_initializer(_In_opt_ LPVOID pvReserved, _In_ DWORD dwCoInit)
1158 {
1159 HRESULT hr = CoInitializeEx(pvReserved, dwCoInit);
1160 if (FAILED(hr))
1161 throw com_runtime_error(hr, "CoInitializeEx failed");
1162 }
1163
1170 {
1171 CoUninitialize();
1172 }
1173 };
1174
1176}
1177
1180
1186template <class T>
1187static _Check_return_ HRESULT CoCreateInstance(_In_ REFCLSID rclsid, _In_opt_ LPUNKNOWN pUnkOuter, _In_ DWORD dwClsContext, _Inout_ winstd::com_obj<T> &v)
1188{
1189 T* ppv;
1190 HRESULT hr = CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (LPVOID*)&ppv);
1191 if (SUCCEEDED(hr))
1192 v.attach(ppv);
1193 return hr;
1194}
1195
1201template <class T>
1202static _Check_return_ HRESULT CoGetObject(_In_ LPCWSTR pszName, _In_opt_ BIND_OPTS* pBindOptions, _In_ REFIID riid, _Inout_ winstd::com_obj<T>& v)
1203{
1204 T* ppv;
1205 HRESULT hr = CoGetObject(pszName, pBindOptions, riid, (LPVOID*)&ppv);
1206 if (SUCCEEDED(hr))
1207 v.attach(ppv);
1208 return hr;
1209}
1210
BSTR string wrapper.
Definition COM.h:196
bstr(LPCOLESTR src)
Constructs BSTR from OLE string.
Definition COM.h:203
handle_type duplicate_internal(handle_type h) const override
Duplicates the string.
Definition COM.h:275
virtual ~bstr()
Destroys the string.
Definition COM.h:239
void free_internal() noexcept override
Destroys the string.
Definition COM.h:261
UINT length() const noexcept
Returns the length of the string.
Definition COM.h:250
bstr(LPCOLESTR src, UINT len)
Constructs BSTR from OLE string with length.
Definition COM.h:213
bstr(const std::basic_string< OLECHAR, _Traits, _Ax > &src)
Constructs BSTR from std::basic_string.
Definition COM.h:224
Context scope automatic COM (un)initialization.
Definition COM.h:1135
com_initializer(LPVOID pvReserved, DWORD dwCoInit)
Initializes the COM library for use by the calling thread, sets the thread's concurrency model,...
Definition COM.h:1157
virtual ~com_initializer()
Uninitializes COM.
Definition COM.h:1169
com_initializer(LPVOID pvReserved)
Initializes the COM library on the current thread and identifies the concurrency model as single-thre...
Definition COM.h:1145
COM object wrapper template.
Definition COM.h:81
void free_internal() noexcept override
Releases the object by decrementing reference counter.
Definition COM.h:171
com_obj(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext)
Creates a new instance of a class.
Definition COM.h:90
HRESULT query_interface(_Other **h) const
Queries the object for another interface.
Definition COM.h:142
T * duplicate_internal(T *h) const override
Duplicates the object by incrementing the reference counter.
Definition COM.h:185
HRESULT query_interface(com_obj< _Other > &h) const
Queries the object for another interface.
Definition COM.h:155
virtual ~com_obj()
Releases object.
Definition COM.h:130
com_obj(_Other *other)
Queries the object for another interface and creates new class with it.
Definition COM.h:106
com_obj(com_obj< _Other > &other)
Queries the object for another interface and creates new class with it.
Definition COM.h:120
COM runtime error.
Definition COM.h:26
com_runtime_error(error_type num, const std::string &msg)
Constructs an exception.
Definition COM.h:34
com_runtime_error(error_type num, const char *msg=nullptr)
Constructs an exception.
Definition COM.h:43
Base abstract template class to support object handle keeping for objects that support trivial handle...
Definition Common.h:1283
T handle_type
Datatype of the object handle this template class handles.
Definition Common.h:1025
handle_type m_h
Object handle.
Definition Common.h:1272
Numerical runtime error.
Definition Common.h:1477
HRESULT error_type
Error number type.
Definition Common.h:1479
Context scope automatic SAFEARRAY (un)access.
Definition COM.h:1091
safearray_accessor(SAFEARRAY *psa)
Increments the lock count of an array, and retrieves a pointer to the array data.
Definition COM.h:1101
T HUGEP * data() const noexcept
Return SAFEARRAY data pointer.
Definition COM.h:1121
SAFEARRAY * m_sa
SAFEARRAY.
Definition COM.h:1127
virtual ~safearray_accessor()
Decrements the lock count of an array.
Definition COM.h:1113
T HUGEP * m_data
SAFEARRAY data.
Definition COM.h:1128
SAFEARRAY string wrapper.
Definition COM.h:1041
virtual ~safearray()
Destroys the array.
Definition COM.h:1050
handle_type duplicate_internal(handle_type h) const override
Duplicates the array.
Definition COM.h:1076
void free_internal() noexcept override
Destroys the array.
Definition COM.h:1062
VARIANT struct wrapper.
Definition COM.h:290
bool operator<=(const VARIANT &varSrc) const noexcept
Is variant less than or equal to?
Definition COM.h:993
variant(bool bSrc) noexcept
Constructs VARIANT from bool.
Definition COM.h:324
variant & operator=(unsigned int nSrc) noexcept
Copy from unsigned int value.
Definition COM.h:626
variant & operator=(unsigned long nSrc) noexcept
Copy from unsigned long value.
Definition COM.h:652
variant(float fltSrc) noexcept
Constructs VARIANT from float.
Definition COM.h:408
variant(VARIANT &&varSrc) noexcept
Moves VARIANT from another.
Definition COM.h:315
variant & operator=(float fltSrc) noexcept
Copy from float value.
Definition COM.h:692
variant & operator=(float *pfSrc) noexcept
Copy from float reference.
Definition COM.h:886
variant(IDispatch *pSrc)
Constructs VARIANT from IDispatch.
Definition COM.h:473
variant(int nSrc, VARTYPE vtSrc=VT_I4) noexcept
Constructs VARIANT from integer.
Definition COM.h:369
variant(const SAFEARRAY *pSrc)
Constructs VARIANT from SAFEARRAY.
Definition COM.h:497
variant & operator=(double *pfSrc) noexcept
Copy from double reference.
Definition COM.h:899
variant & operator=(const SAFEARRAY *pSrc)
Copy from SAFEARRAY.
Definition COM.h:912
variant & operator=(int *pnSrc) noexcept
Copy from int reference.
Definition COM.h:808
bool operator>(const VARIANT &varSrc) const noexcept
Is variant greater than?
Definition COM.h:979
variant & operator=(bool bSrc) noexcept
Copy from bool value.
Definition COM.h:548
variant & operator=(long nSrc) noexcept
Copy from long value.
Definition COM.h:639
HRESULT change_type(VARTYPE _vt, USHORT wFlags=0) noexcept
Converts a variant from one type to another.
Definition COM.h:1016
variant & operator=(IUnknown *pSrc)
Copy from IUnknown.
Definition COM.h:756
variant & operator=(short nSrc) noexcept
Copy from short value.
Definition COM.h:587
variant & operator=(unsigned char *pbSrc) noexcept
Copy from unsigned char reference.
Definition COM.h:769
variant & operator=(unsigned short nSrc) noexcept
Copy from unsigned short value.
Definition COM.h:600
variant & operator=(unsigned char nSrc) noexcept
Copy from unsigned char value.
Definition COM.h:574
variant & operator=(char cSrc) noexcept
Copy from char value.
Definition COM.h:561
variant(LPCOLESTR lpszSrc) noexcept
Constructs VARIANT from OLE string.
Definition COM.h:455
virtual ~variant()
Destroys VARIANT.
Definition COM.h:514
variant(const VARIANT &varSrc)
Constructs VARIANT from another.
Definition COM.h:303
variant(unsigned char nSrc) noexcept
Constructs VARIANT from byte.
Definition COM.h:342
variant & operator=(double dblSrc) noexcept
Copy from double value.
Definition COM.h:705
bool operator!=(const VARIANT &varSrc) const noexcept
Is variant not equal to?
Definition COM.h:952
variant & operator=(int nSrc) noexcept
Copy from int value.
Definition COM.h:613
variant(unsigned long nSrc) noexcept
Constructs VARIANT from unsigned long.
Definition COM.h:399
bool operator==(const VARIANT &varSrc) const noexcept
Is variant equal to?
Definition COM.h:937
variant(IUnknown *pSrc)
Constructs VARIANT from IUnknown.
Definition COM.h:485
variant(unsigned int nSrc, VARTYPE vtSrc=VT_UI4) noexcept
Constructs VARIANT from unsigned integer.
Definition COM.h:379
variant & operator=(CY cySrc) noexcept
Copy from CY value.
Definition COM.h:718
variant & operator=(LPCOLESTR lpszSrc) noexcept
Copy from OLE string value.
Definition COM.h:732
variant(long long nSrc) noexcept
Constructs VARIANT from 64-bit integer.
Definition COM.h:427
variant & operator=(unsigned int *pnSrc) noexcept
Copy from unsigned int reference.
Definition COM.h:821
variant(long nSrc, VARTYPE vtSrc=VT_I4) noexcept
Constructs VARIANT from long.
Definition COM.h:389
variant & operator=(long *pnSrc) noexcept
Copy from long reference.
Definition COM.h:834
variant(unsigned short nSrc) noexcept
Constructs VARIANT from unsigned short.
Definition COM.h:360
bool operator>=(const VARIANT &varSrc) const noexcept
Is variant greater than or equal to?
Definition COM.h:1006
variant & operator=(short *pnSrc) noexcept
Copy from short reference.
Definition COM.h:782
variant() noexcept
Constructs blank VARIANT.
Definition COM.h:295
bool operator<(const VARIANT &varSrc) const noexcept
Is variant less than?
Definition COM.h:965
variant(unsigned long long nSrc) noexcept
Constructs VARIANT from unsigned integer.
Definition COM.h:436
variant(char cSrc) noexcept
Constructs VARIANT from character.
Definition COM.h:333
variant & operator=(unsigned short *pnSrc) noexcept
Copy from unsigned short reference.
Definition COM.h:795
variant & operator=(long long *pnSrc) noexcept
Copy from long long reference.
Definition COM.h:860
variant(BSTR bstr) noexcept
Constructs VARIANT from BSTR.
Definition COM.h:464
variant & operator=(unsigned long long *pnSrc) noexcept
Copy from unsigned long long reference.
Definition COM.h:873
variant(double dblSrc, VARTYPE vtSrc=VT_R8) noexcept
Constructs VARIANT from double or variant date.
Definition COM.h:417
variant(short nSrc) noexcept
Constructs VARIANT from short.
Definition COM.h:351
variant(CY cySrc) noexcept
Constructs VARIANT from CY (64-bit integer)
Definition COM.h:445
variant & operator=(unsigned long long nSrc) noexcept
Copy from unsigned long long value.
Definition COM.h:678
variant & operator=(VARIANT &&varSrc) noexcept
Moves from another VARIANT.
Definition COM.h:535
variant & operator=(long long nSrc) noexcept
Copy from long long value.
Definition COM.h:665
variant & operator=(IDispatch *pSrc)
Copy from IDispatch.
Definition COM.h:743
variant & operator=(unsigned long *pnSrc) noexcept
Copy from unsigned long reference.
Definition COM.h:847
variant & operator=(const VARIANT &varSrc)
Copy from another VARIANT.
Definition COM.h:522
static _Check_return_ HRESULT CoGetObject(LPCWSTR pszName, BIND_OPTS *pBindOptions, REFIID riid, winstd::com_obj< T > &v)
Converts a display name into a moniker that identifies the object named, and then binds to the object...
Definition COM.h:1202
static _Check_return_ HRESULT CoCreateInstance(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext, winstd::com_obj< T > &v)
Creates and default-initializes a single object of the class associated with a specified CLSID.
Definition COM.h:1187
#define WINSTD_NONCOPYABLE(C)
Declares a class as non-copyable.
Definition Common.h:67
#define WINSTD_NONMOVABLE(C)
Declares a class as non-movable.
Definition Common.h:75
#define WINSTD_DPLHANDLE_IMPL(C, T, INVAL)
Implements default constructors and operators to prevent their auto-generation by compiler.
Definition Common.h:176
static const T invalid
Invalid handle value.
Definition Common.h:1030
Deleter for unique_ptr using CoTaskMemFree.
Definition COM.h:56
void operator()(_T *_Ptr) const
Delete a pointer.
Definition COM.h:68
CoTaskMemFree_delete() noexcept
Default constructor.
Definition COM.h:60