almodule.h

Go to the documentation of this file.

#pragma once
#ifndef _LIBALCOMMON_ALCOMMON_ALMODULE_H_
#define _LIBALCOMMON_ALCOMMON_ALMODULE_H_

# include <alcommon/api.h>
# include <qi/macro.hpp>
# include <alcommon/almodulecore.h>
# include <boost/signals2.hpp>

namespace AL
{
  class ALBroker;
  class ALProxy;
  class ALValue;


  namespace detail
  {
    class ALCOMMON_API ALProcessSignals
    {
    public:
      ALProcessSignals()  {}
      virtual ~ALProcessSignals() {}

      typedef boost::signals2::signal<void ()>                     ProcessSignal;
      typedef boost::signals2::signal<void ()>::slot_function_type ProcessSignalSlot;
      typedef boost::signals2::connect_position           ProcessSignalPosition;
      typedef boost::signals2::connection                 ProcessSignalConnection;

      inline ProcessSignalConnection atPreProcess(
          ProcessSignalSlot subscriber,
          ProcessSignalPosition pos = boost::signals2::at_back)
      {
        return fPreProcess.connect(subscriber, pos);
      }

      inline ProcessSignalConnection atPostProcess(
          ProcessSignalSlot subscriber,
          ProcessSignalPosition pos = boost::signals2::at_back)
      {
        return fPostProcess.connect(subscriber, pos);
      }

      inline void removeAllPreProcess(void) {
        fPreProcess.disconnect_all_slots();
      }

      inline void removeAllPostProcess(void) {
        fPostProcess.disconnect_all_slots();
      }

      inline void preProcess(void) {
        fPreProcess();
      }

      inline void postProcess(void) {
        fPostProcess();
      }

    protected:
      ProcessSignal fPreProcess;
      ProcessSignal fPostProcess;
    };
  }


  class ALCOMMON_API ALModule: public ALModuleCore, public detail::ALProcessSignals
  {
    friend class baseModule;

  public:
    template <class T>
    static boost::shared_ptr<T> createModule(boost::shared_ptr<ALBroker> pBroker)
    {
      boost::shared_ptr<T> module(new T(pBroker));
      module->initModule();
      try
      {
        // we call init on a ALModule::Ptr as init may be protected
        // init is a virtual method that can be reimplemented
        (boost::static_pointer_cast<ALModule>(module))->init();
      }
      catch(const ALError& e)
      {
        module->exit();
        throw(e);
      }
      return module;
    }

    template <class T, typename P1>
    static boost::shared_ptr<T> createModule(boost::shared_ptr<ALBroker> pBroker, P1 p1)
    {
      boost::shared_ptr<T> module(new T(pBroker, p1));
      module->initModule();
      try
      {
        // we call init on a ALModule::Ptr as init may be protected
        // init is a virtual method that can be reimplemented
        (boost::static_pointer_cast<ALModule>(module))->init();
      }
      catch(const ALError& e)
      {
        module->exit();
        throw(e);
      }
      return module;
    }

    ALModule(boost::shared_ptr<ALBroker> pBroker, const std::string& pName);

    virtual ~ALModule();

    virtual void stop(const int &taskId);

    bool isStopRequired(const int &taskId = -1);

    bool wait(const int &taskId, const int &timeout);

    qi::FutureSync<void> wait(const int &taskId);

    bool isRunning(const int &taskId);

    int getMethodID(void);

    bool isPCalled();


    virtual void exit();

    QI_API_DEPRECATED void functionStop(int pIDTask);

    virtual void init(void) {}
  };
}

#endif  // _LIBALCOMMON_ALCOMMON_ALMODULE_H_