ircproxy  The Ultimate Cyborg

---

Watched.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Watched.h
//! @brief This file contains the definitions of class Watched and declarations related to Watched and expression (events).
//
// 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.

#ifndef WATCHED_H
#define WATCHED_H

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

#include "ExpressionInterface.h"

class ExpressionEventServer;
template<typename T> class Watched;

//! @brief An expression consisting of a single Watched object.
template<typename T>
class WatchedExpression : public ExpressionInterface {
  public:
    typedef T const& evaluation_type;   //!< The type that the expression evaluates to.

  private:
    Watched<T>& M_b;                    //!< A reference to the watched object.

  public:
    //! Construct a WatchedExpression for Watched object \a b.
    WatchedExpression(Watched<T>& b) : M_b(b) { }

    //! Create and return an event server that is watching this expression.
    ExpressionEventServer& create_event_server(void);

    T const& evaluate_impl(void) const;

    //! Remove event server \a event_server from the notification list.
    void sub_event_server_impl(ExpressionEventServer*);

    virtual void add_event_server(boost::shared_ptr<ExpressionEventServer> const& event_server);
    //! Implement pure virtual ExpressionInterface::evaluate.
    //
    // This function should never be called for this expression because evaluate returns a bool
    // and this expression evaluates to evaluation_type.
    virtual bool evaluate(void)
        { DoutFatal(dc::core, "Calling WatchedExpression<" << type_info_of<T>().demangled_name() << ">::evaluate()");
          return false; /* Dummy return to suppress compiler warning (argh) */ }
    //! Implementation of pure virtual function 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
};

//! @brief A wrapper class for arbitrary objects of type T that need to be watched.
//
// Variables and objects that will be part of an Expression need to be wrapped
// by this class in order for the automatic event generation to work. If such
// a variable is assigned a different value, any expressions that use it will
// be re-evaluated and events generated when the value of any expression(s)
// changed.
template<typename T>
class Watched {
  private:
    T M_value;                                                                  //!< The underlying value.
    bool M_being_destructed;                                                    //!< Set when this object is being destructed.
    std::set<boost::shared_ptr<ExpressionEventServer> > M_event_servers;        //!< The event servers that watch expressions depending on this variable.
#ifdef CWDEBUG
    char const* M_name;                                                         //!< A name for this object, for debugging purposes.
#endif

  public:
#ifdef CWDEBUG
    //! Construct a Watched instance with debug name \a name.
    explicit Watched(char const* name) : M_being_destructed(false), M_name(name) { }
    //! Construct a Watched instance with debug name \a name and value \a value.
    explicit Watched(char const* name, T const& value) : M_value(value), M_being_destructed(false), M_name(name) { }
#else
    //! Default constructor for Watched object of type \a T.
    Watched(void) : M_being_destructed(false) { }
    Watched(T const& value) : M_value(value), M_being_destructed(false) { }
#endif
    //! Copy constructor.
    Watched(Watched const& b) : M_value(b.M_value), M_being_destructed(false)
        {
#ifdef CWDEBUG
          if (!b.M_event_servers.empty())
            Dout(dc::warning, "Copy-constructing a Watched<" <<
                type_info_of<T>().demangled_name() << "> that is being used by one or more ExpressionEventServer's");
#endif
        }
    //! Destructor.
    ~Watched();

#ifdef CWDEBUG
    //! Print M_name to \a os for debugging purposes.
    void print_name(std::ostream& os) const { os << M_name; }
#endif

    //! Add an event server to the event notification list.
    void add_event_server(boost::shared_ptr<ExpressionEventServer> const& event_server)
    {
      M_event_servers.insert(event_server);
    }

    //! Remove an event server from the event notification list.
    void sub_event_server(ExpressionEventServer* event_server)
    {
      if (M_being_destructed)
        return;
      std::set<boost::shared_ptr<ExpressionEventServer> >::iterator iter = M_event_servers.begin();
      while (iter != M_event_servers.end())
      {
        if ((*iter).get() == event_server)
          break;
        ++iter;
      }
      ASSERT(iter != M_event_servers.end());
      M_event_servers.erase(iter);
    }

    //! Templated assignment operator.
    template<typename T2>
    Watched& operator=(T2 const& b)
    {
      T previous_value(M_value);
      M_value = b;
      if (M_value != previous_value)
        changed_to(M_value);
      return *this;
    }

    //! Assignment operator.
    Watched& operator=(Watched const& b)
    {
      if (M_value != b.M_value)
        changed_to(b.M_value);
      return *this;
    }

    //! Templated bitwise AND assignment operator.
    template<typename T2>
    Watched& operator&=(T2 const& b)
    {
      T previous_value(M_value);
      M_value &= b;
      if (M_value != previous_value)
        changed_to(M_value);
      return *this;
    }

    //! Bitwise AND assignment operator.
    Watched& operator&=(Watched const& b)
    {
      T previous_value(M_value);
      M_value &= b.M_value;
      if (M_value != previous_value)
        changed_to(M_value);
      return *this;
    }

