ServiceBuildTask.hpp

Go to the documentation of this file.

/*
Copyright 2007, 2008, 2009, 2010, 2011 Instituto de Sistemas e Robotica, Instituto Superior Tecnico

This file is part of MeRMaID.

MeRMaID is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

MeRMaID 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with MeRMaID.  If not, see <http://www.gnu.org/licenses/>.
*/



/**
 * @Filename ServiceBuildTask.hpp
 * @Description ServiceBuildTask declaration
 * @Status Work in Progress
 * @Version $Id: ServiceBuildTask.hpp 1 2011-03-04 18:13:18Z jreis $
 * @Maintainer
 */

#ifndef __SERVICE_SERVICEBUILDTASK_H
#define __SERVICE_SERVICEBUILDTASK_H

namespace mermaid
{
  namespace support
  {
    namespace service
    {
      template<class SERVICE_TYPE>
      class ServiceBuildTask;
    }
  }
}

#include <ActiveObject.hpp>
#include <DataFeed.hpp>
#include <Entity.hpp>
#include <EntityDescriptionRepository.hpp>
#include <EntityRepository.hpp>
#include <CommunicationGateway.hpp>

#include <Service.hpp>
#include <ServiceInterface.hpp>
#include <ServiceConfiguration.hpp>
#include <ServiceInstanceDescription.hpp>
#include <Task.hpp>

#include <Pingable.hpp>

#include <iostream>

namespace mermaid
{
  namespace support
  {
    namespace service
    {
    
      using mermaid::support::activeobject::ActiveObject;
      using mermaid::support::activeobject::Task;
      using mermaid::support::communication::CommunicationGateway;
      using boost::shared_ptr;
      //using mermaid::support::service::defaulttypes::pingable;
      /**
      * @Class ServiceBuildTask ServiceBuildTask.hpp "ServiceBuildTask.hpp"
      * @Description ServiceBuildTask class, used to build a Service in an ActiveObject
      * @Author Marco Barbosa
      */
      template<class SERVICE_TYPE>
      class ServiceBuildTask : public Task
      {
        public:
          ServiceBuildTask (shared_ptr<ActiveObject> ao, shared_ptr<EntityRepository> entityRepository, std::string entityName, std::string serviceInstanceName, shared_ptr<ServiceConfiguration> serviceConfiguration) {
            ao_ = ao;
            entityRepository_ = entityRepository;
            entityName_ = entityName;
            serviceInstanceName_ = serviceInstanceName;
            serviceConfiguration_ = serviceConfiguration;
          };
          
          virtual void run() {
            shared_ptr<Entity> entity = entityRepository_->getOrCreateEntity (entityName_);
            shared_ptr<ServiceInstanceDescription> serviceInstanceDescription = EntityDescriptionRepository::getInstance()->getEntityDescription (entityName_)->getServiceInstanceDescription (serviceInstanceName_);
            
            // create service
            shared_ptr<Service> s = shared_ptr<Service> (new SERVICE_TYPE (ao_, entity, serviceInstanceDescription, serviceConfiguration_));
            
            //go through all service types
            std::vector<shared_ptr<ServiceTypeDescription> > serviceTypes = serviceInstanceDescription->getServiceTypeDescriptions();
            std::vector<shared_ptr<ServiceTypeDescription> >::iterator typeIterator;
            
            for (typeIterator = serviceTypes.begin(); typeIterator != serviceTypes.end(); typeIterator++) {
              shared_ptr<ServiceTypeDescription> typeDescription = *typeIterator;
              
              // add service interfaces to service
              std::vector< shared_ptr<ServiceInterfaceDescription> > interfaces = typeDescription->getAllServiceInterfaceDescriptions();
              
              std::vector< shared_ptr<ServiceInterfaceDescription> >::iterator interfaceIt;
              
              for (interfaceIt = interfaces.begin(); interfaceIt != interfaces.end(); interfaceIt++) {
                shared_ptr<ServiceInterfaceDescription> itDesc = *interfaceIt;
                shared_ptr<ServiceInterface> interface (new ServiceInterface (itDesc));
                s->addServiceInterface (interface);
              };
              
              // add data feeds to service
              std::vector< shared_ptr<DataFeedDescription> > datafeeds = typeDescription->getAllDataFeedDescriptions();
              
              std::vector< shared_ptr<DataFeedDescription> >::iterator datafeedIt;
              
              for (datafeedIt = datafeeds.begin(); datafeedIt != datafeeds.end(); datafeedIt++) {
                shared_ptr<DataFeedDescription> dfDesc = *datafeedIt;
                shared_ptr<DataFeed> datafeed (new DataFeed (dfDesc));
                s->addDataFeed (datafeed);
              };
            }
            
            //add service to owning entity
            entity->addService (s);
            
            //register service in communication gateway
            ao_->getCommunicationGateway()->registerService (s);
            
            try {
              //attach default service type implementations
              //! @TODO use deployment configuration file to choose which default service type implementations should be attached to each service.
              Pingable * p = new Pingable();
              p->attachToService (s);
            }
            catch (...) {
              std::cout << "Failed to attach \"Pingable\" default service type implementation." << std::endl;
            }
            
            //service is ready for initialization
            s->initialize();
            
            
          };
          
        protected:
          shared_ptr<ActiveObject> ao_;
          shared_ptr<EntityRepository> entityRepository_;
          std::string entityName_;
          std::string serviceInstanceName_;
          shared_ptr<ServiceConfiguration> serviceConfiguration_;
          
      }; // ServiceUpdateTask
    } // namespace service
  } // namespace support
} // namespace mermaid



#endif // __SERVICE_SERVICEBUILDTASK_H