ACE/netsvcs/lib/Log_Message_Receiver.cpp

   1 #if !defined (LOG_MESSAGE_RECEIVER_CPP)
   2 #define LOG_MESSAGE_RECEIVER_CPP
   3
   4 #include "ace/Log_Msg.h"
   5 #include "Log_Message_Receiver.h"
   6
   7 // Type based log message receiver
   8 template<ACE_SYNCH_DECL> void
   9 Static_Log_Message_Receiver<ACE_SYNCH_USE>::log_record (const ACE_TCHAR *hostname,
  10                                                         ACE_Log_Record &record)
  11 {
  12 #if defined (ACE_HAS_THREADS)
  13   static ACE_SYNCH_MUTEX_T lock_;
  14   ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, lock_);
  15 #endif /* ACE_HAS_THREADS */
  16
  17   record.print (hostname,
  18                 ACE_Log_Msg::instance ()->flags (),
  19                 stderr);
  20 }
  21
  22 template<ACE_SYNCH_DECL> void
  23 Static_Log_Message_Receiver<ACE_SYNCH_USE>::log_output (const ACE_TCHAR *hostname,
  24                                                         ACE_Log_Record &record,
  25                                                         ostream *outputfile)
  26 {
  27   if (outputfile != 0)
  28     {
  29 #if defined (ACE_HAS_THREADS)
  30       static ACE_SYNCH_MUTEX_T lock_;
  31       ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, lock_);
  32 #endif /* ACE_HAS_THREADS */
  33       record.print (hostname,
  34                     ACE_Log_Msg::instance ()->flags (),
  35                     *outputfile);
  36     }
  37 }
  38
  39 template<ACE_SYNCH_DECL>
  40 ACE_SYNCH_MUTEX_T Log_Message_Receiver_Impl<ACE_SYNCH_USE>::copy_lock_;
  41
  42 template<ACE_SYNCH_DECL>
  43 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::Log_Message_Receiver_Impl ()
  44   : count_ (0)
  45 {
  46 }
  47
  48 template<ACE_SYNCH_DECL>
  49 Log_Message_Receiver_Impl<ACE_SYNCH_USE> *
  50 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::create ()
  51 {
  52   return new Log_Message_Receiver_Impl<ACE_SYNCH_USE>;
  53 }
  54
  55 template<ACE_SYNCH_DECL>
  56 Log_Message_Receiver_Impl<ACE_SYNCH_USE> *
  57 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::attach (Log_Message_Receiver_Impl<ACE_SYNCH_USE> *body)
  58 {
  59   ACE_ASSERT (body != 0);
  60
  61 #if defined (ACE_HAS_THREADS)
  62   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, guard, copy_lock_, 0);
  63 #endif /* ACE_HAS_THREADS */
  64   ++body->count_;
  65   return body;
  66 }
  67
  68 template<ACE_SYNCH_DECL> void
  69 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::detach (Log_Message_Receiver_Impl<ACE_SYNCH_USE> *body)
  70 {
  71   ACE_ASSERT (body != 0);
  72
  73 #if defined (ACE_HAS_THREADS)
  74   ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, copy_lock_);
  75 #endif /* ACE_HAS_THREADS */
  76   if (body->count_-- == 0)
  77     delete body;
  78 }
  79
  80 // Type based log message receiver
  81 template<ACE_SYNCH_DECL> void
  82 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::log_record (const ACE_TCHAR *hostname,
  83                                                       ACE_Log_Record &record)
  84 {
  85   ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, print_lock_);
  86   record.print (hostname,
  87                 ACE_Log_Msg::instance ()->flags (),
  88                 stderr);
  89 }
  90
  91 template<ACE_SYNCH_DECL> void
  92 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::log_output (const ACE_TCHAR *hostname,
  93                                                       ACE_Log_Record &record,
  94                                                       ostream *outputfile)
  95 {
  96   if (outputfile != 0)
  97     {
  98       ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, print_lock_);
  99       record.print (hostname,
 100                     ACE_Log_Msg::instance ()->flags (),
 101                     *outputfile);
 102     }
 103 }
 104
 105 template<ACE_SYNCH_DECL>
 106 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::~Log_Message_Receiver_Impl ()
 107 {
 108   ACE_ASSERT (count_ == 0 - 1);
 109 }
 110
 111 template<ACE_SYNCH_DECL>
 112 Log_Message_Receiver<ACE_SYNCH_USE>::Log_Message_Receiver ()
 113   : receiver_impl_ (Log_Message_Receiver_Impl<ACE_SYNCH_USE>::create ())
 114 {
 115   ACE_ASSERT (receiver_impl_ != 0);
 116 }
 117
 118 template<ACE_SYNCH_DECL>
 119 Log_Message_Receiver<ACE_SYNCH_USE>::Log_Message_Receiver
 120   (Log_Message_Receiver<ACE_SYNCH_USE> const &rhs)
 121     : receiver_impl_ (Log_Message_Receiver_Impl<ACE_SYNCH_USE>::attach (rhs.receiver_impl_))
 122 {
 123   ACE_ASSERT (receiver_impl_ != 0);
 124 }
 125
 126 // Type based log message receiver
 127 template<ACE_SYNCH_DECL> void
 128 Log_Message_Receiver<ACE_SYNCH_USE>::log_record(const ACE_TCHAR *hostname,
 129                                                 ACE_Log_Record &record)
 130 {
 131   ACE_ASSERT (receiver_impl_ != 0);
 132   receiver_impl_->log_record (hostname, record);
 133 }
 134
 135 template<ACE_SYNCH_DECL> void
 136 Log_Message_Receiver<ACE_SYNCH_USE>::log_output(const ACE_TCHAR *hostname,
 137                                                 ACE_Log_Record &record,
 138                                                 ostream *outputfile)
 139 {
 140   ACE_ASSERT (receiver_impl_ != 0);
 141   receiver_impl_->log_output (hostname, record, outputfile);
 142 }
 143
 144 template<ACE_SYNCH_DECL>
 145 Log_Message_Receiver<ACE_SYNCH_USE>::~Log_Message_Receiver ()
 146 {
 147   ACE_ASSERT (receiver_impl_ != 0);
 148   Log_Message_Receiver_Impl<ACE_SYNCH_USE>::detach (receiver_impl_);
 149 }
 150
 151 #endif /* LOG_MESSAGE_RECEIVER_CPP */