cmil::Ev Class Reference

#include <InputEv.h>

Inheritance diagram for cmil::Ev:

[legend]Collaboration diagram for cmil::Ev:

[legend]List of all members.

Public Types
typedef std::vector< Ev >	Sequence
Public Member Functions
	Ev (const std::string input)
	Ev (unsigned long margin, const std::string input)
	Ev (const std::string dev, std::string input)
	Ev (unsigned long margin, const std::string dev, std::string input)
	Ev (unsigned int ndev, const std::string dev, std::string input)
	Ev (unsigned int margin, unsigned int ndev, const std::string dev, std::string input)
virtual	~Ev ()
InputAction *const	getAction () const
	Returns the action member of this class.
std::string	getDeviceName () const
unsigned int	getDeviceMultiple () const
Sequence *const	getSequence () const
unsigned long	getTimeMargin () const
std::string	getName () const
Ev &	operator<< (const Ev &event)
Ev &	operator<< (InputAction *action)
	This operator also assigns the action to the sequence.
bool	operator== (const Ev &event) const
bool	operator< (const Ev &event) const
bool	operator> (const Ev &event) const
	Ev (const Ev &rhs)
	This is mainly so the m_sequence doesn't get copied to events within that structure,.
Ev &	operator= (const Ev &rhs)
	This is mainly so the m_sequence doesn't get copied to events within that structure,.
Static Public Member Functions
static void	setDefaultDevice (const std::string &name)
static void	setDefaultTimeMargin (unsigned long time)
static std::string	getDefaultDevice ()
static unsigned long	getDefaultTimeMargin ()
static unsigned	getEventCount (const Sequence &seq, const Ev &event)
Static Public Attributes
static std::string	sdev = std::string("")
	This initializes the static default device name.
static unsigned long	smargin = 500
	This initializes the static default margin.
Private Member Functions
InputAction *const	seqAction () const
bool	isAdded (const Ev &event) const
	determines if an event of this kind has been added
Private Attributes
unsigned int	m_time_margin
	the time allowed for this event to occur, respective to others in a sequence, recommended in miliseconds
unsigned int	m_ndev
	the device multiple (what number of the same kind of device) IE: joystick[0]
std::string	m_input
	which input name identifier IE: button0
std::string	m_dev
	the type of device, IE: joystick
Sequence::iterator	m_iter
Sequence *	m_sequence
InputAction *	m_action
	the action, this should only be non-null as the last event of a sequence.

---

Detailed Description

This class is one of the main parts of the CMIL interface, it describes event sequences in conjunction with InputContext functions.

Definition at line 28 of file InputEv.h.

---

Member Typedef Documentation

typedef std::vector<Ev> cmil::Ev::Sequence

Definition at line 30 of file InputEv.h.

---

Constructor & Destructor Documentation

cmil::Ev::Ev

(

const std::string

input

)

[inline]

Definition at line 60 of file InputEv.h.

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

cmil::Ev::Ev	(	unsigned long	margin,
		const std::string	input
	)			[inline]

Definition at line 68 of file InputEv.h.

                                                      : 
        m_time_margin(margin),
        m_ndev(0),
        m_input(input), 
        m_dev(Ev::getDefaultDevice()), 
        m_sequence(NULL),
        m_action(NULL) {}

cmil::Ev::Ev	(	const std::string	dev,
		std::string	input
	)			[inline]

Definition at line 76 of file InputEv.h.

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

cmil::Ev::Ev	(	unsigned long	margin,
		const std::string	dev,
		std::string	input
	)			[inline]

Definition at line 84 of file InputEv.h.

00084                                                                      :
00085         m_time_margin(margin),
00086         m_ndev(0), 
00087         m_input(input), 
00088         m_dev(dev), 
00089         m_sequence(NULL),
00090         m_action(NULL) {}
  

cmil::Ev::Ev	(	unsigned int	ndev,
		const std::string	dev,
		std::string	input
	)			[inline]

Definition at line 93 of file InputEv.h.

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

cmil::Ev::Ev	(	unsigned int	margin,
		unsigned int	ndev,
		const std::string	dev,
		std::string	input
	)			[inline]

Definition at line 101 of file InputEv.h.

                                                                                       :
        m_time_margin(margin),
        m_ndev(ndev), 
        m_input(input), 
        m_dev(dev), 
        m_sequence(NULL),
        m_action(0) {}

virtual cmil::Ev::~Ev

(

)

[inline, virtual]

Definition at line 109 of file InputEv.h.

References m_sequence.

                    { 
        if(m_sequence) 
          delete m_sequence;
      }

cmil::Ev::Ev

(

const Ev &

rhs

)

This is mainly so the m_sequence doesn't get copied to events within that structure,.

Done to prevent circular pointer confusion/chaos

Definition at line 107 of file InputEv.cpp.

