div class="twikiTopBar">

Chair for Computer Aided Medical Procedures & Augmented Reality Lehrstuhl für Informatikanwendungen in der Medizin & Augmented Reality

TemplateService.cpp

Go to the documentation of this file.

/* ========================================================================
 * Copyright (C) 2000-2003  Technische Universit� Mnchen
 *
 * This framework 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; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This framework 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 for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this framework; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 * For further information please contact the DWARF team at
 * <dwarf-gnu@augmentedreality.de>
 * ========================================================================
 * PROJECT: DWARF
 * ======================================================================== */

/*
 * Base class for DWARF services
 * TemplateService.cpp
 * Martin Wagner, October 2003
 * Distributed Wearable Augmented Reality Framework - www.augmentedreality.de
 *
 * For documentation and instructions, see the DWARF documentation website at
 * http://wwwbruegge.in.tum.de/projects/dwarf/doc/
 *
 * For further questions about DWARF, please contact us at
 * dwarf@augmentedreality.de
 * For questions about this particular service, contact
 * Martin Wagner <martin@augmentedreality.de>
 *
 * $Id: TemplateService.cpp,v 1.8 2006/02/15 17:41:45 pustka Exp $
 */

/**
 * @defgroup CPPServiceTemplate Base class for DWARF services
 * This is a sample implementation of a DWARF service written in C++.
 *
 * @author Martin Wagner <martin@augmentedreality.de>
 */

/**
 * @file TemplateService.cpp
 * @brief The file containing the template service class implementation.
 *
 * This file contains the implementation of class TemplateService. We use only
 * the most simple interface, BasicService. BasicService implements the DWARF
 * Service interface and the DWARF SvcStartup interface.
 * See the DWARF Middleware Tutorial for details.
 *
 * @author Martin Wagner <martin@augmentedreality.de>
 * @ingroup CPPServiceTemplate
 */
// cmake/autoconf generated file with configuration information
#include <config.h>

// standard c headers
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
// standard c++ headers
#include <iostream>

#ifdef WIN32
#include <windows.h>
#include <time.h>
#endif

// omniORB threading library header
#include <omnithread.h>



// DWARF debug library header, providing DEBUGSTREAM macro
#include <debug.h>
// DWARF command line parsing library header file
#include <cmdlineprops.h>

#include <DefaultContextSwitch.h>

// The service header file
#include "TemplateService.h"


using namespace DWARF;




TemplateService::TemplateService() :
        m_mutexShouldRun(),
        m_signalShouldRun(&m_mutexShouldRun),
        m_name("Unknown"),
        m_shouldRun(false)
{
        DEBUGSTREAM(5, "Constructor");
}

TemplateService::~TemplateService() {
        stopService( NULL );
}


/**
 * This method stems from the DWARF Service interface. It is
 * not necessary to implement it, however, you can provide
 * more or less useful status information to the service manager
 * and other services interested in (e.g. DIVE)
 *
 * @warning called only from service manager.
 * Do not call these methods yourself!
 *
 * @return CORBA string that must be generated using string_dup
 *
 */
char* TemplateService::getStatus() {
        DEBUGSTREAM(20, "getStatus");
  char status[512];
  sprintf(status, "Dummy message. Overwrite TemplateService::getStatus() to get useful results.");
  return CORBA::string_dup(status);
}


/**
 * This method is called by the service manager on startup. Use this
 * method as the core initialization routine, parsing the service's
 * description for needs and abilities and instantiating corresponding
 * objects.
 *
 * The sequence of action is as follows:
 *  -# Back up the service description to a private variable.
 *  -# Parse all Needs and Abilities (call createAbility/NeedObject for every need),
 *     here you can implement your own behavior by subclassing
 *  -# Check if a need of type ContextSwitch exists and set up a handler object
 *  -# Execute the run() method in a new thread. Implement your own behavior by
 *     subclassing, the default method returns immediately.
 *
 * @TODO Document how the ContextSwitch mechanism works
 * @param serviceDesc The description of this service. This is a service's only
 *                    opportunity to get hold of its own service description.
 *                    If it is needed later on, store a copy of it in a member
 *                    variable
 * @warning This method should only be called by the service manager.
 */
