ServiceProvider.hpp

#ifndef SERVICEPROVIDER_HPP
#define SERVICEPROVIDER_HPP

#include "Export.hpp"
#include "Graph.hpp"
#include "UserInterface.hpp"
#include "ServiceComponent.hpp"
#include "services/EmailServiceAPI.hpp"
#include "services/CodiceServiceAPI.hpp"
#include "services/codice-service/CodiceCache.hpp"
#include "services/DataGatheringServiceAPI.hpp"

namespace Showcase
{

  typedef ShowcaseFactoryPtr<ServiceComponent> ServiceComponentFactoryPtr;

  class SystemConfiguration;
  typedef std::shared_ptr<SystemConfiguration> SystemConfigurationPtr;

  class SHOWCASE_API ServiceProvider
  {
    public:
      ServiceProvider();

      void init(GraphPtr graph, const GraphNode& node);

      bool hasComponent(const QString& name) const;
      ServiceComponentPtr createComponent(const QString& name);

      FactoryKey<ServiceComponent>
      registerFactory(const QString &name, ServiceComponentFactoryPtr factory);

      bool unregisterFactory(FactoryKey<ServiceComponent> key);

      void clear();

      // Actual API for developers


      std::shared_ptr<EmailServiceAPI> emailService(const QString& name = QString());

      std::shared_ptr<CodiceServiceAPI> codiceService();

      std::shared_ptr<CodiceServiceCache> codiceServiceCache();

      std::shared_ptr<DataGathering::DataGatheringServiceAPI> dataGatheringService();

      ServiceInstancePtr
      service(const QString& componentName, const QString& name = QString()) const;

    protected:
      void addServiceInstance(const QString& component, const QString& name,
                              ServiceInstancePtr instance);
      void removeServiceInstance(const QString& component, const QString& name);

    private:
      FactoryMap<ServiceComponent> m_componentFactories;

      typedef std::map<QString, ServiceInstancePtr> ServiceMap;
      std::map<QString, ServiceMap> m_services;

      SystemConfigurationPtr m_systemConfig;

      // CodiceService is a special case since it is built-in to Showcase and
      // always available. It doesn't use normal service component architecture.
      std::shared_ptr<CodiceServiceAPI> m_codiceService;

      // CodiceServiceCache acts as a cache for CodiceService.
      std::shared_ptr<CodiceServiceCache> m_codiceServiceCache;

      friend class SystemConfiguration;
  };
  typedef std::shared_ptr<ServiceProvider> ServiceProviderPtr;

}

#endif // SERVICEPROVIDER_HPP