cppu/source/AffineBridge/AffineBridge.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: AffineBridge.cxx,v $
  10  * $Revision: 1.5 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_cppu.hxx"
  33
  34 #include "osl/thread.hxx"
  35 #include "osl/conditn.hxx"
  36 #include "osl/mutex.hxx"
  37
  38 #include "cppu/helper/purpenv/Environment.hxx"
  39 #include "cppu/helper/purpenv/Mapping.hxx"
  40
  41
  42 #ifdef debug
  43 # define LOG_LIFECYCLE_AffineBridge
  44 #endif
  45
  46 #ifdef LOG_LIFECYCLE_AffineBridge
  47 #  include <iostream>
  48 #  define LOG_LIFECYCLE_AffineBridge_emit(x) x
  49
  50 #else
  51 #  define LOG_LIFECYCLE_AffineBridge_emit(x)
  52
  53 #endif
  54
  55 class InnerThread;
  56 class OuterThread;
  57
  58 class SAL_DLLPRIVATE AffineBridge : public cppu::Enterable
  59 {
  60 public:
  61     enum Msg
  62     {
  63         CB_DONE,
  64         CB_FPOINTER
  65     };
  66
  67     Msg                   m_message;
  68     uno_EnvCallee       * m_pCallee;
  69     va_list             * m_pParam;
  70
  71     osl::Mutex            m_innerMutex;
  72     oslThreadIdentifier   m_innerThreadId;
  73     InnerThread         * m_pInnerThread;
  74     osl::Condition        m_innerCondition;
  75     sal_Int32             m_enterCount;
  76
  77     osl::Mutex            m_outerMutex;
  78     oslThreadIdentifier   m_outerThreadId;
  79     osl::Condition        m_outerCondition;
  80     OuterThread         * m_pOuterThread;
  81
  82     explicit  AffineBridge(void);
  83     virtual  ~AffineBridge(void);
  84
  85     virtual void  v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam);
  86     virtual void  v_callOut_v (uno_EnvCallee * pCallee, va_list * pParam);
  87
  88     virtual void  v_enter(void);
  89     virtual void  v_leave(void);
  90
  91     virtual int  v_isValid(rtl::OUString * pReason);
  92
  93     void innerDispatch(void);
  94     void outerDispatch(int loop);
  95 };
  96
  97 class SAL_DLLPRIVATE InnerThread : public osl::Thread
  98 {
  99     virtual void SAL_CALL run(void);
 100
 101     AffineBridge * m_pAffineBridge;
 102
 103 public:
 104     InnerThread(AffineBridge * threadEnvironment)
 105         : m_pAffineBridge(threadEnvironment)
 106         {
 107             create();
 108         }
 109 };
 110
 111 void InnerThread::run(void)
 112 {
 113     m_pAffineBridge->enter();
 114     m_pAffineBridge->innerDispatch();
 115     m_pAffineBridge->leave();
 116 }
 117
 118 class SAL_DLLPRIVATE OuterThread : public osl::Thread
 119 {
 120     virtual void SAL_CALL run(void);
 121
 122     AffineBridge * m_pAffineBridge;
 123
 124 public:
 125     OuterThread(AffineBridge * threadEnvironment);
 126 };
 127
 128 OuterThread::OuterThread(AffineBridge * threadEnvironment)
 129     : m_pAffineBridge(threadEnvironment)
 130 {
 131     create();
 132 }
 133
 134 void OuterThread::run(void)
 135 {
 136     osl::MutexGuard guard(m_pAffineBridge->m_outerMutex);
 137
 138     m_pAffineBridge->m_outerThreadId = getIdentifier();
 139     m_pAffineBridge->outerDispatch(0);
 140     m_pAffineBridge->m_outerThreadId = 0;
 141
 142     m_pAffineBridge->m_pOuterThread = NULL;
 143     m_pAffineBridge = NULL;
 144 }
 145
 146
 147 AffineBridge::AffineBridge(void)
 148     : m_innerThreadId(0),
 149       m_pInnerThread (NULL),
 150       m_enterCount   (0),
 151       m_outerThreadId(0),
 152       m_pOuterThread (NULL)
 153 {
 154     LOG_LIFECYCLE_AffineBridge_emit(fprintf(stderr, "LIFE: %s -> %p\n", "AffineBridge::AffineBridge(uno_Environment * pEnv)", this));
 155 }
 156
 157 AffineBridge::~AffineBridge(void)
 158 {
 159     LOG_LIFECYCLE_AffineBridge_emit(fprintf(stderr, "LIFE: %s -> %p\n", "AffineBridge::~AffineBridge(void)", this));
 160
 161     if (m_pInnerThread && osl_getThreadIdentifier(NULL) != m_innerThreadId)
 162     {
 163         m_message = CB_DONE;
 164         m_innerCondition.set();
 165
 166         m_pInnerThread->join();
 167     }
 168
 169     delete m_pInnerThread;
 170
 171     if (m_pOuterThread)
 172     {
 173         m_pOuterThread->join();
 174         delete m_pOuterThread;
 175     }
 176 }
 177
 178
 179 void AffineBridge::outerDispatch(int loop)
 180 {
 181     OSL_ASSERT(m_outerThreadId == osl_getThreadIdentifier(NULL));
 182     OSL_ASSERT(m_innerThreadId != m_outerThreadId);
 183
 184     Msg mm;
 185
 186     do
 187     {
 188         // FIXME: created outer thread must not wait
 189         // in case of no message
 190         // note: no message can happen in case newly created
 191         // outer thread acquire outerMutex after a real outer
 192         // thread enters outerDispatch!
 193         m_outerCondition.wait();
 194         m_outerCondition.reset();
 195
 196         mm = m_message;
 197
 198         switch(mm)
 199         {
 200         case CB_DONE:
 201             break;
 202
 203         case CB_FPOINTER:
 204         {
 205             m_pCallee(m_pParam);
 206
 207             m_message = CB_DONE;
 208             m_innerCondition.set();
 209             break;
 210         }
 211         default:
 212             abort();
 213         }
 214     }
 215     while(mm != CB_DONE && loop);
 216 }
 217
 218 void AffineBridge::innerDispatch(void)
 219 {
 220     OSL_ASSERT(m_innerThreadId == osl_getThreadIdentifier(NULL));
 221     OSL_ASSERT(m_innerThreadId != m_outerThreadId);
 222
 223     Msg mm;
 224
 225     do
 226     {
 227         m_innerCondition.wait();
 228         m_innerCondition.reset();
 229
 230         mm = m_message;
 231
 232         switch(mm)
 233         {
 234         case CB_DONE:
 235             break;
 236
 237         case CB_FPOINTER:
 238         {
 239             m_pCallee(m_pParam);
 240
 241             m_message = CB_DONE;
 242             m_outerCondition.set();
 243             break;
 244         }
 245         default:
 246             abort();
 247         }
 248     }
 249     while(mm != CB_DONE);
 250 }
 251
 252 void AffineBridge::v_callInto_v(uno_EnvCallee * pCallee, va_list * pParam)
 253 {
 254     osl::MutexGuard guard(m_outerMutex); // only one thread at a time can call into
 255
 256     if (m_innerThreadId == 0) // no inner thread yet
 257     {
 258         m_pInnerThread  = new InnerThread(this);
 259         m_pInnerThread->resume();
 260     }
 261
 262     bool resetId = false;
 263     if (!m_outerThreadId)
 264     {
 265         m_outerThreadId = osl_getThreadIdentifier(NULL);
 266         resetId = true;
 267     }
 268
 269     m_message = CB_FPOINTER;
 270     m_pCallee = pCallee;
 271     m_pParam  = pParam;
 272     m_innerCondition.set();
 273
 274     outerDispatch(1);
 275
 276     if (resetId)
 277         m_outerThreadId = 0;
 278 }
 279
 280 void AffineBridge::v_callOut_v(uno_EnvCallee * pCallee, va_list * pParam)
 281 {
 282     OSL_ASSERT(m_innerThreadId);
 283
 284     osl::MutexGuard guard(m_innerMutex);
 285
 286     if (m_outerThreadId == 0) // no outer thread yet
 287     {
 288         osl::MutexGuard guard_m_outerMutex(m_outerMutex);
 289
 290         if (m_outerThreadId == 0)
 291         {
 292             if (m_pOuterThread)
 293             {
 294                 m_pOuterThread->join();
 295                 delete m_pOuterThread;
 296             }
 297
 298             m_pOuterThread = new OuterThread(this);
 299         }
 300     }
 301
 302     m_message = CB_FPOINTER;
 303     m_pCallee = pCallee;
 304     m_pParam  = pParam;
 305     m_outerCondition.set();
 306
 307     innerDispatch();
 308 }
 309
 310 void AffineBridge::v_enter(void)
 311 {
 312     m_innerMutex.acquire();
 313
 314     if (!m_enterCount)
 315         m_innerThreadId = osl_getThreadIdentifier(NULL);
 316
 317     OSL_ASSERT(m_innerThreadId == osl_getThreadIdentifier(NULL));
 318
 319     ++ m_enterCount;
 320 }
 321
 322 void AffineBridge::v_leave(void)
 323 {
 324     OSL_ASSERT(m_innerThreadId == osl_getThreadIdentifier(NULL));
 325
 326     -- m_enterCount;
 327     if (!m_enterCount)
 328         m_innerThreadId = 0;
 329
 330     m_innerMutex.release();
 331 }
 332
 333 int  AffineBridge::v_isValid(rtl::OUString * pReason)
 334 {
 335     int result = 1;
 336
 337     result = m_enterCount > 0;
 338     if (!result)
 339         *pReason = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("not entered"));
 340
 341     else
 342     {
 343         result = m_innerThreadId == osl_getThreadIdentifier(NULL);
 344
 345         if (!result)
 346             *pReason = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("wrong thread"));
 347     }
 348
 349     if (result)
 350         *pReason = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM("OK"));
 351
 352     return result;
 353 }
 354
 355 extern "C" void SAL_DLLPUBLIC_EXPORT SAL_CALL uno_initEnvironment(uno_Environment * pEnv)
 356     SAL_THROW_EXTERN_C()
 357 {
 358     cppu::helper::purpenv::Environment_initWithEnterable(pEnv, new AffineBridge());
 359 }
 360
 361 extern "C" void SAL_DLLPUBLIC_EXPORT SAL_CALL uno_ext_getMapping(uno_Mapping     ** ppMapping,
 362                                                         uno_Environment  * pFrom,
 363                                                         uno_Environment  * pTo )
 364 {
 365     cppu::helper::purpenv::createMapping(ppMapping, pFrom, pTo);
 366 }
 367