bbtkPackage.cxx

Go to the documentation of this file.

/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkPackage.cxx,v $
  Language:  C++
  Date:      $Date: 2008/10/17 08:21:44 $
  Version:   $Revision: 1.23 $
=========================================================================*/

/* ---------------------------------------------------------------------

* Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
* Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
*
*  This software is governed by the CeCILL-B license under French law and 
*  abiding by the rules of distribution of free software. You can  use, 
*  modify and/ or redistribute the software under the terms of the CeCILL-B 
*  license as circulated by CEA, CNRS and INRIA at the following URL 
*  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html 
*  or in the file LICENSE.txt.
*
*  As a counterpart to the access to the source code and  rights to copy,
*  modify and redistribute granted by the license, users are provided only
*  with a limited warranty  and the software's author,  the holder of the
*  economic rights,  and the successive licensors  have only  limited
*  liability. 
*
*  The fact that you are presently reading this means that you have had
*  knowledge of the CeCILL-B license and that you accept its terms.
* ------------------------------------------------------------------------ */                                                                         

#include "bbtkPackage.h"
#include "bbtkMessageManager.h"
#include "bbtkConfigurationFile.h"
#include <fstream>
#include <time.h>
#include "bbtkUtilities.h"

namespace bbtk
{
  


  //==========================================================================
  Package::Pointer Package::New(const std::string& name,
                                const std::string& author,
                                const std::string& description,
                                const std::string& version,
                                const std::string& BBTKVersion) 
  {
    bbtkDebugMessage("object",1,"##> Package::New('"<<name<<"',...)"
                     <<bbtkendl);
    Package::Pointer p = MakePointer(new Package(name,
                                               author,
                                               description,
                                               version,
                                               BBTKVersion));
    bbtkDebugMessage("object",2,"<## Package::New('"<<name<<"',...)"
                     <<bbtkendl);
    return p;
  }
  //==========================================================================

  //==========================================================================
  Package::Package(const std::string& name,
                   const std::string& author,
                   const std::string& description,
                   const std::string& version,
                   const std::string& BBTKVersion) 
    :
    mDynamicLibraryHandler(0),
    mName(name),
    mAuthor(author),
    mDescription(description),
    mVersion(version)
  {
    bbtkDebugMessage("object",2,"==> Package::Package('"<<name<<"',...)"
                     <<bbtkendl);
    std::string default_doc_dir = ConfigurationFile::GetInstance().Get_default_temp_dir();
    char c = default_doc_dir.c_str()[strlen(default_doc_dir.c_str())-1];
    std::string url = default_doc_dir; 
    if (c != '/' && c !='\\') url = url + "/";
    url = url +  "temp_dir/" + name + "/index.html";    
    
    SetDocURL(url);
    SetDocRelativeURL("Relative url not set");

    /*
    std::string relurl(BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH));
    relurl += "/packages/"+name+"/bbdoc/index.html";
    std::string url = ConfigurationFile::GetInstance().Get_url()
      + relurl; 
    SetDocURL(url);
    SetDocRelativeURL(relurl);   
    */

    //    std::cout  << "   url=["<<url<<"]"<<std::endl;
    //    std::cout  << "relurl=["<<relurl<<"]"<<std::endl;
    bbtkDebugMessage("object",2,"<== Package::Package('"<<name<<"',...) OK"
                     <<bbtkendl);

  }
  //==========================================================================



  //==========================================================================
  Package::~Package()
  {
    bbtkDebugMessage("object",2,"==> Package::~Package(\""<<mName<<"\")"<<bbtkendl);
    bbtkDebugMessage("object",2,"<== Package::~Package(\""<<mName<<"\")"<<bbtkendl);
  }
  //==========================================================================


  //==========================================================================
  void PackageReleaseBlackBoxDescriptorInternal(Package::WeakPointer pack,
                                                const std::string& descname)
  {
    // Try to release descriptor
    std::string packname = pack.lock()->GetName();

    bbtkDebugMessage("package",5,"--- Releasing descriptor '"
                     <<packname<<"::"<<descname<<"'"<<bbtkendl);


    Package::BlackBoxMapType::iterator desc = 
      pack.lock()->GetBlackBoxMap().find(descname);
    if (desc ==  pack.lock()->GetBlackBoxMap().end())
      {
        bbtkDebugMessage("package",5,
                         "    Descriptor has already been released"
                         <<bbtkendl);
        return;
      }
    //    bbtkDebugMessage("package",3,
    //               "    Trying unreferencing it ... "<<std::endl);
    BlackBoxDescriptor::WeakPointer pdesc = desc->second;
    desc->second.reset();
    // if it is dead : remove it 
    if (pdesc.expired()) 
      {
        bbtkDebugMessage("package",2," ==> '"<<packname<<"::"<<descname<<"' Descriptor expired"<<bbtkendl);
        if (pack.expired()) 
          {
            bbtkDebugMessage("package",2,
                             "     ... and caused its package death"
                             <<bbtkendl);
            return;
          }
        desc = pack.lock()->GetBlackBoxMap().find(descname);
        if (desc !=  pack.lock()->GetBlackBoxMap().end())
          pack.lock()->GetBlackBoxMap().erase(desc);
      }
    else 
      {
        bbtkDebugMessage("package",5,"    ... Descriptor still alive ("
                         <<pdesc.use_count()<<" refs)"
                         <<bbtkendl);
        pack.lock()->GetBlackBoxMap()[descname] = pdesc.lock();
      }
  }
  //==========================================================================


