Communicator.h

Go to the documentation of this file.

#ifndef GCP_UTIL_COMMUNICATOR_H
#define GCP_UTIL_COMMUNICATOR_H

#include <list>
#include <string>
#include <sstream>

#include "gcp/util/common/AntNum.h"
#include "gcp/util/common/String.h"
#include "gcp/util/common/TcpClient.h"
#include "gcp/util/common/TimeVal.h"

#define COMM_PARSER_FN(fn) void (fn)(gcp::util::String& str, void* arg)
#define COMM_END_PARSER_FN(fn) void (fn)(void* arg)

namespace gcp {
namespace util {
    
    class Communicator {
    public:
      
      // A generalized object for managing strings received from the
      // power strips.  If a parser is registered, it will be called
      // to process the string

      struct RcvdStr {
    std::string start_;
    std::string stop_;
    COMM_PARSER_FN(*parser_);
    void* arg_;
    COMM_END_PARSER_FN(*endParser_);
    void* endArg_;
    bool matchAny_;
    std::ostringstream os;

    RcvdStr();
    RcvdStr(const RcvdStr& str);
    RcvdStr(std::string str, COMM_PARSER_FN(*parser)=0, void* arg=0);
    RcvdStr(std::string start, std::string stop, 
        COMM_PARSER_FN(*parser), void* arg, 
        COMM_END_PARSER_FN(*endParser), void* endArg);

    void initialize();
      };

      Communicator();
      
      virtual ~Communicator();
      
      // The number of seconds we will wait for a response

      static const unsigned COMMAND_TIMEOUT_SEC = 10;

      bool timedOut();

      virtual int getFd();

      void run();

      virtual void processClientMessage();
      
      void registerTimeOut();
      
    protected:
      
      // An object for managing the TCP/IP connection to the power strip

      gcp::util::TcpClient* client_;

      // A timer we will use for keeping track of timeouts

      gcp::util::TimeVal timer_;
      
      std::list<std::string> sentStrings_;
      std::list<RcvdStr> rcvdStrings_;
      
      std::list<std::string>::iterator sentStringIter_;
      std::list<RcvdStr>::iterator rcvdStringIter_;
      
      std::ostringstream os_;

      virtual void terminateCommSequence(bool error);
      
      void enableTimeOut(bool enable);
      
      void checkLine();

      static COMM_PARSER_FN(sendNextString);

      virtual void sendNextString(void);

      void advanceIterator(bool bufferReset);
    
      void checkIterators();

    }; // End class Communicator
    
} // End namespace util
} // End namespace gcp



#endif // End #ifndef GCP_UTIL_COMMUNICATOR_H