summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty
diff options
context:
space:
mode:
author Brad Hughes <bradhugh@outlook.com>2016-03-19 21:43:27 -0400
committer Brad Hughes <bradhugh@outlook.com>2016-03-19 21:43:27 -0400
commit9328fa902887c15a58c95bfdf69cfa28e9a012c2 (patch)
tree7a7e9943c870c6a2abfcb721914d292ad3d23ff3 /3rdparty
parent5410d5a40a8a0ceec9cdc726087cc6e5f07f5660 (diff)
Fix VS Build issue for WRL ComPtr
Diffstat (limited to '3rdparty')
-rw-r--r--3rdparty/compat/winsdk-override/wrl/client.h308
1 files changed, 308 insertions, 0 deletions
diff --git a/3rdparty/compat/winsdk-override/wrl/client.h b/3rdparty/compat/winsdk-override/wrl/client.h
new file mode 100644
index 00000000000..5e3e0c35fb1
--- /dev/null
+++ b/3rdparty/compat/winsdk-override/wrl/client.h
@@ -0,0 +1,308 @@
+/**
+ * This file has no copyright assigned and is placed in the Public Domain.
+ * This file is part of the mingw-w64 runtime package.
+ * No warranty is given; refer to the file DISCLAIMER.PD within this package.
+ */
+
+#ifndef _WRL_CLIENT_H_
+#define _WRL_CLIENT_H_
+
+#include <stddef.h>
+#include <unknwn.h>
+/* #include <weakreference.h> */
+#include <roapi.h>
+
+/* #include <wrl/def.h> */
+#include <wrl/internal.h>
+
+namespace Microsoft {
+ namespace WRL {
+ namespace Details {
+ template <typename T> class ComPtrRefBase {
+ protected:
+ T* ptr_;
+
+ public:
+ typedef typename T::InterfaceType InterfaceType;
+
+#ifndef __WRL_CLASSIC_COM__
+ operator IInspectable**() const throw() {
+ static_assert(__is_base_of(IInspectable, InterfaceType), "Invalid cast");
+ return reinterpret_cast<IInspectable**>(ptr_->ReleaseAndGetAddressOf());
+ }
+#endif
+
+ operator IUnknown**() const throw() {
+ static_assert(__is_base_of(IUnknown, InterfaceType), "Invalid cast");
+ return reinterpret_cast<IUnknown**>(ptr_->ReleaseAndGetAddressOf());
+ }
+ };
+
+ template <typename T> class ComPtrRef : public Details::ComPtrRefBase<T> {
+ public:
+ ComPtrRef(T *ptr) throw() {
+ ComPtrRefBase<T>::ptr_ = ptr;
+ }
+
+ operator void**() const throw() {
+ return reinterpret_cast<void**>(ComPtrRefBase<T>::ptr_->ReleaseAndGetAddressOf());
+ }
+
+ operator T*() throw() {
+ *ComPtrRefBase<T>::ptr_ = nullptr;
+ return ComPtrRefBase<T>::ptr_;
+ }
+
+ operator typename ComPtrRefBase<T>::InterfaceType**() throw() {
+ return ComPtrRefBase<T>::ptr_->ReleaseAndGetAddressOf();
+ }
+
+ typename ComPtrRefBase<T>::InterfaceType *operator*() throw() {
+ return ComPtrRefBase<T>::ptr_->Get();
+ }
+
+ typename ComPtrRefBase<T>::InterfaceType *const *GetAddressOf() const throw() {
+ return ComPtrRefBase<T>::ptr_->GetAddressOf();
+ }
+
+ typename ComPtrRefBase<T>::InterfaceType **ReleaseAndGetAddressOf() throw() {
+ return ComPtrRefBase<T>::ptr_->ReleaseAndGetAddressOf();
+ }
+ };
+
+ }
+
+ template<typename T> class ComPtr {
+ public:
+ typedef T InterfaceType;
+
+ ComPtr() throw() : ptr_(nullptr) {}
+ ComPtr(decltype(nullptr)) throw() : ptr_(nullptr) {}
+
+ template<class U> ComPtr(U *other) throw() : ptr_(other.ptr_) {
+ InternalAddRef();
+ }
+
+ ComPtr(const ComPtr &other) throw() : ptr_(other.ptr_) {
+ InternalAddRef();
+ }
+
+ template<class U>
+ ComPtr(const ComPtr<U> &other) throw() : ptr_(other.ptr_) {
+ InternalAddRef();
+ }
+
+ ComPtr(ComPtr &&other) throw() : ptr_(nullptr) {
+ if(this != reinterpret_cast<ComPtr*>(&reinterpret_cast<unsigned char&>(other)))
+ Swap(other);
+ }
+
+ template<class U>
+ ComPtr(ComPtr<U>&& other) throw() : ptr_(other.ptr_) {
+ other.ptr_ = nullptr;
+ }
+
+ ~ComPtr() throw() {
+ InternalRelease();
+ }
+
+ ComPtr &operator=(decltype(nullptr)) throw() {
+ InternalRelease();
+ return *this;
+ }
+
+ ComPtr &operator=(InterfaceType *other) throw() {
+ if (ptr_ != other) {
+ InternalRelease();
+ ptr_ = other;
+ InternalAddRef();
+ }
+ return *this;
+ }
+
+ template<typename U>
+ ComPtr &operator=(U *other) throw() {
+ if (ptr_ != other) {
+ InternalRelease();
+ ptr_ = other;
+ InternalAddRef();
+ }
+ return *this;
+ }
+
+ ComPtr& operator=(const ComPtr &other) throw() {
+ if (ptr_ != other.ptr_)
+ ComPtr(other).Swap(*this);
+ return *this;
+ }
+
+ template<class U>
+ ComPtr &operator=(const ComPtr<U> &other) throw() {
+ ComPtr(other).Swap(*this);
+ return *this;
+ }
+
+ ComPtr& operator=(ComPtr &&other) throw() {
+ ComPtr(other).Swap(*this);
+ return *this;
+ }
+
+ template<class U>
+ ComPtr& operator=(ComPtr<U> &&other) throw() {
+ ComPtr(other).Swap(*this);
+ return *this;
+ }
+
+ void Swap(ComPtr &&r) throw() {
+ InterfaceType *tmp = ptr_;
+ ptr_ = r.ptr_;
+ r.ptr_ = tmp;
+ }
+
+ void Swap(ComPtr &r) throw() {
+ InterfaceType *tmp = ptr_;
+ ptr_ = r.ptr_;
+ r.ptr_ = tmp;
+ }
+
+ operator Details::BoolType() const throw() {
+ return Get() != nullptr ? &Details::BoolStruct::Member : nullptr;
+ }
+
+ InterfaceType *Get() const throw() {
+ return ptr_;
+ }
+
+ InterfaceType *operator->() const throw() {
+ return ptr_;
+ }
+
+ Details::ComPtrRef<ComPtr<T>> operator&() throw() {
+ return Details::ComPtrRef<ComPtr<T>>(this);
+ }
+
+ const Details::ComPtrRef<const ComPtr<T>> operator&() const throw() {
+ return Details::ComPtrRef<const ComPtr<T>>(this);
+ }
+
+ InterfaceType *const *GetAddressOf() const throw() {
+ return &ptr_;
+ }
+
+ InterfaceType **GetAddressOf() throw() {
+ return &ptr_;
+ }
+
+ InterfaceType **ReleaseAndGetAddressOf() throw() {
+ InternalRelease();
+ return &ptr_;
+ }
+
+ InterfaceType *Detach() throw() {
+ T* ptr = ptr_;
+ ptr_ = nullptr;
+ return ptr;
+ }
+
+ void Attach(InterfaceType *other) throw() {
+ if (ptr_ != other) {
+ InternalRelease();
+ ptr_ = other;
+ InternalAddRef();
+ }
+ }
+
+ unsigned long Reset() {
+ return InternalRelease();
+ }
+
+ HRESULT CopyTo(InterfaceType **ptr) const throw() {
+ InternalAddRef();
+ *ptr = ptr_;
+ return S_OK;
+ }
+
+ HRESULT CopyTo(REFIID riid, void **ptr) const throw() {
+ return ptr_->QueryInterface(riid, ptr);
+ }
+
+ template<typename U>
+ HRESULT CopyTo(U **ptr) const throw() {
+ return ptr_->QueryInterface(__uuidof(U), reinterpret_cast<void**>(ptr));
+ }
+
+ template<typename U>
+ HRESULT As(Details::ComPtrRef<ComPtr<U>> p) const throw() {
+ return ptr_->QueryInterface(__uuidof(U), p);
+ }
+
+ template<typename U>
+ HRESULT As(ComPtr<U> *p) const throw() {
+ return ptr_->QueryInterface(__uuidof(U), reinterpret_cast<void**>(p->ReleaseAndGetAddressOf()));
+ }
+
+ HRESULT AsIID(REFIID riid, ComPtr<IUnknown> *p) const throw() {
+ return ptr_->QueryInterface(riid, reinterpret_cast<void**>(p->ReleaseAndGetAddressOf()));
+ }
+
+ /*
+ HRESULT AsWeak(WeakRef *pWeakRef) const throw() {
+ return ::Microsoft::WRL::AsWeak(ptr_, pWeakRef);
+ }
+ */
+ protected:
+ InterfaceType *ptr_;
+
+ void InternalAddRef() const throw() {
+ if(ptr_)
+ ptr_->AddRef();
+ }
+
+ unsigned long InternalRelease() throw() {
+ InterfaceType *tmp = ptr_;
+ if(!tmp)
+ return 0;
+ ptr_ = nullptr;
+ return tmp->Release();
+ }
+ };
+ }
+}
+
+template<typename T>
+void **IID_PPV_ARGS_Helper(::Microsoft::WRL::Details::ComPtrRef<T> pp) throw() {
+ static_assert(__is_base_of(IUnknown, typename T::InterfaceType), "Expected COM interface");
+ return pp;
+}
+
+namespace Windows {
+ namespace Foundation {
+ template<typename T>
+ inline HRESULT ActivateInstance(HSTRING classid, ::Microsoft::WRL::Details::ComPtrRef<T> instance) throw() {
+ return ActivateInstance(classid, instance.ReleaseAndGetAddressOf());
+ }
+
+ template<typename T>
+ inline HRESULT GetActivationFactory(HSTRING classid, ::Microsoft::WRL::Details::ComPtrRef<T> factory) throw() {
+ return RoGetActivationFactory(classid, IID_INS_ARGS(factory.ReleaseAndGetAddressOf()));
+ }
+ }
+}
+
+namespace ABI {
+ namespace Windows {
+ namespace Foundation {
+ template<typename T>
+ inline HRESULT ActivateInstance(HSTRING classid, ::Microsoft::WRL::Details::ComPtrRef<T> instance) throw() {
+ return ActivateInstance(classid, instance.ReleaseAndGetAddressOf());
+ }
+
+ template<typename T>
+ inline HRESULT GetActivationFactory(HSTRING classid, ::Microsoft::WRL::Details::ComPtrRef<T> factory) throw() {
+ return RoGetActivationFactory(classid, IID_INS_ARGS(factory.ReleaseAndGetAddressOf()));
+ }
+ }
+ }
+}
+
+#endif