ircproxy  The Ultimate Cyborg

---

Expression.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Expression.h
//! @brief This file contains the declaration of Expression related code.
//
// Copyright (C) 2006, 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.

#include "Watched.h"

#ifndef EXPRESSION_H
#define EXPRESSION_H

#ifndef USE_PCH
#include <boost/shared_ptr.hpp>
#include "debug.h"
#include <libcw/events.h>
#endif

#include "ExpressionInterface.h"
#include "Bool.h"
#include "Counter.h"

//! The EventType for Expression's.
class ExpressionEventType {
  private:
    bool M_expression_value;
#ifdef CWDEBUG
    boost::shared_ptr<ExpressionInterface> M_expression;
#endif
  public:
#ifdef CWDEBUG
    ExpressionEventType(bool value, boost::shared_ptr<ExpressionInterface> const& expression) :
        M_expression_value(value), M_expression(expression) { }
#else
    ExpressionEventType(bool value) : M_expression_value(value) { }
#endif
    operator bool(void) const { return M_expression_value; }
#ifdef CWDEBUG
    friend std::ostream& operator<<(std::ostream& os, ExpressionEventType const& event_type);
#endif
};

#if 1 // No need to print constructing/destruction of ExpressionEventRequestBase (anymore).
//! The EventRequestBase for Expression's.
typedef event_request_base_tct<ExpressionEventType> ExpressionEventRequestBase;
#else
class ExpressionEventRequestBase : public event_request_base_tct<ExpressionEventType> {
public:
  ExpressionEventRequestBase(event_client_tracker_ct* event_client_tracker) :
      event_request_base_tct<ExpressionEventType>(event_client_tracker)
      { Dout(dc::objects, "Constructing ExpressionEventRequestBase()"); }
  ~ExpressionEventRequestBase() { Dout(dc::objects, "Destructing ExpressionEventRequestBase"); }
  ExpressionEventRequestBase(ExpressionEventRequestBase const& request) :
      event_request_base_tct<ExpressionEventType>(request)
      { Dout(dc::objects, "Copy-constructing ExpressionEventRequestBase"); }
};
#endif

//! The EventRequestQueue for Expression's.
class ExpressionEventRequestQueue {
  typedef std::deque<ExpressionEventRequestBase*> event_requests_ct;
private:
  Counter M_event_requests_locked;              //!< Non-zero if M_event_requests is being processed in a loop.
  event_requests_ct M_event_requests;
  bool M_being_destroyed;
protected:
  ExpressionEventRequestQueue(void) : M_being_destroyed(false) { }
  void add_request(ExpressionEventRequestBase* request)
      { ASSERT(!M_event_requests_locked); ASSERT(M_event_requests.empty()); M_event_requests.push_back(request); }
  virtual ~ExpressionEventRequestQueue()
      {
        M_being_destroyed = true;
        destroy_requests();
      }
  void destroy_requests(void)
      {
        // M_event_requests_locked is ONLY incremented in trigger(),
        // which destroys the request directly after handling it anyway.
        if (M_event_requests_locked)
          return;
        if (!M_event_requests.empty())
        {
          M_event_requests.front()->release();
          M_event_requests.pop_front();
        }
        // It is impossible that there are Bool's left that point to this ExpressionEventRequestQueue,
        // because this event server (derived from this object) is kept alive through shared pointers.
        // When it is destructed, that means that the last shared pointer was destructed, which means
        // that the last Bool was destructed.
        if (!M_being_destroyed)
          all_requests_destroyed();
      }
public:
  void trigger(ExpressionEventRequestBase::event_type_ct const& request_data)
      {
        DoutEntering(dc::expression, "ExpressionEventRequestQueue::trigger(" <<
            libcwd::type_info_of<ExpressionEventRequestBase::event_type_ct>().demangled_name() <<
            " const& " << request_data << ")");
        {
          Increment tmp(M_event_requests_locked);
          event_requests_ct::iterator iter = M_event_requests.begin();
          // I don't think it's possible to get here without an existing request object,
          // but lets test anyway. We don't print that handle() is called however, as it
          // should always be.
          if (iter != M_event_requests.end())
          {
            (*iter)->handle(request_data);
            (*iter)->release();
            M_event_requests.erase(iter);
          }
        }
        ASSERT(M_event_requests.empty());
        all_requests_destroyed();
      }
  virtual void all_requests_destroyed() = 0;
};

