bbtkComplexBlackBox.cxx

Go to the documentation of this file.

/*=========================================================================                                                                               
  Program:   bbtk
  Module:    $RCSfile: bbtkComplexBlackBox.cxx,v $
  Language:  C++
  Date:      $Date: 2008/10/17 08:18:12 $
  Version:   $Revision: 1.21 $
=========================================================================*/

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

* 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 "bbtkComplexBlackBox.h"
#include "bbtkWx.h"
#include "bbtkBlackBoxDescriptor.h"
#include "bbtkFactory.h"
#include "bbtkConfigurationFile.h"

namespace bbtk
{

  //==========================================================================
  ComplexBlackBox::Pointer ComplexBlackBox::New(const std::string& name,
                                                ComplexBlackBoxDescriptor::Pointer desc)
  {
    bbtkDebugMessage("object",1,"##> ComplexBlackBox::New('"<<name<<"','"<<
                     desc->GetTypeName()<<"')" <<bbtkendl);
    ComplexBlackBox::Pointer p = 
      MakeBlackBoxPointer(new ComplexBlackBox(name,desc));
    bbtkDebugMessage("object",2,"<## ComplexBlackBox::New('"<<name<<"','"<<
                     desc->GetTypeName()<<"')" <<bbtkendl);
    return p;
  }
  //==========================================================================

  //=======================================================================
  ComplexBlackBox::ComplexBlackBox(const std::string &name,
                                   ComplexBlackBoxDescriptor::Pointer desc)
    : 
    BlackBox(name),
    mLockedDescriptor(desc),
    mDescriptor(desc)
  {
    bbtkDebugMessage("object",3,
                     "##> ComplexBlackBox::ComplexBlackBox(\""
                     <<name<<"\")"<<std::endl);
    bbAllocateConnectors();
    bbtkDebugMessage("object",3,
                     "<## ComplexBlackBox::ComplexBlackBox(\""
                     <<name<<"\")"<<std::endl);
  }
  //=======================================================================

  //=======================================================================
  ComplexBlackBox::ComplexBlackBox(ComplexBlackBox& from, 
                                   const std::string &name)
    : BlackBox(from,name),
      // The locked descriptor is copied from the unlocked one 
      // to make the box a non-prototype !!
      mLockedDescriptor(from.mDescriptor),
      mDescriptor(from.mDescriptor),
     mExecutionList(from.mExecutionList)    
  {
    bbtkDebugMessage("object",3,
                        "##> ComplexBlackBox::ComplexBlackBox(\""
                        <<from.bbGetName()<<"\",\""
                        <<name<<"\")"<<std::endl);
    bbtkDebugMessage("object",4,"  * Cloning Black Boxes"<<std::endl);

    // We have to make the shared_ptr on this because it is used 
    // in bbUnsafeAddBlackBox !
    MakeBlackBoxPointer(this,true);

    BlackBoxMapType::const_iterator i;
    for ( i = from.mBlackBoxMap.begin(); i != from.mBlackBoxMap.end(); ++i ) 
      {
        bbtkDebugMessageInc("object",5,"    * Cloning \""<<i->first<<"\""<<std::endl);
        BlackBox::Pointer B = i->second->bbClone(i->second->bbGetName());
        bbUnsafeAddBlackBox(B);
      }
   
    bbtkDebugMessage("object",4,"  * Cloning Connections"<<std::endl);
    ConnectionListType::const_iterator j;
    for ( j = from.mConnectionList.begin(); j != from.mConnectionList.end(); ++j ) 
      {
        bbtkDebugMessage("object",5,"    * Cloning \""<<
                         (*j)->GetFullName()<<"\""<<std::endl);

        BlackBox::Pointer bbfrom = bbGetBlackBox( (*j)->GetOriginalBlackBoxFrom()->bbGetName() );
        BlackBox::Pointer bbto = bbGetBlackBox( (*j)->GetOriginalBlackBoxTo()->bbGetName() );

        Connection::Pointer c = mDescriptor.lock()->GetFactory()-> 
          NewConnection( bbfrom, 
                         (*j)->GetOriginalBlackBoxFromOutput(), 
                         bbto, 
                         (*j)->GetOriginalBlackBoxToInput() );
        
        //c->Check();
        bbAddConnection(c);

      }

    bbAllocateConnectors();
    bbtkDebugMessage("object",3,
                        "<## ComplexBlackBox::ComplexBlackBox(\""
                        <<from.bbGetName()<<"\",\""
                        <<name<<"\")"<<std::endl);
  }
  //=======================================================================

  //======================================================================= 
  ComplexBlackBox::~ComplexBlackBox()
  {
    bbtkDebugMessage("object",3,
                     "==> ComplexBlackBox::~ComplexBlackBox() ["
                     <<bbGetName()<<"]"<<std::endl);

    bbtkDebugMessage("object",4,
                     " -> Releasing connections"<<std::endl);
    mConnectionList.clear();
    bbtkDebugMessage("object",4,
                     " -> Releasing boxes"<<std::endl);
    mBlackBoxMap.clear();

    //    Clear();
    this->bbDesallocateConnectors();

    bbtkDebugMessage("object",3,
                     "<== ComplexBlackBox::~ComplexBlackBox() ["
                     <<bbGetName()<<"]"<<std::endl);
  } 
  //=======================================================================
 

