ircproxy  The Ultimate Cyborg

---

Bool.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file Bool.h
//! @brief This file contains the declaration of class Bool.
//
// 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 BOOL_H
#define BOOL_H

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

#include "ExpressionInterface.h"

class Bool;
class ExpressionEventServer;

//! An Expression consisting of a single boolean (Bool).
template<bool inverted>
class BoolExpression : public ExpressionInterface {
  public:
    typedef BoolExpression<!inverted> inverted_type;    //!< The type of the inverted expression.
    typedef bool evaluation_type;                       //!< The return type of evaluate_impl.

  private:
    Bool& M_b;                                          //!< The underlying Bool.

  public:
    //! Copy constructor.
    BoolExpression(Bool& b) : M_b(b) { }

    //! Inversion operator. Returns an inverted expression.
    BoolExpression<!inverted> operator!(void) const { return BoolExpression<!inverted>(M_b); }

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

    bool evaluate_impl(void) const;
    void sub_event_server_impl(ExpressionEventServer*);

    virtual void add_event_server(boost::shared_ptr<ExpressionEventServer> const& event_server);
    //! Implementation of pure virtual function ExpressionInterface::evaluate.
    virtual bool evaluate(void) { return evaluate_impl(); }
    //! 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
};

//! A watchable boolean.
class Bool {
  private:
    bool M_value;               //!< Underlaying bool value.
    bool M_being_destructed;    //!< True when this object is being destructed.
    std::set<boost::shared_ptr<ExpressionEventServer> > M_event_servers;        //!< List of Expression event servers that are watching this Bool.
#ifdef CWDEBUG
    char const* M_name;         //!< For debugging purposes; a human readable name for this object.
#endif

  public:
#ifdef CWDEBUG
    //! Construct a Bool with debug name \a name.
    Bool(char const* name) : M_value(false), M_being_destructed(false), M_name(name) { }
#else
    //! Default constructor.
    Bool(void) : M_value(false), M_being_destructed(false) { }
#endif
    //! Copy constructor.
    Bool(Bool const& b) : M_value(b.M_value), M_being_destructed(false)
#ifdef CWDEBUG
    , M_name(b.M_name)
#endif
        {
#ifdef CWDEBUG
          if (!b.M_event_servers.empty())
            Dout(dc::warning, "Copy-constructing a Bool that is being used by one or more ExpressionEventServer's");
#endif
        }
    //! Destructor.
    ~Bool();

#ifdef CWDEBUG
    //! For debugging purposes. Write the (debug) name of this object to \a os.
    void print_name(std::ostream& os) const { os << M_name; }
#endif

    //! Add event server to notification list.
    void add_event_server(boost::shared_ptr<ExpressionEventServer> const& event_server)
    {
      // If this Bool appears multiple times in one expression, we come here more than once.
      // However, since M_event_servers is a set<>, only the first time the event_server is really added.
      M_event_servers.insert(event_server);
    }

    //! Remove event server from 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;
      }
      // If this Bool appears multiple times in one expression, we come here more than once.
      if (iter != M_event_servers.end())
        M_event_servers.erase(iter);
    }

    //! Assign bool value.
    Bool& operator=(bool b)
    {
      if (M_value != b)
        changed_to(b);
      return *this;
    }

    //! Assign Bool value.
    Bool& operator=(Bool const& b)
    {
      if (M_value != b.M_value)
        changed_to(b.M_value);
      return *this;
    }

    //! Dereference operator. Returns this object as expression.
    BoolExpression<false> operator*(void) { return BoolExpression<false>(*this); }

    //! Returns underlying bool value.
    bool value(void) const { return M_value; }

    //! Write Bool \a b to \a os.
    friend std::ostream& operator<<(std::ostream& os, Bool const& b);

  private:
    //! Called when the underlying boolean changes value to \a b.
    void changed_to(bool b);
};

#ifdef CWDEBUG
//! For debugging purposes. Write the contents of this object to \a os.
template<bool inverted>
void BoolExpression<inverted>::print_on(std::ostream& os) const
{
  if (inverted)
    os << '!';
  M_b.print_name(os);
}
#endif

//! Add event server \a event_server to notification list.
template<bool inverted>
void BoolExpression<inverted>::add_event_server(boost::shared_ptr<ExpressionEventServer> const& event_server)
{
  M_b.add_event_server(event_server);
}

//! @brief Evaluate this expression.
//
// Returns the underlying bool value of the single Bool that this expression consists off.
template<bool inverted>
bool BoolExpression<inverted>::evaluate_impl(void) const
{
  return M_b.value() != inverted;
}

//! Implementation of sub_event_server(). Remove event server \a event_server from the notification list.
template<bool inverted>
void BoolExpression<inverted>::sub_event_server_impl(ExpressionEventServer* event_server)
{
  M_b.sub_event_server(event_server);
}

#endif // BOOL_H

---