/usr/include/ace/Null_Mutex.h is in libace-dev 6.3.3+dfsg-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 | // -*- C++ -*-
//==========================================================================
/**
* @file Null_Mutex.h
*
* Moved from Synch.h.
*
* @author Douglas C. Schmidt <schmidt@cs.wustl.edu>
*/
//==========================================================================
#ifndef ACE_NULL_MUTEX_H
#define ACE_NULL_MUTEX_H
#include /**/ "ace/pre.h"
#include "ace/os_include/os_errno.h"
#if !defined (ACE_LACKS_PRAGMA_ONCE)
# pragma once
#endif /* ACE_LACKS_PRAGMA_ONCE */
#include "ace/Global_Macros.h"
#include "ace/OS_Memory.h"
ACE_BEGIN_VERSIONED_NAMESPACE_DECL
class ACE_Time_Value;
/**
* @class ACE_Null_Mutex
*
* @brief Implement a do nothing ACE_Mutex, i.e., all the methods are
* no ops.
*/
class ACE_Export ACE_Null_Mutex
{
public:
ACE_Null_Mutex (const ACE_TCHAR * = 0)
: lock_ (0) {}
~ACE_Null_Mutex (void) {}
/// Return 0.
int remove (void) {return 0;}
/// Return 0.
int acquire (void) {return 0;}
/// Return -1 with @c errno == @c ETIME.
int acquire (ACE_Time_Value &) {errno = ETIME; return -1;}
/// Return -1 with @c errno == @c ETIME.
int acquire (ACE_Time_Value *) {errno = ETIME; return -1;}
/// Return 0.
int tryacquire (void) {return 0;}
/// Return 0.
int release (void) {return 0;}
/// Return 0.
int acquire_write (void) {return 0;}
/// Return 0.
int tryacquire_write (void) {return 0;}
/// Return 0.
int tryacquire_write_upgrade (void) {return 0;}
/// Return 0.
int acquire_read (void) {return 0;}
/// Return 0.
int tryacquire_read (void) {return 0;}
/// Dump the state of an object.
void dump (void) const {}
/// Declare the dynamic allocation hooks.
//ACE_ALLOC_HOOK_DECLARE;
int lock_; // A dummy lock.
};
// FUZZ: disable check_for_ACE_Guard
template <class ACE_LOCK>
class ACE_Guard;
/**
* @brief Template specialization of ACE_Guard for the
* ACE_Null_Mutex.
*
* This specialization is useful since it helps to speedup
* performance of the "Null_Mutex" considerably.
*/
template<>
class ACE_Export ACE_Guard<ACE_Null_Mutex>
{
public:
// = Initialization and termination methods.
ACE_Guard (ACE_Null_Mutex &) {}
ACE_Guard (ACE_Null_Mutex &, int) {}
ACE_Guard (ACE_Null_Mutex &, int, int) {}
#if defined (ACE_WIN32)
~ACE_Guard (void) {}
#endif /* ACE_WIN32 */
int acquire (void) { return 0; }
int tryacquire (void) { return 0; }
int release (void) { return 0; }
void disown (void) {}
int locked (void) { return 1; }
int remove (void) { return 0; }
void dump (void) const {}
private:
// Disallow copying and assignment.
ACE_Guard (const ACE_Guard<ACE_Null_Mutex> &);
void operator= (const ACE_Guard<ACE_Null_Mutex> &);
};
template <class ACE_LOCK>
class ACE_Write_Guard;
/**
* @brief Template specialization of ACE_Write_Guard for the
* ACE_Null_Mutex.
*/
template<>
class ACE_Export ACE_Write_Guard<ACE_Null_Mutex>
: public ACE_Guard<ACE_Null_Mutex>
{
public:
ACE_Write_Guard (ACE_Null_Mutex &m)
: ACE_Guard<ACE_Null_Mutex> (m) {}
ACE_Write_Guard (ACE_Null_Mutex &m, int blocked)
: ACE_Guard<ACE_Null_Mutex> (m, blocked) {}
int acquire_write (void) { return 0; }
int acquire (void) { return 0; }
int tryacquire_write (void) { return 0; }
int tryacquire (void) { return 0; }
void dump (void) const {}
};
template <class ACE_LOCK>
class ACE_Read_Guard;
/**
* @brief Template specialization of ACE_Read)Guard for the
* ACE_Null_Mutex.
*/
template<>
class ACE_Export ACE_Read_Guard<ACE_Null_Mutex>
: public ACE_Guard<ACE_Null_Mutex>
{
public:
ACE_Read_Guard (ACE_Null_Mutex &m)
: ACE_Guard<ACE_Null_Mutex> (m) {}
ACE_Read_Guard (ACE_Null_Mutex &m, int blocked)
: ACE_Guard<ACE_Null_Mutex> (m, blocked) {}
int acquire_read (void) { return 0; }
int acquire (void) { return 0; }
int tryacquire_read (void) { return 0; }
int tryacquire (void) { return 0; }
void dump (void) const {}
};
// FUZZ: enable check_for_ACE_Guard
template <class T> class ACE_Malloc_Lock_Adapter_T;
/**
* @brief Template specialization of ACE_Malloc_Lock_Adapter_T for the
* ACE_Null_Mutex.
*/
template<>
class ACE_Export ACE_Malloc_Lock_Adapter_T<ACE_Null_Mutex>
{
public:
ACE_Null_Mutex * operator () (const ACE_TCHAR *name)
{
ACE_Null_Mutex *p;
ACE_NEW_RETURN (p, ACE_Null_Mutex (name), 0);
return p;
}
};
ACE_END_VERSIONED_NAMESPACE_DECL
#include /**/ "ace/post.h"
#endif /* ACE_NULL_MUTEX_H */
|