bbtkConnection.cxx

Go to the documentation of this file.

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

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

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

namespace bbtk
{
  //==================================================================
  Connection::Pointer Connection::New(BlackBox::Pointer from, 
                                      const std::string& output,
                                      BlackBox::Pointer to, 
                                      const std::string& input ,
                                      const Factory::Pointer f  )
  {
    bbtkDebugMessage("object",1,"##> Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);
    Connection::Pointer p = 
      MakePointer(new Connection(from,output,to,input,f));
    bbtkDebugMessage("object",1,"<## Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);
    return p;
  }
  //==================================================================

  //==================================================================
Connection::Connection(BlackBox::Pointer from, const std::string& output,
                       BlackBox::Pointer to, const std::string& input ,
                       const Factory::Pointer f  )
    : mAdaptor(),
      mFactory(f),
      mFromAny(false),
      mToAny(false)
  {
    bbtkDebugMessage("object",2,"==> Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);    

    bbtkDebugMessage("connection",1,"==> Connection::Connection(\""
                     <<from->bbGetFullName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetFullName()<<"\",\""<<input<<"\")"
                     <<std::endl);    

    

    if (! from->bbHasOutput(output) )
      {
        bbtkError("The box \""<<from->bbGetTypeName()<<
                  "\" has no output \""<<output<<"\"");
      }
    if (! to->bbHasInput(input) )
      {
        bbtkError("The box \""<<to->bbGetTypeName()<<
                  "\" has no input \""<<input<<"\"");
      } 

    if (to->bbGetInputConnectorMap().find(input)->second->IsConnected())
      {
        bbtkError("The input \""<<input<<"\" of the box \""<<to->bbGetName()
                  <<"\" is already connected");
      }
    
    //  std::string t1 ( from->bbGetOutputType(output).name() );
    //   std::string t2 ( to->bbGetInputType(input).name() );
    // if  //( t1 != t2 ) 
    if ( from->bbGetOutputType(output) !=
         to->bbGetInputType(input) )
      {
        if ( from->bbGetOutputType(output) == typeid(Data) )
          {
            bbtkWarning("Connection '"
                        <<GetFullName()
                        <<"' : '"<<from->bbGetName()<<"."<<output
                        <<"' is of type <"
                        <<HumanTypeName<Data>()
                        <<"> : type compatibility with '"
                        <<to->bbGetName()<<"."<<input
                        <<"' will be resolved at run time"
                        );
            mFromAny = true;
          }
        else if (  to->bbGetInputType(input) == typeid(Data) )
          {   
            bbtkDebugMessage("Kernel",8," -> '"<<input<<"' type is "
                             <<TypeName<Data>()<<" : can receive any data"
                             <<std::endl);
            mToAny = true;
          }
        else 
          {
            //   std::cout << "Adaptive connection "<<std::endl;
            std::string name;
            name = from->bbGetName() + "." + output + "-" 
              + to->bbGetName() + "." + input; 
            mAdaptor = mFactory.lock()
              ->NewAdaptor(from->bbGetOutputType(output),
                           to->bbGetInputType(input),
                           name);
            if (!mAdaptor)  
              {  
                bbtkError("did not find any <"
                          <<TypeName(from->bbGetOutputType(output))
                          <<"> to <"
                          <<TypeName(to->bbGetInputType(input))
                          <<"> adaptor");
              } 
          }
      }


    mFrom = from;
    mOriginalFrom = from;
    mTo = to;
    mOriginalTo = to;
    mInput = mOriginalInput = input;
    mOutput = mOriginalOutput = output;

     // Lock this pointer !!!
    //Pointer p = MakePointer(this,true);
    from->bbConnectOutput(output,this);
    to->bbConnectInput(input,this);

    
    bbtkDebugMessage("connection",1,"<== Connection::Connection(\""
                     <<from->bbGetFullName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetFullName()<<"\",\""<<input<<"\")"
                     <<std::endl);    

    bbtkDebugMessage("object",2,"==> Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);    
  }
 //==================================================================
 
  //==================================================================
  Connection::Pointer Connection::New(BlackBox::Pointer from, 
                                      const std::string& output,
                                      BlackBox::Pointer to, 
                                      const std::string& input )
  {
    bbtkDebugMessage("object",1,"##> Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);
    Connection::Pointer p = 
      MakePointer(new Connection(from,output,to,input));
    bbtkDebugMessage("object",1,"<## Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);
    return p;
  }
  //==================================================================

  //==================================================================
Connection::Connection(BlackBox::Pointer from, const std::string& output,
                       BlackBox::Pointer to, const std::string& input )
  : mAdaptor(),
      mFactory(),
      mFromAny(false),
      mToAny(false)
  {
    bbtkDebugMessage("object",2,"==> Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);    

    bbtkDebugMessage("connection",1,"==> Connection::Connection(\""
                     <<from->bbGetFullName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetFullName()<<"\",\""<<input<<"\")"
                     <<std::endl);    

    

    if (! from->bbHasOutput(output) )
      {
        bbtkError("The box \""<<from->bbGetTypeName()<<
                  "\" has no output \""<<output<<"\"");
      }
    if (! to->bbHasInput(input) )
      {
        bbtkError("The box \""<<to->bbGetTypeName()<<
                  "\" has no input \""<<input<<"\"");
      } 

    if (to->bbGetInputConnectorMap().find(input)->second->IsConnected())
      {
        bbtkError("The input \""<<input<<"\" of the box \""<<to->bbGetName()
                  <<"\" is already connected");
      }
    
    //  std::string t1 ( from->bbGetOutputType(output).name() );
    //   std::string t2 ( to->bbGetInputType(input).name() );
    // if  //( t1 != t2 ) 
    if ( from->bbGetOutputType(output) !=
         to->bbGetInputType(input) )
      {
        if ( from->bbGetOutputType(output) == typeid(Data) )
          {
            bbtkWarning("Connection '"
                        <<GetFullName()
                        <<"' : '"<<from->bbGetName()<<"."<<output
                        <<"' is of type <"
                        <<HumanTypeName<Data>()
                        <<"> : type compatibility with '"
                        <<to->bbGetName()<<"."<<input
                        <<"' will be resolved at run time"
                        );
            mFromAny = true;
          }
        else if (  to->bbGetInputType(input) == typeid(Data) )
          {   
            bbtkDebugMessage("Kernel",8," -> '"<<input<<"' type is "
                             <<TypeName<Data>()<<" : can receive any data"
                             <<std::endl);
            mToAny = true;
          }
        else 
          {
            bbtkError("Connection created between different types without Factory provided");
          }
      }


    mFrom = from;
    mOriginalFrom = from;
    mTo = to;
    mOriginalTo = to;
    mInput = mOriginalInput = input;
    mOutput = mOriginalOutput = output;

     // Lock this pointer !!!
    //Pointer p = MakePointer(this,true);
    from->bbConnectOutput(output,this);
    to->bbConnectInput(input,this);

    
    bbtkDebugMessage("connection",1,"<== Connection::Connection(\""
                     <<from->bbGetFullName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetFullName()<<"\",\""<<input<<"\")"
                     <<std::endl);    

    bbtkDebugMessage("object",2,"==> Connection::Connection(\""
                     <<from->bbGetName()<<"\",\""<<output<<"\",\""
                     <<to->bbGetName()<<"\",\""<<input<<"\")"
                     <<std::endl);    
  }
 //==================================================================
 
  //==================================================================
  Connection::~Connection()
  {
    bbtkDebugMessage("object",2,
                     "==> Connection::~Connection() ["
                     <<GetFullName()<<"]"<<std::endl);

    if (mAdaptor) mAdaptor.reset();
    if (mFrom!=0) 
      {
        mFrom->bbDisconnectOutput(mOutput,this);
        //                                GetThisPointer<Connection>());
        mFrom.reset();
      }
    else 
      {
        bbtkInternalError("Connection::~Connection() : invalid initial box pointer");
      }
    if (mTo!=0) 
      {
        mTo->bbDisconnectInput(mInput,this);//   GetThisPointer<Connection>());
        mTo.reset();
      }
    else 
      {
        bbtkInternalError("Connection::~Connection() : invalid final box pointer");
      }


    bbtkDebugMessage("object",2,
                     "<== Connection::~Connection() ["
                     <<GetFullName()<<"]"<<std::endl);
  }
  //==================================================================
  
  //==================================================================
  IOStatus Connection::BackwardUpdate()
  {
    bbtkDebugMessage("process",5,
                     "===> Connection::BackwardUpdate() ["
                     <<GetFullName()<<"]"<<std::endl);

    IOStatus s = UPTODATE;
    s = mFrom->bbBackwardUpdate(GetThisPointer<Connection>());

    TransferData();

    if (mAdaptor && (s==MODIFIED)) mAdaptor->bbSetModifiedStatus();

    bbtkDebugMessage("process",5,
                     "<=== Connection::BackwardUpdate() ["
                     <<GetFullName()<<"]"<<std::endl);
    return s;
  }
  //==================================================================

  /*
  //==================================================================
  void Connection::ForwardUpdate()
  {
    bbtkDebugMessageInc("process",2,
                        "Connection::ForwardUpdate() ["
                        <<GetFullName()<<"]"<<std::endl);

  
    TransferData();

    mTo->bbForwardUpdate(this);

    bbtkDebugDecTab("process",2);
  }
  //==================================================================
  */

  //==================================================================
  void Connection::TransferData()
  {
    bbtkDebugMessageInc("data",3,
                        "Connection::TransferData() ["
                        <<GetFullName()<<"]"<<std::endl);
    
    
    // If an adaptor was created we need to adapt the data
    if (mAdaptor) 
      {
        mAdaptor->bbSetInput("In",mFrom->bbGetOutput(mOutput),false);
        mAdaptor->bbExecute();
        // LG : Connection Update does not set mTo as modified
        mTo->bbSetInput(mInput, mAdaptor->bbGetOutput("Out"),false);
        
      }
    // If no adaptor but source type is an any and target is not an any
    else if ( mFromAny && (! mToAny) )
      {
        bbtkDebugMessage("data",3,
                         " * Source type is an "
                         <<HumanTypeName<Data>()
                         <<" which contains a <"
                         <<HumanTypeName(mFrom->bbGetOutput(mOutput).type())
                         <<">"<<std::endl);
        bbtkDebugMessage("data",3,
                         " * Target type is <"
                         <<HumanTypeName(mTo->bbGetInputType(mInput))
                         <<">"<<std::endl);
        
        // 1) Test strict type matching between any content and target
        if (mFrom->bbGetOutput(mOutput)
            .contains( mTo->bbGetInputType(mInput) ) )
          {
            bbtkDebugMessage("data",3,
                             " -> Equal types : transfer ok"<<std::endl);
            mTo->bbSetInput( mInput, 
                             mFrom->bbGetOutput(mOutput),
                             false);
          }
        else 
          {
            // 2) Look for an adaptor
            bbtk::BlackBox::Pointer adaptor;
            try 
              {
                adaptor = mFactory.lock()
                  ->NewAdaptor(mFrom->bbGetOutput(mOutput).type(),
                               mTo->bbGetInputType(mInput),
                               "");
              }
            catch (...)
              {
              }
            if (adaptor)  
              {
                bbtkDebugMessage("data",3," -> Adaptor found : using it"
                                 <<std::endl);
                  adaptor->bbSetInput("In",mFrom->bbGetOutput(mOutput),false);
                adaptor->bbExecute();
                // LG : Connection Update does not set mTo as modified
                mTo->bbSetInput(mInput, adaptor->bbGetOutput("Out"),false);
                //      adaptor->bbDelete();
              }
            // 3) If no adaptor found but the any content is a pointer
            //    and target type is also a pointer : we try run-time cast
            else if ( (mFrom->bbGetOutput(mOutput).contains_pointer()) &&
                      (mTo->bbGetDescriptor()->GetInputDescriptor(mInput)
                       ->IsPointerType()) )
              {
                bbtkDebugMessage("data",3,
                                 " -> No adaptor found but source and target types are both pointers : trying up or down cast"<<std::endl);
                
                void* nptr = 
                  mFrom->bbGetOutput(mOutput)
                  .get_pointer_to(mTo->bbGetInput(mInput).pointed_type());
                if (!nptr)  
                  {
                    bbtkError("Connection '"
                              <<GetFullName()
                              <<"' : <"
                              <<HumanTypeName(mFrom->bbGetOutput(mOutput).type())
                              <<"> to <"
                              <<HumanTypeName(mTo->bbGetInputType(mInput))
                              <<"> : no adaptor available and run-time up and down cast failed");
                  }
                mTo->bbBruteForceSetInputPointer(mInput, nptr, false);
              }
            // 4) Nothing worked : error
            else 
              {
                bbtkError("Connection '"<<GetFullName()<<"' "
                          <<"no adaptor found to convert <"
                          <<HumanTypeName(mFrom->bbGetOutput(mOutput).type())
                          <<"> to <"
                          <<HumanTypeName(mTo->bbGetInputType(mInput))<<">");
              }
          }
      }
    // EO : mFromAny && ! mToAny
    // Default case : types are the same; we use simple get-set
    else 
      {
        // LG : Connection Update does not set mTo as modified
        mTo->bbSetInput(mInput, mFrom->bbGetOutput(mOutput),false);
      }

  }
  //==================================================================
  
  //==================================================================
  void Connection::SetModifiedStatus()
  {
    bbtkDebugMessage("modified",2,
                     "==> Connection::SetModifiedStatus() ["
                     <<GetFullName()<<"]"<<std::endl);
    
    if (mAdaptor) mAdaptor->bbSetModifiedStatus();
    
    mTo->bbSetModifiedStatus(  mTo->bbGetInputConnectorMap().find(mInput)->second );
    
    /*
    bbtkDebugMessage("modified",2,
                     "==> Connection::SetModifiedStatus() ["
                     <<GetFullName()<<"]"<<std::endl);
    */
  }
  //==================================================================

  
  //==================================================================
  std::string Connection::GetFullName() const {
    if (mFrom && mTo) 
      {
        std::string res = mFrom->bbGetName()+"."+mOutput+"--"
          +mTo->bbGetName()+"."+mInput;
        if ((!mOriginalFrom.expired()) && (!mOriginalTo.expired()) &&
            ((mFrom!=mOriginalFrom.lock())||(mTo!=mOriginalTo.lock())))
          {
            res += "("+mOriginalFrom.lock()->bbGetName()
              +"."+mOriginalOutput+"--"
              + mOriginalTo.lock()->bbGetName()+"."+mOriginalInput+")";
          }
        return res;
      }
    return "***Invalid Connection***";
  }
  //==================================================================

  //==================================================================
  void Connection::Check() const
  {
    bbtkMessage("debug",1,"** Checking Connection "<<(void*)this<<" ["<<GetFullName()<<"]"
                <<std::endl);
    if (mFrom==0) 
      {
        bbtkMessage("debug",2," - From = 0"<<std::endl);
      }
    else
      {
        bbtkMessage("debug",2," - From : "<<mFrom->bbGetFullName()<<std::endl);
        if (!mFrom->bbHasOutput(mOutput))
          {
            bbtkError("** Checking Connection "<<(void*)this
                       <<" ["<<GetFullName()<<"] : "
                      << mFrom->bbGetFullName()<<" does not have output '"
                      <<mOutput<<"'");
          }     
        bbtkMessage("debug",2," - From : Output '"<<mOutput<<"' exists"<<std::endl);
        BlackBox::OutputConnectorMapType::const_iterator i 
          = mFrom->bbGetOutputConnectorMap().find(mOutput);
        if (i== mFrom->bbGetOutputConnectorMap().end())
          {
             bbtkError("** Checking Connection "<<(void*)this
                       <<" ["<<GetFullName()<<"] : "
                       <<mFrom->bbGetFullName()<<" output '"
                       <<mOutput<<"' is not in OutputConnectorMap");
          }
        bbtkMessage("debug",2," - From : Output '"<<mOutput
                    <<"' is in OutputConnectorMap"<<std::endl);

        std::vector< Connection* >::const_iterator j;
        /*
        for (j  = i->second->GetConnectionVector().begin();
             j != i->second->GetConnectionVector().end();
             ++j)
          {
            if ((*j)==this) break;
          }
        */
        j = find(i->second->GetConnectionVector().begin(),
                 i->second->GetConnectionVector().end(),
                 this);
       
        if (j==i->second->GetConnectionVector().end())
          {
            bbtkError("** Checking Connection "<<(void*)this
                      <<" ["<<GetFullName()<<"] : "
                      << "Connection ["<<GetFullName()<<"] : "
                      <<" OutputConnector '"
                      <<mOutput<<"' of "<<mFrom->bbGetFullName()
                      <<" does not point to this connection");
            
          }
        bbtkMessage("debug",2," - From : This connection is in OutputConnector connection vector"<<std::endl);
        bbtkMessage("debug",2," * Box from : Check successfull"<<std::endl);

      }

    if (mTo==0) 
      {
        bbtkMessage("debug",2," - To   = 0"<<std::endl);
      }
    else
      {
        bbtkMessage("debug",2," - To   : "<<mTo->bbGetName()<<std::endl);
        //      std::cout << mTo << std::endl;
        //      std::cout << mTo->bbGetDescriptor() << std::endl;
        //      std::cout << mTo->bbGetDescriptor()->GetTypeName() << std::endl;
        //      mTo->bbGetFullName();
        bbtkMessage("debug",2," - To   : "<<mTo->bbGetFullName()<<std::endl);
        if (!mTo->bbHasInput(mInput))
          {
            bbtkError("** Checking Connection "<<(void*)this
                      <<" ["<<GetFullName()<<"] : "
                      <<mTo->bbGetFullName()<<" does not have input '"
                      <<mInput<<"'");
          }     
        bbtkMessage("debug",2," - To   : Input '"<<mInput<<"' exists"<<std::endl);
        BlackBox::InputConnectorMapType::const_iterator i 
          = mTo->bbGetInputConnectorMap().find(mInput);
        if (i== mTo->bbGetInputConnectorMap().end())
          {
             bbtkError("** Checking Connection "<<(void*)this
                       <<" ["<<GetFullName()<<"] : "
                       <<mTo->bbGetFullName()<<" input '"
                       <<mInput<<"' is not in InputConnectorMap");
          }
        bbtkMessage("debug",2," - To   : Input '"<<mInput
                    <<"' is in InputConnectorMap"<<std::endl);

        if (i->second->GetConnection()==0)
          {
            bbtkError("** Checking Connection "<<(void*)this
                      <<" ["<<GetFullName()<<"] : "
                      <<"Connection "<<GetFullName()<<" : "
                      <<" InputConnector '"
                      <<mInput<<"' of "<<mTo->bbGetFullName()
                      <<" does not point to this connection");
    
          }
        bbtkMessage("debug",2," - To   : This connection is in InputConnector connection vector"<<std::endl);
        bbtkMessage("debug",2," * Box to   : Check successfull"<<std::endl);

      }
  }
  //==================================================================
 //==========================================================================
  std::string Connection::GetObjectName() const
  {
    std::string s("Connection '");
    s += GetFullName();
    s += "'";
    return s;
  }
  //==========================================================================
  
  //==========================================================================
  std::string  Connection::GetObjectInfo() const 
  {
    std::stringstream i;
    return i.str();
  }
  //==========================================================================

 //==========================================================================
size_t  Connection::GetObjectSize() const 
{
  size_t s = Superclass::GetObjectSize();
  s += Connection::GetObjectInternalSize();
  return s;
  }
  //==========================================================================
  //==========================================================================
size_t  Connection::GetObjectInternalSize() const 
{
  size_t s = sizeof(Connection);
  return s;
  }
  //==========================================================================
  //==========================================================================
  size_t  Connection::GetObjectRecursiveSize() const 
  {
    size_t s = Superclass::GetObjectRecursiveSize();
    s += Connection::GetObjectInternalSize();
    return s;
  }
  //==========================================================================

}// namespace bbtk