/*=========================================================================
                                                                                
Program:   bbtk
Module:    $RCSfile: bbtkFactory.cxx,v $
Language:  C++

Date:      $Date: 2008/01/22 15:02:00 $
Version:   $Revision: 1.1 $
                                                                                

Copyright (c) CREATIS (Centre de Recherche et d'Applications en Traitement de
l'Image). All rights reserved. See doc/license.txt or
http://www.creatis.insa-lyon.fr/Public/bbtk/License.html 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.

=========================================================================*/
/**
 *\file
 *\brief  Class bbtk::Factory : can load and unload dynamic libraries containing 
 *        black boxes packages and create instances of the black boxes registered 
 *       in the packages loaded.
 */
#include "bbtkFactory.h"
#include "bbtkMessageManager.h"
#include "bbtkConnection.h"
#include "bbtkConfigurationFile.h"

#include <sys/stat.h> // for struct stat stFileInfo

#if defined(_WIN32)
#include <direct.h> // for getcwd
#endif


// was in gdcm ...
/*
#ifdef _MSC_VER
#   define getcwd _getcwd
#endif

#if defined(_MSC_VER) || defined(__BORLANDC__)
#   include <direct.h>
#else
#   include <unistd.h>
#endif

*/


namespace bbtk
{
  typedef Package* (*PackageAccessor)();
  typedef void (*PackageDeleteFunction)();


  //===================================================================
  /// Default ctor
  Factory::Factory()
  {
    bbtkDebugMessage("Core",7,"Factory::Factory()"<<std::endl);
  }
  //===================================================================

  //===================================================================
  /// Dtor
  Factory::~Factory()
  {
    bbtkDebugMessageInc("Core",7,"Factory::~Factory()"<<std::endl);
    CloseAllPackages();
    bbtkDebugDecTab("Core",7);
  }
  //===================================================================


  //===================================================================
  void Factory::CloseAllPackages()
  {
    bbtkDebugMessageInc("Core",7,"Factory::CloseAllPackages()"<<std::endl);
    while (mPackageMap.begin() != mPackageMap.end())
      {
        PackageMapType::iterator i = mPackageMap.begin();
        ClosePackage(i);
      }
    bbtkDebugDecTab("Core",7);
  }
  //===================================================================

  //===================================================================
  void Factory::Reset()
  {
    bbtkDebugMessageInc("Core",7,"Factory::Reset()"<<std::endl);
    CloseAllPackages();
    bbtkDebugDecTab("Core",7);
  }
  //===================================================================

// --> usefull in many places (at least : ConfigurationFile, Factory, Interpreter)
// should be factorized ( "bbtk::Util class ?)
/*
bool Factory::FileExists(std::string strFilename)
bool Factory::IsAtRoot(std::string cwd)
std::string Factory::ExtractPackageName(const std::string  &name)
std::string Factory::ExpandLibName(const std::string &name, bool verbose)
std::string Factory::MakeLibnameFromPath(std::string path, std::string pkgname)
bool Factory::CheckIfLibraryContainsPackage(std::string libname,std::string pkgname, bool verbose)
*/

// See : http://www.techbytes.ca/techbyte103.html for more O.S.
bool Factory::FileExists(std::string strFilename) {
  struct stat stFileInfo;
  bool blnReturn;
  int intStat;

  // Attempt to get the file attributes
  intStat = stat(strFilename.c_str(),&stFileInfo);
  if(intStat == 0) {
    // We were able to get the file attributes
    // so the file obviously exists.
    blnReturn = true;
  } else {
    // We were not able to get the file attributes.
    // This may mean that we don't have permission to
    // access the folder which contains this file. If you
    // need to do that level of checking, lookup the
    // return values of stat which will give you
    // more details on why stat failed.
    blnReturn = false;
  }

  return(blnReturn);
}
  
// ===================================================================================