  //==========================================================================
  void Package::Release(Package::WeakPointer pack)
  {
    std::string packname = pack.lock()->mName;
    bbtkDebugMessage("package",1,"==> Package::Release('"<<
                     packname<<"')"<<bbtkendl);

    long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0; 
    long ndesc = pack.lock()->GetBlackBoxMap().size();
    long nrefs = pack.use_count();

    bbtkDebugMessage("package",5," "<<nrefs<<" refs / "
                     <<ndesc<<" descr / dyn="
                     <<dyn<<std::endl);

    // A package is "free" from any external reference iff :
    // i) It is not dynamically loaded and nrefs == ndesc 
    // (each desc references its package) or
    // ii) It is dynamically loaded and nrefs == ndesc + 1
    // (A dynamic library holds a static pointer on the package it contains
    //  which is allocated when the PACKAGENAMEGetPackage() func is called,
    //  and descallocated (reset) by PACKAGENAMEDeletePackage())
    if (nrefs == ndesc + dyn) 
      {
        bbtkDebugMessage("package",5,
                         " -> No more external ref : checking descriptors"
                         <<bbtkendl);
        // We must take care that removing refs on descriptors 
        // can lead to their deletion which can in turn unref 
        // internal boxes which can release their descriptors hence 
        // call Package::ReleaseBlackBoxDescriptor 
        // As a consequence during descriptors release :
        // 1) The map can change dynamically : we cannot iterate over it 
        //    as any iterator can become invalid
        // 2) The package can auto-destruct : we must test its existence 
        //    after each release
        // We must also take care of not locking the package pointer 
        // or any ref count check in Package::ReleaseBlackBoxDescriptor
        // would be wrong

        // The list of descriptors names at start
        std::vector<std::string> descnamelist;
        BlackBoxMapType::iterator i;
        for (i=pack.lock()->mBlackBoxMap.begin();
             i!= pack.lock()->mBlackBoxMap.end();
             ++i)
          descnamelist.push_back(i->first);

        // Iterator over the initial names
        std::vector<std::string>::iterator descname;
        for (descname=descnamelist.begin();
             descname!=descnamelist.end();
             ++descname)
          {
            // Is package still alive ?
            if (pack.expired()) 
              {
                bbtkDebugMessage("package",1,"--- Package::Release('"<<
                                 packname
                                 <<"') : package expired during release : bailing out"<<bbtkendl);
                break;
              }
            
            PackageReleaseBlackBoxDescriptorInternal(pack,*descname);
            
          }

        //
        UnLoadDynamicLibrary(pack);
        // Unload orphan dl packages 
        Package::UnLoadReleasedDynamicallyLoadedPackages();
        

        
        
      }
    
#ifdef BBTK_COMPILE_DEBUG_MESSAGES

    bbtkDebugMessage("package",2,"<== Package::Release('"<<
                     packname<<"')"<<bbtkendl);

    if (!pack.expired())
      {
        long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0; 
        long ndesc = pack.lock()->GetBlackBoxMap().size();
        long nrefs = pack.use_count();
        
        bbtkDebugMessage("package",1," ... Package still alive ("
                         <<nrefs<<" refs / "
                         <<ndesc<<" descr / dyn="
                         <<dyn<<")"<<std::endl);
      }
    else 
      {
        bbtkDebugMessage("package",1," ... Package has been released"
                         <<std::endl);
      }
#endif
  }
  //==========================================================================

  //==========================================================================
  void Package::ReleaseBlackBoxDescriptor(Package::WeakPointer pack,
                                          BlackBoxDescriptor::WeakPointer descr)
  {
    std::string packname = pack.lock()->mName;
    std::string dname = descr.lock()->GetTypeName();    
    bbtkDebugMessage("package",3,"==> Package::ReleaseBlackBoxDescriptor('"<<
                     packname<<"','"<<dname<<"') : refs="
                     <<descr.use_count()<<bbtkendl);

    long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0; 
    long ndesc = pack.lock()->GetBlackBoxMap().size();
    long nrefs = pack.use_count();

    bbtkDebugMessage("package",5," "<<nrefs<<" refs / "
                     <<ndesc<<" descr / dynamically loaded = "
                     <<dyn<<std::endl);

    // A package is "free" from any external reference iff :
    // i) It is not dynamically loaded and nrefs == ndesc 
    // (each desc references its package) or
    // ii) It is dynamically loaded and nrefs == ndesc + 1
    // (A dynamic library holds a static pointer on the package it contains
    //  which is allocated when the PACKAGENAMEGetPackage() func is called,
    //  and descallocated (reset) by PACKAGENAMEDeletePackage())
    if (nrefs == ndesc + dyn) 
      {
        PackageReleaseBlackBoxDescriptorInternal(pack,dname);
      }
    
    // If the package is released and dynamically loaded 
    // then put it in the static list mReleasedDynamicallyLoadedPackages
    UnLoadDynamicLibrary(pack,false);
        
    bbtkDebugMessage("package",4,"<== Package::ReleaseBlackBoxDescriptor('"<<
                     packname<<"','"<<dname<<"'): refs="
                     <<descr.use_count()<<bbtkendl);
    /*
    if (!pack.expired())
      {
        long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0; 
        long ndesc = pack.lock()->GetBlackBoxMap().size();
        long nrefs = pack.use_count();
        
        bbtkDebugMessage("package",3," ... Package still alive ("
                         <<nrefs<<" refs / "
                         <<ndesc<<" descr / dyn="
                         <<dyn<<")"<<std::endl);
      }
    else 
      {
        bbtkDebugMessage("package",3,"   ... Package has been released"
                         <<std::endl);
      }  
    */
  }
  //==========================================================================    

