jccl::ConfigElementHandler Class Reference

Abstract base class for all classes that can handle ConfigElement objects. More...

#include <jccl/RTRC/ConfigElementHandler.h>

List of all members.

Public Member Functions
virtual	~ConfigElementHandler ()
virtual bool	configCanHandle (ConfigElementPtr element)=0
	Checks if this handler can process the given config element.
virtual int	configProcessPending ()
	Processes any pending reconfiguration requests that we know how to deal with.
virtual bool	configAdd (ConfigElementPtr element)=0
	Adds the pending element to the configuration.
virtual bool	configRemove (ConfigElementPtr element)=0
	Removes the pending element from the current configuration.

---

Detailed Description

Abstract base class for all classes that can handle ConfigElement objects.

Any class supporting this interface can be dynamically reconfigured by the JCCL Configuration Manager.

The idea is that a subclass overrides configCanHandle() to recognize those elements types that the derived class cares about. Then override configAdd() and configRemove() to process instances of those elements.

The actual work of checking the list of pending add and remove requests and passing them to the methods of this interface is done by configProcessPending(). This can also be overriden to provide special behavior, but this is strongly discouraged. The default implementation should be sufficient for almost any conceivable dynamic reconfiguration need.

See also:

ConfigManager

Definition at line 61 of file ConfigElementHandler.h.

---

Constructor & Destructor Documentation

virtual jccl::ConfigElementHandler::~ConfigElementHandler

(

)

[inline, virtual]

Definition at line 65 of file ConfigElementHandler.h.

   {
      /* Do nothing. */ ;
   }

---

Member Function Documentation

virtual bool jccl::ConfigElementHandler::configCanHandle

(

ConfigElementPtr

element

)

[pure virtual]

Checks if this handler can process the given config element.

Typically, an implementation of this method will check the element's definition ID to decide if it knows how to deal with it.

Parameters:

element

The current config element that is ready to be processed.

Returns:

true iff this handler can process element.

int jccl::ConfigElementHandler::configProcessPending

(

)

[virtual]

Processes any pending reconfiguration requests that we know how to deal with.

The default implementation does the following for each item in the pending list:

for each pending item p in the pending list do if this->configCanHandle(p) AND p's dependencies are met retval = configAdd or configRemove (p) if retval == true remove request from pending add or remove p.element from active

ConfigManager's pending list MUST be locked before this function is called. Typically, configProcessPending() will be called by jccl::ConfigManager::attemptReconfiguration(), which takes care of this automatically.

See also:

ConfigManager

Definition at line 56 of file ConfigElementHandler.cpp.

References jccl::ConfigManager::PendingElement::ADD, jccl::ConfigManager::addActive(), configRemove(), jccl::DependencyManager::debugOutDependencies(), jccl::FAILED, jccl::ConfigManager::getNumPending(), jccl::ConfigManager::getPendingBegin(), jccl::ConfigManager::getPendingEnd(), jccl::DependencyManager::isSatisfied(), jccl::NEED_DEPS, jccl::outputPendingItemState(), jccl::ConfigManager::PendingElement::REMOVE, jccl::ConfigManager::removeActive(), jccl::ConfigManager::removePending(), jccl::ConfigManager::scanForLostDependencies(), and jccl::SUCCESS.