void TemplateService::startService(ActiveServiceDescription_ptr serviceDesc) {

  DEBUGSTREAM(1, "startService");
  // set service's name and remember serviceDesc
  try{
    m_name = serviceDesc->getName();
    m_serviceDesc = ActiveServiceDescription::_duplicate(serviceDesc);
  }
  catch(CORBA::Exception&) {
    DEBUGSTREAM(1,  "Caught CORBA::Exception while getting service's name");
  }
  catch(...) {
    DEBUGSTREAM(1,  "Caught unknown exception while getting service's name");
  }

  // set up object structure
  DEBUGSTREAM(15, m_name << ": Parsing abilities...");
  parseAbilities(serviceDesc);
  DEBUGSTREAM(15, m_name << ": Parsing needs...");
  parseNeeds(serviceDesc);
  DEBUGSTREAM(15, m_name << ": Looking for ContextSwitch need...");
  checkContextSwitch(serviceDesc);

  // set up control object and start new thread
  DEBUGSTREAM(15, m_name << ": Starting Control object in new thread");
  m_mutexShouldRun.lock();
  m_shouldRun = true;
  m_signalShouldRun.broadcast();
  (new omni_thread( &controlThreadStarter, this ))->start();
  DEBUGSTREAM(10, m_name << ": Thread created and start() called. Signaling it that is should run.");
  m_mutexShouldRun.unlock();
  DEBUGSTREAM(1, m_name << ": Control thread started, startService finished.");
}


/**
 * This method is called by the service manager on shutdown of the
 * service. We use this method to delete the Service Control object,
 * assuming that it takes all necessary means in its destructor to
 * stop the controller thread(s). In addition, we delete all objects
 * handling the service's needs and abilities
 *
 * @param serviceDesc The service's description given by the service
 *                    manager
 * @warning This method should only be called by the service manager.
 */
void TemplateService::stopService(ActiveServiceDescription_ptr serviceDesc) {
  DEBUGSTREAM(1, m_name << ": stopService. Shutting down...");
  // clear all hashmap entries, thereby deleting
  // all Object_var's in the maps

  // This will not work. Have to rethink cleaning up CORBA objects -- Daniel
  //m_abilityMap.clear();
  //m_needMap.clear();
  DEBUGSTREAM(1, m_name << ": Service Controller and all Needs and Abilities NOT destroyed -- find out how to correctly destroy CORBA objects!");

  m_mutexShouldRun.lock();
  m_shouldRun = false;
  m_signalShouldRun.broadcast();
  m_mutexShouldRun.unlock();
  DEBUGSTREAM(10, "Signaled change of m_shouldRun");
}

// Access to abilities, needs and service description
/**
 * @brief returns a list with all abilities' names
 */
std::vector<std::string>* TemplateService::getAbilities(){
        std::vector<std::string> *retVal = new std::vector<std::string>;
        retVal->reserve( m_abilityMap.size() );
        typedef ObjectMap::iterator needAbilIterator;
        for( needAbilIterator abils = m_abilityMap.begin(); abils != m_abilityMap.end(); abils++ ) {
                retVal->push_back((std::string)abils->first);
        }
        return retVal;
}


/**
 * @brief returns a list with all needs' names
 */
std::vector<std::string>* TemplateService::getNeeds(){
        std::vector<std::string> *retVal = new std::vector<std::string>;
        retVal->reserve( m_needMap.size() );
        typedef ObjectMap::iterator needAbilIterator;
        for( needAbilIterator needs = m_needMap.begin(); needs != m_needMap.end(); needs++ ) {
                retVal->push_back(needs->first);
        }
        return retVal;
}


/**
 * @brief add a CORBA object registered for ability <name>
 */