//! The EventServer for Expression's.
class ExpressionEventServer : public event_server_tct<ExpressionEventRequestBase, ExpressionEventRequestQueue> {
  private:
    boost::shared_ptr<ExpressionInterface> M_expression;
    bool M_ok;
    bool M_evaluation;

  public:
    ExpressionEventServer(boost::shared_ptr<ExpressionInterface> const& expression);
#ifdef CWDEBUG
    ~ExpressionEventServer() { Dout(dc::objects, "Destructing ExpressionEventServer " << *this); }
#endif

    void bool_changed(void);
    void bool_destructed(void) { if (M_ok) { M_ok = false; destroy_requests(); } }
    virtual void all_requests_destroyed(void);
#ifdef CWDEBUG
    friend std::ostream& operator<<(std::ostream& os, ExpressionEventServer const& expression_event_server);
#endif
};

//! An expression consisting of a constant.
template<typename T>
class ConstExpression : public ExpressionInterface {
  public:
    enum none { };
    typedef none inverted_type;
  private:
    T const M_const;
  public:
    template<typename T2>
    ConstExpression(T2 const& c) : M_const(c) { }

    T const& evaluate_impl(void) const { return M_const; }
    void sub_event_server_impl(ExpressionEventServer*) { }

    virtual bool evaluate(void) { DoutFatal(dc::core, "Calling ConstExpression::evaluate"); return false; }
    virtual void sub_event_server(ExpressionEventServer* event_server) { sub_event_server_impl(event_server); }
    virtual void add_event_server(boost::shared_ptr<ExpressionEventServer> const&) { }
#ifdef CWDEBUG
    virtual void print_on(std::ostream& os) const;
#endif
};

#ifdef CWDEBUG
template<typename T>
void ConstExpression<T>::print_on(std::ostream& os) const
{
  os << "ConstExpression<" << libcwd::type_info_of<T>().demangled_name() << ">(" << M_const << ")";
}
#endif

//! @brief Possible binary expression operator types.
//
// beop_type stands for BinaryExpression OPerator TYPE.
enum beop_type {
 beop_AND,
 beop_OR,
 beop_NEQ,
 beop_EQ,
 beop_BITWISE_AND,
 beop_BITWISE_OR,
 beop_BITWISE_XOR
};

template<bool inverted, typename T1, beop_type OP, typename T2>
struct binary_operator;

//! @brief An binary boolean expression.
//
// This expression represents a binary expression of the form \a EXPR1 \a OP \a EXPR2.
//
// The expression is optionally inverted when \a inverted is \c true.
template<bool inverted, class EXPR1, beop_type OP, class EXPR2>
class BinaryExpression : public ExpressionInterface {
  public:
    //! The type of this expression inverted.
    typedef BinaryExpression<!inverted, EXPR1, OP, EXPR2> inverted_type;

  protected:
    EXPR1 M_e1;         //!< First expression.
    EXPR2 M_e2;         //!< Second expression.

  public:
    //! Constructor.
    BinaryExpression(EXPR1 e1, EXPR2 e2) : M_e1(e1), M_e2(e2) { }

    //! Return inverted expression.
    BinaryExpression<!inverted, EXPR1, OP, EXPR2> operator!(void) const;

    //! Create and return an event server that is watching this expression.
    ExpressionEventServer& create_event_server(void)
    {
      boost::shared_ptr<ExpressionInterface> expression(new BinaryExpression(*this));
      boost::shared_ptr<ExpressionEventServer> event_server(new ExpressionEventServer(expression));
      expression->add_event_server(event_server);
      return *event_server;
    }

    //! Actual implementation of sub_event_server().
    void sub_event_server_impl(ExpressionEventServer* event_server) { M_e1.sub_event_server_impl(event_server); M_e2.sub_event_server_impl(event_server); }

    //! Implementation of pure virtual funtion ExpressionInterface::add_event_server.
    virtual void add_event_server(boost::shared_ptr<ExpressionEventServer> const& event_server)
        { M_e1.add_event_server(event_server); M_e2.add_event_server(event_server); }

    virtual bool evaluate(void);
    //! Implementation of pure virtual funtion ExpressionInterface::sub_event_server.
    virtual void sub_event_server(ExpressionEventServer* event_server) { sub_event_server_impl(event_server); }

#ifdef CWDEBUG
    virtual void print_on(std::ostream& os) const;
#endif
};