  std::string Factory::ExtractPackageName(const std::string  &name, 
					  std::string& path)
  {
    std::string pkgname;
    path = "";

    std::string::size_type slash_position = name.find_last_of("/\\");
    if (slash_position != std::string::npos) 
      {
	pkgname = name.substr(slash_position+1,std::string::npos);   
	path = name.substr(0,slash_position); 
	//	std::cout << "F:P='"<<path<<"'"<<std::endl;//+1,std::string::npos); 
      } 
    else 
      {
	pkgname = name;  
      }      
          
    // remove {.so | dll} if any
    std::string::size_type dot_position = pkgname.find_last_of('.');      
    if (dot_position != std::string::npos){
      pkgname = pkgname.substr(0,dot_position);
    }      
#if defined(__GNUC__)
    
    // GCC mechanism
    // shared lib name = libbb<name>.so

      // remove {libbb} if any
    if (memcmp ( pkgname.c_str(), "libbb", 5) == 0) {
      pkgname =  pkgname.substr(5, pkgname.length());
    }
      /*
      /// \ \todo     what would happen if (stupid) user names his package 'libbb' ?!?
      /// \ --> Should be forbidden!
      */
#elif defined(_WIN32)

       // WIN 32 mechanism
       // shared lib name = <name>.dll

     // remove {bb} if any
    if (memcmp (pkgname.c_str(), "bb", 2) == 0) {
       pkgname =  pkgname.substr(2, pkgname.length());  
    } 
         
     /*
     /// \ \todo     what would happen if (stupid) user names his package 'bb' ?!?
     /// \ --> Should be forbidden!
     */
#else
    bbtkError("neither __GNUC__ nor _WIN32 ?!? How did you compile ?");
#endif      
    return pkgname;
  }
  
// ===================================================================================

  std::string Factory::ExpandLibName(const std::string &name, bool verbose)
  {
     // -----   Think of expanding path name ( ./ ../ ../../ )

    char buf[2048]; // for getcwd
    char * currentDir = getcwd(buf, 2048);
    std::string cwd(currentDir);
    std::string libname(name);
    
    // tooHigh : true is user supplies a library pathname with too many "../"
    bool tooHigh = false;

    if ( name[0] == '/' ||  name[0] == '\\' )
    {

      return(libname);
    } 
    else if  (name[0] == '.' && (name[1] == '/' || name[1] == '\\') ) 
    {
      libname = cwd  + ConfigurationFile::GetInstance().Get_file_separator () + name.substr(2, name.length());
      return(libname);  
    } 
    else if ( name[0] == '.' &&  name[1] == '.' && (name[2] == '/' || name[2] == '\\') ) 
    {       
      if ( IsAtRoot(cwd) )  // hope it gets / (for Linux),  C: D: (for Windows)
      {  
     // if we are already at / or c: --> hopeless  
         if (verbose)
           std::cout << "   File path [" <<  name << "] doesn't exist" << std::endl;
         tooHigh = true;
      }
      else
      {
         // iterate on ../ and go up from the current working dir!
         std::string a(name); 
         bool alreadyProcessRoot = false;                
         for(;;) 
         { 
            std::string::size_type slash_position = cwd.find_last_of(ConfigurationFile::GetInstance().Get_file_separator ());
            if (slash_position != std::string::npos) {
              if (slash_position == 0)
               slash_position = 1;  
              cwd = cwd.substr(0,slash_position/*+1*/);
              a =  a.substr(3, name.length());  // remove ../  
              if (a == "" || alreadyProcessRoot)
              {
                if (verbose)
                  std::cout << "   File path [" <<  name << "] doesn't exist" << std::endl;
                tooHigh = true;
                break;
              }
              libname =  cwd;
              char c = cwd[cwd.size()-1];
              if (c != '/' && c != '\\' )
                libname += ConfigurationFile::GetInstance().Get_file_separator ();
              libname += a;
                          
              if ( a[0] != '.' ) // if . (probabely ../), loop again
                break;
               
              if (IsAtRoot(cwd))
                alreadyProcessRoot = true;                            
            }                  
         } // end iterating on ../
      }
      if (tooHigh)
         libname="";
//  std::cout << "=======================================3 libname [" << libname << "]" << std::endl;
         
      return (libname);
      
    }  // -----   End of expanding path name   ( ./ ../ ../../ )
    // avoid warnings
    return(""); // will never get here!
  } 
   
// ===================================================================================

