/* -*- C++ -*- */ // $Id$ // ============================================================================ // // = LIBRARY // ace // // = FILENAME // Synch_T.h // // = AUTHOR // Doug Schmidt // // ============================================================================ #ifndef ACE_SYNCH_T_H #define ACE_SYNCH_T_H #include "ace/Event_Handler.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ #include "ace/Synch.h" // Forward decl class ACE_Time_Value; template class ACE_Lock_Adapter : public ACE_Lock { // = TITLE // This is an adapter that allows applications to transparently // combine the abstract base class (which contains // pure virtual methods) with any of the other concrete ACE // synchronization classes (e.g., , , // , etc.). // // = DESCRIPTION // This class uses a form of the Adapter pattern. public: typedef ACE_LOCKING_MECHANISM ACE_LOCK; // = Initialization/Finalization methods. ACE_Lock_Adapter (ACE_LOCKING_MECHANISM &lock); // Constructor. All locking requests will be forwarded to . ACE_Lock_Adapter (void); // Constructor. Since no lock is provided by the user, one will be // created internally. virtual ~ACE_Lock_Adapter (void); // Destructor. If was not passed in by the user, it will be // deleted. // = Lock accessors. virtual int acquire (void); // Block the thread until the lock is acquired. virtual int tryacquire (void); // Conditionally acquire the lock (i.e., won't block). virtual int release (void); // Release the lock. virtual int acquire_read (void); // Block until the thread acquires a read lock. If the locking // mechanism doesn't support read locks then this just calls // . virtual int acquire_write (void); // Block until the thread acquires a write lock. If the locking // mechanism doesn't support read locks then this just calls // . virtual int tryacquire_read (void); // Conditionally acquire a read lock. If the locking mechanism // doesn't support read locks then this just calls . virtual int tryacquire_write (void); // Conditionally acquire a write lock. If the locking mechanism // doesn't support read locks then this just calls . virtual int remove (void); // Explicitly destroy the lock. private: ACE_LOCKING_MECHANISM *lock_; // The concrete locking mechanism that all the methods delegate to. int delete_lock_; // This flag keep track of whether we are responsible for deleting // the lock }; template class ACE_Test_and_Set : public ACE_Event_Handler { public: // = TITLE // Implements the classic ``test and set'' operation. // // = DESCRIPTION // This class keeps track of the status of , which can // be set based on various events (such as receipt of a // signal). This class is derived from so // that it can be "signaled" by a Reactor when a signal occurs. // We assume that is a data type that can be assigned the // value 0 or 1. ACE_Test_and_Set (TYPE initial_value = 0); TYPE is_set (void) const; // Returns true if we are set, else false. TYPE set (TYPE); // Sets the status, returning the original value of // . virtual int handle_signal (int signum, siginfo_t * = 0, ucontext_t * = 0); // Called when object is signaled by OS (either via UNIX signals or // when a Win32 object becomes signaled). private: TYPE is_set_; // Keeps track of our state. ACE_LOCK lock_; // Protect the state from race conditions. }; template class ACE_Atomic_Op { // = TITLE // Transparently parameterizes synchronization into basic // arithmetic operations. // // = DESCRIPTION // This class is described in an article in the July/August 1994 // issue of the C++ Report magazine. It implements a // templatized version of the Decorator pattern from the GoF book. public: // = Initialization methods. ACE_Atomic_Op (void); // Initialize to 0. ACE_Atomic_Op (const TYPE &c); // Initialize to c. // = Accessors. TYPE operator++ (void); // Atomically pre-increment . TYPE operator++ (int); // Atomically post-increment . TYPE operator+= (const TYPE &i); // Atomically increment by i. TYPE operator-- (void); // Atomically pre-decrement . TYPE operator-- (int); // Atomically post-decrement . TYPE operator-= (const TYPE &i); // Atomically decrement by i. int operator== (const TYPE &i) const; // Atomically compare with i. int operator!= (const TYPE &i) const; // Atomically compare with i. int operator>= (const TYPE &i) const; // Atomically check if greater than or equal to i. int operator> (const TYPE &rhs) const; // Atomically check if greater than i. int operator<= (const TYPE &rhs) const; // Atomically check if less than or equal to i. int operator< (const TYPE &rhs) const; // Atomically check if less than i. void operator= (const TYPE &i); // Atomically assign i to . void operator= (const ACE_Atomic_Op &rhs); // Atomically assign to . TYPE value (void) const; // Explicitly return . void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. ACE_Atomic_Op (const ACE_Atomic_Op &); // Manage copying... ACE_LOCK &mutex (void); // Returns a reference to the underlying . This makes it // possible to acquire the lock explicitly, which can be useful in // some cases if you instantiate the with an // or . NOTE: the right // name would be lock_, but HP/C++ will choke on that! TYPE &value_i (void); // Explicitly return (by reference). This gives the user // full, unrestricted access to the underlying value. This method // will usually be used in conjunction with explicit access to the // lock. Use with care ;-) private: ACE_LOCK mutex_; // Type of synchronization mechanism. TYPE value_; // Current object decorated by the atomic op. }; template class ACE_TSS { // = TITLE // Allows objects that are "physically" in thread specific // storage (i.e., private to a thread) to be accessed as though // they were "logically" global to a program. // // = DESCRIPTION // This class is a wrapper around the OS thread library // thread-specific functions. It uses the C++ operator->() to // shield applications from the details of accessing // thread-specific storage. // // NOTE: TYPE cannot be a built-in type, but instead must be a // user-defined class. (Some compilers will allow a built-in // type, but shouldn't. Sun C++ won't, properly detecting the // improper return type from operator-> ().) See template class // ACE_TSS_Type_Adapter, below, for adapting built-in types to // work with ACE_TSS. public: // = Initialization and termination methods. ACE_TSS (TYPE *ts_obj = 0); // If caller has passed us a non-NULL ts_obj *, then we'll just use // this to initialize the thread-specific value (but only for the // calling thread). Thus, subsequent calls to operator->() in this // thread will return this value. This is useful since it enables // us to assign objects to thread-specific data that have // arbitrarily complex constructors. virtual ~ACE_TSS (void); // Deregister with thread-key administration. // = Accessors. TYPE *ts_object (void) const; // Get the thread-specific object for the key associated with this // object. Returns 0 if the data has never been initialized, // otherwise returns a pointer to the data. TYPE *ts_object (TYPE *); // Set the thread-specific object for the key associated with this // object. TYPE *operator-> () const; // Use a "smart pointer" to get the thread-specific object // associated with the . operator TYPE *(void) const; // Return or create and return the calling threads TYPE object. virtual TYPE *make_TSS_TYPE (void) const; // Hook for construction parameters. // = Utility methods. void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. protected: TYPE *ts_get (void) const; // Actually implements the code that retrieves the object from // thread-specific storage. int ts_init (void) const; // Factors out common code for initializing TSS. This must NOT be // called with the lock held... #if !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) TYPE *type_; // This implementation only works for non-threading systems... #else ACE_Thread_Mutex keylock_; // Avoid race conditions during initialization. int once_; // "First time in" flag. ACE_thread_key_t key_; // Key for the thread-specific error data. static void cleanup (void *ptr); // "Destructor" that deletes internal TYPE * when thread exits. #endif /* defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) */ // = Disallow copying... ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_TSS &)) ACE_UNIMPLEMENTED_FUNC (ACE_TSS (const ACE_TSS &)) }; template class ACE_TSS_Type_Adapter { // = TITLE // Adapter that allows built-in types to be used with ACE_TSS. // // = DESCRIPTION // Wraps a value of a built-in type, providing conversions to // and from the type. Example use with ACE_TSS: // // ACE_TSS > i; // *i = 37; // ACE_OS::fprintf (stderr, "%d\n", *i); // // Unfortunately, though, some compilers have trouble with the // implicit type conversions. This seems to work better: // // ACE_TSS > i; // i->operator int & () = 37; // ACE_OS::fprintf (stderr, "%d\n", i->operator int ()); public: ACE_TSS_Type_Adapter (const TYPE value = 0) : value_ (value) {} // Constructor. Inlined here so that it should _always_ be inlined. operator TYPE () { return value_; }; // TYPE conversion. Inlined here so that it should _always_ be inlined. operator TYPE & () { return value_; }; // TYPE & conversion. Inlined here so that it should _always_ be inlined. private: TYPE value_; // The wrapped value. }; template class ACE_Guard { // = TITLE // This data structure is meant to be used within a method or // function... It performs automatic aquisition and release of // a parameterized synchronization object . // // = DESCRIPTION // The class given as an actual parameter must provide at // the very least the , , , and // methods. public: #if defined (ACE_LACKS_METHOD_DEFINITIONS_IN_CLASS_TEMPLATE) // = Initialization and termination methods. ACE_Guard (ACE_LOCK &l); ACE_Guard (ACE_LOCK &l, int block); // Implicitly and automatically acquire (or try to acquire) the // lock. ~ACE_Guard (void); // Implicitly release the lock. // = Lock accessors. int acquire (void); // Explicitly acquire the lock. int tryacquire (void); // Conditionally acquire the lock (i.e., won't block). int release (void); // Explicitly release the lock, but only if it is held! // = Utility methods. int locked (void); // 1 if locked, 0 if couldn't acquire the lock // (errno will contain the reason for this). int remove (void); // Explicitly remove the lock. #else // = Initialization and termination methods. ACE_Guard (ACE_LOCK &l): lock_ (&l) { this->acquire (); } ACE_Guard (ACE_LOCK &l, int block): lock_ (&l) { if (block) this->acquire (); else this->tryacquire (); } // Implicitly and automatically acquire (or try to acquire) the // lock. ~ACE_Guard (void) { int error = errno; this->release (); errno = error; } // Implicitly release the lock. // = Lock accessors. int acquire (void) { return this->owner_ = this->lock_->acquire (); } // Explicitly acquire the lock. int tryacquire (void) { return this->owner_ = this->lock_->tryacquire (); } // Conditionally acquire the lock (i.e., won't block). int release (void) { if (this->owner_ != -1) { this->owner_ = -1; return this->lock_->release (); } else return 0; } // Explicitly release the lock, but only if it is held! // = Utility methods. int locked (void) { return this->owner_ != -1; } // 1 if locked, 0 if couldn't acquire the lock // (errno will contain the reason for this). int remove (void) { return this->lock_->remove (); } // Explicitly remove the lock. #endif /* defined (ACE_LACKS_METHOD_DEFINITIONS_IN_CLASS_TEMPLATE) */ void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. protected: ACE_Guard (ACE_LOCK *lock): lock_ (lock) {} // Helper, meant for subclass only. ACE_LOCK *lock_; // Pointer to the ACE_LOCK we're guarding. int owner_; // Keeps track of whether we acquired the lock or failed. private: // = Prevent assignment and initialization. ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Guard &)) ACE_UNIMPLEMENTED_FUNC (ACE_Guard (const ACE_Guard &)) }; template class ACE_Write_Guard : public ACE_Guard { // = TITLE // This class is similar to class , though it // acquires/releases a write lock automatically (naturally, the // it is instantiated with must support the appropriate // API). public: // = Initialization method. ACE_Write_Guard (ACE_LOCK &m): ACE_Guard (&m) { this->acquire_write (); } // Implicitly and automatically acquire a write lock. ACE_Write_Guard (ACE_LOCK &m, int block): ACE_Guard (&m) { if (block) this->acquire_write (); else this->tryacquire_write (); } // Implicitly and automatically acquire (or try to acquire) a write // lock. // = Lock accessors. int acquire_write (void) { return this->owner_ = this->lock_->acquire_write (); } // Explicitly acquire the write lock. int acquire (void) { return this->owner_ = this->lock_->acquire_write (); } // Explicitly acquire the write lock. int tryacquire_write (void) { return this->owner_ = this->lock_->tryacquire_write (); } // Conditionally acquire the write lock (i.e., won't block). int tryacquire (void) { return this->owner_ = this->lock_->tryacquire_write (); } // Conditionally acquire the write lock (i.e., won't block). // Utility methods. void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. }; template class ACE_Read_Guard : public ACE_Guard { // = TITLE // This class is similar to class , though it // acquires/releases a read lock automatically (naturally, the // it is instantiated with must support the appropriate // API). public: // = Initialization methods. ACE_Read_Guard (ACE_LOCK& m): ACE_Guard (&m) { this->acquire_read (); } ACE_Read_Guard (ACE_LOCK &m, int block): ACE_Guard (&m) { if (block) this->acquire_read (); else this->tryacquire_read (); } // Implicitly and automatically acquire (or try to acquire) a read // lock. // = Lock accessors. int acquire_read (void) { return this->owner_ = this->lock_->acquire_read (); } // Explicitly acquire the read lock. int acquire (void) { return this->owner_ = this->lock_->acquire_read (); } // Explicitly acquire the read lock. int tryacquire_read (void) { return this->owner_ = this->lock_->tryacquire_read (); } // Conditionally acquire the read lock (i.e., won't block). int tryacquire (void) { return this->owner_ = this->lock_->tryacquire_read (); } // Conditionally acquire the read lock (i.e., won't block). // = Utility methods. void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. }; #if !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) #define ACE_TSS_Guard ACE_Guard #define ACE_TSS_Write_GUARD ACE_Write_Guard #define ACE_TSS_Read_GUARD ACE_Read_Guard #else /* ACE platform supports some form of threading and thread-specific storage. */ template class ACE_TSS_Guard { // = TITLE // This data structure is meant to be used within a method or // function... It performs automatic aquisition and release of // a synchronization object. Moreover, it ensures that the lock // is released even if a thread exits via "thr_exit()"! public: // = Initialization and termination methods. ACE_TSS_Guard (ACE_LOCK &lock, int block = 1); // Implicitly and automatically acquire the thread-specific lock. ~ACE_TSS_Guard (void); // Implicitly release the thread-specific lock. // = Lock accessors. int acquire (void); // Explicitly acquire the thread-specific lock. int tryacquire (void); // Conditionally acquire the thread-specific lock (i.e., won't // block). int release (void); // Explicitly release the thread-specific lock. // = Utility methods. int remove (void); // Explicitly release the thread-specific lock. void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. protected: ACE_TSS_Guard (void); // Helper, meant for subclass only. void init_key (void); // Initialize the key. static void cleanup (void *ptr); // Called when thread exits to clean up the lock. ACE_thread_key_t key_; // Thread-specific key... private: // = Prevent assignment and initialization. ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_TSS_Guard &)) ACE_UNIMPLEMENTED_FUNC (ACE_TSS_Guard (const ACE_TSS_Guard &)) }; template class ACE_TSS_Write_Guard : public ACE_TSS_Guard { // = TITLE // This class is similar to class ACE_TSS_Guard, though it // acquires/releases a write-lock automatically (naturally, the // ACE_LOCK it is instantiated with must support the appropriate // API). public: // = Initialization method. ACE_TSS_Write_Guard (ACE_LOCK &lock, int block = 1); // Implicitly and automatically acquire the thread-specific write lock. // = Lock accessors. int acquire_write (void); // Explicitly acquire the thread-specific write lock. int acquire (void); // Explicitly acquire the thread-specific write lock. int tryacquire_write (void); // Conditionally acquire the thread-specific write lock (i.e., won't block). int tryacquire (void); // Conditionally acquire the thread-specific write lock (i.e., won't block). // = Utility methods. void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. }; template class ACE_TSS_Read_Guard : public ACE_TSS_Guard { // = TITLE // This class is similar to class , though it // acquires/releases a read lock automatically (naturally, the // it is instantiated with must support the // appropriate API). public: // = Initialization method. ACE_TSS_Read_Guard (ACE_LOCK &lock, int block = 1); // Implicitly and automatically acquire the thread-specific read lock. // = Lock accessors. int acquire_read (void); // Explicitly acquire the thread-specific read lock. int acquire (void); // Explicitly acquire the thread-specific read lock. int tryacquire_read (void); // Conditionally acquire the thread-specific read lock (i.e., won't // block). int tryacquire (void); // Conditionally acquire the thread-specific read lock (i.e., won't // block). // = Utility methods. void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. }; #endif /* !(defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))) */ #if defined (ACE_HAS_THREADS) /* ACE platform supports some form of threading. */ template class ACE_Condition { // = TITLE // ACE_Condition variable wrapper, which allows threads to block // until shared data changes state. // // A condition variable enables threads to atomically block and // test the condition under the protection of a mutual exclu- // sion lock (mutex) until the condition is satisfied. That is, // the mutex must have been held by the thread before calling // wait or signal on the condition. If the condition is false, // a thread blocks on a condition variable and atomically // releases the mutex that is waiting for the condition to // change. If another thread changes the condition, it may wake // up waiting threads by signaling the associated condition // variable. The waiting threads, upon awakening, reacquire the // mutex and re-evaluate the condition. // public: // = Initialiation and termination methods. ACE_Condition (MUTEX &m, int type = USYNC_THREAD, LPCTSTR name = 0, void *arg = 0); // Initialize the condition variable. ~ACE_Condition (void); // Implicitly destroy the condition variable. // = Lock accessors. int wait (const ACE_Time_Value *abstime); // Block on condition, or until absolute time-of-day has passed. If // abstime == 0 use "blocking" semantics. Else, if // != 0 and the call times out before the condition is signaled // returns -1 and sets errno to ETIME. int wait (void); // Block on condition. int wait (MUTEX &mutex, const ACE_Time_Value *abstime = 0); // Block on condition or until absolute time-of-day has passed. If // abstime == 0 use "blocking" wait() semantics on the // passed as a parameter (this is useful if you need to store the // in shared memory). Else, if != 0 and the // call times out before the condition is signaled returns -1 // and sets errno to ETIME. int signal (void); // Signal one waiting thread. int broadcast (void); // Signal *all* waiting threads. // = Utility methods. int remove (void); // Explicitly destroy the condition variable. MUTEX &mutex (void); // Returns a reference to the underlying mutex_; void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. protected: #if defined (CHORUS) ACE_cond_t *process_cond_; // This condition resides in shared memory. LPCTSTR condname_; // Remember the name of the condition if we created it so we can // unlink it when we go away (only the actor that initialized the // memory can destroy it). #endif /* CHORUS */ ACE_cond_t cond_; // Condition variable. MUTEX &mutex_; // Reference to mutex lock. private: // = Prevent assignment and initialization. ACE_UNIMPLEMENTED_FUNC (void operator= (const ACE_Condition &)) ACE_UNIMPLEMENTED_FUNC (ACE_Condition (const ACE_Condition &)) }; template class ACE_Thread_Condition : public ACE_Condition { // = TITLE // ACE_Condition variable wrapper that works within processes. // // = DESCRIPTION // A condition variable enables threads to atomically block and // test the condition under the protection of a mutual exclu- // sion lock (mutex) until the condition is satisfied. That is, // the mutex must have been held by the thread before calling // wait or signal on the condition. If the condition is false, // a thread blocks on a condition variable and atomically // releases the mutex that is waiting for the condition to // change. If another thread changes the condition, it may wake // up waiting threads by signaling the associated condition // variable. The waiting threads, upon awakening, reacquire the // mutex and re-evaluate the condition. public: // = Initialization method. ACE_Thread_Condition (MUTEX &m, LPCTSTR name = 0, void *arg = 0); void dump (void) const; // Dump the state of an object. // ACE_ALLOC_HOOK_DECLARE; // Declare the dynamic allocation hooks. }; #endif /* ACE_HAS_THREADS */ #if defined (ACE_HAS_TEMPLATE_TYPEDEFS) class ACE_Export ACE_NULL_SYNCH { // = TITLE // Implement a do nothing Synchronization wrapper that // typedefs the and to the Null* versions. public: typedef ACE_Null_Mutex MUTEX; typedef ACE_Null_Mutex NULL_MUTEX; typedef ACE_Null_Mutex PROCESS_MUTEX; typedef ACE_Null_Mutex RECURSIVE_MUTEX; typedef ACE_Null_Mutex RW_MUTEX; typedef ACE_Null_Condition CONDITION; typedef ACE_Null_Mutex SEMAPHORE; typedef ACE_Null_Mutex NULL_SEMAPHORE; }; #if defined (ACE_HAS_THREADS) class ACE_Export ACE_MT_SYNCH { // = TITLE // Implement a default thread safe synchronization wrapper that // typedefs the and to the // and versions. Note that this // should be a template, but SunC++ 4.0.1 complains about // this... public: typedef ACE_Thread_Mutex MUTEX; typedef ACE_Null_Mutex NULL_MUTEX; typedef ACE_Process_Mutex PROCESS_MUTEX; typedef ACE_Recursive_Thread_Mutex RECURSIVE_MUTEX; typedef ACE_RW_Thread_Mutex RW_MUTEX; typedef ACE_Condition_Thread_Mutex CONDITION; typedef ACE_Thread_Semaphore SEMAPHORE; typedef ACE_Null_Mutex NULL_SEMAPHORE; }; #endif /* ACE_HAS_THREADS */ #define ACE_SYNCH_MUTEX ACE_SYNCH::MUTEX #define ACE_SYNCH_NULL_MUTEX ACE_SYNCH::NULL_MUTEX #define ACE_SYNCH_RECURSIVE_MUTEX ACE_SYNCH::RECURSIVE_MUTEX #define ACE_SYNCH_RW_MUTEX ACE_SYNCH::RW_MUTEX #define ACE_SYNCH_CONDITION ACE_SYNCH::CONDITION #define ACE_SYNCH_NULL_SEMAPHORE ACE_SYNCH::NULL_SEMAPHORE #define ACE_SYNCH_SEMAPHORE ACE_SYNCH::SEMAPHORE #else /* !ACE_HAS_TEMPLATE_TYPEDEFS */ #if defined (ACE_HAS_OPTIMIZED_MESSAGE_QUEUE) #define ACE_NULL_SYNCH ACE_Null_Mutex, ACE_Null_Condition, ACE_Null_Mutex #define ACE_MT_SYNCH ACE_Thread_Mutex, ACE_Condition_Thread_Mutex, ACE_Thread_Semaphore #else #define ACE_NULL_SYNCH ACE_Null_Mutex, ACE_Null_Condition #define ACE_MT_SYNCH ACE_Thread_Mutex, ACE_Condition_Thread_Mutex #endif /* ACE_HAS_OPTIMIZED_MESSAGE_QUEUE */ #if defined (ACE_HAS_THREADS) #define ACE_SYNCH_MUTEX ACE_Thread_Mutex #define ACE_SYNCH_NULL_MUTEX ACE_Null_Mutex #define ACE_SYNCH_RECURSIVE_MUTEX ACE_Recursive_Thread_Mutex #define ACE_SYNCH_RW_MUTEX ACE_RW_Thread_Mutex #define ACE_SYNCH_CONDITION ACE_Condition_Thread_Mutex #define ACE_SYNCH_SEMAPHORE ACE_Thread_Semaphore #define ACE_SYNCH_NULL_SEMAPHORE ACE_Null_Mutex #else /* ACE_HAS_THREADS */ #define ACE_SYNCH_MUTEX ACE_Null_Mutex #define ACE_SYNCH_NULL_MUTEX ACE_Null_Mutex #define ACE_SYNCH_RECURSIVE_MUTEX ACE_Null_Mutex #define ACE_SYNCH_RW_MUTEX ACE_Null_Mutex #define ACE_SYNCH_CONDITION ACE_Null_Condition #define ACE_SYNCH_SEMAPHORE ACE_Thread_Semaphore #define ACE_SYNCH_NULL_SEMAPHORE ACE_Null_Mutex #endif /* ACE_HAS_THREADS */ #endif /* ACE_HAS_TEMPLATE_TYPEDEFS */ // These are available on *all* platforms #define ACE_SYNCH_PROCESS_SEMAPHORE ACE_Process_Semaphore #define ACE_SYNCH_PROCESS_MUTEX ACE_Process_Mutex #if defined (ACE_HAS_THREADS) #define ACE_SYNCH ACE_MT_SYNCH #else /* ACE_HAS_THREADS */ #define ACE_SYNCH ACE_NULL_SYNCH #endif /* ACE_HAS_THREADS */ #if defined (__ACE_INLINE__) #include "ace/Synch_T.i" // On non-Win32 platforms, this code will be inlined #if !defined (ACE_WIN32) #include "ace/Atomic_Op.i" #endif /* !ACE_WIN32 */ #endif /* __ACE_INLINE__ */ #if defined (ACE_TEMPLATES_REQUIRE_SOURCE) #include "ace/Synch_T.cpp" // On Win32 platforms, this code will be included as template source // code and will not be inlined. Therefore, we first turn off // ACE_INLINE, set it to be nothing, include the code, and then turn // ACE_INLINE back to its original setting. All this nonsense is // necessary, since the generic template code that needs to be // specialized cannot be inlined, else the compiler will ignore the // specialization code. Also, the specialization code *must* be // inlined or the compiler will ignore the specializations. #if defined (ACE_WIN32) #undef ACE_INLINE #define ACE_INLINE #include "ace/Atomic_Op.i" #undef ACE_INLINE #if defined (__ACE_INLINE__) #define ACE_INLINE inline #else #define ACE_INLINE #endif /* __ACE_INLINE__ */ #endif /* ACE_WIN32 */ #endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ #if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) #pragma implementation "Synch_T.cpp" #endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ #endif /* ACE_SYNCH_T_H */