cppu/source/AffineBridge/AffineBridge.cxx

   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
  21 #include <osl/thread.hxx>
  22 #include <osl/conditn.hxx>
  23 #include <osl/mutex.hxx>
  24 #include <osl/diagnose.h>
  25 #include <sal/log.hxx>
  26
  27 #include <cppu/Enterable.hxx>
  28 #include <cppu/helper/purpenv/Environment.hxx>
  29 #include <cppu/helper/purpenv/Mapping.hxx>
  30 #include <memory>
  31
  32 namespace {
  33
  34 class InnerThread;
  35 class OuterThread;
  36
  37 class AffineBridge : public cppu::Enterable
  38 {
  39 public:
  40     enum Msg
  41     {
  42         CB_DONE,
  43         CB_FPOINTER
  44     };
  45
  46     Msg                   m_message;
  47     uno_EnvCallee       * m_pCallee;
  48     va_list             * m_pParam;
  49
  50     osl::Mutex            m_innerMutex;
  51     oslThreadIdentifier   m_innerThreadId;
  52     std::unique_ptr<InnerThread> m_pInnerThread;
  53     osl::Condition        m_innerCondition;
  54     sal_Int32             m_enterCount;
  55
  56     osl::Mutex            m_outerMutex;
  57     oslThreadIdentifier   m_outerThreadId;
  58     osl::Condition        m_outerCondition;
  59     std::unique_ptr<OuterThread> m_pOuterThread;
  60
  61     explicit  AffineBridge();
  62     virtual  ~AffineBridge() override;
  63
  64     virtual void  v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam) override;
  65     virtual void  v_callOut_v (uno_EnvCallee * pCallee, va_list * pParam) override;
  66
  67     virtual void  v_enter() override;
  68     virtual void  v_leave() override;
  69
  70     virtual bool v_isValid(OUString * pReason) override;
  71
  72     void innerDispatch();
  73     void outerDispatch(bool loop);
  74 };
  75
  76 class InnerThread : public osl::Thread
  77 {
  78     virtual void SAL_CALL run() override;
  79
  80     AffineBridge * m_pAffineBridge;
  81
  82 public:
  83     explicit InnerThread(AffineBridge * threadEnvironment)
  84         : m_pAffineBridge(threadEnvironment)
  85         {
  86             create();
  87         }
  88 };
  89
  90 }
  91
  92 void InnerThread::run()
  93 {
  94     osl_setThreadName("UNO AffineBridge InnerThread");
  95
  96     m_pAffineBridge->enter();
  97     m_pAffineBridge->innerDispatch();
  98     m_pAffineBridge->leave();
  99 }
 100
 101 namespace {
 102
 103 class OuterThread : public osl::Thread
 104 {
 105     virtual void SAL_CALL run() override;
 106
 107     AffineBridge * m_pAffineBridge;
 108
 109 public:
 110     explicit OuterThread(AffineBridge * threadEnvironment);
 111 };
 112
 113 }
 114
 115 OuterThread::OuterThread(AffineBridge * threadEnvironment)
 116     : m_pAffineBridge(threadEnvironment)
 117 {
 118     create();
 119 }
 120
 121 void OuterThread::run()
 122 {
 123     osl_setThreadName("UNO AffineBridge OuterThread");
 124
 125     osl::MutexGuard guard(m_pAffineBridge->m_outerMutex);
 126
 127     m_pAffineBridge->m_outerThreadId = getIdentifier();
 128     m_pAffineBridge->outerDispatch(false);
 129     m_pAffineBridge->m_outerThreadId = 0;
 130
 131     m_pAffineBridge->m_pOuterThread = nullptr;
 132     m_pAffineBridge = nullptr;
 133 }
 134
 135
 136 AffineBridge::AffineBridge()
 137     : m_message      (CB_DONE),
 138       m_pCallee      (nullptr),
 139       m_pParam       (nullptr),
 140       m_innerThreadId(0),
 141       m_enterCount   (0),
 142       m_outerThreadId(0)
 143 {
 144     SAL_INFO("cppu.affinebridge", "LIFE: AffineBridge::AffineBridge(uno_Environment * pEnv) -> " << this);
 145 }
 146
 147 AffineBridge::~AffineBridge()
 148 {
 149     SAL_INFO("cppu.affinebridge", "LIFE: AffineBridge::~AffineBridge() -> " << this);
 150
 151     if (m_pInnerThread && osl::Thread::getCurrentIdentifier() != m_innerThreadId)
 152     {
 153         m_message = CB_DONE;
 154         m_innerCondition.set();
 155
 156         m_pInnerThread->join();
 157     }
 158
 159     m_pInnerThread.reset();
 160
 161     if (m_pOuterThread)
 162     {
 163         m_pOuterThread->join();
 164     }
 165 }
 166
 167
 168 void AffineBridge::outerDispatch(bool loop)
 169 {
 170     OSL_ASSERT(m_outerThreadId == osl::Thread::getCurrentIdentifier());
 171     OSL_ASSERT(m_innerThreadId != m_outerThreadId);
 172
 173     Msg mm;
 174
 175     do
 176     {
 177         // FIXME: created outer thread must not wait
 178         // in case of no message
 179         // note: no message can happen in case newly created
 180         // outer thread acquire outerMutex after a real outer
 181         // thread enters outerDispatch!
 182         m_outerCondition.wait();
 183         m_outerCondition.reset();
 184
 185         mm = m_message;
 186
 187         switch(mm)
 188         {
 189         case CB_DONE:
 190             break;
 191
 192         case CB_FPOINTER:
 193         {
 194             m_pCallee(m_pParam);
 195
 196             m_message = CB_DONE;
 197             m_innerCondition.set();
 198             break;
 199         }
 200         default:
 201             abort();
 202         }
 203     }
 204     while(mm != CB_DONE && loop);
 205 }
 206
 207 void AffineBridge::innerDispatch()
 208 {
 209     OSL_ASSERT(m_innerThreadId == osl::Thread::getCurrentIdentifier());
 210     OSL_ASSERT(m_innerThreadId != m_outerThreadId);
 211
 212     Msg mm;
 213
 214     do
 215     {
 216         m_innerCondition.wait();
 217         m_innerCondition.reset();
 218
 219         mm = m_message;
 220
 221         switch(mm)
 222         {
 223         case CB_DONE:
 224             break;
 225
 226         case CB_FPOINTER:
 227         {
 228             m_pCallee(m_pParam);
 229
 230             m_message = CB_DONE;
 231             m_outerCondition.set();
 232             break;
 233         }
 234         default:
 235             abort();
 236         }
 237     }
 238     while(mm != CB_DONE);
 239 }
 240
 241 void AffineBridge::v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam)
 242 {
 243     osl::MutexGuard guard(m_outerMutex); // only one thread at a time can call into
 244
 245     if (m_innerThreadId == 0) // no inner thread yet
 246     {
 247         m_pInnerThread.reset(new InnerThread(this));
 248         m_pInnerThread->resume();
 249     }
 250
 251     bool bResetId = false;
 252     if (!m_outerThreadId)
 253     {
 254         m_outerThreadId = osl::Thread::getCurrentIdentifier();
 255         bResetId = true;
 256     }
 257
 258     m_message = CB_FPOINTER;
 259     m_pCallee = pCallee;
 260     m_pParam  = pParam;
 261     m_innerCondition.set();
 262
 263     outerDispatch(true);
 264
 265     if (bResetId)
 266         m_outerThreadId = 0;
 267 }
 268
 269 void AffineBridge::v_callOut_v(uno_EnvCallee * pCallee, va_list * pParam)
 270 {
 271     OSL_ASSERT(m_innerThreadId);
 272
 273     osl::MutexGuard guard(m_innerMutex);
 274
 275     if (m_outerThreadId == 0) // no outer thread yet
 276     {
 277         osl::MutexGuard guard_m_outerMutex(m_outerMutex);
 278
 279         if (m_outerThreadId == 0)
 280         {
 281             if (m_pOuterThread)
 282             {
 283                 m_pOuterThread->join();
 284             }
 285
 286             m_pOuterThread.reset(new OuterThread(this));
 287         }
 288     }
 289
 290     m_message = CB_FPOINTER;
 291     m_pCallee = pCallee;
 292     m_pParam  = pParam;
 293     m_outerCondition.set();
 294
 295     innerDispatch();
 296 }
 297
 298 void AffineBridge::v_enter()
 299 {
 300     m_innerMutex.acquire();
 301
 302     if (!m_enterCount)
 303         m_innerThreadId = osl::Thread::getCurrentIdentifier();
 304
 305     OSL_ASSERT(m_innerThreadId == osl::Thread::getCurrentIdentifier());
 306
 307     ++ m_enterCount;
 308 }
 309
 310 void AffineBridge::v_leave()
 311 {
 312     OSL_ASSERT(m_innerThreadId == osl::Thread::getCurrentIdentifier());
 313
 314     -- m_enterCount;
 315     if (!m_enterCount)
 316         m_innerThreadId = 0;
 317
 318     m_innerMutex.release();
 319 }
 320
 321 bool AffineBridge::v_isValid(OUString * pReason)
 322 {
 323     bool result = m_enterCount > 0;
 324     if (!result)
 325         *pReason = "not entered";
 326
 327     else
 328     {
 329         result = m_innerThreadId == osl::Thread::getCurrentIdentifier();
 330
 331         if (!result)
 332             *pReason = "wrong thread";
 333     }
 334
 335     if (result)
 336         *pReason = "OK";
 337
 338     return result;
 339 }
 340
 341 #ifdef DISABLE_DYNLOADING
 342
 343 #define uno_initEnvironment affine_uno_uno_initEnvironment
 344 #define uno_ext_getMapping affine_uno_uno_ext_getMapping
 345
 346 #endif
 347
 348 extern "C" void SAL_DLLPUBLIC_EXPORT uno_initEnvironment(uno_Environment * pEnv)
 349     SAL_THROW_EXTERN_C()
 350 {
 351     cppu::helper::purpenv::Environment_initWithEnterable(pEnv, new AffineBridge());
 352 }
 353
 354 extern "C" void SAL_DLLPUBLIC_EXPORT uno_ext_getMapping(uno_Mapping     ** ppMapping,
 355                                                         uno_Environment  * pFrom,
 356                                                         uno_Environment  * pTo )
 357 {
 358     cppu::helper::purpenv::createMapping(ppMapping, pFrom, pTo);
 359 }
 360
 361 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */