freControllerFactoryBase.cxx

Go to the documentation of this file.

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

  Program:   F.R.E.E. - flexible registration evaluation engine
  Version:   v.0.7.2
  Date:      $Date: 2006/09/01 12:00:00 $
  Module:    $RCSfile: freControllerCentral.cxx,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.

=========================================================================*/
#if defined(_MSC_VER)
#pragma warning ( disable : 4786 )
#endif

#include "freControllerCentral.h"
#include "freExceptions.h"

#include "itkDynamicLoader.h"
#include "itkDirectory.h"
#include "itkVersion.h"
#include "itksys/SystemTools.hxx"

namespace FREE
{

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::PointerListType* pDedicatedLibraryHandles,
                                            ProgressEventBase* pfnOnControl, ProgressEventBase* pfnOnBuild,
                                            ControllerCentral::CtrlCallbackListType* pCallbackList,
                                            ControllerCentral::CtrlProgressListType* pProgressList,
                                            itk::MutexLock* pGlobalCallbackMutex,
                                            itk::MutexLock* pGlobalProgressMutex);

class CleanUpControllerCentral
{
public:
  inline void Use() 
  {
  }
  ~CleanUpControllerCentral()
  {
    ControllerCentral::UnRegisterCallbackEventList();
    ControllerCentral::UnRegisterProgressEventList();
    ControllerCentral::UnRegisterAllControllers();
  }  
};
static CleanUpControllerCentral CleanUpControllerCentralGlobal;

ControllerCentral::ControllerListType* ControllerCentral::m_RegisteredControllers = NULL;

ControllerCentral::PointerListType* ControllerCentral::m_LibraryHandles = NULL;

ControllerCentral::CtrlCallbackListType* ControllerCentral::m_CtrlCallbacks = NULL;

ControllerCentral::CtrlProgressListType* ControllerCentral::m_CtrlProgress = NULL;

ProgressEventBase::Pointer ControllerCentral::m_fnOnControl = NULL;
ProgressEventBase::Pointer ControllerCentral::m_fnOnBuild = NULL;

bool ControllerCentral::m_bControllersAreExternal = false;

itk::MutexLock::Pointer ControllerCentral::m_CallbackMutex = itk::MutexLock::New();
itk::MutexLock::Pointer ControllerCentral::m_ProgressMutex = itk::MutexLock::New();

itk::MutexLock* ControllerCentral::m_GlobalCallbackMutex = 0;
itk::MutexLock* ControllerCentral::m_GlobalProgressMutex = 0;

void
ControllerCentral::
Initialize()
{
  try
  {
    if (!m_RegisteredControllers)
    {
      m_CallbackMutex->Lock();
      if (!m_CtrlCallbacks) m_CtrlCallbacks = new CtrlCallbackListType;
      m_CallbackMutex->Unlock();
     
      m_ProgressMutex->Lock();
      if (!m_CtrlProgress) m_CtrlProgress = new CtrlProgressListType;
      m_ProgressMutex->Unlock();

      m_RegisteredControllers = new ControllerListType;
      m_LibraryHandles = new PointerListType;

      ControllerCentral::RegisterDefaults();
      ControllerCentral::LoadDynamicControllers();
    }
  }
  catchAllNPassStaticMacro("Unknown Exception, while initializing free::ControllerCentral.");
};

void
ControllerCentral::
RegisterDefaults()
{
}

