diff options
author | Stephan Bergmann <sbergman@redhat.com> | 2014-03-17 14:21:59 +0100 |
---|---|---|
committer | Stephan Bergmann <sbergman@redhat.com> | 2014-03-17 16:52:32 +0100 |
commit | 88c4f15debc947d1a9e2aa1964078288228f983d (patch) | |
tree | 6174c449e24217b845ac0e1e24fb9ebd73273d91 | |
parent | 4c1cdd43de6e45726054fffb4b8c80ef9269f24a (diff) |
Remove unused framework::FairRWLock
Change-Id: I91adf908aaa399186ff69d3a07eb945aed0c90f5
-rw-r--r-- | framework/inc/jobs/job.hxx | 1 | ||||
-rw-r--r-- | framework/inc/threadhelp/fairrwlock.hxx | 242 | ||||
-rw-r--r-- | framework/inc/threadhelp/lockhelper.hxx | 3 | ||||
-rw-r--r-- | framework/source/helper/wakeupthread.cxx | 2 |
4 files changed, 5 insertions, 243 deletions
diff --git a/framework/inc/jobs/job.hxx b/framework/inc/jobs/job.hxx index d0c423ded10e..c888fe3154ef 100644 --- a/framework/inc/jobs/job.hxx +++ b/framework/inc/jobs/job.hxx @@ -38,6 +38,7 @@ #include <com/sun/star/frame/DispatchResultEvent.hpp> #include <cppuhelper/implbase3.hxx> +#include <osl/conditn.hxx> #include <rtl/ustring.hxx> diff --git a/framework/inc/threadhelp/fairrwlock.hxx b/framework/inc/threadhelp/fairrwlock.hxx deleted file mode 100644 index 8d90ad091281..000000000000 --- a/framework/inc/threadhelp/fairrwlock.hxx +++ /dev/null @@ -1,242 +0,0 @@ -/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */ -/* - * This file is part of the LibreOffice project. - * - * This Source Code Form is subject to the terms of the Mozilla Public - * License, v. 2.0. If a copy of the MPL was not distributed with this - * file, You can obtain one at http://mozilla.org/MPL/2.0/. - * - * This file incorporates work covered by the following license notice: - * - * Licensed to the Apache Software Foundation (ASF) under one or more - * contributor license agreements. See the NOTICE file distributed - * with this work for additional information regarding copyright - * ownership. The ASF licenses this file to you under the Apache - * License, Version 2.0 (the "License"); you may not use this file - * except in compliance with the License. You may obtain a copy of - * the License at http://www.apache.org/licenses/LICENSE-2.0 . - */ - -#ifndef INCLUDED_FRAMEWORK_INC_THREADHELP_FAIRRWLOCK_HXX -#define INCLUDED_FRAMEWORK_INC_THREADHELP_FAIRRWLOCK_HXX - -#include <threadhelp/inoncopyable.h> -#include <threadhelp/irwlock.h> - -#include <com/sun/star/uno/XInterface.hpp> - -#include <osl/mutex.hxx> -#include <osl/conditn.hxx> - -namespace framework{ - -/*-************************************************************************************************************ - @short implement a read/write lock with fairness between read/write accessors - @descr These implementation never should used as base class! Use it as a member every time. - Use ReadGuard and/or WriteGuard in your methods (which work with these lock) - to make your code threadsafe. - Fair means: All reading or writing threads are synchronized AND serialzed by using one - mutex. For reader this mutex is used to access internal variables of this lock only; - for writer this mutex is used to have an exclusiv access on your class member! - => It's a multi-reader/single-writer lock, which no preferred accessor. - - @implements IRWlock - @base INonCopyable - IRWLock - - @devstatus ready to use -*//*-*************************************************************************************************************/ -class FairRWLock : public IRWLock - , private INonCopyable -{ - - // public methods - - public: - - /*-**************************************************************************************************** - @short standard ctor - @descr Initialize instance with right start values for correct working. - no reader could exist => m_nReadCount = 0 - don't block first coming writer => m_aWriteCondition.set() - - @seealso - - - @param - - @return - - - @onerror - - *//*-*****************************************************************************************************/ - inline FairRWLock() - : m_nReadCount( 0 ) - { - m_aWriteCondition.set(); - } - - inline virtual ~FairRWLock() - { - } - - /*-**************************************************************************************************** - @interface IRWLock - @short set lock for reading - @descr A guard should call this method to acquire read access on your member. - Writing isn't allowed then - but nobody could check it for you! - - @seealso method releaseReadAccess() - - @param - - @return - - - @onerror - - *//*-*****************************************************************************************************/ - inline virtual void acquireReadAccess() - { - // Put call in "SERIALIZE"-queue! - // After successfully acquiring this mutex we are alone ... - ::osl::MutexGuard aSerializeGuard( m_aSerializer ); - - // ... but we should synchronize us with other reader! - // May be - they will unregister himself by using releaseReadAccess()! - ::osl::MutexGuard aAccessGuard( m_aAccessLock ); - - // Now we must register us as reader by increasing counter. - // If this the first writer we must close door for possible writer. - // Other reader don't look for this barrier - they work parallel to us! - if( m_nReadCount == 0 ) - { - m_aWriteCondition.reset(); - } - ++m_nReadCount; - } - - /*-**************************************************************************************************** - @interface IRWLock - @short reset lock for reading - @descr A guard should call this method to release read access on your member. - - @seealso method acquireReadAccess() - - @param - - @return - - - @onerror - - *//*-*****************************************************************************************************/ - inline virtual void releaseReadAccess() - { - // The access lock is enough at this point - // because it's not allowed to wait for all reader or writer here! - // That will cause a deadlock! - ::osl::MutexGuard aAccessGuard( m_aAccessLock ); - - // Unregister as reader first! - // Open writer barrier then if it was the last reader. - --m_nReadCount; - if( m_nReadCount == 0 ) - { - m_aWriteCondition.set(); - } - } - - /*-**************************************************************************************************** - @interface IRWLock - @short set lock for writing - @descr A guard should call this method to acquire write access on your member. - Reading is allowed too - of course. - After successfully calling of this method you are the only writer. - - @seealso method releaseWriteAccess() - - @param - - @return - - - @onerror - - *//*-*****************************************************************************************************/ - inline virtual void acquireWriteAccess() - { - // You have to stand in our serialize-queue till all reader - // are registered (not for releasing them!) or writer finished their work! - // Don't use a guard to do so - because you must hold the mutex till - // you call releaseWriteAccess()! - // After successfully acquiring you have to wait for current working reader. - // Used condition will open by last gone reader object. - m_aSerializer.acquire(); - m_aWriteCondition.wait(); - } - - /*-**************************************************************************************************** - @interface IRWLock - @short reset lock for writing - @descr A guard should call this method to release write access on your member. - - @seealso method acquireWriteAccess() - - @param - - @return - - - @onerror - - *//*-*****************************************************************************************************/ - inline virtual void releaseWriteAccess() - { - // The only one you have to do here is to release - // hold seriliaze-mutex. All other user of these instance are blocked - // by these mutex! - // You don't need any other mutex here - you are the only one in the moment! - - m_aSerializer.release(); - } - - /*-**************************************************************************************************** - @interface IRWLock - @short downgrade a write access to a read access - @descr A guard should call this method to change a write to a read access. - New readers can work too - new writer are blocked! - - @attention Don't call this method if you are not a writer! - Results are not defined then ... - An upgrade can't be implemented really ... because acquiring new access - will be the same - there no differences! - - @seealso - - - @param - - @return - - - @onerror - - *//*-*****************************************************************************************************/ - inline virtual void downgradeWriteAccess() - { - // You must be a writer to call this method! - // We can't check it - but otherwise it's your problem ... - // Thats why you don't need any mutex here. - - // Register himself as "new" reader. - // This value must be 0 before - because we support single writer access only! - ++m_nReadCount; - // Close barrier for other writer! - // Why? - // You hold the serializer mutex - next one can be a reader OR a writer. - // They must blocked then - because you will be a reader after this call - // and writer use this condition to wait for current reader! - m_aWriteCondition.reset(); - // Open door for next waiting thread in serialize queue! - m_aSerializer.release(); - } - - - // private member - - private: - - ::osl::Mutex m_aAccessLock ; /// regulate access on internal member of this instance - ::osl::Mutex m_aSerializer ; /// serialze incoming read/write access threads - ::osl::Condition m_aWriteCondition ; /// a writer must wait till current working reader are gone - sal_Int32 m_nReadCount ; /// every reader is registered - the last one open the door for waiting writer - -}; // class FairRWLock - -} // namespace framework - -#endif // INCLUDED_FRAMEWORK_INC_THREADHELP_FAIRRWLOCK_HXX - -/* vim:set shiftwidth=4 softtabstop=4 expandtab: */ diff --git a/framework/inc/threadhelp/lockhelper.hxx b/framework/inc/threadhelp/lockhelper.hxx index f961f2c2a40e..96ab07623e2b 100644 --- a/framework/inc/threadhelp/lockhelper.hxx +++ b/framework/inc/threadhelp/lockhelper.hxx @@ -23,11 +23,12 @@ #include <threadhelp/inoncopyable.h> #include <framework/imutex.hxx> #include <threadhelp/irwlock.h> -#include <threadhelp/fairrwlock.hxx> #include <comphelper/solarmutex.hxx> #include <fwidllapi.h> +namespace osl { class Mutex; } + namespace framework{ /*-************************************************************************************************************ diff --git a/framework/source/helper/wakeupthread.cxx b/framework/source/helper/wakeupthread.cxx index 08fdc66fcf2d..b89478260fdf 100644 --- a/framework/source/helper/wakeupthread.cxx +++ b/framework/source/helper/wakeupthread.cxx @@ -17,7 +17,9 @@ * the License at http://www.apache.org/licenses/LICENSE-2.0 . */ +#include <sal/config.h> +#include <osl/conditn.hxx> // include files of own module #include <helper/wakeupthread.hxx> |