cmil::ComboHandler Class Reference

#include <InputNode.h>

Inheritance diagram for cmil::ComboHandler:

[legend]Collaboration diagram for cmil::ComboHandler:

[legend]List of all members.

Public Member Functions
	ComboHandler (System *const sys)
virtual	~ComboHandler ()
bool	add (const Ev::Sequence &seq)
virtual bool	handle (const InputData &input)
bool	isCombo (const Ev::Sequence &seq) const
virtual std::string	getName () const
Private Member Functions
bool	canHandle (const InputData &input) const
bool	Merge (const Ev::Sequence &seq)
bool	check_time (const InputNode *child) const
Private Attributes
const System *	m_system
InputNode *	m_root
	This is the first node in the tree structure managed by this handler.
InputNode *	m_controlling
	This is the tracked controlling node in the tree structure managed by this handler.

---

Detailed Description

I decided to compartimentalized handling of combos in order to have a less complicated namespace and provide some further flexibility with handling of InputData types with this specific kind of Sequencer.

Definition at line 151 of file InputNode.h.

---

Constructor & Destructor Documentation

cmil::ComboHandler::ComboHandler

(

System *const

sys

)

[inline]

Definition at line 153 of file InputNode.h.

: SystemClient(sys), m_root(NULL), m_controlling(NULL) {}

virtual cmil::ComboHandler::~ComboHandler

(

)

[inline, virtual]

Definition at line 154 of file InputNode.h.

References m_root.

{ delete m_root; }

---

Member Function Documentation

bool cmil::ComboHandler::add

(

const Ev::Sequence &

seq

)

Definition at line 355 of file InputNode.cpp.

References Logger::log_debug(), and Merge().