void TemplateService::addAbility(CORBA::String_var name, CORBA::Object_ptr object){
        m_abilityMap[(const char*)name] = CORBA::Object::_duplicate( object );
        return;
}

/**
 * @brief returns the CORBA object registered for ability <name>
 */
CORBA::Object_var TemplateService::getAbility(std::string name){
        if( m_abilityMap.find( name ) != m_abilityMap.end() )
                return m_abilityMap[name];

        return CORBA::Object::_nil();
}

/**
 * @brief add a CORBA object registered for need <name>
 */
void TemplateService::addNeed(CORBA::String_var name, CORBA::Object_ptr object){
        m_needMap[(const char*)name] = CORBA::Object::_duplicate( object );
        return;
}

/**
 * @brief returns the CORBA object registered for need <name>
 */
CORBA::Object_var TemplateService::getNeed(std::string name){
        if( m_needMap.find( name ) != m_needMap.end() )
                return m_needMap[name];

   return CORBA::Object::_nil();
}


/**
 * @brief returns the service's description
 */
ActiveServiceDescription_ptr TemplateService::getServiceDesc(){
        return ActiveServiceDescription::_duplicate(m_serviceDesc);
}



// Protected Methods

/**
 *  Parse all Abilities, for each found do
 *    -# Check for its type and connector protocol.
 *    -# Based on type, instantiate an object from a specific class
 *       (this is dependent on the actual service).
 *    -# Check whether this object can handle the specified protocol.
 *    -# Store the Ability description in a private hashmap.
 *    .
 * @param serviceDesc The description of this service.
 */
void TemplateService::parseAbilities(ActiveServiceDescription_ptr serviceDesc) {
        // get all abilities' names
        StringSeq_var abilities;
        try {
                abilities = serviceDesc->getAbilities();
                DEBUGSTREAM(20, m_name << ": Found " << abilities->length() << " Abilities");
        }
  catch(CORBA::Exception&) {
    DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while getting abilities.");
  }
  catch(...) {
    DEBUGSTREAM(1,  m_name << ": Caught unknown exception while getting abilities..");
  }
        // now parse all abilities one by one
        unsigned int num_abil=0;
        unsigned int reg_abil=0;
        for(num_abil=0; num_abil<abilities->length(); num_abil++) {
                try {
                        // Create an object
                        AbilityDescription_ptr abilityDescr = serviceDesc->getAbility(abilities[num_abil]);

         // check if we have an object in our map and it implements the specified connectors
         CORBA::Object_var abil = getAbility( abilityDescr->getName() );
         if ( CORBA::is_nil( abil ) || !checkAbilityObject( abil, abilityDescr ) )
            // call handler of derived object
                           abil = createAbilityObject( abilityDescr );

                        // check whether it exists and implements the specified connectors;
                        // if it does, proceed
                        if( !CORBA::is_nil(abil) && checkAbilityObject(abil,abilityDescr) ) {
                                // ...and tell the service manager that we have a new
                                // ability object
                                DEBUGSTREAM(10, m_name << ": Registering " << abilityDescr->getType() << " Ability " <<
                                                                                abilityDescr->getName() << " at ServiceManager");
                                serviceDesc->registerAbility( abilityDescr->getName(), abil );
                                reg_abil++;

            // add object to map
            addAbility( abilities[num_abil], abil );
                        }
                        // otherwise tell the user and the service manager
                        else {
                                // delete the object from the map
                                m_abilityMap.erase(abilityDescr->getName());

                                DEBUGSTREAM(0, m_name << ": The object you specified for ability <" << abilityDescr->getName() <<
                                                                                "> either has no type that is understood by this service implementation or" <<
                                                                                " does not implement the interfaces necessary for its connectors." << std::endl <<
                                                                                " It will not be registered at the service manager.");
                                serviceDesc->deleteAbility(abilityDescr->getName());
                        }
                }
                catch(CORBA::Exception&) {
                        DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while setting up ability " << num_abil);
                }
                catch(...) {
                        DEBUGSTREAM(1,  m_name << ": Caught unknown exception while setting up ability " << num_abil);
                }
        }
        DEBUGSTREAM(5, m_name << ": Done parsing abilities, found " << num_abil << " abilities and registered "
                                                        << reg_abil << " of these." << std::endl);
}


