← Back to branch summary

~cosme/ubuntu/precise/freeimage/freeimage-3.15.1

« back to all changes in this revision

Viewing changes to Source/OpenEXR/IlmThread/IlmThreadMutex.h

  • Committer: Bazaar Package Importer
  • Author(s): Cosme Domínguez Díaz
  • Date: 2010-07-20 13:42:15 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20100720134215-xt1454zaedv3b604
Tags: 3.13.1-0ubuntu1
https://launchpad.net/bugs/607800
* New upstream release. Closes: (LP: #607800)
 - Updated debian/freeimage-get-orig-source script.
 - Removing no longer necessary debian/patches/* and
   the patch system in debian/rules.
 - Updated debian/rules to work with the new Makefiles.
 - Drop from -O3 to -O2 and use lzma compression saves
   ~10 MB of free space. 
* lintian stuff
 - fixed debhelper-but-no-misc-depends
 - fixed ldconfig-symlink-missing-for-shlib

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/OpenEXR/IlmThread/IlmThreadMutex.h
1
 
///////////////////////////////////////////////////////////////////////////
2
 
//
3
 
// Copyright (c) 2005, Industrial Light & Magic, a division of Lucas
4
 
// Digital Ltd. LLC
5
 
// 
6
 
// All rights reserved.
7
 
// 
8
 
// Redistribution and use in source and binary forms, with or without
9
 
// modification, are permitted provided that the following conditions are
10
 
// met:
11
 
// *       Redistributions of source code must retain the above copyright
12
 
// notice, this list of conditions and the following disclaimer.
13
 
// *       Redistributions in binary form must reproduce the above
14
 
// copyright notice, this list of conditions and the following disclaimer
15
 
// in the documentation and/or other materials provided with the
16
 
// distribution.
17
 
// *       Neither the name of Industrial Light & Magic nor the names of
18
 
// its contributors may be used to endorse or promote products derived
19
 
// from this software without specific prior written permission. 
20
 
// 
21
 
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22
 
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23
 
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24
 
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25
 
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26
 
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27
 
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28
 
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29
 
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30
 
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31
 
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32
 
//
33
 
///////////////////////////////////////////////////////////////////////////
34
 
 
35
 
#ifndef INCLUDED_ILM_THREAD_MUTEX_H
36
 
#define INCLUDED_ILM_THREAD_MUTEX_H
37
 
 
38
 
//-----------------------------------------------------------------------------
39
 
//
40
 
//      class Mutex, class Lock
41
 
//
42
 
//      Class Mutex is a wrapper for a system-dependent mutual exclusion
43
 
//      mechanism.  Actual locking and unlocking of a Mutex object must
44
 
//      be performed using an instance of a Lock (defined below).
45
 
//
46
 
//      Class lock provides safe locking and unlocking of mutexes even in
47
 
//      the presence of C++ exceptions.  Constructing a Lock object locks
48
 
//      the mutex; destroying the Lock unlocks the mutex.
49
 
//
50
 
//      Lock objects are not themselves thread-safe.  You should never
51
 
//      share a Lock object among multiple threads.
52
 
//
53
 
//      Typical usage:
54
 
//    
55
 
//          Mutex mtx;  // Create a Mutex object that is visible
56
 
//                      //to multiple threads
57
 
//
58
 
//          ...         // create some threads
59
 
//
60
 
//          // Then, within each thread, construct a critical section like so:
61
 
//
62
 
//          {
63
 
//              Lock lock (mtx);        // Lock constructor locks the mutex
64
 
//              ...                     // do some computation on shared data
65
 
//          }                           // leaving the block unlocks the mutex
66
 
//
67
 
//-----------------------------------------------------------------------------
68
 
 
69
 
#include "IlmBaseConfig.h"
70
 
 
71
 
#if defined _WIN32 || defined _WIN64
72
 
    #ifdef NOMINMAX
73
 
        #undef NOMINMAX
74
 
    #endif
75
 
    #define NOMINMAX
76
 
    #include <windows.h>
77
 
#elif HAVE_PTHREAD
78
 
    #include <pthread.h>
79
 
#endif
80
 
 
81
 
namespace IlmThread {
82
 
 
83
 
class Lock;
84
 
 
85
 
 
86
 
class Mutex
87
 
{
88
 
  public:
89
 
 
90
 
    Mutex ();
91
 
    virtual ~Mutex ();
92
 
 
93
 
  private:
94
 
 
95
 
    void        lock () const;
96
 
    void        unlock () const;
97
 
 
98
 
    #if defined _WIN32 || defined _WIN64
99
 
        mutable CRITICAL_SECTION _mutex;
100
 
    #elif HAVE_PTHREAD
101
 
        mutable pthread_mutex_t _mutex;
102
 
    #endif
103
 
 
104
 
    void operator = (const Mutex& M);   // not implemented
105
 
    Mutex (const Mutex& M);             // not implemented
106
 
    
107
 
    friend class Lock;
108
 
};
109
 
 
110
 
 
111
 
class Lock
112
 
{
113
 
  public:
114
 
 
115
 
    Lock (const Mutex& m, bool autoLock = true):
116
 
        _mutex (m),
117
 
        _locked (false)
118
 
    {
119
 
        if (autoLock)
120
 
        {
121
 
            _mutex.lock();
122
 
            _locked = true;
123
 
        }
124
 
    }
125
 
    
126
 
    ~Lock ()
127
 
    {
128
 
        if (_locked)
129
 
            _mutex.unlock();
130
 
    }
131
 
    
132
 
    void acquire ()
133
 
    {
134
 
        _mutex.lock();
135
 
        _locked = true;
136
 
    }
137
 
    
138
 
    void release ()
139
 
    {
140
 
        _mutex.unlock();
141
 
        _locked = false;
142
 
    }
143
 
    
144
 
    bool locked ()
145
 
    {
146
 
        return _locked;
147
 
    }
148
 
 
149
 
  private:
150
 
 
151
 
    const Mutex &       _mutex;
152
 
    bool                _locked;
153
 
};
154
 
 
155
 
 
156
 
} // namespace IlmThread
157
 
 
158
 
#endif
 
1
///////////////////////////////////////////////////////////////////////////
 
2
//
 
3
// Copyright (c) 2005, Industrial Light & Magic, a division of Lucas
 
4
// Digital Ltd. LLC
 
5
// 
 
6
// All rights reserved.
 
7
// 
 
8
// Redistribution and use in source and binary forms, with or without
 
9
// modification, are permitted provided that the following conditions are
 
10
// met:
 
11
// *       Redistributions of source code must retain the above copyright
 
12
// notice, this list of conditions and the following disclaimer.
 
13
// *       Redistributions in binary form must reproduce the above
 
14
// copyright notice, this list of conditions and the following disclaimer
 
15
// in the documentation and/or other materials provided with the
 
16
// distribution.
 
17
// *       Neither the name of Industrial Light & Magic nor the names of
 
18
// its contributors may be used to endorse or promote products derived
 
19
// from this software without specific prior written permission. 
 
20
// 
 
21
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
22
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
23
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
24
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
25
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
26
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
27
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
28
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
29
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
30
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
31
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
32
//
 
33
///////////////////////////////////////////////////////////////////////////
 
34
 
 
35
#ifndef INCLUDED_ILM_THREAD_MUTEX_H
 
36
#define INCLUDED_ILM_THREAD_MUTEX_H
 
37
 
 
38
//-----------------------------------------------------------------------------
 
39
//
 
40
//      class Mutex, class Lock
 
41
//
 
42
//      Class Mutex is a wrapper for a system-dependent mutual exclusion
 
43
//      mechanism.  Actual locking and unlocking of a Mutex object must
 
44
//      be performed using an instance of a Lock (defined below).
 
45
//
 
46
//      Class lock provides safe locking and unlocking of mutexes even in
 
47
//      the presence of C++ exceptions.  Constructing a Lock object locks
 
48
//      the mutex; destroying the Lock unlocks the mutex.
 
49
//
 
50
//      Lock objects are not themselves thread-safe.  You should never
 
51
//      share a Lock object among multiple threads.
 
52
//
 
53
//      Typical usage:
 
54
//    
 
55
//          Mutex mtx;  // Create a Mutex object that is visible
 
56
//                      //to multiple threads
 
57
//
 
58
//          ...         // create some threads
 
59
//
 
60
//          // Then, within each thread, construct a critical section like so:
 
61
//
 
62
//          {
 
63
//              Lock lock (mtx);        // Lock constructor locks the mutex
 
64
//              ...                     // do some computation on shared data
 
65
//          }                           // leaving the block unlocks the mutex
 
66
//
 
67
//-----------------------------------------------------------------------------
 
68
 
 
69
#include "IlmBaseConfig.h"
 
70
 
 
71
#if defined _WIN32 || defined _WIN64
 
72
    #ifdef NOMINMAX
 
73
        #undef NOMINMAX
 
74
    #endif
 
75
    #define NOMINMAX
 
76
    #include <windows.h>
 
77
#elif HAVE_PTHREAD
 
78
    #include <pthread.h>
 
79
#endif
 
80
 
 
81
namespace IlmThread {
 
82
 
 
83
class Lock;
 
84
 
 
85
 
 
86
class Mutex
 
87
{
 
88
  public:
 
89
 
 
90
    Mutex ();
 
91
    virtual ~Mutex ();
 
92
 
 
93
  private:
 
94
 
 
95
    void        lock () const;
 
96
    void        unlock () const;
 
97
 
 
98
    #if defined _WIN32 || defined _WIN64
 
99
        mutable CRITICAL_SECTION _mutex;
 
100
    #elif HAVE_PTHREAD
 
101
        mutable pthread_mutex_t _mutex;
 
102
    #endif
 
103
 
 
104
    void operator = (const Mutex& M);   // not implemented
 
105
    Mutex (const Mutex& M);             // not implemented
 
106
    
 
107
    friend class Lock;
 
108
};
 
109
 
 
110
 
 
111
class Lock
 
112
{
 
113
  public:
 
114
 
 
115
    Lock (const Mutex& m, bool autoLock = true):
 
116
        _mutex (m),
 
117
        _locked (false)
 
118
    {
 
119
        if (autoLock)
 
120
        {
 
121
            _mutex.lock();
 
122
            _locked = true;
 
123
        }
 
124
    }
 
125
    
 
126
    ~Lock ()
 
127
    {
 
128
        if (_locked)
 
129
            _mutex.unlock();
 
130
    }
 
131
    
 
132
    void acquire ()
 
133
    {
 
134
        _mutex.lock();
 
135
        _locked = true;
 
136
    }
 
137
    
 
138
    void release ()
 
139
    {
 
140
        _mutex.unlock();
 
141
        _locked = false;
 
142
    }
 
143
    
 
144
    bool locked ()
 
145
    {
 
146
        return _locked;
 
147
    }
 
148
 
 
149
  private:
 
150
 
 
151
    const Mutex &       _mutex;
 
152
    bool                _locked;
 
153
};
 
154
 
 
155
 
 
156
} // namespace IlmThread
 
157
 
 
158
#endif