JReplyMessage.hh

Go to the documentation of this file.

#ifndef __JDB_JREPLYMESSAGE__
#define __JDB_JREPLYMESSAGE__
 
#include <string>
#include <istream>
#include <ostream>
#include <sstream>
#include <iomanip>
 
#include "JNet/JTag.hh"
 
#include "JLang/JException.hh"
#include "JLang/JWhiteSpacesFacet.hh"
 
#include "JDAQ/JDAQTags.hh"
 
#include "JDatalogString.hh"
 
 
namespace JDB {}
namespace JPP { using namespace JDB; }
 
namespace JDB {
 
  using JLANG::JParseError;
 
 
  /**
   * Auxiliary data structure for reply message.
   */
  struct JReplyMessage {
    /**
     * Default constructor.
     */
    JReplyMessage()
    {}
 
 
    /**
     * Copy constructor.
     *
     * \param  datalog       data log
     */
    JReplyMessage(const JDatalogString& datalog)
    {
      using namespace std;
      using namespace JPP;
      using namespace KM3NETDAQ;
 
      if (datalog.source == RC_REPLY.toString()) {
 
        this->tag = datalog.source;
 
        istringstream is(datalog.data);
 
        const locale loc(is.getloc(), new JWhiteSpacesFacet(is.getloc(), TOKEN_DELIMETER));
      
        is.imbue(loc);
          
        if (is >> this->key >> this->ip >> this->nickname >> this->event >>this->state && this->key == RUN_CONTROL_CLIENT) {
          
        } else {
 
          THROW(JParseError, "Invalid string " << datalog.source << " " << datalog.data);
        }
 
      } else {
 
        THROW(JParseError, "Invalid source " << datalog.source);
      }
    }
 
 
    /**
     * Get match.
     *
     * \param  message       message
     * \return               true if message matches; else false
     */
    bool match(const JReplyMessage& message) const
    {
      if (!message.nickname.empty() && message.nickname != nickname) { return false; }
      if (!message.ip      .empty() && message.ip       != ip)       { return false; }
      if (!message.event   .empty() && message.event    != event)    { return false; }
      if (!message.state   .empty() && message.state    != state)    { return false; }
 
      return true;
    }
 
 
    /**
     * Read message from input.
     *
     * \param  in            input stream
     * \param  object        message
     * \return               input stream
     */
    friend inline std::istream& operator>>(std::istream& in, JReplyMessage& object)
    {
      return in >> object.key
                >> object.ip
                >> object.nickname
                >> object.event
                >> object.state;
    }
 
 
    /**
     * Write message to output.
     *
     * \param  out           output stream
     * \param  object        message
     * \return               output stream
     */
    friend inline std::ostream& operator<<(std::ostream& out, const JReplyMessage& object)
    {
      return out << object.key
                 << object.ip
                 << object.nickname
                 << object.event
                 << object.state;
    }
 
 
    std::string  tag;
    std::string  key;
    std::string  ip;
    std::string  nickname;
    std::string  event;
    std::string  state;
  };
}
 
#endif