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 }
37
44 com_runtime_error(_In_ error_type num, _In_opt_z_ const char *msg = nullptr) : num_runtime_error<HRESULT>(num, msg)
45 {
46 }
47 };
48
50
53
58 {
63
69 template <class _T>
70 void operator()(_T *_Ptr) const
71 {
72 CoTaskMemFree(_Ptr);
73 }
74 };
75
81 template <class T>
82 class com_obj : public dplhandle<T*, NULL>
83 {
85
86 public:
93 _In_ REFCLSID rclsid,
94 _In_opt_ LPUNKNOWN pUnkOuter,
95 _In_ DWORD dwClsContext)
96 {
97 HRESULT hr = CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (LPVOID*)&m_h);
98 if (FAILED(hr))
99 throw com_runtime_error(hr, "CoCreateInstance failed");
100 }
101
107 template <class _Other>
108 com_obj(_In_ _Other *other)
109 {
110 assert(other);
111 HRESULT hr = other->QueryInterface(__uuidof(T), (void**)&m_h);
112 if (FAILED(hr))
113 throw com_runtime_error(hr, "QueryInterface failed");
114 }
115
121 template <class _Other>
123 {
124 HRESULT hr = other->QueryInterface(__uuidof(T), (void**)&m_h);
125 if (FAILED(hr))
126 throw com_runtime_error(hr, "QueryInterface failed");
127 }
128
132 virtual ~com_obj()
133 {
134 if (m_h != invalid)
136 }
137
143 template <class _Other>
144 HRESULT query_interface(_Out_ _Other **h) const
145 {
146 assert(h);
147 assert(m_h);
148 return m_h->QueryInterface(__uuidof(_Other), (void**)h);
149 }
150
156 template <class _Other>
157 HRESULT query_interface(_Out_ com_obj<_Other> &h) const
158 {
159 assert(m_h);
160 _Other *_h;
161 HRESULT hr = m_h->QueryInterface(__uuidof(_Other), (void**)&_h);
162 if (SUCCEEDED(hr))
163 h.attach(_h);
164 return hr;
165 }
166
167 protected:
173 void free_internal() noexcept override
174 {
175 m_h->Release();
176 }
177
187 T* duplicate_internal(_In_ T* h) const override
188 {
189 h->AddRef();
190 return h;
191 }
192 };
193
197 class bstr : public dplhandle<BSTR, NULL>
198 {
199 WINSTD_DPLHANDLE_IMPL(bstr, BSTR, NULL)
200
201 public:
205 bstr(_In_opt_z_ LPCOLESTR src)
206 {
207 m_h = SysAllocString(src);
208 if (!m_h)
209 throw std::bad_alloc();
210 }
211
215 bstr(_In_reads_opt_(len) LPCOLESTR src, _In_ UINT len)
216 {
217 m_h = SysAllocStringLen(src, len);
218 if (!m_h)
219 throw std::bad_alloc();
220 }
221
225 template<class _Traits, class _Ax>
226 bstr(_In_ const std::basic_string<OLECHAR, _Traits, _Ax> &src)
227 {
228 size_t len = src.length();
229 if (len > UINT_MAX)
230 throw std::invalid_argument("string too long");
231 m_h = SysAllocStringLen(src.c_str(), static_cast<UINT>(len));
232 if (!m_h)
233 throw std::bad_alloc();
234 }
235
241 virtual ~bstr()
242 {
243 if (m_h != invalid)
245 }
246
252 UINT length() const noexcept
253 {
254 return SysStringLen(m_h);
255 }
256
257 protected:
263 void free_internal() noexcept override
264 {
265 SysFreeString(m_h);
266 }
267
278 {
279 handle_type h_new = SysAllocStringLen(h, SysStringLen(h));
280 if (h_new != invalid)
281 return h_new;
282 throw std::bad_alloc();
283 }
284 };
285
289 #pragma warning(push)
290 #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.
291 class variant : public VARIANT
292 {
293 public:
297 variant() noexcept
298 {
299 VariantInit(this);
300 }
301
305 variant(_In_ const VARIANT& varSrc)
306 {
307 vt = VT_EMPTY;
308 const HRESULT hr = VariantCopy(this, &varSrc);
309 if (FAILED(hr))
310 throw winstd::com_runtime_error(hr, "VariantCopy failed");
311 }
312
316 #pragma warning(suppress: 26495) // vt member is initialized as a result of memcpy()
317 variant(_Inout_ VARIANT&& varSrc) noexcept
318 {
319 memcpy(this, &varSrc, sizeof(VARIANT));
320 varSrc.vt = VT_EMPTY;
321 }
322
326 variant(_In_ bool bSrc) noexcept
327 {
328 vt = VT_BOOL;
329 boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
330 }
331
335 variant(_In_ char cSrc) noexcept
336 {
337 vt = VT_I1;
338 cVal = cSrc;
339 }
340
344 variant(_In_ unsigned char nSrc) noexcept
345 {
346 vt = VT_UI1;
347 bVal = nSrc;
348 }
349
353 variant(_In_ short nSrc) noexcept
354 {
355 vt = VT_I2;
356 iVal = nSrc;
357 }
358
362 variant(_In_ unsigned short nSrc) noexcept
363 {
364 vt = VT_UI2;
365 uiVal = nSrc;
366 }
367
371 variant(_In_ int nSrc, _In_ VARTYPE vtSrc = VT_I4) noexcept
372 {
373 assert(vtSrc == VT_I4 || vtSrc == VT_INT);
374 vt = vtSrc;
375 intVal = nSrc;
376 }
377
381 variant(_In_ unsigned int nSrc, _In_ VARTYPE vtSrc = VT_UI4) noexcept
382 {
383 assert(vtSrc == VT_UI4 || vtSrc == VT_UINT);
384 vt = vtSrc;
385 uintVal= nSrc;
386 }
387
391 variant(_In_ long nSrc, _In_ VARTYPE vtSrc = VT_I4) noexcept
392 {
393 assert(vtSrc == VT_I4 || vtSrc == VT_ERROR);
394 vt = vtSrc;
395 lVal = nSrc;
396 }
397
401 variant(_In_ unsigned long nSrc) noexcept
402 {
403 vt = VT_UI4;
404 ulVal = nSrc;
405 }
406
410 variant(_In_ float fltSrc) noexcept
411 {
412 vt = VT_R4;
413 fltVal = fltSrc;
414 }
415
419 variant(_In_ double dblSrc, _In_ VARTYPE vtSrc = VT_R8) noexcept
420 {
421 assert(vtSrc == VT_R8 || vtSrc == VT_DATE);
422 vt = vtSrc;
423 dblVal = dblSrc;
424 }
425
429 variant(_In_ long long nSrc) noexcept
430 {
431 vt = VT_I8;
432 llVal = nSrc;
433 }
434
438 variant(_In_ unsigned long long nSrc) noexcept
439 {
440 vt = VT_UI8;
441 ullVal = nSrc;
442 }
443
447 variant(_In_ CY cySrc) noexcept
448 {
449 vt = VT_CY;
450 cyVal.Hi = cySrc.Hi;
451 cyVal.Lo = cySrc.Lo;
452 }
453
457 variant(_In_z_ LPCOLESTR lpszSrc) noexcept
458 {
459 vt = VT_EMPTY;
460 *this = lpszSrc;
461 }
462
466 variant(_In_z_ BSTR bstr) noexcept
467 {
468 vt = VT_EMPTY;
469 *this = bstr;
470 }
471
475 variant(_In_opt_ IDispatch* pSrc)
476 {
477 vt = VT_DISPATCH;
478 pdispVal = pSrc;
479
480 if (pdispVal != NULL)
481 pdispVal->AddRef();
482 }
483
487 variant(_In_opt_ IUnknown* pSrc)
488 {
489 vt = VT_UNKNOWN;
490 punkVal = pSrc;
491
492 if (punkVal != NULL)
493 punkVal->AddRef();
494 }
495
499 variant(_In_ const SAFEARRAY *pSrc)
500 {
501 assert(pSrc != NULL);
502
503 LPSAFEARRAY pCopy;
504 const HRESULT hr = SafeArrayCopy(const_cast<LPSAFEARRAY>(pSrc), &pCopy);
505 if (FAILED(hr))
506 throw winstd::com_runtime_error(hr, "SafeArrayCopy failed");
507
508 SafeArrayGetVartype(const_cast<LPSAFEARRAY>(pSrc), &vt);
509 vt |= VT_ARRAY;
510 parray = pCopy;
511 }
512
516 virtual ~variant()
517 {
518 VariantClear(this);
519 }
520
524 variant& operator=(_In_ const VARIANT& varSrc)
525 {
526 if (this != &varSrc) {
527 const HRESULT hr = VariantCopy(this, &varSrc);
528 if (FAILED(hr))
529 throw winstd::com_runtime_error(hr, "VariantCopy failed");
530 }
531 return *this;
532 }
533
537 variant& operator=(_Inout_ VARIANT&& varSrc) noexcept
538 {
539 if (this != &varSrc) {
540 VariantClear(this);
541 memcpy(this, &varSrc, sizeof(VARIANT));
542 varSrc.vt = VT_EMPTY;
543 }
544 return *this;
545 }
546
550 variant& operator=(_In_ bool bSrc) noexcept
551 {
552 if (vt != VT_BOOL) {
553 VariantClear(this);
554 vt = VT_BOOL;
555 }
556 boolVal = bSrc ? VARIANT_TRUE : VARIANT_FALSE;
557 return *this;
558 }
559
563 variant& operator=(_In_ char cSrc) noexcept
564 {
565 if (vt != VT_I1) {
566 VariantClear(this);
567 vt = VT_I1;
568 }
569 cVal = cSrc;
570 return *this;
571 }
572
576 variant& operator=(_In_ unsigned char nSrc) noexcept
577 {
578 if (vt != VT_UI1) {
579 VariantClear(this);
580 vt = VT_UI1;
581 }
582 bVal = nSrc;
583 return *this;
584 }
585
589 variant& operator=(_In_ short nSrc) noexcept
590 {
591 if (vt != VT_I2) {
592 VariantClear(this);
593 vt = VT_I2;
594 }
595 iVal = nSrc;
596 return *this;
597 }
598
602 variant& operator=(_In_ unsigned short nSrc) noexcept
603 {
604 if (vt != VT_UI2) {
605 VariantClear(this);
606 vt = VT_UI2;
607 }
608 uiVal = nSrc;
609 return *this;
610 }
611
615 variant& operator=(_In_ int nSrc) noexcept
616 {
617 if (vt != VT_I4) {
618 VariantClear(this);
619 vt = VT_I4;
620 }
621 intVal = nSrc;
622 return *this;
623 }
624
628 variant& operator=(_In_ unsigned int nSrc) noexcept
629 {
630 if (vt != VT_UI4) {
631 VariantClear(this);
632 vt = VT_UI4;
633 }
634 uintVal= nSrc;
635 return *this;
636 }
637
641 variant& operator=(_In_ long nSrc) noexcept
642 {
643 if (vt != VT_I4) {
644 VariantClear(this);
645 vt = VT_I4;
646 }
647 lVal = nSrc;
648 return *this;
649 }
650
654 variant& operator=(_In_ unsigned long nSrc) noexcept
655 {
656 if (vt != VT_UI4) {
657 VariantClear(this);
658 vt = VT_UI4;
659 }
660 ulVal = nSrc;
661 return *this;
662 }
663
667 variant& operator=(_In_ long long nSrc) noexcept
668 {
669 if (vt != VT_I8) {
670 VariantClear(this);
671 vt = VT_I8;
672 }
673 llVal = nSrc;
674 return *this;
675 }
676
680 variant& operator=(_In_ unsigned long long nSrc) noexcept
681 {
682 if (vt != VT_UI8) {
683 VariantClear(this);
684 vt = VT_UI8;
685 }
686 ullVal = nSrc;
687
688 return *this;
689 }
690
694 variant& operator=(_In_ float fltSrc) noexcept
695 {
696 if (vt != VT_R4) {
697 VariantClear(this);
698 vt = VT_R4;
699 }
700 fltVal = fltSrc;
701 return *this;
702 }
703
707 variant& operator=(_In_ double dblSrc) noexcept
708 {
709 if (vt != VT_R8) {
710 VariantClear(this);
711 vt = VT_R8;
712 }
713 dblVal = dblSrc;
714 return *this;
715 }
716
720 variant& operator=(_In_ CY cySrc) noexcept
721 {
722 if (vt != VT_CY) {
723 VariantClear(this);
724 vt = VT_CY;
725 }
726 cyVal.Hi = cySrc.Hi;
727 cyVal.Lo = cySrc.Lo;
728 return *this;
729 }
730
734 variant& operator=(_In_z_ LPCOLESTR lpszSrc) noexcept
735 {
736 VariantClear(this);
737 vt = VT_BSTR;
738 bstrVal = SysAllocString(lpszSrc);
739 return *this;
740 }
741
745 variant& operator=(_Inout_opt_ IDispatch* pSrc)
746 {
747 VariantClear(this);
748 vt = VT_DISPATCH;
749 pdispVal = pSrc;
750 if (pdispVal != NULL)
751 pdispVal->AddRef();
752 return *this;
753 }
754
758 variant& operator=(_Inout_opt_ IUnknown* pSrc)
759 {
760 VariantClear(this);
761 vt = VT_UNKNOWN;
762 punkVal = pSrc;
763 if (punkVal != NULL)
764 punkVal->AddRef();
765 return *this;
766 }
767
771 variant& operator=(_In_ unsigned char* pbSrc) noexcept
772 {
773 if (vt != (VT_UI1|VT_BYREF)) {
774 VariantClear(this);
775 vt = VT_UI1|VT_BYREF;
776 }
777 pbVal = pbSrc;
778 return *this;
779 }
780
784 variant& operator=(_In_ short* pnSrc) noexcept
785 {
786 if (vt != (VT_I2|VT_BYREF)) {
787 VariantClear(this);
788 vt = VT_I2|VT_BYREF;
789 }
790 piVal = pnSrc;
791 return *this;
792 }
793
797 variant& operator=(_In_ unsigned short* pnSrc) noexcept
798 {
799 if (vt != (VT_UI2|VT_BYREF)) {
800 VariantClear(this);
801 vt = VT_UI2|VT_BYREF;
802 }
803 puiVal = pnSrc;
804 return *this;
805 }
806
810 variant& operator=(_In_ int* pnSrc) noexcept
811 {
812 if (vt != (VT_I4|VT_BYREF)) {
813 VariantClear(this);
814 vt = VT_I4|VT_BYREF;
815 }
816 pintVal = pnSrc;
817 return *this;
818 }
819
823 variant& operator=(_In_ unsigned int* pnSrc) noexcept
824 {
825 if (vt != (VT_UI4|VT_BYREF)) {
826 VariantClear(this);
827 vt = VT_UI4|VT_BYREF;
828 }
829 puintVal = pnSrc;
830 return *this;
831 }
832
836 variant& operator=(_In_ long* pnSrc) noexcept
837 {
838 if (vt != (VT_I4|VT_BYREF)) {
839 VariantClear(this);
840 vt = VT_I4|VT_BYREF;
841 }
842 plVal = pnSrc;
843 return *this;
844 }
845
849 variant& operator=(_In_ unsigned long* pnSrc) noexcept
850 {
851 if (vt != (VT_UI4|VT_BYREF)) {
852 VariantClear(this);
853 vt = VT_UI4|VT_BYREF;
854 }
855 pulVal = pnSrc;
856 return *this;
857 }
858
862 variant& operator=(_In_ long long* pnSrc) noexcept
863 {
864 if (vt != (VT_I8|VT_BYREF)) {
865 VariantClear(this);
866 vt = VT_I8|VT_BYREF;
867 }
868 pllVal = pnSrc;
869 return *this;
870 }
871
875 variant& operator=(_In_ unsigned long long* pnSrc) noexcept
876 {
877 if (vt != (VT_UI8|VT_BYREF)) {
878 VariantClear(this);
879 vt = VT_UI8|VT_BYREF;
880 }
881 pullVal = pnSrc;
882 return *this;
883 }
884
888 variant& operator=(_In_ float* pfSrc) noexcept
889 {
890 if (vt != (VT_R4|VT_BYREF)) {
891 VariantClear(this);
892 vt = VT_R4|VT_BYREF;
893 }
894 pfltVal = pfSrc;
895 return *this;
896 }
897
901 variant& operator=(_In_ double* pfSrc) noexcept
902 {
903 if (vt != (VT_R8|VT_BYREF)) {
904 VariantClear(this);
905 vt = VT_R8|VT_BYREF;
906 }
907 pdblVal = pfSrc;
908 return *this;
909 }
910
914 variant& operator=(_In_ const SAFEARRAY *pSrc)
915 {
916 assert(pSrc != NULL);
917 VariantClear(this);
918
919 LPSAFEARRAY pCopy;
920 const HRESULT hr = SafeArrayCopy(const_cast<LPSAFEARRAY>(pSrc), &pCopy);
921 if (SUCCEEDED(hr)) {
922 SafeArrayGetVartype(const_cast<LPSAFEARRAY>(pSrc), &vt);
923 vt |= VT_ARRAY;
924 parray = pCopy;
925 return *this;
926 }
927 throw com_runtime_error(hr, "SafeArrayCopy failed");
928 }
929
930 public:
939 bool operator==(_In_ const VARIANT& varSrc) const noexcept
940 {
941 if (vt == VT_NULL && varSrc.vt == VT_NULL) return true;
942 if (vt != varSrc.vt) return false;
943 return compare(static_cast<const VARIANT&>(*this), varSrc, LOCALE_USER_DEFAULT, 0) == static_cast<HRESULT>(VARCMP_EQ);
944 }
945
954 bool operator!=(_In_ const VARIANT& varSrc) const noexcept
955 {
956 return !operator==(varSrc);
957 }
958
967 bool operator<(_In_ const VARIANT& varSrc) const noexcept
968 {
969 if (vt == VT_NULL && varSrc.vt == VT_NULL) return false;
970 return compare(static_cast<const VARIANT&>(*this), varSrc, LOCALE_USER_DEFAULT, 0)== static_cast<HRESULT>(VARCMP_LT);
971 }
972
981 bool operator>(_In_ const VARIANT& varSrc) const noexcept
982 {
983 if (vt == VT_NULL && varSrc.vt == VT_NULL) return false;
984 return compare(static_cast<const VARIANT&>(*this), varSrc, LOCALE_USER_DEFAULT, 0)== static_cast<HRESULT>(VARCMP_GT);
985 }
986
995 bool operator<=(_In_ const VARIANT& varSrc) const noexcept
996 {
997 return !operator>(varSrc);
998 }
999
1008 bool operator>=(_In_ const VARIANT& varSrc) const noexcept
1009 {
1010 return !operator<(varSrc);
1011 }
1012
1018 HRESULT change_type(_In_ VARTYPE _vt, _In_opt_ USHORT wFlags = 0) noexcept
1019 {
1020 return VariantChangeType(this, this, wFlags, _vt);
1021 }
1022
1023 private:
1025 HRESULT compare(_In_ const VARIANT &varLeft, _In_ const VARIANT &varRight, _In_ LCID lcid, _In_ ULONG dwFlags) const noexcept
1026 {
1027 switch(vt) {
1028 case VT_I1: return varLeft.cVal == varRight.cVal ? VARCMP_EQ : varLeft.cVal > varRight.cVal ? VARCMP_GT : VARCMP_LT;
1029 case VT_UI2: return varLeft.uiVal == varRight.uiVal ? VARCMP_EQ : varLeft.uiVal > varRight.uiVal ? VARCMP_GT : VARCMP_LT;
1030 case VT_UI4: return varLeft.uintVal == varRight.uintVal ? VARCMP_EQ : varLeft.uintVal > varRight.uintVal ? VARCMP_GT : VARCMP_LT;
1031 case VT_UI8: return varLeft.ullVal == varRight.ullVal ? VARCMP_EQ : varLeft.ullVal > varRight.ullVal ? VARCMP_GT : VARCMP_LT;
1032 default: return VarCmp(const_cast<LPVARIANT>(&varLeft), const_cast<LPVARIANT>(&varRight), lcid, dwFlags);
1033 }
1034 }
1036 };
1037 #pragma warning(pop)
1038
1042 class safearray : public dplhandle<SAFEARRAY*, NULL>
1043 {
1044 WINSTD_DPLHANDLE_IMPL(safearray, SAFEARRAY*, NULL)
1045
1046 public:
1052 virtual ~safearray()
1053 {
1054 if (m_h != invalid)
1055 free_internal();
1056 }
1057
1058 protected:
1064 void free_internal() noexcept override
1065 {
1066 SafeArrayDestroy(m_h);
1067 }
1068
1079 {
1080 handle_type h_new;
1081 HRESULT hr = SafeArrayCopy(h, &h_new);
1082 if (SUCCEEDED(hr))
1083 return h_new;
1084 throw com_runtime_error(hr, "SafeArrayCopy failed");
1085 }
1086 };
1087
1091 template <class T>
1093 {
1096
1097 public:
1103 safearray_accessor(_In_ SAFEARRAY* psa) : m_sa(psa)
1104 {
1105 HRESULT hr = SafeArrayAccessData(psa, (void HUGEP**)&m_data);
1106 if (FAILED(hr))
1107 throw com_runtime_error(hr, "SafeArrayAccessData failed");
1108 }
1109
1116 {
1117 SafeArrayUnaccessData(m_sa);
1118 }
1119
1123 T HUGEP* data() const noexcept
1124 {
1125 return m_data;
1126 }
1127
1128 protected:
1129 SAFEARRAY* m_sa;
1130 T HUGEP* m_data;
1131 };
1132
1137 {
1140
1141 public:
1147 com_initializer(_In_opt_ LPVOID pvReserved)
1148 {
1149 HRESULT hr = CoInitialize(pvReserved);
1150 if (FAILED(hr))
1151 throw com_runtime_error(hr, "CoInitialize failed");
1152 }
1153
1159 com_initializer(_In_opt_ LPVOID pvReserved, _In_ DWORD dwCoInit)
1160 {
1161 HRESULT hr = CoInitializeEx(pvReserved, dwCoInit);
1162 if (FAILED(hr))
1163 throw com_runtime_error(hr, "CoInitializeEx failed");
1164 }
1165
1172 {
1173 CoUninitialize();
1174 }
1175 };
1176
1178}
1179
1182
1188template <class T>
1189static _Check_return_ HRESULT CoCreateInstance(_In_ REFCLSID rclsid, _In_opt_ LPUNKNOWN pUnkOuter, _In_ DWORD dwClsContext, _Inout_ winstd::com_obj<T> &v)
1190{
1191 T* ppv;
1192 HRESULT hr = CoCreateInstance(rclsid, pUnkOuter, dwClsContext, __uuidof(T), (LPVOID*)&ppv);
1193 if (SUCCEEDED(hr))
1194 v.attach(ppv);
1195 return hr;
1196}
1197
1203template <class T>
1204static _Check_return_ HRESULT CoGetObject(_In_ LPCWSTR pszName, _In_opt_ BIND_OPTS* pBindOptions, _In_ REFIID riid, _Inout_ winstd::com_obj<T>& v)
1205{
1206 T* ppv;
1207 HRESULT hr = CoGetObject(pszName, pBindOptions, riid, (LPVOID*)&ppv);
1208 if (SUCCEEDED(hr))
1209 v.attach(ppv);
1210 return hr;
1211}
1212
BSTR string wrapper.
Definition COM.h:198
bstr(LPCOLESTR src)
Constructs BSTR from OLE string.
Definition COM.h:205
handle_type duplicate_internal(handle_type h) const override
Duplicates the string.
Definition COM.h:277
virtual ~bstr()
Destroys the string.
Definition COM.h:241
void free_internal() noexcept override
Destroys the string.
Definition COM.h:263
UINT length() const noexcept
Returns the length of the string.
Definition COM.h:252
bstr(LPCOLESTR src, UINT len)
Constructs BSTR from OLE string with length.
Definition COM.h:215
bstr(const std::basic_string< OLECHAR, _Traits, _Ax > &src)
Constructs BSTR from std::basic_string.
Definition COM.h:226
Context scope automatic COM (un)initialization.
Definition COM.h:1137
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:1159
virtual ~com_initializer()
Uninitializes COM.
Definition COM.h:1171
com_initializer(LPVOID pvReserved)
Initializes the COM library on the current thread and identifies the concurrency model as single-thre...
Definition COM.h:1147
COM object wrapper template.
Definition COM.h:83
void free_internal() noexcept override
Releases the object by decrementing reference counter.
Definition COM.h:173
com_obj(REFCLSID rclsid, LPUNKNOWN pUnkOuter, DWORD dwClsContext)
Creates a new instance of a class.
Definition COM.h:92
HRESULT query_interface(_Other **h) const
Queries the object for another interface.
Definition COM.h:144
T * duplicate_internal(T *h) const override
Duplicates the object by incrementing the reference counter.
Definition COM.h:187
HRESULT query_interface(com_obj< _Other > &h) const
Queries the object for another interface.
Definition COM.h:157
virtual ~com_obj()
Releases object.
Definition COM.h:132
com_obj(_Other *other)
Queries the object for another interface and creates new class with it.
Definition COM.h:108
com_obj(com_obj< _Other > &other)
Queries the object for another interface and creates new class with it.
Definition COM.h:122
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:44
Base abstract template class to support object handle keeping for objects that support trivial handle...
Definition Common.h:1285
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:1274
Numerical runtime error.
Definition Common.h:1483
HRESULT error_type
Error number type.
Definition Common.h:1485
Context scope automatic SAFEARRAY (un)access.
Definition COM.h:1093
safearray_accessor(SAFEARRAY *psa)
Increments the lock count of an array, and retrieves a pointer to the array data.
Definition COM.h:1103
T HUGEP * data() const noexcept
Return SAFEARRAY data pointer.
Definition COM.h:1123
SAFEARRAY * m_sa
SAFEARRAY.
Definition COM.h:1129
virtual ~safearray_accessor()
Decrements the lock count of an array.
Definition COM.h:1115
T HUGEP * m_data
SAFEARRAY data.
Definition COM.h:1130
SAFEARRAY string wrapper.
Definition COM.h:1043
virtual ~safearray()
Destroys the array.
Definition COM.h:1052
handle_type duplicate_internal(handle_type h) const override
Duplicates the array.
Definition COM.h:1078
void free_internal() noexcept override
Destroys the array.
Definition COM.h:1064
VARIANT struct wrapper.
Definition COM.h:292
bool operator<=(const VARIANT &varSrc) const noexcept
Is variant less than or equal to?
Definition COM.h:995
variant(bool bSrc) noexcept
Constructs VARIANT from bool.
Definition COM.h:326
variant & operator=(unsigned int nSrc) noexcept
Copy from unsigned int value.
Definition COM.h:628
variant & operator=(unsigned long nSrc) noexcept
Copy from unsigned long value.
Definition COM.h:654
variant(float fltSrc) noexcept
Constructs VARIANT from float.
Definition COM.h:410
variant(VARIANT &&varSrc) noexcept
Moves VARIANT from another.
Definition COM.h:317
variant & operator=(float fltSrc) noexcept
Copy from float value.
Definition COM.h:694
variant & operator=(float *pfSrc) noexcept
Copy from float reference.
Definition COM.h:888
variant(IDispatch *pSrc)
Constructs VARIANT from IDispatch.
Definition COM.h:475
variant(int nSrc, VARTYPE vtSrc=VT_I4) noexcept
Constructs VARIANT from integer.
Definition COM.h:371
variant(const SAFEARRAY *pSrc)
Constructs VARIANT from SAFEARRAY.
Definition COM.h:499
variant & operator=(double *pfSrc) noexcept
Copy from double reference.
Definition COM.h:901
variant & operator=(const SAFEARRAY *pSrc)
Copy from SAFEARRAY.
Definition COM.h:914
variant & operator=(int *pnSrc) noexcept
Copy from int reference.
Definition COM.h:810
bool operator>(const VARIANT &varSrc) const noexcept
Is variant greater than?
Definition COM.h:981
variant & operator=(bool bSrc) noexcept
Copy from bool value.
Definition COM.h:550
variant & operator=(long nSrc) noexcept
Copy from long value.
Definition COM.h:641
HRESULT change_type(VARTYPE _vt, USHORT wFlags=0) noexcept
Converts a variant from one type to another.
Definition COM.h:1018
variant & operator=(IUnknown *pSrc)
Copy from IUnknown.
Definition COM.h:758
variant & operator=(short nSrc) noexcept
Copy from short value.
Definition COM.h:589
variant & operator=(unsigned char *pbSrc) noexcept
Copy from unsigned char reference.
Definition COM.h:771
variant & operator=(unsigned short nSrc) noexcept
Copy from unsigned short value.
Definition COM.h:602
variant & operator=(unsigned char nSrc) noexcept
Copy from unsigned char value.
Definition COM.h:576
variant & operator=(char cSrc) noexcept
Copy from char value.
Definition COM.h:563
variant(LPCOLESTR lpszSrc) noexcept
Constructs VARIANT from OLE string.
Definition COM.h:457
virtual ~variant()
Destroys VARIANT.
Definition COM.h:516
variant(const VARIANT &varSrc)
Constructs VARIANT from another.
Definition COM.h:305
variant(unsigned char nSrc) noexcept
Constructs VARIANT from byte.
Definition COM.h:344
variant & operator=(double dblSrc) noexcept
Copy from double value.
Definition COM.h:707
bool operator!=(const VARIANT &varSrc) const noexcept
Is variant not equal to?
Definition COM.h:954
variant & operator=(int nSrc) noexcept
Copy from int value.
Definition COM.h:615
variant(unsigned long nSrc) noexcept
Constructs VARIANT from unsigned long.
Definition COM.h:401
bool operator==(const VARIANT &varSrc) const noexcept
Is variant equal to?
Definition COM.h:939
variant(IUnknown *pSrc)
Constructs VARIANT from IUnknown.
Definition COM.h:487
variant(unsigned int nSrc, VARTYPE vtSrc=VT_UI4) noexcept
Constructs VARIANT from unsigned integer.
Definition COM.h:381
variant & operator=(CY cySrc) noexcept
Copy from CY value.
Definition COM.h:720
variant & operator=(LPCOLESTR lpszSrc) noexcept
Copy from OLE string value.
Definition COM.h:734
variant(long long nSrc) noexcept
Constructs VARIANT from 64-bit integer.
Definition COM.h:429
variant & operator=(unsigned int *pnSrc) noexcept
Copy from unsigned int reference.
Definition COM.h:823
variant(long nSrc, VARTYPE vtSrc=VT_I4) noexcept
Constructs VARIANT from long.
Definition COM.h:391
variant & operator=(long *pnSrc) noexcept
Copy from long reference.
Definition COM.h:836
variant(unsigned short nSrc) noexcept
Constructs VARIANT from unsigned short.
Definition COM.h:362
bool operator>=(const VARIANT &varSrc) const noexcept
Is variant greater than or equal to?
Definition COM.h:1008
variant & operator=(short *pnSrc) noexcept
Copy from short reference.
Definition COM.h:784
variant() noexcept
Constructs blank VARIANT.
Definition COM.h:297
bool operator<(const VARIANT &varSrc) const noexcept
Is variant less than?
Definition COM.h:967
variant(unsigned long long nSrc) noexcept
Constructs VARIANT from unsigned integer.
Definition COM.h:438
variant(char cSrc) noexcept
Constructs VARIANT from character.
Definition COM.h:335
variant & operator=(unsigned short *pnSrc) noexcept
Copy from unsigned short reference.
Definition COM.h:797
variant & operator=(long long *pnSrc) noexcept
Copy from long long reference.
Definition COM.h:862
variant(BSTR bstr) noexcept
Constructs VARIANT from BSTR.
Definition COM.h:466
variant & operator=(unsigned long long *pnSrc) noexcept
Copy from unsigned long long reference.
Definition COM.h:875
variant(double dblSrc, VARTYPE vtSrc=VT_R8) noexcept
Constructs VARIANT from double or variant date.
Definition COM.h:419
variant(short nSrc) noexcept
Constructs VARIANT from short.
Definition COM.h:353
variant(CY cySrc) noexcept
Constructs VARIANT from CY (64-bit integer)
Definition COM.h:447
variant & operator=(unsigned long long nSrc) noexcept
Copy from unsigned long long value.
Definition COM.h:680
variant & operator=(VARIANT &&varSrc) noexcept
Moves from another VARIANT.
Definition COM.h:537
variant & operator=(long long nSrc) noexcept
Copy from long long value.
Definition COM.h:667
variant & operator=(IDispatch *pSrc)
Copy from IDispatch.
Definition COM.h:745
variant & operator=(unsigned long *pnSrc) noexcept
Copy from unsigned long reference.
Definition COM.h:849
variant & operator=(const VARIANT &varSrc)
Copy from another VARIANT.
Definition COM.h:524
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:1204
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:1189
#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:58
void operator()(_T *_Ptr) const
Delete a pointer.
Definition COM.h:70
CoTaskMemFree_delete() noexcept
Default constructor.
Definition COM.h:62