void
ControllerCentral::
LinkControllerCentralAsDedicated(ControllerListType* pDedicatedControllerList,
                                 PointerListType* pDedicatedLibraryHandles,
                                 ProgressEventBase* pfnOnControl,
                                 ProgressEventBase* pfnOnBuild,
                                 CtrlCallbackListType* pCtrlCallbackList,
                                 CtrlProgressListType* pCtrlProgressList,
                                 itk::MutexLock* pGlobalCallbackMutex,
                                 itk::MutexLock* pGlobalProgressMutex)
{
  if (m_RegisteredControllers!=pDedicatedControllerList)
  {
    UnRegisterAllControllers();
    m_LibraryHandles = pDedicatedLibraryHandles;
    m_RegisteredControllers = pDedicatedControllerList;
    m_bControllersAreExternal = true;
  }

  m_CallbackMutex->Lock();
  if (m_CtrlCallbacks!=pCtrlCallbackList)
  {
    ControllerCentral::UnRegisterCallbackEventList();
    m_CtrlCallbacks = pCtrlCallbackList;
    m_GlobalCallbackMutex = pGlobalCallbackMutex;
  }
  m_CallbackMutex->Unlock();

  m_ProgressMutex->Lock();
  if (m_CtrlProgress!=pCtrlProgressList)
  {
    ControllerCentral::UnRegisterProgressEventList();
    m_CtrlProgress = pCtrlProgressList;
    m_GlobalProgressMutex = pGlobalProgressMutex;
  }
  m_ProgressMutex->Unlock();

  m_fnOnControl = pfnOnControl;
  m_fnOnBuild = pfnOnBuild;
};

void
ControllerCentral::
LoadDynamicControllers()
{
#ifdef _WIN32
  char cPathSeparator = ';';
#else
  char cPathSeparator = ':';
#endif
  
  std::string sLoadPath = GetGeneralFREEPath();
        char* pcEnvironmentEntry = getenv(csFREEAutoLoadPath);
        if (pcEnvironmentEntry) sLoadPath += cPathSeparator+std::string(pcEnvironmentEntry);

  std::string sCurrentDirectory = itksys::SystemTools::GetCurrentWorkingDirectory();

  if (!sCurrentDirectory.empty())
        {
                sLoadPath += cPathSeparator+sCurrentDirectory;
        }

  if(sLoadPath.size() == 0)
  {
    return;
  }
  
        std::string::size_type endSeparatorPosition = 0;
  std::string::size_type startSeparatorPosition = 0;

  while ( startSeparatorPosition != std::string::npos )
  {
    startSeparatorPosition = endSeparatorPosition;
    endSeparatorPosition = sLoadPath.find(cPathSeparator, startSeparatorPosition);

    if(endSeparatorPosition == std::string::npos)
    {
      endSeparatorPosition = sLoadPath.size();
    }

    std::string CurrentPath = sLoadPath.substr(startSeparatorPosition, endSeparatorPosition);
    ControllerCentral::LoadLibrariesInPath(CurrentPath.c_str());
    
    if(endSeparatorPosition == sLoadPath.size())
    {
      startSeparatorPosition = std::string::npos;
    }
    else
    {
      endSeparatorPosition++;
    }
  }
}


static
std::string
CreateFullPath(const char* path, const char* file)
{
  std::string ret;

#ifdef _WIN32
  const char sep = '\\';
#else
  const char sep = '/';
#endif

  ret = path;
  if ( ret[ret.size()-1] != sep )
    {
    ret.append(1, sep);
    }
  ret.append(file);
  return ret;
}


inline bool
NameIsSharedLibrary(const char* name)
{
  std::string sname = name;
  if ( sname.find(itk::DynamicLoader::LibExtension()) != std::string::npos )
    {
    return true;
    }
  return false;
}


void
ControllerCentral::
LoadLibrariesInPath(const char* path)
{
        itk::Directory::Pointer dir = itk::Directory::New();
        if ( !dir->Load(path) )
        {
                return;
        }

        for ( unsigned int i = 0; i < dir->GetNumberOfFiles(); i++ )
        {
                const char* file = dir->GetFile(i);
                if ( NameIsSharedLibrary(file) )
                {
                        std::string fullpath = CreateFullPath(path, file);
                        itk::LibHandle lib = itk::DynamicLoader::OpenLibrary(fullpath.c_str());

                        if ( lib )
                        {
                                FREE_GET_CONTROLLER_LIST_FUNCTION pListFunction = (FREE_GET_CONTROLLER_LIST_FUNCTION)itk::DynamicLoader::GetSymbolAddress(lib, "FREEGetControllerList");
                                FREE_CREATE_CONTROLLER_FUNCTION pLoadFunction = (FREE_CREATE_CONTROLLER_FUNCTION)itk::DynamicLoader::GetSymbolAddress(lib, "FREECreateController");
        FREE_LINK_CENTRAL_FUNCTION pLinkFunction = (FREE_LINK_CENTRAL_FUNCTION)itk::DynamicLoader::GetSymbolAddress(lib, "FREELinkCentralAsDedicated");

        unsigned int iSymbolCount = 0;
        if (pListFunction!=NULL) iSymbolCount++;
        if (pLoadFunction!=NULL) iSymbolCount++;
        if (pLinkFunction!=NULL) iSymbolCount++;

        if (iSymbolCount == 3)
                                { 
          int iCtrlCount = 0;
          char** pControllerIDs = 0;
                                        
          TriggerControlEvent(2,"load components ("+fullpath+")...");

          (*pListFunction)(iCtrlCount,pControllerIDs);
                                        
          for (int index=0; index<iCtrlCount; index++)
                                        {
            char* pControllerID = pControllerIDs[index];
                                                if (!GetController(std::string(pControllerID)))
                                                {
                                                  GenericComponentController* pNewController = (*pLoadFunction)(pControllerID);
                                                  if (pNewController)
                                                  {
                                                          try
                                                          {
                                                                  ControllerCentral::RegisterController(pNewController);
                                                                  m_LibraryHandles->push_back((void*)lib);
                                                          }
                                                          catch (ControllerException& e)
                                                          {
                  logException.AddEntry("External DLL error: "+std::string(e.what()));
                                                          };
                                                  }
              else logException.AddEntry("External DLL error: Controller missing. LoadController returns no controller for ControllerID:"+std::string(pControllerID));
                                          }
            else
            {
              logException.AddEntry("WARNING: Controller "+std::string(pControllerID)+" is already registered. Skip last one.");
              TriggerControlEvent(2,"WARNING: Controller "+std::string(pControllerID)+" is already registered. Skip last one.");
            }
          };

                                        if (pControllerIDs) delete [] pControllerIDs;

          if (!m_bControllersAreExternal)
          {
            (*pLinkFunction)(m_RegisteredControllers,
                             m_LibraryHandles,
                             m_fnOnControl,
                             m_fnOnBuild,
                             m_CtrlCallbacks,
                             m_CtrlProgress,
                             m_CallbackMutex,
                             m_ProgressMutex);
          }
          else
          {
            (*pLinkFunction)(m_RegisteredControllers,
                             m_LibraryHandles,
                             m_fnOnControl,
                             m_fnOnBuild,
                             m_CtrlCallbacks,
                             m_CtrlProgress,
                             m_GlobalCallbackMutex,
                             m_GlobalProgressMutex);
          }
                                }
        else if (iSymbolCount>0)
        {
          //dll seems some how corrupted, because some symbols have been found, but not all
          //needed to load controllers properly.
          if ( !pListFunction)
          {
            logException.AddEntry("External DLL error: DLL seems to be invalid because FREEGetControllerList symbol is missing.");
            TriggerControlEvent(2,"!!! WARNING: Invalid DLL ("+fullpath+"); FREEGetControllerList symbol is missing.");          
          }
          
          if ( !pLoadFunction)
          {
            logException.AddEntry("External DLL error: DLL seems to be invalid because FREECreateController symbol is missing.");
            TriggerControlEvent(2,"!!! WARNING: Invalid DLL ("+fullpath+"); FREECreateController symbol is missing.");          
          }
          
          if ( !pLinkFunction)
          {
            logException.AddEntry("External DLL error: DLL seems to be invalid because FREELinkCentralAsDedicated symbol is missing.");
            TriggerControlEvent(2,"!!! WARNING: Invalid DLL ("+fullpath+"); FREELinkCentralAsDedicated symbol is missing.");          
          }
        };
                        };
                };
        };
};