Referenced by cmil::NodeSequencer::imp_addCombo().

                                              {
      std::cout << std::endl;
      log_debug("add(seq) : defering sequence to merge function."); 
      return Merge(seq);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cmil::ComboHandler::canHandle

(

const InputData &

input

)

const [private]

Definition at line 361 of file InputNode.cpp.

References m_root.

Referenced by handle().

                                                           {
    if(!m_root) {
      //log_debug(std::string("canHandle() ").append(input.getName()).append(" not handled due to no sequences stored."));
      return false;
    }
    return true;
  }

Here is the caller graph for this function:

bool cmil::ComboHandler::check_time

(

const InputNode *

child

)

const [private]

Definition at line 369 of file InputNode.cpp.

References cmil::InputNode::getParent(), cmil::InputNode::getTime(), cmil::InputNode::getTimeMargin(), Logger::log_debug(), and Logger::log_error().

Referenced by handle().

                                                            { 
    unsigned long child_time   = child->getTime();
    unsigned long child_margin = child->getTimeMargin();
    unsigned long parent_time  = 0;

    if(!child->getParent()) {
      log_error("check_time() failing due to being called on a root node.");
      return false;
    }

    if(!(child->getParent())->getParent()) {
      log_debug("check_time returning true due to calling from m_root node");
      return true;
    }

    parent_time = child->getParent()->getTime();

    if((child_time - parent_time) <= child_margin) { 
      log_debug("check_time() returning true because of time verification.");
      return true;
    }

    log_debug("check_time() returning false due to time check failure.");
    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual std::string cmil::ComboHandler::getName

(

)

const [inline, virtual]

Reimplemented from cmil::SystemClient.

Definition at line 161 of file InputNode.h.

{ return "ComboHandler"; }

bool cmil::ComboHandler::handle

(

const InputData &

input

)

[virtual]

Definition at line 397 of file InputNode.cpp.

References canHandle(), check_time(), cmil::InputNode::getAction(), cmil::InputNode::getChild(), cmil::InputData::getID(), cmil::InputData::getName(), cmil::InputData::getState(), cmil::InputData::getTime(), Logger::log_debug(), m_controlling, m_root, cmil::InputData::run(), and cmil::InputNode::setTime().

Referenced by cmil::NodeSequencer::imp_handle().

                                                  {
    InputNode* child;

    if(!canHandle(input) || !input.getState()) 
      return false;
    
  
    if ( (child = m_controlling->getChild(input.getID())) != NULL) {
      child->setTime(input.getTime());
      if(check_time(child))
      {
        if(child->getAction()) {
           input.run(child->getAction());
           m_controlling = m_root;
        }
        else  {
          log_debug(string("handle(InputData) moving to next child in sequence: ").append(input.getName()));  
          child->setTime(input.getTime());  
          m_controlling = child; 
        }

        log_debug(string("handle(InputData) : ").append(input.getName()).append(" handled."));
        return true; 
      }
    }

    m_controlling = m_root;
    log_debug(string("handle(InputData) : ").append(input.getName()).append(" not handled."));
    return false; 
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cmil::ComboHandler::isCombo

(

const Ev::Sequence &

seq

)

const

Determine if the sequence has combo qualities Note that this will return true if passed a normal sequence. It is the equivelant with the exception of allowing duplicate events.

All sequences should have an action asigned.

Validate InputData matching the event.

Validate action position and compatibilty.

Not at the end yet.

Definition at line 241 of file InputNode.cpp.

References cmil::SystemClient::getData(), cmil::InputData::isActionCompatible(), Logger::log_debug(), and Logger::log_error().

Referenced by cmil::NodeSequencer::isCombo().

                                                        {
    InputData*   tmp_input;
    InputAction* tmp_action;

    if( !(  seq.back().getAction() )  ) { 
      log_error("isCombo() : event is not part of a valid sequence due to missing action"); 
      return false;
    }

    for(Ev::Sequence::const_iterator i = seq.begin() ; i!= seq.end(); i++) {
      log_debug(string("isCombo() : iteratoring to event named: ").append((*i).getName())); 
      
      if( ( tmp_input = getData((*i))) == NULL ) {
        log_error(string("isCombo() : sequence found invalid due no InputData found for event: ").append((*i).getName()));
        return false;
      }
      
      if((tmp_action = (*i).getAction()) != NULL) {
        if( i != --(seq.end()) ) {
          log_error(string("isCombo() : action found in wrong position of sequence. Ev: ").append((*i).getName())); 
          return false;
        }
        else if(!tmp_input->isActionCompatible(tmp_action)) {
          log_error("isCombo() : action found incompatible with event. "); 
          return false;
        }

        log_debug("isCombo() : returning true "); 
        return true;
      }
    }

    log_error("isCombo() : returning false ");
    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cmil::ComboHandler::Merge

(

const Ev::Sequence &

seq

)

[private]

Definition at line 431 of file InputNode.cpp.

References cmil::InputNode::createChild(), cmil::InputNode::createRoot(), cmil::SystemClient::getSize(), cmil::SystemClient::getSystem(), Logger::log_debug(), Logger::log_error(), m_controlling, m_root, cmil::InputNode::setAction(), and cmil::InputNode::setTimeMargin().

Referenced by add().

                                                {
    std::ostringstream debug_ss;
    InputAction* tmp_action;
    InputNode* current;

    if(!m_root) {
      log_debug("Merge() creating root node");
      m_root = InputNode::createRoot(getSystem(), getSize());
      m_controlling = m_root;
    }

    current = m_root;

    for(Ev::Sequence::const_iterator i = seq.begin() ; i!=seq.end(); i++) {
      //log_debug(string("  Merge() iterating through event sequence, name: ").append((*i).getName()));

      if((current = current->createChild(true, *i)) == NULL) {
        log_error("  Merge() Unable to merge sequence due to InputNode creation error.");
        return false;
      }

      current->setTimeMargin( (*i).getTimeMargin() );

      if((tmp_action = (*i).getAction()) != NULL) {
        log_debug(string("  Merge() found action at event, assigning: ").append((*i).getName())); 

        current->setAction(tmp_action);

        return true;
      }
      else 
        log_debug(string("  Merge() did not find an action at event: ").append((*i).getName()));
    }
    
    log_error("Merge() Unable to merge sequence due to no action being found.");
    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

InputNode* cmil::ComboHandler::m_controlling [private]

This is the tracked controlling node in the tree structure managed by this handler.

Definition at line 175 of file InputNode.h.

Referenced by handle(), and Merge().

InputNode* cmil::ComboHandler::m_root [private]

This is the first node in the tree structure managed by this handler.

Definition at line 172 of file InputNode.h.

Referenced by canHandle(), handle(), Merge(), and ~ComboHandler().

const System* cmil::ComboHandler::m_system [private]

Reimplemented from cmil::SystemClient.

Definition at line 169 of file InputNode.h.

---

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

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

---