//! @internal
//
// evaluate_impl cannot be a member of BinaryExpression because it's return
// type depends on binary_operator, which in turn depends on BinaryExpression.
// Trying to make evaluate_impl a member of BinaryExpression creates a dependency
// loop that results in the compile error: trying to use undefined class BinaryExpression.
template<bool inverted, class EXPR1, beop_type OP, class EXPR2>
struct BinaryExpressionDerived : public BinaryExpression<inverted, EXPR1, OP, EXPR2> {
  typename binary_operator<inverted, EXPR1, OP, EXPR2>::return_type evaluate_impl(void) const;
};

template<typename T>
inline bool only_pass_if_bool(T const&) { return false; }

inline bool only_pass_if_bool(bool value) { return value; }

template<bool inverted, class EXPR1, beop_type OP, class EXPR2>
bool BinaryExpression<inverted, EXPR1, OP, EXPR2>::evaluate(void)
{
  typename binary_operator<inverted, EXPR1, OP, EXPR2>::return_type result =
    static_cast<BinaryExpressionDerived<inverted, EXPR1, OP, EXPR2>*>(this)->evaluate_impl();
  return only_pass_if_bool(result);
}

template<bool inverted, class EXPR1, beop_type OP, class EXPR2>
BinaryExpression<!inverted, EXPR1, OP, EXPR2>
BinaryExpression<inverted, EXPR1, OP, EXPR2>::operator!(void) const
    { return BinaryExpression<!inverted, EXPR1, OP, EXPR2>(M_e1, M_e2); }

#ifdef CWDEBUG
template<bool inverted, class EXPR1, beop_type OP, class EXPR2>
void BinaryExpression<inverted, EXPR1, OP, EXPR2>::print_on(std::ostream& os) const
{
  if (inverted)
    os << '!';
  os << '(';
  M_e1.print_on(os);
  switch (OP)
  {
    case beop_AND:
      os << " && ";
      break;
    case beop_OR:
      os << " || ";
      break;
    case beop_NEQ:
      os << " != ";
      break;
    case beop_EQ:
      os << " == ";
      break;
    case beop_BITWISE_AND:
      os << " & ";
      break;
    case beop_BITWISE_OR:
      os << " | ";
      break;
    case beop_BITWISE_XOR:
      os << " ^ ";
      break;
  }
  M_e2.print_on(os);
  os << ')';
}
#endif

// Operator definitions.

// Bool && Bool
template<bool inverted1, bool inverted2>
inline BinaryExpression<inverted1 && inverted2,
      BoolExpression<inverted1 && !inverted2>,
      (inverted1 && inverted2) ? beop_OR : beop_AND,
      BoolExpression<inverted2 && !inverted1>
    >
operator&&(BoolExpression<inverted1> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BoolExpression<inverted1 && !inverted2>,
        (inverted1 && inverted2) ? beop_OR : beop_AND,
        BoolExpression<inverted2 && !inverted1>
      >(e1, e2);
}

// Expr && Bool
template<bool inverted1, class EXPR1, beop_type OP, class EXPR2, bool inverted2>
inline BinaryExpression<inverted1 && inverted2,
      BinaryExpression<inverted1 && !inverted2, EXPR1, OP, EXPR2>,
      (inverted1 && inverted2) ? beop_OR : beop_AND,
      BoolExpression<inverted2 && !inverted1>
    >
operator&&(BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BinaryExpression<inverted1 && !inverted2, EXPR1, OP, EXPR2>,
        (inverted1 && inverted2) ? beop_OR : beop_AND,
        BoolExpression<inverted2 && !inverted1>
      >(e1, e2);
}

// Bool && Expr
template<bool inverted1, bool inverted2, class EXPR1, beop_type OP, class EXPR2>
inline BinaryExpression<inverted1 && inverted2,
      BoolExpression<inverted1 && !inverted2>,
      (inverted1 && inverted2) ? beop_OR : beop_AND,
      BinaryExpression<inverted2 && !inverted1, EXPR1, OP, EXPR2>
    >
operator&&(BoolExpression<inverted1> const& e1,
           BinaryExpression<inverted2, EXPR1, OP, EXPR2> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BoolExpression<inverted1 && !inverted2>,
        (inverted1 && inverted2) ? beop_OR : beop_AND,
        BinaryExpression<inverted2 && !inverted1, EXPR1, OP, EXPR2>
      >(e1, e2);
}

