cmil::NormalHandler Class Reference

#include <InputNode.h>

Inheritance diagram for cmil::NormalHandler:

[legend]Collaboration diagram for cmil::NormalHandler:

[legend]List of all members.

Public Types
typedef std::map< Ev::Sequence, NodeSequence * >	AddedSequences
Public Member Functions
	NormalHandler (System *const sys)
virtual	~NormalHandler ()
virtual std::string	getName () const
bool	add (const Ev::Sequence &seq)
bool	remove (const Ev::Sequence &seq)
virtual bool	handle (const InputData &input)
virtual bool	handle (const ModData &input)
bool	isNormal (const Ev::Sequence &seq) const
Private Member Functions
bool	canHandle (const InputData &input) const
bool	Merge (const Ev::Sequence &seq)
bool	unMerge (const Ev::Sequence &seq)
	This removes a sequence starting at it's last node.
InputNode *	HandleActivity (const ModData &input)
InputNode *	recurChildController (InputNode *const node)
InputNode *	recurParentController (InputNode *const node)
void	RemoveControl (InputNode *node)
	Remove control of this node or any nodes that depend on it.
Private Attributes
std::deque< InputNode * >::iterator	m_i
std::deque< InputNode * >	m_controlnodes
InputNode *	m_root
	This is the first node in the tree structure managed by this handler.
InputNode::NodeIndex	m_active
	This tracks the active nodes throughout the tree to allow for fast access.
AddedSequences	m_added_seq
Classes
class	NodeSequence

---

Detailed Description

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

Definition at line 181 of file InputNode.h.

---

Member Typedef Documentation

typedef std::map<Ev::Sequence, NodeSequence* > cmil::NormalHandler::AddedSequences

Definition at line 194 of file InputNode.h.

---

Constructor & Destructor Documentation

cmil::NormalHandler::NormalHandler

(

System *const

sys

)

[inline]

Node data and structures based off them are built on use, rather than building them while the registry contains a non-complete index.

Definition at line 200 of file InputNode.h.

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

virtual cmil::NormalHandler::~NormalHandler

(

)

[inline, virtual]

Definition at line 201 of file InputNode.h.

References m_added_seq, and m_root.

                               { 
        delete m_root; 

        for(AddedSequences::iterator i  = m_added_seq.begin(); i != m_added_seq.end() ; i++) 
          delete (i->second);
      } 

---

Member Function Documentation

bool cmil::NormalHandler::add

(

const Ev::Sequence &

seq

)

Definition at line 331 of file InputNode.cpp.

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

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

                                               {
    std::cout << std::endl;

    if( m_added_seq.find(seq) != m_added_seq.end()) {
      log_error(" add() found matching pre-existing sequence, not adding."); 
      return false;
    }

    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::NormalHandler::canHandle

(

const InputData &

input

)

const [private]

Definition at line 471 of file InputNode.cpp.

References cmil::InputData::getID(), cmil::InputData::getName(), Logger::log_debug(), Logger::log_error(), m_active, and 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;
    }
    if(m_active.size()) {
      if(m_active.size() <= input.getID()) {
        log_error(std::string("canHandle() ").append(input.getName()).append(" not handled due to input not being availabile in present index."));
        return false;
      }
    }
    else {
      log_debug(std::string("canHandle() ").append(input.getName()).append(" not handled due to no seqeuences stored."));
      return false;
    }

    //log_debug(std::string("canHandle() ").append(input.getName()).append(" returning true"));
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

virtual std::string cmil::NormalHandler::getName

(

)

const [inline, virtual]

Reimplemented from cmil::SystemClient.

Definition at line 207 of file InputNode.h.

{ return "NormalHandler"; }

bool cmil::NormalHandler::handle

(

const ModData &

input

)

[virtual]

Definition at line 190 of file InputNode.cpp.