void
ControllerCentral::
ReHash()
{
  //After rehashing the central isn't dedicated any more, so
  //remove the pointer to the external event lists.
  m_ProgressMutex->Lock();
  if (m_bControllersAreExternal)
  {
    m_GlobalProgressMutex = 0;
    m_CtrlProgress = 0;
  }
  m_ProgressMutex->Unlock();

  m_CallbackMutex->Lock();
  if (m_bControllersAreExternal)
  {
    m_GlobalCallbackMutex = 0;
    m_CtrlCallbacks = 0;
  }
  m_CallbackMutex->Unlock();


  ControllerCentral::UnRegisterAllControllers();
  ControllerCentral::Initialize();
}


ControllerCentral::
ControllerCentral()
{
  ControllerCentral::Initialize();
}


ControllerCentral::
~ControllerCentral()
{
}

void
ControllerCentral::
RegisterController(GenericComponentController* pController)
{
  if (!m_RegisteredControllers) Initialize();
  if (!GetController(pController->ControllerID()))
  {
          m_RegisteredControllers->push_back(pController);
                TriggerControlEvent(1, pController->ControllerID() + " added", pController);
  }
        else
  {
    logException.AddEntry("WARNING: Try to register a controller that is already registered. ControllerID: "+std::string(pController->ControllerID()));
    TriggerControlEvent(2,"WARNING: Try to register a controller that is already registered. ControllerID: "+std::string(pController->ControllerID()));
  }
}

void
ControllerCentral::
UnRegisterController(GenericComponentController* pController)
{ 
  try
  {
    if (!m_bControllersAreExternal)
    {
      for (ControllerListType::iterator pos = m_RegisteredControllers->begin(); pos != m_RegisteredControllers->end(); pos++)
      {
        if ((*pos)==pController)
        {
          delete pController;
          m_RegisteredControllers->erase(pos);
          return;
        }
      }
    }
  }
  catchAllNPassStaticMacro("Unknown exception, while unregistering controller. ControllerID: " << pController->ControllerID());
}
  
void
ControllerCentral::
UnRegisterAllControllers()
{
  GenericComponentController* pController;
  std::string  sControllerName;

  if (!m_bControllersAreExternal)
  {

    try
    {
                  if (m_RegisteredControllers)
      {
        while ( m_RegisteredControllers->size()>0 )
        {
          sControllerName = "Unknown";
          pController = (*m_RegisteredControllers)[0];
          sControllerName = pController->ControllerID();
          m_RegisteredControllers->erase(m_RegisteredControllers->begin());

          delete pController;
        }

        delete m_RegisteredControllers;
      }
    }
    catchAllNPassStaticMacro("Unknown exception, while unregistering all controllers." << sControllerName);

    try
    {
      if (m_LibraryHandles)
      {
        while (m_LibraryHandles->size() > 0)
        {
          itk::DynamicLoader::CloseLibrary((itk::LibHandle)(*m_LibraryHandles)[0]);
          m_LibraryHandles->erase(m_LibraryHandles->begin());
        }

        delete m_LibraryHandles;
      }
    }
    catchAllNPassStaticMacro("Unknown exception while closing all all libraries.");
  }

  m_bControllersAreExternal = false;
  m_RegisteredControllers = NULL;
  m_LibraryHandles = NULL;
};

void
ControllerCentral::
UnRegisterCallbackEventList()
{
  if(m_CallbackMutex.IsNotNull()) m_CallbackMutex->Lock();
    if (!m_bControllersAreExternal)
    {
      try
      {
        if (m_CtrlCallbacks)
        {
          delete m_CtrlCallbacks;
        }
      }
      catchAllNPassStaticMacro("Unknown exception while deleting callback list.");
    }

    m_CtrlCallbacks = NULL;
  if(m_CallbackMutex.IsNotNull())   m_CallbackMutex->Unlock();
};

