summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorStephan Bergmann <sbergman@redhat.com>2014-03-17 14:21:59 +0100
committerStephan Bergmann <sbergman@redhat.com>2014-03-17 16:52:32 +0100
commit88c4f15debc947d1a9e2aa1964078288228f983d (patch)
tree6174c449e24217b845ac0e1e24fb9ebd73273d91
parent4c1cdd43de6e45726054fffb4b8c80ef9269f24a (diff)
Remove unused framework::FairRWLock
Change-Id: I91adf908aaa399186ff69d3a07eb945aed0c90f5
-rw-r--r--framework/inc/jobs/job.hxx1
-rw-r--r--framework/inc/threadhelp/fairrwlock.hxx242
-rw-r--r--framework/inc/threadhelp/lockhelper.hxx3
-rw-r--r--framework/source/helper/wakeupthread.cxx2
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>