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 #if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
  40 template<ACE_SYNCH_DECL>
  41 ACE_SYNCH_MUTEX_T Log_Message_Receiver_Impl<ACE_SYNCH_USE>::copy_lock_;
  42 #else
  43 static ACE_SYNCH_MUTEX global_copy_lock_;
  44 #endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
  45
  46 template<ACE_SYNCH_DECL>
  47 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::Log_Message_Receiver_Impl (void)
  48   : count_ (0)
  49 {
  50 }
  51
  52 template<ACE_SYNCH_DECL>
  53 Log_Message_Receiver_Impl<ACE_SYNCH_USE> *
  54 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::create (void)
  55 {
  56   return new Log_Message_Receiver_Impl<ACE_SYNCH_USE>;
  57 }
  58
  59 template<ACE_SYNCH_DECL>
  60 Log_Message_Receiver_Impl<ACE_SYNCH_USE> *
  61 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::attach (Log_Message_Receiver_Impl<ACE_SYNCH_USE> *body)
  62 {
  63   ACE_ASSERT (body != 0);
  64
  65 #if defined (ACE_HAS_THREADS)
  66 #  if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
  67   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX_T, guard, copy_lock_, 0);
  68 #  else
  69   // Use the "body"s print lock as copy lock.
  70   ACE_GUARD_RETURN (ACE_SYNCH_MUTEX, guard, global_copy_lock_, 0);
  71 #  endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
  72 #endif /* ACE_HAS_THREADS */
  73   ++body->count_;
  74   return body;
  75 }
  76
  77 template<ACE_SYNCH_DECL> void
  78 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::detach (Log_Message_Receiver_Impl<ACE_SYNCH_USE> *body)
  79 {
  80   ACE_ASSERT (body != 0);
  81
  82 #if defined (ACE_HAS_THREADS)
  83 #  if !defined (ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES)
  84   ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, copy_lock_);
  85 #  else
  86   // Use the "body"s print lock as copy lock.
  87   ACE_GUARD (ACE_SYNCH_MUTEX, guard, global_copy_lock_);
  88 #  endif /* ACE_LACKS_STATIC_DATA_MEMBER_TEMPLATES */
  89 #endif /* ACE_HAS_THREADS */
  90   if (body->count_-- == 0)
  91     delete body;
  92 }
  93
  94 // Type based log message receiver
  95 template<ACE_SYNCH_DECL> void
  96 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::log_record (const ACE_TCHAR *hostname,
  97                                                       ACE_Log_Record &record)
  98 {
  99   ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, print_lock_);
 100   record.print (hostname,
 101                 ACE_Log_Msg::instance ()->flags (),
 102                 stderr);
 103 }
 104
 105 template<ACE_SYNCH_DECL> void
 106 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::log_output (const ACE_TCHAR *hostname,
 107                                                       ACE_Log_Record &record,
 108                                                       ostream *outputfile)
 109 {
 110   if (outputfile != 0)
 111     {
 112       ACE_GUARD (ACE_SYNCH_MUTEX_T, guard, print_lock_);
 113       record.print (hostname,
 114                     ACE_Log_Msg::instance ()->flags (),
 115                     *outputfile);
 116     }
 117 }
 118
 119 template<ACE_SYNCH_DECL>
 120 Log_Message_Receiver_Impl<ACE_SYNCH_USE>::~Log_Message_Receiver_Impl (void)
 121 {
 122   ACE_ASSERT (count_ == 0 - 1);
 123 }
 124
 125 template<ACE_SYNCH_DECL>
 126 Log_Message_Receiver<ACE_SYNCH_USE>::Log_Message_Receiver (void)
 127   : receiver_impl_ (Log_Message_Receiver_Impl<ACE_SYNCH_USE>::create ())
 128 {
 129   ACE_ASSERT (receiver_impl_ != 0);
 130 }
 131
 132 template<ACE_SYNCH_DECL>
 133 Log_Message_Receiver<ACE_SYNCH_USE>::Log_Message_Receiver
 134   (Log_Message_Receiver<ACE_SYNCH_USE> const &rhs)
 135     : receiver_impl_ (Log_Message_Receiver_Impl<ACE_SYNCH_USE>::attach (rhs.receiver_impl_))
 136 {
 137   ACE_ASSERT (receiver_impl_ != 0);
 138 }
 139
 140 // Type based log message receiver
 141 template<ACE_SYNCH_DECL> void
 142 Log_Message_Receiver<ACE_SYNCH_USE>::log_record(const ACE_TCHAR *hostname,
 143                                                 ACE_Log_Record &record)
 144 {
 145   ACE_ASSERT (receiver_impl_ != 0);
 146   receiver_impl_->log_record (hostname, record);
 147 }
 148
 149 template<ACE_SYNCH_DECL> void
 150 Log_Message_Receiver<ACE_SYNCH_USE>::log_output(const ACE_TCHAR *hostname,
 151                                                 ACE_Log_Record &record,
 152                                                 ostream *outputfile)
 153 {
 154   ACE_ASSERT (receiver_impl_ != 0);
 155   receiver_impl_->log_output (hostname, record, outputfile);
 156 }
 157
 158 template<ACE_SYNCH_DECL>
 159 Log_Message_Receiver<ACE_SYNCH_USE>::~Log_Message_Receiver (void)
 160 {
 161   ACE_ASSERT (receiver_impl_ != 0);
 162   Log_Message_Receiver_Impl<ACE_SYNCH_USE>::detach (receiver_impl_);
 163 }
 164
 165 #endif /* LOG_MESSAGE_RECEIVER_CPP */