    //! Templated bitwise OR assignment operator.
    template<typename T2>
    Watched& operator|=(T2 const& b)
    {
      T previous_value(M_value);
      M_value |= b;
      if (M_value != previous_value)
        changed_to(M_value);
      return *this;
    }

    //! Bitwise OR assignment operator.
    Watched& operator|=(Watched const& b)
    {
      T previous_value(M_value);
      M_value |= b.M_value;
      if (M_value != previous_value)
        changed_to(M_value);
      return *this;
    }

    //! Templated bitwise XOR assignment operator.
    template<typename T2>
    Watched& operator^=(T2 const& b)
    {
      T previous_value(M_value);
      M_value ^= b;
      if (M_value != previous_value)
        changed_to(M_value);
      return *this;
    }

    //! Bitwise XOR assignment operator.
    Watched& operator^=(Watched const& b)
    {
      T previous_value(M_value);
      M_value ^= b.M_value;
      if (M_value != previous_value)
        changed_to(M_value);
      return *this;
    }

    //! Bitwise NOT operator.
    T operator~(void) { return ~M_value; }

    //! Dereference operator. Returns the Watched variable as Expression type.
    WatchedExpression<T> operator*(void) { return WatchedExpression<T>(*this); }

    //! Return underlying value.
    T const& value(void) const { return M_value; }

    //! Cast operator. Return underlying value.
    operator T const& () { return M_value; }

    template<typename T2>
    friend std::ostream& operator<<(std::ostream& os, Watched<T2> const& b);

  private:
    void changed_to(T const& b);
};

//! Serialize a Watched object.
template<typename T>
std::ostream& operator<<(std::ostream& os, Watched<T> const& b)
{
  return os << b.M_value;
}

//! Compare a Watched object with another object.
template<typename T1, typename T2> bool operator==(Watched<T1> const& v1, T2 const& v2) { return v1.value() == v2; }
//! Compare a Watched object with another object.
template<typename T1, typename T2> bool operator!=(Watched<T1> const& v1, T2 const& v2) { return v1.value() != v2; }
//! Compare a Watched object with another object.
template<typename T1, typename T2> bool operator<(Watched<T1> const& v1, T2 const& v2) { return v1.value() < v2; }
//! Compare a Watched object with another object.
template<typename T1, typename T2> bool operator<=(Watched<T1> const& v1, T2 const& v2) { return v1.value() <= v2; }
//! Compare a Watched object with another object.
template<typename T1, typename T2> bool operator>(Watched<T1> const& v1, T2 const& v2) { return v1.value() > v2; }
//! Compare a Watched object with another object.
template<typename T1, typename T2> bool operator>=(Watched<T1> const& v1, T2 const& v2) { return v1.value() >= v2; }
//! Perform a bitwise AND of a Watched object with another object.
template<typename T1, typename T2> T1 operator&(Watched<T1> const& v1, T2 const& v2) { return v1.value() & v2; }
//! Perform a bitwise OR of a Watched object with another object.
template<typename T1, typename T2> T1 operator|(Watched<T1> const& v1, T2 const& v2) { return v1.value() | v2; }
//! Perform a bitwise XOR of a Watched object with another object.
template<typename T1, typename T2> T1 operator^(Watched<T1> const& v1, T2 const& v2) { return v1.value() ^ v2; }

#ifdef CWDEBUG
//! For debugging purpose; write the (debug) name of this object to \a os.
template<typename T>
void WatchedExpression<T>::print_on(std::ostream& os) const
{
  M_b.print_name(os);
}
#endif

//! Add Expression event server \a event_server to the notification list.
template<typename T>
void WatchedExpression<T>::add_event_server(boost::shared_ptr<ExpressionEventServer> const& event_server)
{
  M_b.add_event_server(event_server);
}

//! Return the value of the underlying type.
template<typename T>
T const& WatchedExpression<T>::evaluate_impl(void) const
{
  return M_b.value();
}

//! Remove Expression event server \a event_server to the notification list.
template<typename T>
void WatchedExpression<T>::sub_event_server_impl(ExpressionEventServer* event_server)
{
  M_b.sub_event_server(event_server);
}

#include "Expression.h"

//! Inform listening Expression event servers that this variable changed value.
template<typename T>
void Watched<T>::changed_to(T const& b)
{
  M_value = b;
  std::set<boost::shared_ptr<ExpressionEventServer> >::iterator iter = M_event_servers.begin();
  // The call to bool_changed can remove iter from the set<>. Therefore increment iter before calling bool_changed.
  while (iter != M_event_servers.end())
    (*iter++)->bool_changed();
}

//! Destructor. Inform listening Expression event servers that this variable is no longer watched.
template<typename T>
Watched<T>::~Watched()
{
  M_being_destructed = true;
  for (std::set<boost::shared_ptr<ExpressionEventServer> >::iterator iter = M_event_servers.begin(); iter != M_event_servers.end();)
    (*iter++)->bool_destructed();
}

#endif // WATCHED_H

---