References m_action, m_dev, m_input, m_ndev, m_sequence, and m_time_margin.

                      {
    m_time_margin = rhs.m_time_margin; 
    m_ndev        = rhs.m_ndev; 
    m_input       = rhs.m_input;
    m_dev         = rhs.m_dev;

    m_action = rhs.m_action;

    m_sequence = NULL;
  }

---

Member Function Documentation

InputAction *const cmil::Ev::getAction

(

)

const

Returns the action member of this class.

Definition at line 41 of file InputEv.cpp.

References m_action.

Referenced by seqAction().

                                         { 
    return m_action;
  }

Here is the caller graph for this function:

static std::string cmil::Ev::getDefaultDevice

(

)

[inline, static]

Definition at line 46 of file InputEv.h.

References sdev.

{ return Ev::sdev; }

static unsigned long cmil::Ev::getDefaultTimeMargin

(

)

[inline, static]

Definition at line 47 of file InputEv.h.

References smargin.

{ return Ev::smargin; }

unsigned int cmil::Ev::getDeviceMultiple

(

)

const [inline]

Definition at line 119 of file InputEv.h.

References m_ndev.

Referenced by cmil::DeviceRegistry::getData().

{ return m_ndev; }

Here is the caller graph for this function:

std::string cmil::Ev::getDeviceName

(

)

const [inline]

Definition at line 117 of file InputEv.h.

References m_dev.

Referenced by cmil::DeviceRegistry::getData().

{ return m_dev; }

Here is the caller graph for this function:

static unsigned cmil::Ev::getEventCount	(	const Sequence &	seq,
		const Ev &	event
	)			[inline, static]

Definition at line 49 of file InputEv.h.

Referenced by cmil::NormalHandler::isNormal().

                                                                          {
        unsigned int ev_count = 0;

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

        return ev_count;
      }

Here is the caller graph for this function:

std::string cmil::Ev::getName

(

)

const [inline, virtual]

Implements Logger.

Definition at line 125 of file InputEv.h.

References m_input.

Referenced by cmil::DeviceRegistry::getData(), and operator<<().

                                { 
        return m_input; 
      }

Here is the caller graph for this function:

Ev::Sequence *const cmil::Ev::getSequence

(

)

const

Definition at line 57 of file InputEv.cpp.

References m_sequence.

Referenced by cmil::InputSequencer::addCombo(), cmil::InputSequencer::addNormal(), and cmil::InputSequencer::removeNormal().

                                          { 
     return m_sequence;
  }

Here is the caller graph for this function:

unsigned long cmil::Ev::getTimeMargin

(

)

const [inline]

Definition at line 123 of file InputEv.h.

References m_time_margin.

{ return m_time_margin; }

bool cmil::Ev::isAdded

(

const Ev &

event

)

const [private]

determines if an event of this kind has been added

bool cmil::Ev::operator<

(

const Ev &

event

)

const

Definition at line 142 of file InputEv.cpp.

References m_dev, m_input, and m_ndev.

                                          { 
    if(m_dev < event.m_dev) 
      return true;
    else if (m_ndev < event.m_ndev)
      return true;
    else if(m_ndev < event.m_ndev) 
      return true;
    else if(m_input < event.m_input) 
      return true;

    return false;
  }

Ev & cmil::Ev::operator<<

(

InputAction *

action

)

This operator also assigns the action to the sequence.

Set the action to what should be the last added event.

Apply the action.

Definition at line 88 of file InputEv.cpp.

References Logger::log_debug(), m_action, and m_sequence.

                                        { 
    log_debug("(Ev) operator<<(InputAction* action)" );
    
    if(!m_sequence) {
      m_sequence = new Ev::Sequence(1, *this);
      
      log_debug("(Ev) operator<< InputAction* : creating sequence "); 
    }

    log_debug(std::string("(Ev) operator<< InputAction*  assigning action to: ").append(m_sequence->back().getName()));
    
    (m_sequence->back()).m_action = action;

    return *this;  
  }

Here is the call graph for this function:

Ev & cmil::Ev::operator<<

(

const Ev &

event

)

This operator assigns responsibility in building an event sequence to this instance. Note that no checking is done as to the validity of the events. It is up to the InputSequencer to objectively determine that.

Ensure an action isn't already assigned to this sequence prior to adding

Create our sequence if necessary, adding this instance as the first entry.

add the event

Definition at line 65 of file InputEv.cpp.

References getName(), Logger::log_error(), m_sequence, and seqAction().

                                    { 
    
    if( !seqAction() ) {
       if(!m_sequence) {
         //log_debug( "(Ev) operator<< initializing new sequence");
         m_sequence = new Sequence(1, *this);
       }

       m_sequence->push_back(event);

       return *this;  
    }
    else 
      log_error(std::string("(Ev) operator<< addition not possible due to action already applied in sequence. (").append( 
      getName()).append(")"));

    return *this;  
  }                                           

