自学教程：C++ ACE_LIB_TEXT函数代码示例

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 ().intACE_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> voidACE_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));}

intACE_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}

template <class ACE_LOCK> voidACE_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> voidACE_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")));}

voidACE_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 */}

voidACE_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> voidACE_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 */}

voidACE_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")));}

intACE_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> voidACE_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 */}

voidACE_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> voidACE_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> voidACE_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));}

voidACE_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> voidACE_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 */}

voidACE_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 */}

voidACE_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 */}

voidACE_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")));}

voidACE_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));}