References canHandle(), cmil::InputData::getID(), cmil::InputData::getName(), cmil::InputData::getState(), HandleActivity(), Logger::log_debug(), m_active, RemoveControl(), and cmil::tInputData< ActionType >::run().

                                                 {
    if(!canHandle(input)) 
      return false;

    log_debug(string("Handle(ModData) : ").append(input.getName()));

    if(m_active[input.getID()]) {
      log_debug(string("Handle(ModData) : found in active active index: ").append(input.getName()));

      if(!input.getState())  {
        (((m_active[input.getID()])->getParent())->setActiveChild(NULL));

        RemoveControl(m_active[input.getID()]);
      }

      if((m_active[input.getID()])->getAction()) 
        input.run((m_active[input.getID()])->getAction());
    
      m_active[input.getID()] = NULL;

      log_debug(string("Handle(ModData) : ").append(input.getName()).append(" handled, inactivity set."));
      return true;
    }
    else {
      if(input.getState()) {

        if((m_active[input.getID()] = HandleActivity(input)) != NULL) {
          log_debug(string("Handle(ModData) : ").append(input.getName()).append(" handled, activity set"));
          return true;
        }
        else
          log_debug(string("Handle(ModData) : ").append(input.getName()).append(" not handled, no activity set"));

        log_debug(string("Handle(ModData) : ").append(input.getName()).append(" not handled due to no sequence found, "));
        return false;
      }
      return false;
    }
  }

Here is the call graph for this function:

bool cmil::NormalHandler::handle

(

const InputData &

input

)

[virtual]

Definition at line 152 of file InputNode.cpp.

