Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

2 files changed, 333 insertions, 0 deletions

diff --git a/include/osl/mutex.h b/include/osl/mutex.h
new file mode 100644
index 000000000..d624beb0c
--- /dev/null
+++ b/include/osl/mutex.h
@@ -0,0 +1,80 @@
+/* -*- 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_OSL_MUTEX_H
+#define INCLUDED_OSL_MUTEX_H
+
+#include "sal/config.h"
+
+#include "sal/saldllapi.h"
+#include "sal/types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct _oslMutexImpl;
+typedef struct _oslMutexImpl * oslMutex;
+
+/** Create a mutex.
+
+    @return 0 if the mutex could not be created, otherwise a handle to the mutex.
+*/
+SAL_DLLPUBLIC oslMutex SAL_CALL osl_createMutex(void);
+
+/** Release the OS-structures and free mutex data-structure.
+
+    @param Mutex the mutex-handle
+*/
+SAL_DLLPUBLIC void SAL_CALL osl_destroyMutex(oslMutex Mutex);
+
+/** Acquire the mutex, block if already acquired by another thread.
+    @param Mutex handle to a created mutex.
+    @retval False if system-call fails.
+*/
+SAL_DLLPUBLIC sal_Bool SAL_CALL osl_acquireMutex(oslMutex Mutex);
+
+/** Try to acquire the mutex without blocking.
+
+    @param Mutex handle to a created mutex.
+
+    @retval False if it could not be acquired.
+*/
+SAL_DLLPUBLIC sal_Bool SAL_CALL osl_tryToAcquireMutex(oslMutex Mutex);
+
+/** Release the mutex.
+
+    @param Mutex handle to a created mutex.
+    @retval False if system-call fails.
+*/
+SAL_DLLPUBLIC sal_Bool SAL_CALL osl_releaseMutex(oslMutex Mutex);
+
+/** Returns a unique and global mutex.
+
+    @return the global mutex.
+*/
+SAL_DLLPUBLIC oslMutex * SAL_CALL osl_getGlobalMutex(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // INCLUDED_OSL_MUTEX_H
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/include/osl/mutex.hxx b/include/osl/mutex.hxx
new file mode 100644
index 000000000..f984f035c
--- /dev/null
+++ b/include/osl/mutex.hxx
@@ -0,0 +1,253 @@
+/* -*- 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_OSL_MUTEX_HXX
+#define INCLUDED_OSL_MUTEX_HXX
+
+#include "osl/mutex.h"
+
+#include <cassert>
+
+namespace osl
+{
+    /** A mutual exclusion synchronization object
+    */
+    class SAL_WARN_UNUSED Mutex {
+
+    public:
+        /** Create a mutex.
+            @return 0 if the mutex could not be created, otherwise a handle to the mutex.
+            @see ::osl_createMutex()
+        */
+        Mutex()
+        {
+            mutex = osl_createMutex();
+        }
+
+        /** Release the OS-structures and free mutex data-structure.
+            @see ::osl_destroyMutex()
+        */
+        ~Mutex()
+        {
+            osl_destroyMutex(mutex);
+        }
+
+        /** Acquire the mutex, block if already acquired by another thread.
+            @return false if system-call fails.
+            @see ::osl_acquireMutex()
+        */
+        bool acquire()
+        {
+            return osl_acquireMutex(mutex);
+        }
+
+        /** Try to acquire the mutex without blocking.
+            @return false if it could not be acquired.
+            @see ::osl_tryToAcquireMutex()
+        */
+        bool tryToAcquire()
+        {
+            return osl_tryToAcquireMutex(mutex);
+        }
+
+        /** Release the mutex.
+            @return false if system-call fails.
+            @see ::osl_releaseMutex()
+        */
+        bool release()
+        {
+            return osl_releaseMutex(mutex);
+        }
+
+        /** Returns a global static mutex object.
+            The global and static mutex object can be used to initialize other
+            static objects in a thread safe manner.
+            @return the global mutex object
+            @see ::osl_getGlobalMutex()
+        */
+        static Mutex * getGlobalMutex()
+        {
+            return reinterpret_cast<Mutex *>(osl_getGlobalMutex());
+        }
+
+    private:
+        oslMutex mutex;
+
+        /** The underlying oslMutex has no reference count.
+
+        Since the underlying oslMutex is not a reference counted object, copy
+        constructed Mutex may work on an already destructed oslMutex object.
+
+        */
+        Mutex(const Mutex&) SAL_DELETED_FUNCTION;
+
+        /** This assignment operator is deleted for the same reason as
+            the copy constructor.
+        */
+        Mutex& operator= (const Mutex&) SAL_DELETED_FUNCTION;
+    };
+
+    /** Object lifetime scoped mutex object or interface lock.
+     *
+     * Acquires the template object on construction and releases it on
+     * destruction.
+     *
+     * @see MutexGuard
+     */
+    template<class T>
+    class Guard
+    {
+        Guard(const Guard&) SAL_DELETED_FUNCTION;
+        Guard& operator=(const Guard&) SAL_DELETED_FUNCTION;
+
+    protected:
+        T * pT;
+
+    public:
+        /** Acquires the object specified as parameter.
+        */
+        Guard(T * pT_) : pT(pT_)
+        {
+            assert(pT != NULL);
+            pT->acquire();
+        }
+
+        /** Acquires the object specified as parameter.
+        */
+        Guard(T & t) : pT(&t)
+        {
+            pT->acquire();
+        }
+
+        /** Releases the mutex or interface. */
+        ~Guard()
+        {
+            pT->release();
+        }
+    };
+
+    /** Object lifetime scoped mutex object or interface lock with unlock.
+     *
+     * Use this if you can't use scoped code blocks and Guard.
+     *
+     * @see ClearableMutexGuard, Guard
+     */
+    template<class T>
+    class ClearableGuard
+    {
+        ClearableGuard( const ClearableGuard& ) SAL_DELETED_FUNCTION;
+        ClearableGuard& operator=(const ClearableGuard&) SAL_DELETED_FUNCTION;
+
+    protected:
+        T * pT;
+
+    public:
+        /** Acquires the object specified as parameter.
+        */
+        ClearableGuard(T * pT_) : pT(pT_)
+        {
+            assert(pT != NULL);
+            pT->acquire();
+        }
+
+        /** Acquires the object specified as parameter.
+        */
+        ClearableGuard(T & t) : pT(&t)
+        {
+            pT->acquire();
+        }
+
+        /** Releases the mutex or interface if not already released by clear().
+        */
+        ~ClearableGuard()
+        {
+            if (pT)
+                pT->release();
+        }
+
+        /** Releases the mutex or interface.
+        */
+        void clear()
+        {
+#ifdef LIBO_INTERNAL_ONLY
+            assert(pT);
+#else
+            if (pT)
+#endif
+            {
+                pT->release();
+                pT = NULL;
+            }
+        }
+    };
+
+    /** Template for temporary releasable mutex objects and interfaces locks.
+     *
+     * Use this if you want to acquire a lock but need to temporary release
+     * it and can't use multiple scoped Guard objects.
+     *
+     * @see ResettableMutexGuard
+     */
+    template< class T >
+    class ResettableGuard : public ClearableGuard< T >
+    {
+        ResettableGuard(const ResettableGuard&) SAL_DELETED_FUNCTION;
+        ResettableGuard& operator=(const ResettableGuard&) SAL_DELETED_FUNCTION;
+
+    protected:
+        T* pResetT;
+
+    public:
+        /** Acquires the object specified as parameter.
+        */
+        ResettableGuard( T* pT_ ) :
+                ClearableGuard<T>( pT_ ),
+                pResetT( pT_ )
+        {}
+
+        /** Acquires the object specified as parameter.
+        */
+        ResettableGuard( T& rT ) :
+                ClearableGuard<T>( rT ),
+                pResetT( &rT )
+        {}
+
+        /** Re-acquires the mutex or interface.
+        */
+        void reset()
+        {
+#ifdef LIBO_INTERNAL_ONLY
+            assert(!this->pT);
+#endif
+            if (pResetT)
+            {
+                this->pT = pResetT;
+                this->pT->acquire();
+            }
+        }
+    };
+
+    typedef Guard<Mutex> MutexGuard;
+    typedef ClearableGuard<Mutex> ClearableMutexGuard;
+    typedef ResettableGuard< Mutex > ResettableMutexGuard;
+}
+
+#endif // INCLUDED_OSL_MUTEX_HXX
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */