include/systools/win32/comtools.hxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #ifndef INCLUDED_SYSTOOLS_WIN32_COMTOOLS_HXX
  21 #define INCLUDED_SYSTOOLS_WIN32_COMTOOLS_HXX
  22
  23 #include <string>
  24 #include <stdexcept>
  25 #include <objbase.h>
  26
  27 namespace sal
  28 {
  29 namespace systools
  30 {
  31     typedef int HRESULT;
  32
  33     /* Simple exception class for propagating COM errors */
  34     class ComError : public std::runtime_error
  35     {
  36     public:
  37         ComError(const std::string& message, HRESULT hr) :
  38             std::runtime_error(message),
  39             hr_(hr)
  40         {}
  41
  42         HRESULT GetHresult() const
  43         {
  44             return hr_;
  45         }
  46
  47     private:
  48         HRESULT hr_;
  49     };
  50
  51     /* A simple COM smart pointer template */
  52     template <typename T>
  53     class COMReference
  54     {
  55     public:
  56         COMReference() :
  57             com_ptr_(NULL)
  58         {
  59         }
  60
  61         explicit COMReference(T* comptr) :
  62             com_ptr_(comptr)
  63         {
  64             addRef();
  65         }
  66
  67         /* Explicitly controllable whether AddRef will be called or not */
  68         COMReference(T* comptr, bool bAddRef) :
  69             com_ptr_(comptr)
  70         {
  71             if (bAddRef)
  72                 addRef();
  73         }
  74
  75         COMReference(const COMReference<T>& other) :
  76             com_ptr_(other.com_ptr_)
  77         {
  78             addRef();
  79         }
  80
  81         COMReference<T>& operator=(const COMReference<T>& other)
  82         {
  83             if (other.com_ptr_)
  84                 other.com_ptr_->AddRef();
  85             release();
  86             com_ptr_ = other.com_ptr_;
  87             return *this;
  88         }
  89
  90         COMReference<T>& operator=(T* comptr)
  91         {
  92             release();
  93             com_ptr_ = comptr;
  94             addRef();
  95             return *this;
  96         }
  97
  98         ~COMReference()
  99         {
 100             release();
 101         }
 102
 103         template<typename InterfaceType>
 104         COMReference<InterfaceType> QueryInterface(REFIID iid)
 105         {
 106             COMReference<InterfaceType> ip;
 107             HRESULT hr = E_FAIL;
 108             if (com_ptr_)
 109                 hr = com_ptr_->QueryInterface(iid, reinterpret_cast<LPVOID*>(&ip));
 110
 111             if (FAILED(hr))
 112                 throw ComError("QueryInterface failed: Interface not supported!", hr);
 113
 114             return ip;
 115         }
 116
 117         T* operator->() const
 118         {
 119             return com_ptr_;
 120         }
 121
 122         T& operator*() const
 123         {
 124             return *com_ptr_;
 125         }
 126
 127         /* Necessary for assigning com_ptr_ from functions like
 128            CoCreateInstance which require a 'void**' */
 129         T** operator&()
 130         {
 131             release();
 132             com_ptr_ = NULL;
 133             return &com_ptr_;
 134         }
 135
 136         T* get() const
 137         {
 138             return com_ptr_;
 139         }
 140
 141         COMReference<T>& clear()
 142         {
 143             release();
 144             com_ptr_ = NULL;
 145             return *this;
 146         }
 147
 148         bool is() const
 149         {
 150             return (com_ptr_ != NULL);
 151         }
 152
 153     private:
 154         ULONG addRef()
 155         {
 156             ULONG cnt = 0;
 157             if (com_ptr_)
 158                 cnt = com_ptr_->AddRef();
 159             return cnt;
 160         }
 161
 162         ULONG release()
 163         {
 164             ULONG cnt = 0;
 165             if (com_ptr_)
 166                 cnt = com_ptr_->Release();
 167             return cnt;
 168         }
 169
 170     private:
 171         T* com_ptr_;
 172     };
 173
 174 } // systools
 175 } // sal
 176
 177 /* Typedefs for some popular COM interfaces */
 178 typedef sal::systools::COMReference<IDataObject> IDataObjectPtr;
 179 typedef sal::systools::COMReference<IStream> IStreamPtr;
 180
 181 #endif // INCLUDED_SYSTOOLS_WIN32_COMTOOLS_HXX
 182
 183 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */