diff options
54 files changed, 3236 insertions, 3136 deletions
diff --git a/ChangeLog b/ChangeLog index e15a9199695..cb88aee66d6 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,3 +1,66 @@ +Mon May 30 18:10:56 2005 Ossama Othman <ossama@dre.vanderbilt.edu> + + * ace/Addr.cpp: + * ace/Addr.inl: + * ace/Event_Handler_T.cpp: + * ace/Event_Handler_T.inl: + * ace/Free_List.cpp: + * ace/Free_List.inl: + * ace/Hashable.cpp: + * ace/Hashable.inl: + * ace/IOStream_T.cpp: + * ace/IOStream_T.inl: + * ace/Local_Tokens.cpp: + * ace/Local_Tokens.inl: + * ace/Lock_Adapter_T.cpp: + * ace/Lock_Adapter_T.inl: + * ace/Malloc_T.cpp: + * ace/Malloc_T.inl: + * ace/Map_T.cpp: + * ace/Map_T.inl: + * ace/Message_Block.cpp: + * ace/Message_Block.inl: + * ace/Message_Queue.cpp: + * ace/Message_Queue.inl: + * ace/Message_Queue_T.cpp: + * ace/Message_Queue_T.inl: + * ace/POSIX_CB_Proactor.cpp: + * ace/POSIX_CB_Proactor.inl: + * ace/POSIX_Proactor.cpp: + * ace/POSIX_Proactor.inl: + * ace/Refcounted_Auto_Ptr.h: + * ace/Refcounted_Auto_Ptr.inl: + * ace/Refcounted_Auto_Ptr.cpp: + * ace/Remote_Tokens.cpp: + * ace/Remote_Tokens.inl: + * ace/Reverse_Lock_T.cpp: + * ace/Reverse_Lock_T.inl: + * ace/SUN_Proactor.cpp: + * ace/SUN_Proactor.inl: + * ace/Shared_Memory_MM.cpp: + * ace/Shared_Memory_MM.inl: + * ace/Shared_Memory_SV.cpp: + * ace/Shared_Memory_SV.inl: + * ace/Strategies_T.cpp: + * ace/Strategies_T.inl: + * ace/String_Base.cpp: + * ace/Task.cpp: + * ace/Task.inl: + * ace/Thread_Manager.cpp: + * ace/Thread_Manager.inl: + * ace/Timer_Queue_Adapters.cpp: + * ace/Timer_Queue_Adapters.inl: + * ace/Timer_Queue_T.inl: + + Moved inlined virtual methods out of line. Addresses + RTTI-related problems when using g++ 4.0's + "-fvisibility-inlines-hidden" command line option. + + * ace/Makefile.am: + * ace/ace.mpc: + + Added Refcounted_Auto_Ptr.cpp to the list of template files. + Mon May 30 13:39:12 UTC 2005 Johnny Willemsen <jwillemsen@remedy.nl> * ace/Task.cpp: diff --git a/ace/Addr.cpp b/ace/Addr.cpp index eaf755de8d1..a627d8262c0 100644 --- a/ace/Addr.cpp +++ b/ace/Addr.cpp @@ -1,8 +1,12 @@ -// Addr.cpp // $Id$ #include "ace/Addr.h" -ACE_RCSID(ace, Addr, "$Id$") + + +ACE_RCSID (ace, + Addr, + "$Id$") + #if !defined (__ACE_INLINE__) #include "ace/Addr.inl" @@ -17,17 +21,28 @@ const ACE_Addr ACE_Addr::sap_any (AF_ANY, -1); ACE_ALLOC_HOOK_DEFINE(ACE_Addr) -void -ACE_Addr::dump (void) const + +// Initializes instance variables. Note that 0 is an unspecified +// protocol family type... + +ACE_Addr::ACE_Addr (int type, int size) { -#if defined (ACE_HAS_DUMP) - ACE_TRACE ("ACE_Addr::dump"); + this->base_set (type, size); +} - ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); - ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("addr_type_ = %d"), this->addr_type_)); - ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\naddr_size_ = %d"), this->addr_size_)); - ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); -#endif /* ACE_HAS_DUMP */ +ACE_Addr::~ACE_Addr (void) +{ +} + +void * +ACE_Addr::get_addr (void) const +{ + return 0; +} + +void +ACE_Addr::set_addr (void *, int) +{ } // Initializes instance variables. @@ -39,14 +54,15 @@ ACE_Addr::base_set (int type, int size) this->addr_size_ = size; } -// Initializes instance variables. Note that 0 is an unspecified -// protocol family type... - -ACE_Addr::ACE_Addr (int type, int size) +void +ACE_Addr::dump (void) const { - this->base_set (type, size); -} +#if defined (ACE_HAS_DUMP) + ACE_TRACE ("ACE_Addr::dump"); -ACE_Addr::~ACE_Addr (void) -{ + ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this)); + ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("addr_type_ = %d"), this->addr_type_)); + ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\naddr_size_ = %d"), this->addr_size_)); + ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP)); +#endif /* ACE_HAS_DUMP */ } diff --git a/ace/Addr.inl b/ace/Addr.inl index 95b90655bd9..34457d86612 100644 --- a/ace/Addr.inl +++ b/ace/Addr.inl @@ -2,20 +2,8 @@ // // $Id$ -// Addr.i - // Return the address of the address. -ACE_INLINE void * -ACE_Addr::get_addr (void) const -{ - return 0; -} - -ACE_INLINE void -ACE_Addr::set_addr (void *, int) -{ -} ACE_INLINE bool ACE_Addr::operator == (const ACE_Addr &sap) const diff --git a/ace/Event_Handler_T.cpp b/ace/Event_Handler_T.cpp index d2b19d1dfae..cbe9676a58e 100644 --- a/ace/Event_Handler_T.cpp +++ b/ace/Event_Handler_T.cpp @@ -1,8 +1,9 @@ // Event_Handler_T.cpp +// // $Id$ -#ifndef EVENT_HANDLER_T_C -#define EVENT_HANDLER_T_C +#ifndef ACE_EVENT_HANDLER_T_CPP +#define ACE_EVENT_HANDLER_T_CPP #include "ace/Event_Handler_T.h" @@ -10,14 +11,13 @@ # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -ACE_RCSID(ace, Event_Handler_T, "$Id$") - #if defined (ACE_HAS_TEMPLATE_TYPEDEFS) #if !defined (__ACE_INLINE__) #include "ace/Event_Handler_T.inl" #endif /* __ACE_INLINE__ */ + ACE_ALLOC_HOOK_DEFINE(ACE_Event_Handler_T) template <class T> void @@ -60,6 +60,63 @@ ACE_Event_Handler_T<T>::ACE_Event_Handler_T (T *op_handler, int delete_handler, ACE_TRACE ("ACE_Event_Handler_T<T>::ACE_Event_Handler_T"); } +template<class T> ACE_HANDLE +ACE_Event_Handler_T<T>::get_handle (void) const +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::get_handle"); + return this->get_handle_ == 0 ? ACE_INVALID_HANDLE : (this->op_handler_->*get_handle_) (); +} + +template<class T> void +ACE_Event_Handler_T<T>::set_handle (ACE_HANDLE h) +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::set_handle"); + if (this->set_handle_ != 0) + (this->op_handler_->*set_handle_) (h); +} + +template<class T> int +ACE_Event_Handler_T<T>::handle_input (ACE_HANDLE fd) +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::handle_input"); + return this->input_handler_ == 0 ? 0 : (this->op_handler_->*input_handler_) (fd); +} + +template<class T> int +ACE_Event_Handler_T<T>::handle_output (ACE_HANDLE fd) +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::handle_output"); + return this->output_handler_ == 0 ? 0 : (this->op_handler_->*output_handler_) (fd); +} + +template<class T> int +ACE_Event_Handler_T<T>::handle_exception (ACE_HANDLE fd) +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::handle_exception"); + return this->except_handler_ == 0 ? 0 : (this->op_handler_->*except_handler_) (fd); +} + +template<class T> int +ACE_Event_Handler_T<T>::handle_timeout (const ACE_Time_Value &tv, const void *arg) +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::handle_timeout"); + return this->to_handler_ == 0 ? 0 : (this->op_handler_->*to_handler_) (tv, arg); +} + +template<class T> int +ACE_Event_Handler_T<T>::handle_close (ACE_HANDLE fd, ACE_Reactor_Mask close_mask) +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::handle_close"); + return this->cl_handler_ == 0 ? 0 : (this->op_handler_->*cl_handler_) (fd, close_mask); +} + +template<class T> int +ACE_Event_Handler_T<T>::handle_signal (int signum, siginfo_t *s, ucontext_t *u) +{ + ACE_TRACE ("ACE_Event_Handler_T<T>::handle_signal"); + return this->sig_handler_ == 0 ? 0 : (this->op_handler_->*sig_handler_) (signum, s, u); +} + #endif /* ACE_HAS_TEMPLATE_TYPEDEFS */ -#endif /* EVENT_HANDLER_T_C */ +#endif /* ACE_EVENT_HANDLER_T_CPP */ diff --git a/ace/Event_Handler_T.inl b/ace/Event_Handler_T.inl index d096ebeed78..f5d85f862b5 100644 --- a/ace/Event_Handler_T.inl +++ b/ace/Event_Handler_T.inl @@ -1,8 +1,11 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ + #include "ace/Global_Macros.h" + template<class T> ACE_INLINE void ACE_Event_Handler_T<T>::op_handler (T *op) { @@ -17,63 +20,6 @@ ACE_Event_Handler_T<T>::op_handler (void) return this->op_handler_; } -template<class T> ACE_INLINE ACE_HANDLE -ACE_Event_Handler_T<T>::get_handle (void) const -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::get_handle"); - return this->get_handle_ == 0 ? ACE_INVALID_HANDLE : (this->op_handler_->*get_handle_) (); -} - -template<class T> ACE_INLINE void -ACE_Event_Handler_T<T>::set_handle (ACE_HANDLE h) -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::set_handle"); - if (this->set_handle_ != 0) - (this->op_handler_->*set_handle_) (h); -} - -template<class T> ACE_INLINE int -ACE_Event_Handler_T<T>::handle_input (ACE_HANDLE fd) -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::handle_input"); - return this->input_handler_ == 0 ? 0 : (this->op_handler_->*input_handler_) (fd); -} - -template<class T> ACE_INLINE int -ACE_Event_Handler_T<T>::handle_output (ACE_HANDLE fd) -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::handle_output"); - return this->output_handler_ == 0 ? 0 : (this->op_handler_->*output_handler_) (fd); -} - -template<class T> ACE_INLINE int -ACE_Event_Handler_T<T>::handle_exception (ACE_HANDLE fd) -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::handle_exception"); - return this->except_handler_ == 0 ? 0 : (this->op_handler_->*except_handler_) (fd); -} - -template<class T> ACE_INLINE int -ACE_Event_Handler_T<T>::handle_timeout (const ACE_Time_Value &tv, const void *arg) -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::handle_timeout"); - return this->to_handler_ == 0 ? 0 : (this->op_handler_->*to_handler_) (tv, arg); -} - -template<class T> ACE_INLINE int -ACE_Event_Handler_T<T>::handle_close (ACE_HANDLE fd, ACE_Reactor_Mask close_mask) -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::handle_close"); - return this->cl_handler_ == 0 ? 0 : (this->op_handler_->*cl_handler_) (fd, close_mask); -} - -template<class T> ACE_INLINE int -ACE_Event_Handler_T<T>::handle_signal (int signum, siginfo_t *s, ucontext_t *u) -{ - ACE_TRACE ("ACE_Event_Handler_T<T>::handle_signal"); - return this->sig_handler_ == 0 ? 0 : (this->op_handler_->*sig_handler_) (signum, s, u); -} - template<class T> ACE_INLINE ACE_TYPENAME ACE_Event_Handler_T<T>::GET_HANDLE ACE_Event_Handler_T<T>::handle_get (void) { diff --git a/ace/Free_List.cpp b/ace/Free_List.cpp index 0405fe1e9fb..23d00ebc960 100644 --- a/ace/Free_List.cpp +++ b/ace/Free_List.cpp @@ -1,9 +1,10 @@ // $Id$ -#ifndef ACE_FREE_LIST_C -#define ACE_FREE_LIST_C +#ifndef ACE_FREE_LIST_CPP +#define ACE_FREE_LIST_CPP #include "ace/Free_List.h" +#include "ace/Guard_T.h" #if !defined (ACE_LACKS_PRAGMA_ONCE) # pragma once @@ -13,7 +14,6 @@ #include "ace/Free_List.inl" #endif /* __ACE_INLINE__ */ -ACE_RCSID(ace, Free_List, "$Id$") // Empty constructor @@ -57,6 +57,77 @@ ACE_Locked_Free_List<T, ACE_LOCK>::~ACE_Locked_Free_List (void) } } +// Inserts an element onto the free list (if we are allowed to manage +// elements withing and it pasts the high water mark, delete the +// element) + +template <class T, class ACE_LOCK> void +ACE_Locked_Free_List<T, ACE_LOCK>::add (T *element) +{ + ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); + + // Check to see that we not at the high water mark. + if (this->mode_ == ACE_PURE_FREE_LIST + || this->size_ < this->hwm_) + { + element->set_next (this->free_list_); + this->free_list_ = element; + this->size_++; + } + else + delete element; +} + +// Takes a element off the freelist and returns it. It creates <inc> +// new elements if we are allowed to do it and the size is at the low +// water mark. + +template <class T, class ACE_LOCK> T * +ACE_Locked_Free_List<T, ACE_LOCK>::remove (void) +{ + ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0)); + + // If we are at the low water mark, add some nodes + if (this->mode_ != ACE_PURE_FREE_LIST && this->size_ <= this->lwm_) + this->alloc (this->inc_); + + // Remove a node + T *temp = this->free_list_; + + if (temp != 0) + { + this->free_list_ = this->free_list_->get_next (); + this->size_--; + } + + return temp; +} + + +// Returns the current size of the free list + +template <class T, class ACE_LOCK> size_t +ACE_Locked_Free_List<T, ACE_LOCK>::size (void) +{ + return this->size_; +} + +// Resizes the free list to <newsize> + +template <class T, class ACE_LOCK> void +ACE_Locked_Free_List<T, ACE_LOCK>::resize (size_t newsize) +{ + ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); + + // Check if we are allowed to resize + if (this->mode_ != ACE_PURE_FREE_LIST) + // Check to see if we grow or shrink + if (newsize < this->size_) + this->dealloc (this->size_ - newsize); + else + this->alloc (newsize - this->size_); +} + // Allocates <n> extra nodes for the freelist template <class T, class ACE_LOCK> void @@ -87,4 +158,4 @@ ACE_Locked_Free_List<T, ACE_LOCK>::dealloc (size_t n) } } -#endif /* ACE_FREE_LIST_C */ +#endif /* ACE_FREE_LIST_CPP */ diff --git a/ace/Free_List.inl b/ace/Free_List.inl index c5668dfd0bc..2ad999ebb73 100644 --- a/ace/Free_List.inl +++ b/ace/Free_List.inl @@ -1,77 +1,3 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ - -#include "ace/Guard_T.h" - -// Inserts an element onto the free list (if we are allowed to manage -// elements withing and it pasts the high water mark, delete the -// element) - -template <class T, class ACE_LOCK> ACE_INLINE void -ACE_Locked_Free_List<T, ACE_LOCK>::add (T *element) -{ - ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); - - // Check to see that we not at the high water mark. - if (this->mode_ == ACE_PURE_FREE_LIST - || this->size_ < this->hwm_) - { - element->set_next (this->free_list_); - this->free_list_ = element; - this->size_++; - } - else - delete element; -} - -// Takes a element off the freelist and returns it. It creates <inc> -// new elements if we are allowed to do it and the size is at the low -// water mark. - -template <class T, class ACE_LOCK> ACE_INLINE T * -ACE_Locked_Free_List<T, ACE_LOCK>::remove (void) -{ - ACE_MT (ACE_GUARD_RETURN (ACE_LOCK, ace_mon, this->mutex_, 0)); - - // If we are at the low water mark, add some nodes - if (this->mode_ != ACE_PURE_FREE_LIST && this->size_ <= this->lwm_) - this->alloc (this->inc_); - - // Remove a node - T *temp = this->free_list_; - - if (temp != 0) - { - this->free_list_ = this->free_list_->get_next (); - this->size_--; - } - - return temp; -} - - -// Returns the current size of the free list - -template <class T, class ACE_LOCK> ACE_INLINE size_t -ACE_Locked_Free_List<T, ACE_LOCK>::size (void) -{ - return this->size_; -} - -// Resizes the free list to <newsize> - -template <class T, class ACE_LOCK> ACE_INLINE void -ACE_Locked_Free_List<T, ACE_LOCK>::resize (size_t newsize) -{ - ACE_MT (ACE_GUARD (ACE_LOCK, ace_mon, this->mutex_)); - - // Check if we are allowed to resize - if (this->mode_ != ACE_PURE_FREE_LIST) - // Check to see if we grow or shrink - if (newsize < this->size_) - this->dealloc (this->size_ - newsize); - else - this->alloc (newsize - this->size_); -} - - diff --git a/ace/Hashable.cpp b/ace/Hashable.cpp index c07ec6d0d65..fca05cf96c5 100644 --- a/ace/Hashable.cpp +++ b/ace/Hashable.cpp @@ -1,8 +1,32 @@ //$Id$ + #include "ace/Hashable.h" #if !defined (__ACE_INLINE__) #include "ace/Hashable.inl" #endif /* __ACE_INLINE __ */ -ACE_RCSID(ace, Hashable, "$Id$") + +ACE_RCSID (ace, + Hashable, + "$Id$") + + +ACE_Hashable::~ACE_Hashable (void) +{ +} + +unsigned long +ACE_Hashable::hash (void) const +{ + // In doing the check below, we take chance of paying a performance + // price when the hash value is zero. But, that will (hopefully) + // happen far less often than a non-zero value, so this caching + // strategy should pay off, esp. if hash computation is expensive + // relative to the simple comparison. + + if (this->hash_value_ == 0) + (const_cast <ACE_Hashable *> (this))->hash_value_ = this->hash_i (); + + return this->hash_value_; +} diff --git a/ace/Hashable.inl b/ace/Hashable.inl index 69f6c3312a0..55f28b31da4 100644 --- a/ace/Hashable.inl +++ b/ace/Hashable.inl @@ -8,23 +8,3 @@ ACE_Hashable::ACE_Hashable (void) : hash_value_ (0) { } - -ACE_INLINE -ACE_Hashable::~ACE_Hashable (void) -{ -} - -ACE_INLINE unsigned long -ACE_Hashable::hash (void) const -{ - // In doing the check below, we take chance of paying a performance - // price when the hash value is zero. But, that will (hopefully) - // happen far less often than a non-zero value, so this caching - // strategy should pay off, esp. if hash computation is expensive - // relative to the simple comparison. - - if (this->hash_value_ == 0) - (const_cast <ACE_Hashable *> (this))->hash_value_ = this->hash_i (); - - return this->hash_value_; -} diff --git a/ace/IOStream_T.cpp b/ace/IOStream_T.cpp index d8ff9c53b15..237ce56b8bc 100644 --- a/ace/IOStream_T.cpp +++ b/ace/IOStream_T.cpp @@ -1,7 +1,7 @@ // $Id$ -#ifndef ACE_IOSTREAM_T_C -#define ACE_IOSTREAM_T_C +#ifndef ACE_IOSTREAM_T_CPP +#define ACE_IOSTREAM_T_CPP #include "ace/IOStream_T.h" #include "ace/OS_Memory.h" @@ -10,8 +10,6 @@ # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -ACE_RCSID(ace, IOStream_T, "$Id$") - #if !defined (ACE_LACKS_ACE_IOSTREAM) #if !defined (__ACE_INLINE__) @@ -48,6 +46,54 @@ ACE_Streambuf_T<STREAM>::ACE_Streambuf_T (STREAM *peer, #endif /* ! ACE_LACKS_LINEBUFFERED_STREAMBUF */ } +template <class STREAM> ssize_t +ACE_Streambuf_T<STREAM>::send (char *buf, ssize_t len) +{ + return peer_->send_n (buf,len); +} + +template <class STREAM> ssize_t +ACE_Streambuf_T<STREAM>::recv (char *buf, + ssize_t len, + ACE_Time_Value *tv) +{ + return this->recv (buf, len, 0, tv); +} + +template <class STREAM> ssize_t +ACE_Streambuf_T<STREAM>::recv (char *buf, + ssize_t len, + int flags, + ACE_Time_Value * tv) +{ + this->timeout_ = 0; + errno = ESUCCESS; + ssize_t rval = peer_->recv (buf, len, flags, tv); + if (errno == ETIME) + this->timeout_ = 1; + return rval; +} + +template <class STREAM> ssize_t +ACE_Streambuf_T<STREAM>::recv_n (char *buf, + ssize_t len, + int flags, + ACE_Time_Value *tv) +{ + this->timeout_ = 0; + errno = ESUCCESS; + ssize_t rval = peer_->recv_n (buf, len, flags, tv); + if (errno == ETIME) + this->timeout_ = 1; + return rval; +} + +template <class STREAM> ACE_HANDLE +ACE_Streambuf_T<STREAM>::get_handle (void) +{ + return peer_ ? peer_->get_handle () : 0; +} + // The typical constructor. This will initiailze your STREAM and then // setup the iostream baseclass to use a custom streambuf based on // STREAM. @@ -194,4 +240,4 @@ operator<< (STREAM &stream, #endif /* ACE_HAS_STRING_CLASS */ #endif /* ACE_LACKS_ACE_IOSTREAM */ -#endif /* ACE_IOSTREAM_T_C */ +#endif /* ACE_IOSTREAM_T_CPP */ diff --git a/ace/IOStream_T.inl b/ace/IOStream_T.inl index da8a071ee29..9d2fd414ca1 100644 --- a/ace/IOStream_T.inl +++ b/ace/IOStream_T.inl @@ -4,54 +4,6 @@ #include "ace/OS_NS_errno.h" #include "ace/OS_NS_sys_select.h" -template <class STREAM> ssize_t -ACE_Streambuf_T<STREAM>::send (char *buf, ssize_t len) -{ - return peer_->send_n (buf,len); -} - -template <class STREAM> ssize_t -ACE_Streambuf_T<STREAM>::recv (char *buf, - ssize_t len, - ACE_Time_Value *tv) -{ - return this->recv (buf, len, 0, tv); -} - -template <class STREAM> ssize_t -ACE_Streambuf_T<STREAM>::recv (char *buf, - ssize_t len, - int flags, - ACE_Time_Value * tv) -{ - this->timeout_ = 0; - errno = ESUCCESS; - ssize_t rval = peer_->recv (buf, len, flags, tv); - if (errno == ETIME) - this->timeout_ = 1; - return rval; -} - -template <class STREAM> ssize_t -ACE_Streambuf_T<STREAM>::recv_n (char *buf, - ssize_t len, - int flags, - ACE_Time_Value *tv) -{ - this->timeout_ = 0; - errno = ESUCCESS; - ssize_t rval = peer_->recv_n (buf, len, flags, tv); - if (errno == ETIME) - this->timeout_ = 1; - return rval; -} - -template <class STREAM> ACE_HANDLE -ACE_Streambuf_T<STREAM>::get_handle (void) -{ - return peer_ ? peer_->get_handle () : 0; -} - template <class STREAM> ACE_INLINE int ACE_IOStream<STREAM>::eof (void) const { diff --git a/ace/Local_Tokens.cpp b/ace/Local_Tokens.cpp index 0281408a602..4600ef95e5d 100644 --- a/ace/Local_Tokens.cpp +++ b/ace/Local_Tokens.cpp @@ -40,6 +40,10 @@ ACE_Tokens::ACE_Tokens (void) ACE_TRACE ("ACE_Tokens::ACE_Tokens"); } +ACE_Tokens::~ACE_Tokens (void) +{ +} + void ACE_Tokens::make_owner (ACE_TPQ_Entry *caller) { @@ -47,6 +51,20 @@ ACE_Tokens::make_owner (ACE_TPQ_Entry *caller) this->waiters_.enqueue (caller, 0); } +ACE_Token_Proxy_Queue * +ACE_Tokens::waiters () +{ + ACE_TRACE ("ACE_Tokens::waiters"); + return &this->waiters_; +} + +int +ACE_Tokens::no_of_waiters () +{ + ACE_TRACE ("ACE_Tokens::no_of_waiters"); + return this->waiters_.size (); +} + #if defined (ACE_LACKS_INLINE_FUNCTIONS) ACE_Null_Token::ACE_Null_Token (void) { @@ -161,6 +179,9 @@ ACE_TPQ_Entry::client_id (const ACE_TCHAR *id) ACE_MAXCLIENTIDLEN); } +ACE_TSS_TPQ_Entry::~ACE_TSS_TPQ_Entry (void) +{ + void ACE_TSS_TPQ_Entry::dump (void) const { @@ -668,6 +689,22 @@ ACE_Mutex_Token::is_owner (const ACE_TCHAR *id) return 0; } +int +ACE_Mutex_Token::type (void) const +{ + ACE_TRACE ("ACE_Mutex_Token::type"); + return (int) ACE_Tokens::MUTEX; +} + +// ************************************************************ + +int +ACE_RW_Token::type (void) const +{ + ACE_TRACE ("ACE_RW_Token::type"); + return (int) ACE_Tokens::RWLOCK; +} + void ACE_RW_Token::dump (void) const { @@ -1412,6 +1449,45 @@ ACE_Token_Proxy::token_acquired (ACE_TPQ_Entry *e) return; } +int +ACE_Token_Proxy::type (void) const +{ + ACE_TRACE ("ACE_Token_Proxy::type"); + return 0; +} + +int +ACE_Token_Proxy::acquire_read (int notify, + void (*sleep_hook)(void *), + ACE_Synch_Options &options) +{ + return this->acquire (notify, + sleep_hook, + options); +} + +int +ACE_Token_Proxy::acquire_write (int notify, + void (*sleep_hook)(void *), + ACE_Synch_Options &options) +{ + return this->acquire (notify, + sleep_hook, + options); +} + +int +ACE_Token_Proxy::tryacquire_read (void (*sleep_hook)(void *)) +{ + return this->tryacquire (sleep_hook); +} + +int +ACE_Token_Proxy::tryacquire_write (void (*sleep_hook)(void *)) +{ + return this->tryacquire (sleep_hook); +} + ACE_Token_Name::ACE_Token_Name (const ACE_TCHAR *token_name) { ACE_TRACE ("ACE_Token_Name::ACE_Token_Name"); @@ -1448,6 +1524,104 @@ ACE_Token_Name::dump (void) const #endif /* ACE_HAS_DUMP */ } +// ************************************************************ + +ACE_Token_Proxy * +ACE_Local_Mutex::clone (void) const +{ + ACE_Token_Proxy *temp = 0; + ACE_NEW_RETURN (temp, + ACE_Local_Mutex (token_->name (), + ignore_deadlock_, + debug_), + 0); + return temp; +} + +ACE_Tokens * +ACE_Local_Mutex::create_token (const ACE_TCHAR *name) +{ + ACE_Tokens *temp = 0; + ACE_NEW_RETURN (temp, + ACE_Mutex_Token (name), + 0); + return temp; +} + +ACE_Local_Mutex::~ACE_Local_Mutex (void) +{ +} + +// ************************************************************ + +ACE_Local_RLock::~ACE_Local_RLock (void) +{ +} + +ACE_Tokens * +ACE_Local_RLock::create_token (const ACE_TCHAR *name) +{ + ACE_Tokens *temp = 0; + ACE_NEW_RETURN (temp, + ACE_RW_Token (name), + 0); + return temp; +} + +int +ACE_Local_RLock::type (void) const +{ + return ACE_RW_Token::READER; +} + +ACE_Token_Proxy * +ACE_Local_RLock::clone (void) const +{ + ACE_Token_Proxy *temp = 0; + ACE_NEW_RETURN (temp, + ACE_Local_RLock (token_->name (), + ignore_deadlock_, + debug_), + 0); + return temp; +} + +// ************************************************************ + +ACE_Local_WLock::~ACE_Local_WLock (void) +{ +} + +ACE_Tokens * +ACE_Local_WLock::create_token (const ACE_TCHAR *name) +{ + ACE_Tokens *temp = 0; + ACE_NEW_RETURN (temp, + ACE_RW_Token (name), + 0); + return temp; +} + +int +ACE_Local_WLock::type (void) const +{ + return ACE_RW_Token::WRITER; +} + +ACE_Token_Proxy * +ACE_Local_WLock::clone (void) const +{ + ACE_Token_Proxy *temp = 0; + ACE_NEW_RETURN (temp, + ACE_Local_WLock (token_->name (), + ignore_deadlock_, + debug_), + 0); + return temp; +} + +// ************************************************************ + #if defined (ACE_HAS_EXPLICIT_TEMPLATE_INSTANTIATION) #if !defined (ACE_NO_TSS_TOKENS) diff --git a/ace/Local_Tokens.inl b/ace/Local_Tokens.inl index 5fed1b6c025..3008f25c69a 100644 --- a/ace/Local_Tokens.inl +++ b/ace/Local_Tokens.inl @@ -3,45 +3,6 @@ #if defined (ACE_HAS_TOKENS_LIBRARY) -ACE_INLINE int -ACE_Token_Proxy::type (void) const -{ - ACE_TRACE ("ACE_Token_Proxy::type"); - return 0; -} - -ACE_INLINE int -ACE_Token_Proxy::acquire_read (int notify, - void (*sleep_hook)(void *), - ACE_Synch_Options &options) -{ - return this->acquire (notify, - sleep_hook, - options); -} - -ACE_INLINE int -ACE_Token_Proxy::acquire_write (int notify, - void (*sleep_hook)(void *), - ACE_Synch_Options &options) -{ - return this->acquire (notify, - sleep_hook, - options); -} - -ACE_INLINE int -ACE_Token_Proxy::tryacquire_read (void (*sleep_hook)(void *)) -{ - return this->tryacquire (sleep_hook); -} - -ACE_INLINE int -ACE_Token_Proxy::tryacquire_write (void (*sleep_hook)(void *)) -{ - return this->tryacquire (sleep_hook); -} - // ************************************************************ ACE_INLINE int @@ -89,11 +50,6 @@ ACE_TPQ_Entry::proxy (ACE_Token_Proxy *proxy) } ACE_INLINE -ACE_TSS_TPQ_Entry::~ACE_TSS_TPQ_Entry (void) -{ -} - -ACE_INLINE ACE_TPQ_Iterator::~ACE_TPQ_Iterator (void) { } @@ -103,11 +59,6 @@ ACE_Token_Proxy_Queue::~ACE_Token_Proxy_Queue (void) { } -ACE_INLINE -ACE_Tokens::~ACE_Tokens (void) -{ -} - ACE_INLINE void ACE_Tokens::remove (ACE_TPQ_Entry *caller) { @@ -134,20 +85,6 @@ ACE_Tokens::inc_reference (void) ++this->reference_count_; } -ACE_INLINE ACE_Token_Proxy_Queue * -ACE_Tokens::waiters () -{ - ACE_TRACE ("ACE_Tokens::waiters"); - return &this->waiters_; -} - -ACE_INLINE int -ACE_Tokens::no_of_waiters () -{ - ACE_TRACE ("ACE_Tokens::no_of_waiters"); - return this->waiters_.size (); -} - ACE_INLINE const ACE_TPQ_Entry * ACE_Token_Proxy_Queue::head (void) { @@ -217,24 +154,6 @@ ACE_Tokens::current_owner (void) // ************************************************************ ACE_INLINE int -ACE_Mutex_Token::type (void) const -{ - ACE_TRACE ("ACE_Mutex_Token::type"); - return (int) ACE_Tokens::MUTEX; -} - -// ************************************************************ - -ACE_INLINE int -ACE_RW_Token::type (void) const -{ - ACE_TRACE ("ACE_RW_Token::type"); - return (int) ACE_Tokens::RWLOCK; -} - -// ************************************************************ - -ACE_INLINE int ACE_TPQ_Entry::nesting_level (void) const { ACE_TRACE ("ACE_TPQ_Entry::nesting_level"); @@ -318,33 +237,6 @@ ACE_Token_Name::name (void) const return this->token_name_; } -ACE_INLINE ACE_Token_Proxy * -ACE_Local_Mutex::clone (void) const -{ - ACE_Token_Proxy *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Local_Mutex (token_->name (), - ignore_deadlock_, - debug_), - 0); - return temp; -} - -ACE_INLINE ACE_Tokens * -ACE_Local_Mutex::create_token (const ACE_TCHAR *name) -{ - ACE_Tokens *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Mutex_Token (name), - 0); - return temp; -} - -ACE_INLINE -ACE_Local_Mutex::~ACE_Local_Mutex (void) -{ -} - // ************************************************************ ACE_INLINE @@ -356,39 +248,6 @@ ACE_Local_RLock::ACE_Local_RLock (const ACE_TCHAR *token_name, this->open (token_name, ignore_deadlock, debug); } -ACE_INLINE -ACE_Local_RLock::~ACE_Local_RLock (void) -{ -} - -ACE_INLINE ACE_Tokens * -ACE_Local_RLock::create_token (const ACE_TCHAR *name) -{ - ACE_Tokens *temp = 0; - ACE_NEW_RETURN (temp, - ACE_RW_Token (name), - 0); - return temp; -} - -ACE_INLINE int -ACE_Local_RLock::type (void) const -{ - return ACE_RW_Token::READER; -} - -ACE_INLINE ACE_Token_Proxy * -ACE_Local_RLock::clone (void) const -{ - ACE_Token_Proxy *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Local_RLock (token_->name (), - ignore_deadlock_, - debug_), - 0); - return temp; -} - // ************************************************************ ACE_INLINE @@ -400,39 +259,6 @@ ACE_Local_WLock::ACE_Local_WLock (const ACE_TCHAR *token_name, this->open (token_name, ignore_deadlock, debug); } -ACE_INLINE -ACE_Local_WLock::~ACE_Local_WLock (void) -{ -} - -ACE_INLINE ACE_Tokens * -ACE_Local_WLock::create_token (const ACE_TCHAR *name) -{ - ACE_Tokens *temp = 0; - ACE_NEW_RETURN (temp, - ACE_RW_Token (name), - 0); - return temp; -} - -ACE_INLINE int -ACE_Local_WLock::type (void) const -{ - return ACE_RW_Token::WRITER; -} - -ACE_INLINE ACE_Token_Proxy * -ACE_Local_WLock::clone (void) const -{ - ACE_Token_Proxy *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Local_WLock (token_->name (), - ignore_deadlock_, - debug_), - 0); - return temp; -} - // ************************************************************ diff --git a/ace/Lock_Adapter_T.cpp b/ace/Lock_Adapter_T.cpp index ab69d2387bb..d71a1fbd2fc 100644 --- a/ace/Lock_Adapter_T.cpp +++ b/ace/Lock_Adapter_T.cpp @@ -1,7 +1,7 @@ // $Id$ -#ifndef ACE_LOCK_ADAPTER_T_C -#define ACE_LOCK_ADAPTER_T_C +#ifndef ACE_LOCK_ADAPTER_T_CPP +#define ACE_LOCK_ADAPTER_T_CPP #include "ace/Lock_Adapter_T.h" #include "ace/OS_Memory.h" // for ACE_NEW @@ -10,12 +10,11 @@ # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -ACE_RCSID(ace, Lock_Adapter_T, "$Id$") - #if !defined (__ACE_INLINE__) #include "ace/Lock_Adapter_T.inl" #endif /* __ACE_INLINE__ */ + // This constructor isn't inlined, because SunPRO C++ 4.2 + patch // 104631-07 has trouble compiling TAO with it inline. template <class ACE_LOCKING_MECHANISM> @@ -27,4 +26,89 @@ ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::ACE_Lock_Adapter (void) ACE_LOCKING_MECHANISM); } -#endif /* ACE_LOCK_ADAPTER_T_C */ +template <class ACE_LOCKING_MECHANISM> +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::~ACE_Lock_Adapter (void) +{ + if (this->delete_lock_) + delete this->lock_; +} + +// Explicitly destroy the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::remove (void) +{ + return this->lock_->remove (); +} + +// Block the thread until the lock is acquired. +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire (void) +{ + return this->lock_->acquire (); +} + +// Conditionally acquire the lock (i.e., won't block). + +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire (void) +{ + return this->lock_->tryacquire (); +} + +// Release the lock. + +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::release (void) +{ + return this->lock_->release (); +} + +// Block until the thread acquires a read lock. If the locking +// mechanism doesn't support read locks then this just calls +// <acquire>. + +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_read (void) +{ + return this->lock_->acquire_read (); +} + +// Block until the thread acquires a write lock. If the locking +// mechanism doesn't support read locks then this just calls +// <acquire>. + +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_write (void) +{ + return this->lock_->acquire_write (); +} + +// Conditionally acquire a read lock. If the locking mechanism +// doesn't support read locks then this just calls <acquire>. + +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_read (void) +{ + return this->lock_->tryacquire_read (); +} + +// Conditionally acquire a write lock. If the locking mechanism +// doesn't support write locks then this just calls <acquire>. + +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write (void) +{ + return this->lock_->tryacquire_write (); +} + +// Conditionally try to upgrade a lock held for read to a write lock. +// If the locking mechanism doesn't support read locks then this just +// calls <acquire>. Returns 0 on success, -1 on failure. + +template <class ACE_LOCKING_MECHANISM> int +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade (void) +{ + return this->lock_->tryacquire_write_upgrade (); +} + +#endif /* ACE_LOCK_ADAPTER_T_CPP */ diff --git a/ace/Lock_Adapter_T.inl b/ace/Lock_Adapter_T.inl index 90ba3002e6f..2ecd393d56d 100644 --- a/ace/Lock_Adapter_T.inl +++ b/ace/Lock_Adapter_T.inl @@ -1,94 +1,12 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ -template <class ACE_LOCKING_MECHANISM> ACE_INLINE -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::ACE_Lock_Adapter (ACE_LOCKING_MECHANISM &lock) +template <class ACE_LOCKING_MECHANISM> +ACE_INLINE +ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::ACE_Lock_Adapter ( + ACE_LOCKING_MECHANISM &lock) : lock_ (&lock), delete_lock_ (0) { } - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::~ACE_Lock_Adapter (void) -{ - if (this->delete_lock_) - delete this->lock_; -} - -// Explicitly destroy the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::remove (void) -{ - return this->lock_->remove (); -} - -// Block the thread until the lock is acquired. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire (void) -{ - return this->lock_->acquire (); -} - -// Conditionally acquire the lock (i.e., won't block). - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire (void) -{ - return this->lock_->tryacquire (); -} - -// Release the lock. - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::release (void) -{ - return this->lock_->release (); -} - -// Block until the thread acquires a read lock. If the locking -// mechanism doesn't support read locks then this just calls -// <acquire>. - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_read (void) -{ - return this->lock_->acquire_read (); -} - -// Block until the thread acquires a write lock. If the locking -// mechanism doesn't support read locks then this just calls -// <acquire>. - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::acquire_write (void) -{ - return this->lock_->acquire_write (); -} - -// Conditionally acquire a read lock. If the locking mechanism -// doesn't support read locks then this just calls <acquire>. - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_read (void) -{ - return this->lock_->tryacquire_read (); -} - -// Conditionally acquire a write lock. If the locking mechanism -// doesn't support write locks then this just calls <acquire>. - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write (void) -{ - return this->lock_->tryacquire_write (); -} - -// Conditionally try to upgrade a lock held for read to a write lock. -// If the locking mechanism doesn't support read locks then this just -// calls <acquire>. Returns 0 on success, -1 on failure. - -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Lock_Adapter<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade (void) -{ - return this->lock_->tryacquire_write_upgrade (); -} diff --git a/ace/Makefile.am b/ace/Makefile.am index 9ea746c50fb..7528d8a81d1 100644 --- a/ace/Makefile.am +++ b/ace/Makefile.am @@ -824,6 +824,7 @@ nobase_include_HEADERS = \ Refcountable.inl \ Refcounted_Auto_Ptr.h \ Refcounted_Auto_Ptr.inl \ + Refcounted_Auto_Ptr.cpp \ Registry.h \ Registry_Name_Space.h \ Remote_Name_Space.h \ diff --git a/ace/Malloc_T.cpp b/ace/Malloc_T.cpp index 47e4ebb3f21..e228f89c6c5 100644 --- a/ace/Malloc_T.cpp +++ b/ace/Malloc_T.cpp @@ -1,8 +1,7 @@ -// Malloc_T.cpp // $Id$ -#ifndef ACE_MALLOC_T_C -#define ACE_MALLOC_T_C +#ifndef ACE_MALLOC_T_CPP +#define ACE_MALLOC_T_CPP #include "ace/Malloc_T.h" @@ -17,7 +16,6 @@ #include "ace/ACE.h" #include "ace/OS_NS_string.h" -ACE_RCSID(ace, Malloc_T, "$Id$") template <class T, class ACE_LOCK> ACE_Cached_Allocator<T, ACE_LOCK>::ACE_Cached_Allocator (size_t n_chunks) @@ -57,6 +55,48 @@ ACE_Cached_Allocator<T, ACE_LOCK>::~ACE_Cached_Allocator (void) delete [] this->pool_; } +template <class T, class ACE_LOCK> void * +ACE_Cached_Allocator<T, ACE_LOCK>::malloc (size_t nbytes) +{ + // Check if size requested fits within pre-determined size. + if (nbytes > sizeof (T)) + return 0; + + // addr() call is really not absolutely necessary because of the way + // ACE_Cached_Mem_Pool_Node's internal structure arranged. + return this->free_list_.remove ()->addr (); +} + +template <class T, class ACE_LOCK> void * +ACE_Cached_Allocator<T, ACE_LOCK>::calloc (size_t nbytes, + char initial_value) +{ + // Check if size requested fits within pre-determined size. + if (nbytes > sizeof (T)) + return 0; + + // addr() call is really not absolutely necessary because of the way + // ACE_Cached_Mem_Pool_Node's internal structure arranged. + void *ptr = this->free_list_.remove ()->addr (); + ACE_OS::memset (ptr, initial_value, sizeof (T)); + return ptr; +} + +template <class T, class ACE_LOCK> void * +ACE_Cached_Allocator<T, ACE_LOCK>::calloc (size_t, + size_t, + char) +{ + ACE_NOTSUP_RETURN (0); +} + +template <class T, class ACE_LOCK> void +ACE_Cached_Allocator<T, ACE_LOCK>::free (void * ptr) +{ + if (ptr != 0) + this->free_list_.add ((ACE_Cached_Mem_Pool_Node<T> *) ptr) ; +} + template <class ACE_LOCK> ACE_Dynamic_Cached_Allocator<ACE_LOCK>::ACE_Dynamic_Cached_Allocator (size_t n_chunks, size_t chunk_size) @@ -87,8 +127,153 @@ ACE_Dynamic_Cached_Allocator<ACE_LOCK>::~ACE_Dynamic_Cached_Allocator (void) chunk_size_ = 0; } +template <class ACE_LOCK> void * +ACE_Dynamic_Cached_Allocator<ACE_LOCK>::malloc (size_t nbytes) +{ + // Check if size requested fits within pre-determined size. + if (nbytes > chunk_size_) + return 0; + + // addr() call is really not absolutely necessary because of the way + // ACE_Cached_Mem_Pool_Node's internal structure arranged. + return this->free_list_.remove ()->addr (); +} + +template <class ACE_LOCK> void * +ACE_Dynamic_Cached_Allocator<ACE_LOCK>::calloc (size_t nbytes, + char initial_value) +{ + // Check if size requested fits within pre-determined size. + if (nbytes > chunk_size_) + return 0; + + // addr() call is really not absolutely necessary because of the way + // ACE_Cached_Mem_Pool_Node's internal structure arranged. + void *ptr = this->free_list_.remove ()->addr (); + ACE_OS::memset (ptr, initial_value, chunk_size_); + return ptr; +} + +template <class ACE_LOCK> void * +ACE_Dynamic_Cached_Allocator<ACE_LOCK>::calloc (size_t, size_t, char) +{ + ACE_NOTSUP_RETURN (0); +} + +template <class ACE_LOCK> void +ACE_Dynamic_Cached_Allocator<ACE_LOCK>::free (void * ptr) +{ + if (ptr != 0) + this->free_list_.add ((ACE_Cached_Mem_Pool_Node<char> *) ptr); +} + ACE_ALLOC_HOOK_DEFINE (ACE_Malloc_T) +template <class MALLOC> void * +ACE_Allocator_Adapter<MALLOC>::malloc (size_t nbytes) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::malloc"); + return this->allocator_.malloc (nbytes); +} + +template <class MALLOC> void * +ACE_Allocator_Adapter<MALLOC>::calloc (size_t nbytes, + char initial_value) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::calloc"); + return this->allocator_.calloc (nbytes, initial_value); +} + +template <class MALLOC> void * +ACE_Allocator_Adapter<MALLOC>::calloc (size_t n_elem, + size_t elem_size, + char initial_value) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::calloc"); + return this->allocator_.calloc (n_elem, elem_size, initial_value); +} + +template <class MALLOC> MALLOC & +ACE_Allocator_Adapter<MALLOC>::alloc (void) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::allocator"); + return this->allocator_; +} + +template <class MALLOC> void +ACE_Allocator_Adapter<MALLOC>::free (void *ptr) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::free"); + this->allocator_.free (ptr); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::remove (void) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::remove"); + return this->allocator_.remove (); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::trybind (const char *name, + void *&pointer) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::trybind"); + return this->allocator_.trybind (name, pointer); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::bind (const char *name, + void *pointer, + int duplicates) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::bind"); + return this->allocator_.bind (name, pointer, duplicates); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::find (const char *name, + void *&pointer) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::find"); + return this->allocator_.find (name, pointer); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::find (const char *name) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::find"); + return this->allocator_.find (name); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::unbind (const char *name, void *&pointer) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::unbind"); + return this->allocator_.unbind (name, pointer); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::unbind (const char *name) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::unbind"); + return this->allocator_.unbind (name); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::sync (ssize_t len, int flags) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::sync"); + return this->allocator_.sync (len, flags); +} + +template <class MALLOC> int +ACE_Allocator_Adapter<MALLOC>::sync (void *addr, size_t len, int flags) +{ + ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::sync"); + return this->allocator_.sync (addr, len, flags); +} + template <class MALLOC> int ACE_Allocator_Adapter<MALLOC>::protect (ssize_t len, int flags) { diff --git a/ace/Malloc_T.inl b/ace/Malloc_T.inl index 109d1153336..ff9fc26f4be 100644 --- a/ace/Malloc_T.inl +++ b/ace/Malloc_T.inl @@ -25,205 +25,18 @@ ACE_Cached_Mem_Pool_Node<T>::set_next (ACE_Cached_Mem_Pool_Node<T> *ptr) this->next_ = ptr; } -template <class T, class ACE_LOCK> ACE_INLINE void * -ACE_Cached_Allocator<T, ACE_LOCK>::malloc (size_t nbytes) -{ - // Check if size requested fits within pre-determined size. - if (nbytes > sizeof (T)) - return 0; - - // addr() call is really not absolutely necessary because of the way - // ACE_Cached_Mem_Pool_Node's internal structure arranged. - return this->free_list_.remove ()->addr (); -} - -template <class T, class ACE_LOCK> ACE_INLINE void * -ACE_Cached_Allocator<T, ACE_LOCK>::calloc (size_t nbytes, - char initial_value) -{ - // Check if size requested fits within pre-determined size. - if (nbytes > sizeof (T)) - return 0; - - // addr() call is really not absolutely necessary because of the way - // ACE_Cached_Mem_Pool_Node's internal structure arranged. - void *ptr = this->free_list_.remove ()->addr (); - ACE_OS::memset (ptr, initial_value, sizeof (T)); - return ptr; -} - -template <class T, class ACE_LOCK> ACE_INLINE void * -ACE_Cached_Allocator<T, ACE_LOCK>::calloc (size_t, - size_t, - char) -{ - ACE_NOTSUP_RETURN (0); -} - -template <class T, class ACE_LOCK> ACE_INLINE void -ACE_Cached_Allocator<T, ACE_LOCK>::free (void * ptr) -{ - if (ptr != 0) - this->free_list_.add ((ACE_Cached_Mem_Pool_Node<T> *) ptr) ; -} - template <class T, class ACE_LOCK> ACE_INLINE size_t ACE_Cached_Allocator<T, ACE_LOCK>::pool_depth (void) { return this->free_list_.size (); } -template <class ACE_LOCK> ACE_INLINE void * -ACE_Dynamic_Cached_Allocator<ACE_LOCK>::malloc (size_t nbytes) -{ - // Check if size requested fits within pre-determined size. - if (nbytes > chunk_size_) - return 0; - - // addr() call is really not absolutely necessary because of the way - // ACE_Cached_Mem_Pool_Node's internal structure arranged. - return this->free_list_.remove ()->addr (); -} - -template <class ACE_LOCK> ACE_INLINE void * -ACE_Dynamic_Cached_Allocator<ACE_LOCK>::calloc (size_t nbytes, - char initial_value) -{ - // Check if size requested fits within pre-determined size. - if (nbytes > chunk_size_) - return 0; - - // addr() call is really not absolutely necessary because of the way - // ACE_Cached_Mem_Pool_Node's internal structure arranged. - void *ptr = this->free_list_.remove ()->addr (); - ACE_OS::memset (ptr, initial_value, chunk_size_); - return ptr; -} - -template <class ACE_LOCK> ACE_INLINE void * -ACE_Dynamic_Cached_Allocator<ACE_LOCK>::calloc (size_t, size_t, char) -{ - ACE_NOTSUP_RETURN (0); -} - -template <class ACE_LOCK> ACE_INLINE void -ACE_Dynamic_Cached_Allocator<ACE_LOCK>::free (void * ptr) -{ - if (ptr != 0) - this->free_list_.add ((ACE_Cached_Mem_Pool_Node<char> *) ptr); -} - template <class ACE_LOCK> ACE_INLINE size_t ACE_Dynamic_Cached_Allocator<ACE_LOCK>::pool_depth (void) { return this->free_list_.size (); } -template <class MALLOC> ACE_INLINE void * -ACE_Allocator_Adapter<MALLOC>::malloc (size_t nbytes) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::malloc"); - return this->allocator_.malloc (nbytes); -} - -template <class MALLOC> ACE_INLINE void * -ACE_Allocator_Adapter<MALLOC>::calloc (size_t nbytes, - char initial_value) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::calloc"); - return this->allocator_.calloc (nbytes, initial_value); -} - -template <class MALLOC> ACE_INLINE void * -ACE_Allocator_Adapter<MALLOC>::calloc (size_t n_elem, - size_t elem_size, - char initial_value) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::calloc"); - return this->allocator_.calloc (n_elem, elem_size, initial_value); -} - -template <class MALLOC> ACE_INLINE MALLOC & -ACE_Allocator_Adapter<MALLOC>::alloc (void) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::allocator"); - return this->allocator_; -} - -template <class MALLOC> ACE_INLINE void -ACE_Allocator_Adapter<MALLOC>::free (void *ptr) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::free"); - this->allocator_.free (ptr); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::remove (void) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::remove"); - return this->allocator_.remove (); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::trybind (const char *name, - void *&pointer) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::trybind"); - return this->allocator_.trybind (name, pointer); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::bind (const char *name, - void *pointer, - int duplicates) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::bind"); - return this->allocator_.bind (name, pointer, duplicates); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::find (const char *name, - void *&pointer) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::find"); - return this->allocator_.find (name, pointer); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::find (const char *name) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::find"); - return this->allocator_.find (name); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::unbind (const char *name, void *&pointer) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::unbind"); - return this->allocator_.unbind (name, pointer); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::unbind (const char *name) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::unbind"); - return this->allocator_.unbind (name); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::sync (ssize_t len, int flags) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::sync"); - return this->allocator_.sync (len, flags); -} - -template <class MALLOC> ACE_INLINE int -ACE_Allocator_Adapter<MALLOC>::sync (void *addr, size_t len, int flags) -{ - ACE_TRACE ("ACE_Allocator_Adapter<MALLOC>::sync"); - return this->allocator_.sync (addr, len, flags); -} - template <ACE_MEM_POOL_1, class ACE_LOCK, class ACE_CB> ACE_INLINE int ACE_Malloc_T<ACE_MEM_POOL_2, ACE_LOCK, ACE_CB>::ref_counter (void) { diff --git a/ace/Map_T.cpp b/ace/Map_T.cpp index 2522962f0bc..9fde641a348 100644 --- a/ace/Map_T.cpp +++ b/ace/Map_T.cpp @@ -1,7 +1,7 @@ // $Id$ -#ifndef ACE_MAP_T_C -#define ACE_MAP_T_C +#ifndef ACE_MAP_T_CPP +#define ACE_MAP_T_CPP #include "ace/Map_T.h" @@ -13,6 +13,1323 @@ #include "ace/Map_T.inl" #endif /* __ACE_INLINE__ */ -ACE_RCSID(ace, Map_T, "$Id$") -#endif /* ACE_MAP_T_C */ +template <class T> +ACE_Iterator_Impl<T>::~ACE_Iterator_Impl (void) +{ +} + +template <class T> +ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl (void) +{ +} + +template <class T, class IMPLEMENTATION, class ENTRY> +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter (void) +{ +} + + +template <class T, class IMPLEMENTATION, class ENTRY> ACE_Iterator_Impl<T> * +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const +{ + ACE_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this), + 0); + return temp; +} + +template <class T, class IMPLEMENTATION, class ENTRY> int +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Iterator_Impl<T> &rhs) const +{ + const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local + = dynamic_cast<const ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class IMPLEMENTATION, class ENTRY> T +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const +{ + ENTRY &entry = *this->implementation_; + return T (entry.ext_id_, + entry.int_id_); +} + +template <class T, class IMPLEMENTATION, class ENTRY> void +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class IMPLEMENTATION, class ENTRY> void +ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void) +{ + --this->implementation_; +} + +template <class T, class IMPLEMENTATION, class ENTRY> +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter (void) +{ +} + +template <class T, class IMPLEMENTATION, class ENTRY> ACE_Reverse_Iterator_Impl<T> * +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const +{ + ACE_Reverse_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this), + 0); + return temp; +} + + +template <class T, class IMPLEMENTATION, class ENTRY> int +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const +{ + const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local + = dynamic_cast<const ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class IMPLEMENTATION, class ENTRY> T +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const +{ + ENTRY &entry = *this->implementation_; + return T (entry.ext_id_, + entry.int_id_); +} + +template <class T, class IMPLEMENTATION, class ENTRY> void +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class IMPLEMENTATION, class ENTRY> void +ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void) +{ + --this->implementation_; +} + + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl (void) +{ +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::open (size_t length, + ACE_Allocator *alloc) +{ + return this->implementation_.open (length, + alloc); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void) +{ + return this->implementation_.close (); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind (const KEY &key, + const VALUE &value) +{ + return this->implementation_.bind (key, + value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_modify_key (const VALUE &value, + KEY &key) +{ + return this->implementation_.bind_modify_key (value, + key); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::create_key (KEY &key) +{ + return this->implementation_.create_key (key); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value, + KEY &key) +{ + return this->implementation_.bind_create_key (value, + key); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value) +{ + return this->implementation_.bind_create_key (value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::recover_key (const KEY &modified_key, + KEY &original_key) +{ + return this->implementation_.recover_key (modified_key, + original_key); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key, + const VALUE &value) +{ + return this->implementation_.rebind (key, + value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key, + const VALUE &value, + VALUE &old_value) +{ + return this->implementation_.rebind (key, + value, + old_value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key, + const VALUE &value, + KEY &old_key, + VALUE &old_value) +{ + return this->implementation_.rebind (key, + value, + old_key, + old_value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::trybind (const KEY &key, + VALUE &value) +{ + return this->implementation_.trybind (key, + value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key, + VALUE &value) +{ + return this->implementation_.find (key, + value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key) +{ + return this->implementation_.find (key); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key) +{ + return this->implementation_.unbind (key); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> int +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key, + VALUE &value) +{ + return this->implementation_.unbind (key, + value); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void) const +{ + return this->implementation_.current_size (); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> size_t +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void) const +{ + return this->implementation_.total_size (); +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> void +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const +{ +#if defined (ACE_HAS_DUMP) + this->implementation_.dump (); +#endif /* ACE_HAS_DUMP */ +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.begin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.end ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rbegin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rend ()), + 0); + return temp; +} + +template <class T, class VALUE> +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter (void) +{ +} + +template <class T, class VALUE> ACE_Iterator_Impl<T> * +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const +{ + ACE_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>) (*this), + 0); + return temp; +} + + +template <class T, class VALUE> int +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const +{ + const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs_local + = dynamic_cast<const ACE_Active_Map_Manager_Iterator_Adapter< T, VALUE> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class VALUE> T +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::dereference () const +{ + // The following syntax is necessary to work around certain broken compilers. + // In particular, please do not prefix implementation_ with this-> + return T ((*implementation_).int_id_.first (), + (*implementation_).int_id_.second ()); +} + +template <class T, class VALUE> void +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class VALUE> void +ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus (void) +{ + --this->implementation_; +} + +template <class T, class VALUE> +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void) +{ +} + +template <class T, class VALUE> ACE_Reverse_Iterator_Impl<T> * +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const +{ + ACE_Reverse_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>) (*this), + 0); + return temp; +} + + +template <class T, class VALUE> int +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const +{ + const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs_local + = dynamic_cast<const ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class VALUE> T +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::dereference () const +{ + // The following syntax is necessary to work around certain broken compilers. + // In particular, please do not prefix implementation_ with this-> + return T ((*implementation_).int_id_.first (), + (*implementation_).int_id_.second ()); +} + +template <class T, class VALUE> void +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class VALUE> void +ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus (void) +{ + --this->implementation_; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter (void) +{ +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length, + ACE_Allocator *alloc) +{ + return this->implementation_.open (length, + alloc); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void) +{ + return this->implementation_.close (); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind (const KEY &, + const VALUE &) +{ + ACE_NOTSUP_RETURN (-1); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const VALUE &value, + KEY &key) +{ + // Reserve a slot and create an active key. + expanded_value *internal_value = 0; + ACE_Active_Map_Manager_Key active_key; + int result = this->implementation_.bind (active_key, + internal_value); + if (result == 0) + { + // Encode the active key and the existing user key into key part + // of <expanded_value>. + result = this->key_adapter_.encode (key, + active_key, + internal_value->first ()); + if (result == 0) + { + // Copy user value into <expanded_value>. + internal_value->second (value); + // Copy new, modified key back to the user key. + key = internal_value->first (); + } + else + { + // In case of errors, unbind from map. + this->implementation_.unbind (active_key); + } + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::create_key (KEY &) +{ + ACE_NOTSUP_RETURN (-1); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value, + KEY &key) +{ + // Reserve a slot and create an active key. + expanded_value *internal_value = 0; + ACE_Active_Map_Manager_Key active_key; + int result = this->implementation_.bind (active_key, + internal_value); + if (result == 0) + { + // Encode the active key into key part of <expanded_value>. + result = this->key_adapter_.encode (internal_value->first (), + active_key, + internal_value->first ()); + if (result == 0) + { + // Copy user value into <expanded_value>. + internal_value->second (value); + // Copy new, modified key to the user key. + key = internal_value->first (); + } + else + { + // In case of errors, unbind from map. + this->implementation_.unbind (active_key); + } + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value) +{ + // Reserve a slot and create an active key. + expanded_value *internal_value = 0; + ACE_Active_Map_Manager_Key active_key; + int result = this->implementation_.bind (active_key, + internal_value); + if (result == 0) + { + // Encode the active key into key part of <expanded_value>. + result = this->key_adapter_.encode (internal_value->first (), + active_key, + internal_value->first ()); + if (result == 0) + { + // Copy user value into <expanded_value>. + internal_value->second (value); + } + else + { + // In case of errors, unbind from map. + this->implementation_.unbind (active_key); + } + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY &modified_key, + KEY &original_key) +{ + // Ask the <key_adapter_> to help out with recovering the original + // user key, since it was the one that encode it in the first place. + return this->key_adapter_.decode (modified_key, + original_key); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key, + expanded_value *&internal_value) +{ + // Ask the <key_adapter_> to recover the active key. + ACE_Active_Map_Manager_Key active_key; + int result = this->key_adapter_.decode (key, + active_key); + if (result == 0) + { + // Find recovered active key in map. + result = this->implementation_.find (active_key, + internal_value); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key, + VALUE &value) +{ + expanded_value *internal_value = 0; + int result = this->find (key, + internal_value); + + if (result == 0) + { + // Copy value. + value = internal_value->second (); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key) +{ + expanded_value *internal_value = 0; + return this->find (key, + internal_value); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key, + const VALUE &value) +{ + expanded_value *internal_value = 0; + int result = this->find (key, + internal_value); + + if (result == 0) + { + // Reset value. + internal_value->second (value); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key, + const VALUE &value, + VALUE &old_value) +{ + expanded_value *internal_value = 0; + int result = this->find (key, + internal_value); + + if (result == 0) + { + // Copy old value. + old_value = internal_value->second (); + + // Reset to new value. + internal_value->second (value); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key, + const VALUE &value, + KEY &old_key, + VALUE &old_value) +{ + expanded_value *internal_value = 0; + int result = this->find (key, + internal_value); + + if (result == 0) + { + // Copy old key and value. + old_key = internal_value->first (); + old_value = internal_value->second (); + + // Reset to new value. + internal_value->second (value); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::trybind (const KEY &, + VALUE &) +{ + ACE_NOTSUP_RETURN (-1); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key, + expanded_value *&internal_value) +{ + // Ask the <key_adapter_> to recover the active key. + ACE_Active_Map_Manager_Key active_key; + int result = this->key_adapter_.decode (key, + active_key); + if (result == 0) + { + // Unbind recovered active key from map. + result = this->implementation_.unbind (active_key, + internal_value); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key) +{ + expanded_value *internal_value = 0; + return this->unbind (key, + internal_value); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> int +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key, + VALUE &value) +{ + expanded_value *internal_value = 0; + int result = this->unbind (key, + internal_value); + + if (result == 0) + { + // Copy value. + value = internal_value->second (); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> size_t +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void) const +{ + return this->implementation_.current_size (); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> size_t +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void) const +{ + return this->implementation_.total_size (); +} + +template <class KEY, class VALUE, class KEY_ADAPTER> void +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const +{ +#if defined (ACE_HAS_DUMP) + this->implementation_.dump (); +#endif /* ACE_HAS_DUMP */ +} + +template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.begin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.end ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rbegin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class KEY_ADAPTER> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rend ()), + 0); + return temp; +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void) +{ +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Iterator_Impl<T> * +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const +{ + ACE_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this), + 0); + return temp; +} + + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Iterator_Impl<T> &rhs) const +{ + const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local + = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const +{ + // The following syntax is necessary to work around certain broken compilers. + // In particular, please do not prefix implementation_ with this-> + return T ((*implementation_).ext_id_, + (*implementation_).int_id_); +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void +ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void) +{ + --this->implementation_; +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void) +{ +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_Reverse_Iterator_Impl<T> * +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const +{ + ACE_Reverse_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this), + 0); + return temp; +} + + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> int +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const +{ + const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local + = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> T +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const +{ + // The following syntax is necessary to work around certain broken compilers. + // In particular, please do not prefix implementation_ with this-> + return T ((*implementation_).ext_id_, + (*implementation_).int_id_); +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> void +ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void) +{ + --this->implementation_; +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter (void) +{ +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::open (size_t length, + ACE_Allocator *alloc) +{ + return this->implementation_.open (length, + alloc); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void) +{ + return this->implementation_.close (); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind (const KEY &key, + const VALUE &value) +{ + return this->implementation_.bind (key, + value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_modify_key (const VALUE &value, + KEY &key) +{ + return this->implementation_.bind (key, + value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::create_key (KEY &key) +{ + // Invoke the user specified key generation functor. + return this->key_generator_ (key); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value, + KEY &key) +{ + // Invoke the user specified key generation functor. + int result = this->key_generator_ (key); + + if (result == 0) + { + // Try to add. + result = this->implementation_.bind (key, + value); + } + + return result; +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value) +{ + KEY key; + return this->bind_create_key (value, + key); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::recover_key (const KEY &modified_key, + KEY &original_key) +{ + original_key = modified_key; + return 0; +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key, + const VALUE &value) +{ + return this->implementation_.rebind (key, + value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key, + const VALUE &value, + VALUE &old_value) +{ + return this->implementation_.rebind (key, + value, + old_value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key, + const VALUE &value, + KEY &old_key, + VALUE &old_value) +{ + return this->implementation_.rebind (key, + value, + old_key, + old_value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::trybind (const KEY &key, + VALUE &value) +{ + return this->implementation_.trybind (key, + value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key, + VALUE &value) +{ + return this->implementation_.find (key, + value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key) +{ + return this->implementation_.find (key); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key) +{ + return this->implementation_.unbind (key); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> int +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key, + VALUE &value) +{ + return this->implementation_.unbind (key, + value); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void) const +{ + return this->implementation_.current_size (); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> size_t +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void) const +{ + return this->implementation_.total_size (); +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> void +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const +{ +#if defined (ACE_HAS_DUMP) + this->implementation_.dump (); +#endif /* ACE_HAS_DUMP */ +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.begin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.end ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rbegin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rend ()), + 0); + return temp; +} + +template <class T, class KEY, class VALUE> +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter (void) +{ +} + +template <class T, class KEY, class VALUE> ACE_Iterator_Impl<T> * +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const +{ + ACE_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>) (*this), + 0); + return temp; +} + + +template <class T, class KEY, class VALUE> int +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const +{ + const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs_local + = dynamic_cast<const ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class KEY, class VALUE> T +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::dereference () const +{ + // The following syntax is necessary to work around certain broken compilers. + // In particular, please do not prefix implementation_ with this-> + return T ((*implementation_).ext_id_, + (*implementation_).int_id_); +} + +template <class T, class KEY, class VALUE> void +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class KEY, class VALUE> void +ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void) +{ + --this->implementation_; +} + +template <class T, class KEY, class VALUE> +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter (void) +{ +} + +template <class T, class KEY, class VALUE> ACE_Reverse_Iterator_Impl<T> * +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const +{ + ACE_Reverse_Iterator_Impl<T> *temp = 0; + ACE_NEW_RETURN (temp, + (ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>) (*this), + 0); + return temp; +} + + +template <class T, class KEY, class VALUE> int +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const +{ + const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs_local + = dynamic_cast<const ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE> &> (rhs); + + return this->implementation_ == rhs_local.implementation_; +} + +template <class T, class KEY, class VALUE> T +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::dereference () const +{ + // The following syntax is necessary to work around certain broken compilers. + // In particular, please do not prefix implementation_ with this-> + return T ((*implementation_).ext_id_, + (*implementation_).int_id_); +} + +template <class T, class KEY, class VALUE> void +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void) +{ + ++this->implementation_; +} + +template <class T, class KEY, class VALUE> void +ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void) +{ + --this->implementation_; +} + +template <class KEY, class VALUE, class KEY_GENERATOR> +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter (void) +{ +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length, + ACE_Allocator *alloc) +{ + return this->implementation_.open (length, + alloc); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void) +{ + return this->implementation_.close (); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind (const KEY &key, + const VALUE &value) +{ + return this->implementation_.bind (key, + value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_modify_key (const VALUE &value, + KEY &key) +{ + return this->implementation_.bind (key, + value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::create_key (KEY &key) +{ + // Invoke the user specified key generation functor. + return this->key_generator_ (key); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value, + KEY &key) +{ + // Invoke the user specified key generation functor. + int result = this->key_generator_ (key); + + if (result == 0) + { + // Try to add. + result = this->implementation_.bind (key, + value); + } + + return result; +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value) +{ + KEY key; + return this->bind_create_key (value, + key); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modified_key, + KEY &original_key) +{ + original_key = modified_key; + return 0; +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key, + const VALUE &value) +{ + return this->implementation_.rebind (key, + value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key, + const VALUE &value, + VALUE &old_value) +{ + return this->implementation_.rebind (key, + value, + old_value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key, + const VALUE &value, + KEY &old_key, + VALUE &old_value) +{ + return this->implementation_.rebind (key, + value, + old_key, + old_value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::trybind (const KEY &key, + VALUE &value) +{ + return this->implementation_.trybind (key, + value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key, + VALUE &value) +{ + return this->implementation_.find (key, + value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key) +{ + return this->implementation_.find (key); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key) +{ + return this->implementation_.unbind (key); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> int +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key, + VALUE &value) +{ + return this->implementation_.unbind (key, + value); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> size_t +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void) const +{ + return this->implementation_.current_size (); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> size_t +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void) const +{ + return this->implementation_.total_size (); +} + +template <class KEY, class VALUE, class KEY_GENERATOR> void +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const +{ +#if defined (ACE_HAS_DUMP) + this->implementation_.dump (); +#endif /* ACE_HAS_DUMP */ +} + +template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.begin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void) +{ + ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + iterator_impl (this->implementation_.end ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rbegin ()), + 0); + return temp; +} + +template <class KEY, class VALUE, class KEY_GENERATOR> ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * +ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl (void) +{ + ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; + ACE_NEW_RETURN (temp, + reverse_iterator_impl (this->implementation_.rend ()), + 0); + return temp; +} + +#endif /* ACE_MAP_T_CPP */ diff --git a/ace/Map_T.inl b/ace/Map_T.inl index 82bd75794b2..87d821177e4 100644 --- a/ace/Map_T.inl +++ b/ace/Map_T.inl @@ -27,16 +27,6 @@ ACE_Incremental_Key_Generator<T>::current_value (void) const } template <class T> ACE_INLINE -ACE_Iterator_Impl<T>::~ACE_Iterator_Impl (void) -{ -} - -template <class T> ACE_INLINE -ACE_Reverse_Iterator_Impl<T>::~ACE_Reverse_Iterator_Impl (void) -{ -} - -template <class T> ACE_INLINE ACE_Iterator<T>::ACE_Iterator (ACE_Iterator_Impl<T> *impl) : implementation_ (impl) { @@ -236,51 +226,6 @@ ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Iterator_A { } -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Iterator_Adapter (void) -{ -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE ACE_Iterator_Impl<T> * -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const -{ - ACE_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this), - 0); - return temp; -} - - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE int -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Iterator_Impl<T> &rhs) const -{ - const ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local - = dynamic_cast<const ACE_Map_Impl_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE T -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const -{ - ENTRY &entry = *this->implementation_; - return T (entry.ext_id_, - entry.int_id_); -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void -ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION & ACE_Map_Impl_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void) { @@ -293,51 +238,6 @@ ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::ACE_Map_Impl_Re { } -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::~ACE_Map_Impl_Reverse_Iterator_Adapter (void) -{ -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE ACE_Reverse_Iterator_Impl<T> * -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::clone (void) const -{ - ACE_Reverse_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>) (*this), - 0); - return temp; -} - - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE int -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const -{ - const ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY> &rhs_local - = dynamic_cast<const ACE_Map_Impl_Reverse_Iterator_Adapter< T, IMPLEMENTATION, ENTRY> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE T -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::dereference () const -{ - ENTRY &entry = *this->implementation_; - return T (entry.ext_id_, - entry.int_id_); -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE void -ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class IMPLEMENTATION, class ENTRY> ACE_INLINE IMPLEMENTATION & ACE_Map_Impl_Reverse_Iterator_Adapter<T, IMPLEMENTATION, ENTRY>::impl (void) { @@ -358,195 +258,6 @@ ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::ACE { } -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::~ACE_Map_Impl (void) -{ -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::open (size_t length, - ACE_Allocator *alloc) -{ - return this->implementation_.open (length, - alloc); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::close (void) -{ - return this->implementation_.close (); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind (const KEY &key, - const VALUE &value) -{ - return this->implementation_.bind (key, - value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_modify_key (const VALUE &value, - KEY &key) -{ - return this->implementation_.bind_modify_key (value, - key); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::create_key (KEY &key) -{ - return this->implementation_.create_key (key); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value, - KEY &key) -{ - return this->implementation_.bind_create_key (value, - key); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::bind_create_key (const VALUE &value) -{ - return this->implementation_.bind_create_key (value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::recover_key (const KEY &modified_key, - KEY &original_key) -{ - return this->implementation_.recover_key (modified_key, - original_key); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key, - const VALUE &value) -{ - return this->implementation_.rebind (key, - value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key, - const VALUE &value, - VALUE &old_value) -{ - return this->implementation_.rebind (key, - value, - old_value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rebind (const KEY &key, - const VALUE &value, - KEY &old_key, - VALUE &old_value) -{ - return this->implementation_.rebind (key, - value, - old_key, - old_value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::trybind (const KEY &key, - VALUE &value) -{ - return this->implementation_.trybind (key, - value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key, - VALUE &value) -{ - return this->implementation_.find (key, - value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::find (const KEY &key) -{ - return this->implementation_.find (key); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key) -{ - return this->implementation_.unbind (key); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE int -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::unbind (const KEY &key, - VALUE &value) -{ - return this->implementation_.unbind (key, - value); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::current_size (void) const -{ - return this->implementation_.current_size (); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE size_t -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::total_size (void) const -{ - return this->implementation_.total_size (); -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE void -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->implementation_.dump (); -#endif /* ACE_HAS_DUMP */ -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::begin_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.begin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::end_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.end ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rbegin_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rbegin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::rend_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rend ()), - 0); - return temp; -} - template <class KEY, class VALUE, class IMPLEMENTATION, class ITERATOR, class REVERSE_ITERATOR, class ENTRY> ACE_INLINE IMPLEMENTATION & ACE_Map_Impl<KEY, VALUE, IMPLEMENTATION, ITERATOR, REVERSE_ITERATOR, ENTRY>::impl (void) { @@ -559,52 +270,6 @@ ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manager_Iterat { } -template <class T, class VALUE> ACE_INLINE -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Iterator_Adapter (void) -{ -} - -template <class T, class VALUE> ACE_INLINE ACE_Iterator_Impl<T> * -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::clone (void) const -{ - ACE_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>) (*this), - 0); - return temp; -} - - -template <class T, class VALUE> ACE_INLINE int -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const -{ - const ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE> &rhs_local - = dynamic_cast<const ACE_Active_Map_Manager_Iterator_Adapter< T, VALUE> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class VALUE> ACE_INLINE T -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::dereference () const -{ - // The following syntax is necessary to work around certain broken compilers. - // In particular, please do not prefix implementation_ with this-> - return T ((*implementation_).int_id_.first (), - (*implementation_).int_id_.second ()); -} - -template <class T, class VALUE> ACE_INLINE void -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class VALUE> ACE_INLINE void -ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class VALUE> ACE_INLINE ACE_Map_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> & ACE_Active_Map_Manager_Iterator_Adapter<T, VALUE>::impl (void) { @@ -617,52 +282,6 @@ ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::ACE_Active_Map_Manage { } -template <class T, class VALUE> ACE_INLINE -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::~ACE_Active_Map_Manager_Reverse_Iterator_Adapter (void) -{ -} - -template <class T, class VALUE> ACE_INLINE ACE_Reverse_Iterator_Impl<T> * -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::clone (void) const -{ - ACE_Reverse_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>) (*this), - 0); - return temp; -} - - -template <class T, class VALUE> ACE_INLINE int -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const -{ - const ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE> &rhs_local - = dynamic_cast<const ACE_Active_Map_Manager_Reverse_Iterator_Adapter< T, VALUE> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class VALUE> ACE_INLINE T -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::dereference () const -{ - // The following syntax is necessary to work around certain broken compilers. - // In particular, please do not prefix implementation_ with this-> - return T ((*implementation_).int_id_.first (), - (*implementation_).int_id_.second ()); -} - -template <class T, class VALUE> ACE_INLINE void -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class VALUE> ACE_INLINE void -ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<ACE_Active_Map_Manager_Key, VALUE, ACE_Null_Mutex> & ACE_Active_Map_Manager_Reverse_Iterator_Adapter<T, VALUE>::impl (void) { @@ -683,356 +302,6 @@ ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::ACE_Active_Map_Manager_ { } -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::~ACE_Active_Map_Manager_Adapter (void) -{ -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::open (size_t length, - ACE_Allocator *alloc) -{ - return this->implementation_.open (length, - alloc); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::close (void) -{ - return this->implementation_.close (); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind (const KEY &, - const VALUE &) -{ - ACE_NOTSUP_RETURN (-1); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_modify_key (const VALUE &value, - KEY &key) -{ - // Reserve a slot and create an active key. - expanded_value *internal_value = 0; - ACE_Active_Map_Manager_Key active_key; - int result = this->implementation_.bind (active_key, - internal_value); - if (result == 0) - { - // Encode the active key and the existing user key into key part - // of <expanded_value>. - result = this->key_adapter_.encode (key, - active_key, - internal_value->first ()); - if (result == 0) - { - // Copy user value into <expanded_value>. - internal_value->second (value); - // Copy new, modified key back to the user key. - key = internal_value->first (); - } - else - { - // In case of errors, unbind from map. - this->implementation_.unbind (active_key); - } - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::create_key (KEY &) -{ - ACE_NOTSUP_RETURN (-1); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value, - KEY &key) -{ - // Reserve a slot and create an active key. - expanded_value *internal_value = 0; - ACE_Active_Map_Manager_Key active_key; - int result = this->implementation_.bind (active_key, - internal_value); - if (result == 0) - { - // Encode the active key into key part of <expanded_value>. - result = this->key_adapter_.encode (internal_value->first (), - active_key, - internal_value->first ()); - if (result == 0) - { - // Copy user value into <expanded_value>. - internal_value->second (value); - // Copy new, modified key to the user key. - key = internal_value->first (); - } - else - { - // In case of errors, unbind from map. - this->implementation_.unbind (active_key); - } - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::bind_create_key (const VALUE &value) -{ - // Reserve a slot and create an active key. - expanded_value *internal_value = 0; - ACE_Active_Map_Manager_Key active_key; - int result = this->implementation_.bind (active_key, - internal_value); - if (result == 0) - { - // Encode the active key into key part of <expanded_value>. - result = this->key_adapter_.encode (internal_value->first (), - active_key, - internal_value->first ()); - if (result == 0) - { - // Copy user value into <expanded_value>. - internal_value->second (value); - } - else - { - // In case of errors, unbind from map. - this->implementation_.unbind (active_key); - } - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::recover_key (const KEY &modified_key, - KEY &original_key) -{ - // Ask the <key_adapter_> to help out with recovering the original - // user key, since it was the one that encode it in the first place. - return this->key_adapter_.decode (modified_key, - original_key); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key, - expanded_value *&internal_value) -{ - // Ask the <key_adapter_> to recover the active key. - ACE_Active_Map_Manager_Key active_key; - int result = this->key_adapter_.decode (key, - active_key); - if (result == 0) - { - // Find recovered active key in map. - result = this->implementation_.find (active_key, - internal_value); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key, - VALUE &value) -{ - expanded_value *internal_value = 0; - int result = this->find (key, - internal_value); - - if (result == 0) - { - // Copy value. - value = internal_value->second (); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::find (const KEY &key) -{ - expanded_value *internal_value = 0; - return this->find (key, - internal_value); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key, - const VALUE &value) -{ - expanded_value *internal_value = 0; - int result = this->find (key, - internal_value); - - if (result == 0) - { - // Reset value. - internal_value->second (value); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key, - const VALUE &value, - VALUE &old_value) -{ - expanded_value *internal_value = 0; - int result = this->find (key, - internal_value); - - if (result == 0) - { - // Copy old value. - old_value = internal_value->second (); - - // Reset to new value. - internal_value->second (value); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rebind (const KEY &key, - const VALUE &value, - KEY &old_key, - VALUE &old_value) -{ - expanded_value *internal_value = 0; - int result = this->find (key, - internal_value); - - if (result == 0) - { - // Copy old key and value. - old_key = internal_value->first (); - old_value = internal_value->second (); - - // Reset to new value. - internal_value->second (value); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::trybind (const KEY &, - VALUE &) -{ - ACE_NOTSUP_RETURN (-1); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key, - expanded_value *&internal_value) -{ - // Ask the <key_adapter_> to recover the active key. - ACE_Active_Map_Manager_Key active_key; - int result = this->key_adapter_.decode (key, - active_key); - if (result == 0) - { - // Unbind recovered active key from map. - result = this->implementation_.unbind (active_key, - internal_value); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key) -{ - expanded_value *internal_value = 0; - return this->unbind (key, - internal_value); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE int -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::unbind (const KEY &key, - VALUE &value) -{ - expanded_value *internal_value = 0; - int result = this->unbind (key, - internal_value); - - if (result == 0) - { - // Copy value. - value = internal_value->second (); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::current_size (void) const -{ - return this->implementation_.current_size (); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE size_t -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::total_size (void) const -{ - return this->implementation_.total_size (); -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE void -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->implementation_.dump (); -#endif /* ACE_HAS_DUMP */ -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::begin_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.begin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::end_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.end ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rbegin_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rbegin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::rend_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rend ()), - 0); - return temp; -} - template <class KEY, class VALUE, class KEY_ADAPTER> ACE_INLINE ACE_Active_Map_Manager<ACE_Pair<KEY, VALUE> > & ACE_Active_Map_Manager_Adapter<KEY, VALUE, KEY_ADAPTER>::impl (void) { @@ -1051,52 +320,6 @@ ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>: { } -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Iterator_Adapter (void) -{ -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Iterator_Impl<T> * -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const -{ - ACE_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this), - 0); - return temp; -} - - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Iterator_Impl<T> &rhs) const -{ - const ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local - = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE T -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const -{ - // The following syntax is necessary to work around certain broken compilers. - // In particular, please do not prefix implementation_ with this-> - return T ((*implementation_).ext_id_, - (*implementation_).int_id_); -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void -ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> & ACE_Hash_Map_Manager_Ex_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void) { @@ -1109,52 +332,6 @@ ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPAR { } -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::~ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter (void) -{ -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Reverse_Iterator_Impl<T> * -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::clone (void) const -{ - ACE_Reverse_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>) (*this), - 0); - return temp; -} - - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const -{ - const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &rhs_local - = dynamic_cast<const ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter< T, KEY, VALUE, HASH_KEY, COMPARE_KEYS> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE T -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::dereference () const -{ - // The following syntax is necessary to work around certain broken compilers. - // In particular, please do not prefix implementation_ with this-> - return T ((*implementation_).ext_id_, - (*implementation_).int_id_); -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE void -ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS> ACE_INLINE ACE_Hash_Map_Reverse_Iterator_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> & ACE_Hash_Map_Manager_Ex_Reverse_Iterator_Adapter<T, KEY, VALUE, HASH_KEY, COMPARE_KEYS>::impl (void) { @@ -1175,207 +352,6 @@ ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATO { } -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::~ACE_Hash_Map_Manager_Ex_Adapter (void) -{ -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::open (size_t length, - ACE_Allocator *alloc) -{ - return this->implementation_.open (length, - alloc); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::close (void) -{ - return this->implementation_.close (); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind (const KEY &key, - const VALUE &value) -{ - return this->implementation_.bind (key, - value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_modify_key (const VALUE &value, - KEY &key) -{ - return this->implementation_.bind (key, - value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::create_key (KEY &key) -{ - // Invoke the user specified key generation functor. - return this->key_generator_ (key); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value, - KEY &key) -{ - // Invoke the user specified key generation functor. - int result = this->key_generator_ (key); - - if (result == 0) - { - // Try to add. - result = this->implementation_.bind (key, - value); - } - - return result; -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::bind_create_key (const VALUE &value) -{ - KEY key; - return this->bind_create_key (value, - key); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::recover_key (const KEY &modified_key, - KEY &original_key) -{ - original_key = modified_key; - return 0; -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key, - const VALUE &value) -{ - return this->implementation_.rebind (key, - value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key, - const VALUE &value, - VALUE &old_value) -{ - return this->implementation_.rebind (key, - value, - old_value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rebind (const KEY &key, - const VALUE &value, - KEY &old_key, - VALUE &old_value) -{ - return this->implementation_.rebind (key, - value, - old_key, - old_value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::trybind (const KEY &key, - VALUE &value) -{ - return this->implementation_.trybind (key, - value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key, - VALUE &value) -{ - return this->implementation_.find (key, - value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::find (const KEY &key) -{ - return this->implementation_.find (key); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key) -{ - return this->implementation_.unbind (key); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE int -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::unbind (const KEY &key, - VALUE &value) -{ - return this->implementation_.unbind (key, - value); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::current_size (void) const -{ - return this->implementation_.current_size (); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE size_t -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::total_size (void) const -{ - return this->implementation_.total_size (); -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE void -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->implementation_.dump (); -#endif /* ACE_HAS_DUMP */ -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::begin_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.begin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::end_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.end ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rbegin_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rbegin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::rend_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rend ()), - 0); - return temp; -} - template <class KEY, class VALUE, class HASH_KEY, class COMPARE_KEYS, class KEY_GENERATOR> ACE_INLINE ACE_Hash_Map_Manager_Ex<KEY, VALUE, HASH_KEY, COMPARE_KEYS, ACE_Null_Mutex> & ACE_Hash_Map_Manager_Ex_Adapter<KEY, VALUE, HASH_KEY, COMPARE_KEYS, KEY_GENERATOR>::impl (void) { @@ -1394,52 +370,6 @@ ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Iterator_Adapte { } -template <class T, class KEY, class VALUE> ACE_INLINE -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Iterator_Adapter (void) -{ -} - -template <class T, class KEY, class VALUE> ACE_INLINE ACE_Iterator_Impl<T> * -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::clone (void) const -{ - ACE_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>) (*this), - 0); - return temp; -} - - -template <class T, class KEY, class VALUE> ACE_INLINE int -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Iterator_Impl<T> &rhs) const -{ - const ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE> &rhs_local - = dynamic_cast<const ACE_Map_Manager_Iterator_Adapter< T, KEY, VALUE> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class KEY, class VALUE> ACE_INLINE T -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::dereference () const -{ - // The following syntax is necessary to work around certain broken compilers. - // In particular, please do not prefix implementation_ with this-> - return T ((*implementation_).ext_id_, - (*implementation_).int_id_); -} - -template <class T, class KEY, class VALUE> ACE_INLINE void -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class KEY, class VALUE> ACE_INLINE void -ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Iterator<KEY, VALUE, ACE_Null_Mutex> & ACE_Map_Manager_Iterator_Adapter<T, KEY, VALUE>::impl (void) { @@ -1452,52 +382,6 @@ ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::ACE_Map_Manager_Reverse { } -template <class T, class KEY, class VALUE> ACE_INLINE -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::~ACE_Map_Manager_Reverse_Iterator_Adapter (void) -{ -} - -template <class T, class KEY, class VALUE> ACE_INLINE ACE_Reverse_Iterator_Impl<T> * -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::clone (void) const -{ - ACE_Reverse_Iterator_Impl<T> *temp = 0; - ACE_NEW_RETURN (temp, - (ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>) (*this), - 0); - return temp; -} - - -template <class T, class KEY, class VALUE> ACE_INLINE int -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::compare (const ACE_Reverse_Iterator_Impl<T> &rhs) const -{ - const ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE> &rhs_local - = dynamic_cast<const ACE_Map_Manager_Reverse_Iterator_Adapter< T, KEY, VALUE> &> (rhs); - - return this->implementation_ == rhs_local.implementation_; -} - -template <class T, class KEY, class VALUE> ACE_INLINE T -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::dereference () const -{ - // The following syntax is necessary to work around certain broken compilers. - // In particular, please do not prefix implementation_ with this-> - return T ((*implementation_).ext_id_, - (*implementation_).int_id_); -} - -template <class T, class KEY, class VALUE> ACE_INLINE void -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::plus_plus (void) -{ - ++this->implementation_; -} - -template <class T, class KEY, class VALUE> ACE_INLINE void -ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::minus_minus (void) -{ - --this->implementation_; -} - template <class T, class KEY, class VALUE> ACE_INLINE ACE_Map_Reverse_Iterator<KEY, VALUE, ACE_Null_Mutex> & ACE_Map_Manager_Reverse_Iterator_Adapter<T, KEY, VALUE>::impl (void) { @@ -1518,207 +402,6 @@ ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::ACE_Map_Manager_Adapter (siz { } -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::~ACE_Map_Manager_Adapter (void) -{ -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::open (size_t length, - ACE_Allocator *alloc) -{ - return this->implementation_.open (length, - alloc); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::close (void) -{ - return this->implementation_.close (); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind (const KEY &key, - const VALUE &value) -{ - return this->implementation_.bind (key, - value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_modify_key (const VALUE &value, - KEY &key) -{ - return this->implementation_.bind (key, - value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::create_key (KEY &key) -{ - // Invoke the user specified key generation functor. - return this->key_generator_ (key); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value, - KEY &key) -{ - // Invoke the user specified key generation functor. - int result = this->key_generator_ (key); - - if (result == 0) - { - // Try to add. - result = this->implementation_.bind (key, - value); - } - - return result; -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::bind_create_key (const VALUE &value) -{ - KEY key; - return this->bind_create_key (value, - key); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::recover_key (const KEY &modified_key, - KEY &original_key) -{ - original_key = modified_key; - return 0; -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key, - const VALUE &value) -{ - return this->implementation_.rebind (key, - value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key, - const VALUE &value, - VALUE &old_value) -{ - return this->implementation_.rebind (key, - value, - old_value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rebind (const KEY &key, - const VALUE &value, - KEY &old_key, - VALUE &old_value) -{ - return this->implementation_.rebind (key, - value, - old_key, - old_value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::trybind (const KEY &key, - VALUE &value) -{ - return this->implementation_.trybind (key, - value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key, - VALUE &value) -{ - return this->implementation_.find (key, - value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::find (const KEY &key) -{ - return this->implementation_.find (key); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key) -{ - return this->implementation_.unbind (key); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE int -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::unbind (const KEY &key, - VALUE &value) -{ - return this->implementation_.unbind (key, - value); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::current_size (void) const -{ - return this->implementation_.current_size (); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE size_t -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::total_size (void) const -{ - return this->implementation_.total_size (); -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE void -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::dump (void) const -{ -#if defined (ACE_HAS_DUMP) - this->implementation_.dump (); -#endif /* ACE_HAS_DUMP */ -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::begin_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.begin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::end_impl (void) -{ - ACE_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - iterator_impl (this->implementation_.end ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rbegin_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rbegin ()), - 0); - return temp; -} - -template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > * -ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::rend_impl (void) -{ - ACE_Reverse_Iterator_Impl<ACE_Reference_Pair<const KEY, VALUE> > *temp = 0; - ACE_NEW_RETURN (temp, - reverse_iterator_impl (this->implementation_.rend ()), - 0); - return temp; -} - template <class KEY, class VALUE, class KEY_GENERATOR> ACE_INLINE ACE_Map_Manager<KEY, VALUE, ACE_Null_Mutex> & ACE_Map_Manager_Adapter<KEY, VALUE, KEY_GENERATOR>::impl (void) { diff --git a/ace/Message_Block.cpp b/ace/Message_Block.cpp index 09b12e2b91c..4d384e162d1 100644 --- a/ace/Message_Block.cpp +++ b/ace/Message_Block.cpp @@ -1266,6 +1266,16 @@ ACE_Deadline_Message_Strategy::~ACE_Deadline_Message_Strategy (void) } void +ACE_Deadline_Message_Strategy::convert_priority (ACE_Time_Value & priority, + const ACE_Message_Block & mb) +{ + // Convert absolute time passed in tv to negative time + // to deadline of mb with respect to that absolute time. + priority -= mb.msg_deadline_time (); +} + // dynamic priority conversion function based on time to deadline + +void ACE_Deadline_Message_Strategy::dump (void) const { #if defined (ACE_HAS_DUMP) @@ -1298,6 +1308,17 @@ ACE_Laxity_Message_Strategy::~ACE_Laxity_Message_Strategy (void) } void +ACE_Laxity_Message_Strategy::convert_priority (ACE_Time_Value & priority, + const ACE_Message_Block & mb) +{ + // Convert absolute time passed in tv to negative + // laxity of mb with respect to that absolute time. + priority += mb.msg_execution_time (); + priority -= mb.msg_deadline_time (); +} + // dynamic priority conversion function based on laxity + +void ACE_Laxity_Message_Strategy::dump (void) const { #if defined (ACE_HAS_DUMP) diff --git a/ace/Message_Block.inl b/ace/Message_Block.inl index 03cf8cde245..8db92601d59 100644 --- a/ace/Message_Block.inl +++ b/ace/Message_Block.inl @@ -624,35 +624,3 @@ ACE_Dynamic_Message_Strategy::priority_status (ACE_Message_Block & mb, return status; } // returns the priority status of the message - - - -///////////////////////////////////////// -// class ACE_Deadline_Message_Strategy // -///////////////////////////////////////// - -ACE_INLINE void -ACE_Deadline_Message_Strategy::convert_priority (ACE_Time_Value & priority, - const ACE_Message_Block & mb) -{ - // Convert absolute time passed in tv to negative time - // to deadline of mb with respect to that absolute time. - priority -= mb.msg_deadline_time (); -} - // dynamic priority conversion function based on time to deadline - - -/////////////////////////////////////// -// class ACE_Laxity_Message_Strategy // -/////////////////////////////////////// - -ACE_INLINE void -ACE_Laxity_Message_Strategy::convert_priority (ACE_Time_Value & priority, - const ACE_Message_Block & mb) -{ - // Convert absolute time passed in tv to negative - // laxity of mb with respect to that absolute time. - priority += mb.msg_execution_time (); - priority -= mb.msg_deadline_time (); -} - // dynamic priority conversion function based on laxity diff --git a/ace/Message_Queue.cpp b/ace/Message_Queue.cpp index 6ba5fa5c649..160e5c9637e 100644 --- a/ace/Message_Queue.cpp +++ b/ace/Message_Queue.cpp @@ -1,8 +1,5 @@ // $Id$ -#if !defined (ACE_MESSAGE_QUEUE_C) -#define ACE_MESSAGE_QUEUE_C - #include "ace/Message_Queue.h" #include "ace/Log_Msg.h" @@ -10,7 +7,10 @@ #include "ace/Message_Queue.inl" #endif /* __ACE_INLINE__ */ -ACE_RCSID(ace, Message_Queue, "$Id$") + +ACE_RCSID (ace, + Message_Queue, + "$Id$") ACE_Message_Queue_Base::~ACE_Message_Queue_Base (void) @@ -144,6 +144,88 @@ ACE_Message_Queue_Vx::close (void) return ::msgQDelete (msgq ()); } + +int +ACE_Message_Queue_Vx::is_empty_i (void) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::is_empty_i"); + return ::msgQNumMsgs (msgq ()) == 0; +} + +int +ACE_Message_Queue_Vx::is_full_i (void) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::is_full_i"); + return ::msgQNumMsgs (msgq ()) >= max_messages_; +} + +size_t +ACE_Message_Queue_Vx::high_water_mark (void) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark"); + ACE_NOTSUP_RETURN ((size_t) -1); +} + +void +ACE_Message_Queue_Vx::high_water_mark (size_t) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark"); + ACE_NOTSUP; +} + +size_t +ACE_Message_Queue_Vx::low_water_mark (void) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark"); + // Don't need to guard, because this is fixed. + + ACE_NOTSUP_RETURN ((size_t) -1); +} + +void +ACE_Message_Queue_Vx::low_water_mark (size_t) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark"); + ACE_NOTSUP; +} + +size_t +ACE_Message_Queue_Vx::message_bytes (void) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes"); + ACE_NOTSUP_RETURN ((size_t) -1); +} + +size_t +ACE_Message_Queue_Vx::message_length (void) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::message_length"); + ACE_NOTSUP_RETURN ((size_t) -1); +} + +int +ACE_Message_Queue_Vx::message_count (void) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::message_count"); + // Don't need to guard, because this is a system call. + + return ::msgQNumMsgs (msgq ()); +} + +void +ACE_Message_Queue_Vx::message_bytes (size_t) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes"); + ACE_NOTSUP; +} + +void +ACE_Message_Queue_Vx::message_length (size_t) +{ + ACE_TRACE ("ACE_Message_Queue_Vx::message_length"); + ACE_NOTSUP; +} + int ACE_Message_Queue_Vx::signal_enqueue_waiters (void) { @@ -523,5 +605,3 @@ ACE_Message_Queue_NT::dump (void) const } #endif /* ACE_WIN32 && ACE_HAS_WINNT4 != 0 */ - -#endif /* ACE_MESSAGE_QUEUE_C */ diff --git a/ace/Message_Queue.inl b/ace/Message_Queue.inl index 6fadfd2c2c6..45199aa0997 100644 --- a/ace/Message_Queue.inl +++ b/ace/Message_Queue.inl @@ -16,87 +16,6 @@ ACE_Message_Queue_Vx::msgq (void) return reinterpret_cast<MSG_Q_ID> (tail_); } -ACE_INLINE int -ACE_Message_Queue_Vx::is_empty_i (void) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::is_empty_i"); - return ::msgQNumMsgs (msgq ()) == 0; -} - -ACE_INLINE int -ACE_Message_Queue_Vx::is_full_i (void) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::is_full_i"); - return ::msgQNumMsgs (msgq ()) >= max_messages_; -} - -ACE_INLINE size_t -ACE_Message_Queue_Vx::high_water_mark (void) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark"); - ACE_NOTSUP_RETURN ((size_t) -1); -} - -ACE_INLINE void -ACE_Message_Queue_Vx::high_water_mark (size_t) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::high_water_mark"); - ACE_NOTSUP; -} - -ACE_INLINE size_t -ACE_Message_Queue_Vx::low_water_mark (void) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark"); - // Don't need to guard, because this is fixed. - - ACE_NOTSUP_RETURN ((size_t) -1); -} - -ACE_INLINE void -ACE_Message_Queue_Vx::low_water_mark (size_t) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::low_water_mark"); - ACE_NOTSUP; -} - -ACE_INLINE size_t -ACE_Message_Queue_Vx::message_bytes (void) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes"); - ACE_NOTSUP_RETURN ((size_t) -1); -} - -ACE_INLINE size_t -ACE_Message_Queue_Vx::message_length (void) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::message_length"); - ACE_NOTSUP_RETURN ((size_t) -1); -} - -ACE_INLINE int -ACE_Message_Queue_Vx::message_count (void) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::message_count"); - // Don't need to guard, because this is a system call. - - return ::msgQNumMsgs (msgq ()); -} - -ACE_INLINE void -ACE_Message_Queue_Vx::message_bytes (size_t) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::message_bytes"); - ACE_NOTSUP; -} - -ACE_INLINE void -ACE_Message_Queue_Vx::message_length (size_t) -{ - ACE_TRACE ("ACE_Message_Queue_Vx::message_length"); - ACE_NOTSUP; -} - #endif /* VXWORKS */ #if defined (ACE_WIN32) && (ACE_HAS_WINNT4 != 0) diff --git a/ace/Message_Queue_T.cpp b/ace/Message_Queue_T.cpp index 58fb0053f86..111808319c2 100644 --- a/ace/Message_Queue_T.cpp +++ b/ace/Message_Queue_T.cpp @@ -1,7 +1,7 @@ // $Id$ -#ifndef ACE_MESSAGE_QUEUE_T_C -#define ACE_MESSAGE_QUEUE_T_C +#ifndef ACE_MESSAGE_QUEUE_T_CPP +#define ACE_MESSAGE_QUEUE_T_CPP // #include Message_Queue.h instead of Message_Queue_T.h to avoid // circular include problems. @@ -19,8 +19,6 @@ #include "ace/Notification_Strategy.h" -ACE_RCSID(ace, Message_Queue_T, "$Id$") - ACE_ALLOC_HOOK_DEFINE(ACE_Message_Queue) ACE_ALLOC_HOOK_DEFINE(ACE_Dynamic_Message_Queue) ACE_ALLOC_HOOK_DEFINE(ACE_Message_Queue_Ex) @@ -337,6 +335,160 @@ ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notify (void) return this->queue_.notify (); } + +ACE_ALLOC_HOOK_DEFINE(ACE_Message_Queue_Reverse_Iterator) + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue (ACE_MESSAGE_TYPE *&first_item, + ACE_Time_Value *timeout) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue"); + + return this->dequeue_head (first_item, timeout); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_Notification_Strategy * +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy"); + + return this->queue_.notification_strategy (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> void +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy (ACE_Notification_Strategy *s) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy"); + + this->queue_.notification_strategy (s); +} + +// Check if queue is empty (holds locks). + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_empty (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_empty"); + + return this->queue_.is_empty (); +} + +// Check if queue is full (holds locks). + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_full (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_full"); + + return this->queue_.is_full (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> size_t +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark"); + + return this->queue_.high_water_mark (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> void +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark (size_t hwm) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark"); + + this->queue_.high_water_mark (hwm); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> size_t +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark"); + + return this->queue_.low_water_mark (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> void +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark (size_t lwm) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark"); + + this->queue_.low_water_mark (lwm); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> size_t +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_bytes (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_bytes"); + + return this->queue_.message_bytes (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> size_t +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_length (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_length"); + + return this->queue_.message_length (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_count (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_count"); + + return this->queue_.message_count (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivate (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivate"); + + return this->queue_.deactivate (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::activate (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::activate"); + + return this->queue_.activate (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::pulse (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::pulse"); + + return this->queue_.pulse (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivated (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivated"); + + return this->queue_.deactivated (); +} + +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> int +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::state (void) +{ + ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::state"); + + return this->queue_.state (); +} + +#if 0 +// The Sun Forte 6 (CC 5.1) compiler is only happy if this is in the +// header file (j.russell.noseworthy@objectsciences.com) +template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_SYNCH_MUTEX_T & +ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::lock (void) +{ + return this->queue_.lock (); +} +#endif /* 0 */ + template <ACE_SYNCH_DECL> ACE_Message_Queue_Iterator<ACE_SYNCH_USE>::ACE_Message_Queue_Iterator (ACE_Message_Queue <ACE_SYNCH_USE> &q) : queue_ (q), @@ -431,6 +583,187 @@ ACE_Message_Queue_Reverse_Iterator<ACE_SYNCH_USE>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::dequeue (ACE_Message_Block *&first_item, + ACE_Time_Value *timeout) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::dequeue"); + return this->dequeue_head (first_item, timeout); +} + +template <ACE_SYNCH_DECL> ACE_Notification_Strategy * +ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy"); + + return this->notification_strategy_; +} + +template <ACE_SYNCH_DECL> void +ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy (ACE_Notification_Strategy *s) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy"); + + this->notification_strategy_ = s; +} + +// Check if queue is empty (does not hold locks). + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::is_empty_i (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_empty_i"); + return this->tail_ == 0; +} + +// Check if queue is full (does not hold locks). + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::is_full_i (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_full_i"); + return this->cur_bytes_ >= this->high_water_mark_; +} + +// Check if queue is empty (holds locks). + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::is_empty (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_empty"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); + + return this->is_empty_i (); +} + +// Check if queue is full (holds locks). + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::is_full (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_full"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); + + return this->is_full_i (); +} + +template <ACE_SYNCH_DECL> size_t +ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); + + return this->high_water_mark_; +} + +template <ACE_SYNCH_DECL> void +ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark (size_t hwm) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark"); + ACE_GUARD (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_); + + this->high_water_mark_ = hwm; +} + +template <ACE_SYNCH_DECL> size_t +ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); + + return this->low_water_mark_; +} + +template <ACE_SYNCH_DECL> void +ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark (size_t lwm) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark"); + ACE_GUARD (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_); + + this->low_water_mark_ = lwm; +} + +template <ACE_SYNCH_DECL> size_t +ACE_Message_Queue<ACE_SYNCH_USE>::message_bytes (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::message_bytes"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); + + return this->cur_bytes_; +} + +template <ACE_SYNCH_DECL> size_t +ACE_Message_Queue<ACE_SYNCH_USE>::message_length (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::message_length"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); + + return this->cur_length_; +} + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::message_count (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::message_count"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); + + return this->cur_count_; +} + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::deactivate () +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::deactivate"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); + + return this->deactivate_i (0); // Not a pulse +} + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::activate (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::activate"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); + + return this->activate_i (); +} + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::pulse () +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::pulse"); + ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); + + return this->deactivate_i (1); // Just a pulse +} + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::deactivated (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::deactivated"); + + return this->state_ == ACE_Message_Queue_Base::DEACTIVATED; +} + +template <ACE_SYNCH_DECL> int +ACE_Message_Queue<ACE_SYNCH_USE>::state (void) +{ + ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::state"); + + return this->state_; +} + +#if 0 +// The Sun Forte 6 (CC 5.1) compiler is only happy if this is in the +// header file (j.russell.noseworthy@objectsciences.com) + +template <ACE_SYNCH_DECL> ACE_SYNCH_MUTEX_T & +ACE_Message_Queue<ACE_SYNCH_USE>::lock (void) +{ + return this->lock_; +} +#endif /* 0 */ + template <ACE_SYNCH_DECL> void ACE_Message_Queue<ACE_SYNCH_USE>::dump (void) const { @@ -2343,4 +2676,4 @@ ACE_Message_Queue_Factory<ACE_SYNCH_USE>::create_NT_message_queue (size_t max_th #endif /* ACE_WIN32 && ACE_HAS_WINNT4 != 0 */ #endif /* defined (VXWORKS) */ -#endif /* ACE_MESSAGE_QUEUE_T_C */ +#endif /* !ACE_MESSAGE_QUEUE_T_CPP */ diff --git a/ace/Message_Queue_T.inl b/ace/Message_Queue_T.inl index dc3c06f7ede..2ad999ebb73 100644 --- a/ace/Message_Queue_T.inl +++ b/ace/Message_Queue_T.inl @@ -1,336 +1,3 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::dequeue (ACE_Message_Block *&first_item, - ACE_Time_Value *timeout) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::dequeue"); - return this->dequeue_head (first_item, timeout); -} - -template <ACE_SYNCH_DECL> ACE_INLINE ACE_Notification_Strategy * -ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy"); - - return this->notification_strategy_; -} - -template <ACE_SYNCH_DECL> ACE_INLINE void -ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy (ACE_Notification_Strategy *s) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::notification_strategy"); - - this->notification_strategy_ = s; -} - -// Check if queue is empty (does not hold locks). - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::is_empty_i (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_empty_i"); - return this->tail_ == 0; -} - -// Check if queue is full (does not hold locks). - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::is_full_i (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_full_i"); - return this->cur_bytes_ >= this->high_water_mark_; -} - -// Check if queue is empty (holds locks). - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::is_empty (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_empty"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); - - return this->is_empty_i (); -} - -// Check if queue is full (holds locks). - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::is_full (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::is_full"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); - - return this->is_full_i (); -} - -template <ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); - - return this->high_water_mark_; -} - -template <ACE_SYNCH_DECL> ACE_INLINE void -ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark (size_t hwm) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::high_water_mark"); - ACE_GUARD (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_); - - this->high_water_mark_ = hwm; -} - -template <ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); - - return this->low_water_mark_; -} - -template <ACE_SYNCH_DECL> ACE_INLINE void -ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark (size_t lwm) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::low_water_mark"); - ACE_GUARD (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_); - - this->low_water_mark_ = lwm; -} - -template <ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue<ACE_SYNCH_USE>::message_bytes (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::message_bytes"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); - - return this->cur_bytes_; -} - -template <ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue<ACE_SYNCH_USE>::message_length (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::message_length"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); - - return this->cur_length_; -} - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::message_count (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::message_count"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, 0); - - return this->cur_count_; -} - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::deactivate () -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::deactivate"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); - - return this->deactivate_i (0); // Not a pulse -} - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::activate (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::activate"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); - - return this->activate_i (); -} - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::pulse () -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::pulse"); - ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, ace_mon, this->lock_, -1); - - return this->deactivate_i (1); // Just a pulse -} - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::deactivated (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::deactivated"); - - return this->state_ == ACE_Message_Queue_Base::DEACTIVATED; -} - -template <ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue<ACE_SYNCH_USE>::state (void) -{ - ACE_TRACE ("ACE_Message_Queue<ACE_SYNCH_USE>::state"); - - return this->state_; -} - -#if 0 -// The Sun Forte 6 (CC 5.1) compiler is only happy if this is in the -// header file (j.russell.noseworthy@objectsciences.com) - -template <ACE_SYNCH_DECL> ACE_INLINE ACE_SYNCH_MUTEX_T & -ACE_Message_Queue<ACE_SYNCH_USE>::lock (void) -{ - return this->lock_; -} -#endif /* 0 */ - -ACE_ALLOC_HOOK_DEFINE(ACE_Message_Queue_Reverse_Iterator) - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue (ACE_MESSAGE_TYPE *&first_item, - ACE_Time_Value *timeout) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::dequeue"); - - return this->dequeue_head (first_item, timeout); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE ACE_Notification_Strategy * -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy"); - - return this->queue_.notification_strategy (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE void -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy (ACE_Notification_Strategy *s) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::notification_strategy"); - - this->queue_.notification_strategy (s); -} - -// Check if queue is empty (holds locks). - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_empty (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_empty"); - - return this->queue_.is_empty (); -} - -// Check if queue is full (holds locks). - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_full (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::is_full"); - - return this->queue_.is_full (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark"); - - return this->queue_.high_water_mark (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE void -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark (size_t hwm) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::high_water_mark"); - - this->queue_.high_water_mark (hwm); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark"); - - return this->queue_.low_water_mark (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE void -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark (size_t lwm) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::low_water_mark"); - - this->queue_.low_water_mark (lwm); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_bytes (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_bytes"); - - return this->queue_.message_bytes (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE size_t -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_length (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_length"); - - return this->queue_.message_length (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_count (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::message_count"); - - return this->queue_.message_count (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivate (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivate"); - - return this->queue_.deactivate (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::activate (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::activate"); - - return this->queue_.activate (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::pulse (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::pulse"); - - return this->queue_.pulse (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivated (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::deactivated"); - - return this->queue_.deactivated (); -} - -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE int -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::state (void) -{ - ACE_TRACE ("ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::state"); - - return this->queue_.state (); -} - -#if 0 -// The Sun Forte 6 (CC 5.1) compiler is only happy if this is in the -// header file (j.russell.noseworthy@objectsciences.com) -template <class ACE_MESSAGE_TYPE, ACE_SYNCH_DECL> ACE_INLINE ACE_SYNCH_MUTEX_T & -ACE_Message_Queue_Ex<ACE_MESSAGE_TYPE, ACE_SYNCH_USE>::lock (void) -{ - return this->queue_.lock (); -} -#endif /* 0 */ diff --git a/ace/POSIX_CB_Proactor.cpp b/ace/POSIX_CB_Proactor.cpp index c07849f726e..98bfc985f55 100644 --- a/ace/POSIX_CB_Proactor.cpp +++ b/ace/POSIX_CB_Proactor.cpp @@ -30,6 +30,12 @@ ACE_POSIX_CB_Proactor::~ACE_POSIX_CB_Proactor (void) this->close (); } +ACE_POSIX_Proactor::Proactor_Type +ACE_POSIX_CB_Proactor::get_impl_type (void) +{ + return PROACTOR_CB; +} + void ACE_POSIX_CB_Proactor::aio_completion_func (sigval_t cb_data) { ACE_POSIX_CB_Proactor * impl = static_cast<ACE_POSIX_CB_Proactor *> (cb_data.sival_ptr); diff --git a/ace/POSIX_CB_Proactor.inl b/ace/POSIX_CB_Proactor.inl index 5e6be74df26..2ad999ebb73 100644 --- a/ace/POSIX_CB_Proactor.inl +++ b/ace/POSIX_CB_Proactor.inl @@ -1,12 +1,3 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ - -#if defined (ACE_HAS_AIO_CALLS) - -ACE_INLINE -ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_CB_Proactor::get_impl_type (void) -{ - return PROACTOR_CB; -} - -#endif /* ACE_HAS_AIO_CALLS */ diff --git a/ace/POSIX_Proactor.cpp b/ace/POSIX_Proactor.cpp index 22f716a39e5..c7b2d11a39d 100644 --- a/ace/POSIX_Proactor.cpp +++ b/ace/POSIX_Proactor.cpp @@ -590,6 +590,13 @@ ACE_POSIX_Proactor::post_wakeup_completions (int how_many) return 0; } +ACE_POSIX_Proactor::Proactor_Type +ACE_POSIX_Proactor::get_impl_type (void) +{ + return PROACTOR_POSIX; +} + + /** * @class ACE_AIOCB_Notify_Pipe_Manager * @@ -820,6 +827,13 @@ ACE_POSIX_AIOCB_Proactor::~ACE_POSIX_AIOCB_Proactor (void) this->close(); } +ACE_POSIX_Proactor::Proactor_Type +ACE_POSIX_AIOCB_Proactor::get_impl_type (void) +{ + return PROACTOR_AIOCB; +} + + int ACE_POSIX_AIOCB_Proactor::close (void) { @@ -1680,6 +1694,12 @@ ACE_POSIX_SIG_Proactor::~ACE_POSIX_SIG_Proactor (void) // @@ Enable the masked signals again. } +ACE_POSIX_Proactor::Proactor_Type +ACE_POSIX_SIG_Proactor::get_impl_type (void) +{ + return PROACTOR_SIG; +} + int ACE_POSIX_SIG_Proactor::handle_events (ACE_Time_Value &wait_time) { diff --git a/ace/POSIX_Proactor.inl b/ace/POSIX_Proactor.inl index c5e80b49943..eb358c0b8ae 100644 --- a/ace/POSIX_Proactor.inl +++ b/ace/POSIX_Proactor.inl @@ -1,29 +1,8 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ ACE_INLINE -ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_Proactor::get_impl_type (void) -{ - return PROACTOR_POSIX; -} - -ACE_INLINE -ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_AIOCB_Proactor::get_impl_type (void) -{ - return PROACTOR_AIOCB; -} - -#if defined(ACE_HAS_POSIX_REALTIME_SIGNALS) - -ACE_INLINE -ACE_POSIX_Proactor::Proactor_Type ACE_POSIX_SIG_Proactor::get_impl_type (void) -{ - return PROACTOR_SIG; -} - -#endif /* ACE_HAS_POSIX_REALTIME_SIGNALS */ - -ACE_INLINE ACE_Asynch_Pseudo_Task& ACE_POSIX_Proactor::get_asynch_pseudo_task (void) { return this->pseudo_task_; diff --git a/ace/Refcounted_Auto_Ptr.cpp b/ace/Refcounted_Auto_Ptr.cpp new file mode 100644 index 00000000000..8abc1d7768d --- /dev/null +++ b/ace/Refcounted_Auto_Ptr.cpp @@ -0,0 +1,14 @@ +// $Id$ + +#ifndef ACE_REFCOUNTED_AUTO_PTR_CPP +#define ACE_REFCOUNTED_AUTO_PTR_CPP + +#include "ace/Refcounted_Auto_Ptr.h" + +template <class X, class ACE_LOCK> +ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr (void) +{ + AUTO_REFCOUNTED_PTR_REP::detach (rep_); +} + +#endif /* !ACE_REFCOUNTED_AUTO_PTR_CPP */ diff --git a/ace/Refcounted_Auto_Ptr.h b/ace/Refcounted_Auto_Ptr.h index 620ef555cfb..adac3dd7cd3 100644 --- a/ace/Refcounted_Auto_Ptr.h +++ b/ace/Refcounted_Auto_Ptr.h @@ -12,6 +12,7 @@ #ifndef ACE_REFCOUNTED_AUTO_PTR_H #define ACE_REFCOUNTED_AUTO_PTR_H + #include /**/ "ace/pre.h" #include "ace/Auto_Ptr.h" @@ -189,5 +190,14 @@ private: #include "ace/Refcounted_Auto_Ptr.inl" +#if defined (ACE_TEMPLATES_REQUIRE_SOURCE) +#include "ace/Refcounted_Auto_Ptr.cpp" +#endif /* ACE_TEMPLATES_REQUIRE_SOURCE */ + +#if defined (ACE_TEMPLATES_REQUIRE_PRAGMA) +#pragma implementation ("Refcounted_Auto_Ptr.cpp") +#endif /* ACE_TEMPLATES_REQUIRE_PRAGMA */ + #include /**/ "ace/post.h" + #endif /* ACE_REFCOUNTED_AUTO_PTR_H */ diff --git a/ace/Refcounted_Auto_Ptr.inl b/ace/Refcounted_Auto_Ptr.inl index 47c18678dfe..e0dfaa2e63c 100644 --- a/ace/Refcounted_Auto_Ptr.inl +++ b/ace/Refcounted_Auto_Ptr.inl @@ -157,12 +157,6 @@ ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::ACE_Refcounted_Auto_Ptr (const ACE_Refcoun { } -template <class X, class ACE_LOCK> inline -ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::~ACE_Refcounted_Auto_Ptr (void) -{ - AUTO_REFCOUNTED_PTR_REP::detach (rep_); -} - template <class X, class ACE_LOCK> inline bool ACE_Refcounted_Auto_Ptr<X, ACE_LOCK>::operator== (const ACE_Refcounted_Auto_Ptr<X, ACE_LOCK> &r) const { diff --git a/ace/Remote_Tokens.cpp b/ace/Remote_Tokens.cpp index 36c0d98e156..f80fe9a3bf8 100644 --- a/ace/Remote_Tokens.cpp +++ b/ace/Remote_Tokens.cpp @@ -2,15 +2,20 @@ // $Id$ #include "ace/Remote_Tokens.h" + +#if defined (ACE_HAS_TOKENS_LIBRARY) + #include "ace/Singleton.h" #if !defined (__ACE_INLINE__) #include "ace/Remote_Tokens.inl" #endif /* __ACE_INLINE__ */ -#if defined (ACE_HAS_TOKENS_LIBRARY) -ACE_RCSID(ace, Remote_Tokens, "$Id$") +ACE_RCSID (ace, + Remote_Tokens, + "$Id$") + #if defined (ACE_MT_SAFE) && (ACE_MT_SAFE != 0) #define ACE_TSS_CONNECTION_MUTEX ACE_Thread_Mutex @@ -398,6 +403,28 @@ ACE_Remote_Token_Proxy::dump (void) const #endif /* ACE_HAS_DUMP */ } +ACE_Token_Proxy * +ACE_Remote_Mutex::clone (void) const +{ + ACE_Token_Proxy *temp; + ACE_NEW_RETURN (temp, + ACE_Remote_Mutex (this->name (), + ignore_deadlock_, + debug_), + 0); + return temp; +} + +ACE_Tokens * +ACE_Remote_Mutex::create_token (const ACE_TCHAR *name) +{ + ACE_Tokens *temp; + ACE_NEW_RETURN (temp, + ACE_Mutex_Token (name), + 0); + return temp; +} + void ACE_Remote_Mutex::dump (void) const { @@ -411,6 +438,34 @@ ACE_Remote_Mutex::dump (void) const #endif /* ACE_HAS_DUMP */ } +ACE_Tokens * +ACE_Remote_RLock::create_token (const ACE_TCHAR *name) +{ + ACE_Tokens *temp = 0; + ACE_NEW_RETURN (temp, + ACE_RW_Token (name), + 0); + return temp; +} + +int +ACE_Remote_RLock::type (void) const +{ + return ACE_RW_Token::READER; +} + +ACE_Token_Proxy * +ACE_Remote_RLock::clone (void) const +{ + ACE_Token_Proxy *temp = 0; + ACE_NEW_RETURN (temp, + ACE_Remote_RLock (this->name (), + ignore_deadlock_, + debug_), + 0); + return temp; +} + void ACE_Remote_RLock::dump (void) const { @@ -424,6 +479,35 @@ ACE_Remote_RLock::dump (void) const #endif /* ACE_HAS_DUMP */ } + +ACE_Tokens * +ACE_Remote_WLock::create_token (const ACE_TCHAR *name) +{ + ACE_Tokens *temp = 0; + ACE_NEW_RETURN (temp, + ACE_RW_Token (name), + 0); + return temp; +} + +int +ACE_Remote_WLock::type (void) const +{ + return ACE_RW_Token::WRITER; +} + +ACE_Token_Proxy * +ACE_Remote_WLock::clone (void) const +{ + ACE_Token_Proxy *temp = 0; + ACE_NEW_RETURN (temp, + ACE_Remote_WLock (this->name (), + ignore_deadlock_, + debug_), + 0); + return temp; +} + void ACE_Remote_WLock::dump (void) const { diff --git a/ace/Remote_Tokens.inl b/ace/Remote_Tokens.inl index f0cc90e5105..004fe75b7d4 100644 --- a/ace/Remote_Tokens.inl +++ b/ace/Remote_Tokens.inl @@ -1,4 +1,5 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ #if defined (ACE_HAS_TOKENS_LIBRARY) @@ -18,28 +19,6 @@ ACE_Remote_Mutex::ACE_Remote_Mutex (const ACE_TCHAR *token_name, this->open (token_name, ignore_deadlock, debug); } -ACE_INLINE ACE_Token_Proxy * -ACE_Remote_Mutex::clone (void) const -{ - ACE_Token_Proxy *temp; - ACE_NEW_RETURN (temp, - ACE_Remote_Mutex (this->name (), - ignore_deadlock_, - debug_), - 0); - return temp; -} - -ACE_INLINE ACE_Tokens * -ACE_Remote_Mutex::create_token (const ACE_TCHAR *name) -{ - ACE_Tokens *temp; - ACE_NEW_RETURN (temp, - ACE_Mutex_Token (name), - 0); - return temp; -} - // ************************************************************ ACE_INLINE @@ -51,34 +30,6 @@ ACE_Remote_RLock::ACE_Remote_RLock (const ACE_TCHAR *token_name, this->open (token_name, ignore_deadlock, debug); } -ACE_INLINE ACE_Tokens * -ACE_Remote_RLock::create_token (const ACE_TCHAR *name) -{ - ACE_Tokens *temp = 0; - ACE_NEW_RETURN (temp, - ACE_RW_Token (name), - 0); - return temp; -} - -ACE_INLINE int -ACE_Remote_RLock::type (void) const -{ - return ACE_RW_Token::READER; -} - -ACE_INLINE ACE_Token_Proxy * -ACE_Remote_RLock::clone (void) const -{ - ACE_Token_Proxy *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Remote_RLock (this->name (), - ignore_deadlock_, - debug_), - 0); - return temp; -} - // ************************************************************ ACE_INLINE @@ -90,33 +41,4 @@ ACE_Remote_WLock::ACE_Remote_WLock (const ACE_TCHAR *token_name, this->open (token_name, ignore_deadlock, debug); } - -ACE_INLINE ACE_Tokens * -ACE_Remote_WLock::create_token (const ACE_TCHAR *name) -{ - ACE_Tokens *temp = 0; - ACE_NEW_RETURN (temp, - ACE_RW_Token (name), - 0); - return temp; -} - -ACE_INLINE int -ACE_Remote_WLock::type (void) const -{ - return ACE_RW_Token::WRITER; -} - -ACE_INLINE ACE_Token_Proxy * -ACE_Remote_WLock::clone (void) const -{ - ACE_Token_Proxy *temp = 0; - ACE_NEW_RETURN (temp, - ACE_Remote_WLock (this->name (), - ignore_deadlock_, - debug_), - 0); - return temp; -} - #endif /* ACE_HAS_TOKENS_LIBRARY */ diff --git a/ace/Reverse_Lock_T.cpp b/ace/Reverse_Lock_T.cpp index b2f6cef8c64..0dc093cf7a5 100644 --- a/ace/Reverse_Lock_T.cpp +++ b/ace/Reverse_Lock_T.cpp @@ -1,7 +1,7 @@ // $Id$ -#ifndef ACE_REVERSE_LOCK_T_C -#define ACE_REVERSE_LOCK_T_C +#ifndef ACE_REVERSE_LOCK_T_CPP +#define ACE_REVERSE_LOCK_T_CPP #include "ace/Reverse_Lock_T.h" @@ -9,15 +9,82 @@ # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -ACE_RCSID(ace, Reverse_Lock_T, "$Id$") - #if !defined (__ACE_INLINE__) #include "ace/Reverse_Lock_T.inl" #endif /* __ACE_INLINE__ */ + template <class ACE_LOCKING_MECHANISM> ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::~ACE_Reverse_Lock (void) { } -#endif /* ACE_REVERSE_LOCK_T_C */ +// Explicitly destroy the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::remove (void) +{ + return this->lock_.remove (); +} + +// Release the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire (void) +{ + return this->lock_.release (); +} + +// Release the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire (void) +{ + ACE_NOTSUP_RETURN (-1); +} + +// Acquire the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::release (void) +{ + if (this->acquire_method_ == ACE_Acquire_Method::ACE_READ) + return this->lock_.acquire_read (); + else if (this->acquire_method_ == ACE_Acquire_Method::ACE_WRITE) + return this->lock_.acquire_write (); + else + return this->lock_.acquire (); +} + +// Release the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_read (void) +{ + ACE_NOTSUP_RETURN (-1); +} + +// Release the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_write (void) +{ + ACE_NOTSUP_RETURN (-1); +} + +// Release the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_read (void) +{ + ACE_NOTSUP_RETURN (-1); +} + +// Release the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write (void) +{ + ACE_NOTSUP_RETURN (-1); +} + +// Release the lock. +template <class ACE_LOCKING_MECHANISM> int +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade (void) +{ + ACE_NOTSUP_RETURN (-1); +} + +#endif /* ACE_REVERSE_LOCK_T_CPP */ diff --git a/ace/Reverse_Lock_T.inl b/ace/Reverse_Lock_T.inl index 191e3623549..84533466663 100644 --- a/ace/Reverse_Lock_T.inl +++ b/ace/Reverse_Lock_T.inl @@ -1,81 +1,15 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ #include "ace/config-all.h" #include "ace/OS_NS_errno.h" template <class ACE_LOCKING_MECHANISM> ACE_INLINE -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::ACE_Reverse_Lock (ACE_LOCKING_MECHANISM &lock, - ACE_Acquire_Method::METHOD_TYPE acquire_method) +ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::ACE_Reverse_Lock ( + ACE_LOCKING_MECHANISM &lock, + ACE_Acquire_Method::METHOD_TYPE acquire_method) : lock_ (lock), acquire_method_ (acquire_method) { } - -// Explicitly destroy the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::remove (void) -{ - return this->lock_.remove (); -} - -// Release the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire (void) -{ - return this->lock_.release (); -} - -// Release the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire (void) -{ - ACE_NOTSUP_RETURN (-1); -} - -// Acquire the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::release (void) -{ - if (this->acquire_method_ == ACE_Acquire_Method::ACE_READ) - return this->lock_.acquire_read (); - else if (this->acquire_method_ == ACE_Acquire_Method::ACE_WRITE) - return this->lock_.acquire_write (); - else - return this->lock_.acquire (); -} - -// Release the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_read (void) -{ - ACE_NOTSUP_RETURN (-1); -} - -// Release the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::acquire_write (void) -{ - ACE_NOTSUP_RETURN (-1); -} - -// Release the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_read (void) -{ - ACE_NOTSUP_RETURN (-1); -} - -// Release the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write (void) -{ - ACE_NOTSUP_RETURN (-1); -} - -// Release the lock. -template <class ACE_LOCKING_MECHANISM> ACE_INLINE int -ACE_Reverse_Lock<ACE_LOCKING_MECHANISM>::tryacquire_write_upgrade (void) -{ - ACE_NOTSUP_RETURN (-1); -} diff --git a/ace/SUN_Proactor.cpp b/ace/SUN_Proactor.cpp index 306ea2485a3..c3928d525cf 100644 --- a/ace/SUN_Proactor.cpp +++ b/ace/SUN_Proactor.cpp @@ -310,4 +310,10 @@ ACE_SUN_Proactor::cancel_aiocb (ACE_POSIX_Asynch_Result *result) return 2; } +ACE_POSIX_Proactor::Proactor_Type +ACE_SUN_Proactor::get_impl_type (void) +{ + return PROACTOR_SUN; +} + #endif /* ACE_HAS_AIO_CALLS && sun */ diff --git a/ace/SUN_Proactor.inl b/ace/SUN_Proactor.inl index 545841223aa..2ad999ebb73 100644 --- a/ace/SUN_Proactor.inl +++ b/ace/SUN_Proactor.inl @@ -1,8 +1,3 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ - -ACE_INLINE -ACE_POSIX_Proactor::Proactor_Type ACE_SUN_Proactor::get_impl_type (void) -{ - return PROACTOR_SUN; -} diff --git a/ace/Shared_Memory_MM.cpp b/ace/Shared_Memory_MM.cpp index fac4fc964c2..9ad0bb021f3 100644 --- a/ace/Shared_Memory_MM.cpp +++ b/ace/Shared_Memory_MM.cpp @@ -1,4 +1,3 @@ -// Shared_Memory_MM.cpp // $Id$ #include "ace/Shared_Memory_MM.h" @@ -7,7 +6,11 @@ #include "ace/Shared_Memory_MM.inl" #endif /* __ACE_INLINE__ */ -ACE_RCSID(ace, Shared_Memory_MM, "$Id$") + +ACE_RCSID (ace, + Shared_Memory_MM, + "$Id$") + ACE_ALLOC_HOOK_DEFINE(ACE_Shared_Memory_MM) @@ -52,3 +55,54 @@ ACE_Shared_Memory_MM::ACE_Shared_Memory_MM (void) { ACE_TRACE ("ACE_Shared_Memory_MM::ACE_Shared_Memory_MM"); } + +// The overall size of the segment. + +int +ACE_Shared_Memory_MM::get_segment_size (void) const +{ + ACE_TRACE ("ACE_Shared_Memory_MM::get_segment_size"); + // This cast is legit since the original length in open() is an int. + return static_cast<int> (this->shared_memory_.size ()); +} + +// Unmaps the shared memory segment. + +int +ACE_Shared_Memory_MM::remove (void) +{ + ACE_TRACE ("ACE_Shared_Memory_MM::remove"); + return shared_memory_.remove (); +} + +// Closes (unmaps) the shared memory segment. + +int +ACE_Shared_Memory_MM::close (void) +{ + ACE_TRACE ("ACE_Shared_Memory_MM::close"); + return shared_memory_.unmap (); +} + +void * +ACE_Shared_Memory_MM::malloc (size_t) +{ + ACE_TRACE ("ACE_Shared_Memory_MM::malloc"); + void *addr; + + return this->shared_memory_ (addr) == -1 ? 0 : addr; +} + +ACE_HANDLE +ACE_Shared_Memory_MM::get_id (void) const +{ + ACE_TRACE ("ACE_Shared_Memory_MM::get_id"); + return this->shared_memory_.handle (); +} + +int +ACE_Shared_Memory_MM::free (void *p) +{ + ACE_TRACE ("ACE_Shared_Memory_MM::free"); + return p != 0; +} diff --git a/ace/Shared_Memory_MM.inl b/ace/Shared_Memory_MM.inl index 0c6b18d8aba..ff52dacd44b 100644 --- a/ace/Shared_Memory_MM.inl +++ b/ace/Shared_Memory_MM.inl @@ -37,54 +37,3 @@ ACE_Shared_Memory_MM::open (const ACE_TCHAR *file_name, return shared_memory_.map (file_name, len, flags, mode, prot, share, addr, pos); } - -// The overall size of the segment. - -ACE_INLINE int -ACE_Shared_Memory_MM::get_segment_size (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_MM::get_segment_size"); - // This cast is legit since the original length in open() is an int. - return static_cast<int> (this->shared_memory_.size ()); -} - -// Unmaps the shared memory segment. - -ACE_INLINE int -ACE_Shared_Memory_MM::remove (void) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::remove"); - return shared_memory_.remove (); -} - -// Closes (unmaps) the shared memory segment. - -ACE_INLINE int -ACE_Shared_Memory_MM::close (void) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::close"); - return shared_memory_.unmap (); -} - -ACE_INLINE void * -ACE_Shared_Memory_MM::malloc (size_t) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::malloc"); - void *addr; - - return this->shared_memory_ (addr) == -1 ? 0 : addr; -} - -ACE_INLINE ACE_HANDLE -ACE_Shared_Memory_MM::get_id (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_MM::get_id"); - return this->shared_memory_.handle (); -} - -ACE_INLINE int -ACE_Shared_Memory_MM::free (void *p) -{ - ACE_TRACE ("ACE_Shared_Memory_MM::free"); - return p != 0; -} diff --git a/ace/Shared_Memory_SV.cpp b/ace/Shared_Memory_SV.cpp index 8b530fd7462..59d6ad2fedc 100644 --- a/ace/Shared_Memory_SV.cpp +++ b/ace/Shared_Memory_SV.cpp @@ -1,4 +1,3 @@ -// Shared_Memory_SV.cpp // $Id$ #include "ace/Shared_Memory_SV.h" @@ -7,7 +6,11 @@ #include "ace/Shared_Memory_SV.inl" #endif /* __ACE_INLINE__ */ -ACE_RCSID(ace, Shared_Memory_SV, "$Id$") + +ACE_RCSID (ace, + Shared_Memory_SV, + "$Id$") + ACE_ALLOC_HOOK_DEFINE(ACE_Shared_Memory_SV) @@ -30,3 +33,52 @@ ACE_Shared_Memory_SV::ACE_Shared_Memory_SV (key_t id, ACE_TRACE ("ACE_Shared_Memory_SV::ACE_Shared_Memory_SV"); } +// The overall size of the segment. + +int +ACE_Shared_Memory_SV::get_segment_size (void) const +{ + ACE_TRACE ("ACE_Shared_Memory_SV::get_segment_size"); + // This cast is ok since the 'open' method for this class allows only + // an 'int' size. Therefore, this case should not lose information. + return static_cast<int> (this->shared_memory_.get_segment_size ()); +} + +// Removes the shared memory segment. + +int +ACE_Shared_Memory_SV::remove (void) +{ + ACE_TRACE ("ACE_Shared_Memory_SV::remove"); + return shared_memory_.remove (); +} + +// Closes (detaches) the shared memory segment. + +int +ACE_Shared_Memory_SV::close (void) +{ + ACE_TRACE ("ACE_Shared_Memory_SV::close"); + return shared_memory_.detach (); +} + +void * +ACE_Shared_Memory_SV::malloc (size_t) +{ + ACE_TRACE ("ACE_Shared_Memory_SV::malloc"); + return this->shared_memory_.get_segment_ptr (); +} + +ACE_HANDLE +ACE_Shared_Memory_SV::get_id (void) const +{ + ACE_TRACE ("ACE_Shared_Memory_SV::get_id"); + return this->shared_memory_.get_id (); +} + +int +ACE_Shared_Memory_SV::free (void *p) +{ + ACE_TRACE ("ACE_Shared_Memory_SV::free"); + return p != 0; +} diff --git a/ace/Shared_Memory_SV.inl b/ace/Shared_Memory_SV.inl index 7f9d6d963fd..1830df3f630 100644 --- a/ace/Shared_Memory_SV.inl +++ b/ace/Shared_Memory_SV.inl @@ -18,49 +18,6 @@ ACE_Shared_Memory_SV::open (key_t id, perms, addr, flags); } -// The overall size of the segment. - -ACE_INLINE int -ACE_Shared_Memory_SV::get_segment_size (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_SV::get_segment_size"); - // This cast is ok since the 'open' method for this class allows only - // an 'int' size. Therefore, this case should not lose information. - return static_cast<int> (this->shared_memory_.get_segment_size ()); -} - -// Removes the shared memory segment. - -ACE_INLINE int -ACE_Shared_Memory_SV::remove (void) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::remove"); - return shared_memory_.remove (); -} - -// Closes (detaches) the shared memory segment. - -ACE_INLINE int -ACE_Shared_Memory_SV::close (void) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::close"); - return shared_memory_.detach (); -} - -ACE_INLINE void * -ACE_Shared_Memory_SV::malloc (size_t) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::malloc"); - return this->shared_memory_.get_segment_ptr (); -} - -ACE_INLINE ACE_HANDLE -ACE_Shared_Memory_SV::get_id (void) const -{ - ACE_TRACE ("ACE_Shared_Memory_SV::get_id"); - return this->shared_memory_.get_id (); -} - // The "do-nothing" constructor. ACE_INLINE @@ -68,10 +25,3 @@ ACE_Shared_Memory_SV::ACE_Shared_Memory_SV (void) { ACE_TRACE ("ACE_Shared_Memory_SV::ACE_Shared_Memory_SV"); } - -ACE_INLINE int -ACE_Shared_Memory_SV::free (void *p) -{ - ACE_TRACE ("ACE_Shared_Memory_SV::free"); - return p != 0; -} diff --git a/ace/Strategies_T.cpp b/ace/Strategies_T.cpp index a3f2a8ff9ef..7408ba305f2 100644 --- a/ace/Strategies_T.cpp +++ b/ace/Strategies_T.cpp @@ -26,6 +26,45 @@ ACE_RCSID (ace, "$Id$") +template<class SVC_HANDLER> +ACE_Recycling_Strategy<SVC_HANDLER>::~ACE_Recycling_Strategy (void) +{ +} + +template<class SVC_HANDLER> int +ACE_Recycling_Strategy<SVC_HANDLER>::assign_recycler (SVC_HANDLER *svc_handler, + ACE_Connection_Recycling_Strategy *recycler, + const void *recycling_act) +{ + svc_handler->recycler (recycler, recycling_act); + return 0; +} + +template<class SVC_HANDLER> int +ACE_Recycling_Strategy<SVC_HANDLER>::prepare_for_recycling (SVC_HANDLER *svc_handler) +{ + return svc_handler->recycle (); +} + +template <class SVC_HANDLER> +ACE_Singleton_Strategy<SVC_HANDLER>::~ACE_Singleton_Strategy (void) +{ + ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::~ACE_Singleton_Strategy"); + if (this->delete_svc_handler_ != 0) + delete this->svc_handler_; +} + +// Create a Singleton SVC_HANDLER by always returning the same +// SVC_HANDLER. + +template <class SVC_HANDLER> int +ACE_Singleton_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh) +{ + ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::make_svc_handler"); + sh = this->svc_handler_; + return 0; +} + template <class SVC_HANDLER> int ACE_Singleton_Strategy<SVC_HANDLER>::open (SVC_HANDLER *sh, ACE_Thread_Manager *) @@ -556,6 +595,38 @@ ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::open } template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int +ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::make_svc_handler + (SVC_HANDLER *&sh) +{ + return this->creation_strategy_->make_svc_handler (sh); +} + +template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int +ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::activate_svc_handler + (SVC_HANDLER *svc_handler) +{ + return this->concurrency_strategy_->activate_svc_handler (svc_handler); +} + +template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int +ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::assign_recycler + (SVC_HANDLER *svc_handler, + ACE_Connection_Recycling_Strategy *recycler, + const void *recycling_act) +{ + return this->recycling_strategy_->assign_recycler (svc_handler, + recycler, + recycling_act); +} + +template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int +ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::prepare_for_recycling + (SVC_HANDLER *svc_handler) +{ + return this->recycling_strategy_->prepare_for_recycling (svc_handler); +} + +template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> int ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::check_hint_i (SVC_HANDLER *&sh, const ACE_PEER_CONNECTOR_ADDR &remote_addr, @@ -1156,6 +1227,13 @@ ACE_DLL_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> +ACE_Concurrency_Strategy<SVC_HANDLER>::~ACE_Concurrency_Strategy (void) +{ + ACE_TRACE ("ACE_Concurrency_Strategy<SVC_HANDLER>::~ACE_Concurrency_Strategy"); +} + + template <class SVC_HANDLER> void ACE_Concurrency_Strategy<SVC_HANDLER>::dump (void) const { @@ -1164,6 +1242,13 @@ ACE_Concurrency_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> +ACE_Reactive_Strategy<SVC_HANDLER>::~ACE_Reactive_Strategy (void) +{ + ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::~ACE_Reactive_Strategy"); +} + + template <class SVC_HANDLER> void ACE_Reactive_Strategy<SVC_HANDLER>::dump (void) const { @@ -1172,6 +1257,12 @@ ACE_Reactive_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> +ACE_Thread_Strategy<SVC_HANDLER>::~ACE_Thread_Strategy (void) +{ + ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::~ACE_Thread_Strategy"); +} + template <class SVC_HANDLER> void ACE_Thread_Strategy<SVC_HANDLER>::dump (void) const { @@ -1180,6 +1271,29 @@ ACE_Thread_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> +ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Accept_Strategy (void) +{ + ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Accept_Strategy"); + + // Close the underlying acceptor. + this->peer_acceptor_.close (); +} + +template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_HANDLE +ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const +{ + ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle"); + return this->peer_acceptor_.get_handle (); +} + +template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_PEER_ACCEPTOR & +ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const +{ + ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor"); + return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_; +} + template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> void ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const { @@ -1188,6 +1302,19 @@ ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> +ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connect_Strategy (void) +{ + ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connect_Strategy"); +} + +template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_PEER_CONNECTOR & +ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector (void) const +{ + ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector"); + return (ACE_PEER_CONNECTOR &) this->connector_; +} + template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> void ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump (void) const { @@ -1196,6 +1323,12 @@ ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> +ACE_Process_Strategy<SVC_HANDLER>::~ACE_Process_Strategy (void) +{ + ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::~ACE_Process_Strategy"); +} + template <class SVC_HANDLER> void ACE_Process_Strategy<SVC_HANDLER>::dump (void) const { @@ -1204,6 +1337,26 @@ ACE_Process_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> +ACE_Scheduling_Strategy<SVC_HANDLER>::~ACE_Scheduling_Strategy (void) +{ + ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::~ACE_Scheduling_Strategy"); +} + +template <class SVC_HANDLER> int +ACE_Scheduling_Strategy<SVC_HANDLER>::suspend (void) +{ + ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::suspend"); + return -1; +} + +template <class SVC_HANDLER> int +ACE_Scheduling_Strategy<SVC_HANDLER>::resume (void) +{ + ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::resume"); + return -1; +} + template <class SVC_HANDLER> void ACE_Scheduling_Strategy<SVC_HANDLER>::dump (void) const { @@ -1215,6 +1368,20 @@ ACE_Scheduling_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> int +ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::suspend (void) +{ + ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::suspend"); + return this->reactor_->suspend_handlers (); +} + +template <class SVC_HANDLER> int +ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::resume (void) +{ + ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::resume"); + return this->reactor_->resume_handlers (); +} + template <class SVC_HANDLER> void ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::dump (void) const { @@ -1225,6 +1392,20 @@ ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> int +ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::suspend (void) +{ + ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::suspend"); + return this->thr_mgr_->suspend_all (); +} + +template <class SVC_HANDLER> int +ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::resume (void) +{ + ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::resume"); + return this->thr_mgr_->resume_all (); +} + template <class SVC_HANDLER> void ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::dump (void) const { @@ -1235,6 +1416,11 @@ ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class T> +ACE_Refcounted_Hash_Recyclable<T>::~ACE_Refcounted_Hash_Recyclable (void) +{ +} + template <class SVC_HANDLER> void ACE_Singleton_Strategy<SVC_HANDLER>::dump (void) const { @@ -1243,6 +1429,26 @@ ACE_Singleton_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> +ACE_Creation_Strategy<SVC_HANDLER>::~ACE_Creation_Strategy (void) +{ + ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::~ACE_Creation_Strategy"); +} + +// Default behavior is to make a new SVC_HANDLER, passing in the +// Thread_Manager (if any). + +template <class SVC_HANDLER> int +ACE_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh) +{ + ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::make_svc_handler"); + + if (sh == 0) + ACE_NEW_RETURN (sh, SVC_HANDLER (this->thr_mgr_), -1); + sh->reactor (this->reactor_); + return 0; +} + template <class SVC_HANDLER> void ACE_Creation_Strategy<SVC_HANDLER>::dump (void) const { @@ -1251,6 +1457,22 @@ ACE_Creation_Strategy<SVC_HANDLER>::dump (void) const #endif /* ACE_HAS_DUMP */ } +template <class SVC_HANDLER> int +ACE_NOOP_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&) +{ + ACE_TRACE ("ACE_NOOP_Creation_Strategy<SVC_HANDLER>::make_svc_handler"); + return 0; +} + +template <class SVC_HANDLER> int +ACE_NOOP_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *, + void *) +{ + ACE_TRACE ("ACE_NOOP_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler"); + return 0; +} + + ACE_ALLOC_HOOK_DEFINE(ACE_Creation_Strategy) ACE_ALLOC_HOOK_DEFINE(ACE_Singleton_Strategy) ACE_ALLOC_HOOK_DEFINE(ACE_DLL_Strategy) diff --git a/ace/Strategies_T.inl b/ace/Strategies_T.inl index 97d4a9a00a9..6f0c59304b1 100644 --- a/ace/Strategies_T.inl +++ b/ace/Strategies_T.inl @@ -1,26 +1,7 @@ // -*- C++ -*- +// // $Id$ -template<class SVC_HANDLER> ACE_INLINE -ACE_Recycling_Strategy<SVC_HANDLER>::~ACE_Recycling_Strategy (void) -{ -} - -template<class SVC_HANDLER> ACE_INLINE int -ACE_Recycling_Strategy<SVC_HANDLER>::assign_recycler (SVC_HANDLER *svc_handler, - ACE_Connection_Recycling_Strategy *recycler, - const void *recycling_act) -{ - svc_handler->recycler (recycler, recycling_act); - return 0; -} - -template<class SVC_HANDLER> ACE_INLINE int -ACE_Recycling_Strategy<SVC_HANDLER>::prepare_for_recycling (SVC_HANDLER *svc_handler) -{ - return svc_handler->recycle (); -} - template <class SVC_HANDLER> ACE_INLINE ACE_Singleton_Strategy<SVC_HANDLER>::ACE_Singleton_Strategy (SVC_HANDLER *sh, ACE_Thread_Manager *tm) @@ -34,25 +15,6 @@ ACE_Singleton_Strategy<SVC_HANDLER>::ACE_Singleton_Strategy (SVC_HANDLER *sh, ACE_LIB_TEXT ("ACE_Singleton_Strategy"))); } -template <class SVC_HANDLER> ACE_INLINE -ACE_Singleton_Strategy<SVC_HANDLER>::~ACE_Singleton_Strategy (void) -{ - ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::~ACE_Singleton_Strategy"); - if (this->delete_svc_handler_ != 0) - delete this->svc_handler_; -} - -// Create a Singleton SVC_HANDLER by always returning the same -// SVC_HANDLER. - -template <class SVC_HANDLER> ACE_INLINE int -ACE_Singleton_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh) -{ - ACE_TRACE ("ACE_Singleton_Strategy<SVC_HANDLER>::make_svc_handler"); - sh = this->svc_handler_; - return 0; -} - template <class SVC_HANDLER> ACE_INLINE int ACE_Creation_Strategy<SVC_HANDLER>::open (ACE_Thread_Manager *thr_mgr, ACE_Reactor *reactor) @@ -74,26 +36,6 @@ ACE_Creation_Strategy<SVC_HANDLER>::ACE_Creation_Strategy (ACE_Thread_Manager *t ACE_LIB_TEXT ("ACE_Creation_Strategy"))); } -// Default behavior is to make a new SVC_HANDLER, passing in the -// Thread_Manager (if any). - -template <class SVC_HANDLER> ACE_INLINE int -ACE_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&sh) -{ - ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::make_svc_handler"); - - if (sh == 0) - ACE_NEW_RETURN (sh, SVC_HANDLER (this->thr_mgr_), -1); - sh->reactor (this->reactor_); - return 0; -} - -template <class SVC_HANDLER> ACE_INLINE -ACE_Creation_Strategy<SVC_HANDLER>::~ACE_Creation_Strategy (void) -{ - ACE_TRACE ("ACE_Creation_Strategy<SVC_HANDLER>::~ACE_Creation_Strategy"); -} - template <class SVC_HANDLER> ACE_INLINE ACE_DLL_Strategy<SVC_HANDLER>::ACE_DLL_Strategy (const ACE_TCHAR dll_name[], const ACE_TCHAR factory_function[], @@ -126,12 +68,6 @@ ACE_Concurrency_Strategy<SVC_HANDLER>::ACE_Concurrency_Strategy (int flags) } template <class SVC_HANDLER> ACE_INLINE -ACE_Concurrency_Strategy<SVC_HANDLER>::~ACE_Concurrency_Strategy (void) -{ - ACE_TRACE ("ACE_Concurrency_Strategy<SVC_HANDLER>::~ACE_Concurrency_Strategy"); -} - -template <class SVC_HANDLER> ACE_INLINE ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy (ACE_Reactor *reactor, ACE_Reactor_Mask mask, int flags) @@ -156,12 +92,6 @@ ACE_Reactive_Strategy<SVC_HANDLER>::ACE_Reactive_Strategy (int flags) } template <class SVC_HANDLER> ACE_INLINE -ACE_Reactive_Strategy<SVC_HANDLER>::~ACE_Reactive_Strategy (void) -{ - ACE_TRACE ("ACE_Reactive_Strategy<SVC_HANDLER>::~ACE_Reactive_Strategy"); -} - -template <class SVC_HANDLER> ACE_INLINE ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy (ACE_Thread_Manager *thr_mgr, long thr_flags, int n_threads, @@ -188,12 +118,6 @@ ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy (int flags) ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::ACE_Thread_Strategy"); } -template <class SVC_HANDLER> ACE_INLINE -ACE_Thread_Strategy<SVC_HANDLER>::~ACE_Thread_Strategy (void) -{ - ACE_TRACE ("ACE_Thread_Strategy<SVC_HANDLER>::~ACE_Thread_Strategy"); -} - template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_INLINE ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy (ACE_Reactor *reactor) : reactor_ (reactor) @@ -201,48 +125,12 @@ ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy (ACE_ ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy"); } -template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_INLINE ACE_HANDLE -ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle (void) const -{ - ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::get_handle"); - return this->peer_acceptor_.get_handle (); -} - -template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_INLINE ACE_PEER_ACCEPTOR & -ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor (void) const -{ - ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::acceptor"); - return (ACE_PEER_ACCEPTOR &) this->peer_acceptor_; -} - -template <class SVC_HANDLER, ACE_PEER_ACCEPTOR_1> ACE_INLINE -ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Accept_Strategy (void) -{ - ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::~ACE_Accept_Strategy"); - - // Close the underlying acceptor. - this->peer_acceptor_.close (); -} - -template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_INLINE ACE_PEER_CONNECTOR & -ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector (void) const -{ - ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::connector"); - return (ACE_PEER_CONNECTOR &) this->connector_; -} - template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_INLINE ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connect_Strategy (void) { ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::ACE_Connect_Strategy"); } -template <class SVC_HANDLER, ACE_PEER_CONNECTOR_1> ACE_INLINE -ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connect_Strategy (void) -{ - ACE_TRACE ("ACE_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2>::~ACE_Connect_Strategy"); -} - template <class SVC_HANDLER> ACE_INLINE ACE_Process_Strategy<SVC_HANDLER>::ACE_Process_Strategy (size_t n_processes, ACE_Event_Handler *acceptor, @@ -260,38 +148,12 @@ ACE_Process_Strategy<SVC_HANDLER>::ACE_Process_Strategy (size_t n_processes, } template <class SVC_HANDLER> ACE_INLINE -ACE_Process_Strategy<SVC_HANDLER>::~ACE_Process_Strategy (void) -{ - ACE_TRACE ("ACE_Process_Strategy<SVC_HANDLER>::~ACE_Process_Strategy"); -} - -template <class SVC_HANDLER> ACE_INLINE ACE_Scheduling_Strategy<SVC_HANDLER>::ACE_Scheduling_Strategy (SVC_HANDLER *) { ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::ACE_Scheduling_Strategy"); } template <class SVC_HANDLER> ACE_INLINE -ACE_Scheduling_Strategy<SVC_HANDLER>::~ACE_Scheduling_Strategy (void) -{ - ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::~ACE_Scheduling_Strategy"); -} - -template <class SVC_HANDLER> ACE_INLINE int -ACE_Scheduling_Strategy<SVC_HANDLER>::suspend (void) -{ - ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::suspend"); - return -1; -} - -template <class SVC_HANDLER> ACE_INLINE int -ACE_Scheduling_Strategy<SVC_HANDLER>::resume (void) -{ - ACE_TRACE ("ACE_Scheduling_Strategy<SVC_HANDLER>::resume"); - return -1; -} - -template <class SVC_HANDLER> ACE_INLINE ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::ACE_Schedule_All_Reactive_Strategy (SVC_HANDLER *scheduler) : ACE_Scheduling_Strategy<SVC_HANDLER> (scheduler) @@ -304,20 +166,6 @@ ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::ACE_Schedule_All_Reactive_Strat this->reactor_ = scheduler->reactor (); } -template <class SVC_HANDLER> ACE_INLINE int -ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::suspend (void) -{ - ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::suspend"); - return this->reactor_->suspend_handlers (); -} - -template <class SVC_HANDLER> ACE_INLINE int -ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::resume (void) -{ - ACE_TRACE ("ACE_Schedule_All_Reactive_Strategy<SVC_HANDLER>::resume"); - return this->reactor_->resume_handlers (); -} - template <class SVC_HANDLER> ACE_INLINE ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::ACE_Schedule_All_Threaded_Strategy (SVC_HANDLER *scheduler) @@ -331,20 +179,6 @@ ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::ACE_Schedule_All_Threaded_Strat this->thr_mgr_ = scheduler->thr_mgr (); } -template <class SVC_HANDLER> ACE_INLINE int -ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::suspend (void) -{ - ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::suspend"); - return this->thr_mgr_->suspend_all (); -} - -template <class SVC_HANDLER> ACE_INLINE int -ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::resume (void) -{ - ACE_TRACE ("ACE_Schedule_All_Threaded_Strategy<SVC_HANDLER>::resume"); - return this->thr_mgr_->resume_all (); -} - template <class T> ACE_INLINE ACE_Refcounted_Hash_Recyclable<T>::ACE_Refcounted_Hash_Recyclable (void) : ACE_Refcountable (0), @@ -365,11 +199,6 @@ ACE_Refcounted_Hash_Recyclable<T>::ACE_Refcounted_Hash_Recyclable (const T &t, { } -template <class T> ACE_INLINE -ACE_Refcounted_Hash_Recyclable<T>::~ACE_Refcounted_Hash_Recyclable (void) -{ -} - template <class T> ACE_INLINE u_long ACE_Refcounted_Hash_Recyclable<T>::hash_i (void) const { @@ -395,50 +224,3 @@ ACE_Refcounted_Hash_Recyclable<T>::operator!= (const ACE_Refcounted_Hash_Recycla { return !this->operator== (rhs); } - -template <class SVC_HANDLER> ACE_INLINE int -ACE_NOOP_Creation_Strategy<SVC_HANDLER>::make_svc_handler (SVC_HANDLER *&) -{ - ACE_TRACE ("ACE_NOOP_Creation_Strategy<SVC_HANDLER>::make_svc_handler"); - return 0; -} - -template <class SVC_HANDLER> ACE_INLINE int -ACE_NOOP_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler (SVC_HANDLER *, - void *) -{ - ACE_TRACE ("ACE_NOOP_Concurrency_Strategy<SVC_HANDLER>::activate_svc_handler"); - return 0; -} - -template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_INLINE int -ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::make_svc_handler - (SVC_HANDLER *&sh) -{ - return this->creation_strategy_->make_svc_handler (sh); -} - -template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_INLINE int -ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::activate_svc_handler - (SVC_HANDLER *svc_handler) -{ - return this->concurrency_strategy_->activate_svc_handler (svc_handler); -} - -template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_INLINE int -ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::assign_recycler - (SVC_HANDLER *svc_handler, - ACE_Connection_Recycling_Strategy *recycler, - const void *recycling_act) -{ - return this->recycling_strategy_->assign_recycler (svc_handler, - recycler, - recycling_act); -} - -template<class SVC_HANDLER, ACE_PEER_CONNECTOR_1, class MUTEX> ACE_INLINE int -ACE_Cached_Connect_Strategy<SVC_HANDLER, ACE_PEER_CONNECTOR_2, MUTEX>::prepare_for_recycling - (SVC_HANDLER *svc_handler) -{ - return this->recycling_strategy_->prepare_for_recycling (svc_handler); -} diff --git a/ace/String_Base.cpp b/ace/String_Base.cpp index 5fdeb917cba..e8d861c69a8 100644 --- a/ace/String_Base.cpp +++ b/ace/String_Base.cpp @@ -24,7 +24,7 @@ template <class CHAR> // Default constructor. -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR>::ACE_String_Base (ACE_Allocator *the_allocator) : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()), len_ (0), @@ -37,7 +37,7 @@ ACE_String_Base<CHAR>::ACE_String_Base (ACE_Allocator *the_allocator) // Constructor that actually copies memory. -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR>::ACE_String_Base (const CHAR *s, ACE_Allocator *the_allocator, int release) @@ -51,7 +51,7 @@ ACE_String_Base<CHAR>::ACE_String_Base (const CHAR *s, this->set (s, release); } -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR>::ACE_String_Base (CHAR c, ACE_Allocator *the_allocator) : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()), @@ -67,7 +67,7 @@ ACE_String_Base<CHAR>::ACE_String_Base (CHAR c, // Constructor that actually copies memory. -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR>::ACE_String_Base (const CHAR *s, size_t len, ACE_Allocator *the_allocator, @@ -85,7 +85,7 @@ ACE_String_Base<CHAR>::ACE_String_Base (const CHAR *s, // Copy constructor. -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR>::ACE_String_Base (const ACE_String_Base<CHAR> &s) : allocator_ (s.allocator_ ? s.allocator_ : ACE_Allocator::instance ()), len_ (0), @@ -98,7 +98,7 @@ ACE_String_Base<CHAR>::ACE_String_Base (const ACE_String_Base<CHAR> &s) this->set (s.rep_, s.len_, 1); } -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR>::ACE_String_Base (size_t len, CHAR c, ACE_Allocator *the_allocator) : allocator_ (the_allocator ? the_allocator : ACE_Allocator::instance ()), len_ (0), @@ -111,7 +111,7 @@ ACE_String_Base<CHAR>::ACE_String_Base (size_t len, CHAR c, ACE_Allocator *the_a this->resize (len, c); } -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR>::~ACE_String_Base (void) { ACE_TRACE ("ACE_String_Base<CHAR>::~ACE_String_Base"); @@ -293,7 +293,7 @@ ACE_String_Base<CHAR>::clear (int release) } // Assignment operator (does copy memory). -template <class CHAR> ACE_INLINE ACE_String_Base<CHAR> & +template <class CHAR> ACE_String_Base<CHAR> & ACE_String_Base<CHAR>::operator= (const ACE_String_Base<CHAR> &s) { ACE_TRACE ("ACE_String_Base<CHAR>::operator="); @@ -307,7 +307,7 @@ ACE_String_Base<CHAR>::operator= (const ACE_String_Base<CHAR> &s) return *this; } -template <class CHAR> ACE_INLINE void +template <class CHAR> void ACE_String_Base<CHAR>::set (const CHAR *s, int release) { size_t length = 0; @@ -317,7 +317,7 @@ ACE_String_Base<CHAR>::set (const CHAR *s, int release) this->set (s, length, release); } -template <class CHAR> ACE_INLINE void +template <class CHAR> void ACE_String_Base<CHAR>::fast_clear (void) { this->len_ = 0; @@ -337,7 +337,7 @@ ACE_String_Base<CHAR>::fast_clear (void) // Get a copy of the underlying representation. -template <class CHAR> ACE_INLINE CHAR * +template <class CHAR> CHAR * ACE_String_Base<CHAR>::rep (void) const { ACE_TRACE ("ACE_String_Base<CHAR>::rep"); @@ -349,7 +349,7 @@ ACE_String_Base<CHAR>::rep (void) const return new_string; } -template <class CHAR> ACE_INLINE int +template <class CHAR> int ACE_String_Base<CHAR>::compare (const ACE_String_Base<CHAR> &s) const { ACE_TRACE ("ACE_String_Base<CHAR>::compare"); @@ -371,7 +371,7 @@ ACE_String_Base<CHAR>::compare (const ACE_String_Base<CHAR> &s) const // Comparison operator. -template <class CHAR> ACE_INLINE bool +template <class CHAR> bool ACE_String_Base<CHAR>::operator== (const ACE_String_Base<CHAR> &s) const { ACE_TRACE ("ACE_String_Base<CHAR>::operator=="); @@ -380,7 +380,7 @@ ACE_String_Base<CHAR>::operator== (const ACE_String_Base<CHAR> &s) const return compare (s) == 0; } -template <class CHAR> ACE_INLINE ssize_t +template <class CHAR> ssize_t ACE_String_Base<CHAR>::find (const CHAR *s, size_t pos) const { CHAR *substr = this->rep_ + pos; @@ -392,7 +392,7 @@ ACE_String_Base<CHAR>::find (const CHAR *s, size_t pos) const return pointer - this->rep_; } -template <class CHAR> ACE_INLINE ssize_t +template <class CHAR> ssize_t ACE_String_Base<CHAR>::find (CHAR c, size_t pos) const { CHAR *substr = this->rep_ + pos; @@ -403,7 +403,7 @@ ACE_String_Base<CHAR>::find (CHAR c, size_t pos) const return pointer - this->rep_; } -template <class CHAR> ACE_INLINE ssize_t +template <class CHAR> ssize_t ACE_String_Base<CHAR>::rfind (CHAR c, ssize_t pos) const { if (pos == npos || pos > static_cast<ssize_t> (this->len_)) @@ -416,7 +416,7 @@ ACE_String_Base<CHAR>::rfind (CHAR c, ssize_t pos) const return ACE_String_Base<CHAR>::npos; } -template <class CHAR> ACE_INLINE ACE_String_Base<CHAR> +template <class CHAR> ACE_String_Base<CHAR> operator+ (const ACE_String_Base<CHAR> &s, const ACE_String_Base<CHAR> &t) { ACE_String_Base<CHAR> temp (s.length() + t.length()); @@ -425,7 +425,7 @@ operator+ (const ACE_String_Base<CHAR> &s, const ACE_String_Base<CHAR> &t) return temp; } -template <class CHAR> ACE_INLINE ACE_String_Base<CHAR> +template <class CHAR> ACE_String_Base<CHAR> operator+ (const CHAR *s, const ACE_String_Base<CHAR> &t) { size_t slen = 0; @@ -438,7 +438,7 @@ operator+ (const CHAR *s, const ACE_String_Base<CHAR> &t) return temp; } -template <class CHAR> ACE_INLINE ACE_String_Base<CHAR> +template <class CHAR> ACE_String_Base<CHAR> operator+ (const ACE_String_Base<CHAR> &s, const CHAR *t) { size_t tlen = 0; @@ -451,7 +451,7 @@ operator+ (const ACE_String_Base<CHAR> &s, const CHAR *t) return temp; } -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR> operator + (const ACE_String_Base<CHAR> &t, const CHAR c) { @@ -461,7 +461,7 @@ ACE_String_Base<CHAR> operator + (const ACE_String_Base<CHAR> &t, return temp; } -template <class CHAR> ACE_INLINE +template <class CHAR> ACE_String_Base<CHAR> operator + (const CHAR c, const ACE_String_Base<CHAR> &t) { @@ -471,7 +471,7 @@ ACE_String_Base<CHAR> operator + (const CHAR c, return temp; } -template <class CHAR> ACE_INLINE ACE_String_Base<CHAR> & +template <class CHAR> ACE_String_Base<CHAR> & ACE_String_Base<CHAR>::operator+= (const CHAR* s) { size_t slen = 0; diff --git a/ace/Task.cpp b/ace/Task.cpp index 6405d323d08..b2bacc0eaf2 100644 --- a/ace/Task.cpp +++ b/ace/Task.cpp @@ -7,11 +7,11 @@ #include "ace/Task.inl" #endif /* __ACE_INLINE__ */ -ACE_RCSID(ace, Task, "$Id$") -ACE_Task_Base::~ACE_Task_Base (void) -{ -} +ACE_RCSID (ace, + Task, + "$Id$") + ACE_Task_Base::ACE_Task_Base (ACE_Thread_Manager *thr_man) : thr_count_ (0), @@ -21,6 +21,55 @@ ACE_Task_Base::ACE_Task_Base (ACE_Thread_Manager *thr_man) { } +ACE_Task_Base::~ACE_Task_Base (void) +{ +} + +// Default ACE_Task service routine + +int +ACE_Task_Base::svc (void) +{ + ACE_TRACE ("ACE_Task_Base::svc"); + return 0; +} + +// Default ACE_Task open routine + +int +ACE_Task_Base::open (void *) +{ + ACE_TRACE ("ACE_Task_Base::open"); + return 0; +} + +// Default ACE_Task close routine + +int +ACE_Task_Base::close (u_long) +{ + ACE_TRACE ("ACE_Task_Base::close"); + return 0; +} + +// Forward the call to close() so that existing applications don't +// break. + +int +ACE_Task_Base::module_closed (void) +{ + return this->close (1); +} + +// Default ACE_Task put routine. + +int +ACE_Task_Base::put (ACE_Message_Block *, ACE_Time_Value *) +{ + ACE_TRACE ("ACE_Task_Base::put"); + return 0; +} + // Wait for all threads running in a task to exit. int @@ -223,12 +272,3 @@ ACE_Task_Base::svc_run (void *args) #endif return status; } - -// Forward the call to close() so that existing applications don't -// break. - -int -ACE_Task_Base::module_closed (void) -{ - return this->close (1); -} diff --git a/ace/Task.inl b/ace/Task.inl index 184b3bd5c26..c903afffbc2 100644 --- a/ace/Task.inl +++ b/ace/Task.inl @@ -1,7 +1,7 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ -// Task.i ACE_INLINE ACE_Thread_Manager * ACE_Task_Base::thr_mgr (void) const @@ -52,42 +52,6 @@ ACE_Task_Base::is_writer (void) const return (ACE_BIT_DISABLED (this->flags_, ACE_Task_Flags::ACE_READER)); } -// Default ACE_Task service routine - -ACE_INLINE int -ACE_Task_Base::svc (void) -{ - ACE_TRACE ("ACE_Task_Base::svc"); - return 0; -} - -// Default ACE_Task open routine - -ACE_INLINE int -ACE_Task_Base::open (void *) -{ - ACE_TRACE ("ACE_Task_Base::open"); - return 0; -} - -// Default ACE_Task close routine - -ACE_INLINE int -ACE_Task_Base::close (u_long) -{ - ACE_TRACE ("ACE_Task_Base::close"); - return 0; -} - -// Default ACE_Task put routine. - -ACE_INLINE int -ACE_Task_Base::put (ACE_Message_Block *, ACE_Time_Value *) -{ - ACE_TRACE ("ACE_Task_Base::put"); - return 0; -} - // Get the current group id. ACE_INLINE int ACE_Task_Base::grp_id (void) const diff --git a/ace/Thread_Manager.cpp b/ace/Thread_Manager.cpp index 390126572ca..5715bde6401 100644 --- a/ace/Thread_Manager.cpp +++ b/ace/Thread_Manager.cpp @@ -12,7 +12,32 @@ #include "ace/Thread_Manager.inl" #endif /* __ACE_INLINE__ */ -ACE_RCSID(ace, Thread_Manager, "$Id$") + +ACE_RCSID (ace, + Thread_Manager, + "$Id$") + + +#if !defined(ACE_USE_ONE_SHOT_AT_THREAD_EXIT) + +ACE_At_Thread_Exit::~ACE_At_Thread_Exit (void) +{ + this->do_apply (); +} + +ACE_At_Thread_Exit_Func::~ACE_At_Thread_Exit_Func (void) +{ + this->do_apply (); +} + +void +ACE_At_Thread_Exit_Func::apply (void) +{ + this->func_ (this->object_, this->param_); +} + +#endif /* ! ACE_USE_ONE_SHOT_AT_THREAD_EXIT */ + ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Control) ACE_ALLOC_HOOK_DEFINE(ACE_Thread_Manager) diff --git a/ace/Thread_Manager.inl b/ace/Thread_Manager.inl index 8c2c7243a5f..86d2357cb35 100644 --- a/ace/Thread_Manager.inl +++ b/ace/Thread_Manager.inl @@ -1,7 +1,7 @@ -/* -*- C++ -*- */ +// -*- C++ -*- +// // $Id$ -// Thread_Manager.i #if !defined(ACE_USE_ONE_SHOT_AT_THREAD_EXIT) ACE_INLINE @@ -50,12 +50,6 @@ ACE_At_Thread_Exit::do_apply (void) } ACE_INLINE -ACE_At_Thread_Exit::~ACE_At_Thread_Exit (void) -{ - this->do_apply (); -} - -ACE_INLINE ACE_At_Thread_Exit_Func::ACE_At_Thread_Exit_Func (void *object, ACE_CLEANUP_FUNC func, void *param) @@ -64,18 +58,6 @@ ACE_At_Thread_Exit_Func::ACE_At_Thread_Exit_Func (void *object, param_(param) { } - -ACE_INLINE -ACE_At_Thread_Exit_Func::~ACE_At_Thread_Exit_Func (void) -{ - this->do_apply (); -} - -ACE_INLINE void -ACE_At_Thread_Exit_Func::apply () -{ - func_ (object_, param_); -} #endif /* ! ACE_USE_ONE_SHOT_AT_THREAD_EXIT */ ACE_INLINE diff --git a/ace/Timer_Queue_Adapters.cpp b/ace/Timer_Queue_Adapters.cpp index 6bd7caf2066..82f78f80284 100644 --- a/ace/Timer_Queue_Adapters.cpp +++ b/ace/Timer_Queue_Adapters.cpp @@ -6,10 +6,8 @@ # pragma once #endif /* ACE_LACKS_PRAGMA_ONCE */ -#ifndef ACE_TIMER_QUEUE_ADAPTERS_C -# define ACE_TIMER_QUEUE_ADAPTERS_C - -ACE_RCSID(ace, Timer_Queue_Adapters, "$Id$") +#ifndef ACE_TIMER_QUEUE_ADAPTERS_CPP +#define ACE_TIMER_QUEUE_ADAPTERS_CPP # if !defined (__ACE_INLINE__) # include "ace/Timer_Queue_Adapters.inl" @@ -319,6 +317,27 @@ ACE_Thread_Timer_Queue_Adapter<TQ>::dispatch_commands (void) return 0; } +template<class TQ> int +ACE_Thread_Timer_Queue_Adapter<TQ>::activate (long flags, + int , + int , + long priority, + int grp_id, + ACE_Task_Base *task, + ACE_hthread_t thread_handles[], + void *stack[], + size_t stack_size[], + ACE_thread_t thread_names[]) +{ + // Macros to avoid "warning: unused parameter" type warning. + ACE_UNUSED_ARG (thread_handles); + + // Make sure that we only allow a single thread to be spawned for + // our adapter. Otherwise, too many weird things can happen. + return ACE_Task_Base::activate (flags, 1, 0, priority, grp_id, task, 0, + stack, stack_size, thread_names); +} + # endif /* ACE_HAS_DEFERRED_TIMER_COMMANDS */ -#endif /* ACE_TIMER_QUEUE_ADAPTERS_C*/ +#endif /* ACE_TIMER_QUEUE_ADAPTERS_CPP */ diff --git a/ace/Timer_Queue_Adapters.inl b/ace/Timer_Queue_Adapters.inl index 4e29cd9f2a9..547c693dd13 100644 --- a/ace/Timer_Queue_Adapters.inl +++ b/ace/Timer_Queue_Adapters.inl @@ -22,24 +22,3 @@ ACE_Thread_Timer_Queue_Adapter<TQ>::thr_id (void) const { return this->thr_id_; } - -template<class TQ> ACE_INLINE int -ACE_Thread_Timer_Queue_Adapter<TQ>::activate (long flags, - int , - int , - long priority, - int grp_id, - ACE_Task_Base *task, - ACE_hthread_t thread_handles[], - void *stack[], - size_t stack_size[], - ACE_thread_t thread_names[]) -{ - // Macros to avoid "warning: unused parameter" type warning. - ACE_UNUSED_ARG (thread_handles); - - // Make sure that we only allow a single thread to be spawned for - // our adapter. Otherwise, too many weird things can happen. - return ACE_Task_Base::activate (flags, 1, 0, priority, grp_id, task, 0, - stack, stack_size, thread_names); -} diff --git a/ace/Timer_Queue_T.inl b/ace/Timer_Queue_T.inl index a4af07d5372..294433e8285 100644 --- a/ace/Timer_Queue_T.inl +++ b/ace/Timer_Queue_T.inl @@ -1,6 +1,7 @@ +// -*- C++ -*- +// // $Id$ -/* -*- C++ -*- */ template <class TYPE> ACE_INLINE void ACE_Timer_Node_T<TYPE>::set (const TYPE &type, diff --git a/ace/ace.mpc b/ace/ace.mpc index 17a5a62378f..6f8563eb4cf 100644 --- a/ace/ace.mpc +++ b/ace/ace.mpc @@ -328,6 +328,7 @@ project(ACE) : acedefaults, core, other, codecs, token, svcconf, uuid, filecache Obstack_T.cpp Pair_T.cpp RB_Tree.cpp + Refcounted_Auto_Ptr.cpp Reverse_Lock_T.cpp Select_Reactor_T.cpp Singleton.cpp |