Here is the call graph for this function:

Ev & cmil::Ev::operator=

(

const Ev &

rhs

)

This is mainly so the m_sequence doesn't get copied to events within that structure,.

Done to prevent circular pointer confusion/chaos

Definition at line 120 of file InputEv.cpp.

References m_action, m_dev, m_input, m_ndev, m_sequence, and m_time_margin.

                                 { 
    //log_debug("calling Ev& operator=(const Ev& rhs)"); 
    m_time_margin = rhs.m_time_margin; 
    m_ndev        = rhs.m_ndev; 
    m_input       = rhs.m_input;
    m_dev         = rhs.m_dev;

    m_action = rhs.m_action;
    
    m_sequence = NULL;

    return *this;
  }

bool cmil::Ev::operator==

(

const Ev &

event

)

const

Definition at line 135 of file InputEv.cpp.

References m_dev, m_input, and m_ndev.

                                           { 
    if( (m_ndev  == event.m_ndev) && (m_dev  == event.m_dev) && (m_input == event.m_input) ) 
      return true;

    return false;
  }

bool cmil::Ev::operator>

(

const Ev &

event

)

const

Definition at line 156 of file InputEv.cpp.

References m_dev, m_input, and m_ndev.

                                          { 
    if(m_dev > event.m_dev) 
      return true;
    else if (m_ndev > event.m_ndev)
      return true;
    else if(m_ndev > event.m_ndev) 
      return true;
    else if(m_input > event.m_input) 
      return true;

    return false;
  }

InputAction *const cmil::Ev::seqAction

(

)

const [private]

returns the action member of the sequence associated with this instance If no sequence is available, it is not the responsible instance.

Definition at line 47 of file InputEv.cpp.

References getAction(), and m_sequence.

Referenced by operator<<().

                                         { 
    if(m_sequence) {
//        log_debug("seqAction() returning action from last event in sequence");
        return m_sequence->back().getAction();
    }

//    log_debug("seqAction() return the action of this instance instead of the sequence.");
    return getAction();
  }

Here is the call graph for this function:

Here is the caller graph for this function:

static void cmil::Ev::setDefaultDevice

(

const std::string &

name

)

[inline, static]

Definition at line 38 of file InputEv.h.

References sdev.

                                                          {
        Ev::sdev = name;  
      }

static void cmil::Ev::setDefaultTimeMargin

(

unsigned long

time

)

[inline, static]

Definition at line 42 of file InputEv.h.

References smargin.

                                                           {
        Ev::smargin= time;  
      }

---

Member Data Documentation

InputAction* cmil::Ev::m_action [private]

the action, this should only be non-null as the last event of a sequence.

Definition at line 165 of file InputEv.h.

Referenced by Ev(), getAction(), operator<<(), and operator=().

std::string cmil::Ev::m_dev [private]

the type of device, IE: joystick

Definition at line 152 of file InputEv.h.

Referenced by Ev(), getDeviceName(), operator<(), operator=(), operator==(), and operator>().

std::string cmil::Ev::m_input [private]

which input name identifier IE: button0

Definition at line 149 of file InputEv.h.

Referenced by Ev(), getName(), operator<(), operator=(), operator==(), and operator>().

Sequence::iterator cmil::Ev::m_iter [private]

Definition at line 155 of file InputEv.h.

unsigned int cmil::Ev::m_ndev [private]

the device multiple (what number of the same kind of device) IE: joystick[0]

Definition at line 146 of file InputEv.h.

Referenced by Ev(), getDeviceMultiple(), operator<(), operator=(), operator==(), and operator>().

Sequence* cmil::Ev::m_sequence [private]

this should only be initialized to non-NULL in the Ev responsible for the sequence, and remain NULL in all actual sequenced events, See the copy constructor.

Definition at line 162 of file InputEv.h.

Referenced by Ev(), getSequence(), operator<<(), operator=(), seqAction(), and ~Ev().

unsigned int cmil::Ev::m_time_margin [private]

the time allowed for this event to occur, respective to others in a sequence, recommended in miliseconds

Definition at line 143 of file InputEv.h.

Referenced by Ev(), getTimeMargin(), and operator=().

std::string cmil::Ev::sdev = std::string("") [static]

This initializes the static default device name.

Definition at line 33 of file InputEv.h.

Referenced by getDefaultDevice(), and setDefaultDevice().

unsigned long cmil::Ev::smargin = 500 [static]

This initializes the static default margin.

Definition at line 36 of file InputEv.h.

Referenced by getDefaultTimeMargin(), and setDefaultTimeMargin().

---

The documentation for this class was generated from the following files:

• /home/jpf/code/cc/project/cmil/include/InputEv.h
• /home/jpf/code/cc/project/cmil/src/InputEv.cpp

---