/home/jpf/code/cc/project/cmil/include/InputEv.h

Go to the documentation of this file.

// =====================================================================================
//       Filename:  InputEv.h 
//    Description:  
//        Created:  02/15/2007 08:47:46 PM EST
//       Revision:  none
//       Compiler:  gcc 3.4.6
// 
//         Author:  John P. Feltz 
//          Email:  jfeltz@gmail.com
//        License:  Copyright (c) 2006-2007, John P. Feltz 
//                  This program is free software; you can redistribute it and/or
//                  modify it under the terms of the GNU General Public License as
//                  published by the Free Software Foundation, version 2 of the
//                  License.
//                  This program is distributed in the hope that it will be
//                  useful, but WITHOUT ANY WARRANTY; without even the implied
//                  warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//                  PURPOSE.
//                  See the GNU General Public License version 2 for more details.
// 
// =====================================================================================


namespace cmil {

  class Ev : public Logger {
    public:
      typedef std::vector<Ev> Sequence;

      //the static default device type 
      static std::string sdev;  

      //the static default margin
      static unsigned long smargin; 

      static void setDefaultDevice(const std::string& name) {
        Ev::sdev = name;  
      }

      static void setDefaultTimeMargin(unsigned long time) {
        Ev::smargin= time;  
      }

      static std::string getDefaultDevice() { return Ev::sdev; }
      static unsigned long getDefaultTimeMargin() { return Ev::smargin; }

      static unsigned getEventCount(const Sequence& seq, const Ev& event) {
        unsigned int ev_count = 0;

        for(Sequence::const_iterator i = seq.begin() ; i != seq.end() ; i++) 
          if(*i == event) { ev_count++; }

        return ev_count;
      }

      //Main interface definitions for the event structure. 

      Ev(const std::string input) : 
        m_time_margin(Ev::getDefaultTimeMargin()),
        m_ndev(0),
        m_input(input), 
        m_dev(Ev::getDefaultDevice()), 
        m_sequence(NULL),
        m_action(NULL) {}

      Ev(unsigned long margin, const std::string input) : 
        m_time_margin(margin),
        m_ndev(0),
        m_input(input), 
        m_dev(Ev::getDefaultDevice()), 
        m_sequence(NULL),
        m_action(NULL) {}

      Ev(const std::string dev, std::string input) :
        m_time_margin(Ev::getDefaultTimeMargin()),
        m_ndev(0), 
        m_input(input), 
        m_dev(dev), 
        m_sequence(NULL),
        m_action(NULL) {}

      Ev(unsigned long margin, const std::string dev, std::string input) :
        m_time_margin(margin),
        m_ndev(0), 
        m_input(input), 
        m_dev(dev), 
        m_sequence(NULL),
        m_action(NULL) {}
  
  
      Ev(unsigned int ndev, const std::string dev, std::string input) :
        m_time_margin(Ev::getDefaultTimeMargin()),
        m_ndev(ndev), 
        m_input(input), 
        m_dev(dev), 
        m_sequence(NULL),
        m_action(0) {}

      Ev(unsigned int margin, unsigned int ndev, const std::string dev, std::string input) :
        m_time_margin(margin),
        m_ndev(ndev), 
        m_input(input), 
        m_dev(dev), 
        m_sequence(NULL),
        m_action(0) {}

      virtual ~Ev() { 
        if(m_sequence) 
          delete m_sequence;
      }

      InputAction* const getAction() const;

      std::string getDeviceName() const { return m_dev; }

      unsigned int getDeviceMultiple() const { return m_ndev; }

      Sequence* const getSequence() const;

      unsigned long getTimeMargin() const { return m_time_margin; }

      std::string getName() const { 
        return m_input; 
      }

      Ev& operator<<(const Ev& event);
      Ev& operator<<(InputAction* action);

      bool operator==(const Ev& event) const; 
      bool operator<(const Ev& event) const; 
      bool operator>(const Ev& event) const;

      Ev(const Ev& rhs);
      Ev& operator=(const Ev& rhs);

    private:
      InputAction* const seqAction() const;

      unsigned int m_time_margin;

      unsigned int m_ndev;

      std::string m_input; 

      std::string m_dev; 

      //this should only be initialized in the Ev responsible for the sequence
      Sequence::iterator m_iter;

      bool isAdded(const Ev& event ) const;

      Sequence* m_sequence;

      InputAction* m_action;
  };

}

---