void
ControllerCentral::
UnRegisterProgressEventList()
{
  if(m_ProgressMutex.IsNotNull()) m_ProgressMutex->Lock();

    if (!m_bControllersAreExternal)
    {
      try
      {
        if (m_CtrlProgress)
        {
          delete m_CtrlProgress;
        }
      }
      catchAllNPassStaticMacro("Unknown exception while deleting progress event list.");
    }

    m_CtrlProgress = NULL;

  if(m_ProgressMutex.IsNotNull()) m_ProgressMutex->Unlock();
};

ControllerCentral::ControllerListType
ControllerCentral::
GetControllers()
{
  if (!m_RegisteredControllers) Initialize();

  return *m_RegisteredControllers;
};

GenericComponentController*
ControllerCentral::
GetController(const std::string&  sControllerName)
{
  if (!m_RegisteredControllers) Initialize();

  for( ControllerListType::iterator pos = m_RegisteredControllers->begin(); pos != m_RegisteredControllers->end(); pos++)
  {
    if ((*pos)->ControllerID()==sControllerName)
    {
      return (*pos);
    }
  }
  return NULL;
};

GenericComponentController*
ControllerCentral::
GetResponsibleController(const GenericComponentType* pComponent)
{
  if (!pComponent) return 0;
  if (!m_RegisteredControllers) Initialize();

  for( ControllerListType::iterator pos = m_RegisteredControllers->begin(); pos != m_RegisteredControllers->end(); pos++)
  {
    if ((*pos)->ControllerIsResponsible(pComponent)) return (*pos);
  }
  
  return 0;
};

void
ControllerCentral::
SetOnControlEvent(ProgressEventBase* pOnControl)
{
        m_fnOnControl = pOnControl;
};

void
ControllerCentral::
SetOnBuildEvent(ProgressEventBase* pOnBuild)
{
        m_fnOnBuild = pOnBuild;
};


void
ControllerCentral::
AddOnProgressEvent(ProgressCtrlEventBase* pOnProgress)
{
  m_ProgressMutex->Lock();
    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Lock();
      if ((!m_bControllersAreExternal)&&(!m_CtrlProgress)) m_CtrlProgress = new CtrlProgressListType;

      if (m_CtrlProgress)
      {
        m_CtrlProgress->push_back(ProgressCtrlEventBase::Pointer(pOnProgress));
      }
    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Unlock();
  m_ProgressMutex->Unlock();
};

void
ControllerCentral::
RemoveOnProgressEvent(ProgressCtrlEventBase* pOnProgress)
{
  m_ProgressMutex->Lock();

  if (m_CtrlProgress)
  {
    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Lock();

    CtrlProgressListType::iterator pos = m_CtrlProgress->begin();
    while (pos != m_CtrlProgress->end())
    { //roam through the whole list and remove all entries of the observer
      if ((*pos).GetPointer()==pOnProgress)
      {
        pos = m_CtrlProgress->erase(pos);
      }
      else
      {
        ++pos;
      }
    }

    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Unlock();
  }
  m_ProgressMutex->Unlock();
};

void
ControllerCentral::
ClearProgressEventList()
{
  m_ProgressMutex->Lock();

  if (m_CtrlProgress)
  {
    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Lock();
      m_CtrlProgress->clear();
    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Unlock();
  }

  m_ProgressMutex->Unlock();
};

void
ControllerCentral::
AddOnCallbackEvent(CallbackCtrlEventBase* pOnCallback)
{
  m_CallbackMutex->Lock();
    if (m_GlobalCallbackMutex) m_GlobalCallbackMutex->Lock();

      if ((!m_bControllersAreExternal)&&(!m_CtrlCallbacks))
      {
        m_CtrlCallbacks = new CtrlCallbackListType;
      }

      if (m_CtrlCallbacks)
      {
        m_CtrlCallbacks->push_back(CallbackCtrlEventBase::Pointer(pOnCallback));
      }

    if (m_GlobalCallbackMutex) m_GlobalCallbackMutex->Unlock();

  m_CallbackMutex->Unlock();
};