References canHandle(), cmil::InputNode::getAction(), cmil::InputData::getID(), cmil::InputNode::getIndex(), cmil::InputData::getName(), Logger::log_debug(), m_controlnodes, m_i, m_root, and cmil::InputData::run().

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

                                                   {
    InputNode* child;
    std::ostringstream debug_ss;
  
    if(!canHandle(input)) 
      return false;
  
    for(m_i = m_controlnodes.begin() ; m_i != m_controlnodes.end() ; m_i++) {
      //log_debug( "handle() iterating through control nodes.."); 
      //check for the child by input index value 
  
      if((child = (*(*m_i)->getIndex())[input.getID()])  != NULL) {
        if(child->getAction())
          input.run(child->getAction());
  
        debug_ss <<" handle( " << input.getName() << ") handled. ";
        log_debug(debug_ss.str());
        debug_ss.str("");

        return true;
      }
    }
  
    if(m_root)
      if((child = (*m_root->getIndex())[input.getID()]) != NULL) {
        input.run(child->getAction());
        log_debug(string("handle(InputData) : ").append(input.getName()).append(" handled."));
        return true;
      }
  
    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:

InputNode * cmil::NormalHandler::HandleActivity

(

const ModData &

input

)

[private]

This checks non-root controlling node index'es to see if one of their children matches if so, replace the parent, if checking the root index, add as a new controlling node.

Check the registered controlling node index'es, last added to first.

Check for the child by input index value.

Set the parent's activechild to the one found.

Check if the child has dependants

Add this child as a controlling node since it's a child of the root the push_front call essentially sets the priority of which sequence handles the same input

Definition at line 570 of file InputNode.cpp.

References cmil::InputNode::getAction(), cmil::InputData::getID(), cmil::InputNode::getIndex(), cmil::InputData::getName(), Logger::log_debug(), m_controlnodes, m_i, m_root, recurChildController(), and cmil::tInputData< ActionType >::run().

Referenced by handle().

                                                               {
    InputNode* child;

//    log_debug(string("HandleActivity() : ").append(input.getName()));

    for(m_i = m_controlnodes.begin() ; m_i != m_controlnodes.end() ; m_i++) {
      if((child = (*(*m_i)->getIndex())[input.getID()]) != NULL) {
        if(child->getAction())
          input.run(child->getAction());

        (*m_i)->setActiveChild(child);
        (*m_i) = recurChildController(child);

        log_debug(string("HandleActivity(ModData) ").append(input.getName()).append( "successfully handled."));
        return child;
      }
    }

    log_debug(" HandleActivity() checking root since no control nodes found.");

    if(m_root)
      if((child = (*m_root->getIndex())[input.getID()]) != NULL) {
        if(child->getAction()) {
          log_debug("HandleActivity() running found action.");
          input.run(child->getAction());
        }

        if(child->getIndex() != NULL) 
          m_controlnodes.push_front(child);

        return child;
      }

    log_debug(string("HandleActivity(ModeData) ").append(input.getName()).append(" not handled."));
    return NULL;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cmil::NormalHandler::isNormal

(

const Ev::Sequence &

seq

)

const

Definition at line 281 of file InputNode.cpp.

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

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

                                                          {
    InputData*   tmp_input;
    InputAction* tmp_action;

    if( !( seq.back().getAction() )  ) { 
      log_error("isNormal() : 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("isNormal() : iteratoring to event named: ").append((*i).getName())); 
        if(Ev::getEventCount(seq, *(i)) > 1) {
          log_debug("isNormal() : returning false"); 
          return false;
        }
      
       if( ( tmp_input = getData(*i)) == NULL ) {
         log_error(string("isNormal() : sequence found invalid due no InputData found for event: ").append((*i).getName()));
         return false;
       }
       else if( i != --(seq.end()) ) {
          if(dynamic_cast<ModData*>(tmp_input) == NULL) {
          log_error("isNormal() : sequence found invalid due to a non-ModData type having dependant events.");
          return false;
        }
       }
      
      if((tmp_action = (*i).getAction()) != NULL) {
        if( i != --(seq.end()) ) {
          log_error(string("isNormal() : action found in wrong position of sequence. Ev: ").append((*i).getName())); 
          return false;
        }
        else if(!tmp_input->isActionCompatible(tmp_action)) {
          log_error("isNormal() : action found incompatible with event. "); 
          return false;
        }

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

    return false;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cmil::NormalHandler::Merge

(

const Ev::Sequence &

seq

)

[private]

Definition at line 491 of file InputNode.cpp.

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

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());
    }

    if(!m_active.size()) { 
      log_debug("Merge() setting m_active" );
      m_active = InputNode::NodeIndex(SystemClient::getSize());
    }

    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(false, (*i))) == NULL)
        return false;

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

        current->setAction(tmp_action);

        m_added_seq[seq] = new NodeSequence(current);
        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:

InputNode * cmil::NormalHandler::recurChildController

(

InputNode *const

node

)

[private]

This function created a need for an getActiveChild(), because i don't want to have to iterate over the vector members just to get what should be a single node.

This node is qualified to be a controller if it has an m_index, but check the activechild to see if it meets the same quality first.

This node doesn't meet the m_index quality => it can't be a controller => return the parent which is the last valid controller.

Definition at line 617 of file InputNode.cpp.

References cmil::InputNode::getActiveChild(), cmil::InputNode::getIndex(), and cmil::InputNode::getParent().

Referenced by HandleActivity(), and RemoveControl().

                                                                      {
    if((node->getIndex() != NULL) ) { 
      if(node->getActiveChild() != NULL) 
        return recurChildController(node->getActiveChild());
      else 
        return node;
    }

    return node->getParent(); 
  }

Here is the call graph for this function:

Here is the caller graph for this function:

InputNode * cmil::NormalHandler::recurParentController

(

InputNode *const

node

)

[private]

This finds the last valid parent controlling node (active /w index and accessible through parent). This should return NULL if closest found is root.

this is the root node, return NULL

It's active, return it.

Tt isn't, go to the next parent.

Definition at line 634 of file InputNode.cpp.

References cmil::InputNode::getID(), cmil::InputNode::getParent(), and m_active.

Referenced by RemoveControl().

                                                                       {
    if(!node->getParent())
      return NULL;

    if(m_active[node->getID()]) 
      return node;

    return recurParentController(node->getParent());
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cmil::NormalHandler::remove

(

const Ev::Sequence &

seq

)

Definition at line 343 of file InputNode.cpp.

References Logger::log_debug(), Logger::log_error(), m_added_seq, and unMerge().

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

                                                  {
    std::cout << std::endl;

    if( m_added_seq.find(seq) == m_added_seq.end()) {
      log_error(" remove(seq) no existing sequence found, not removing."); 
      return false;
    }

    log_debug("remove(seq) : defering sequence to unmerge function.");  
    return unMerge(seq);
  }

Here is the call graph for this function:

Here is the caller graph for this function:

void cmil::NormalHandler::RemoveControl

(

InputNode *

node

)

[private]

Remove control of this node or any nodes that depend on it.

Get the last in sequence child node with controller properties.

Get the iterator to the controller in the list.

Set the controlling node to the closest valid parent.

This is the root node, delete the node sequence.

Give the parent the same priority as the replaced controlling node.

Definition at line 648 of file InputNode.cpp.

References cmil::InputNode::getID(), cmil::InputNode::getParent(), m_controlnodes, m_i, recurChildController(), and recurParentController().

Referenced by handle().

                                                   {
    InputNode* controller = recurChildController(node);

    for(m_i = m_controlnodes.begin() ; m_i != m_controlnodes.end() ; m_i++) 
      if((*m_i)->getID() == controller->getID()) {
        
    
      InputNode* new_controller = recurParentController(node->getParent());

      if (new_controller== NULL)
        m_controlnodes.erase(m_i);
      else {
        (*m_i) = new_controller; 
      }
      break;
    }
  }

Here is the call graph for this function:

Here is the caller graph for this function:

bool cmil::NormalHandler::unMerge

(

const Ev::Sequence &

seq

)

[private]

This removes a sequence starting at it's last node.

Definition at line 535 of file InputNode.cpp.

References cmil::InputNode::deleteChild(), cmil::InputNode::getChildren(), cmil::InputNode::getID(), cmil::InputNode::getParent(), Logger::log_debug(), Logger::log_error(), m_added_seq, and m_root.

Referenced by remove().

                                                   {
    InputNode* parent;
    InputNode* current;

    if(!m_root) {
      log_debug("unMerge() found no root node, returning false");
      return false; 
    }

    if(m_added_seq[seq]) {
      current = m_added_seq[seq]->getLastNode();
      m_added_seq.erase(seq);
    }
    else {
      log_error("unMerge() didn't find the sequence on what should be second check.");
      return false;
    }
  
    for(Ev::Sequence::const_iterator i = seq.end() ; i!=seq.begin(); --i) {
      if( (current->getChildren()) || (!current->getParent()) ) 
        continue;

      parent = current->getParent();
      parent->deleteChild(current->getID());

      current = parent;
    }

    log_debug("unMerge() finishing removal"); 
    return true;
  }

Here is the call graph for this function:

Here is the caller graph for this function:

---

Member Data Documentation

InputNode::NodeIndex cmil::NormalHandler::m_active [private]

This tracks the active nodes throughout the tree to allow for fast access.

Definition at line 243 of file InputNode.h.

Referenced by canHandle(), handle(), Merge(), and recurParentController().

AddedSequences cmil::NormalHandler::m_added_seq [private]

Definition at line 245 of file InputNode.h.

Referenced by add(), Merge(), remove(), unMerge(), and ~NormalHandler().

std::deque<InputNode* > cmil::NormalHandler::m_controlnodes [private]

This tracks which inputs which have control of a sequence. IE: given Ctrl-Q as a sequence, and Ctrl(pressed)->A(released), the node for Ctrl be stored here while Ctrl is pressed. A deque was used to express the order of precindence between control nodes with the same dependant event.

Definition at line 237 of file InputNode.h.

Referenced by handle(), HandleActivity(), and RemoveControl().

std::deque<InputNode* >::iterator cmil::NormalHandler::m_i [private]

This is an iterator which needs to be at the class scope in order to be useful to certain functions.

Definition at line 230 of file InputNode.h.

Referenced by handle(), HandleActivity(), and RemoveControl().

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

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

Definition at line 240 of file InputNode.h.

Referenced by canHandle(), handle(), HandleActivity(), Merge(), unMerge(), and ~NormalHandler().

---

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

---