  //==========================================================================
  DynamicLibraryHandler Package::OpenDynamicLibrary
  ( const std::string& libname,
    const std::string& package_name,
    DLGetPackageFunction& getpack,
    DLDeletePackageFunction& delpack)
  {
    bbtkDebugMessage("package",3,"==> Package::OpenDynamicLibrary("
                     <<libname<<")"<<std::endl);
#if defined(__GNUC__)

    // Open shared lib
    void *handler;
    handler = dlopen(libname.c_str(),
                     BBTK_RTLD_TIME | BBTK_RTLD_SCOPE );
    if (!handler)
      {
        bbtkMessage("package",2,
                    "Could not open shared library [" <<libname<<"] : "
                    <<dlerror() << std::endl);
        return 0;
      }

    bbtkDebugMessage("package",3,"* Shared lib ["<<libname<<"] open"<<std::endl);

    // Loads the Package bbtk version function 
    std::string getvername(package_name);
    getvername += 
      BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_BBTK_VERSION_FUNCTION_NAME);
    DLGetPackageBBTKVersionFunction getbbtkversion 
      = (DLGetPackageBBTKVersionFunction)(dlsym(handler,getvername.c_str()));
    if (!getbbtkversion)
      {
        bbtkDebugMessage("package",3,"***"<<std::endl);
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] is not a valid bbtk package."
                    <<" Symbol ["<<getvername<<"] :"<<dlerror()<< std::endl);
        dlclose(handler);
        return 0;
      }

    bbtkDebugMessage("package",3,"* Symbol ["<<getvername
                     <<"] found"<<std::endl);
    // version matches ?
    if (getbbtkversion() != bbtk::GetVersion())
      {
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] was build with bbtk version "
                    <<getbbtkversion()
                    <<" but the current program runs with version "
                    <<bbtk::GetVersion()<<" : cannot load it"<<std::endl);
        dlclose(handler);
        return 0;
        
      }

    bbtkDebugMessage("package",3,"* Package bbtk version '"<<getbbtkversion()<<"' matches"<<std::endl);
            // Loads the Package get function
    std::string getpackname(package_name);
    getpackname += BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_FUNCTION_NAME);
    getpack = (DLGetPackageFunction)(dlsym(handler, getpackname.c_str()));
    if (!getpack)
      {
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] is not a valid bbtk package."
                    <<" Symbol ["<<getpackname<<"] :"<<dlerror()<< std::endl);
        dlclose(handler);
        return 0;
      }
  
    bbtkDebugMessage("package",3,"* Symbol ["<<getpackname<<"] found"<<std::endl);
    // Loads the Package delete function
                                          
    std::string delpackname(package_name);
    delpackname += BBTK_STRINGIFY_SYMBOL(BBTK_DEL_PACKAGE_FUNCTION_NAME);
    delpack = (DLDeletePackageFunction)(dlsym(handler, delpackname.c_str()));
    if (!delpack)
      {
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] is not a valid bbtk package."
                    <<" Symbol ["<<delpackname<<"] :"<<dlerror()<< std::endl);
        dlclose(handler);
        return 0;
      }
    bbtkDebugMessage("package",3,"* Symbol ["<<delpackname<<"] found"<<std::endl);                
#elif defined(_WIN32)
    
    HINSTANCE handler;
    
    SetErrorMode(0);
    // Open shared lib
    handler = LoadLibrary(libname.c_str());
    if (!handler)
      {
        bbtkMessage("package",2,
                    "Could not open shared library [" <<libname<<"]"
                    << std::endl);
        DWORD dwErrorCode = 0;
        dwErrorCode = GetLastError();
        bbtkMessage("package",2,
                "Windows Error: [" << dwErrorCode <<"]"
                << std::endl);
         
        return 0;
      }
    
    // Loads the Package bbtk version function 
    std::string getvername(package_name);
    getvername += 
      BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_BBTK_VERSION_FUNCTION_NAME);
    DLGetPackageBBTKVersionFunction getbbtkversion 
      = (DLGetPackageBBTKVersionFunction)(GetProcAddress(handler,
                                                        getvername.c_str()));
    if (!getbbtkversion)
      {
        FreeLibrary(handler);
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] is not a valid bbtk package."
                    <<" Symbol ["<<getbbtkversion<<"] not found"<< std::endl);
        return 0;
      }
    
    // version matches ?
    if (getbbtkversion() != bbtk::GetVersion())
      {
        FreeLibrary(handler);
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] was build with bbtk version "
                    <<getbbtkversion()
                    <<" but the current program runs with version "
                    <<bbtk::GetVersion()<<" : cannot load it"<<std::endl);
        return 0;
        
      }

     // Loads the Package get function
    std::string getpackname(package_name);
    getpackname += BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_FUNCTION_NAME);
    getpack = (DLGetPackageFunction)(GetProcAddress(handler, getpackname.c_str()));
    if (!getpack)
      {
        FreeLibrary(handler);
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] is not a valid bbtk package."
                    <<" Symbol ["<<getpackname<<"] not found"<< std::endl);
        return 0;
      }
    
    // Loads the Package delete function
    std::string delpackname(package_name);
    delpackname += BBTK_STRINGIFY_SYMBOL(BBTK_DEL_PACKAGE_FUNCTION_NAME);
    delpack = (DLDeletePackageFunction)(GetProcAddress(handler, delpackname.c_str()));
    if (!delpack)
      {
        FreeLibrary(handler);
        bbtkMessage("package",2,
                    "Shared library ["<<libname
                    <<"] is not a valid bbtk package."
                    <<" Symbol ["<<delpackname<<"] not found"<< std::endl);
        return 0;
      }
                                         