/**
 * Parse all connectors of the given ability description. Test if the
 * given object implements the necessary interface using _is_a().
 *
 * @return <<true>> if the object matches all connectors, <<false>> otherwise
 */
bool TemplateService::checkAbilityObject(CORBA::Object_ptr ability, AbilityDescription_ptr abilityDescr){
        bool validObject = true;
        try {
                StringSeq_var connectors = abilityDescr->getConnectors();
                for( unsigned int i=0; i<connectors->length(); i++) {
                        const char *connProtocol = (const char*) abilityDescr->getConnector(connectors[i])->getProtocol();
                        DEBUGSTREAM(20, m_name << ": Found Connector " << abilityDescr->getConnector(connectors[i])
                                                                        << " of protocol " << connProtocol);
                        if(!strcmp(connProtocol, "PushSupplier")) {
                                // check if the ability implements SvcProtPushSupplier
                                if( !ability->_is_a("IDL:in.tum.de/DWARF/SvcProtPushSupplier:1.0") ) {
                                        // it doesn't, so the object cannot be registered
                                        validObject = false;
                                        break;
                                }
                        }
                        else if(!strcmp(connProtocol, "Shmem")) {
                                // check if the ability implements SvcProtShmem
                                if( !ability->_is_a("IDL:in.tum.de/DWARF/SvcProtShmem:1.0") ) {
                                        // it doesn't, so the object cannot be registered
                                        validObject = false;
                                        break;
                                }
                        }
                }
                // it may happen that someone implements the SvcSession
                // interface and has separate objects for communication
                if( ability->_is_a("IDL:in.tum.de/DWARF/SvcSession:1.0")) validObject = true;
        }
        catch(CORBA::Exception&) {
                DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while checking ability object.");
                return false;
        }
        catch(...) {
                DEBUGSTREAM(1,  m_name << ": Caught unknown exception while checking ability object.");
                return false;
        }
        return validObject;
}



/**
 *  Parse all Needs, for each found do
 *    -# Check for its type and connector protocol.
 *    -# Based on type, instantiate an object from a specific class
 *       (this is dependent on the actual service).
 *    -# Check whether this object can handle the specified protocol.
 *    -# Store the Need description in a private hashmap.
 *    .
 * @param serviceDesc The description of this service.
 */
void TemplateService::parseNeeds(ActiveServiceDescription_ptr serviceDesc) {
        // get all needs' names
        StringSeq_var needs;
        try {
                needs = serviceDesc->getNeeds();
                DEBUGSTREAM(20, m_name << ": Found " << needs->length() << " Needs");
        }
        catch(CORBA::Exception&) {
                DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while getting needs.");
        }
        catch(...) {
                DEBUGSTREAM(1,  m_name << ": Caught unknown exception while getting needs.");
        }
        // now parse all needs one by one
        unsigned int num_need=0;
        unsigned int reg_need=0;
        for(num_need=0; num_need<needs->length(); num_need++) {
                try {
                        // get need, output its name and type
                        NeedDescription_ptr needDescr = serviceDesc->getNeed(needs[num_need]);
                        // if the need sis of type ContextSwitch, it gets handled later
                        if(!strcmp(needDescr->getType(), "ContextSwitch") ) continue;

         // check if we have an object in our map and it implements the specified connectors
         CORBA::Object_var need = getNeed( static_cast< const char* >( needs[num_need] ) );
         if ( CORBA::is_nil( need ) || !checkNeedObject( need, needDescr ) )
            need = createNeedObject( needDescr );

                        // check whether it implements the specified connectors
                        // if it does, proceed
                        if(  !CORBA::is_nil(need) && checkNeedObject(need,needDescr) ) {
                                // ...and tell the service manager that we have a new
                                // need object
                                DEBUGSTREAM(10, m_name << ": Registering " << needDescr->getType() << " Need " <<
                                                                                needDescr->getName() << " at ServiceManager");
                                serviceDesc->registerNeed( needDescr->getName(), need );
                                reg_need++;

            // add object to map
            addNeed( needs[num_need], need );
                        }
                        // otherwise tell the user and the service manager
                        else {
                                // delete the object from the map
                                m_needMap.erase(needDescr->getName());

                                DEBUGSTREAM(0, m_name << ": The object you specified for need <" << needDescr->getName() <<
                                                                                "> either has no type that is understood by this service implementation or" <<
                                                                                " does not implement the interfaces necessary for its connectors." << std::endl <<
                                                                                " It will not be registered at the service manager.");
                                serviceDesc->deleteNeed(needDescr->getName());
                        }
                }
                catch(CORBA::Exception&) {
                        DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while setting up need #" << num_need);
                }
                catch(...) {
                        DEBUGSTREAM(1,  m_name << ": Caught unknown exception while setting up need #" << num_need);
                }
        }
        DEBUGSTREAM(5, m_name << ": Done parsing needs, found " << num_need << " needs and registered "
                                                        << reg_need << " of these.");

}