// Expr && Expr
template<bool inverted1, class EXPR1, beop_type OP1, class EXPR2,
         bool inverted2, class EXPR3, beop_type OP2, class EXPR4>
inline BinaryExpression<inverted1 && inverted2,
      BinaryExpression<inverted1 && !inverted2, EXPR1, OP1, EXPR2>,
      (inverted1 && inverted2) ? beop_OR : beop_AND,
      BinaryExpression<inverted2 && !inverted1, EXPR3, OP2, EXPR4>
    >
operator&&(BinaryExpression<inverted1, EXPR1, OP1, EXPR2> const& e1,
           BinaryExpression<inverted2, EXPR3, OP2, EXPR4> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BinaryExpression<inverted1 && !inverted2, EXPR1, OP1, EXPR2>,
        (inverted1 && inverted2) ? beop_OR : beop_AND,
        BinaryExpression<inverted2 && !inverted1, EXPR3, OP2, EXPR4>
      >(e1, e2);
}

// Bool || Bool
template<bool inverted1, bool inverted2>
inline BinaryExpression<inverted1 && inverted2,
      BoolExpression<inverted1 && !inverted2>,
      (inverted1 && inverted2) ? beop_AND : beop_OR,
      BoolExpression<inverted2 && !inverted1>
    >
operator||(BoolExpression<inverted1> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BoolExpression<inverted1 && !inverted2>,
        (inverted1 && inverted2) ? beop_AND : beop_OR,
        BoolExpression<inverted2 && !inverted1>
      >(e1, e2);
}

// Expr || Bool
template<bool inverted1, class EXPR1, beop_type OP, class EXPR2, bool inverted2>
inline BinaryExpression<inverted1 && inverted2,
      BinaryExpression<inverted1 && !inverted2, EXPR1, OP, EXPR2>,
      (inverted1 && inverted2) ? beop_AND : beop_OR,
      BoolExpression<inverted2 && !inverted1>
    >
operator||(BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BinaryExpression<inverted1 && !inverted2, EXPR1, OP, EXPR2>,
        (inverted1 && inverted2) ? beop_AND : beop_OR,
        BoolExpression<inverted2 && !inverted1>
      >(e1, e2);
}

// Bool || Expr
template<bool inverted1, bool inverted2, class EXPR1, beop_type OP, class EXPR2>
inline BinaryExpression<inverted1 && inverted2,
      BoolExpression<inverted1 && !inverted2>,
      (inverted1 && inverted2) ? beop_AND : beop_OR,
      BinaryExpression<inverted2 && !inverted1, EXPR1, OP, EXPR2>
    >
operator||(BoolExpression<inverted1> const& e1,
           BinaryExpression<inverted2, EXPR1, OP, EXPR2> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BoolExpression<inverted1 && !inverted2>,
        (inverted1 && inverted2) ? beop_AND : beop_OR,
        BinaryExpression<inverted2 && !inverted1, EXPR1, OP, EXPR2>
      >(e1, e2);
}

// Expr || Expr
template<bool inverted1, class EXPR1, beop_type OP1, class EXPR2,
         bool inverted2, class EXPR3, beop_type OP2, class EXPR4>
inline BinaryExpression<inverted1 && inverted2,
      BinaryExpression<inverted1 && !inverted2, EXPR1, OP1, EXPR2>,
      (inverted1 && inverted2) ? beop_AND : beop_OR,
      BinaryExpression<inverted2 && !inverted1, EXPR3, OP2, EXPR4>
    >
operator||(BinaryExpression<inverted1, EXPR1, OP1, EXPR2> const& e1,
           BinaryExpression<inverted2, EXPR3, OP2, EXPR4> const& e2)
{
  return BinaryExpression<inverted1 && inverted2,
        BinaryExpression<inverted1 && !inverted2, EXPR1, OP1, EXPR2>,
        (inverted1 && inverted2) ? beop_AND : beop_OR,
        BinaryExpression<inverted2 && !inverted1, EXPR3, OP2, EXPR4>
      >(e1, e2);
}

