freControllerCollector.cxx

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: freControllerCollector.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 "freControllerCollector.h"
#include "freControllerCentral.h"
#include "freFileDispatch.h"

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

namespace FREE
{


ControllerCollectorInfo::ControllerCollectorInfo()
{
  m_ControllerID = "";
  m_ControllerStatus = ControllerCollectorInfo::CSActive;
  m_LibraryFile = "";
};

void
ControllerCollector::
LoadDynamicControllers()
{
#ifdef _WIN32
  char cPathSeparator = ';';
#else
  char cPathSeparator = ':';
#endif
  
  std::string sLoadPath = GetGeneralFREEPath();
  std::string sAutoLoadPath;
  
#ifndef _DEBUG
  //Auto load path should not be added in the debug version of f.r.e.e. to avoid
  //conflicts with any installations of release versions
        if (itksys::SystemTools::GetEnv(csFREEAutoLoadPath,sAutoLoadPath)) sLoadPath += cPathSeparator+sAutoLoadPath;
#endif

  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-startSeparatorPosition);
    ControllerCollector::LoadLibrariesInPath(CurrentPath.c_str());
    
    if(endSeparatorPosition == sLoadPath.size())
    {
      startSeparatorPosition = std::string::npos;
    }
    else
    {
      endSeparatorPosition++;
    }
  }
}


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


void
ControllerCollector::
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 = FileDispatch::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");

        if (pListFunction)
                                { 
          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];
            ControllerCollectorInfo::Pointer smpInfo = ControllerCollectorInfo::New();
            
            smpInfo->SetControllerID(std::string(pControllerID));
            smpInfo->SetLibraryFile(fullpath);
            if (this->m_Controllers.find(std::string(pControllerID)) != this->m_Controllers.end())
                                                { //already loaded so ignore this controller
              smpInfo->SetControllerStatus(ControllerCollectorInfo::CSIgnored);
            }
            
            typedef std::pair<std::string,ControllerCollectorInfo::Pointer> ListPair;
            this->m_Controllers.insert(ListPair(smpInfo->GetControllerID(),smpInfo));

          };

                                        if (pControllerIDs) delete [] pControllerIDs;
                                }
                        };
                };
        };
};


ControllerCollector::
ControllerCollector()
{
  this->m_fnOnControl = NULL;
  this->m_Controllers.clear();
}

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

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

void
ControllerCollector::
Initialize()
{
  try
  {
    this->m_Controllers.clear();
    this->LoadDynamicControllers();
  }
  catchAllNPassStaticMacro("Unknown Exception, while initializing free::ControllerCollector.");
};

} //end of namspace free

---