ircproxy  The Ultimate Cyborg

---

JustInTime.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file JustInTime.h
//! @brief This file contains the declaration of class JustInTimeToken and derived classes.
//
// 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 JUSTINTIME_H
#define JUSTINTIME_H

#ifndef USE_PCH
#include <string>
#include "debug.h"
#endif

#include "command_to_str.h"

//! A base class for parameters of output messages.
class JustInTimeToken {
public:
  //! Virtual destructor.
  virtual ~JustInTimeToken() { }    
  virtual std::string value(ClientSession const&) const = 0;
  virtual std::string value(ServerSession const&) const = 0;
  virtual void write_to(std::ostream& os, ClientSession const&) const = 0;
  virtual void write_to(std::ostream& os, ServerSession const&) const = 0;
  virtual bool is_prefix(void) { return false; }
};

//! A just-in-time string.
class JustInTimeString : public JustInTimeToken {
private:
  std::string M_token;          //!< The token string.
public:
  //! Construct a JustInTimeString with value \a token.
  JustInTimeString(std::string const& token) : M_token(token) { }
  //! Return the underlying value.
  virtual std::string value(ClientSession const&) const { return M_token; }
  virtual std::string value(ServerSession const&) const { return M_token; }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const&) const { os << ' ' << M_token; }
  virtual void write_to(std::ostream& os, ServerSession const&) const { os << ' ' << M_token; }
};

//! A just-in-time char.
class JustInTimeChar : public JustInTimeToken {
private:
  char M_token;         //!< The token char.
public:
  //! Construct a JustInTimeChar with value \a token.
  JustInTimeChar(char token) : M_token(token) { }
  //! Return the underlying value.
  virtual std::string value(ClientSession const&) const { std::string result; result = M_token; return result; }
  virtual std::string value(ServerSession const&) const { std::string result; result = M_token; return result; }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const&) const { os << ' ' << M_token; }
  virtual void write_to(std::ostream& os, ServerSession const&) const { os << ' ' << M_token; }
};

//! A just-in-time long.
class JustInTimeLong : public JustInTimeToken {
private:
  long M_token;         //!< The token.
public:
  //! Construct a JustInTimeLong with value \a token.
  JustInTimeLong(long token) : M_token(token) { }
  //! Return the underlying value.
  virtual std::string value(ClientSession const&) const { std::ostringstream result; result << M_token; return result.str(); }
  virtual std::string value(ServerSession const&) const { std::ostringstream result; result << M_token; return result.str(); }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const&) const { os << ' ' << M_token; }
  virtual void write_to(std::ostream& os, ServerSession const&) const { os << ' ' << M_token; }
};

//! A just-in-time target.
class JustInTimeTarget : public JustInTimeToken {
private:
  boost::shared_ptr<Target> M_target;   //!< Underlaying token.
private:
  //! Return the underlying value.
  std::string value_impl(ClientSession const& session) const { return M_target->out_name(session); }
  std::string value_impl(ServerSession const& session) const { return M_target->out_name(session); }
public:
  //! Constructor.
  JustInTimeTarget(boost::shared_ptr<Target> const& target) : M_target(target) { }
  //! Return the underlying value.
  virtual std::string value(ClientSession const& session) const { return value_impl(session); }
  virtual std::string value(ServerSession const& session) const { return value_impl(session); }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const& session) const { os << ' ' << value_impl(session); }
  virtual void write_to(std::ostream& os, ServerSession const& session) const { os << ' ' << value_impl(session); }
};

//! A just-in-time command.
class JustInTimeCommand : public JustInTimeToken {
private:
  int M_token;                  //!< The command or numeric.
public:
  //! Construct a JustInTimeCommand with value \a token.
  JustInTimeCommand(int token) : M_token(token) { }
  //! Return the underlying value.
  virtual std::string value(ClientSession const&) const { return command_to_str(M_token); }
  virtual std::string value(ServerSession const&) const { return command_to_str(M_token); }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const&) const { os << command_to_str(M_token); }
  virtual void write_to(std::ostream& os, ServerSession const&) const { os << command_to_str(M_token); }
  //! Return the command.
  virtual int command(void) const { return M_token; }
};