  std::string Factory::MakeLibnameFromPath(std::string path, std::string pkgname)
  {
    std::string libname = path;
    char c = path[path.size()-1];    
#if defined(__GNUC__)
       if (c != '/')
          libname += "/libbb";
       libname += pkgname;
       libname += ".so";
         
#elif defined(_WIN32)
       if (c != '\\')
          libname = path+"\\bb";
       libname += pkgname;
       libname += ".dll";
#endif
    return libname;    
  }
   
// ===================================================================================


  bool  Factory::IsAtRoot(std::string cwd)
  {
    if ( cwd == "/"                             // hope it gets /     (for Linux)
        || (cwd.size() <= 3 && cwd[1] == ':') ) // hope it gets C: D: (for Windows)
      return (true);
    else
      return(false);
}
// ===================================================================================

  bool Factory::DoLoadPackage(std::string libname,
			      std::string pkgname, 
			      std::string path, 
			      bool verbose)
  {

#if defined(__GNUC__)

        void *handler;            
        handler = dlopen(libname.c_str(), 
                                     BBTK_RTLD_TIME | BBTK_RTLD_SCOPE );
        if (!handler)
        {
          if (verbose) {
            std::cout <<"[" <<libname<<"] can't be open" << std::endl;
            std::cout << "   " <<dlerror() << std::endl;
          }
          return false; // try next path
        }
      
        if (verbose)
          std::cout <<"   -->[" <<libname<<"] found" << std::endl;

      // Loads the Package accessor

        std::string getpackname(pkgname);
        getpackname += "GetPackage";
        void *getpack = dlsym(handler, getpackname.c_str());
        if (!getpack)
        {
          dlclose(handler);
          bbtkError("GetPackage : could not load package \""<<pkgname
                   <<"\" [symbol "<<getpackname<<"] :"<<dlerror());
        }

        // Verifies that the Package delete function is present
        std::string delfname(pkgname);
        delfname += "DeletePackage";
        void *delf = dlsym(handler, delfname.c_str());
        if (!delf)
        {
          dlclose(handler);
          bbtkError("DeletePackage : could not load package \""<<pkgname
                    <<"\" [symbol "<<delfname<<"] :"<<dlerror());
        } 

#elif defined(_WIN32)

        HINSTANCE handler;
     
        SetErrorMode(0);
        handler = LoadLibrary(libname.c_str());
        if (!handler){
          if (verbose)
            std::cout <<"   no handler for [" <<libname<<"];" << std::endl;     
          return false;// Problem with the found library
        }
        if (verbose)
          std::cout <<"   --->[" <<libname<<"] found" << std::endl;

    // Loads the Package accessor

        std::string getpackname(pkgname);
        getpackname += "GetPackage";
        void *getpack = GetProcAddress(handler, getpackname.c_str());
        if (!getpack)
        {
          FreeLibrary(handler);
          bbtkError("[1]could not load package \""<<pkgname
          <<"\" : "<<getpackname<<" symbol not found (is it a bbtk package lib ?)");
          // look how to get the error message on win
              //<<dlerror());

        }
        // Verifies that the Package delete function is present
        std::string delfname(pkgname);
        delfname += "DeletePackage";
        void *delf = GetProcAddress(handler, delfname.c_str());
        if (!delf)
        {
          FreeLibrary(handler);
          bbtkError("[2]could not load package \""<<pkgname
                     <<"\" : "<<delfname<<" symbol not found (is it a bbtk package lib ?)");
          // look how to get the error message on win
          //<<dlerror());
        } 
#else
        bbtkError("neither __GNUC__ nor _WIN32 ?!? How did you compile ?");
#endif   
  
    // Stores the package
        PackageInfoType pack;
        pack.mDynamicLibraryHandler = handler;
    // Invokes the accessor to the PackageUnit pointer
        pack.mPackage = ((PackageAccessor)getpack)();

        mPackageMap[pkgname] = pack;

    // Test bbtk build version ok
        if ( pack.mPackage->GetBBTKVersion() != bbtk::GetVersion() )
        {
          std::string v(pack.mPackage->GetBBTKVersion());
          UnLoadPackage(pkgname);
          bbtkError(" package build with bbtk version "
		    << v
		    << " whereas application build with version "
		    << bbtk::GetVersion());
        }

	std::string separator = 
	  ConfigurationFile::GetInstance().Get_file_separator ();
	//BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH)
	std::string docreldoc = separator + "packages" + separator + pkgname 
	  + separator + "bbdoc" + separator + "index.html";
	std::string reldoc = ".." + separator + ".." + separator 
	  + ".." + docreldoc;
	std::string doc = path + separator + ".." + separator
	  + BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH) 
	  + docreldoc; 
	std::cout << "doc='"<<doc<<"'"<<std::endl;
	