// Bool != Bool
template<bool inverted1, bool inverted2>
inline BinaryExpression<false,
      BoolExpression<false>,
      (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
      BoolExpression<false>
    >
operator!=(BoolExpression<inverted1> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<false,
        BoolExpression<false>,
        (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
        BoolExpression<false>
      >(e1, e2);
}

// Expr != Bool
template<bool inverted1, class EXPR1, beop_type OP, class EXPR2, bool inverted2>
inline BinaryExpression<false,
      BinaryExpression<false, EXPR1, OP, EXPR2>,
      (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
      BoolExpression<false>
    >
operator!=(BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<false,
        BinaryExpression<false, EXPR1, OP, EXPR2>,
        (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
        BoolExpression<false>
      >(e1, e2);
}

// Expr != Const
template<bool inverted1, class EXPR1, beop_type OP, class EXPR2, typename T>
inline BinaryExpression<false,
      BinaryExpression<false, EXPR1, OP, EXPR2>,
      inverted1 ? beop_EQ : beop_NEQ,
      ConstExpression<T>
    >
operator!=(BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e1,
           ConstExpression<T> const& e2)
{
  return BinaryExpression<false,
        BinaryExpression<false, EXPR1, OP, EXPR2>,
        inverted1 ? beop_EQ : beop_NEQ,
        ConstExpression<T>
      >(e1, e2);
}

// Bool != Expr
template<bool inverted1, bool inverted2, class EXPR1, beop_type OP, class EXPR2>
inline BinaryExpression<false,
      BoolExpression<false>,
      (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
      BinaryExpression<false, EXPR1, OP, EXPR2>
    >
operator!=(BoolExpression<inverted1> const& e1,
           BinaryExpression<inverted2, EXPR1, OP, EXPR2> const& e2)
{
  return BinaryExpression<false,
        BoolExpression<false>,
        (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
        BinaryExpression<false, EXPR1, OP, EXPR2>
      >(e1, e2);
}

// Const != Expr
template<typename T, bool inverted1, class EXPR1, beop_type OP, class EXPR2>
inline BinaryExpression<false,
      ConstExpression<T>,
      inverted1 ? beop_EQ : beop_NEQ,
      BinaryExpression<false, EXPR1, OP, EXPR2>
    >
operator!=(ConstExpression<T> const& e1,
           BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e2)
{
  return BinaryExpression<false,
        ConstExpression<T>,
        inverted1 ? beop_EQ : beop_NEQ,
        BinaryExpression<false, EXPR1, OP, EXPR2>
      >(e1, e2);
}

// Expr != Expr
template<bool inverted1, class EXPR1, beop_type OP1, class EXPR2,
         bool inverted2, class EXPR3, beop_type OP2, class EXPR4>
inline BinaryExpression<false,
      BinaryExpression<false, EXPR1, OP1, EXPR2>,
      (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
      BinaryExpression<false, EXPR3, OP2, EXPR4>
    >
operator!=(BinaryExpression<inverted1, EXPR1, OP1, EXPR2> const& e1,
           BinaryExpression<inverted2, EXPR3, OP2, EXPR4> const& e2)
{
  return BinaryExpression<false,
        BinaryExpression<false, EXPR1, OP1, EXPR2>,
        (inverted1 == inverted2) ? beop_NEQ : beop_EQ,
        BinaryExpression<false, EXPR3, OP2, EXPR4>
      >(e1, e2);
}

// Bool == Bool
template<bool inverted1, bool inverted2>
inline BinaryExpression<false,
      BoolExpression<false>,
      (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
      BoolExpression<false>
    >
operator==(BoolExpression<inverted1> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<false,
        BoolExpression<false>,
        (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
        BoolExpression<false>
      >(e1, e2);
}

// Expr == Bool
template<bool inverted1, class EXPR1, beop_type OP, class EXPR2, bool inverted2>
inline BinaryExpression<false,
      BinaryExpression<false, EXPR1, OP, EXPR2>,
      (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
      BoolExpression<false>
    >
operator==(BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e1,
           BoolExpression<inverted2> const& e2)
{
  return BinaryExpression<false,
        BinaryExpression<false, EXPR1, OP, EXPR2>,
        (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
        BoolExpression<false>
      >(e1, e2);
}

// Expr == Const
template<bool inverted1, class EXPR1, beop_type OP, class EXPR2, typename T>
inline BinaryExpression<false,
      BinaryExpression<false, EXPR1, OP, EXPR2>,
      inverted1 ? beop_NEQ : beop_EQ,
      ConstExpression<T>
    >
operator==(BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e1,
           ConstExpression<T> const& e2)
{
  return BinaryExpression<false,
        BinaryExpression<false, EXPR1, OP, EXPR2>,
        inverted1 ? beop_NEQ : beop_EQ,
        ConstExpression<T>
      >(e1, e2);
}

// Bool == Expr
template<bool inverted1, bool inverted2, class EXPR1, beop_type OP, class EXPR2>
inline BinaryExpression<false,
      BoolExpression<false>,
      (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
      BinaryExpression<false, EXPR1, OP, EXPR2>
    >
operator==(BoolExpression<inverted1> const& e1,
           BinaryExpression<inverted2, EXPR1, OP, EXPR2> const& e2)
{
  return BinaryExpression<false,
        BoolExpression<false>,
        (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
        BinaryExpression<false, EXPR1, OP, EXPR2>
      >(e1, e2);
}

// Const == Expr
template<typename T, bool inverted1, class EXPR1, beop_type OP, class EXPR2>
inline BinaryExpression<false,
      ConstExpression<T>,
      inverted1 ? beop_NEQ : beop_EQ,
      BinaryExpression<false, EXPR1, OP, EXPR2>
    >
operator==(ConstExpression<T> const& e1,
           BinaryExpression<inverted1, EXPR1, OP, EXPR2> const& e2)
{
  return BinaryExpression<false,
        ConstExpression<T>,
        inverted1 ? beop_NEQ : beop_EQ,
        BinaryExpression<false, EXPR1, OP, EXPR2>
      >(e1, e2);
}

// Expr == Expr
template<bool inverted1, class EXPR1, beop_type OP1, class EXPR2,
         bool inverted2, class EXPR3, beop_type OP2, class EXPR4>
inline BinaryExpression<false,
      BinaryExpression<false, EXPR1, OP1, EXPR2>,
      (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
      BinaryExpression<false, EXPR3, OP2, EXPR4>
    >
operator==(BinaryExpression<inverted1, EXPR1, OP1, EXPR2> const& e1,
           BinaryExpression<inverted2, EXPR3, OP2, EXPR4> const& e2)
{
  return BinaryExpression<false,
        BinaryExpression<false, EXPR1, OP1, EXPR2>,
        (inverted1 == inverted2) ? beop_EQ : beop_NEQ,
        BinaryExpression<false, EXPR3, OP2, EXPR4>
      >(e1, e2);
}

// Watched == Const
template<typename T>
BinaryExpression<false,
      WatchedExpression<T>,
      beop_EQ,
      ConstExpression<T>
    >
operator==(WatchedExpression<T> const& e1,
           ConstExpression<T> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T>,
        beop_EQ,
        ConstExpression<T>
      >(e1, e2);
}

// Const == Watched
template<typename T>
BinaryExpression<false,
      ConstExpression<T>,
      beop_EQ,
      WatchedExpression<T>
    >
operator==(ConstExpression<T> const& e1,
           WatchedExpression<T> const& e2)
{
  return BinaryExpression<false,
        ConstExpression<T>,
        beop_EQ,
        WatchedExpression<T>
      >(e1, e2);
}

// Watched == Watched
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_EQ,
      WatchedExpression<T2>
    >
operator==(WatchedExpression<T1> const& e1,
           WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_EQ,
        WatchedExpression<T2>
      >(e1, e2);
}

// Watched != Const
template<typename T>
BinaryExpression<false,
      WatchedExpression<T>,
      beop_NEQ,
      ConstExpression<T>
    >
operator!=(WatchedExpression<T> const& e1,
           ConstExpression<T> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T>,
        beop_NEQ,
        ConstExpression<T>
      >(e1, e2);
}

// Const != Watched
template<typename T>
BinaryExpression<false,
      ConstExpression<T>,
      beop_NEQ,
      WatchedExpression<T>
    >
operator!=(ConstExpression<T> const& e1,
           WatchedExpression<T> const& e2)
{
  return BinaryExpression<false,
        ConstExpression<T>,
        beop_NEQ,
        WatchedExpression<T>
      >(e1, e2);
}

// Watched != Watched
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_NEQ,
      WatchedExpression<T2>
    >
operator!=(WatchedExpression<T1> const& e1,
           WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_NEQ,
        WatchedExpression<T2>
      >(e1, e2);
}

// Watched & Const
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_BITWISE_AND,
      ConstExpression<T2>
    >
operator&(WatchedExpression<T1> const& e1,
          ConstExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_BITWISE_AND,
        ConstExpression<T2>
      >(e1, e2);
}

// Const & Watched
template<typename T1, typename T2>
BinaryExpression<false,
      ConstExpression<T1>,
      beop_BITWISE_AND,
      WatchedExpression<T2>
    >
operator&(ConstExpression<T1> const& e1,
          WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        ConstExpression<T1>,
        beop_BITWISE_AND,
        WatchedExpression<T2>
      >(e1, e2);
}

// Watched & Watched
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_BITWISE_AND,
      WatchedExpression<T2>
    >
operator&(WatchedExpression<T1> const& e1,
           WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_BITWISE_AND,
        WatchedExpression<T2>
      >(e1, e2);
}

// Watched | Const
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_BITWISE_OR,
      ConstExpression<T2>
    >
operator|(WatchedExpression<T1> const& e1,
          ConstExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_BITWISE_OR,
        ConstExpression<T2>
      >(e1, e2);
}

// Const | Watched
template<typename T1, typename T2>
BinaryExpression<false,
      ConstExpression<T1>,
      beop_BITWISE_OR,
      WatchedExpression<T2>
    >
operator|(ConstExpression<T1> const& e1,
          WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        ConstExpression<T1>,
        beop_BITWISE_OR,
        WatchedExpression<T2>
      >(e1, e2);
}

// Watched | Watched
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_BITWISE_OR,
      WatchedExpression<T2>
    >
operator|(WatchedExpression<T1> const& e1,
           WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_BITWISE_OR,
        WatchedExpression<T2>
      >(e1, e2);
}

// Watched ^ Const
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_BITWISE_XOR,
      ConstExpression<T2>
    >
operator^(WatchedExpression<T1> const& e1,
          ConstExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_BITWISE_XOR,
        ConstExpression<T2>
      >(e1, e2);
}

// Const ^ Watched
template<typename T1, typename T2>
BinaryExpression<false,
      ConstExpression<T1>,
      beop_BITWISE_XOR,
      WatchedExpression<T2>
    >
operator^(ConstExpression<T1> const& e1,
          WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        ConstExpression<T1>,
        beop_BITWISE_XOR,
        WatchedExpression<T2>
      >(e1, e2);
}

// Watched ^ Watched
template<typename T1, typename T2>
BinaryExpression<false,
      WatchedExpression<T1>,
      beop_BITWISE_XOR,
      WatchedExpression<T2>
    >
operator^(WatchedExpression<T1> const& e1,
           WatchedExpression<T2> const& e2)
{
  return BinaryExpression<false,
        WatchedExpression<T1>,
        beop_BITWISE_XOR,
        WatchedExpression<T2>
      >(e1, e2);
}

#define ON_TRUE(expr, action...) do { (expr).create_event_server()(action); } while(0)

#define DECLARE_BINARY_OPERATOR(op, code) \
  template<typename T1, typename T2> \
  struct binary_operator<false, T1, beop_##code, T2> \
  { \
    typedef T1 arg1_type; \
    typedef T2 arg2_type; \
    typedef typeof(((arg1_type const*)0)->evaluate_impl() op ((arg2_type const*)0)->evaluate_impl()) return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return a1.evaluate_impl() op a2.evaluate_impl(); } \
  }; \
  template<bool inverted, typename T3, beop_type OP, typename T4, typename T2> \
  struct binary_operator<false, BinaryExpression<inverted, T3, OP, T4>, beop_##code, T2> \
  { \
    typedef BinaryExpression<inverted, T3, OP, T4> arg1_type; \
    typedef BinaryExpressionDerived<inverted, T3, OP, T4> cast1_type; \
    typedef T2 arg2_type; \
    typedef typeof(((cast1_type const*)0)->evaluate_impl() op ((arg2_type const*)0)->evaluate_impl()) return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return static_cast<cast1_type const &>(a1).evaluate_impl() op a2.evaluate_impl(); } \
  }; \
  template<typename T1, bool inverted, typename T3, beop_type OP, typename T4> \
  struct binary_operator<false, T1, beop_##code, BinaryExpression<inverted, T3, OP, T4> > \
  { \
    typedef T1 arg1_type; \
    typedef BinaryExpression<inverted, T3, OP, T4> arg2_type; \
    typedef BinaryExpressionDerived<inverted, T3, OP, T4> cast2_type; \
    typedef typeof(((arg1_type const*)0)->evaluate_impl() op ((cast2_type const*)0)->evaluate_impl()) return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return a1.evaluate_impl() op static_cast<cast2_type const&>(a2).evaluate_impl(); } \
  }; \
  template<bool inverted1, typename T3, beop_type OP1, typename T4, \
           bool inverted2, typename T5, beop_type OP2, typename T6> \
  struct binary_operator<false, BinaryExpression<inverted1, T3, OP1, T4>, \
                         beop_##code, BinaryExpression<inverted2, T5, OP2, T6> > \
  { \
    typedef BinaryExpression<inverted1, T3, OP1, T4> arg1_type; \
    typedef BinaryExpressionDerived<inverted1, T3, OP1, T4> cast1_type; \
    typedef BinaryExpression<inverted2, T5, OP2, T6> arg2_type; \
    typedef BinaryExpressionDerived<inverted2, T5, OP2, T6> cast2_type; \
    typedef typeof(((cast1_type*)0)->evaluate_impl() op ((cast2_type*)0)->evaluate_impl()) return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return static_cast<cast1_type const&>(a1).evaluate_impl() \
            op static_cast<cast2_type const&>(a2).evaluate_impl(); } \
  }; \
  template<typename T1, typename T2> \
  struct binary_operator<true, T1, beop_##code, T2> \
  { \
    typedef T1 arg1_type; \
    typedef T2 arg2_type; \
    typedef bool return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return !(a1.evaluate_impl() op a2.evaluate_impl()); } \
  }; \
  template<bool inverted, typename T3, beop_type OP, typename T4, typename T2> \
  struct binary_operator<true, BinaryExpression<inverted, T3, OP, T4>, beop_##code, T2> \
  { \
    typedef BinaryExpression<inverted, T3, OP, T4> arg1_type; \
    typedef BinaryExpressionDerived<inverted, T3, OP, T4> cast1_type; \
    typedef T2 arg2_type; \
    typedef bool return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return !(static_cast<cast1_type const&>(a1).evaluate_impl() op a2.evaluate_impl()); } \
  }; \
  template<typename T1, bool inverted, typename T3, beop_type OP, typename T4> \
  struct binary_operator<true, T1, beop_##code, BinaryExpression<inverted, T3, OP, T4> > \
  { \
    typedef T1 arg1_type; \
    typedef BinaryExpression<inverted, T3, OP, T4> arg2_type; \
    typedef BinaryExpressionDerived<inverted, T3, OP, T4> cast2_type; \
    typedef bool return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return !(a1.evaluate_impl() op static_cast<cast2_type const&>(a2).evaluate_impl()); } \
  }; \
  template<bool inverted1, typename T3, beop_type OP1, typename T4, \
           bool inverted2, typename T5, beop_type OP2, typename T6> \
  struct binary_operator<true, BinaryExpression<inverted1, T3, OP1, T4>, \
                         beop_##code, BinaryExpression<inverted2, T5, OP2, T6> > \
  { \
    typedef BinaryExpression<inverted1, T3, OP1, T4> arg1_type; \
    typedef BinaryExpressionDerived<inverted1, T3, OP1, T4> cast1_type; \
    typedef BinaryExpression<inverted2, T5, OP2, T6> arg2_type; \
    typedef BinaryExpressionDerived<inverted2, T5, OP2, T6> cast2_type; \
    typedef bool return_type; \
    return_type operator()(arg1_type const& a1, arg2_type const& a2) \
        { return !(static_cast<cast1_type const&>(a1).evaluate_impl() \
            op static_cast<cast2_type const&>(a2).evaluate_impl()); } \
  }

DECLARE_BINARY_OPERATOR(&&, AND);
DECLARE_BINARY_OPERATOR(||, OR);
DECLARE_BINARY_OPERATOR(!=, NEQ);
DECLARE_BINARY_OPERATOR(==, EQ);
DECLARE_BINARY_OPERATOR(&, BITWISE_AND);
DECLARE_BINARY_OPERATOR(|, BITWISE_OR);
DECLARE_BINARY_OPERATOR(^, BITWISE_XOR);

template<bool inverted, class EXPR1, beop_type OP, class EXPR2>
typename binary_operator<inverted, EXPR1, OP, EXPR2>::return_type
BinaryExpressionDerived<inverted, EXPR1, OP, EXPR2>::evaluate_impl(void) const
{
  return binary_operator<inverted, EXPR1, OP, EXPR2>()(this->M_e1, this->M_e2);
}

#endif // EXPRESSION_H

---