ControlUnitServiceBuildTask.hpp

/*
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/>.
*/



#ifndef _CONTROLUNITSERVICEBUILDTASK_HPP__
#define _CONTROLUNITSERVICEBUILDTASK_HPP__

#include <ServiceBuildTask.hpp>
#include <ActiveObject.hpp>

#include <Entity.hpp>
#include <EntityRepository.hpp>
#include <EntityDescription.hpp>
#include <ServiceConfiguration.hpp>
#include "UnitService.hpp"
#include <ServiceInstanceDescription.hpp>
#include <ServiceInterfaceDescription.hpp>
#include <ServiceInterface.hpp>
#include <ServiceTypeDescription.hpp>
#include <DataFeedDescription.hpp>
#include <DataFeed.hpp>
#include <Pingable.hpp>

#include <vector>
#include <map>

//
// this class extends ServiceBuildTask functionality
// I need to pass the services to be called somewhere
//

namespace mermaid
{
  namespace support
  {
    namespace unitgenerator
    {
    
      using namespace std;
      using mermaid::support::service::ServiceBuildTask;
      
      using boost::shared_ptr;
      using mermaid::support::service::Service;
      using mermaid::support::service::Entity;
      using mermaid::support::service::EntityRepository;
      using mermaid::support::service::ServiceConfiguration;
      using mermaid::support::service::ServiceInstanceDescription;
      using mermaid::support::service::ServiceTypeDescription;
      using mermaid::support::service::ServiceInterfaceDescription;
      using mermaid::support::service::ServiceInterface;
      using mermaid::support::service::DataFeedDescription;
      using mermaid::support::service::DataFeed;
      using mermaid::support::service::Pingable;
      using mermaid::support::activeobject::ActiveObject;
      
      template<class SERVICE_TYPE>
      class ControlUnitServiceBuildTask : public ServiceBuildTask<SERVICE_TYPE>
      {
        public:
          ControlUnitServiceBuildTask (shared_ptr<ActiveObject> ao, shared_ptr<EntityRepository> entityRepository, std::string entityName, std::string serviceInstanceName, shared_ptr<ServiceConfiguration> serviceConfiguration, const map<string, shared_ptr<Service> >& map = shared_ptr<Service>()) :
              ServiceBuildTask<SERVICE_TYPE> (ao, entityRepository, entityName, serviceInstanceName, serviceConfiguration) {
            nameToServiceMap_ = map;
          }
          
          virtual void run() {
            shared_ptr<Entity> entity = ServiceBuildTask<SERVICE_TYPE>::entityRepository_->getOrCreateEntity (ServiceBuildTask<SERVICE_TYPE>::entityName_);
            shared_ptr<ServiceInstanceDescription> serviceInstanceDescription = ServiceBuildTask<SERVICE_TYPE>::EntityDescriptionRepository::getInstance()->getEntityDescription (ServiceBuildTask<SERVICE_TYPE>::entityName_)->getServiceInstanceDescription (ServiceBuildTask<SERVICE_TYPE>::serviceInstanceName_);
            
            // create service
            shared_ptr<UnitService> s = shared_ptr<UnitService> (new SERVICE_TYPE (ServiceBuildTask<SERVICE_TYPE>::ao_, ServiceBuildTask<SERVICE_TYPE>::entity, ServiceBuildTask<SERVICE_TYPE>::serviceInstanceDescription, ServiceBuildTask<SERVICE_TYPE>::serviceConfiguration_));
            
            // these 2 lines is an addition
            s->setNameToServiceMap (nameToServiceMap_);
            
            //go through all service types
            std::vector<shared_ptr<ServiceTypeDescription> > serviceTypes = ServiceBuildTask<SERVICE_TYPE>::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
            ServiceBuildTask<SERVICE_TYPE>::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();
          }
          
        private:
          map<string, shared_ptr<Service> > nameToServiceMap_;
      };
    }
  }
}

#endif // _CONTROLUNITSERVICEBUILDTASK_HPP__