/**
 * Parse all connectors of the given ability description. Test if the
 * given object implements the necessary interface using dynamic_cast.
 *
 * @return <<true>> if the object matches all connectors, <<false>> otherwise
 */
bool TemplateService::checkNeedObject(CORBA::Object_ptr need, NeedDescription_ptr needDescr){
        bool validObject = true;
        try {
                StringSeq_var connectors = needDescr->getConnectors();
                for( unsigned int i=0; i<connectors->length(); i++) {
                        const char *connProtocol = (const char*) needDescr->getConnector(connectors[i])->getProtocol();
                        DEBUGSTREAM(20, m_name << ": Found Connector " << needDescr->getConnector(connectors[i])
                                                                        << " of protocol " << connProtocol);
                        if(!strcmp(connProtocol, "PushConsumer")) {
                                // check if the ability implements SvcProtPushConsumer
                                if( !need->_is_a("IDL:in.tum.de/DWARF/SvcProtPushConsumer:1.0") ) {
                                        // it doesn't, so the object cannot be registered
                                        validObject = false;
                                        break;
                                }
                        }
                        else if(!strcmp(connProtocol, "PullConsumer")) {
                                // check if the ability implements SvcProtPushConsumer
                                if( !need->_is_a("IDL:in.tum.de/DWARF/SvcProtPullConsumer:1.0") ) {
                                        // it doesn't, so the object cannot be registered
                                        validObject = false;
                                        break;
                                }
                        }
                        else if(!strcmp(connProtocol, "Shmem")) {
                                // check if the ability implements SvcProtShmem
                                if( !need->_is_a("IDL:in.tum.de/DWARF/SvcProtShmem:1.0") ) {
                                        // it doesn't, so the object cannot be registered
                                        validObject = false;
                                        break;
                                }
                        }
                        else if(!strcmp(connProtocol, "ObjrefImporter")) {
                                // check if the ability implements SvcProtObjRefImporter
                                if( !need->_is_a("IDL:in.tum.de/DWARF/SvcProtObjrefImporter:1.0") ) {
                                        // it doesn't, so the object cannot be registered
                                        validObject = false;
                                        break;
                                }
                        }
                }
                if( validObject==false ) {
                        // it may happen that someone implements the Session
                        // interface and has separate objects for communication
                        if( need->_is_a("IDL:in.tum.de/DWARF/SvcSession:1.0") ) validObject = true;
                }
        }
        catch(CORBA::Exception&) {
                DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while checking need object.");
                return false;
        }
        catch(...) {
                DEBUGSTREAM(1,  m_name << ": Caught unknown exception while checking need object.");
                return false;
        }
        return validObject;
}

