bbtkBlackBox.cxx

Go to the documentation of this file.

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

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

* 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 "bbtkBlackBox.h"
#include "bbtkPackage.h"
#include "bbtkMessageManager.h"
#include "bbtkFactory.h"

#include "bbtkConfigurationFile.h"
#include "bbtkWxBlackBox.h"

#include <fstream>
//#include <vector>


namespace bbtk
{


  static bool bbmgSomeBoxExecuting = false;
  static bool bbmgFreezeExecution = false;
  static std::set<BlackBox::Pointer> bbmgExecutionList;

  //=========================================================================
  BlackBox::Deleter::Deleter()
  {
  }
  //=========================================================================
  
  //=========================================================================
  void BlackBox::Deleter::Delete(Object* p)
  {
    BlackBox* b = dynamic_cast<BlackBox*>(p);
    if (!b)
      {
        bbtkInternalError("BlackBox::Deleter::Delete("<<p->GetObjectName()
                          <<"["<<p<<"]) : "
                          <<"dynamic cast to BlackBox* failed !");
      }
    std::string name = p->GetObjectName();//b->bbGetNameWithParent();
    bbtkDebugMessage("object",2,"##> BlackBox::Deleter(\""<<name<<"\")"<<std::endl);


    BlackBoxDescriptor::WeakPointer desc = b->bbGetDescriptor();
    bbtkDebugMessage("object",2,"##> BlackBox::Deleter(\""<<name<<"\") : deleting black box"<<std::endl);
    
    b->bbDelete();

    bbtkDebugMessage("object",2,"##> BlackBox::Deleter(\""<<name<<"\") : releasing descriptor ["<<desc.lock()<<"]"<<std::endl);
    
    if (!desc.expired()) 
      {
        Package::WeakPointer pack = desc.lock()->GetPackage();
        if (!pack.expired()) 
          {
            Package::ReleaseBlackBoxDescriptor(pack,desc);
          }
        else 
          {
            bbtkDebugMessage("object",2,"##> BlackBox::Deleter(\""<<name<<"\") : descriptor package expired (was not held by a package and the box was the last instance)"<<std::endl);
          }
      }
    else
      {
        bbtkDebugMessage("object",2,"##> BlackBox::Deleter(\""<<name<<"\") : descriptor expired : nothing to do (was not held by a package or the box is a complex black box prototype)"<<std::endl);
      }
    bbtkDebugMessage("object",2,"<## BlackBox::Deleter(\""<<name<<"\")"<<std::endl);
  }
  //=========================================================================

  //=========================================================================
  BlackBox::BlackBox(const std::string &name) 
    : 
    bbmStatus(MODIFIED), 
    bbmName(name),
    bbmBoxProcessMode("Pipeline"),
    bbmParent()
    
  {
    bbtkDebugMessage("object",4,"==> BlackBox::BlackBox(\""
                     <<name<<"\")"<<std::endl);
    bbtkDebugMessage("object",4,"<== BlackBox::BlackBox(\""
                     <<name<<"\")"<<std::endl);
  }
  //=========================================================================

  //=========================================================================
  BlackBox::BlackBox(const BlackBox&)
  {}

  //=========================================================================
  BlackBox::BlackBox(BlackBox& from, const std::string &name) 
    :
      bbmStatus(from.bbmStatus), 
      bbmName(name), 
      bbmBoxProcessMode(from.bbmBoxProcessMode),
      bbmParent()

  {
    bbtkDebugMessage("object",4,"==> BlackBox::BlackBox("
                     <<from.bbGetFullName()<<",\""
                     <<name<<"\")"<<std::endl);
    bbtkDebugMessage("object",4,"<== BlackBox::BlackBox("
                     <<from.bbGetFullName()<<",\""
                     <<name<<"\")"<<std::endl);
  }
  //=========================================================================


  //=========================================================================
  BlackBox::~BlackBox()
  {
    bbtkDebugMessage("object",4,"==> BlackBox::~BlackBox() ["<<bbmName
                     <<"]"<<std::endl);
    this->bbDesallocateConnectors();
    bbtkDebugMessage("object",4,"<== BlackBox::~BlackBox() ["<<bbmName
                     <<"]"<<std::endl);
  }
  //=========================================================================


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

    // If execution frozen : return
    if (bbGlobalGetFreezeExecution()) 
      {
        bbtkDebugMessage("process",2,
                         " -> FreezeExecution global flag is 'true' : abort execution"<<std::endl);
      }

    BBTK_BUSY_CURSOR;

    // If force is true then update is triggered even if the box is UPTODATE
    if (force) bbSetModifiedStatus();