//! A just-in-time Prefix.
class JustInTimePrefix : public JustInTimeToken {
private:
  Prefix M_token;               //!< The prefix.
private:
  //! Return the underlying value.
  virtual std::string value_impl(ClientSession const& session) const { return  M_token.out_prefix(session, true); }
  virtual std::string value_impl(ServerSession const& session) const { return  M_token.out_prefix(session, true); }
public:
  //! Construct a JustInTimePrefix with value \a token.
  JustInTimePrefix(Prefix const& token) : M_token(token) { }
  //! Return the underlying value.
  virtual std::string value(ClientSession const& session) const { return value_impl(session); }
  virtual std::string value(ServerSession const& session) const { return value_impl(session); }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const& session) const { os << ':' << value_impl(session) << ' '; }
  virtual void write_to(std::ostream& os, ServerSession const& session) const { os << ':' << value_impl(session) << ' '; }
  //! Return true if this is a Prefix.
  virtual bool is_prefix(void) { return true; }
};

//! A just-in-time MsgPart.
class JustInTimeMsgPart : public JustInTimeToken {
private:
  MsgPart M_token;              //!< The MsgPart.
public:
  //! Construct a JustInTimeMsgPart with value \a token.
  JustInTimeMsgPart(MsgPart const& token) : M_token(token) { }
  //! Return the underlying value.
  virtual std::string value(ClientSession const&) const { return std::string(M_token.start(), M_token.len()); }
  virtual std::string value(ServerSession const&) const { return std::string(M_token.start(), M_token.len()); }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const&) const { os << ' '; os.write(M_token.start(), M_token.len()); }
  virtual void write_to(std::ostream& os, ServerSession const&) const { os << ' '; os.write(M_token.start(), M_token.len()); }
};

//! A just-in-time manipulator. This causes the passed token to be catenated to the previous token, without separator.
//
// For example: <code>msgout << *word_start << JustInTimeCatenate(nick);</code> would write the nick directly
// against the output of <code>*word_start</code>.
class JustInTimeCatenate : public JustInTimeToken {
private:
  boost::shared_ptr<JustInTimeToken> M_token;   //!< The token to be catenated.
public:
  //! Construct a JustInTimeCatenate with value \a token.
  JustInTimeCatenate(char token) : M_token(NEW(JustInTimeChar(token))) { }
  //! Construct a JustInTimeCatenate with value \a token.
  JustInTimeCatenate(std::string const& token) : M_token(NEW(JustInTimeString(token))) { }
  //! Construct a JustInTimeCatenate with value \a token.
  JustInTimeCatenate(boost::shared_ptr<Target> const& token) : M_token(NEW(JustInTimeTarget(token))) { }
  //! Construct a JustInTimeCatenate with value \a token.
  JustInTimeCatenate(MsgPart const& token) : M_token(NEW(JustInTimeMsgPart(token))) { }

  //! Return the underlying value.
  virtual std::string value(ClientSession const& session) const { return M_token->value(session); }
  virtual std::string value(ServerSession const& session) const { return M_token->value(session); }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const& session) const { os << M_token->value(session); }
  virtual void write_to(std::ostream& os, ServerSession const& session) const { os << M_token->value(session); }
};

//! A just-in-time manipulator. This causes the passed token to be prepended with a colon, assuming it's the last parameter.
//
// For example: <code>msgout << nick << JustInTimeLast("hello world");</code> would write the nick
// followed by the characters <code>" :hello world"</code>.
class JustInTimeLast : public JustInTimeToken {
private:
  boost::shared_ptr<JustInTimeToken> M_token;   //!< The token to be appended last.
public:
  //! Construct a JustInTimeLast with value \a token.
  JustInTimeLast(std::string const& token) : M_token(NEW(JustInTimeString(token))) { }
  //! Construct a JustInTimeLast with value \a token.
  JustInTimeLast(MsgPart const& token) : M_token(NEW(JustInTimeMsgPart(token))) { }

  //! Return the underlying value.
  virtual std::string value(ClientSession const& session) const { return M_token->value(session); }
  virtual std::string value(ServerSession const& session) const { return M_token->value(session); }
  //! Write the underlying token, including seperators, to an ostream.
  virtual void write_to(std::ostream& os, ClientSession const& session) const { os << " :" << M_token->value(session); }
  virtual void write_to(std::ostream& os, ServerSession const& session) const { os << " :" << M_token->value(session); }
};

#endif // JUSTINTIME

---