	pack.mPackage->SetDocURL(doc);
	pack.mPackage->SetDocRelativeURL(reldoc);
	
    //===================================================================
        bbtkMessage("Output",2,pack.mPackage->GetName()<<" "
           <<pack.mPackage->GetVersion()
           <<" (bbtk "
           <<pack.mPackage->GetBBTKVersion()<<") "
           <<pack.mPackage->GetAuthor() 
           <<std::endl);
        bbtkMessage("Output",2,pack.mPackage->GetDescription()<<std::endl);
    //===================================================================

        bbtkDebugDecTab("Core",7);
        return true;
  }

 //===================================================================
  /// \brief Loads a package.
  ///
  /// The name is the system-independant name of the package (the name of the instance of bbtk::Package).
  /// Tries to open the dynamic library :
  /// - "libbb<name>.so" for linux systems,
  /// - "bb<name>.dll" for windows systems.
  /// If it succeeds, then tries to load the symbols "<name>GetPackage" and "<name>DeletePackage".
  /// "<name>GetPackage" is called to get the pointer on the bbtk::Package of the library
  /// ("<name>DeletePackage" is not used, its presence is just checked before loading the package).

  /// now, filename is only the last name (no longer the full name!)
  /// it will be searched within *all* the paths given in bbtk_config.xml

  /// verbose = true (set by "config v") displays the loading process
  void Factory::LoadPackage( const std::string& name,
                             bool use_configuration_file, bool verbose)
  {
  // Note : in the following :
  // name : the user supplied name 
  //      - abreviated name    e.g.       pkg   pkg.so   libbpkg   libbbpkg.so 
  //      - relative full name e.g.       ./libbbpkg.so   ../../libbbpkg.so 
  //      - absolute full name e.g.       /home/usrname/proj/lib/libbbpkg.so
  //          same for Windows, with      c:, d: ...
  //
    bbtkDebugMessageInc("Core",7,"Factory::LoadPackage(\""<<name<<"\")"<<std::endl);    
    bbtkMessage("Debug",1,"Factory::LoadPackage(\""<<name<<"\")"<<std::endl);    
    bbtkMessage("Debug",1,"use_configuration_file [" 
		<< use_configuration_file << "]" << std::endl);
  
    std::vector<std::string> package_paths;
    std::string libname;  // full path library name
    std::string pkgname;  // e.g. libbb<pkgname>.so
    
    std::string upath;
    pkgname = ExtractPackageName(name,upath);

    bbtkMessage("Debug",1,"Package name ["<<pkgname<<"]"<<std::endl);
    bbtkMessage("Debug",1,"Package path ["<<upath<<"]"<<std::endl);

    // no loading package if already loaded
    PackageMapType::iterator iUnload;
    iUnload = mPackageMap.find(pkgname);
    if (iUnload != mPackageMap.end()) 
    {
      bbtkMessage("Output",2,"["<<pkgname<<"] already loaded"<<std::endl);
      return; 
    }
    
   // If path provided by user will be the first scanned : 
    // push it into vector of paths
    if (upath.length()>0) package_paths.push_back(upath);

    // Add the path of config file 
    if (use_configuration_file)
    {
      std::vector<std::string>::const_iterator pi;
      for (pi =ConfigurationFile::GetInstance().Get_package_paths().begin();
	        pi!=ConfigurationFile::GetInstance().Get_package_paths().end();
	      ++pi)
	     package_paths.push_back(*pi);
    }
 
   
    bool ok = false; 
    bool foundFile = false;    

    std::vector<std::string>::iterator i;
    for (i=package_paths.begin();i!=package_paths.end();++i)
      {
        foundFile = false;    
	     std::string path = *i;
	
	// we *really* want '.' to be the current working directory
        if (path == ".") {
          char buf[2048]; // for getcwd
          char * currentDir = getcwd(buf, 2048);
          std::string cwd(currentDir);        
          path = currentDir;
        }
	
        libname = MakeLibnameFromPath(path, pkgname);
	
	     bbtkMessage("Debug",2,"-> Trying to load ["<<libname<<"]"<<std::endl);

      // Check if library exists           
        if ( !FileExists(libname) )
        {
        // The following is *NOT* a debug time message :
        // It's a user intended message.
        // Please don't remove it.
	      if (verbose)
	         std::cout <<"   [" <<libname <<"] : doesn't exist" <<std::endl;
            continue;  // try next path
        }
        foundFile = true; 

      // Try to Load the library
         
        ok = DoLoadPackage( libname, pkgname, path, verbose);
        if (ok)
	     {
	        bbtkMessage("Debug",2,"   OK"<<std::endl);
	        break; // a package was found; we stop iterating
	     }
    } //------------------ // end for ( package_paths.begin();i!=package_paths.end() )
      //  }

    if( !ok )  // nothing was loaded
    {
      if (!foundFile)
      {
        bbtkError("could not find package ["<<pkgname<< "]");
      }
      else
      {
#if defined(__GNUC__)
        bbtkError("could not load package \""<< pkgname
                  <<"\" :" << std::endl << "   " <<dlerror());
#elif defined(_WIN32)
        bbtkError("could not load package \""<<pkgname
                 <<"\" : " << std::endl << "   " <<libname<<" not found");

    // look how to get the error message on win
    //<<dlerror());
    // it is the bordel !! (the bloody fucking bordel, you mean?)
    // look : http://msdn2.microsoft.com/en-us/library/ms680582.aspx
#endif
      }
    }
    bbtkMessage("Output",2,"[" << libname << "] loaded" << std::endl);

  }
    
  //===================================================================
  /// \brief UnLoads a package.
  ///
  /// The package must have been previously loaded by LoadPackage.
  /// If the entry is found in the map, calls ClosePackage
 void Factory::UnLoadPackage( const std::string& userSuppliedName )
  { 
    std::string path;
    std::string name = ExtractPackageName(userSuppliedName,path);
    bbtkDebugMessageInc("Core",7,"Factory::UnLoadPackage(\""
                       <<name<<"\")"<<std::endl);
  
    PackageMapType::iterator i;
    i = mPackageMap.find(name);
    if (i == mPackageMap.end()) 
    {
      bbtkError("cannot unload package \""<<name
                <<"\" : package not loaded !");
    }
    ClosePackage(i);
    bbtkDebugDecTab("Core",7);
  }
  //===================================================================


  //===================================================================
  /// \brief Close the package referenced by the iterator 
  ///
  /// If it is a dynamically loaded package 
  /// - Loads and calls the function "<name>DeletePackage" of the dynamic library (responsible for package desallocation)
  /// - Closes the dynamic library
  /// - Erases the package entry in the packages map
  ///
  /// Else simply erases the package entry in the packages map
  void Factory::ClosePackage(PackageMapType::iterator& i) 
  {   
     bbtkDebugMessageInc("Core",7,"Factory::ClosePackage(\""
                         <<i->second.mPackage->GetName()
                        <<"\")"<<std::endl);

     if (i->second.mDynamicLibraryHandler) 
     {
 
      // If it is a dynamically loaded package
      // Loads the Package delete function

        std::string delfname(i->second.mPackage->GetName());
        delfname += "DeletePackage";
#if defined(__GNUC__)     
        void *delf = dlsym(i->second.mDynamicLibraryHandler, delfname.c_str());
        if (!delf)
        {
           bbtkError("could not close package \""
                     <<i->second.mPackage->GetName()
                     <<"\" :"<<dlerror());
        }    
#elif defined(_WIN32)
        void *delf = GetProcAddress(i->second.mDynamicLibraryHandler, 
                                 delfname.c_str());
        if (!delf)
        {  
           bbtkError("could not close package \""
                <<i->second.mPackage->GetName()
                <<"\" : "<<delfname
                <<" symbol not found (how did you open it ???");
               //<<"\" :"<<dlerror());
        }    
#endif     

   // deletes the package
   ((PackageDeleteFunction)delf)();

   // closes the dl handler
#if defined(__GNUC__)  
    dlclose(i->second.mDynamicLibraryHandler);  
#elif defined(_WIN32)

    FreeLibrary(i->second.mDynamicLibraryHandler);
#endif
    }
    else 
    {  
       // If it is a manually inserted package 
       delete i->second.mPackage;
    }

    // remove the entry in the map
    mPackageMap.erase(i);
    bbtkDebugDecTab("Core",7);
 }
  //===================================================================



  //===================================================================  
  /// Displays the list of packages loaded
  void Factory::PrintPackages(bool details, bool adaptors) const
  {
    bbtkDebugMessageInc("Core",9,"Factory::PrintPackages"<<std::endl);

    PackageMapType::const_iterator i;
    for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
    {
      bbtkMessage("Help",1, i->first << std::endl);
      if (details) {
         i->second.mPackage->PrintBlackBoxes(false,adaptors);
      }
    }

    bbtkDebugDecTab("Core",9);
  }
  //===================================================================

  //===================================================================  
  /// Displays help on a package
  void Factory::HelpPackage(const std::string& name/* &userSuppliedName */, bool adaptors) const
  {
   // std::string name = ExtractPackageName(userSuppliedName);
    bbtkDebugMessageInc("Core",9,"Factory::HelpPackage(\""<<name<<"\")"
                        <<std::endl);

    PackageMapType::const_iterator i = mPackageMap.find(name);
    if ( i != mPackageMap.end() ) 
      {
      bbtkMessage("Help",1, "Package "<<i->first<<" ");
      if (i->second.mPackage->GetVersion().length()>0)
        bbtkMessageCont("Help",1,"v" <<i->second.mPackage->GetVersion());
      if (i->second.mPackage->GetAuthor().length()>0)
        bbtkMessageCont("Help",1,"- "<<i->second.mPackage->GetAuthor());
      bbtkMessageCont("Help",1,std::endl);
      bbtkIncTab("Help",1);
      bbtkMessage("Help",1,i->second.mPackage->GetDescription()<<std::endl);
      if (i->second.mPackage->GetNumberOfBlackBoxes()>0) 
        {
          bbtkMessage("Help",1, "Black boxes : "<<std::endl);
          i->second.mPackage->PrintBlackBoxes(true,adaptors);
        }
      else 
        {
          bbtkMessage("Help",1, "No black boxes"<<std::endl);
        }
      bbtkDecTab("Help",1);
      }
    else 
      {
      bbtkDebugDecTab("Core",9);
      bbtkError("package \""<<name<<"\" unknown");
      }
    
    bbtkDebugDecTab("Core",9);
  }
  //===================================================================

  //===================================================================
  /// Prints help on the black box of type <name>
  void Factory::HelpBlackBox(const std::string& name, bool full) const
  {
    bbtkDebugMessageInc("Core",9,"Factory::HelpBlackBox(\""<<name<<"\")"
                        <<std::endl);

    bool found = false;
    PackageMapType::const_iterator i;
    for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
      {
      if (i->second.mPackage->ContainsBlackBox(name)) 
        {
          i->second.mPackage->HelpBlackBox(name,full);
          found = true;
        }
      }
    
    bbtkDebugDecTab("Core",9);
    if (!found) 
      {
      bbtkError("No package of the factory contains any black box <"
                 <<name<<">");
      }
  }  
  //===================================================================


  //=================================================================== 
  /// Inserts a package in the factory
  void Factory::InsertPackage( Package* p )
  {
    bbtkDebugMessageInc("Core",9,"Factory::InsertPackage(\""<<
                        p->GetName()<<"\")"<<std::endl);

    PackageInfoType pack;
    pack.mDynamicLibraryHandler = 0;
    
    pack.mPackage = p;

    mPackageMap[p->GetName()] = pack;
    bbtkDebugDecTab("Core",9);
  }
  //===================================================================
  
  //=================================================================== 
  /// Removes a package from the factory (and deletes it)
  void Factory::RemovePackage( Package* p )
  {
    bbtkDebugMessageInc("Core",9,"Factory::RemovePackage(\""<<
                        p->GetName()<<"\")"<<std::endl);

    PackageMapType::iterator i;
    for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
      {
         if (i->second.mPackage == p) break;
      };
    
    if (i!=mPackageMap.end())
      {
      ClosePackage(i);
      }
    else 
      {
      bbtkError("Factory::RemovePackage(\""<<
                 p->GetName()<<"\") : package absent from factory");
      }

    bbtkDebugDecTab("Core",9);
  }
  //===================================================================
  

  //===================================================================
  /// Creates an instance of a black box of type <type> with name <name>
  BlackBox* Factory::NewBlackBox(const std::string& type, 
                                 const std::string& name) const
  {
    bbtkDebugMessageInc("Core",7,"Factory::NewBlackBox(\""
                        <<type<<"\",\""<<name<<"\")"<<std::endl);

    BlackBox* b = 0; 
    PackageMapType::const_iterator i;
    for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
      {
      b = i->second.mPackage->NewBlackBox(type,name);
      if (b) break; 
      }
    if (!b) 
      {
       bbtkError("black box type \""<<type<<"\" unknown");
      } 

    bbtkDebugDecTab("Core",7);
    return b;
  }
  //===================================================================

  //===================================================================
  /// Creates an instance of a black box of type <type> with name <name>
  BlackBox* Factory::NewAdaptor(TypeInfo typein,
                     TypeInfo typeout,
                     const std::string& name) const
  {
    bbtkDebugMessageInc("Core",8,"Factory::NewAdaptor(<"
                        <<TypeName(typein)<<">,<"
                        <<TypeName(typeout)<<">,\""
                        <<name<<"\")"<<bbtkendl);


    BlackBox* b = 0; 
    PackageMapType::const_iterator i;
    for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
      {
      b = i->second.mPackage->NewAdaptor(typein,typeout,name);
      if (b) break; 
      }
    if (!b) 
      {
      bbtkError("no <"
          <<TypeName(typein)<<"> to <"
          <<TypeName(typeout)
          <<"> adaptor available");
      } 
    
    bbtkDebugDecTab("Core",7);
    return b; 
  }
  //===================================================================

  //===================================================================
  /// Creates an instance of a connection
  Connection* Factory::NewConnection(BlackBox* from,
                                     const std::string& output,
                                     BlackBox* to,
                                     const std::string& input) const
  {
    bbtkDebugMessage("Core",7,"Factory::NewConnection(\""
                      <<from->bbGetName()<<"\",\""<<output<<"\",\""
                      <<to->bbGetName()<<"\",\""<<input
                      <<"\")"<<std::endl);
    
    return new Connection(from,output,to,input);
    /*  
       Connection* c;
    // !!! WARNING : WE NEED TO TEST THE TYPE NAME EQUALITY 
    // BECAUSE IN DIFFERENT DYN LIBS THE type_info EQUALITY CAN 
    // BE FALSE (DIFFERENT INSTANCES !)
  
    std::string t1 ( from->bbGetOutputType(output).name() );
    std::string t2 ( to->bbGetInputType(input).name() );


    if ( t1 == t2 ) 
       //from->bbGetOutputType(output) ==
       // to->bbGetInputType(input) )
      {
         c = new Connection(from,output,to,input);
      }
    else 
      {
         //   std::cout << "Adaptive connection "<<std::endl;
         std::string name;
         name = from->bbGetName() + "." + output + "-" 
                                  + to->bbGetName() + "." + input; 

         BlackBox* b = 0; 
         PackageMapType::const_iterator i;
         for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
         {
             b = i->second.mPackage->NewAdaptor(from->bbGetOutputType(output),
                                                  to->bbGetInputType(input),
                                                  name);
             if (b) break; 
         } 
         if (!b)  
         {  
            bbtkError("did not find any <"
                       <<TypeName(from->bbGetOutputType(output))
                       <<"> to <"
                       <<TypeName(to->bbGetInputType(input))
                       <<"> adaptor");
         } 
         c = new AdaptiveConnection(from,output,to,input,b);
      }
      bbtkDebugDecTab("Core",7);
    
      return c;
    */
  }
  //===================================================================



  //===================================================================
  const Package* Factory::GetPackage(const std::string& name) const
  {
    bbtkDebugMessageInc("Core",9,"Factory::GetPackage(\""<<name<<"\")"
                         <<std::endl);

    PackageMapType::const_iterator i = mPackageMap.find(name);
    if ( i != mPackageMap.end() ) 
    {
      bbtkDebugDecTab("Core",9); 
      return i->second.mPackage;
    }
    else 
    {
       bbtkDebugDecTab("Core",9);
       bbtkError("package \""<<name<<"\" unknown");
    }
    
    bbtkDebugDecTab("Core",9);  
  }
  //===================================================================
  
  //===================================================================
  Package* Factory::GetPackage(const std::string& name) 
  {
    bbtkDebugMessageInc("Core",9,"Factory::GetPackage(\""<<name<<"\")"
                         <<std::endl);

    PackageMapType::const_iterator i = mPackageMap.find(name);
    if ( i != mPackageMap.end() ) 
    {
      bbtkDebugDecTab("Core",9); 
      return i->second.mPackage;
    }
    else 
    {
       bbtkDebugDecTab("Core",9);
       bbtkError("package \""<<name<<"\" unknown");
    }
    
    bbtkDebugDecTab("Core",9);  
  }
  //===================================================================

  //===================================================================
  void Factory::WriteDotFilePackagesList(FILE *ff)
  {
    bbtkDebugMessageInc("Core",9,"Factory::WriteDotFilePackagesList()"
                         <<std::endl);

    fprintf( ff , "\n");
    fprintf( ff , "subgraph cluster_FACTORY {\n");
    fprintf( ff , "  label = \"PACKAGES\"%s\n",  ";");
    fprintf( ff , "  style=filled%s\n",";");
    fprintf( ff , "  color=lightgrey%s\n",";");
    fprintf( ff , "  rankdir=TB%s\n",";");

    PackageMapType::const_iterator i;
    for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
    {
       std::string url = GetPackage(i->first)->GetDocURL();
       fprintf(ff,"  %s [shape=ellipse, URL=\"%s\"]%s\n",
	       i->first.c_str(),
	       url.c_str(),";" );
    }
    fprintf( ff , "}\n\n");
    bbtkDebugDecTab("Core",9);
  }
  //===================================================================


  void Factory::ShowGraphTypes(const std::string& name) const
  {
    bool found = false;
    PackageMapType::const_iterator i;
    for (i = mPackageMap.begin(); i!=mPackageMap.end(); ++i )
      {
	if (i->second.mPackage->ContainsBlackBox(name)) 
	  {
	    std::string separator = ConfigurationFile::GetInstance().Get_file_separator ();
	    
            // Don't pollute the file store with  "doc_tmp" directories ...    
	    std::string default_doc_dir = ConfigurationFile::GetInstance().Get_default_doc_tmp();
	    std::string directory = "\"" + default_doc_dir + separator + "doc_tmp"  +separator + "\"";
	    std::string filename2 =  default_doc_dir + separator + "doc_tmp" + separator + "tmp.html"; 
	    
#if defined(_WIN32)  
	    std::string command("start \"Titre\" /D ");
#else 
	    std::string command("gnome-open ");
#endif
	    command=command + directory +" tmp.html";
	    FILE *ff;
	    ff=fopen(filename2.c_str(),"w");
	    
	    fprintf(ff,"<html><head><title>TMP</title> <script type=\"text/javascript\"> <!--\n");
	    fprintf(ff,"  window.location=\"%s#%s\";\n" , i->second.mPackage->GetDocURL().c_str(),name.c_str() );
	    fprintf(ff,"//--></script></head><body></body></html>\n");
	    
	    
	    //fprintf(ff, "<a  href=\"%s#%s\">Link</a>\n", i->second.mPackage->GetDocURL().c_str(),name.c_str() );
	    fclose(ff);
	    system( command.c_str() );      
	    found = true;
	  }
      }
    
    bbtkDebugDecTab("Core",9);
    if (!found) 
      {
	bbtkError("No package of the factory contains any black box <"
		  <<name<<">");
      }
  }

}