C++ ACE_Log_Record::priority方法代码示例

//
// log
//
ssize_t CUTS_ACE_Msg_Backend::log (ACE_Log_Record &log_record)
{
  this->logger_.log (log_record.priority (),
                     log_record.msg_data (),
                     log_record.length ());

  // Manually invoke the old message callback
  if (this->old_msg_backend_ != 0)
    this->old_msg_backend_->log (log_record);

  return log_record.length ();
}

ssize_t
ACE_Log_Msg_IPC::log (ACE_Log_Record &log_record)
{
    // Serialize the log record using a CDR stream, allocate enough
    // space for the complete <ACE_Log_Record>.
    size_t const max_payload_size =
        4    // type
        + 4  // pid
        + 12 // timestamp
        + 4  // process id
        + 4  // data length
#if defined (ACE_USES_WCHAR)
        + (log_record.msg_data_len () * ACE_OutputCDR::wchar_maxbytes())  // message
#else
        + log_record.msg_data_len () // message
#endif
        + ACE_CDR::MAX_ALIGNMENT;     // padding;

    // Insert contents of <log_record> into payload stream.
    ACE_OutputCDR payload (max_payload_size);
    payload << log_record;

    // Get the number of bytes used by the CDR stream. If it becomes desireable
    // to support payloads more than 4GB, this field will need to be changed
    // to a 64-bit value.
    ACE_CDR::ULong length =
        ACE_Utils::truncate_cast<ACE_CDR::ULong> (payload.total_length ());

    // Send a header so the receiver can determine the byte order and
    // size of the incoming CDR stream.
    ACE_OutputCDR header (ACE_CDR::MAX_ALIGNMENT + 8);
    header << ACE_OutputCDR::from_boolean (ACE_CDR_BYTE_ORDER);

    // Store the size of the payload that follows
    header << ACE_CDR::ULong (length);

    // Use an iovec to send both buffer and payload simultaneously.
    iovec iov[2];
    iov[0].iov_base = header.begin ()->rd_ptr ();
    iov[0].iov_len  = 8;
    iov[1].iov_base = payload.begin ()->rd_ptr ();
    iov[1].iov_len  = length;

#if defined (ACE_HAS_STREAM_PIPES)
    // Use the <putpmsg> API if supported to ensure correct message
    // queueing according to priority.

    ACE_Str_Buf header_msg (static_cast<void *> (header.begin ()->rd_ptr ()),
                            static_cast<int> (8));

    ACE_Str_Buf payload_msg (static_cast<void *> (payload.begin ()->rd_ptr ()),
                             static_cast<int> (length));

    return this->message_queue_.send (&header_msg,
                                      &payload_msg,
                                      static_cast<int> (log_record.priority ()),
                                      MSG_BAND);
#else
    // We're running over sockets, so send header and payload
    // efficiently using "gather-write".
    return this->message_queue_.sendv_n (iov, 2);
#endif /* ACE_HAS_STREAM_PIPES */
}