1999-08-16 21:50:52 +00:00
|
|
|
/*
|
2001-03-21 20:44:20 +00:00
|
|
|
******************************************************************************
|
1999-12-13 22:28:37 +00:00
|
|
|
*
|
2012-10-05 21:22:02 +00:00
|
|
|
* Copyright (C) 1997-2012, International Business Machines
|
1999-12-13 22:28:37 +00:00
|
|
|
* Corporation and others. All Rights Reserved.
|
|
|
|
*
|
2001-03-21 20:44:20 +00:00
|
|
|
******************************************************************************
|
1999-08-16 21:50:52 +00:00
|
|
|
*/
|
2001-03-21 20:44:20 +00:00
|
|
|
//----------------------------------------------------------------------------
|
1999-08-16 21:50:52 +00:00
|
|
|
// File: mutex.h
|
|
|
|
//
|
|
|
|
// Lightweight C++ wrapper for umtx_ C mutex functions
|
|
|
|
//
|
|
|
|
// Author: Alan Liu 1/31/97
|
|
|
|
// History:
|
|
|
|
// 06/04/97 helena Updated setImplementation as per feedback from 5/21 drop.
|
|
|
|
// 04/07/1999 srl refocused as a thin wrapper
|
|
|
|
//
|
2001-03-21 20:44:20 +00:00
|
|
|
//----------------------------------------------------------------------------
|
1999-08-16 21:50:52 +00:00
|
|
|
#ifndef MUTEX_H
|
|
|
|
#define MUTEX_H
|
|
|
|
|
2002-06-27 01:19:20 +00:00
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#include "unicode/uobject.h"
|
1999-08-16 21:50:52 +00:00
|
|
|
#include "umutex.h"
|
|
|
|
|
2001-10-08 23:26:58 +00:00
|
|
|
U_NAMESPACE_BEGIN
|
|
|
|
|
2001-03-21 20:44:20 +00:00
|
|
|
//----------------------------------------------------------------------------
|
2003-08-05 01:25:54 +00:00
|
|
|
// Code within that accesses shared static or global data should
|
1999-08-16 21:50:52 +00:00
|
|
|
// should instantiate a Mutex object while doing so. You should make your own
|
|
|
|
// private mutex where possible.
|
|
|
|
|
|
|
|
// For example:
|
|
|
|
//
|
2012-10-05 21:22:02 +00:00
|
|
|
// UMutex myMutex;
|
1999-08-16 21:50:52 +00:00
|
|
|
//
|
|
|
|
// void Function(int arg1, int arg2)
|
|
|
|
// {
|
2003-08-05 01:25:54 +00:00
|
|
|
// static Object* foo; // Shared read-write object
|
1999-08-16 21:50:52 +00:00
|
|
|
// Mutex mutex(&myMutex); // or no args for the global lock
|
|
|
|
// foo->Method();
|
|
|
|
// // When 'mutex' goes out of scope and gets destroyed here, the lock is released
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// Note: Do NOT use the form 'Mutex mutex();' as that merely forward-declares a function
|
|
|
|
// returning a Mutex. This is a common mistake which silently slips through the
|
|
|
|
// compiler!!
|
|
|
|
//
|
|
|
|
|
2002-10-04 17:27:53 +00:00
|
|
|
class U_COMMON_API Mutex : public UMemory {
|
1999-08-16 21:50:52 +00:00
|
|
|
public:
|
2012-10-05 21:22:02 +00:00
|
|
|
inline Mutex(UMutex *mutex = NULL);
|
1999-08-16 21:50:52 +00:00
|
|
|
inline ~Mutex();
|
|
|
|
|
|
|
|
private:
|
2012-10-05 21:22:02 +00:00
|
|
|
UMutex *fMutex;
|
2002-06-29 00:04:16 +00:00
|
|
|
|
2002-10-04 17:27:53 +00:00
|
|
|
Mutex(const Mutex &other); // forbid copying of this class
|
|
|
|
Mutex &operator=(const Mutex &other); // forbid copying of this class
|
1999-08-16 21:50:52 +00:00
|
|
|
};
|
|
|
|
|
2012-10-05 21:22:02 +00:00
|
|
|
inline Mutex::Mutex(UMutex *mutex)
|
1999-08-16 21:50:52 +00:00
|
|
|
: fMutex(mutex)
|
|
|
|
{
|
|
|
|
umtx_lock(fMutex);
|
|
|
|
}
|
|
|
|
|
|
|
|
inline Mutex::~Mutex()
|
|
|
|
{
|
|
|
|
umtx_unlock(fMutex);
|
|
|
|
}
|
|
|
|
|
2010-01-06 23:50:03 +00:00
|
|
|
// common code for singletons ---------------------------------------------- ***
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Function pointer for the instantiator parameter of
|
|
|
|
* SimpleSingleton::getInstance() and TriStateSingleton::getInstance().
|
|
|
|
* The function creates some object, optionally using the context parameter.
|
|
|
|
* The function need not check for U_FAILURE(errorCode).
|
|
|
|
*/
|
|
|
|
typedef void *InstantiatorFn(const void *context, UErrorCode &errorCode);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Singleton struct with shared instantiation/mutexing code.
|
|
|
|
* Simple: Does not remember if a previous instantiation failed.
|
|
|
|
* Best used if the instantiation can really only fail with an out-of-memory error,
|
|
|
|
* otherwise use a TriStateSingleton.
|
|
|
|
* Best used via SimpleSingletonWrapper or similar.
|
|
|
|
* Define a static SimpleSingleton instance via the STATIC_SIMPLE_SINGLETON macro.
|
|
|
|
*/
|
|
|
|
struct SimpleSingleton {
|
|
|
|
void *fInstance;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the singleton instance, or NULL if it could not be created.
|
|
|
|
* Calls the instantiator with the context if the instance has not been
|
|
|
|
* created yet. In a race condition, the duplicate may not be NULL.
|
|
|
|
* The caller must delete the duplicate.
|
|
|
|
* The caller need not initialize the duplicate before the call.
|
|
|
|
*/
|
|
|
|
void *getInstance(InstantiatorFn *instantiator, const void *context,
|
|
|
|
void *&duplicate,
|
|
|
|
UErrorCode &errorCode);
|
|
|
|
/**
|
|
|
|
* Resets the fields. The caller must have deleted the singleton instance.
|
|
|
|
* Not mutexed.
|
|
|
|
* Call this from a cleanup function.
|
|
|
|
*/
|
|
|
|
void reset() { fInstance=NULL; }
|
|
|
|
};
|
|
|
|
|
|
|
|
#define STATIC_SIMPLE_SINGLETON(name) static SimpleSingleton name={ NULL }
|
|
|
|
|
|
|
|
/**
|
2011-03-29 00:47:41 +00:00
|
|
|
* Handy wrapper for a SimpleSingleton.
|
2010-01-06 23:50:03 +00:00
|
|
|
* Intended for temporary use on the stack, to make the SimpleSingleton easier to deal with.
|
|
|
|
* Takes care of the duplicate deletion and type casting.
|
|
|
|
*/
|
|
|
|
template<typename T>
|
|
|
|
class SimpleSingletonWrapper {
|
|
|
|
public:
|
|
|
|
SimpleSingletonWrapper(SimpleSingleton &s) : singleton(s) {}
|
|
|
|
void deleteInstance() {
|
|
|
|
delete (T *)singleton.fInstance;
|
|
|
|
singleton.reset();
|
|
|
|
}
|
|
|
|
T *getInstance(InstantiatorFn *instantiator, const void *context,
|
|
|
|
UErrorCode &errorCode) {
|
|
|
|
void *duplicate;
|
|
|
|
T *instance=(T *)singleton.getInstance(instantiator, context, duplicate, errorCode);
|
|
|
|
delete (T *)duplicate;
|
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
SimpleSingleton &singleton;
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Singleton struct with shared instantiation/mutexing code.
|
|
|
|
* Tri-state: Instantiation succeeded/failed/not attempted yet.
|
|
|
|
* Best used via TriStateSingletonWrapper or similar.
|
|
|
|
* Define a static TriStateSingleton instance via the STATIC_TRI_STATE_SINGLETON macro.
|
|
|
|
*/
|
|
|
|
struct TriStateSingleton {
|
|
|
|
void *fInstance;
|
|
|
|
UErrorCode fErrorCode;
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Returns the singleton instance, or NULL if it could not be created.
|
|
|
|
* Calls the instantiator with the context if the instance has not been
|
|
|
|
* created yet. In a race condition, the duplicate may not be NULL.
|
|
|
|
* The caller must delete the duplicate.
|
|
|
|
* The caller need not initialize the duplicate before the call.
|
|
|
|
* The singleton creation is only attempted once. If it fails,
|
|
|
|
* the singleton will then always return NULL.
|
|
|
|
*/
|
|
|
|
void *getInstance(InstantiatorFn *instantiator, const void *context,
|
|
|
|
void *&duplicate,
|
|
|
|
UErrorCode &errorCode);
|
|
|
|
/**
|
|
|
|
* Resets the fields. The caller must have deleted the singleton instance.
|
|
|
|
* Not mutexed.
|
|
|
|
* Call this from a cleanup function.
|
|
|
|
*/
|
|
|
|
void reset();
|
|
|
|
};
|
|
|
|
|
2011-03-29 00:47:41 +00:00
|
|
|
#define STATIC_TRI_STATE_SINGLETON(name) static TriStateSingleton name={ NULL, U_ZERO_ERROR }
|
2010-01-06 23:50:03 +00:00
|
|
|
|
|
|
|
/**
|
2011-03-29 00:47:41 +00:00
|
|
|
* Handy wrapper for a TriStateSingleton.
|
2010-01-06 23:50:03 +00:00
|
|
|
* Intended for temporary use on the stack, to make the TriStateSingleton easier to deal with.
|
|
|
|
* Takes care of the duplicate deletion and type casting.
|
|
|
|
*/
|
|
|
|
template<typename T>
|
|
|
|
class TriStateSingletonWrapper {
|
|
|
|
public:
|
|
|
|
TriStateSingletonWrapper(TriStateSingleton &s) : singleton(s) {}
|
|
|
|
void deleteInstance() {
|
|
|
|
delete (T *)singleton.fInstance;
|
|
|
|
singleton.reset();
|
|
|
|
}
|
|
|
|
T *getInstance(InstantiatorFn *instantiator, const void *context,
|
|
|
|
UErrorCode &errorCode) {
|
|
|
|
void *duplicate;
|
|
|
|
T *instance=(T *)singleton.getInstance(instantiator, context, duplicate, errorCode);
|
|
|
|
delete (T *)duplicate;
|
|
|
|
return instance;
|
|
|
|
}
|
|
|
|
private:
|
|
|
|
TriStateSingleton &singleton;
|
|
|
|
};
|
|
|
|
|
2001-10-08 23:26:58 +00:00
|
|
|
U_NAMESPACE_END
|
|
|
|
|
1999-08-16 21:50:52 +00:00
|
|
|
#endif //_MUTEX_
|
|
|
|
//eof
|