void
ControllerCentral::
RemoveOnCallbackEvent(CallbackCtrlEventBase* pOnCallback)
{
  m_CallbackMutex->Lock();

  if (m_CtrlCallbacks)
  {
    if (m_GlobalCallbackMutex) m_GlobalCallbackMutex->Lock();

    CtrlCallbackListType::iterator pos = m_CtrlCallbacks->begin();
    while (pos != m_CtrlCallbacks->end())
    { //roam through the whole list and remove all entries of the observer
      if ((*pos).GetPointer()==pOnCallback)
      {
        pos = m_CtrlCallbacks->erase(pos);
      }
      else
      {
        ++pos;
      }
    }

    if (m_GlobalCallbackMutex) m_GlobalCallbackMutex->Unlock();
  }

  m_CallbackMutex->Unlock();
};

void
ControllerCentral::
ClearCallbackList()
{
  m_CallbackMutex->Lock();

  if (m_CtrlCallbacks)
  {
    if (m_GlobalCallbackMutex) m_GlobalCallbackMutex->Lock();
      m_CtrlCallbacks->clear();
    if (m_GlobalCallbackMutex) m_GlobalCallbackMutex->Unlock();
  }

  m_CallbackMutex->Unlock();
};

bool
ControllerCentral::
TriggerControlEvent(const int iStatusID, const std::string& sComment, void* pSender, long threadID)
{
  if (m_fnOnControl.IsNotNull())
  {
    m_fnOnControl->Execute(iStatusID, sComment, pSender, threadID);
    return true;
  }
  return false;
};

bool
ControllerCentral::
TriggerBuildEvent(const int iStatusID, const std::string& sComment, void* pSender, long threadID)
{
  if (m_fnOnBuild.IsNotNull())
  {
    m_fnOnBuild->Execute(iStatusID, sComment, pSender, threadID);
    return true;
  }
  return false;
};

void
ControllerCentral::
TriggerControllerProgressEvent(const IDPath& senderID, const ProgressCtrlEventBase::StatusID status,
                                             const std::string& sComment,
                                             SessionComponentCache* pSender,
                                             long threadID)
{
  m_ProgressMutex->Lock();

  if (m_CtrlProgress)
  {
    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Lock();

    //check all limited events
    for (CtrlProgressListType::iterator pos = m_CtrlProgress->begin(); pos != m_CtrlProgress->end(); pos++)
    { //
      if ((*pos)->GetACR())
      {
        (*pos)->Execute(senderID,status,sComment,pSender,threadID);
      }
    }
    //now all non limited events
    for (CtrlProgressListType::iterator pos = m_CtrlProgress->begin(); pos != m_CtrlProgress->end(); pos++)
    { //
      if (!(*pos)->GetACR())
      {
        (*pos)->Execute(senderID,status,sComment,pSender,threadID);
      }
    }

    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Unlock();
  }

  m_ProgressMutex->Unlock();
};

bool
ControllerCentral::
TriggerControllerCallback(const IDPath& senderID, CallbackCtrlEventBase::CallbackType callbackID,
                                        void* pData, SessionComponentCache* pSender, long threadID)
{
  bool result = false;

  m_CallbackMutex->Lock();

  if (m_CtrlCallbacks)
  {
    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Lock();

      //check all limited events
      for (CtrlCallbackListType::iterator pos = m_CtrlCallbacks->begin(); pos != m_CtrlCallbacks->end(); pos++)
      { //
        if ((*pos)->GetACR())
        {
          if ((*pos)->Execute(senderID,callbackID,pData,pSender,threadID))
          {
            result = true;
            break;
          }
        }
      }
      //now all non limited events
      for (CtrlCallbackListType::iterator pos = m_CtrlCallbacks->begin(); pos != m_CtrlCallbacks->end(); pos++)
      { //
        if (!(*pos)->GetACR())
        {
          if ((*pos)->Execute(senderID,callbackID,pData,pSender,threadID))
          {
            result = true;
            break;
          }
        }
      }

    if (m_GlobalProgressMutex) m_GlobalProgressMutex->Unlock();
  }

  m_CallbackMutex->Unlock();

  return result;
};

} //end of namspace free

---