freControllerCentral.h

Go to the documentation of this file.

/*=========================================================================

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.1.0.0
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freControllerCentral.h,v $
  Language:  C++



  Copyright (c) 2007 Ralf o Floca (Department of Medical Informatics,
  Institute for Medical Biometry and Informatics, University of Heidelberg,
  Germany). All rights reserved.
  See FREECopyright.txt or http://www.mi.med.uni-hd.de/free/copyright.htm
  for details.

     This software is distributed WITHOUT ANY WARRANTY; without even 
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __freControllerCentral_h
#define __freControllerCentral_h

#include "freElementals.h"
#include "freEvents.h"
#include "freSetup.h"
#include "freControllerEvents.h"
#include "freControllerBase.h"

#include "itkMutexLock.h"
#include "itkDynamicLoader.h"

namespace FREE
{

class ControllerInfo
{
public:
  typedef itk::LibHandle LibraryHandleType;

  const std::string& GetControllerID() const
  {return m_ControllerID;};

  GenericComponentController* GetController() const
  { return m_pController;};

  const LibraryHandleType& GetLibraryHandle() const
  { return m_LibraryHandle;};

  const std::string& GetLibraryFile() const
  { return m_LibraryFile;};

  bool IsOwnedByLibrary() const
  { return m_bOwnedByLibrary;};

  ControllerInfo(GenericComponentController* pController,
                 const LibraryHandleType& libraryHandle,
                 const std::string& sLibraryFile);

  ControllerInfo(GenericComponentController* pController);

protected:
  std::string m_ControllerID;
  GenericComponentController* m_pController;
  LibraryHandleType m_LibraryHandle;
  std::string m_LibraryFile;
  bool m_bOwnedByLibrary;
};

class ControllerCentral
{
public:  
  typedef std::vector<ControllerInfo*> ControllerListType;
  typedef ControllerInfo::LibraryHandleType LibraryHandleType;
  typedef std::vector<LibraryHandleType> LibraryHandleListType;
  typedef std::vector<CallbackCtrlEventBase::Pointer> CtrlCallbackListType;
  typedef std::vector<ProgressCtrlEventBase::Pointer> CtrlProgressListType;

  typedef ControllerCentral Self;

  static void ReHash(); 

  static void RegisterController(GenericComponentController* pController,
                                 const LibraryHandleType& handle,
                                 const std::string& sLibraryFile);

  static void RegisterController(GenericComponentController* pController);

  static void UnRegisterController(GenericComponentController* pController);

  static void UnRegisterAllControllers();
  
  static void UnRegisterCallbackEventList();
  static void UnRegisterProgressEventList();

  static GenericComponentController* GetController(const std::string&  sControllerName);

  static ControllerInfo* GetControllerInfo(const std::string&  sControllerName);

  static GenericComponentController* GetResponsibleController(const GenericComponentType* pComponent);

  static ControllerListType GetControllers();

  ControllerCentral();
  ~ControllerCentral();

        static void SetOnControlEvent(ProgressEventBase* pOnControl);

        static void SetOnBuildEvent(ProgressEventBase* pOnBuild);

        static void AddOnProgressEvent(ProgressCtrlEventBase* pOnProgress);
        static void RemoveOnProgressEvent(ProgressCtrlEventBase* pOnProgress);
  static void ClearProgressEventList();

        static void AddOnCallbackEvent(CallbackCtrlEventBase* pOnCallback);
        static void RemoveOnCallbackEvent(CallbackCtrlEventBase* pOnCallback);
  static void ClearCallbackList();

  static void TriggerControllerProgressEvent(const IDPath& senderID,
                                             const ProgressCtrlEventBase::StatusID status,
                                             const std::string& sComment,
                                             SessionComponentCache* pSender,
                                             long threadID);

  static bool TriggerControllerCallback(const IDPath& senderID,
                                        CallbackCtrlEventBase::CallbackType callbackID,
                                        void* pData,
                                        SessionComponentCache* pSender,
                                        long threadID);


  static bool TriggerControlEvent(const int iStatusID, const std::string& sComment, void* pSender = 0, long threadID = 0);

  static bool TriggerBuildEvent(const int iStatusID, const std::string& sComment, void* pSender = 0, long threadID = 0);

  static void LinkControllerCentralAsDedicated(ControllerListType* pDedicatedControllerList,
                                              LibraryHandleListType* pDedicatedLibraryHandles,
                                              ProgressEventBase* pfnOnControl,
                                              ProgressEventBase* pfnOnBuild,
                                              CtrlCallbackListType* pCallbackList,
                                              CtrlProgressListType* pProgressList,
                                              itk::MutexLock* pGlobalCallbackMutex,
                                              itk::MutexLock* pGlobalProgressMutex);

private:
  friend class CleanUpControllerCentral;

  static void Initialize();

  static void RegisterDefaults();

  static void LoadDynamicControllers();

  static void LoadLibrariesInPath( const char*);

  static ControllerListType* m_RegisteredControllers; 

  static LibraryHandleListType* m_LibraryHandles;

  static CtrlCallbackListType* m_CtrlCallbacks;

  static CtrlProgressListType* m_CtrlProgress;
  
        static ProgressEventBase::Pointer m_fnOnControl;

        static ProgressEventBase::Pointer m_fnOnBuild;

  static itk::MutexLock::Pointer m_CallbackMutex;
  static itk::MutexLock::Pointer m_ProgressMutex;

  static itk::MutexLock* m_GlobalCallbackMutex;
  static itk::MutexLock* m_GlobalProgressMutex;

  static bool m_bControllersAreExternal;
};


typedef void (* FREE_GET_CONTROLLER_LIST_FUNCTION)(int& iCount, char**& pControllerIDs);

typedef GenericComponentController* (* FREE_CREATE_CONTROLLER_FUNCTION)(char* pControllerID);

typedef bool (* FREE_DELETE_CONTROLLER_FUNCTION)(GenericComponentController* pController);

typedef void (* FREE_LINK_CENTRAL_FUNCTION)(ControllerCentral::ControllerListType* pDedicatedControllerList,
                                            ControllerCentral::LibraryHandleListType* pDedicatedLibraryHandles,
                                            ProgressEventBase* pfnOnControl, ProgressEventBase* pfnOnBuild,
                                            ControllerCentral::CtrlCallbackListType* pCallbackList,
                                            ControllerCentral::CtrlProgressListType* pProgressList,
                                            itk::MutexLock* pGlobalCallbackMutex,
                                            itk::MutexLock* pGlobalProgressMutex);


} //end of namespace free;

#endif

---