ACE_Proactor::ACE_Proactor (ACE_Proactor_Impl *implementation,
int delete_implementation,
TIMER_QUEUE *tq)
: implementation_ (0),
delete_implementation_ (delete_implementation),
timer_handler_ (0),
timer_queue_ (0),
delete_timer_queue_ (0),
end_event_loop_ (0),
event_loop_thread_count_ (0)
{
this->implementation (implementation);
if (this->implementation () == 0)
{
#if defined (ACE_HAS_AIO_CALLS)
// POSIX Proactor.
# if defined (ACE_POSIX_AIOCB_PROACTOR)
ACE_NEW (implementation, ACE_POSIX_AIOCB_Proactor);
# elif defined (ACE_POSIX_SIG_PROACTOR)
ACE_NEW (implementation, ACE_POSIX_SIG_Proactor);
# else /* Default order: CB (but not Lynx), SIG, AIOCB */
# if !defined (__Lynx) && !defined (__FreeBSD__)
ACE_NEW (implementation, ACE_POSIX_CB_Proactor);
# else
# if defined(ACE_HAS_POSIX_REALTIME_SIGNALS)
ACE_NEW (implementation, ACE_POSIX_SIG_Proactor);
# else
ACE_NEW (implementation, ACE_POSIX_AIOCB_Proactor);
# endif /* ACE_HAS_POSIX_REALTIME_SIGNALS */
# endif /* !__Lynx && !__FreeBSD__ */
# endif /* ACE_POSIX_AIOCB_PROACTOR */
#elif (defined (ACE_WIN32) && !defined (ACE_HAS_WINCE))
// WIN_Proactor.
ACE_NEW (implementation,
ACE_WIN32_Proactor);
#endif /* ACE_HAS_AIO_CALLS */
this->implementation (implementation);
this->delete_implementation_ = 1;
}
// Set the timer queue.
this->timer_queue (tq);
// Create the timer handler
ACE_NEW (this->timer_handler_,
ACE_Proactor_Timer_Handler (*this));
// Activate <timer_handler>.
if (this->timer_handler_->activate (THR_NEW_LWP) == -1)
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("%N:%l:(%P | %t):%p\n"),
ACE_LIB_TEXT ("Task::activate:could not create thread\n")));
}
// Add a session to the set of sessions created by this factory. This is a
// private method called by the create_session ().
int
ACE_QoS_Session_Factory::add_session (ACE_QoS_Session *qos_session)
{
if (this->qos_session_set_.insert (qos_session) != 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_LIB_TEXT ("Error in adding a new session")
ACE_LIB_TEXT ("to the session set\n")),
-1);
return 0;
}
ACE_INET_Addr::ACE_INET_Addr (u_short port_number,
ACE_UINT32 inet_address)
: ACE_Addr (this->determine_type(), sizeof (inet_addr_))
{
ACE_TRACE ("ACE_INET_Addr::ACE_INET_Addr");
this->reset ();
if (this->set (port_number, inet_address) == -1)
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("%p\n"),
ACE_LIB_TEXT ("ACE_INET_Addr::ACE_INET_Addr")));
}
ACE_SV_Semaphore_Simple::ACE_SV_Semaphore_Simple (key_t k,
int flags,
int initial_value,
u_short n,
int perms)
: key_ (k)
{
ACE_TRACE ("ACE_SV_Semaphore_Simple::ACE_SV_Semaphore_Simple");
if (this->open (k, flags, initial_value, n, perms) == -1)
ACE_ERROR ((LM_ERROR, ACE_LIB_TEXT ("%p\n"), ACE_LIB_TEXT ("ACE_SV_Semaphore::ACE_SV_Semaphore")));
}
Method_Request_print::Method_Request_print (Scheduler *new_scheduler,
Printer_var &printer)
: scheduler_ (new_scheduler),
printer_ (printer)
{
ACE_DEBUG ((LM_DEBUG,
ACE_LIB_TEXT ("(%t) Method_Request_print created\n")));
ACE_DEBUG ((LM_DEBUG,
ACE_LIB_TEXT ("(%t) Printer reference count: %d\n"),
printer_.count ()));
}
template <class CONCRETE> void
ACE_Based_Pointer_Basic<CONCRETE>::dump (void) const
{
ACE_TRACE ("ACE_Based_Pointer_Basic<CONCRETE>::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ntarget_ = %d\n"), this->target_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("base_offset_ = %d\n"), this->base_offset_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("computed pointer = %x\n"), (CONCRETE *)(ACE_COMPUTE_BASED_POINTER (this))));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
}
int
ACE_Asynch_Pseudo_Task::start (void)
{
if (this->reactor_.initialized () == 0)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_LIB_TEXT ("%N:%l:%p\n"),
ACE_LIB_TEXT ("start reactor is not initialized")),
-1);
return this->activate () == -1 ? -1 : 0; // If started, return 0
}
// Remove a session from the set of sessions created by this factory. This is
// a private method called by the destroy_session ().
int
ACE_QoS_Session_Factory::remove_session (ACE_QoS_Session *qos_session)
{
if (this->qos_session_set_.remove (qos_session) == -1)
ACE_ERROR_RETURN ((LM_ERROR,
ACE_LIB_TEXT ("Error in removing a session")
ACE_LIB_TEXT ("from the session set\n")),
-1);
return 0;
}
template <class ACE_LOCK> void
ACE_Guard<ACE_LOCK>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
// ACE_TRACE ("ACE_Guard<ACE_LOCK>::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("mutex_ = %x\n"), this->lock_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("owner_ = %d\n"), this->owner_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
template <class SVC_HANDLER> void
ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_NonBlocking_Connect_Handler<SVC_HANDLER>::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("svc_handler_ = %x"), this->svc_handler_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ntimer_id_ = %d"), this->timer_id_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
ACE_LSOCK_Dgram::ACE_LSOCK_Dgram (const ACE_Addr &local,
int protocol_family,
int protocol)
{
ACE_TRACE ("ACE_LSOCK_Dgram::ACE_LSOCK_Dgram");
if (this->open (local,
protocol_family,
protocol) == -1)
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("%p\n"),
ACE_LIB_TEXT ("ACE_LSOCK_Dgram")));
}
void
ACE_Pipe::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_Pipe::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("handles_[0] = %d"), this->handles_[0]));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nhandles_[1] = %d"), this->handles_[1]));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n")));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
void
ACE_Obchunk::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_Obchunk::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("end_ = %x\n"), this->end_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("cur_ = %x\n"), this->cur_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
template <class ACE_LOCK> void
ACE_TSS_Guard<ACE_LOCK>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
// ACE_TRACE ("ACE_TSS_Guard<ACE_LOCK>::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("key_ = %d"), this->key_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n")));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
void
ACE_Token_Manager::dump (void) const
{
ACE_TRACE ("ACE_Token_Manager::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("ACE_Token_Manager::dump:\n")));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("lock_\n")));
lock_.dump ();
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("collection_\n")));
collection_.dump ();
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
}
ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor
(const ACE_PEER_ACCEPTOR_ADDR &local_addr,
ACE_Reactor *reactor,
ACE_Concurrency_Strategy<SVC_HANDLER> *cs)
: delete_concurrency_strategy_ (0)
{
ACE_TRACE ("ACE_Oneshot_Acceptor<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Oneshot_Acceptor");
if (this->open (local_addr, reactor, cs) == -1)
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("%p\n"),
ACE_LIB_TEXT ("ACE_Oneshot_Acceptor::ACE_Oneshot_Acceptor")));
}
int
ACE_Proactor_Timer_Handler::svc (void)
{
ACE_Time_Value absolute_time;
ACE_Time_Value relative_time;
int result = 0;
while (this->shutting_down_ == 0)
{
// Check whether the timer queue has any items in it.
if (this->proactor_.timer_queue ()->is_empty () == 0)
{
// Get the earliest absolute time.
absolute_time = this->proactor_.timer_queue ()->earliest_time ();
// Get current time from timer queue since we don't know
// which <gettimeofday> was used.
ACE_Time_Value cur_time = this->proactor_.timer_queue ()->gettimeofday ();
// Compare absolute time with curent time received from the
// timer queue.
if (absolute_time > cur_time)
relative_time = absolute_time - cur_time;
else
relative_time = 0;
// Block for relative time.
result = this->timer_event_.wait (&relative_time, 0);
}
else
// The timer queue has no entries, so wait indefinitely.
result = this->timer_event_.wait ();
// Check for timer expiries.
if (result == -1)
{
switch (errno)
{
case ETIME:
// timeout: expire timers
this->proactor_.timer_queue ()->expire ();
break;
default:
// Error.
ACE_ERROR_RETURN ((LM_ERROR,
ACE_LIB_TEXT ("%N:%l:(%P | %t):%p\n"),
ACE_LIB_TEXT ("ACE_Proactor_Timer_Handler::svc:wait failed")),
-1);
}
}
}
return 0;
}
template <class EXT_ID, class INT_ID, class HASH_KEY, class COMPARE_KEYS, class ACE_LOCK> void
ACE_Hash_Map_Manager_Ex<EXT_ID, INT_ID, HASH_KEY, COMPARE_KEYS, ACE_LOCK>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("total_size_ = %d"), this->total_size_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ncur_size_ = %d"), this->cur_size_));
this->allocator_->dump ();
this->lock_.dump ();
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
void
ACE_PI_Control_Block::ACE_Malloc_Header::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_PI_Control_Block::ACE_Malloc_Header::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nnext_block = %x"), (ACE_Malloc_Header *) this->next_block_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nsize = %d\n"), this->size_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
ACE_File_Lock::ACE_File_Lock (ACE_HANDLE h,
int unlink_in_destructor)
: removed_ (0),
unlink_in_destructor_ (unlink_in_destructor)
{
// ACE_TRACE ("ACE_File_Lock::ACE_File_Lock");
if (ACE_OS::flock_init (&this->lock_) == -1)
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("%p\n"),
ACE_LIB_TEXT ("ACE_File_Lock::ACE_File_Lock")));
this->set_handle (h);
}
ACE_Shared_Memory_Pool::ACE_Shared_Memory_Pool (const ACE_TCHAR *backing_store_name,
const OPTIONS *options)
: base_addr_ (0),
file_perms_ (ACE_DEFAULT_FILE_PERMS),
max_segments_ (ACE_DEFAULT_MAX_SEGMENTS),
minimum_bytes_ (0),
segment_size_ (ACE_DEFAULT_SEGMENT_SIZE)
{
ACE_TRACE ("ACE_Shared_Memory_Pool::ACE_Shared_Memory_Pool");
// Only change the defaults if <options> != 0.
if (options)
{
this->base_addr_ =
reinterpret_cast<void *> (const_cast<char *> (options->base_addr_));
this->max_segments_ = options->max_segments_;
this->file_perms_ = options->file_perms_;
this->minimum_bytes_ = options->minimum_bytes_;
this->segment_size_ = options->segment_size_;
}
if (backing_store_name)
{
// Convert the string into a number that is used as the segment
// key.
int segment_key;
int result = ::sscanf (ACE_TEXT_ALWAYS_CHAR (backing_store_name),
"%d",
&segment_key);
if (result == 0 || result == EOF)
// The conversion to a number failed so hash with crc32
// ACE::crc32 is also used in <SV_Semaphore_Simple>.
this->base_shm_key_ =
(key_t) ACE::crc32 (ACE_TEXT_ALWAYS_CHAR (backing_store_name));
else
this->base_shm_key_ = segment_key;
if (this->base_shm_key_ == IPC_PRIVATE)
// Make sure that the segment can be shared between unrelated
// processes.
this->base_shm_key_ = ACE_DEFAULT_SHM_KEY;
}
else
this->base_shm_key_ = ACE_DEFAULT_SHM_KEY;
if (this->signal_handler_.register_handler (SIGSEGV, this) == -1)
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("%p\n"),
ACE_LIB_TEXT ("ACE_Sig_Handler::register_handler")));
}
template <class TYPE> void
ACE_TSS<TYPE>::dump (void) const
{
// ACE_TRACE ("ACE_TSS<TYPE>::dump");
#if defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION))
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
this->keylock_.dump ();
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("key_ = %d\n"), this->key_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nonce_ = %d"), this->once_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n")));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* defined (ACE_HAS_THREADS) && (defined (ACE_HAS_THREAD_SPECIFIC_STORAGE) || defined (ACE_HAS_TSS_EMULATION)) */
}
template <class MUTEX> void
ACE_Condition<MUTEX>::dump (void) const
{
// ACE_TRACE ("ACE_Condition<MUTEX>::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
#if defined (CHORUS)
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("condname_ = %s\n"), this->condname_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("process_cond_ = %x\n"), this->process_cond_));
#endif /* CHORUS */
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n")));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
}
void
ACE_Mutex::dump (void) const
{
// ACE_TRACE ("ACE_Mutex::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
#if defined (CHORUS) || defined (ACE_HAS_PTHREADS) || defined(ACE_HAS_STHREADS)
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("lockname_ = %s\n"), this->lockname_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("process_lock_ = %x\n"), this->process_lock_));
#endif /* CHORUS || ACE_HAS_PTHREADS || ACE_HAS_STHREADS */
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n")));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
}
template <class CHAR> void
ACE_Obstack_T<CHAR>::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_Obstack_T<CHAR>::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("size_ = %d\n"), this->size_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("head_ = %x\n"), this->head_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("curr_ = %x\n"), this->curr_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
void
ACE_Sub_Barrier::dump (void) const
{
#if defined (ACE_HAS_DUMP)
// ACE_TRACE ("ACE_Sub_Barrier::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
this->barrier_finished_.dump ();
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("running_threads_ = %d"), this->running_threads_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n")));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
void
ACE_Time_Value::dump (void) const
{
#if defined (ACE_HAS_DUMP)
// ACE_OS_TRACE ("ACE_Time_Value::dump");
#if 0
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ntv_sec_ = %d"), this->tv_.tv_sec));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\ntv_usec_ = %d\n"), this->tv_.tv_usec));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* 0 */
#endif /* ACE_HAS_DUMP */
}
void
ACE_Read_Buffer::dump (void) const
{
#if defined (ACE_HAS_DUMP)
ACE_TRACE ("ACE_Read_Buffer::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("size_ = %d"), this->size_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\noccurrences_ = %d"), this->occurrences_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nstream_ = %x"), this->stream_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nallocator_ = %x"), this->allocator_));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
#endif /* ACE_HAS_DUMP */
}
ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy
(const ACE_PEER_ACCEPTOR_ADDR &local_addr,
int reuse_addr,
ACE_Reactor *reactor)
: reactor_ (reactor)
{
ACE_TRACE ("ACE_Accept_Strategy<SVC_HANDLER, ACE_PEER_ACCEPTOR_2>::ACE_Accept_Strategy");
if (this->open (local_addr, reuse_addr) == -1)
ACE_ERROR ((LM_ERROR,
ACE_LIB_TEXT ("%p\n"),
ACE_LIB_TEXT ("open")));
}
void
ACE_Static_Allocator_Base::dump (void) const
{
ACE_TRACE ("ACE_Static_Allocator_Base::dump");
ACE_DEBUG ((LM_DEBUG, ACE_BEGIN_DUMP, this));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\noffset_ = %d"), this->offset_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\nsize_ = %d\n"), this->size_));
ACE_HEX_DUMP ((LM_DEBUG, this->buffer_, this->size_));
ACE_DEBUG ((LM_DEBUG, ACE_LIB_TEXT ("\n")));
ACE_DEBUG ((LM_DEBUG, ACE_END_DUMP));
}