void TemplateService::checkContextSwitch(DWARF::ActiveServiceDescription_ptr serviceDesc) {
        // get all needs' names
        StringSeq_var needs;
        try {
                needs = serviceDesc->getNeeds();
                DEBUGSTREAM(20, m_name << ": Found " << needs->length() << " Needs");
        }
        catch(CORBA::Exception&) {
                DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while getting needs.");
        }
        catch(...) {
                DEBUGSTREAM(1,  m_name << ": Caught unknown exception while getting needs.");
        }
        // now parse all needs one by one
        unsigned int num_need=0;
        unsigned int reg_need=0;
        for(num_need=0; num_need<needs->length(); num_need++) {
                try {
                        // get need, output its name and type
                        NeedDescription_ptr needDescr = serviceDesc->getNeed(needs[num_need]);
                        // if the need is _not_ of type ContextSwitch, it has been handled before
                        if(strcmp(needDescr->getType(), "ContextSwitch")) continue;

                        CORBA::Object_ptr contextSwitch = createContextSwitchObject(needDescr, serviceDesc);

                        // check whether it implements the specified connectors
                        // if it does, proceed
                        if(  !CORBA::is_nil(contextSwitch) && checkNeedObject(contextSwitch,needDescr) ) {
                                // ...and tell the service manager that we have a new
                                // need object
                                DEBUGSTREAM(10, m_name << ": Registering ContextSwitch Need " <<
                                        needDescr->getName() << " at ServiceManager");
                                serviceDesc->registerNeed( needDescr->getName(), contextSwitch );
                                reg_need++;
                        }
                        // otherwise tell the user and the service manager
                        else {
                                // delete the object from the map
                                m_needMap.erase(needDescr->getName());

                                serviceDesc->deleteNeed(needDescr->getName());
                        }
                }
                catch(CORBA::Exception&) {
                        DEBUGSTREAM(1,  m_name << ": Caught CORBA::Exception while setting up ContextSwitch need #" << num_need);
                }
                catch(...) {
                        DEBUGSTREAM(1,  m_name << ": Caught unknown exception while setting up ContextSwitch need #" << num_need);
                }
        }
        return;
}


CORBA::Object_ptr TemplateService::createContextSwitchObject( DWARF::NeedDescription_ptr needDescr,
        DWARF::ActiveServiceDescription_ptr serviceDesc ) {
        // create an object of the default type ContextSwitch and return a _this CORBA pointer to it
        POA_DWARF::ContextSwitch *object = new DefaultContextSwitch(needDescr, serviceDesc);
   CORBA::Object_ptr pCorbaObject = object->_this();
        addNeed( needDescr->getName(), pCorbaObject );
        return pCorbaObject;
}

/**
 * Does nothing except calling the run() method of the Service
 * object. Note that it is this object's responsibility to
 * terminate the thread by returning from the run() method
 *
 * @param data A pointer to a ServiceController object.
 */
void* TemplateService::controlThreadStarter(void* data) {
  ((TemplateService*)data)->run();
  return 0;
}

/**
 * Returns immediately, thus stopping the just started new thread.
 * Implement your own behavior by subclassing.
 */
void TemplateService::run() {
        DEBUGSTREAM(1, m_name << ": Default run() method. Returning immediately");
        return;
}

void TemplateService::blockUntilRunning() {
  m_mutexShouldRun.lock();
  while(!m_shouldRun) m_signalShouldRun.wait();
  m_mutexShouldRun.unlock();
}

void TemplateService::blockUntilStopped() {
  m_mutexShouldRun.lock();
  while(m_shouldRun) m_signalShouldRun.wait();
  m_mutexShouldRun.unlock();
}
bool TemplateService::shouldRun() {
  bool retval;
  m_mutexShouldRun.lock();
  retval = m_shouldRun;
  m_mutexShouldRun.unlock();
  return retval;
}

TemplateService.cpp Source File | generated on Sun Apr 29 02:01:05 2007 by Doxygen 1.4.1 for DWARF