{
   ConfigManager*     cfg_mgr = ConfigManager::instance();
   DependencyManager* dep_mgr = DependencyManager::instance();

   bool scan_for_lost_dependants(false);       // Do we need to scan for un-filled dependencies

   // We need to track the number vefore and after to know if we changed anything
   std::list<ConfigManager::PendingElement>::size_type num_pending_before =
      cfg_mgr->getNumPending();
   std::list<ConfigManager::PendingElement>::size_type num_pending_after(0);

   vprDEBUG_BEGIN(vprDBG_ALL,vprDBG_STATE_LVL)
      << typeid(*this).name() << "::configProcessPending: Entering: "
      << num_pending_before << " items pending.\n" << vprDEBUG_FLUSH;

   // Perform the work of processing pending config elements.
   {
      std::list<ConfigManager::PendingElement>::iterator current, end, remove_me;
      current = cfg_mgr->getPendingBegin();
      end = cfg_mgr->getPendingEnd();

      // --- For each item in pending list --- //
      while(current != end)
      {
         // Get information about the current element
         ConfigElementPtr cur_element = (*current).mElement;
         vprASSERT(cur_element.get() != NULL && "Trying to use an invalid element");
         std::string element_name = cur_element->getName();
         std::string element_type = cur_element->getID();

         vprDEBUG_BEGIN(vprDBG_ALL,vprDBG_VERB_LVL)
            << "Item: name:" << element_name << " type:" << element_type
            << std::endl << vprDEBUG_FLUSH;

         // If the current handler (this) knows about the element
         if(this->configCanHandle(cur_element))
         {
            // ---- HANDLE THE ELEMENT ---- //
            switch ((*current).mType)
            {
            case ConfigManager::PendingElement::ADD:         // -- CONFIG ADD -- //
               if(dep_mgr->isSatisfied(cur_element))         // Are all the dependencies satisfied
               {
                  bool added = this->configAdd(cur_element);
                  if(added)                                 // SUCCESS adding
                  {
                     remove_me = current;
                     current++;                          // Goto next item
                     cfg_mgr->removePending(remove_me);  // Delete previous item
                     cfg_mgr->addActive(cur_element);    // Add it to the current config

                     outputPendingItemState(vprDBG_CONFIG_STATUS_LVL,
                                            element_name, element_type,
                                            SUCCESS);
                  }
                  else  // FAILED adding
                  {
                     outputPendingItemState(vprDBG_CRITICAL_LVL, element_name,
                                            element_type, FAILED);
                     current++;
                  }
               }
               else     // Dependency failed
               {
                  outputPendingItemState(vprDBG_CONFIG_LVL, element_name,
                                         element_type, NEED_DEPS);
                  vprDEBUG_CONT(vprDBG_ALL,vprDBG_CONFIG_LVL)
                     << std::endl << vprDEBUG_FLUSH;
                  dep_mgr->debugOutDependencies(cur_element,vprDBG_CONFIG_LVL);
                  current++;
               }
               break;

            case ConfigManager::PendingElement::REMOVE:      // Config remove
               {
                  bool removed = this->configRemove(cur_element);
                  if(removed)      // Was there success adding
                  {
                     remove_me = current;
                     current++;                          // Goto next item
                     cfg_mgr->removePending(remove_me);  // Delete previous item
                     cfg_mgr->removeActive(cur_element->getName());     // Add it to the current config
                     scan_for_lost_dependants = true;    // We have to scan to see if somebody depended on that element
                  }
                  else // Failed to remove
                  {
                     current++;
                  }
               }
               break;

            default:
               current++;  // Goto next entry
               break;
            }
         }
         // ---- CAN'T HANDLE THE ELEMENT --- //
         else           // if(can_handle)
         {
            vprDEBUG_NEXT(vprDBG_ALL,vprDBG_STATE_LVL)
               << "Pending item: " << cur_element->getName()
               << " type: " << cur_element->getID()
               << " --> Not handled by this handler.\n" << vprDEBUG_FLUSH;
            current++;
         }

         vprDEBUG_END(vprDBG_ALL,vprDBG_VERB_LVL) << "==== End item =====\n"
                                                  << vprDEBUG_FLUSH;
      }        // END: while(current != end)
   }

   num_pending_after = cfg_mgr->getNumPending();

   vprDEBUG_END(vprDBG_ALL,vprDBG_STATE_LVL)
      << "              Exiting: "
      << num_pending_after << " items now pending ==> We processed "
      << (num_pending_before-num_pending_after) << " items.\n"
      << vprDEBUG_FLUSH;

   // Check for items that have lost their dependencies dues to a remove item being processed
   if(scan_for_lost_dependants)
   {
      cfg_mgr->scanForLostDependencies();
   }

   return (num_pending_before-num_pending_after);
}

virtual bool jccl::ConfigElementHandler::configAdd

(

ConfigElementPtr

element

)

[pure virtual]

Adds the pending element to the configuration.

Precondition:

configCanHandle(element) == true.

Parameters:

element

A newly added config element to be processed.

Returns:

true is returned if and only if the given element was processed successfully.

virtual bool jccl::ConfigElementHandler::configRemove

(

ConfigElementPtr

element

)

[pure virtual]

Removes the pending element from the current configuration.

Precondition:

configCanHandle(element) == true.

Parameters:

element

A newly removed config element to be processed.

Returns:

true is returned if and only if the given element was processed successfully.

Referenced by configProcessPending().

---

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

• ConfigElementHandler.h
• ConfigElementHandler.cpp

---