#else
    bbtkError("neither __GNUC__ nor _WIN32 ?!? How did you compile ?");
#endif
    
    return handler;
  }
  //==========================================================================
  
  //==========================================================================
  Package::Pointer Package::CreateFromDynamicLibrary(const std::string& libname,
                                                     const std::string& pkgname,
                                                     const std::string& path)
  {
    bbtkDebugMessage("package",1,"==> Package::CreateFromDynamicLibrary("
                     <<libname<<")"<<std::endl);

    DLGetPackageFunction gf;
    DLDeletePackageFunction df;
    DynamicLibraryHandler h = Package::OpenDynamicLibrary(libname,
                                                          pkgname,
                                                          gf,df);
    if (h==0) return Package::Pointer(); 
    Package::Pointer p = gf();
    p->mDynamicLibraryHandler = h;
    p->mDLDeletePackageFunction = df;
    
    std::string separator =
      ConfigurationFile::GetInstance().Get_file_separator ();
    //BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH)
    std::string docreldoc = 
      separator + "bbdoc" + separator + pkgname + separator + "index.html";
    std::string reldoc = 
      ".." + separator + ".." + docreldoc;
    std::string doc = path + separator + ".." + separator
      + BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH)
      + docreldoc;
    
    p->SetDocURL(doc);
    p->SetDocRelativeURL(reldoc);
    
    bbtkDebugMessage("package",2,"<== Package::CreateFromDynamicLibrary("
                     <<libname<<") .. OK"<<std::endl);
    return p;
  }
  //==========================================================================




  //==========================================================================
  void Package::UnLoadDynamicLibrary(Package::WeakPointer pack, bool doit)
  {
    if (pack.expired() || (!pack.lock()->mDynamicLibraryHandler))
      return;
    
    
    std::string packname = pack.lock()->GetName();
    bbtkDebugMessage("package",5,"==> Package::UnLoadDynamicLibrary('"
                     <<packname<<"')"
                     <<std::endl);
    
    if (!pack.lock()->GetBlackBoxMap().empty())
      {
        
        bbtkDebugMessage("package",5,"   Package not empty ... abort"
                         <<std::endl);
        return;
        /*
        bbtkGlobalError("Package::UnLoadDynamicLibrary('"<<packname<<") : "
                        <<"BlackBoxMap not empty "
                        <<BBTK_INTERNAL_ERROR_MESSAGE);
        */
        
      }

    if (pack.use_count()!=1)
      {
        bbtkGlobalError("Package::UnLoadDynamicLibrary('"<<packname<<") : "
                        <<"empty dl package with external refs"
                        <<BBTK_INTERNAL_ERROR_MESSAGE);
      } 

    if (doit) 
      {
        UnLoad(pack);
        bbtkDebugMessage("package",5,"==> dynamic library for package '"
                         <<packname<<"' closed"
                         <<std::endl);    
      }
    else 
      {
        mReleasedDynamicallyLoadedPackages.insert(pack);
        bbtkDebugMessage("package",1,"==> package '"<<packname
                         <<"' put in the 'to unload' list"
                         <<std::endl);

      }

    bbtkDebugMessage("package",5,"<== Package::UnLoadDynamicLibrary('"
                     <<packname<<"')"
                     <<std::endl);
    
  }
  //==========================================================================

  //==========================================================================
  void Package::UnLoadReleasedDynamicallyLoadedPackages()
  {
    bbtkDebugMessage("package",5,"==> Package::UnLoadReleasedDynamicallyLoadedPackages()"<<std::endl);

    std::set<Package::WeakPointer>::iterator i;
    for (i=mReleasedDynamicallyLoadedPackages.begin();
         i!=mReleasedDynamicallyLoadedPackages.end();
         ++i)
      {
        if (!i->expired()) UnLoad(*i);
      }
    bbtkDebugMessage("package",5,"<== Package::UnLoadReleasedDynamicallyLoadedPackages()"<<std::endl);
  }
  //==========================================================================

  //==========================================================================
  void Package::UnLoad(Package::WeakPointer pack)
  {
    std::string packname = pack.lock()->GetName();
    bbtkDebugMessage("package",6,"==> Package::UnLoad("<<packname<<")"<<std::endl);

    Package* p = pack.lock().get();
    
    DynamicLibraryHandler h = p->mDynamicLibraryHandler;
    
    // deletes the package
    p->mDLDeletePackageFunction();
    
    // closes the dl handler
#if defined(__GNUC__)  
    dlclose(h);  
#elif defined(_WIN32)
    FreeLibrary(h);
#endif

    bbtkDebugMessage("package",1,"==> dynamic library for package '"
                     <<packname<<"' closed"
                     <<std::endl);    
    bbtkDebugMessage("package",6,"   ... dynamic library unloaded"<<std::endl);
  }
  //==========================================================================

  //==========================================================================
  BlackBox::Pointer Package::NewBlackBox(const std::string& type, 
                                         const std::string& name) const
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<">::NewBlackBox(\""<<type<<"\",\""<<name<<"\")"<<bbtkendl);
    
    BlackBoxMapType::const_iterator i = mBlackBoxMap.find(type);
    if (i == mBlackBoxMap.end())  
    {
           bbtkDebugDecTab("Kernel",8);
           return BlackBox::Pointer();
    }
    BlackBox::Pointer bb =i->second->NewBlackBox(name);
    bbtkDebugDecTab("Kernel",8);
    return bb;   

  }
  //==========================================================================



  //==========================================================================
  BlackBox::Pointer Package::NewAdaptor(const DataInfo& typein,
                                const DataInfo& typeout,
                                const std::string& name) const
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<
                        ">::NewAdaptor("
                        <<typein<<","
                        <<typeout<<",\""
                        <<name<<"\")"<<bbtkendl);

    AdaptorKey key(typein,typeout,
                   BlackBoxDescriptor::DEFAULT_ADAPTOR);
    AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
    if (i == mAdaptorMap.end())  
      {
        bbtkDebugDecTab("Kernel",8);
        return BlackBox::Pointer();
      }
    BlackBox::Pointer bb =i->second.lock()->NewBlackBox(name);
    bbtkDebugDecTab("Kernel",8);
    return bb;   

  }
  //==========================================================================

  //==========================================================================
  BlackBox::Pointer Package::NewWidgetAdaptor(const DataInfo& typein,
                                      const DataInfo& typeout,
                                      const std::string& name) const
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<
                        ">::NewWidgetAdaptor("
                        <<typein<<","
                        <<typeout<<",\""
                        <<name<<"\")"<<bbtkendl);

    AdaptorKey key(typein,typeout,
                   BlackBoxDescriptor::DEFAULT_GUI);
    AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
    if (i == mAdaptorMap.end())  
      {
        bbtkDebugDecTab("Kernel",8);
        return BlackBox::Pointer();
      }
    BlackBox::Pointer bb =i->second.lock()->NewBlackBox(name);
    bbtkDebugDecTab("Kernel",8);
    return bb;   

  }
  //==========================================================================



  //==========================================================================
  bool Package::FindWidgetAdaptor(const DataInfo& typein,
                                  const DataInfo& typeout,
                                  std::string& adaptor) const
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<
                        ">::FindWidgetAdaptor("
                        <<typein<<","
                        <<typeout<<")"<<bbtkendl);
   
    AdaptorKey key(/*typein*/
                   DataInfo(typeid(void),""),
                   typeout,
                   BlackBoxDescriptor::DEFAULT_GUI);
    // First try to find a single widget adaptor
    AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
    if (i == mAdaptorMap.end())  
      {
        bbtkDebugDecTab("Kernel",8);
        return false;
      }
    adaptor = i->second.lock()->GetTypeName();
    bbtkDebugDecTab("Kernel",8);
    return true;   

  }
  //==========================================================================



  //==========================================================================
  bool Package::FindAdaptor(const DataInfo& typein,
                            const DataInfo& typeout,
                            std::string& adaptor) const
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<
                        ">::FindAdaptor("
                        <<typein<<","
                        <<typeout<<")"<<bbtkendl);
    
    AdaptorKey key(typein,typeout,
                   BlackBoxDescriptor::DEFAULT_ADAPTOR);
    AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
    if (i == mAdaptorMap.end())  
      {
        bbtkDebugDecTab("Kernel",8);
        return false;
      }
    adaptor = i->second.lock()->GetTypeName();
    bbtkDebugDecTab("Kernel",8);
    return true;   

  }
  //==========================================================================


  //==========================================================================
  bool Package::RegisterBlackBox(BlackBoxDescriptor::Pointer d) 
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<">::RegisterBlackBox(\""<<d->GetTypeName()<<"\")"<<std::endl);
    
    BlackBoxMapType::iterator i = mBlackBoxMap.find(d->GetTypeName());
    if (i!=mBlackBoxMap.end())
      {
        bbtkWarning("Package<"<<GetName()<<"> : Trying to register box type <"
                    <<d->GetTypeName()<<"> which is already in the package");
        return false;
      }

    mBlackBoxMap[d->GetTypeName()] = d;
    //    d->Reference();
    d->SetPackage(GetThisPointer<Package>());
    
    // If it is a default adaptor, also register it in the adaptors map
    if ( d->GetKind() == BlackBoxDescriptor::DEFAULT_ADAPTOR )
      {
        bbtkDebugMessage("Kernel",8,"Package<"<<GetName()<<">::RegisterBlackBox(\""<<d->GetTypeName()<<"\") : The box is an adaptor, inserting it in adaptors map ..."<<std::endl);   
        
        TypeInfo typein = d->GetInputDescriptor("In")->GetTypeInfo();
        TypeInfo typeout = d->GetOutputDescriptor("Out")->GetTypeInfo();
        DataInfo infoin(typein,d->GetInputDescriptor("In")->GetNature());
        DataInfo infoout(typeout,d->GetOutputDescriptor("Out")->GetNature());
        AdaptorKey key(infoin,infoout,d->GetKind());
        
        AdaptorMapType::const_iterator i;
        i = mAdaptorMap.find(key);        
        if (i == mAdaptorMap.end())  
          {
            mAdaptorMap[key] = d;
          }
        // If already an adaptor registered : error
        else 
          {
            if (i->second.lock()->GetTypeName() != d->GetTypeName()) 
              {
                bbtkError("Package <"<<GetName()<<
                          "> : trying to register black box <"
                          <<d->GetTypeName()
                          <<"> as default adaptor but there is already a default adaptor registered (<"
                          <<i->second.lock()->GetTypeName()<<">)");
              }
          }
      }
    // If it is a default adaptor, also register it in the adaptors map
    else if ( d->GetKind() == BlackBoxDescriptor::DEFAULT_GUI)
      {
        bbtkDebugMessage("Kernel",8,"Package<"<<GetName()<<">::RegisterBlackBox(\""<<d->GetTypeName()<<"\") : The box is a widget adaptor, inserting it in adaptors map ..."<<std::endl);   
        
        TypeInfo typeout = d->GetOutputDescriptor("Out")->GetTypeInfo();
        DataInfo infoin(typeid(void),"");
        DataInfo infoout(typeout,d->GetOutputDescriptor("Out")->GetNature());
        AdaptorKey key(infoin,infoout,d->GetKind());

        AdaptorMapType::const_iterator i;
        i = mAdaptorMap.find(key);        
        if (i == mAdaptorMap.end())  
          {
            mAdaptorMap[key] = d;
          }
        // If already an adaptor registered : error
        else 
          {
            if (i->second.lock()->GetTypeName() != d->GetTypeName()) 
              {
                bbtkError("Package <"<<GetName()<<
                          "> : trying to register black box <"
                          <<d->GetTypeName()
                          <<"> as default widget adaptor but there is already a default adaptor registered (<"
                          <<i->second.lock()->GetTypeName()<<">)");
              }
          }
      }
    

    bbtkDebugDecTab("Kernel",8);
   
    return true;
  }
  //==========================================================================
  
  //===================================================================
  void Package::CheckBoxes() const
  {
    bbtkMessage("debug",1,"****** Checking Package "<<(void*)this
                <<" ["<<GetName()<<"]"<<std::endl);
    BlackBoxMapType::const_iterator i;
    for (i=mBlackBoxMap.begin();
         i!=mBlackBoxMap.end();
         ++i) 
      {
        i->second->Check(true);
      }
    bbtkMessage("debug",1,"****** Checking Package "<<(void*)this
                <<" ["<<GetName()<<"] ... OK"<<std::endl);
  }
  //===================================================================


  //==========================================================================
  void Package::ChangeBlackBoxName( const std::string& oldname, const std::string& newname )
  { 
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<">::ChangeBlackBoxName(\""<<oldname<<"\",\""<<newname<<"\")"<<std::endl);
    // Looking into the bb map
    BlackBoxMapType::iterator i = mBlackBoxMap.find(oldname);
    if (i == mBlackBoxMap.end())  
      {
         bbtkDebugDecTab("Kernel",8);
         bbtkError("ChangeBlackBoxName : The package <"<<GetName()<<"> does not contains the black box <"<<oldname<<">");
      }

    i->second->SetTypeName(newname);
    mBlackBoxMap[newname] = i->second;
    mBlackBoxMap.erase(i);

    bbtkDebugDecTab("Kernel",8);    
  }
  //==========================================================================



  //==========================================================================
  void Package::PrintBlackBoxes(bool description, bool adaptors) const
  {
    unsigned int lmax = 0;
    std::vector<std::string> names;
    std::vector<std::string> kinds;
    std::vector<std::string> descrs;

    BlackBoxMapType::const_iterator i;
    for (i=mBlackBoxMap.begin();
         i!=mBlackBoxMap.end();
         ++i) 
      {
        if ( adaptors || 
             ( i->second->GetKind() == BlackBoxDescriptor::STANDARD) ) 
          {
            std::string name("  ");
            name += i->second->GetTypeName();
            names.push_back(name);

            std::string kind;
            if ( i->second->GetKind() == BlackBoxDescriptor::ADAPTOR )
              {
                kind = std::string("[A]");
              }
            else if ( i->second->GetKind() == 
                      BlackBoxDescriptor::DEFAULT_ADAPTOR )
              {
                kind = std::string("[DA]");
              }
            kinds.push_back(kind);

            unsigned int l = name.size()+kind.size();
            if (l>lmax) lmax = l;

            std::string descr;
            if (description) 
              {
                descr += " : ";
                descr += i->second->GetDescription();
              } 
            descrs.push_back(descr);
          }
      } 
    

    std::string offs;
    offs.append(lmax+3,' ');
    std::vector<std::string>::iterator ni,ci,di;
    for (ni = names.begin(), ci = kinds.begin(), di = descrs.begin();
         ni != names.end(); ++ni, ++ci, ++di)
      {
        std::string space;
        space.append(lmax - ni->size() - ci->size(),' ');
        bbtkMessage("Help",1,*ni << space << *ci );
        std::string d(*di);
        unsigned int dmax = 75 - lmax;
        //      while (d.size() > dmax ) 
        //  {
        if (d.size()>dmax) 
          bbtkMessage("Help",1,d.substr(0,dmax) << "..." << std::endl);
        else 
          bbtkMessage("Help",1,d << std::endl);
        //    d = d.substr(dmax,d.size());
        //  }
      }

  }
  //==========================================================================

  //==========================================================================
  void Package::PrintAdaptors(bool description) const
  {
    BlackBoxMapType::const_iterator i;
    for (i=mBlackBoxMap.begin();
         i!=mBlackBoxMap.end();
         ++i) 
      {
        if ( i->second->GetKind() != BlackBoxDescriptor::STANDARD ) 
          {
            bbtkMessage("Help",1,
                        "  "<<i->second->GetTypeName());
            if ( i->second->GetKind() == 
                 BlackBoxDescriptor::DEFAULT_ADAPTOR )
              {
                bbtkMessage("Help",1,
                            " [default]");
              }  
            if (description) 
              {
                bbtkMessage("Help",1,
                            " : "<<i->second->GetDescription());

              } 
            bbtkMessage("Help",1,std::endl);
          }
      } 
    /*
    AdaptorMapType::const_iterator i;
    for (i=mAdaptorMap.begin();
         i!=mAdaptorMap.end();
         ++i) 
      {
        bbtkMessage("Help",1,
                    "  "<<i->second->GetTypeName());
        if (detail_level>0) 
          {
            bbtkMessage("Help",1,
                        " : "<<i->second->GetDescription());
  
          } 
        bbtkMessage("Help",1,std::endl);
      }
    */ 
  }
  //==========================================================================

  //==========================================================================
  void Package::HelpBlackBox(const std::string& name, bool full) const
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<">::HelpBlackBox(\""
                        <<name<<"\")"<<bbtkendl);

    BlackBoxMapType::const_iterator i = mBlackBoxMap.find(name);
    if (i == mBlackBoxMap.end())  
      {
        bbtkDebugDecTab("Kernel",8);
        bbtkError("The package <"<<GetName()<<"> does not contains the black box <"<<name<<">");
      }
    //    bbtkMessage("Help",1,"["<<GetName()<<"] ");
    i->second->GetHelp(full);
    bbtkDebugDecTab("Kernel",8);

  }
  //==========================================================================


  //==========================================================================
  bool Package::ContainsBlackBox(const std::string& name) const 
  {
    bbtkDebugMessageInc("Kernel",8,"Package<"<<GetName()<<">::HelpBlackBox(\""
                        <<name<<"\")"<<bbtkendl);
    
    BlackBoxMapType::const_iterator i = mBlackBoxMap.find(name);
    if (i == mBlackBoxMap.end())  
    {
      bbtkDebugDecTab("Kernel",8);
      return false;
    }
    bbtkDebugDecTab("Kernel",8);
    return true;
  }
  //==========================================================================


 
  //==========================================================================
  void Package::CreateHtmlPage(const std::string& filename,
                               const std::string& caller,
                               const std::string& source,
                               const std::string& custom_header,
                               const std::string& custom_title,
                               int detail, 
                               int level,
                               bool relative_link ) const
  {
    bbtkDebugMessageInc("Kernel",9,"Package<"<<GetName()<<">::CreateHtmlPage(\""
                        <<filename<<"\")"<<bbtkendl);

    //---------------------
    // Open output file
    std::ofstream s;
    s.open(filename.c_str());
    if (!s.good()) 
    {
       bbtkError("Package "<<GetName()<<" : CreateHtmlPage : could not open file '"<<filename<<"'");
    }
    
    //----------------------
    // Html head
    std::string title = "BBTK Package "+GetName()+" "+GetVersion(); 

    if (custom_title.length() != 0) title = custom_title;

    s << "<html lang=\"en\">\n";
    s << "<head>\n";
    s << "<title>" << title << "</title>\n";
    s << "<meta http-equiv=\"Content-Type\" content=\"text/html\">\n";
    s << "<meta name=\"description\" content=\""<<title<<"\">\n";
    s << "<meta name=\"generator\" content=\"\">\n";
    s << "<link title=\"Top\" rel=\"top\" href=\"#Top\">\n";
    //<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
    s << "<meta http-equiv=\"Content-Style-Type\" content=\"text/css\"><style type=\"text/css\"><!--\n";
    s << "pre.display { font-family:inherit }\n";
    s << "pre.format  { font-family:inherit }\n";
    s << "pre.smalldisplay { font-family:inherit; font-size:smaller }\n";
    s << "pre.smallformat  { font-family:inherit; font-size:smaller }\n";
    s << "pre.smallexample { font-size:smaller }\n";
    s << "pre.smalllisp    { font-size:smaller }\n";
    s << "span.sc    { font-variant:small-caps }\n";
    s << "span.roman { font-family:serif; font-weight:normal; } \n";
    s << "span.sansserif { font-family:sans-serif; font-weight:normal; }\n"; 
    s << "--></style>\n";
    s << "</head>\n";
    //----------------------

    //----------------------
    // Html body
    s << "<body>\n";
    s << "<a name=\"Top\"></a>\n"; 
    
    //----------------------
    // Header
    if ( custom_header.length() != 0) 
      {
        if ( custom_header != "none" )
          { 
            std::ifstream in;
            in.open(custom_header.c_str());    
            if (!in.good()) 
              {
                bbtkError("Could not open file \""<<custom_header<<"\"");
              }
            char buffer[512];
            while (!in.eof()) 
              {
                in.getline(buffer,512);
                std::string line(buffer);
                s << line;
              }
            in.close();
            s << "<hr>\n";
           
            /*   
            s << "<object data=\"" << custom_header 
              << "\" type = \"text/html\"\"style=\"width: 1200px; height: 400px;\"> Warning: "
              << custom_header <<" could not be embedded.</object>\n";
            
            s << "<hr>\n";
            */
          }
      }

    else 
      {
        s << "<h1 class=\"settitle\">"<<title<<"</h1>\n";
        s << "<p><TABLE cellspacing=0  cellpadding=3>\n";
        s << "<TR><TD style='vertical-align: top;'><b> Description </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'> " 
          << GetDescription() << "</TD></TR>\n";
        s << "<TR><TD style='vertical-align: top;'><b> Author(s) </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'>  " 
          << GetAuthor() << "</TD></TR>\n";
        s << "<TR><TD style='vertical-align: top;'><b> Author(s) </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'>  " 
          << GetCategory() << "</TD></TR>\n";
        s << "<TR><TD style='vertical-align: top;'><b> Version </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'> " 
          << GetVersion() << "</TD></TR>\n";
        s << "<TR><TD style='vertical-align: top;'><b> bbtk Version </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'> " 
          << bbtk::GetVersion() << "</TD></TR>\n";
        s << "</TABLE>\n";
      }

    //-------------------
    // Table of contents
    // Black boxes list
    //  s << "<div class=\"contents\">\n";
    s << "<p><b> Black Boxes : </b>\n";
    s << "<ul>\n";

    s << "<p><TABLE cellspacing=0  cellpadding=3>\n";

    BlackBoxMapType::const_iterator i;
    for (i=mBlackBoxMap.begin(); i!=mBlackBoxMap.end(); ++i) 
      {
        if ( i->second->GetKind() != BlackBoxDescriptor::STANDARD) 
          continue;
        
        std::string name = i->second->GetTypeName();
        Utilities::html_format(name);
        std::string descr = i->second->GetDescription();
        //Utilities::html_format(descr);

        s << "<TR>";
        s << "<TD style='vertical-align: top;'>";
        s << "&nbsp;&nbsp;&nbsp;<a name=\"toc_"<<name
          <<"\" href=\"#"<<name<<"\">"
          <<name<<"</a>";
        s << "</TD> ";
        s << " <TD style='vertical-align: top;'>" << descr << " </TD>";
        s << "</TR>\n";
      }    
    s << "</TABLE>\n";
    
    
    s << "</ul>\n";
    s << "</div>\n";
    
    //-------------------
    // Adaptors list
    if (mAdaptorMap.size()>0) 
      {
        //  s << "<div class=\"contents\">\n";
        s << "<p><b> Adaptors : </b>\n";
        s << "<ul>\n";

        //    BlackBoxMapType::const_iterator i;
        s << "<p><TABLE cellspacing=0  cellpadding=3>\n";
        for (i=mBlackBoxMap.begin(); i!=mBlackBoxMap.end();++i) 
          {
            if ( i->second->GetKind() == BlackBoxDescriptor::STANDARD) 
              continue;
    
            std::string name = i->second->GetTypeName();
            Utilities::html_format(name);
            std::string descr = i->second->GetDescription();
    
            s << "<TR>";
            s << "<TD style='vertical-align: top;'>";
            s << "&nbsp;&nbsp;&nbsp;<a name=\"toc_"<<name
              <<"\" href=\"#"<<name<<"\">"
              <<name<<"</a>";
            s << "</TD> ";
            s << " <TD style='vertical-align: top;'>" << descr << " </TD>";
            s << "</TR>\n";
          }    
        s << "</TABLE>\n";

        s << "</ul>\n";
        s << "</div>\n";
      }
    
    
    //  s << "<div class=\"node\">\n";

    //    s << "<p><hr>\n";
    //    s << "<a name=\"Top\"></a>\n";
    //  s << "Top:&nbsp;<a rel=\"top\" accesskey=\"t\" href=\"#Top\">Top</a>\n";
    // s << "Previous:&nbsp;<a rel="previous" accesskey="p" href="#dir">(dir)</a>,
    // s << "Up:&nbsp;<a rel="up" accesskey="u" href="#dir">(dir)</a>
    
    //    s << "</div>\n";

    //----------------------
    // Boxes doc

    //-------------------
    // Computes output directory from filename to pass it to 
    // BlackBoxDescriptor::InsertHtmlHelp
    std::string dir;

    std::string::size_type slash_position = filename.find_last_of("/\\");


        if (slash_position != std::string::npos) {
      if (slash_position == 0)
         slash_position = 1;  
      dir = filename.substr(0,slash_position);
    }

    for (i=mBlackBoxMap.begin();
         i!=mBlackBoxMap.end();
         ++i) 
      {
        i->second->InsertHtmlHelp(s,detail,level,dir,relative_link);
      }    

    //----------------------
    // Footer 
    time_t rawtime;
    tm * ptm;
    time ( &rawtime );
    ptm = gmtime ( &rawtime );

    s << "<p><hr>\n";
    s << "Automatically generated by <b>"<<caller<<"</b> "//from <b>"
      //      <<source<<"</b>
      <<"on "
      << ptm->tm_mday << "/" << ptm->tm_mon << "/" << ptm->tm_year+1900 
      << " - " << ptm->tm_hour << ":" << ptm->tm_min << " GMT\n";
    s << "</body></html>\n"; 
    s.close();
    //----------------------

    // End
    bbtkDebugDecTab("Kernel",9);
  }
  //==========================================================================
  
  //==========================================================================
  std::string  Package::GetObjectName() const 
  { 
    return std::string("Package '")+mName+std::string("'"); 
  }
  //==========================================================================

  //==========================================================================
  std::string Package::GetObjectInfo() const 
  {
    std::stringstream i;
    i << "  - "<<mBlackBoxMap.size() << " boxes" << std::endl;
    if (mDynamicLibraryHandler) 
      {
        i<< "  - Loaded from dynamic library"<<std::endl;
      }
    return i.str();
  }
  //==========================================================================


  //==========================================================================
  size_t  Package::GetObjectSize() const 
  {
    size_t s = Superclass::GetObjectSize();
    s += Package::GetObjectInternalSize();
    return s;
  }
  //==========================================================================
  //==========================================================================
  size_t  Package::GetObjectInternalSize() const 
  {
    size_t s = sizeof(Package);
    return s;
  }
  //==========================================================================
  //==========================================================================
  size_t  Package::GetObjectRecursiveSize() const 
  {
    size_t s = Superclass::GetObjectRecursiveSize();
    s += Package::GetObjectInternalSize();
    
    BlackBoxMapType::const_iterator i;
    for (i = mBlackBoxMap.begin(); i!=mBlackBoxMap.end(); ++i )
      {
        s += i->second->GetObjectRecursiveSize();
      }
    return s;
  }
  //==========================================================================
  
  //==========================================================================
  std::set<Package::WeakPointer> 
  Package::mReleasedDynamicallyLoadedPackages;
  //==========================================================================
}