  //=========================================================================
  void ComplexBlackBox::bbAllocateConnectors()
  {  
    bbtkDebugMessageInc("Kernel",8,
                        "ComplexBlackBox::bbAllocateConnectors() ["
                        <<bbGetFullName()<<"]"
                        <<std::endl);   
    
    // Input connectors
    const BlackBoxDescriptor::InputDescriptorMapType& imap 
      = bbGetDescriptor()->GetInputDescriptorMap(); 
    BlackBoxDescriptor::InputDescriptorMapType::const_iterator i;       
    for ( i = imap.begin(); i != imap.end(); ++i )                      
      {                                                                 
        bbtkDebugMessage("Kernel",8,"* Allocate \""<<i->first<<"\""<<std::endl);
        // Redirect the connector to the internal box connector
        // Cast the BBInputDescriptor into a ComplexBBInputDescriptor
        ComplexBlackBoxInputDescriptor* d = 
          (ComplexBlackBoxInputDescriptor*)i->second;
        // Get the internal box connector
        BlackBoxInputConnector* c = 
          bbUnsafeGetBlackBox ( d->GetTarget() )
          ->bbGetInputConnectorMap()[ d->GetInput() ];
        
        bbGetInputConnectorMap()[i->second->GetName()] = c;
      }                                                                 

    // Output connectors
    const BlackBoxDescriptor::OutputDescriptorMapType& omap 
      = bbGetDescriptor()->GetOutputDescriptorMap();                   
    BlackBoxDescriptor::OutputDescriptorMapType::const_iterator o; 
    for ( o = omap.begin(); o != omap.end(); ++o )
      {                                                 
        bbtkDebugMessage("Kernel",8,"* Allocate \""<<o->first<<"\""<<std::endl);
        // Redirect the connector to the internal box connector
        // Cast the BBOutputDescriptor into a ComplexBBOutputDescriptor
        ComplexBlackBoxOutputDescriptor* d = 
          (ComplexBlackBoxOutputDescriptor*)o->second;
        // Get the internal box connector
        BlackBoxOutputConnector* c = 
          bbUnsafeGetBlackBox ( d->GetTarget() )
          ->bbGetOutputConnectorMap()[ d->GetOutput() ];

        bbGetOutputConnectorMap()[o->second->GetName()] = c;
      }
    
    bbtkDebugDecTab("Kernel",8);  
  }
  //=========================================================================


