ircproxy  The Ultimate Cyborg

---

MessageOut.cc

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file MessageOut.cc
//! @brief This file contains the implementation of class MessageOut.
//
// Copyright (C) 2007 by
//
// Carlo Wood, Run on IRC <carlo@alinoe.com>
// RSA-1024 0x624ACAD5 1997-01-26                    Sign & Encrypt
// Fingerprint16 = 32 EC A7 B6 AC DB 65 A6  F6 F6 55 DD 1C DC FF 61
//
// This file may be distributed under the terms of the Q Public License
// version 1.0 as appearing in the file LICENSE.QPL included in the
// packaging of this file.

#ifndef USE_PCH
#include "sys.h"
#include "debug.h"
#include <iostream>
#endif

#include "MessageOut.h"
#include "JustInTime.h"
#include "Target.h"
#include "ClientSession.h"
#include "ServerSession.h"

uint32_t MessageOutData::S_sequence_number;

MessageOut& operator<<(MessageOut& message_out, Prefix const& prefix)
{
  if (!message_out.M_data->M_tokens.empty())
    message_out.M_data.reset(NEW(MessageOutData(message_out.M_data->M_priority, message_out.M_data->M_type)));
  if (!prefix.empty())
  {
    boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimePrefix(prefix)));
    message_out.M_data->M_tokens.push_back(token);
  }
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, int command)
{
  size_t n = message_out.M_data->M_tokens.size();
  if (n > 1 || (n == 1 && !message_out.M_data->M_tokens[0]->is_prefix()))
    message_out.M_data.reset(NEW(MessageOutData(message_out.M_data->M_priority, message_out.M_data->M_type)));
  boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeCommand(command)));
  message_out.M_data->M_tokens.push_back(token);
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, std::string const& str)
{
  boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeString(str)));
  message_out.M_data->M_tokens.push_back(token);
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, char c)
{
  boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeChar(c)));
  message_out.M_data->M_tokens.push_back(token);
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, long val)
{
  boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeLong(val)));
  message_out.M_data->M_tokens.push_back(token);
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, boost::shared_ptr<Target> const& target)
{
  boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeTarget(target)));
  message_out.M_data->M_tokens.push_back(token);
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, MsgPart const& part)
{
  if (part.start())
  {
    boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeMsgPart(part)));
    message_out.M_data->M_tokens.push_back(token);
  }
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, JustInTimeCatenate const& to_be_catenated_token)
{
  boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeCatenate(to_be_catenated_token)));
  message_out.M_data->M_tokens.push_back(token);
  return message_out;
}

MessageOut& operator<<(MessageOut& message_out, JustInTimeLast const& to_be_appended_token)
{
  boost::shared_ptr<JustInTimeToken> token(NEW(JustInTimeLast(to_be_appended_token)));
  message_out.M_data->M_tokens.push_back(token);
  return message_out;
}

template<class SESSION>
void MessageOut::write_to(std::ostream& os, SESSION const& session) const
{
  DoutEntering(dc::debug, "MessageOut<" << type_info_of<SESSION>().demangled_name() << ">::write_to(" << os << ", " << session << ") for " << *this);
  if (M_data->is_pseudo_message())
    boost::static_pointer_cast<PseudoMessageOutData>(M_data)->M_pseudo_message_event_server.trigger(PseudoMessageEventType());
  else
  {
#ifndef CWDEBUG
    std::ostream& tmp(os);
#else
    ASSERT(!os.fail());
    std::stringstream tmp;
#endif
    for (std::vector<boost::shared_ptr<JustInTimeToken> >::iterator iter = M_data->M_tokens.begin(); iter != M_data->M_tokens.end(); ++iter)
      (*iter)->write_to(tmp, session);
    tmp << "\r\n";
#ifdef CWDEBUG
    std::string result(tmp.str());
    os << result;
    Dout(dc::debug, "Wrote string \"" << buf2str(result.data(), result.size()) << "\".");
#endif
  }
}

void MessageOut::write_to(ClientSession& session) const
{
  write_to(session, session);
}

void MessageOut::write_to(ServerSession& session) const
{
  write_to(session, session);
}

---