    // Calls the main recursive update method 
    bbBackwardUpdate(Connection::Pointer());

    bbtkDebugMessageDec("process",2,
                        "<= BlackBox::bbExecute() ["
                        <<bbGetFullName()<<"]"<<std::endl);
  }
  //=========================================================================

  //=========================================================================
  std::string BlackBox::bbGetFullName() const
  { 
    return this->bbGetNameWithParent()+"<"+this->bbGetDescriptor()->GetTypeName()+">";
  }
  //=========================================================================
     


  //=========================================================================
  std::string BlackBox::bbGetNameWithParent() const
  {
    if (bbmParent.lock()) 
      {
        return bbmParent.lock()->bbGetNameWithParent() + ":" + bbmName;
      }
    else 
      {
        return bbmName;
      }
  } 
  //=========================================================================

  //=========================================================================
  void BlackBox::bbGetHelp(bool full) const
  {
    bbGetDescriptor()->GetHelp(full); 
  }
  //=========================================================================


  //=========================================================================
  bool BlackBox::bbHasInput(const std::string& name) const
  {
    bbtkDebugMessageInc("Kernel",8,
                        "BlackBox::bbHasInput(\""
                        <<name<<"\") ["<<bbGetFullName()<<"]"
                        <<std::endl);
    bool r = ( bbGetDescriptor()->GetInputDescriptorMap().find(name)
               != bbGetDescriptor()->GetInputDescriptorMap().end());
    bbtkDebugDecTab("Kernel",8);
    return r;
  }
  //=========================================================================


  //=========================================================================  
  bool BlackBox::bbHasOutput(const std::string& name) const
  {
    bbtkDebugMessageInc("Kernel",8,"BlackBox::bbHasOutput(\""
                        <<name<<"\") ["<<bbGetFullName()<<"]"<<std::endl);
    bool r = ( bbGetDescriptor()->GetOutputDescriptorMap().find(name)
               != bbGetDescriptor()->GetOutputDescriptorMap().end());
    bbtkDebugDecTab("Kernel",8);
    return r;
  }
  //=========================================================================


  //=========================================================================  
  TypeInfo BlackBox::bbGetOutputType( const std::string &name ) const 
  {
    bbtkDebugMessageInc("Kernel",8,
                        "BlackBox::bbGetOutputType(\""
                        <<name<<"\") ["<<bbGetFullName()<<"]"<<std::endl);
    TypeInfo r = bbGetDescriptor()->GetOutputDescriptor(name)->GetTypeInfo();
    bbtkDebugDecTab("Kernel",8); 
    return r;
  }
  //=========================================================================

  //=========================================================================
  TypeInfo BlackBox::bbGetInputType( const std::string &name ) const
  {
    bbtkDebugMessageInc("Kernel",8,
                        "BlackBox::bbGetInputType(\""
                        <<name<<"\") ["<<bbGetFullName()<<"]"<<std::endl);
    TypeInfo r = bbGetDescriptor()->GetInputDescriptor(name)->GetTypeInfo();
    bbtkDebugDecTab("Kernel",8);
    return r;
  }
  //=========================================================================


  //=========================================================================
  void BlackBox::bbAllocateConnectors()
  {  
    bbtkDebugMessageInc("Kernel",8,
                        "BlackBox::bbAllocateConnectors() ["
                        <<bbGetFullName()<<"]"
                        <<std::endl);                                   
    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);
        bbGetInputConnectorMap()[i->second->GetName()] 
          = new BlackBoxInputConnector(GetThisPointer<BlackBox>());
      }                                                                 
    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);
        bbGetOutputConnectorMap()[o->second->GetName()] 
          = new BlackBoxOutputConnector();
      }
    bbtkDebugDecTab("Kernel",8);  
  }
  //=========================================================================


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

    InputConnectorMapType::const_iterator i;
    for ( i = bbGetInputConnectorMap().begin();
          i != bbGetInputConnectorMap().end(); ++i )                   
      {                                                                 
        bbtkDebugMessage("Kernel",8,"* Delete \""<<i->first<<"\""<<std::endl);
        delete (i->second);
      }                                                                 
    OutputConnectorMapType::const_iterator o;   
    for ( o = bbGetOutputConnectorMap().begin(); 
          o != bbGetOutputConnectorMap().end(); ++o )                   
      {                                                                 
        bbtkDebugMessage("Kernel",8,"* Delete \""<<o->first<<"\""<<std::endl);         
        delete (o->second);
      }                                                                 
   
    bbtkDebugDecTab("Kernel",8);  

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


  //=========================================================================
  void BlackBox::bbCopyIOValues(BlackBox& from)
  {
    bbtkDebugMessageInc("Kernel",9,
                        "BlackBox::bbCopyIOValues("
                        <<from.bbGetFullName()<<") ["
                        <<bbGetFullName()<<"]"<<std::endl);
    // copies the input values
    const BlackBoxDescriptor::InputDescriptorMapType& imap 
      = bbGetDescriptor()->GetInputDescriptorMap(); 
    BlackBoxDescriptor::InputDescriptorMapType::const_iterator i;       
    for ( i = imap.begin(); i != imap.end(); ++i )                      
      {         
        if (! i->second->GetCopyConstruct() ) continue;
        std::string input = i->second->GetName();
        this->bbSetInput(input, from.bbGetInput(input) );
      }                                                                 
    // copies the output values
    const BlackBoxDescriptor::OutputDescriptorMapType& omap 
      = bbGetDescriptor()->GetOutputDescriptorMap();                   
    BlackBoxDescriptor::OutputDescriptorMapType::const_iterator o; 
    for ( o = omap.begin(); o != omap.end(); ++o )
      {                                                 
        if (! o->second->GetCopyConstruct() ) continue;
        std::string output = o->second->GetName();
        this->bbSetOutput(output, from.bbGetOutput(output) );
      }

    bbtkDebugDecTab("Kernel",9);

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



  //=========================================================================
  bool BlackBox::bbCanReact() const 
  { 
    return ( bbGlobalGetSomeBoxExecuting() 
#ifdef _USE_WXWIDGETS_
             || Wx::IsSomeWindowAlive() 
#endif
             ); 
  }
  //=========================================================================



  //=========================================================================
  void BlackBox::bbUserDelete() 
  {   
    bbtkDebugMessage("process",5,
                     "=> BlackBox::bbUserDelete() ["
                     <<bbGetFullName()<<"]"
                     <<" : not overloaded; using standard deletion"
                     <<std::endl);
    delete this;
  }
  //=========================================================================


  //=========================================================================
  BlackBox::BoxProcessModeValue BlackBox::bbGetBoxProcessModeValue() const
  {
    const std::string& p = bbmBoxProcessMode;
    if ( (p == "0") ||
         (p == "P") || (p == "p") ||
         (p == "Pipeline") || (p == "pipeline") ) return Pipeline;
    if ( (p == "1") ||
         (p == "A") || (p == "a") ||
         (p == "Always") || (p == "always") ) return Always;
    if ( (p == "2") ||
         (p == "R") || (p == "r") ||
         (p == "Reactive") || (p == "reactive") ) return Reactive;
    bbtkError(bbGetFullName()<<" : BoxProcessMode value '"<<p
              <<"' unknown. Possible values : "
              <<"'0'/'P'/'p'/'Pipeline'/'pipeline' | "
              <<"'1'/'A'/'a'/'Always'/'always' | "
              <<"'2'/'R'/'r'/'Reactive'/'reactive'"<<std::endl);
  }
  //=========================================================================
  
  //=========================================================================
  bool  BlackBox::bbBoxProcessModeIsReactive() const
  {
    return (bbGetBoxProcessModeValue() == Reactive);
  }
  //=========================================================================

  //=========================================================================
  bool  BlackBox::bbBoxProcessModeIsAlways() const
  {
    return (bbGetBoxProcessModeValue() == Always);
  }
  //=========================================================================

  //=========================================================================
  void BlackBox::bbSetModifiedStatus(BlackBoxInputConnector* c)
  {
    bbtkDebugMessage("modified",1,
                     "==> BlackBox::bbSetModifiedStatus("<<c<<") ["
                     <<bbGetFullName()<<"]"<<std::endl);
    
    if ( (c==bbGetInputConnectorMap().find("WinHide")->second) )
      //         && (bbCanReact()))
      {
        bbtkDebugMessage("modified",2,
                         "-> Hide triggered by WinHide input change"
                         <<std::endl);
        this->bbHideWindow();
        this->bbSetStatus(MODIFIED); 
        return;
      }
    if ( (c==bbGetInputConnectorMap().find("WinClose")->second) )
      //         && (bbCanReact()))
      {
        bbtkDebugMessage("modified",2,
                         "-> Close triggered by WinClose input change"
                         <<std::endl);
        this->bbHideWindow();
        this->bbSetStatus(MODIFIED); 
        return;
      }
    
    if ( ( bbBoxProcessModeIsReactive()  ||
           (c==bbGetInputConnectorMap().find("BoxExecute")->second))
         && (bbCanReact() ) )
      {
        bbtkDebugMessage("modified",2,
                         "-> Execution triggered by Reactive mode or BoxExecute input change"<<std::endl);
        this->bbSetStatus(MODIFIED); 
        bbGlobalAddToExecutionList( GetThisPointer<BlackBox>() );
      }
    /*
    else if ( bbGetStatus() == MODIFIED ) //! this->bbIsUptodate()) 
      { 
        bbtkDebugMessage("modified",2,"-> Already modified"<<std::endl);
        return;
      }
    */
    else 
      {
        bbtkDebugMessage("modified",2,"-> Status set to modified"<<std::endl);
        this->bbSetStatus(MODIFIED); 
      }
 
    this->bbSignalOutputModification(false);

    /* 
  bbtkDebugMessageDec("process",5,
                        "<= BlackBox::bbSetModifiedStatus("<<c<<") ["
                        <<bbGetFullName()<<"]"<<std::endl);
    */
  }  
  //=========================================================================

  //=========================================================================  
  void BlackBox::bbSignalOutputModification(bool reaction)
  {
    bbtkDebugMessageInc("process",5,
                        "=> BlackBox::bbSignalOutputModification() ["
                        <<bbGetFullName()<<"]"<<std::endl);
    
    OutputConnectorMapType::iterator change = bbGetOutputConnectorMap().end();
    OutputConnectorMapType::iterator i;
    for ( i  = bbGetOutputConnectorMap().begin(); 
          i != bbGetOutputConnectorMap().end(); ++i) {
      /*     if ( i->first == "BoxChange" ) 
        {
          change = i;
          continue;
        }
      */
      i->second->SetModifiedStatus();
    } 
    //    if (change != bbGetOutputConnectorMap().end()) 
    // change->second->SetModifiedStatus();

    if (reaction) bbGlobalProcessExecutionList();

    bbtkDebugMessageDec("process",5,
                        "<= BlackBox::bbSignalOutputModification() ["
                        <<bbGetFullName()<<"]"<<std::endl);
    
  }  
  //=========================================================================   
  //=========================================================================  
  void BlackBox::bbSignalOutputModification(const std::string& output,
        bool reaction)
  {
    bbtkDebugMessageInc("process",5,
                        "=> BlackBox::bbSignalOutputModification("
                        <<output<<") ["
                        <<bbGetFullName()<<"]"<<std::endl);
    
    OutputConnectorMapType::iterator i = bbGetOutputConnectorMap().find(output);
    if ( i == bbGetOutputConnectorMap().end() ) 
        {
          bbtkError("BlackBox["<<bbGetFullName()<<"]::bbSignalOutputModification("<<output<<") : unknown output");
        }
    i->second->SetModifiedStatus();
    // Has to notify the output "BoxChange" also
    if (output != "BoxChange") 
      {
        i = bbGetOutputConnectorMap().find("BoxChange");
        if ( i != bbGetOutputConnectorMap().end() ) 
          {
            i->second->SetModifiedStatus();
          }
      }
  if (reaction) bbGlobalProcessExecutionList();

  bbtkDebugMessageDec("process",5,
                      "<= BlackBox::bbSignalOutputModification("
                      <<output<<") ["
                      <<bbGetFullName()<<"]"<<std::endl);

  }  
  //=========================================================================   
  //=========================================================================  
  void BlackBox::bbSignalOutputModification(const std::vector<std::string>& output,
        bool reaction)
  {
    bbtkDebugMessageInc("process",5,
                        "=> BlackBox::bbSignalOutputModification(vector of outputs) ["
                        <<bbGetFullName()<<"]"<<std::endl);
    OutputConnectorMapType::iterator i;
    std::vector<std::string>::const_iterator o;
    for (o=output.begin();o!=output.end();++o) 
      {
        // the output "BoxChange" must be signaled **AFTER** all others
        if (*o == "BoxChange") continue;
        // Look for the connector
        i = bbGetOutputConnectorMap().find(*o);
        if ( i == bbGetOutputConnectorMap().end() ) 
          {
            bbtkError("BlackBox["<<bbGetFullName()<<"]::bbSignalOutputModification("<<*o<<") : unknown output");
          }
        i->second->SetModifiedStatus();
      }
    // Has to notify the output "BoxChange" also
    i = bbGetOutputConnectorMap().find("BoxChange");
    if ( i != bbGetOutputConnectorMap().end() ) 
      {
        i->second->SetModifiedStatus();
      }
  if (reaction) bbGlobalProcessExecutionList();

   bbtkDebugMessageDec("process",5,
                       "<= BlackBox::bbSignalOutputModification(vector of outputs) ["
                        <<bbGetFullName()<<"]"<<std::endl);

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

  //=========================================================================
  IOStatus BlackBox::bbUpdateInputs(bool excludeParent)
  {
    bbtkDebugMessageInc("process",4,
                        "=> BlackBox::bbUpdateInputs() ["
                        <<bbGetFullName()<<"]"
                        <<std::endl);   

    IOStatus s = UPTODATE;

    InputConnectorMapType::iterator i;
    for ( i = bbGetInputConnectorMap().begin(); 
          i!= bbGetInputConnectorMap().end(); ++i) 
      {
        if (excludeParent && (i->first=="WinParent")) continue;
        if (i->first=="WinHide") continue;
        // If input type is Void : no recurse
        //if (  bbGetDescriptor()->GetInputDescriptor(i->first)->GetTypeInfo() 
        //      == typeid(Void) ) 
        //  continue;

        IOStatus t = i->second->BackwardUpdate();
        if (t==MODIFIED) s = MODIFIED;
      }
    
   bbtkDebugMessageDec("process",4,
                        "<= BlackBox::bbUpdateInputs() ["
                        <<bbGetFullName()<<"]"
                        <<std::endl);   


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

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


    InputConnectorMapType::iterator i = bbGetInputConnectorMap().find(name);
    if (i==bbGetInputConnectorMap().end())
      {
        bbtkError("no input called '"<<name<<"'");
      }
    i->second->SetConnection(c);
    
    bbtkDebugMessage("connection",2,
                        "<== BlackBox::bbConnectInput(\""
                        <<name<<"\","<<c->GetFullName()<<") ["
                        <<bbGetFullName()<<"]"
                        <<std::endl);       
    //  bbSetModifiedStatus();

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


  //=========================================================================  
  void BlackBox::bbConnectOutput( const std::string& name, Connection* c)
  {
    bbtkDebugMessage("connection",2,
                     "==> BlackBox::bbConnectOutput(\""<<name<<"\","
                     <<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"<<std::endl);       
    
    OutputConnectorMapType::iterator i = bbGetOutputConnectorMap().find(name);
    if (i==bbGetOutputConnectorMap().end())
      {
        bbtkError("no output called '"<<name<<"'");
      }
    i->second->SetConnection(c);

    bbtkDebugMessage("connection",2,
                     "<== BlackBox::bbConnectOutput(\""<<name<<"\","
                     <<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"<<std::endl);       

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


  //=========================================================================
  void BlackBox::bbDisconnectInput( const std::string& name, Connection* c)
  {

    bbtkDebugMessage("connection",2,
                     "==> BlackBox::bbDisconnectInput(\""<<name
                     <<"\","<<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"
                     <<std::endl);      

    if (!c) 
      {

        bbtkDebugMessage("connection",2,"c==0"<<std::endl);     
        return;
      }

    InputConnectorMapType::iterator i = bbGetInputConnectorMap().find(name);
    if (i==bbGetInputConnectorMap().end())
      {
        bbtkError("no input called '"<<name<<"'");
      }
    i->second->UnsetConnection(c);

    bbtkDebugMessage("connection",2,
                     "<== BlackBox::bbDisconnectInput(\""<<name
                     <<"\","<<c->GetFullName()<<") ["
                     <<bbGetFullName()<<"]"
                     <<std::endl);      

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


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

        bbtkDebugMessage("connection",2,"c==0"<<std::endl);     
        return;
      }

    OutputConnectorMapType::iterator i = bbGetOutputConnectorMap().find(name);
    if (i==bbGetOutputConnectorMap().end())
      {
        bbtkError("no output called '"<<name<<"'");
      }
    i->second->UnsetConnection(c);

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

  //=========================================================================
  void BlackBox::bbWriteDotInputOutputName(FILE *ff,bool inputoutput,int detail, int level)
  {
    fprintf(ff,"%s%p",bbGetTypeName().c_str(),this);
  }
  //=========================================================================


  //=========================================================================
  std::string BlackBox::bbGetOutputAsString( const std::string &output ) 
  {
    std::string v;
    // Looks for the adaptor
    if (bbGetOutputType(output).name() != typeid(std::string).name() ) 
      {
        // Look for factory 
        Package::Pointer p = bbGetDescriptor()->GetPackage();
        if ((p != 0) && ( ! p->GetFactorySet().empty() ) )
          {
            Factory::Pointer f = p->GetFactorySet().begin()->lock();
            BlackBox::Pointer a;
            try
              {
                a = f->NewAdaptor(  
                                  bbGetOutputType(output),
                                  typeid(std::string),
                                  "");
              } catch (bbtk::Exception e) 
              {
              }
            if (a){
              //                        bbUpdate();
              a->bbSetInput("In",bbGetOutput(output));
              a->bbExecute();
              v = a->bbGetOutput("Out").unsafe_get<std::string>() ;
            } else {
              v="? (no adaptor found)";
            }
          }
        else 
          {
            v="? (no factory found)";
          }
      } 
    else 
      {
        //         bbUpdate();
        v = bbGetOutput(output).unsafe_get<std::string>() ;
      }
    return v;
  }
  //=========================================================================

  //=========================================================================
  std::string BlackBox::bbGetInputAsString( const std::string &input ) 
  {
    std::string v;
    // Looks for the adaptor
    if (bbGetInputType(input) != typeid(std::string)) 
      {
        // Look for factory 
        Package::Pointer p = bbGetDescriptor()->GetPackage();
        if ((p != 0) && ( ! p->GetFactorySet().empty() ) )
          {
            Factory::Pointer f = p->GetFactorySet().begin()->lock();
            BlackBox::Pointer a;
            try
              {
                a = f->NewAdaptor(  
                               bbGetInputType(input),
                               typeid(std::string),
                               "");
              }catch (bbtk::Exception e) 
              {
              }
            if (a)
              {
                //                      bbUpdate();
                a->bbSetInput("In",bbGetInput(input));
                a->bbExecute();
                v = a->bbGetOutput("Out").unsafe_get<std::string>() ;
              } 
            else 
              {
                v="? (no adaptor found)";
              }
          } 
        else 
          {
            v="? (no factory found)";
          }
      }
    else 
      {
        v = bbGetInput(input).unsafe_get<std::string>() ;
      }
    return v;
  }
  //=======================================================================

  //=======================================================================
  // Replaces substrings "<" by "["
  void SubsBrackets ( std::string& s )
  {
    //   std::cout << "BEFORE=["<<s<<"]"<<std::endl;
    std::string ss("<");
    std::string::size_type pos = 0;
    pos = s.find(ss,0);
    char* cr = "[";
    while ( pos != std::string::npos )
      {
        //      std::cout << "*** find one "<<std::endl;
        s.replace(pos,1,cr,1);
        pos = s.find(ss, pos);
      } 
    ss = ">";
    pos = 0;
    pos = s.find(ss,0);
    cr = "]";
    while ( pos != std::string::npos )
      {
        //      std::cout << "*** find one "<<std::endl;
        s.replace(pos,1,cr,1);
        pos = s.find(ss, pos);
      } 
    ss = ",";
    pos = 0;
    pos = s.find(ss,0);
    cr = "-";
    while ( pos != std::string::npos )
      {
        //      std::cout << "*** find one "<<std::endl;
        s.replace(pos,1,cr,1);
        pos = s.find(ss, pos);
      }     //    std::cout << "AFTER=["<<s<<"]"<<std::endl;
  }
  //=======================================================================

  //=========================================================================
  void BlackBox::bbWriteDotFileBlackBox(FILE *ff,
                                        BlackBox::Pointer parentblackbox, 
                                        int detail, int level,
                                        bool instanceOrtype,
                                        bool relative_link )

  { 
    InputConnectorMapType::iterator i;
    // label
    std::string labelStr;
    std::string valueStr("");

        if (detail==0) {
                labelStr = bbGetName() ; 
//EED 18 Fev 2008
                labelStr = labelStr + "\\n[" +this->bbGetDescriptor()->GetPackage()->GetName()+"::"+ bbGetTypeName() + "]";
        } else {
                labelStr = bbGetName();
                labelStr = labelStr + "   [" +this->bbGetDescriptor()->GetPackage()->GetName()+"::"+ bbGetTypeName() + "]  ";
    }

    SubsBrackets(labelStr);
    if (detail==1)
      {
        labelStr = labelStr + " | {{ "; 
        std::string tempStrTypeName;
        bool tmp; 
        tmp=false;
        for ( i = mInputConnectorMap.begin(); i != mInputConnectorMap.end(); ++i ) 
          {
            if (tmp==true)
              {
                labelStr=labelStr+" | ";
              }
            tmp=true;
            if (instanceOrtype==true)
              {
                valueStr = this->bbGetInputAsString(i->first) + " = ";
              } 
            const BlackBoxInputDescriptor* id = bbGetDescriptor()->GetInputDescriptor(i->first);
            tempStrTypeName=id->GetTypeName();
            SubsBrackets(tempStrTypeName);
            std::string Name(i->first);
            SubsBrackets(Name);
            labelStr=labelStr + "<"+i->first.c_str()+"> "  + valueStr +  Name.c_str() + "  [" + tempStrTypeName.c_str() + "]";
          }
        labelStr=labelStr+ " } | {";
        tmp = false;
        OutputConnectorMapType::iterator ii;
        for ( ii = mOutputConnectorMap.begin(); ii != mOutputConnectorMap.end(); ++ii ) 
        {
           if (tmp==true)
           {
                   labelStr=labelStr+" | ";
           }
           tmp = true;
           if (instanceOrtype==true)
           {
                   valueStr = this->bbGetOutputAsString(ii->first) + " = ";
           }
           const BlackBoxOutputDescriptor* id = bbGetDescriptor()->GetOutputDescriptor(ii->first); 
           tempStrTypeName=id->GetTypeName();
           SubsBrackets(tempStrTypeName);
            std::string Name(ii->first);
            SubsBrackets(Name);
           labelStr=labelStr+"<"+ii->first.c_str()+"> " + valueStr + Name.c_str() + "  ["+tempStrTypeName+"]";
        }
        labelStr = labelStr+ "      } }" ;
} // detail

    fprintf(ff,"  " );
    bbWriteDotInputOutputName(ff,true,detail,level);
    std::string tmp ( bbGetTypeName() );
    SubsBrackets(tmp);
    std::string url;
    if (relative_link) 
      url = this->bbGetDescriptor()->GetPackage()->GetDocRelativeURL() + "#" + tmp;
    else 
      url = this->bbGetDescriptor()->GetPackage()->GetDocURL() + "#" + tmp;
  
    fprintf( ff , " [shape=record, URL=\"%s\",label=\"%s\"]%s\n",url.c_str(),labelStr.c_str(),";" );
    //    std::cout  << labelStr << std::endl;

    // Relation Input
    if (GetThisPointer<BlackBox>()!=parentblackbox){
      for ( i = mInputConnectorMap.begin(); i != mInputConnectorMap.end(); ++i ) 
        {
          if (i->second)
            {
              Connection* con = i->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 BlackBox::bbShowRelations(BlackBox::Pointer parentblackbox, 
                                 int detail, int level
                                 /*,Factory *factory*/ )
  {
     
    if (this->bbGetDescriptor()->GetPackage()) 
      {
        bbtkMessage("Help",1,"Black Box '"<<bbGetName()<<"' <"<<
                    this->bbGetDescriptor()->GetPackage()->GetName()
                    <<"::"<<this->bbGetDescriptor()->GetTypeName()<<">"<<std::endl);
      }
    else 
      {
        bbtkMessage("Help",1,"Black Box <::"<<this->bbGetDescriptor()->GetTypeName()<<">"<<std::endl);
      }
    //    bbtkMessage("Help",1," "<<GetDescription()<<std::endl);
    //    bbtkMessage("Help",1," By : "<<GetAuthor()<<std::endl);

    std::vector<std::string> iname;
    std::vector<std::string> ivalue;
    std::vector<std::string> iconn;

    InputConnectorMapType::iterator i;
    unsigned int namelmax = 0;
    unsigned int valuelmax = 0;
    //   unsigned int connlmax = 0;
    for ( i = mInputConnectorMap.begin(); i != mInputConnectorMap.end(); ++i ) 
      {
        iname.push_back(i->first);
        if (iname.back().size()>namelmax) namelmax = iname.back().size();
        ivalue.push_back(bbGetInputAsString(i->first));
        if (ivalue.back().size()>valuelmax) valuelmax = ivalue.back().size();
        std::string s("");
        Connection* con = i->second->GetConnection();
        if (con!=0){
          s = con->GetOriginalBlackBoxFrom()->bbGetName();
          s += ".";
          s += con->GetOriginalBlackBoxFromOutput();
        }  // if con
        iconn.push_back(s);
      }
    OutputConnectorMapType::iterator o;
    std::vector<std::string> oname;
    std::vector<std::string> ovalue;
    std::vector<std::vector<std::string> > oconn;
    for ( o = mOutputConnectorMap.begin(); o != mOutputConnectorMap.end(); ++o ) 
      {
        oname.push_back(o->first);
        if (oname.back().size()>namelmax) namelmax = oname.back().size();
        ovalue.push_back(bbGetOutputAsString(o->first));
        if (ovalue.back().size()>valuelmax) valuelmax = ovalue.back().size();
        std::vector<std::string> ss;
        const std::vector<Connection*>& con 
          = o->second->GetConnectionVector();
        std::vector<Connection*>::const_iterator c;
        for (c=con.begin();c!=con.end();++c) 
          {
            std::string s;
            s = (*c)->GetOriginalBlackBoxTo()->bbGetName();
            s += ".";
            s += (*c)->GetOriginalBlackBoxToInput();
            ss.push_back(s);
        }  // if con
        oconn.push_back(ss);
      }

    if (iname.size()) 
      bbtkMessage("Help",1," * Inputs : "<<std::endl);
    else 
      bbtkMessage("Help",1," * No inputs"<<std::endl);

    std::vector<std::string>::iterator i1,i2,i3;
    for (i1=iname.begin(),i2=ivalue.begin(),i3=iconn.begin();
         i1!=iname.end(),i2!=ivalue.end(),i3!=iconn.end();
         ++i1,++i2,++i3)
      {
        std::string name(*i1);
        name += "'";
        name.append(1+namelmax-name.size(),' ');
        std::string value(*i2);
        value += "'";
        value.append(1+valuelmax-value.size(),' ');
        if (i3->size()) 
          bbtkMessage("Help",1,"    '"<<name<<" = '"<<value<<" <-- '"<<*i3<<"'"<<std::endl);
        else 
          bbtkMessage("Help",1,"    '"<<name<<" = '"<<value<<std::endl);
      }

    if (oname.size()) 
      bbtkMessage("Help",1," * Outputs : "<<std::endl);
    else 
      bbtkMessage("Help",1," * No outputs"<<std::endl);

    std::vector<std::vector<std::string> >::iterator i4;

    for (i1=oname.begin(),i2=ovalue.begin(),i4=oconn.begin();
         i1!=oname.end(),i2!=ovalue.end(),i4!=oconn.end();
         ++i1,++i2,++i4)
      {
        std::string name(*i1);
        name += "'";
        name.append(1+namelmax-name.size(),' ');
        std::string value(*i2);
        value += "'";
        value.append(1+valuelmax-value.size(),' ');
        if (!(*i4).size())
          bbtkMessage("Help",1,"    '"<<name<<" = '"<<value<<std::endl);
        else 
          {
            std::string pref = "    '"+name+" = '"+value;
            for (i3=i4->begin();i3!=i4->end();++i3)
              {
                bbtkMessage("Help",1,pref<<" --> '"<<*i3<<"'"<<std::endl);
                pref.replace(0,pref.size(),pref.size(),' ');
              }
          }
      }

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


  //=========================================================================
   void BlackBox::bbGlobalProcessExecutionList()
   {   
     bbtkDebugMessageInc("process",3,
                         "=> BlackBox::bbGlobalProcessExecutionList()"
                         <<std::endl);     
     
     std::set<BlackBox::Pointer>::iterator i;
     for (i=bbmgExecutionList.begin();
          i!=bbmgExecutionList.end();
          ++i)
       {
         bbtkDebugMessage("process",4,
                          " -> Executing "<<(*i)->bbGetFullName()<<std::endl);
         (*i)->bbExecute(true);
       }
     
     bbmgExecutionList.clear();
     bbtkDebugMessageDec("process",3,
                         "<= BlackBox::bbGlobalProcessExecutionList()"
                         <<std::endl);     
     
     
   }
  //=========================================================================

    bool BlackBox::bbGlobalGetSomeBoxExecuting()
        { 
                return bbmgSomeBoxExecuting; 
        }

    void BlackBox::bbGlobalSetSomeBoxExecuting(bool b) 
        { 
                bbmgSomeBoxExecuting = b; 
        }

    void BlackBox::bbGlobalSetFreezeExecution(bool b) 
        { 
                bbmgFreezeExecution = b;
        }

    bool BlackBox::bbGlobalGetFreezeExecution() 
        { 
                return bbmgFreezeExecution; 
        }

  void BlackBox::bbGlobalAddToExecutionList( BlackBox::Pointer b )
        {  
                bbmgExecutionList.insert(b); 
        } 


   //=========================================================================

  //=========================================================================
  void BlackBox::Check(bool recursive)
  {
    bbtkMessage("debug",1,"*** Checking Black Box "<<(void*)this<<" ["<<bbGetFullName()
                <<"] ... OK"<<std::endl);
  }
  //=========================================================================

  void BlackBox::bbUserOnShowWidget(std::string nameInput)
  {
          bbtk::BlackBoxInputConnector *cc;
          cc = this->bbGetInputConnectorMap().find( nameInput.c_str() )->second;
          if (cc->GetConnection()!=NULL) 
          {
                  cc->GetConnection()->GetBlackBoxFrom()->bbUserOnShow();
          }
  }



}  // EO namespace bbtk

// EOF