  //=========================================================================
  void ComplexBlackBox::bbDesallocateConnectors()
  {
    bbtkDebugMessageInc("Kernel",8,
                        "ComplexBlackBox::DesallocateConnectors()"
                        <<std::endl);                                   

    // The connectors have not been allocated by the complex box 
    // but by the internal boxes. Hence **DO NOT** desallocate !
    // just clear the maps to avoid that 
    // BlackBox::bbDesallocateConnectors delete the connectors
    bbGetInputConnectorMap().clear();
    bbGetOutputConnectorMap().clear();

    bbtkDebugDecTab("Kernel",8);  

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

  //=======================================================================
  BlackBox::Pointer ComplexBlackBox::bbClone(const std::string& name)
  {
    bbtkDebugMessageInc("Kernel",9,
                        "ComplexBlackBox::bbClone(\""<<name<<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);
    
    ComplexBlackBox* CBB = new ComplexBlackBox(*this,name);
    return MakeBlackBoxPointer(CBB);
  }
  //=======================================================================

  //=======================================================================
  void ComplexBlackBox::bbExecute(bool force)
  {
    bbtkDebugMessageInc("process",2,
                        "=> ComplexBlackBox::bbExecute() ["
                        <<bbGetFullName()<<"]"<<std::endl);


    Wx::BusyCursor wait;
    
    if (mExecutionList.size() != 0) 
      {
        
        std::vector<std::string>::const_iterator i;
        for (i=mExecutionList.begin(); 
             i!=mExecutionList.end();
             ++i) 
          {
            bbtkDebugMessage("process",3," -> Executing '"<<*i<<"'"<<std::endl);
            mBlackBoxMap[*i]->bbExecute(force);
          }
      }
    else 
      {
        std::map<std::string, BlackBox::Pointer>::iterator i;
        for (i=mBlackBoxMap.begin(); i!=mBlackBoxMap.end(); ++i)
          {
            i->second->bbExecute(force);
          }
      } 

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

  //==================================================================
  void ComplexBlackBox::bbSetModifiedStatus(BlackBoxInputConnector* c)
  {
    bbtkDebugMessage("modified",1,
                        "==> ComplexBlackBox::bbSetModifiedStatus("
                     <<c<<") ["<<bbGetFullName()<<"]"<<std::endl);

    c->GetBlackBox()->bbSetModifiedStatus(c);

    /*
    bbtkDebugMessage("modified",1,
                     "<== ComplexBlackBox::bbSetModifiedStatus("
                     <<c<<") ["<<bbGetFullName()<<"]"<<std::endl);
    */
  }
  //==================================================================

  //==================================================================
  void ComplexBlackBox::bbAddToExecutionList( const std::string& name )
  {
        bbtkDebugMessageInc("Kernel",9,
                        "ComplexBlackBox::bbAddToExecutionList(\""
                        <<name<<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);

        mExecutionList.push_back( name );

     bbtkDebugDecTab("Kernel",9);   

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

  //==================================================================
  IOStatus ComplexBlackBox::bbBackwardUpdate(Connection::Pointer caller)
  {
    bbtkDebugMessageInc("process",3,
                        "==> ComplexBlackBox::bbBackwardUpdate("
                        <<(caller?caller->GetFullName():"0")<<") ["
                        <<bbGetFullName()<<"]"<<std::endl);
    //    bbtkInternalError("ComplexBlackBox::bbBackwardUpdate should never be called !");
    
    if (caller==0)
      {
        bbtkInternalError("ComplexBlackBox::bbBackwardUpdate called with caller=0");
      }

    /*
    std::cout << "CBB BUP : "<<caller->GetBlackBoxFrom()->bbGetFullName()
              <<"."<<caller->GetBlackBoxFromOutput()<<"----"
              <<caller->GetOriginalBlackBoxFrom()->bbGetFullName()
              <<"."<<caller->GetOriginalBlackBoxFromOutput()<<std::endl;
    */
      


    IOStatus s = UPTODATE;
    const BlackBoxDescriptor::OutputDescriptorMapType& omap 
      = bbGetDescriptor()->GetOutputDescriptorMap(); 
    BlackBoxDescriptor::OutputDescriptorMapType::const_iterator i 
      = omap.find(caller->GetBlackBoxFromOutput());
    if (i!=omap.end())
      { 
        // Cast the BBOutputDescriptor into a ComplexBBOutputDescriptor
        ComplexBlackBoxOutputDescriptor* d = 
          (ComplexBlackBoxOutputDescriptor*)i->second;
        // Get the internal box 
        BlackBox::Pointer b = bbUnsafeGetBlackBox ( d->GetTarget() );
        // Calls BackwardUpdate on it
        bbtkDebugMessageInc("process",4,"Internal box connected to output : "<<d->GetTarget()<<std::endl);
        // Because internal box can also be a complex box we have to 
        // temporarily change the connection BlackBoxFromOutput to the 
        // mapped one
        
        //      std::string oldout = caller->GetBlackBoxFromOutput();
        //      std::cout << "oldout = "<<oldout<<std::endl;
        //      std::cout << "tmpout = "<<d->GetOutput()<<std::endl;
        //      caller->SetBlackBoxFromOutput(d->GetOutput());
        //
        //Connection newcaller(*caller);
        //newcaller.SetBlackBoxFromOutput(d->GetOutput());
        //IOStatus s1 = b->bbBackwardUpdate(&newcaller);
        IOStatus s1 = b->bbBackwardUpdate(caller);
        //newcaller.Clear();
        // restore old output
        //      caller->SetBlackBoxFromOutput(oldout);

        // ??? STATUS OF CBBs ???
        // ??? Here it is only the final status of the boxes connected to the output 
        if (s1==MODIFIED) s=MODIFIED;
      }
    else 
      {
        bbtkError("Connection '"<<caller->GetFullName()<<"' does not point to a valid output of the complex box !");
      }

    return s;
    
  }
  //==================================================================


  //==================================================================
  Data ComplexBlackBox::bbGetOutput( const std::string &name )
  {
    bbtkDebugMessageInc("Data",7,
                        "ComplexBlackBox::bbGetOutput(\""<<name<<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);

    ComplexBlackBoxOutputDescriptor* d = 
      (ComplexBlackBoxOutputDescriptor*)
      bbGetDescriptor()->GetOutputDescriptor(name);
    
    Data p = bbGetBlackBox(d->GetTarget())->bbGetOutput(d->GetOutput());


    bbtkDebugDecTab("Data",7);
    return p;
  }
  //==================================================================

  //==================================================================
  Data ComplexBlackBox::bbGetInput( const std::string &name ) 
  {
    bbtkDebugMessageInc("Data",7,
                        "ComplexBlackBox::bbGetInput(\""<<name<<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);  

    ComplexBlackBoxInputDescriptor* d = 
      (ComplexBlackBoxInputDescriptor*)
      bbGetDescriptor()->GetInputDescriptor(name);

    Data p = bbGetBlackBox(d->GetTarget())->bbGetInput(d->GetInput());

    bbtkDebugDecTab("Data",7);
    return p;
  }
  //==================================================================

  //==================================================================
  void ComplexBlackBox::bbSetOutput( const std::string &name, Data data)
  {
    bbtkDebugMessageInc("Data",7,
                        "ComplexBlackBox::bbSetOutput(\""<<name<<"\",data) ["
                        <<bbGetFullName()<<"]"<<std::endl); 

    ComplexBlackBoxOutputDescriptor* d = 
      (ComplexBlackBoxOutputDescriptor*)
      bbGetDescriptor()->GetOutputDescriptor(name);
    
    bbGetBlackBox(d->GetTarget())->bbSetOutput(d->GetOutput(),data);

    bbtkDebugDecTab("Data",7);
  }
  //==================================================================
  
  //==================================================================
  void ComplexBlackBox::bbSetInput( const std::string &name, Data data,
                                    bool setModified)
  {
    bbtkDebugMessageInc("Data",7,
                        "ComplexBlackBox::bbSetInput(\""<<name<<"\",data) ["
                        <<bbGetFullName()<<"]"<<std::endl);  

    ComplexBlackBoxInputDescriptor* d = (ComplexBlackBoxInputDescriptor*)
      bbGetDescriptor()->GetInputDescriptor(name);

    bbGetBlackBox(d->GetTarget())->bbSetInput(d->GetInput(),data,setModified);

    bbtkDebugDecTab("Data",7);
  }
  //==================================================================

 
  //==================================================================
  void ComplexBlackBox::bbBruteForceSetInputPointer( const std::string &name, 
                                                     void* data,
                                                     bool setModified)
  {
    bbtkDebugMessageInc("Data",7,
                        "ComplexBlackBox::bbBruteForceSetInputPointer('"
                        <<name<<"',"<<data<<") ["
                        <<bbGetFullName()<<"]"<<std::endl);  

    ComplexBlackBoxInputDescriptor* d = (ComplexBlackBoxInputDescriptor*)
      bbGetDescriptor()->GetInputDescriptor(name);

    bbGetBlackBox(d->GetTarget())->bbBruteForceSetInputPointer(d->GetInput(),
                                                               data,
                                                               setModified);

    bbtkDebugDecTab("Data",7);
  }
  //==================================================================

  //=========================================================================
  void ComplexBlackBox::bbConnectInput( const std::string& name, Connection* c)
  {
    bbtkDebugMessage("connection",2,
                     "==> ComplexBlackBox::bbConnectInput(\""
                     <<name<<"\","<<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"
                     <<std::endl);       
    
   ComplexBlackBoxInputDescriptor* d = (ComplexBlackBoxInputDescriptor*)
      bbGetDescriptor()->GetInputDescriptor(name);


   BlackBox::Pointer t = bbGetBlackBox(d->GetTarget());

   bbtkDebugMessage("connection",2," - Target = "<<d->GetTarget()<<" = "<<t->bbGetFullName()<<std::endl);

   c->SetBlackBoxTo(t);
   c->SetBlackBoxToInput(d->GetInput());

   bbtkDebugMessage("connection",2," - New conn = "<<c->GetFullName()<<std::endl);
   t->bbConnectInput(d->GetInput(),c);

   bbtkDebugMessage("connection",2,
                     "<== ComplexBlackBox::bbConnectInput(\""
                     <<name<<"\","<<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"
                     <<std::endl);       
  }
  //=========================================================================


  //=========================================================================  
  void ComplexBlackBox::bbConnectOutput( const std::string& name, Connection* c)
  {
    bbtkDebugMessage("connection",2,
                     "==> ComplexBlackBox::bbConnectOutput(\""
                     <<name<<"\","<<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"<<std::endl);       

   ComplexBlackBoxOutputDescriptor* d = (ComplexBlackBoxOutputDescriptor*)
      bbGetDescriptor()->GetOutputDescriptor(name);

   BlackBox::Pointer t = bbGetBlackBox(d->GetTarget());
 
  bbtkDebugMessage("connection",2," - Target = "<<d->GetTarget()<<" = "<<t->bbGetFullName()<<std::endl);

   c->SetBlackBoxFrom(t);
   c->SetBlackBoxFromOutput(d->GetOutput());

   bbtkDebugMessage("connection",2," - New conn = "<<c->GetFullName()<<std::endl);

   t->bbConnectOutput(d->GetOutput(),c);
  
    bbtkDebugMessage("connection",2,
                     "<== ComplexBlackBox::bbConnectOutput(\""
                     <<name<<"\","<<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"<<std::endl);       
  }
  //=========================================================================


  //==================================================================
  void ComplexBlackBox::bbAddBlackBox( BlackBox::Pointer b)
  {
    bbtkDebugMessageInc("Kernel",7,
                        "ComplexBlackBox::AddBlackBox(\""<<b->bbGetName()
                        <<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);  
    
    if ( bbUnsafeGetBlackBox(b->bbGetName()) ) 
      {
        bbtkError("a black box called \""<<b->bbGetName()
                  <<"\" already exists");
      }
    b->bbSetParent(GetThisPointer<ComplexBlackBox>());
    mBlackBoxMap[b->bbGetName()] = b;

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

  //==================================================================
  void ComplexBlackBox::bbUnsafeAddBlackBox( BlackBox::Pointer b)
  {
    bbtkDebugMessageInc("Kernel",7,
                        "ComplexBlackBox::UnsafeAddBlackBox(\""<<b->bbGetName()
                        <<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);  
    
    b->bbSetParent(GetThisPointer<ComplexBlackBox>());
    mBlackBoxMap[b->bbGetName()] = b;

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

  //==================================================================
  void ComplexBlackBox::bbRemoveBlackBox( const std::string& name, 
                                          bool remove_connections )
  {
    bbtkDebugMessageInc("Kernel",7,
                        "ComplexBlackBox::RemoveBlackBox(\""<<name<<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);  

    BlackBoxMapType::iterator i = mBlackBoxMap.find(name);
    if ( i == mBlackBoxMap.end() ) 
      {
        bbtkError("the black box \""<<name<<"\" does not exist");
      }
    BlackBox::WeakPointer p = i->second;
    
    if (remove_connections)
      {
        ConnectionListType::const_iterator j;
        for ( j = mConnectionList.begin(); 
              j != mConnectionList.end(); ++j ) 
          {
            (*j)->Check();
          }
      }
    if (p.use_count()!=1) 
      {
        bbtkError("the black box \""<<name<<"\" is still connected");
      }
    
    mBlackBoxMap.erase(i);
    

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

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

  //==================================================================
  void ComplexBlackBox::bbAddConnection( Connection::Pointer c)
  {
    bbtkDebugMessageInc("Kernel",7,
                        "ComplexBlackBox::AddConnection(\""<<"..."<<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);  

    mConnectionList.push_back(c);

    bbtkDebugDecTab("Kernel",7);
  }
  //==================================================================
  //    void RemoveConnection( );

  //==================================================================
  BlackBox::Pointer ComplexBlackBox::bbGetBlackBox( const std::string& name )
  {
    bbtkDebugMessageInc("Kernel",9,
                        "ComplexBlackBox::GetBlackBox(\""<<name<<"\") ["
                        <<bbGetFullName()<<"]"<<std::endl);  

    BlackBoxMapType::iterator i = mBlackBoxMap.find(name);
    if ( i == mBlackBoxMap.end() ) 
      {
        bbtkError("the black box \""<<name<<"\" does not exist");
      }

    bbtkDebugDecTab("Kernel",9);
    return i->second;
  }
  //==================================================================

  //==================================================================
  BlackBox::Pointer ComplexBlackBox::bbUnsafeGetBlackBox( const std::string& name )
  {
    bbtkDebugMessageInc("Kernel",9,
                        "ComplexBlackBox::UnsafeGetBlackBox(\""<<name<<"\") ["
                        <<bbGetFullName()<<"]"
                        <<std::endl);  

    BlackBoxMapType::iterator i = mBlackBoxMap.find(name);
    if ( i == mBlackBoxMap.end() ) 
      {
        bbtkDebugDecTab("Kernel",9);
        return BlackBox::Pointer();
      }

    bbtkDebugDecTab("Kernel",9);
    return i->second;
    
  }
  //==================================================================

  //==================================================================
  void ComplexBlackBox::bbPrintBlackBoxes()
  {
    bbtkDebugMessageInc("Kernel",9,
                        "ComplexBlackBox::PrintBlackBoxes() ["
                        <<bbGetFullName()<<"]"
                        <<std::endl);  

    BlackBoxMapType::iterator i;
    for ( i = mBlackBoxMap.begin(); i != mBlackBoxMap.end(); ++i ) 
      {
        bbtkMessage("Help",1,i->second->bbGetFullName()<<std::endl);
      }

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


 
  //=========================================================================
  void ComplexBlackBox::bbWriteDotInputOutputName(FILE *ff,bool inputoutput,int detail, int level)
  {
    if (inputoutput)
      {
        fprintf(ff,"%s_IN_%p",bbGetTypeName().c_str(),this);
      } else {
      fprintf(ff,"%s_OUT_%p",bbGetTypeName().c_str(),this);
    } // if inputoutput
  }
  //=========================================================================


  //=========================================================================
  BlackBox::Pointer ComplexBlackBox::bbFindBlackBox(const std::string &blackboxname)
  {
    BlackBox::Pointer blackbox;
    std::string subname="";
    std::string restname="";
    std::string delimiters(">");
    // Skip delimiters at beginning.
    std::string::size_type lastPos = blackboxname.find_first_not_of(delimiters, 0);
    // Find first "non-delimiter".
    std::string::size_type pos     = blackboxname.find_first_of(delimiters, lastPos);
            
    // Found a token, add it to the vector.
    subname = blackboxname.substr(lastPos, pos - lastPos);
    restname = blackboxname.substr(lastPos+pos - lastPos+1, 999);

    if (restname==subname)
    {
           restname="";
    }

    BlackBoxMapType::iterator i = mBlackBoxMap.find(subname);
    if ( i != mBlackBoxMap.end() ) 
    {
       blackbox = i->second;
       if (restname!="")
            {
             blackbox = blackbox->bbFindBlackBox(restname);
            }
    }
    return blackbox;
  }
  //=========================================================================

  //=========================================================================
  void ComplexBlackBox::bbInsertHTMLGraph(  std::ofstream& s, 
                                            int detail, 
                                            int level,
                                            bool instanceOrtype,
                                            const std::string& output_dir,
                                            bool relative_link )
  {
    
    std::string directory(output_dir);

    if (output_dir.length() == 0) 
    {
           // Don't pollute the file store with  "temp_dir" directories ... 
           std::string default_temp_dir = ConfigurationFile::GetInstance().Get_default_temp_dir();
           directory =  default_temp_dir + "/" + "temp_dir";
    }
    
    std::string simplefilename  (this->bbGetTypeName()+"_"+this->bbGetName());
    std::string simplefilename_png (simplefilename+".png");
    std::string filename           (directory+"/"+simplefilename);
    std::string filename_png       (filename+".png");
    std::string filename_cmap      (filename+".cmap");
    std::string filename_dot       (filename+".dot");

    std::string filename_png2   ("\""   + filename_png  + "\"");
    std::string filename_cmap2  ("\""   + filename_cmap + "\"");
    std::string filename_dot2   ("\""   + filename_dot  + "\"");
    

    std::string command1 ("dot -T png -o "  
                          + filename_png2  + " " + filename_dot2);
    std::string command1a("dot -T cmap -o " 
                          + filename_cmap2 + " " + filename_dot2);

    // 1. Generating .dot file
    FILE *ff;
    ff = fopen(filename_dot.c_str(),"w");
    fprintf(ff,"digraph bbtk_graph{\n");
    fprintf(ff,"rankdir=LR%s\n",";");
    fprintf(ff,"node [shape=record]%s\n",";");

    this->bbWriteDotFileBlackBox(ff,
                                 GetThisPointer<ComplexBlackBox>(),
                                 detail,level,
                                 instanceOrtype,
                                 relative_link );

    fprintf(ff,"}\n");
    fclose(ff);

    // 2. Executing .dot file -> png
    system( command1.c_str() );   
    // 3. Executing .dot file -> cmap
    system( command1a.c_str() );  
    
    // 4. HTML code insertion
    // 4.1 image
    (s) << "<center><img src=\"" << simplefilename_png 
         <<   "\" border=\"0\" usemap=\"#map_"<< simplefilename 
         <<"\" alt=\"\"></center>\n";

    // 4.2 map
    (s) << "<map name=\"map_"<< simplefilename <<"\">\n";
    FILE *ff2;
    char c;
    ff2=fopen(filename_cmap.c_str(),"r");
    while (!feof(ff2))
    {
           c=fgetc(ff2);
           if (c!=-1)
           {
              (s) << c;
           }
    }
    (s) << "</map>\n\n";
    
    // End
  }
  //=========================================================================


  //=========================================================================
  void ComplexBlackBox::bbWriteDotFileBlackBox(FILE *ff,
                                               BlackBox::Pointer parentblackbox, 
                                               int detail, int level,
                                               bool instanceOrtype,
                                               bool relative_link )   
  {
    std::string tmp1;
    std::string valueStr("");
    Package::Pointer package = this->bbGetDescriptor()->GetPackage(); 

    if (package!=NULL)
    {
      if (relative_link)
             tmp1 = this->bbGetDescriptor()->GetPackage()->GetDocRelativeURL();
           else 
             tmp1 = this->bbGetDescriptor()->GetPackage()->GetDocURL();
    } 
    else 
    {
           tmp1 = "Caspitas";
    }

    std::string tmp2=bbGetTypeName();
    std::string url(tmp1 + "#" + tmp2 );        
    fprintf( ff , "subgraph cluster_%s_%p {\n",bbGetName().c_str(),this);

    if (!(   (bbGetTypeName()=="workspace") && (bbGetName()=="workspacePrototype")) )
    {
           fprintf( ff , "  URL = \"%s\" %s",url.c_str(),";");
    }

    std::string boxname="["+bbGetTypeName()+"]";
    if (GetThisPointer<ComplexBlackBox>()!=parentblackbox)
    {
       if (detail==0)
            {
          boxname=bbGetName();
       } 
       else 
       {
          boxname = bbGetName();
          boxname = boxname + "   [" +this->bbGetDescriptor()->GetPackage()->GetName()+"::"+ bbGetTypeName() + "]";
            }

    }
    fprintf( ff , "  label = \"%s\"%s\n",  boxname.c_str() ,";");



    //  fprintf( ff , "  style=filled%s\n",";");
    //  fprintf( ff , "  color=grey%s\n",";");
    fprintf( ff , "  node [style=filled]%s\n",";");
    fprintf( ff , "  fillcolor=grey%s\n",";");
    fprintf( ff , "  edge [color=blue]%s\n",";");


    // Labels Salida
    std::string labelStr1;
    std::string labelStr2;
    labelStr1 = boxname + "\\n(output)" ; 
    labelStr2 = " | {{ ";
    bool tmp; 
    tmp=false;
    OutputConnectorMapType::iterator i;

    const BlackBoxDescriptor::OutputDescriptorMapType& omap = this->bbGetDescriptor()->GetOutputDescriptorMap();
    BlackBoxDescriptor::OutputDescriptorMapType::const_iterator o;      
    for ( o = omap.begin();  o != omap.end(); ++o ) 
      {
        if (tmp==true)
          {
            labelStr2=labelStr2+" | ";
          }
        tmp=true;
        if (instanceOrtype==true)
          {
            valueStr = this->bbGetOutputAsString(o->second->GetName()/*
                                                                   ,factory*/) + " = ";
          } 
        labelStr2=labelStr2+"<"+o->second->GetName().c_str()+"> " + valueStr + o->second->GetName().c_str();
      }

    labelStr2 = labelStr2+ " } }";



    if (detail==1)
      {
        labelStr1 = labelStr1 + labelStr2;
      }

    if (tmp){
      fprintf(ff,"  " );
      bbWriteDotInputOutputName(ff,false,detail,level);
      fprintf( ff , " [shape=record, style=filled,fillcolor=grey,color=red,label=\"%s\"]%s\n",labelStr1.c_str(),";" );
    }


    // label Entrada
    labelStr1 = boxname + "\\n(input)" ; 
    labelStr2 = " | {{ "; 
    tmp=false;
    InputConnectorMapType::iterator ii;

    const BlackBoxDescriptor::InputDescriptorMapType& imap = this->bbGetDescriptor()->GetInputDescriptorMap();  
    BlackBoxDescriptor::InputDescriptorMapType::const_iterator iii;
    for ( iii = imap.begin();  iii != imap.end(); ++iii ) 
      {
        if (tmp==true)
          {
            labelStr2=labelStr2+" | ";
          }
        tmp=true;
        if (instanceOrtype==true)
          {
            valueStr = this->bbGetInputAsString(iii->second->GetName()/*,factory*/) + " = ";
          } 
        labelStr2=labelStr2+"<"+iii->second->GetName().c_str()+"> " + valueStr + iii->second->GetName().c_str();
      }


    labelStr2 = labelStr2+ " } }";
    if (detail==1)
      {
        labelStr1 = labelStr1 + labelStr2;
      }
    if (tmp){
      fprintf(ff,"  " );
      bbWriteDotInputOutputName(ff,true,detail,level);
      fprintf( ff , " [shape=record, style=filled,fillcolor=grey,color=red,label=\"%s\"]%s\n",labelStr1.c_str(),";" );
    }


    // Body
    BlackBoxMapType::iterator j;
    for ( j = mBlackBoxMap.begin(); j != mBlackBoxMap.end(); ++j ) 
      {
        if (level>-1)
          {
            j->second->bbWriteDotFileBlackBox(ff,
                                              parentblackbox,
                                              detail,
                                              level-1,
                                              instanceOrtype,
                                              relative_link);
          }
      }

    fprintf( ff , "}\n\n");

    fprintf( ff , "  edge[color=blue]%s\n",";");

    if (level>-1)
      {
        // Relation Input  with the inside BlackBox of the this ComplexBlackbox
        ComplexBlackBoxDescriptor::InputDescriptorMapType::iterator xx;
        ComplexBlackBoxDescriptor::InputDescriptorMapType idmt=bbGetDescriptor()->GetInputDescriptorMap();
        for ( xx = idmt.begin(); xx != idmt.end(); ++xx ) 
          {
            ComplexBlackBoxInputDescriptor *cbbid = (ComplexBlackBoxInputDescriptor*)xx->second;

            fprintf(ff,"  ");
            bbWriteDotInputOutputName(ff,true,detail,level);
            if (detail==1)
              {
                fprintf(ff,":%s",cbbid->GetName().c_str() );
              }
            fprintf(ff,"->" );
            BlackBox::Pointer bb = bbGetBlackBox( cbbid->GetTarget() ); 
            bb->bbWriteDotInputOutputName(ff,true,detail,level);
            if (detail==1)
              {
                fprintf(ff,":%s \n", cbbid->GetInput().c_str() );
              }
          }// for xx



        fprintf(ff,"\n \n");



        // Relation Output ComplexBlackBox
        ComplexBlackBoxDescriptor::OutputDescriptorMapType::iterator yy;
        ComplexBlackBoxDescriptor::OutputDescriptorMapType odmt=bbGetDescriptor()->GetOutputDescriptorMap();
        for ( yy = odmt.begin(); yy != odmt.end(); ++yy ) 
          {
            ComplexBlackBoxOutputDescriptor *cbbod = (ComplexBlackBoxOutputDescriptor*)yy->second;
            fprintf(ff,"  ");
            BlackBox::Pointer bb = bbGetBlackBox( cbbod->GetTarget() ); 
            bb->bbWriteDotInputOutputName(ff,false,detail,level);
            if (detail==1)
              {
                fprintf(ff,":%s", cbbod->GetOutput().c_str() );
              }
            fprintf(ff,"->" );
            bbWriteDotInputOutputName(ff,false,detail,level);
            if (detail==1)
              {
                fprintf(ff,":%s",cbbod->GetName().c_str() );
              }
            fprintf(ff,"\n");
          } // for yy

      } // if level



        // Relation from the out side of this ComplexBlackBox with its Inputs
    if (GetThisPointer<ComplexBlackBox>()!=parentblackbox) {
      for ( ii = bbGetInputConnectorMap().begin(); 
            ii != bbGetInputConnectorMap().end(); ++ii ) 
        {
          if (ii->second)
            {
              Connection* con = ii->second->GetConnection();
              if (con!=NULL){
                BlackBox::Pointer a=con->GetOriginalBlackBoxFrom();
                BlackBox::Pointer b=con->GetOriginalBlackBoxTo();
                fprintf(ff,"  ");
                a->bbWriteDotInputOutputName(ff,false,detail,level);
                if (detail==1)
                  {
                    fprintf(ff,":%s",con->GetOriginalBlackBoxFromOutput().c_str());
                  }
                fprintf(ff,"->");
                b->bbWriteDotInputOutputName(ff,true,detail,level);
                if (detail==1)
                  {
                    fprintf(ff,":%s",con->GetOriginalBlackBoxToInput().c_str());
                  }
                fprintf(ff,"%s\n",";");
              } // if con
            } // if second
        } // for
    } // if parentblackbox
  }
  //=========================================================================
  



  /*

  //=======================================================================
  void ComplexBlackBox::GetPackagesDependencies(std::vector<Package*>& deps)
  {
    deps.clear;
    BlackBoxMapType::iterator i;
    for ( i = mBlackBoxMap.begin(); i != mBlackBoxMap.end(); ++i ) 
      {
        deps.push_back(i->second->bbGetDescriptor()->GetPackage());
      }

  }
  //=======================================================================
  */

  //=======================================================================
  void ComplexBlackBox::Check(bool recursive)
  {
     bbtkMessage("debug",1,"**** Checking Complex Black Box "<<(void*)this
                 <<" ["<<bbGetFullName()<<"]"<<std::endl);
     
     BlackBoxMapType::const_iterator i;
     for ( i = mBlackBoxMap.begin(); i != mBlackBoxMap.end(); ++i ) 
       {
         i->second->Check(recursive);
       }
     ConnectionListType::const_iterator j;
     for ( j = mConnectionList.begin(); 
           j != mConnectionList.end(); ++j ) 
       {
         (*j)->Check();
       }
     bbtkMessage("debug",1,"**** Checking Complex Black Box "<<(void*)this
                 <<" ["<<bbGetFullName()<<"] ... OK"<<std::endl);
  
  }
  //=======================================================================

  //=========================================================================
  std::string ComplexBlackBox::bbGetNameWithParent() const
  {
    if (!IsAPrototype()) return BlackBox::bbGetNameWithParent();
    if (bbGetDescriptor()) 
      {
        return bbGetDescriptor()->GetFullTypeName() + ":" + bbGetName();
      }
    else 
      {
        return std::string(":") + bbGetName();
      }
  } 
  //=========================================================================

  //==========================================================================
  std::string ComplexBlackBox::GetObjectName() const
  {
    return std::string("ComplexBlackBox '")+bbGetNameWithParent()
      +std::string("'");
  }
  //==========================================================================
  
  //==========================================================================
  std::string ComplexBlackBox::GetObjectInfo() const 
  {
    std::stringstream i;
    i << "  - "<<mBlackBoxMap.size() << " boxes / "
      <<mConnectionList.size() << " connections" << std::endl;
    return i.str();
  }
  //==========================================================================

  //==========================================================================
  size_t  ComplexBlackBox::GetObjectSize() const 
  {
    size_t s = Superclass::GetObjectSize();
    s += ComplexBlackBox::GetObjectInternalSize();
    return s;
  }
  //==========================================================================
  //==========================================================================
  size_t  ComplexBlackBox::GetObjectInternalSize() const 
  {
    size_t s = sizeof(ComplexBlackBox);
    return s;
  }
  //==========================================================================
  //==========================================================================
  size_t  ComplexBlackBox::GetObjectRecursiveSize() const 
  {
    size_t s = Superclass::GetObjectRecursiveSize();
    s += ComplexBlackBox::GetObjectInternalSize();
    BlackBoxMapType::const_iterator i;
    for ( i = mBlackBoxMap.begin(); i != mBlackBoxMap.end(); ++i ) 
      {
        s += i->second->GetObjectRecursiveSize();
      }
    ConnectionListType::const_iterator j;
    for ( j = mConnectionList.begin(); 
          j != mConnectionList.end(); ++j ) 
      {
        s += (*j)->GetObjectRecursiveSize();
      }
    return s;
  }
  //==========================================================================

}