kernel/src/bbtkPackage.cxx

   1
   2 /*=========================================================================
   3   Program:   bbtk
   4   Module:    $RCSfile: bbtkPackage.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2010/01/14 13:17:27 $
   7   Version:   $Revision: 1.33 $
   8 =========================================================================*/
   9
  10 /* ---------------------------------------------------------------------
  11
  12 * Copyright (c) CREATIS-LRMN (Centre de Recherche en Imagerie Medicale)
  13 * Authors : Eduardo Davila, Laurent Guigues, Jean-Pierre Roux
  14 *
  15 *  This software is governed by the CeCILL-B license under French law and
  16 *  abiding by the rules of distribution of free software. You can  use,
  17 *  modify and/ or redistribute the software under the terms of the CeCILL-B
  18 *  license as circulated by CEA, CNRS and INRIA at the following URL
  19 *  http://www.cecill.info/licences/Licence_CeCILL-B_V1-en.html
  20 *  or in the file LICENSE.txt.
  21 *
  22 *  As a counterpart to the access to the source code and  rights to copy,
  23 *  modify and redistribute granted by the license, users are provided only
  24 *  with a limited warranty  and the software's author,  the holder of the
  25 *  economic rights,  and the successive licensors  have only  limited
  26 *  liability.
  27 *
  28 *  The fact that you are presently reading this means that you have had
  29 *  knowledge of the CeCILL-B license and that you accept its terms.
  30 * ------------------------------------------------------------------------ */
  31
  32 /**
  33  *\file
  34  *\brief Class bbtk::Package : registers black boxes descriptors and is able to create instances of the black boxes registered.
  35  */
  36 #include "bbtkPackage.h"
  37 #include "bbtkComplexBlackBoxDescriptor.h"
  38 #include "bbtkMessageManager.h"
  39 #include "bbtkConfigurationFile.h"
  40 #include <fstream>
  41 #include <time.h>
  42 #include "bbtkUtilities.h"
  43
  44 namespace bbtk
  45 {
  46
  47
  48
  49   //==========================================================================
  50   /// Creates a new package
  51   Package::Pointer Package::New(const std::string& name,
  52                                 const std::string& author,
  53                                 const std::string& description,
  54                                 const std::string& version)
  55   {
  56     bbtkDebugMessage("object",1,"##> Package::New('"<<name<<"',...)"
  57                      <<bbtkendl);
  58     Package::Pointer p = MakePointer(new Package(name,
  59                                                author,
  60                                                description,
  61                                                version));
  62     bbtkDebugMessage("object",2,"<## Package::New('"<<name<<"',...)"
  63                      <<bbtkendl);
  64     return p;
  65   }
  66   //==========================================================================
  67
  68   //==========================================================================
  69   /// Ctor with the name of the package
  70   Package::Package(const std::string& name,
  71                    const std::string& author,
  72                    const std::string& description,
  73                    const std::string& version)
  74     :
  75     mDynamicLibraryHandler(0),
  76     mName(name),
  77     mAuthor(author),
  78     mDescription(description),
  79     mVersion(version)
  80   {
  81     bbtkDebugMessage("object",2,"==> Package('"<<name<<"',...)"
  82                      <<bbtkendl);
  83     std::string default_doc_dir = ConfigurationFile::GetInstance().Get_default_temp_dir();
  84     char c = default_doc_dir.c_str()[strlen(default_doc_dir.c_str())-1];
  85     std::string url = default_doc_dir;
  86     if (c != '/' && c !='\\') url = url + "/";
  87     url = url +  "temp_dir/" + name + "/index.html";
  88
  89     SetDocURL(url);
  90     SetDocRelativeURL("Relative url not set");
  91
  92     /*
  93     std::string relurl(BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH));
  94     relurl += "/packages/"+name+"/bbdoc/index.html";
  95     std::string url = ConfigurationFile::GetInstance().Get_url()
  96       + relurl;
  97     SetDocURL(url);
  98     SetDocRelativeURL(relurl);
  99     */
 100
 101     //    std::cout  << "   url=["<<url<<"]"<<std::endl;
 102     //    std::cout  << "relurl=["<<relurl<<"]"<<std::endl;
 103     bbtkDebugMessage("object",2,"<== Package::Package('"<<name<<"',...) OK"
 104                      <<bbtkendl);
 105
 106   }
 107   //==========================================================================
 108
 109
 110
 111   //==========================================================================
 112   /// Dtor
 113   Package::~Package()
 114   {
 115     bbtkDebugMessage("object",2,"==> ~Package(\""<<mName<<"\")"<<bbtkendl);
 116   }
 117   //==========================================================================
 118
 119
 120   //==========================================================================
 121   void PackageReleaseBlackBoxDescriptorInternal(Package::WeakPointer pack,
 122                                                 const std::string& descname)
 123   {
 124     // Try to release descriptor
 125     std::string packname = pack.lock()->GetName();
 126
 127     bbtkDebugMessage("package",5,"--- Releasing descriptor '"
 128                      <<packname<<"::"<<descname<<"'"<<bbtkendl);
 129
 130
 131     Package::DescriptorMapType::iterator desc =
 132       pack.lock()->GetDescriptorMap().find(descname);
 133     if (desc ==  pack.lock()->GetDescriptorMap().end())
 134       {
 135         bbtkDebugMessage("package",5,
 136                          "    Descriptor has already been released"
 137                         <<bbtkendl);
 138         return;
 139                   }
 140     //    bbtkDebugMessage("package",3,
 141     //               "    Trying unreferencing it ... "<<std::endl);
 142     BlackBoxDescriptor::WeakPointer pdesc = desc->second;
 143     desc->second.reset();
 144     // if it is dead : remove it
 145     if (pdesc.expired())
 146       {
 147         bbtkDebugMessage("package",2," ==> '"<<packname<<"::"<<descname<<"' Descriptor expired"<<bbtkendl);
 148         if (pack.expired())
 149           {
 150             bbtkDebugMessage("package",2,
 151                              "     ... and caused its package death"
 152                              <<bbtkendl);
 153             return;
 154           } // pack.expired
 155         desc = pack.lock()->GetDescriptorMap().find(descname);
 156         if (desc !=  pack.lock()->GetDescriptorMap().end())       pack.lock()->GetDescriptorMap().erase(desc);
 157       }   else    {  //pdesc.expired
 158       bbtkDebugMessage("package",5,"    ... Descriptor still alive ("
 159                        <<pdesc.use_count()<<" refs)"
 160                        <<bbtkendl);
 161       pack.lock()->GetDescriptorMap()[descname] = pdesc.lock();
 162     } // pdesc.expired
 163   }
 164   //==========================================================================
 165
 166
 167   //==========================================================================
 168   /// Release
 169   void Package::Release(Package::WeakPointer pack)
 170   {
 171     std::string packname = pack.lock()->mName;
 172     bbtkDebugMessage("package",1,"==> Package::Release('"<<
 173                      packname<<"')"<<bbtkendl);
 174
 175     long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0;
 176     long ndesc = pack.lock()->GetDescriptorMap().size();
 177     long nrefs = pack.use_count();
 178
 179     bbtkDebugMessage("package",5," "<<nrefs<<" refs / "
 180                      <<ndesc<<" descr / dyn="
 181                      <<dyn<<std::endl);
 182
 183     // A package is "free" from any external reference iff :
 184     // i) It is not dynamically loaded and nrefs == ndesc
 185     // (each desc references its package) or
 186     // ii) It is dynamically loaded and nrefs == ndesc + 1
 187     // (A dynamic library holds a static pointer on the package it contains
 188     //  which is allocated when the PACKAGENAMEGetPackage() func is called,
 189     //  and descallocated (reset) by PACKAGENAMEDeletePackage())
 190     if (nrefs == ndesc + dyn)
 191       {
 192         bbtkDebugMessage("package",5,
 193                          " -> No more external ref : checking descriptors"
 194                          <<bbtkendl);
 195         // We must take care that removing refs on descriptors
 196         // can lead to their deletion which can in turn unref
 197         // internal boxes which can release their descriptors hence
 198         // call Package::ReleaseBlackBoxDescriptor
 199         // As a consequence during descriptors release :
 200         // 1) The map can change dynamically : we cannot iterate over it
 201         //    as any iterator can become invalid
 202         // 2) The package can auto-destruct : we must test its existence
 203         //    after each release
 204         // We must also take care of not locking the package pointer
 205         // or any ref count check in Package::ReleaseBlackBoxDescriptor
 206         // would be wrong
 207
 208         // The list of descriptors names at start
 209         std::vector<std::string> descnamelist;
 210         DescriptorMapType::iterator i;
 211         for (i=pack.lock()->mDescriptorMap.begin();
 212              i!= pack.lock()->mDescriptorMap.end();
 213              ++i)
 214           descnamelist.push_back(i->first);
 215
 216         // Iterator over the initial names
 217         std::vector<std::string>::iterator descname;
 218         for (descname=descnamelist.begin();
 219              descname!=descnamelist.end();
 220              ++descname)
 221           {
 222             // Is package still alive ?
 223             if (pack.expired())
 224               {
 225                 bbtkDebugMessage("package",1,"--- Package::Release('"<<
 226                                  packname
 227                                  <<"') : package expired during release : bailing out"<<bbtkendl);
 228                 break;
 229               }
 230
 231 #if defined(MACOSX)
 232                   BlackBoxDescriptor::Pointer desc = pack.lock()->mDescriptorMap[*descname];
 233                   if ( (dyn==0) || (boost::dynamic_pointer_cast<ComplexBlackBoxDescriptor>(desc)) )
 234                   {
 235                           PackageReleaseBlackBoxDescriptorInternal(pack,*descname);
 236                   }
 237 #else
 238                   PackageReleaseBlackBoxDescriptorInternal(pack,*descname);
 239 #endif
 240
 241           }
 242
 243         //
 244         UnLoadDynamicLibrary(pack);
 245         // Unload orphan dl packages
 246         Package::UnLoadReleasedDynamicallyLoadedPackages();
 247
 248       }
 249
 250 #ifdef BBTK_COMPILE_DEBUG_MESSAGES
 251
 252     bbtkDebugMessage("package",2,"<== Package::Release('"<<
 253                      packname<<"')"<<bbtkendl);
 254
 255     if (!pack.expired())
 256       {
 257         long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0;
 258         long ndesc = pack.lock()->GetDescriptorMap().size();
 259         long nrefs = pack.use_count();
 260
 261         bbtkDebugMessage("package",1," ... Package still alive ("
 262                          <<nrefs<<" refs / "
 263                          <<ndesc<<" descr / dyn="
 264                          <<dyn<<")"<<std::endl);
 265       }
 266     else
 267       {
 268         bbtkDebugMessage("package",1," ... Package has been released"
 269                          <<std::endl);
 270       }
 271 #endif
 272   }
 273   //==========================================================================
 274
 275   //==========================================================================
 276   /// "Releases" the package
 277   /// Signals the package that it can free the given descriptor
 278   /// if they are no more used and free itself if it is no
 279   /// more used
 280   /// Note : Any non-weak pointer on the package must have been freed
 281   void Package::ReleaseBlackBoxDescriptor(Package::WeakPointer pack,
 282                                           BlackBoxDescriptor::WeakPointer descr)
 283   {
 284     std::string packname = pack.lock()->mName;
 285     std::string dname = descr.lock()->GetTypeName();
 286     bbtkDebugMessage("package",3,"==> Package::ReleaseBlackBoxDescriptor('"<<
 287                      packname<<"','"<<dname<<"') : refs="
 288                      <<descr.use_count()<<bbtkendl);
 289
 290     long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0;
 291     long ndesc = pack.lock()->GetDescriptorMap().size();
 292     long nrefs = pack.use_count();
 293
 294     bbtkDebugMessage("package",5," "<<nrefs<<" refs / "
 295                      <<ndesc<<" descr / dynamically loaded = "
 296                      <<dyn<<std::endl);
 297
 298     // A package is "free" from any external reference iff :
 299     // i) It is not dynamically loaded and nrefs == ndesc
 300     // (each desc references its package) or
 301     // ii) It is dynamically loaded and nrefs == ndesc + 1
 302     // (A dynamic library holds a static pointer on the package it contains
 303     //  which is allocated when the PACKAGENAMEGetPackage() func is called,
 304     //  and descallocated (reset) by PACKAGENAMEDeletePackage())
 305     if (nrefs == ndesc + dyn)
 306       {
 307 #if defined(MACOSX)
 308                   //
 309                   if (dyn==0)
 310                           PackageReleaseBlackBoxDescriptorInternal(pack,dname);
 311 #else
 312                   PackageReleaseBlackBoxDescriptorInternal(pack,dname);
 313 #endif
 314       }
 315
 316     // If the package is released and dynamically loaded
 317     // then put it in the static list mReleasedDynamicallyLoadedPackages
 318     UnLoadDynamicLibrary(pack,false);
 319
 320     bbtkDebugMessage("package",4,"<== Package::ReleaseBlackBoxDescriptor('"<<
 321                      packname<<"','"<<dname<<"'): refs="
 322                      <<descr.use_count()<<bbtkendl);
 323     /*
 324     if (!pack.expired())
 325       {
 326         long dyn = pack.lock()->mDynamicLibraryHandler ? 1:0;
 327         long ndesc = pack.lock()->GetDescriptorMap().size();
 328         long nrefs = pack.use_count();
 329
 330         bbtkDebugMessage("package",3," ... Package still alive ("
 331                          <<nrefs<<" refs / "
 332                          <<ndesc<<" descr / dyn="
 333                          <<dyn<<")"<<std::endl);
 334       }
 335     else
 336       {
 337         bbtkDebugMessage("package",3,"   ... Package has been released"
 338                          <<std::endl);
 339       }
 340     */
 341   }
 342   //==========================================================================
 343
 344   //==========================================================================
 345   /// Opens a dynamic library which contains a bbtk package
 346   /// Returns the handler
 347   /// Load the package management symbols from the lib
 348   /// returns false if a problem occured hence can be used
 349   /// to test that a dyn lib is a valid bbtk package lib
 350   /// NB : The BBTK version exported from the library
 351   ///      is tested against the current bbtk version
 352   DynamicLibraryHandler Package::OpenDynamicLibrary
 353   ( const std::string& libname,
 354     const std::string& package_name,
 355     DLGetPackageFunction& getpack,
 356     DLDeletePackageFunction& delpack)
 357   {
 358     bbtkDebugMessage("package",3,"==> Package::OpenDynamicLibrary("
 359                      <<libname<<")"<<std::endl);
 360 #if defined(__GNUC__)
 361
 362     // Open shared lib
 363     void *handler;
 364     handler = dlopen(libname.c_str(), BBTK_RTLD_TIME | BBTK_RTLD_SCOPE );
 365 //EED     handler = dlopen(libname.c_str(), RTLD_LAZY | RTLD_LOCAL );
 366
 367     if (!handler)
 368       {
 369         bbtkMessage("package",2,
 370                     "Could not open shared library [" <<libname<<"] : "
 371                     <<dlerror() << std::endl);
 372         return 0;
 373       }
 374
 375     bbtkDebugMessage("package",3,"* Shared lib ["<<libname<<"] open"<<std::endl);
 376
 377     // Loads the Package bbtk version function
 378     std::string getvername(package_name);
 379     getvername +=
 380       BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_BBTK_VERSION_FUNCTION_NAME);
 381     DLGetPackageBBTKVersionFunction getbbtkversion
 382       = (DLGetPackageBBTKVersionFunction)(dlsym(handler,getvername.c_str()));
 383     if (!getbbtkversion)
 384       {
 385         bbtkDebugMessage("package",3,"***"<<std::endl);
 386         bbtkMessage("package",2,
 387                     "Shared library ["<<libname
 388                     <<"] is not a valid bbtk package."
 389                     <<" Symbol ["<<getvername<<"] :"<<dlerror()<< std::endl);
 390         dlclose(handler);
 391         return 0;
 392       }
 393
 394     bbtkDebugMessage("package",3,"* Symbol ["<<getvername
 395                      <<"] found"<<std::endl);
 396     // version matches ?
 397     if (getbbtkversion() != bbtk::GetVersion())
 398       {
 399         bbtkMessage("package",2,
 400                     "Shared library ["<<libname
 401                     <<"] was build with bbtk version "
 402                     <<getbbtkversion()
 403                     <<" but the current program runs with version "
 404                     <<bbtk::GetVersion()<<" : cannot load it"<<std::endl);
 405         dlclose(handler);
 406         return 0;
 407
 408       }
 409
 410     bbtkDebugMessage("package",3,"* Package bbtk version '"<<getbbtkversion()<<"' matches"<<std::endl);
 411             // Loads the Package get function
 412     std::string getpackname(package_name);
 413     getpackname += BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_FUNCTION_NAME);
 414     getpack = (DLGetPackageFunction)(dlsym(handler, getpackname.c_str()));
 415     if (!getpack)
 416       {
 417         bbtkMessage("package",2,
 418                     "Shared library ["<<libname
 419                     <<"] is not a valid bbtk package."
 420                     <<" Symbol ["<<getpackname<<"] :"<<dlerror()<< std::endl);
 421         dlclose(handler);
 422         return 0;
 423       }
 424
 425     bbtkDebugMessage("package",3,"* Symbol ["<<getpackname<<"] found"<<std::endl);
 426     // Loads the Package delete function
 427
 428     std::string delpackname(package_name);
 429     delpackname += BBTK_STRINGIFY_SYMBOL(BBTK_DEL_PACKAGE_FUNCTION_NAME);
 430     delpack = (DLDeletePackageFunction)(dlsym(handler, delpackname.c_str()));
 431     if (!delpack)
 432       {
 433         bbtkMessage("package",2,
 434                     "Shared library ["<<libname
 435                     <<"] is not a valid bbtk package."
 436                     <<" Symbol ["<<delpackname<<"] :"<<dlerror()<< std::endl);
 437         dlclose(handler);
 438         return 0;
 439       }
 440     bbtkDebugMessage("package",3,"* Symbol ["<<delpackname<<"] found"<<std::endl);
 441 #elif defined(_WIN32)
 442
 443     HINSTANCE handler;
 444
 445     SetErrorMode(0);
 446     // Open shared lib
 447     handler = LoadLibrary(libname.c_str());
 448     if (!handler)
 449       {
 450         bbtkMessage("package",2,
 451                     "Could not open shared library [" <<libname<<"]"
 452                     << std::endl);
 453         DWORD dwErrorCode = 0;
 454         dwErrorCode = GetLastError();
 455         bbtkMessage("package",2,
 456                 "Windows Error: [" << dwErrorCode <<"]"
 457                 << std::endl);
 458
 459         return 0;
 460       }
 461
 462     // Loads the Package bbtk version function
 463     std::string getvername(package_name);
 464     getvername +=
 465       BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_BBTK_VERSION_FUNCTION_NAME);
 466     DLGetPackageBBTKVersionFunction getbbtkversion
 467       = (DLGetPackageBBTKVersionFunction)(GetProcAddress(handler,
 468                                                         getvername.c_str()));
 469     if (!getbbtkversion)
 470       {
 471         FreeLibrary(handler);
 472         bbtkMessage("package",2,
 473                     "Shared library ["<<libname
 474                     <<"] is not a valid bbtk package."
 475                     <<" Symbol ["<<getbbtkversion<<"] not found"<< std::endl);
 476         return 0;
 477       }
 478
 479     // version matches ?
 480     if (getbbtkversion() != bbtk::GetVersion())
 481       {
 482         FreeLibrary(handler);
 483         bbtkMessage("package",2,
 484                     "Shared library ["<<libname
 485                     <<"] was build with bbtk version "
 486                     <<getbbtkversion()
 487                     <<" but the current program runs with version "
 488                     <<bbtk::GetVersion()<<" : cannot load it"<<std::endl);
 489         return 0;
 490
 491       }
 492
 493      // Loads the Package get function
 494     std::string getpackname(package_name);
 495     getpackname += BBTK_STRINGIFY_SYMBOL(BBTK_GET_PACKAGE_FUNCTION_NAME);
 496     getpack = (DLGetPackageFunction)(GetProcAddress(handler, getpackname.c_str()));
 497     if (!getpack)
 498       {
 499         FreeLibrary(handler);
 500         bbtkMessage("package",2,
 501                     "Shared library ["<<libname
 502                     <<"] is not a valid bbtk package."
 503                     <<" Symbol ["<<getpackname<<"] not found"<< std::endl);
 504         return 0;
 505       }
 506
 507     // Loads the Package delete function
 508     std::string delpackname(package_name);
 509     delpackname += BBTK_STRINGIFY_SYMBOL(BBTK_DEL_PACKAGE_FUNCTION_NAME);
 510     delpack = (DLDeletePackageFunction)(GetProcAddress(handler, delpackname.c_str()));
 511     if (!delpack)
 512       {
 513         FreeLibrary(handler);
 514         bbtkMessage("package",2,
 515                     "Shared library ["<<libname
 516                     <<"] is not a valid bbtk package."
 517                     <<" Symbol ["<<delpackname<<"] not found"<< std::endl);
 518         return 0;
 519       }
 520
 521 #else
 522     bbtkError("neither __GNUC__ nor _WIN32 ?!? How did you compile ?");
 523 #endif
 524
 525     return handler;
 526   }
 527   //==========================================================================
 528
 529   //==========================================================================
 530   /// Loads a package from a dynamic library
 531   Package::Pointer Package::CreateFromDynamicLibrary(const std::string& libname,
 532                                                      const std::string& pkgname,
 533                                                      const std::string& path)
 534   {
 535     bbtkDebugMessage("package",1,"==> Package::CreateFromDynamicLibrary("
 536                      <<libname<<")"<<std::endl);
 537
 538     DLGetPackageFunction gf;
 539     DLDeletePackageFunction df;
 540     DynamicLibraryHandler h = Package::OpenDynamicLibrary(libname,
 541                                                           pkgname,
 542                                                           gf,df);
 543     if (h==0) return Package::Pointer();
 544     Package::Pointer p = gf();
 545     p->mDynamicLibraryHandler = h;
 546     p->mDLDeletePackageFunction = df;
 547
 548     std::string separator =
 549       ConfigurationFile::GetInstance().Get_file_separator ();
 550     //BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH)
 551     std::string docreldoc =
 552       separator + "bbdoc" + separator + pkgname + separator + "index.html";
 553     std::string reldoc =
 554       ".." + separator + ".." + docreldoc;
 555     std::string doc = path + separator + ".." + separator
 556       + BBTK_STRINGIFY_SYMBOL(BBTK_DOC_REL_PATH)
 557       + docreldoc;
 558
 559     p->SetDocURL(doc);
 560     p->SetDocRelativeURL(reldoc);
 561
 562     bbtkDebugMessage("package",2,"<== Package::CreateFromDynamicLibrary("
 563                      <<libname<<") .. OK"<<std::endl);
 564     return p;
 565   }
 566   //==========================================================================
 567
 568
 569
 570
 571   //==========================================================================
 572   /// UnLoads the package dynamic library (if any)
 573   void Package::UnLoadDynamicLibrary(Package::WeakPointer pack, bool doit)
 574   {
 575     if (pack.expired() || (!pack.lock()->mDynamicLibraryHandler))
 576       return;
 577
 578
 579     std::string packname = pack.lock()->GetName();
 580     bbtkDebugMessage("package",5,"==> Package::UnLoadDynamicLibrary('"
 581                      <<packname<<"')"
 582                      <<std::endl);
 583
 584     if (!pack.lock()->GetDescriptorMap().empty())
 585       {
 586
 587         bbtkDebugMessage("package",5,"   Package not empty ... abort"
 588                          <<std::endl);
 589         return;
 590         /*
 591         bbtkGlobalError("Package::UnLoadDynamicLibrary('"<<packname<<") : "
 592                         <<"DescriptorMap not empty "
 593                         <<BBTK_INTERNAL_ERROR_MESSAGE);
 594         */
 595
 596       }
 597
 598     if (pack.use_count()!=1)
 599       {
 600         bbtkGlobalError("Package::UnLoadDynamicLibrary('"<<packname<<") : "
 601                         <<"empty dl package with external refs"
 602                         <<BBTK_INTERNAL_ERROR_MESSAGE);
 603       }
 604
 605     if (doit)
 606       {
 607         UnLoad(pack);
 608         bbtkDebugMessage("package",5,"==> dynamic library for package '"
 609                          <<packname<<"' closed"
 610                          <<std::endl);
 611       }
 612     else
 613       {
 614         mReleasedDynamicallyLoadedPackages.insert(pack);
 615         bbtkDebugMessage("package",1,"==> package '"<<packname
 616                          <<"' put in the 'to unload' list"
 617                          <<std::endl);
 618
 619       }
 620
 621     bbtkDebugMessage("package",5,"<== Package::UnLoadDynamicLibrary('"
 622                      <<packname<<"')"
 623                      <<std::endl);
 624
 625   }
 626   //==========================================================================
 627
 628   //==========================================================================
 629   /// UnLoads released packages that were loaded dynamically
 630   /// see UnLoadDynamicLibrary and ReleaseBlackBoxDescriptor
 631   void Package::UnLoadReleasedDynamicallyLoadedPackages()
 632   {
 633     bbtkDebugMessage("package",5,"==> Package::UnLoadReleasedDynamicallyLoadedPackages()"<<std::endl);
 634
 635     std::set<Package::WeakPointer>::iterator i;
 636
 637 //JCP- 21-04-09
 638         if(mReleasedDynamicallyLoadedPackages.size()>0){
 639                 for (i=mReleasedDynamicallyLoadedPackages.begin();
 640                 i!=mReleasedDynamicallyLoadedPackages.end();
 641                 ++i)
 642                 {
 643                 if (!i->expired()) UnLoad(*i);
 644                 }
 645         }
 646 //JCP- 21-04-09
 647     bbtkDebugMessage("package",5,"<== Package::UnLoadReleasedDynamicallyLoadedPackages()"<<std::endl);
 648   }
 649   //==========================================================================
 650
 651   //==========================================================================
 652   void Package::UnLoad(Package::WeakPointer pack)
 653   {
 654     std::string packname = pack.lock()->GetName();
 655     bbtkDebugMessage("package",6,"==> Package::UnLoad("<<packname<<")"<<std::endl);
 656
 657     Package* p = pack.lock().get();
 658
 659     DynamicLibraryHandler h = p->mDynamicLibraryHandler;
 660
 661     // deletes the package
 662     p->mDLDeletePackageFunction();
 663
 664     // closes the dl handler
 665 #if defined(__GNUC__)
 666           if (dlclose(h)!=0)
 667           {
 668                   printf("EED Package::UnLoad ERROR %s\n", packname.c_str() );
 669                   bbtkWarning("Failed to close dynamic library for package '"<<packname
 670                                           <<"'"<<std::endl);
 671           }
 672
 673 #elif defined(_WIN32)
 674     FreeLibrary(h);
 675 #endif
 676
 677     bbtkDebugMessage("package",1,"==> dynamic library for package '"
 678                      <<packname<<"' closed"
 679                      <<std::endl);
 680     bbtkDebugMessage("package",6,"   ... dynamic library unloaded"<<std::endl);
 681   }
 682   //==========================================================================
 683
 684   //==========================================================================
 685   /// Creates an instance of a black box of type <type> with name <name>
 686   BlackBox::Pointer Package::NewBlackBox(const std::string& type,
 687                                          const std::string& name) const
 688   {
 689     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()<<">::NewBlackBox(\""<<type<<"\",\""<<name<<"\")"<<bbtkendl);
 690
 691     DescriptorMapType::const_iterator i = mDescriptorMap.find(type);
 692     if (i == mDescriptorMap.end())
 693     {
 694            bbtkDebugDecTab("kernel",8);
 695            return BlackBox::Pointer();
 696     }
 697     BlackBox::Pointer bb =i->second->NewBlackBox(name);
 698     bbtkDebugDecTab("kernel",8);
 699     return bb;
 700
 701   }
 702   //==========================================================================
 703
 704
 705
 706   //==========================================================================
 707   /// Creates an instance of an adaptor of input type <typein> and
 708   /// output type <typeout>  with name <name>
 709   BlackBox::Pointer Package::NewAdaptor(const DataInfo& typein,
 710                                 const DataInfo& typeout,
 711                                 const std::string& name) const
 712   {
 713     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()<<
 714                         ">::NewAdaptor("
 715                         <<typein<<","
 716                         <<typeout<<",\""
 717                         <<name<<"\")"<<bbtkendl);
 718
 719     AdaptorKey key(typein,typeout,
 720                    BlackBoxDescriptor::DEFAULT_ADAPTOR);
 721     AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
 722     if (i == mAdaptorMap.end())
 723       {
 724         bbtkDebugDecTab("kernel",8);
 725         return BlackBox::Pointer();
 726       }
 727     BlackBox::Pointer bb =i->second.lock()->NewBlackBox(name);
 728     bbtkDebugDecTab("kernel",8);
 729     return bb;
 730
 731   }
 732   //==========================================================================
 733
 734   //==========================================================================
 735   /// Creates an instance of an adaptor of input type <typein> and
 736   /// output type <typeout>  with name <name>
 737   BlackBox::Pointer Package::NewWidgetAdaptor(const DataInfo& typein,
 738                                       const DataInfo& typeout,
 739                                       const std::string& name) const
 740   {
 741     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()<<
 742                         ">::NewWidgetAdaptor("
 743                         <<typein<<","
 744                         <<typeout<<",\""
 745                         <<name<<"\")"<<bbtkendl);
 746
 747     AdaptorKey key(typein,typeout,
 748                    BlackBoxDescriptor::DEFAULT_GUI);
 749     AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
 750     if (i == mAdaptorMap.end())
 751       {
 752         bbtkDebugDecTab("kernel",8);
 753         return BlackBox::Pointer();
 754       }
 755     BlackBox::Pointer bb =i->second.lock()->NewBlackBox(name);
 756     bbtkDebugDecTab("kernel",8);
 757     return bb;
 758
 759   }
 760   //==========================================================================
 761
 762
 763
 764   //==========================================================================
 765   /// Returns true is the package contains
 766   /// an adaptor of input type <typein> and
 767   /// output type <typeout>
 768   /// If successfull then adaptor contains the black box type name
 769   bool Package::FindWidgetAdaptor(const DataInfo& typein,
 770                                   const DataInfo& typeout,
 771                                   std::string& adaptor) const
 772   {
 773     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()<<
 774                         ">::FindWidgetAdaptor("
 775                         <<typein<<","
 776                         <<typeout<<")"<<bbtkendl);
 777
 778     AdaptorKey key(/*typein*/
 779                    DataInfo(typeid(void),""),
 780                    typeout,
 781                    BlackBoxDescriptor::DEFAULT_GUI);
 782     // First try to find a single widget adaptor
 783     AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
 784     if (i == mAdaptorMap.end())
 785       {
 786         bbtkDebugDecTab("kernel",8);
 787         return false;
 788       }
 789     adaptor = i->second.lock()->GetTypeName();
 790     bbtkDebugDecTab("kernel",8);
 791     return true;
 792
 793   }
 794   //==========================================================================
 795
 796
 797
 798   //==========================================================================
 799   /// Returns true is the package contains
 800   /// an adaptor of input type <typein> and
 801   /// output type <typeout>
 802   /// If successfull then adaptor contains the black box type name
 803   bool Package::FindAdaptor(const DataInfo& typein,
 804                             const DataInfo& typeout,
 805                             std::string& adaptor) const
 806   {
 807     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()<<
 808                         ">::FindAdaptor("
 809                         <<typein<<","
 810                         <<typeout<<")"<<bbtkendl);
 811
 812     AdaptorKey key(typein,typeout,
 813                    BlackBoxDescriptor::DEFAULT_ADAPTOR);
 814     AdaptorMapType::const_iterator i = mAdaptorMap.find(key);
 815     if (i == mAdaptorMap.end())
 816       {
 817         bbtkDebugDecTab("kernel",8);
 818         return false;
 819       }
 820     adaptor = i->second.lock()->GetTypeName();
 821     bbtkDebugDecTab("kernel",8);
 822     return true;
 823
 824   }
 825   //==========================================================================
 826
 827
 828   //==========================================================================
 829   /// Registers a black box descriptor in the package
 830   bool Package::Register(BlackBoxDescriptor::Pointer d)
 831   {
 832     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()<<">::Register(\""<<d->GetTypeName()<<"\")"<<std::endl);
 833
 834     DescriptorMapType::iterator i = mDescriptorMap.find(d->GetTypeName());
 835     if (i!=mDescriptorMap.end())
 836       {
 837         bbtkWarning("Package<"<<GetName()<<"> : Trying to register box type <"
 838                     <<d->GetTypeName()<<"> which is already in the package");
 839         return false;
 840       }
 841
 842     mDescriptorMap[d->GetTypeName()] = d;
 843     //    d->Reference();
 844     d->SetPackage(GetThisPointer<Package>());
 845
 846     // If it is a default adaptor, also register it in the adaptors map
 847     if ( d->GetKind() == BlackBoxDescriptor::DEFAULT_ADAPTOR )
 848       {
 849         bbtkDebugMessage("kernel",8,"Package<"<<GetName()<<">::Register(\""<<d->GetTypeName()<<"\") : The box is an adaptor, inserting it in adaptors map ..."<<std::endl);
 850
 851         TypeInfo typein = d->GetInputDescriptor("In")->GetTypeInfo();
 852         TypeInfo typeout = d->GetOutputDescriptor("Out")->GetTypeInfo();
 853         DataInfo infoin(typein,d->GetInputDescriptor("In")->GetNature());
 854         DataInfo infoout(typeout,d->GetOutputDescriptor("Out")->GetNature());
 855         AdaptorKey key(infoin,infoout,d->GetKind());
 856
 857         AdaptorMapType::const_iterator i;
 858         i = mAdaptorMap.find(key);
 859         if (i == mAdaptorMap.end())
 860           {
 861             mAdaptorMap[key] = d;
 862           }
 863         // If already an adaptor registered : error
 864         else
 865           {
 866             if (i->second.lock()->GetTypeName() != d->GetTypeName())
 867               {
 868                 bbtkError("Package <"<<GetName()<<
 869                           "> : trying to register black box <"
 870                           <<d->GetTypeName()
 871                           <<"> as default adaptor but there is already a default adaptor registered (<"
 872                           <<i->second.lock()->GetTypeName()<<">)");
 873               }
 874           }
 875       }
 876     // If it is a default adaptor, also register it in the adaptors map
 877     else if ( d->GetKind() == BlackBoxDescriptor::DEFAULT_GUI)
 878       {
 879         bbtkDebugMessage("kernel",8,"Package<"<<GetName()<<">::Register(\""<<d->GetTypeName()<<"\") : The box is a widget adaptor, inserting it in adaptors map ..."<<std::endl);
 880
 881         TypeInfo typeout = d->GetOutputDescriptor("Out")->GetTypeInfo();
 882         DataInfo infoin(typeid(void),"");
 883         DataInfo infoout(typeout,d->GetOutputDescriptor("Out")->GetNature());
 884         AdaptorKey key(infoin,infoout,d->GetKind());
 885
 886         AdaptorMapType::const_iterator i;
 887         i = mAdaptorMap.find(key);
 888         if (i == mAdaptorMap.end())
 889           {
 890             mAdaptorMap[key] = d;
 891           }
 892         // If already an adaptor registered : error
 893         else
 894           {
 895             if (i->second.lock()->GetTypeName() != d->GetTypeName())
 896               {
 897                 bbtkError("Package <"<<GetName()<<
 898                           "> : trying to register black box <"
 899                           <<d->GetTypeName()
 900                           <<"> as default widget adaptor but there is already a default adaptor registered (<"
 901                           <<i->second.lock()->GetTypeName()<<">)");
 902               }
 903           }
 904       }
 905
 906
 907     bbtkDebugDecTab("kernel",8);
 908
 909     return true;
 910   }
 911   //==========================================================================
 912
 913   //===================================================================
 914   void Package::Check() const
 915   {
 916     bbtkMessage("debug",1,"****** Checking Package "<<(void*)this
 917                 <<" ["<<GetName()<<"]"<<std::endl);
 918     DescriptorMapType::const_iterator i;
 919     for (i=mDescriptorMap.begin();
 920          i!=mDescriptorMap.end();
 921          ++i)
 922       {
 923         i->second->Check(true);
 924       }
 925     bbtkMessage("debug",1,"****** Checking Package "<<(void*)this
 926                 <<" ["<<GetName()<<"] ... OK"<<std::endl);
 927   }
 928   //===================================================================
 929
 930
 931   //==========================================================================
 932   /// Changes the name of a black box type
 933   void Package::ChangeDescriptorName( const std::string& oldname, const std::string& newname )
 934   {
 935     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()
 936                         <<">::ChangeDescriptorName(\""<<oldname
 937                         <<"\",\""<<newname<<"\")"<<std::endl);
 938     // Looking into the bb map
 939     DescriptorMapType::iterator i = mDescriptorMap.find(oldname);
 940     if (i == mDescriptorMap.end())
 941       {
 942          bbtkDebugDecTab("kernel",8);
 943          bbtkError("ChangeDescriptorName : The package <"<<GetName()<<"> does not contains the black box <"<<oldname<<">");
 944       }
 945
 946     i->second->SetTypeName(newname);
 947     mDescriptorMap[newname] = i->second;
 948     mDescriptorMap.erase(i);
 949
 950     bbtkDebugDecTab("kernel",8);
 951   }
 952   //==========================================================================
 953
 954
 955
 956   //==========================================================================
 957   void Package::PrintHelpListDescriptors(bool description, bool adaptors) const
 958   {
 959     unsigned int lmax = 0;
 960     std::vector<std::string> names;
 961     std::vector<std::string> kinds;
 962     std::vector<std::string> descrs;
 963
 964     DescriptorMapType::const_iterator i;
 965     for (i=mDescriptorMap.begin();
 966          i!=mDescriptorMap.end();
 967          ++i)
 968       {
 969         if ( adaptors ||
 970              ( i->second->GetKind() == BlackBoxDescriptor::STANDARD) )
 971           {
 972             std::string name("  ");
 973             name += i->second->GetTypeName();
 974             names.push_back(name);
 975
 976             std::string kind;
 977             if ( i->second->GetKind() == BlackBoxDescriptor::ADAPTOR )
 978               {
 979                 kind = std::string("[A]");
 980               }
 981             else if ( i->second->GetKind() ==
 982                       BlackBoxDescriptor::DEFAULT_ADAPTOR )
 983               {
 984                 kind = std::string("[DA]");
 985               }
 986             kinds.push_back(kind);
 987
 988             unsigned int l = name.size()+kind.size();
 989             if (l>lmax) lmax = l;
 990
 991             std::string descr;
 992             if (description)
 993               {
 994                 descr += " : ";
 995                 descr += i->second->GetDescription();
 996               }
 997             descrs.push_back(descr);
 998           }
 999       }
1000
1001
1002     std::string offs;
1003     offs.append(lmax+3,' ');
1004     std::vector<std::string>::iterator ni,ci,di;
1005     for (ni = names.begin(), ci = kinds.begin(), di = descrs.begin();
1006          ni != names.end(); ++ni, ++ci, ++di)
1007       {
1008         std::string space;
1009         space.append(lmax - ni->size() - ci->size(),' ');
1010         bbtkMessage("help",1,*ni << space << *ci );
1011         std::string d(*di);
1012         unsigned int dmax = 75 - lmax;
1013         //      while (d.size() > dmax )
1014         //  {
1015         if (d.size()>dmax)
1016           bbtkMessage("help",1,d.substr(0,dmax) << "..." << std::endl);
1017         else
1018           bbtkMessage("help",1,d << std::endl);
1019         //    d = d.substr(dmax,d.size());
1020         //  }
1021       }
1022
1023   }
1024   //==========================================================================
1025
1026   //==========================================================================
1027   /// Displays the list of adaptors of the package
1028   void Package::PrintHelpListAdaptors(bool description) const
1029   {
1030     DescriptorMapType::const_iterator i;
1031     for (i=mDescriptorMap.begin();
1032          i!=mDescriptorMap.end();
1033          ++i)
1034       {
1035         if ( i->second->GetKind() != BlackBoxDescriptor::STANDARD )
1036           {
1037             bbtkMessage("help",1,
1038                         "  "<<i->second->GetTypeName());
1039             if ( i->second->GetKind() ==
1040                  BlackBoxDescriptor::DEFAULT_ADAPTOR )
1041               {
1042                 bbtkMessage("help",1,
1043                             " [default]");
1044               }
1045             if (description)
1046               {
1047                 bbtkMessage("help",1,
1048                             " : "<<i->second->GetDescription());
1049
1050               }
1051             bbtkMessage("help",1,std::endl);
1052           }
1053       }
1054     /*
1055     AdaptorMapType::const_iterator i;
1056     for (i=mAdaptorMap.begin();
1057          i!=mAdaptorMap.end();
1058          ++i)
1059       {
1060         bbtkMessage("help",1,
1061                     "  "<<i->second->GetTypeName());
1062         if (detail_level>0)
1063           {
1064             bbtkMessage("help",1,
1065                         " : "<<i->second->GetDescription());
1066
1067           }
1068         bbtkMessage("help",1,std::endl);
1069       }
1070     */
1071   }
1072   //==========================================================================
1073
1074   //==========================================================================
1075   /// Prints help on a black box descriptor
1076   void Package::PrintHelpDescriptor(const std::string& name, bool full) const
1077   {
1078     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()
1079                         <<">::PrintHelpDescriptor(\""
1080                         <<name<<"\")"<<bbtkendl);
1081
1082     DescriptorMapType::const_iterator i = mDescriptorMap.find(name);
1083     if (i == mDescriptorMap.end())
1084       {
1085         bbtkDebugDecTab("kernel",8);
1086         bbtkError("The package <"<<GetName()<<"> does not contains the black box <"<<name<<">");
1087       }
1088     //    bbtkMessage("help",1,"["<<GetName()<<"] ");
1089     i->second->GetHelp(full);
1090     bbtkDebugDecTab("kernel",8);
1091
1092   }
1093   //==========================================================================
1094
1095
1096   //==========================================================================
1097   /// Returns true iff the package contains the box of name boxname
1098   bool Package::ContainsDescriptor(const std::string& name) const
1099   {
1100     bbtkDebugMessageInc("kernel",8,"Package<"<<GetName()
1101                         <<">::ContainsDescriptor(\""
1102                         <<name<<"\")"<<bbtkendl);
1103
1104     DescriptorMapType::const_iterator i = mDescriptorMap.find(name);
1105     if (i == mDescriptorMap.end())
1106     {
1107       bbtkDebugDecTab("kernel",8);
1108       return false;
1109     }
1110     bbtkDebugDecTab("kernel",8);
1111     return true;
1112   }
1113   //==========================================================================
1114
1115
1116
1117   //==========================================================================
1118   void Package::CreateHtmlPage(const std::string& filename,
1119                                const std::string& caller,
1120                                const std::string& source,
1121                                const std::string& custom_header,
1122                                const std::string& custom_title,
1123                                int detail,
1124                                int level,
1125                                bool relative_link ) const
1126   {
1127     bbtkDebugMessageInc("kernel",9,"Package<"<<GetName()<<">::CreateHtmlPage(\""
1128                         <<filename<<"\")"<<bbtkendl);
1129
1130 //std::cout<<"JCP bbtkPackage.cxx void Package::CreateHtmlPage() ln 1133"<<std::endl;
1131
1132     //---------------------
1133     // Open output file
1134     std::ofstream s;
1135     s.open(filename.c_str());
1136     if (!s.good())
1137     {
1138        bbtkError("Package "<<GetName()<<" : CreateHtmlPage : could not open file '"<<filename<<"'");
1139     }
1140
1141     //----------------------
1142     // Html head
1143     std::string title = "BBTK Package "+GetName()+" "+GetVersion();
1144
1145     if (custom_title.length() != 0) title = custom_title;
1146
1147     s << "<html lang=\"en\">\n";
1148     s << "<head>\n";
1149     s << "<title>" << title << "</title>\n";
1150     s << "<meta http-equiv=\"Content-Type\" content=\"text/html\">\n";
1151     s << "<meta name=\"description\" content=\""<<title<<"\">\n";
1152     s << "<meta name=\"generator\" content=\"\">\n";
1153     s << "<link title=\"Top\" rel=\"top\" href=\"#Top\">\n";
1154     //<link href="http://www.gnu.org/software/texinfo/" rel="generator-home" title="Texinfo Homepage">
1155     s << "<meta http-equiv=\"Content-Style-Type\" content=\"text/css\"><style type=\"text/css\"><!--\n";
1156     s << "pre.display { font-family:inherit }\n";
1157     s << "pre.format  { font-family:inherit }\n";
1158     s << "pre.smalldisplay { font-family:inherit; font-size:smaller }\n";
1159     s << "pre.smallformat  { font-family:inherit; font-size:smaller }\n";
1160     s << "pre.smallexample { font-size:smaller }\n";
1161     s << "pre.smalllisp    { font-size:smaller }\n";
1162     s << "span.sc    { font-variant:small-caps }\n";
1163     s << "span.roman { font-family:serif; font-weight:normal; } \n";
1164     s << "span.sansserif { font-family:sans-serif; font-weight:normal; }\n";
1165     s << "--></style>\n";
1166     s << "</head>\n";
1167     //----------------------
1168
1169     //----------------------
1170     // Html body
1171     s << "<body>\n";
1172     s << "<a name=\"Top\"></a>\n";
1173
1174     //----------------------
1175     // Header
1176     if ( custom_header.length() != 0)
1177       {
1178         if ( custom_header != "none" )
1179           {
1180             std::ifstream in;
1181             in.open(custom_header.c_str());
1182             if (!in.good())
1183               {
1184                 bbtkError("Could not open file \""<<custom_header<<"\"");
1185               }
1186             char buffer[512];
1187             while (!in.eof())
1188               {
1189                 in.getline(buffer,512);
1190                 std::string line(buffer);
1191                 s << line;
1192               }
1193             in.close();
1194             s << "<hr>\n";
1195
1196             /*
1197             s << "<object data=\"" << custom_header
1198               << "\" type = \"text/html\"\"style=\"width: 1200px; height: 400px;\"> Warning: "
1199               << custom_header <<" could not be embedded.</object>\n";
1200
1201             s << "<hr>\n";
1202             */
1203           }
1204       }
1205
1206     else
1207       {
1208         s << "<h1 class=\"settitle\">"<<title<<"</h1>\n";
1209         s << "<p><TABLE cellspacing=0  cellpadding=3>\n";
1210         s << "<TR><TD style='vertical-align: top;'><b> Description </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'> "
1211           << GetDescription() << "</TD></TR>\n";
1212         s << "<TR><TD style='vertical-align: top;'><b> Author(s) </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'>  "
1213           << GetAuthor() << "</TD></TR>\n";
1214         s << "<TR><TD style='vertical-align: top;'><b> Author(s) </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'>  "
1215           << GetCategory() << "</TD></TR>\n";
1216         s << "<TR><TD style='vertical-align: top;'><b> Version </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'> "
1217           << GetVersion() << "</TD></TR>\n";
1218         s << "<TR><TD style='vertical-align: top;'><b> bbtk Version </b></TD><TD style='vertical-align: top;'> : </TD><TD style='vertical-align: top;'> "
1219           << bbtk::GetVersion() << "</TD></TR>\n";
1220         s << "</TABLE>\n";
1221       }
1222 //std::cout<<"JCP bbtkPackage.cxx void Package::CreateHtmlPage() ln 1225"<<std::endl;
1223     //-------------------
1224     // Table of contents
1225     // Black boxes list
1226     //  s << "<div class=\"contents\">\n";
1227     s << "<p><b> Black Boxes : </b>\n";
1228     s << "<ul>\n";
1229
1230     s << "<p><TABLE cellspacing=0  cellpadding=3>\n";
1231
1232     DescriptorMapType::const_iterator i;
1233 //std::cout<<"JCP bbtkPackage.cxx void Package::CreateHtmlPage() ln 1236"<<std::endl;
1234     for (i=mDescriptorMap.begin(); i!=mDescriptorMap.end(); ++i) {
1235                 if ( i->second->GetKind() != BlackBoxDescriptor::STANDARD)
1236                         continue;
1237
1238                 std::string name = i->second->GetTypeName();
1239                 Utilities::html_format(name);
1240                 std::string descr = i->second->GetDescription();
1241                 //Utilities::html_format(descr);
1242 //std::cout<<"JCP bbtkPackage.cxx void Package::CreateHtmlPage() ln 1246"<<std::endl;
1243                 s << "<TR>";
1244                 s << "<TD style='vertical-align: top;'>";
1245                 s << "&nbsp;&nbsp;&nbsp;<a name=\"toc_"<<name
1246                 <<"\" href=\"#"<<name<<"\">"
1247                 <<name<<"</a>";
1248                 s << "</TD> ";
1249                 s << " <TD style='vertical-align: top;'>" << descr << " </TD>";
1250                 s << "</TR>\n";
1251                 }
1252                 s << "</TABLE>\n";
1253
1254
1255                 s << "</ul>\n";
1256                 s << "</div>\n";
1257
1258                 //-------------------
1259                 // Adaptors list
1260                 if (mAdaptorMap.size()>0)
1261                 {
1262                         //  s << "<div class=\"contents\">\n";
1263                         s << "<p><b> Adaptors : </b>\n";
1264                         s << "<ul>\n";
1265 //std::cout<<"JCP bbtkPackage.cxx void Package::CreateHtmlPage() ln 1268"<<std::endl;
1266                         //    DescriptorMapType::const_iterator i;
1267                         s << "<p><TABLE cellspacing=0  cellpadding=3>\n";
1268                         for (i=mDescriptorMap.begin(); i!=mDescriptorMap.end();++i)
1269                         {
1270                                 if ( i->second->GetKind() == BlackBoxDescriptor::STANDARD)
1271                                         continue;
1272
1273                                 std::string name = i->second->GetTypeName();
1274                                 Utilities::html_format(name);
1275                                 std::string descr = i->second->GetDescription();
1276
1277                                 s << "<TR>";
1278                                 s << "<TD style='vertical-align: top;'>";
1279                                 s << "&nbsp;&nbsp;&nbsp;<a name=\"toc_"<<name
1280                                   <<"\" href=\"#"<<name<<"\">"
1281                                   <<name<<"</a>";
1282                                 s << "</TD> ";
1283                                 s << " <TD style='vertical-align: top;'>" << descr << " </TD>";
1284                                 s << "</TR>\n";
1285                         }
1286                         s << "</TABLE>\n";
1287
1288                         s << "</ul>\n";
1289                         s << "</div>\n";
1290                 }
1291
1292
1293     //  s << "<div class=\"node\">\n";
1294
1295     //    s << "<p><hr>\n";
1296     //    s << "<a name=\"Top\"></a>\n";
1297     //  s << "Top:&nbsp;<a rel=\"top\" accesskey=\"t\" href=\"#Top\">Top</a>\n";
1298     // s << "Previous:&nbsp;<a rel="previous" accesskey="p" href="#dir">(dir)</a>,
1299     // s << "Up:&nbsp;<a rel="up" accesskey="u" href="#dir">(dir)</a>
1300
1301     //    s << "</div>\n";
1302
1303     //----------------------
1304     // Boxes doc
1305
1306     //-------------------
1307     // Computes output directory from filename to pass it to
1308     // BlackBoxDescriptor::InsertHtmlHelp
1309                 std::string dir;
1310
1311                 std::string::size_type slash_position = filename.find_last_of("/\\");
1312
1313
1314                 if (slash_position != std::string::npos) {
1315                         if (slash_position == 0)
1316                          slash_position = 1;
1317                         dir = filename.substr(0,slash_position);
1318                 }
1319
1320                 for (i=mDescriptorMap.begin();
1321                  i!=mDescriptorMap.end();
1322                  ++i)
1323                 {
1324                         i->second->InsertHtmlHelp(s,detail,level,dir,relative_link);
1325                 }
1326
1327     //----------------------
1328     // Footer
1329     time_t rawtime;
1330     tm * ptm;
1331     time ( &rawtime );
1332     ptm = gmtime ( &rawtime );
1333
1334     s << "<p><hr>\n";
1335     s << "Automatically generated by <b>"<<caller<<"</b> "//from <b>"
1336       //      <<source<<"</b>
1337       <<"on "
1338       << ptm->tm_mday << "/" << ptm->tm_mon << "/" << ptm->tm_year+1900
1339       << " - " << ptm->tm_hour << ":" << ptm->tm_min << " GMT\n";
1340     s << "</body></html>\n";
1341     s.close();
1342     //----------------------
1343
1344     // End
1345     bbtkDebugDecTab("kernel",9);
1346   }
1347   //==========================================================================
1348
1349   //==========================================================================
1350   std::string  Package::GetObjectName() const
1351   {
1352     return std::string("Package '")+mName+std::string("'");
1353   }
1354   //==========================================================================
1355
1356   //==========================================================================
1357   std::string Package::GetObjectInfo() const
1358   {
1359     std::stringstream i;
1360     i << "  - "<<mDescriptorMap.size() << " boxes" << std::endl;
1361     if (mDynamicLibraryHandler)
1362       {
1363         i<< "  - Loaded from dynamic library"<<std::endl;
1364       }
1365     return i.str();
1366   }
1367   //==========================================================================
1368
1369
1370   //==========================================================================
1371   size_t  Package::GetObjectSize() const
1372   {
1373     size_t s = Superclass::GetObjectSize();
1374     s += Package::GetObjectInternalSize();
1375     return s;
1376   }
1377   //==========================================================================
1378   //==========================================================================
1379   size_t  Package::GetObjectInternalSize() const
1380   {
1381     size_t s = sizeof(Package);
1382     return s;
1383   }
1384   //==========================================================================
1385   //==========================================================================
1386   size_t  Package::GetObjectRecursiveSize() const
1387   {
1388     size_t s = Superclass::GetObjectRecursiveSize();
1389     s += Package::GetObjectInternalSize();
1390
1391     DescriptorMapType::const_iterator i;
1392     for (i = mDescriptorMap.begin(); i!=mDescriptorMap.end(); ++i )
1393       {
1394         s += i->second->GetObjectRecursiveSize();
1395       }
1396     return s;
1397   }
1398   //==========================================================================
1399
1400   //==========================================================================
1401   std::set<Package::WeakPointer>
1402   Package::mReleasedDynamicallyLoadedPackages;
1403   //==========================================================================
1404 }
1405