ircproxy  The Ultimate Cyborg

---

UserAnswer.h

Go to the documentation of this file.

// ircproxy -- An IRC bouncer.
//
//! @file UserAnswer.h
//! @brief This file contains the declaration of the UserAnswer events 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.

#ifndef USERANSWER_H
#define USERANSWER_H

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

#include "Target.h"
#include "question_nt.h"
#include "Counter.h"

//! \brief A user answer to a question.
// The UserAnswer event server EventData (http://libcw.sourceforge.net/events/interface.html#EventData).
class UserAnswer {
private:
  std::string M_answer;                         //!< The answer as typed by the user.
  ClientSession const& M_client_session;        //!< The client session that the answer is directed to.
  std::string const& M_target_name;             //!< The name of the target that the answer is directed to.
public:
  //! Construct a UserAnswer with answer \a answer, target Network \a network and target name \a target_name.
  UserAnswer(std::string const& answer, ClientSession const& client_session, std::string const& target_name) :
      M_answer(answer), M_client_session(client_session), M_target_name(target_name) { }
  //! Returns the answer string.
  std::string const& answer(void) const { return M_answer; }
  //! Returns the name of the target that the answer is directed to.
  std::string const& target_name(void) const { return M_target_name; }
  //! Returns true if \a target is the same target that this answer is directed to.
  bool is_match(boost::shared_ptr<Target> const& target) const;

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

//! \brief The UserAnswer event server's EventType.
// A UserAnswer. See http://libcw.sourceforge.net/events/interface.html#EventType
class UserAnswerEventType : public UserAnswer {
public:
  //! Construct a UserAnswerEventType with answer \a answer, target network \a network and target name \a target_name.
  UserAnswerEventType(std::string const& answer, ClientSession const& client_session, std::string const& target_name) :
      UserAnswer(answer, client_session, target_name) { }
};

//! The question that belongs to a given QuestionTarget.
class UserQuestion {
private:
  question_nt M_question_number;        //!< The question index.
  std::string M_question;               //!< The full question.
public:
  //! Construct a UserQuestion with index \a question_number and string \a question.
  UserQuestion(question_nt question_number, std::string const& question) :
      M_question_number(question_number), M_question(question) { }
  //! Return the question string.
  std::string const& question(void) const { return M_question; }
  //! Return the question index.
  question_nt number(void) const { return M_question_number; }
};

//! \brief Request data passed to the event server.
class UserAnswerRequestData {
private:
  ClientSession& M_client_session;              //!< The related client session.
  boost::shared_ptr<UserQuestion> M_question;   //!< Pointer to the associated question.

public:
  //! Construct UserAnswerRequestData for client session \a client_session with question index \a question_number and question string \a question.
  UserAnswerRequestData(ClientSession& client_session, question_nt question_number, std::string const& question) :
      M_client_session(client_session), M_question(NEW(UserQuestion(question_number, question))) { }

  //! Return the associated question string.
  std::string const& question(void) const { return M_question->question(); }
  //! Return the associated question.
  boost::shared_ptr<UserQuestion> user_question(void) { return M_question; }
  //! Return associated client session.
  ClientSession& client_session(void) { return M_client_session; }
  //! Return associated client session.
  ClientSession const& client_session(void) const { return M_client_session; }
};

//! \brief Base class for UserAnswer event request objects.
class UserAnswerEventRequestBase : public event_request_base_tct<UserAnswerEventType> {
public:
  //! The type of the request data.
  typedef UserAnswerRequestData event_request_data_ct;
private:
  event_request_data_ct M_request_data;         //!< The request data.
  boost::shared_ptr<Target> M_target;           //!< The target.
public:
  UserAnswerEventRequestBase(event_client_tracker_ct* event_client_tracker, event_request_data_ct request_data);
  ~UserAnswerEventRequestBase();
  //! Copy constructor.
  UserAnswerEventRequestBase(UserAnswerEventRequestBase const& request) :
      event_request_base_tct<UserAnswerEventType>(request),
      M_request_data(request.M_request_data),
      M_target(request.M_target)
      { Dout(dc::objects, "Copy-constructing UserAnswerEventRequestBase from " << request); }

  //! Returns the target.
  boost::shared_ptr<Target> const& target(void) const { return M_target; }

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

//! The UserAnswer event request queue class.
class UserAnswerEventRequestQueue {
  //! The type of the event request queue.
  typedef std::deque<UserAnswerEventRequestBase*> 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;           //!< The actual event request queue.
  event_requests_ct M_event_requests_tmp;       //!< Temporary event request queue for when M_event_requests is locked.
protected:
  //! Add event request \a request to the queue.
  void add_request(UserAnswerEventRequestBase* request)
      {
        if (M_event_requests_locked)
          M_event_requests_tmp.push_back(request);
        else
          M_event_requests.push_back(request);
      }
  //! Destructor.
  ~UserAnswerEventRequestQueue() { destroy_requests(); }
public:
  //! Destroy any requests for events left in the queue.
  void destroy_requests(void)
      {
        ASSERT(!M_event_requests_locked);
        while (!M_event_requests.empty())
        {
          M_event_requests.front()->release();
          M_event_requests.pop_front();
        }
      }
  //! Trigger an event.
  void trigger(UserAnswerEventRequestBase::event_type_ct const& event_type)
      {
        DoutEntering(dc::notice, "UserAnswerEventRequestQueue::trigger(" <<
            libcwd::type_info_of<UserAnswerEventRequestBase::event_type_ct>().demangled_name() <<
            " const& " << event_type << ")");
        {
          Increment tmp(M_event_requests_locked);
          event_requests_ct::iterator iter = M_event_requests.begin();
          while (iter != M_event_requests.end())
          {
            if ((*iter)->canceled())
            {
              Dout(dc::notice, "Removing canceled " << **iter);
              (*iter)->release();
              iter = M_event_requests.erase(iter);
            }
            else if (event_type.is_match((*iter)->target()))
            {
              Dout(dc::notice, "Calling handle() for " << **iter);
              (*iter)->handle(event_type);
              (*iter)->release();
              iter = M_event_requests.erase(iter);
            }
            else
              ++iter;
          }
        }
        if (M_event_requests_locked == 0)
          while (!M_event_requests_tmp.empty())
          {
            add_request(M_event_requests_tmp.front());
            M_event_requests_tmp.pop_front();
          }
      }
};

//! The event server for UserAnswerEventType.
typedef event_data_server_tct<UserAnswerEventRequestBase, UserAnswerEventRequestQueue> UserAnswerEventServer;

// Return the name of target 'number'.
extern char const* question_target_name(question_nt number);

#endif // USERANSWER_H

---