bbtkBlackBox.h

Go to the documentation of this file.

/*=========================================================================
  Program:   bbtk
  Module:    $RCSfile: bbtkBlackBox.h,v $
  Language:  C++
  Date:      $Date: 2011/03/03 14:33:13 $
  Version:   $Revision: 1.32 $
=========================================================================*/

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

* 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.
* ------------------------------------------------------------------------ */



#ifndef __bbtkBlackBox_h__
#define __bbtkBlackBox_h__

#include "bbtkSystem.h"
#include "bbtkMessageManager.h"
#include "bbtkBlackBoxDescriptor.h"
#include "bbtkBlackBoxInputConnector.h"
//#include "bbtkBlackBoxOutputConnector.h"
#include <set>

// Signal/slot mechanism for output change events
#include <boost/signal.hpp>
#include <boost/bind.hpp>


#define bbtkBlackBoxMessage(key,level,mess) \
  bbtkMessage(key,level,"["<<bbGetName()<<"] "<<mess)
#define bbtkBlackBoxDebugMessage(key,level,mess)        \
  bbtkDebugMessage(key,level,"["<<bbGetName()<<"] "<<mess)

namespace bbtk
{

  struct Void { Void(int = 0) {} };

  class Factory;
  class Connection;
  class BlackBoxOutputConnector;

  class BBTK_EXPORT BlackBox : public Object
  {
    BBTK_ABSTRACT_OBJECT_INTERFACE(BlackBox);


  public:

    //==================================================================
    // Types
    //==================================================================
    typedef boost::signals::trackable OutputChangeObserverType;
    typedef boost::signal<void (bbtk::BlackBox::Pointer,
                                const std::string&,
                                IOStatus)>  OutputChangeSignalType;
    typedef OutputChangeSignalType::slot_function_type
    OutputChangeCallbackType;

    typedef std::map<std::string, BlackBoxOutputConnector*>
    OutputConnectorMapType;
    typedef std::map<std::string, BlackBoxInputConnector*>
    InputConnectorMapType;
    //==================================================================


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


    virtual void bbExecute(bool force = false);
    //==================================================================





    //==================================================================
    virtual BlackBox::Pointer bbClone(const std::string& name) = 0;
    //==================================================================


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


    virtual BlackBoxDescriptor::Pointer bbGetDescriptor() const = 0;

    const std::string& bbGetTypeName() const
      { return bbGetDescriptor()->GetTypeName(); }


    const std::string& bbGetName() const { return bbmName; }

    virtual std::string bbGetFullName() const;

    virtual std::string bbGetNameWithParent() const;

    BlackBox::Pointer bbGetParent() const { return bbmParent.lock(); }

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



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


    virtual bool bbHasInput(const std::string& label) const;
    virtual TypeInfo bbGetInputType( const std::string &label ) const;
    IOStatus bbGetInputStatus( const std::string &name ) const
    { return mInputConnectorMap.find(name)->second->GetStatus(); }
    virtual Data bbGetInput( const std::string &name )  = 0;
    std::string bbGetInputAsString( const std::string &input);


    virtual void bbSetInput( const std::string &name, Data data,
                             bool update_time = true ) = 0;
    virtual void bbBruteForceSetInputPointer( const std::string &name,
                                              void* data,
                                              bool update_time = true) =0;


    virtual bool bbHasOutput(const std::string& label) const;
    virtual TypeInfo bbGetOutputType( const std::string &label ) const;
    virtual Data bbGetOutput( const std::string &name ) = 0;
    std::string bbGetOutputAsString( const std::string &output ); //,Factory *factory);

    virtual void bbSetOutput( const std::string &name, Data data) = 0;


    InputConnectorMapType&  bbGetInputConnectorMap()
    { return mInputConnectorMap; }
    const InputConnectorMapType&  bbGetInputConnectorMap() const
    { return mInputConnectorMap; }
    BlackBoxInputConnector&  bbGetInputConnector(const std::string& n)
    { return *(mInputConnectorMap.find(n)->second); }
    const BlackBoxInputConnector&  bbGetInputConnector(const std::string& n) const
    { return *(mInputConnectorMap.find(n)->second); }


    OutputConnectorMapType& bbGetOutputConnectorMap()
    { return mOutputConnectorMap; }
    const OutputConnectorMapType& bbGetOutputConnectorMap() const
    { return mOutputConnectorMap; }
    BlackBoxOutputConnector& bbGetOutputConnector(const std::string& n)
    { return *(mOutputConnectorMap.find(n)->second); }
    const BlackBoxOutputConnector& bbGetOutputConnector(const std::string& n) const
    { return *(mOutputConnectorMap.find(n)->second); }

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

    virtual void bbGetHelp(bool full=true) const;



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


    //==================================================================
    void bbAddOutputObserver(const std::string& output_name,
                             OutputChangeCallbackType f);

    void bbRemoveOutputObserver(const std::string& output_name,
                                OutputChangeCallbackType f);
   //==================================================================


    //==================================================================
    virtual void bbSignalOutputModification(bool reaction = true);
    virtual void bbSignalOutputModification( const std::string& output_name,
                                             bool reaction = true);
    virtual void bbSignalOutputModification( const std::vector<std::string>&
                                             output_name,
                                             bool reaction = true);
   //==================================================================






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


    std::string bbGetInputBoxProcessMode() { return bbmBoxProcessMode; }
    void bbSetInputBoxProcessMode(std::string a) { bbmBoxProcessMode = a; }
 
    typedef enum 
     {
      bbPipeline,
      bbAlways,
      bbReactive
     }
    BoxProcessModeValue;
    
    BoxProcessModeValue bbGetBoxProcessModeValue() const;
    virtual bool bbBoxProcessModeIsReactive() const;
    virtual bool bbBoxProcessModeIsAlways() const;

    Void bbGetInputBoxExecute() { return Void(); }
    void bbSetInputBoxExecute(Void = 0) {}

    Void bbGetOutputBoxChange() { return Void(); }
    void bbSetOutputBoxChange(Void = 0) { }
    //==================================================================

    virtual void bbPrintHelp(BlackBox::Pointer parentblackbox,
                             int detail, int level
                             );

    void bbInsertHTMLGraph(  std::ofstream& s,
                             int detail,
                             int level,
                             bool instanceOrtype,
                             const std::string& output_dir,
                             bool relative_link )
    {}


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

    virtual void bbSetShown(bool) {}
    virtual bool bbIsShown() { return false; }
    //==================================================================

    //JCP changed to public 09-06-09
        //==================================================================

            static bool bbGlobalGetSomeBoxExecuting();
            static void bbGlobalSetSomeBoxExecuting(bool b);

            static void bbGlobalSetFreezeExecution(bool b);
            static bool bbGlobalGetFreezeExecution();

            static void bbGlobalAddToExecutionList( BlackBox::Pointer b );
            static void bbGlobalProcessExecutionList();

    //JCP 09-06-09

  protected:

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


    //==================================================================
    virtual void bbUserSetDefaultValues() {}

    virtual void bbUserInitializeProcessing() {}

    virtual void bbUserFinalizeProcessing() {}
    virtual void bbUserOnShow() {}

    //==================================================================
    // @}
    //==================================================================


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

    virtual void bbWriteDotFileBlackBox(FILE *ff,
                                        BlackBox::Pointer parentblackbox,
                                        int detail, int level,
                                        bool instanceOrtype,
                                        bool relative_link );
    virtual void bbWriteDotInputOutputName(FILE *ff,
                                           bool inputoutput,
                                           int detail, int level);

     virtual BlackBox::Pointer bbFindBlackBox(const std::string &blackboxname)
              { return BlackBox::Pointer();}

    virtual void Check(bool recursive = true);

    //==================================================================
    // PROTECTED PART : ACCESSIBLE TO THE BlackBox DEVELOPER
    // (IN INHERITED CLASSES)
    BlackBox(const std::string &name);
    BlackBox(BlackBox& from, const std::string &name);
    //==================================================================



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

    //==================================================================
    virtual void bbRecursiveExecute(Connection::Pointer caller);
    //==================================================================

    //==================================================================
    IOStatus bbUpdateInputs();
    //==================================================================


    //==================================================================
    virtual void bbCreateWindow()
    {
      //  bbtkError("BlackBox::bbCreateWidget called : how can this happen ?");
    }
    //==================================================================

    //==================================================================
    virtual void bbShowWindow()
    {
      //  bbtkError("BlackBox::bbShowWidget called : how can this happen ?");
    }
    //==================================================================


   //==================================================================
    virtual void bbProcess()
    {
      bbtkError("BlackBox::bbProcess called : how can this happen ?");
//      this->bbUserProcess();
    }
    //==================================================================

    //==================================================================
    void bbComputePostProcessStatus();
    //==================================================================


    //==================================================================
    virtual void bbSetStatusAndPropagate(BlackBoxInputConnector* c,
                                         IOStatus s);
    //==================================================================



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


    //==================================================================
    virtual void bbAllocateConnectors();
    virtual void bbDesallocateConnectors();
    virtual void bbCopyIOValues(BlackBox& from);
    //==================================================================

    //==================================================================
    void bbInitializeProcessing();

    void bbFinalizeProcessing();

    virtual void bbRecursiveInitializeProcessing() {}


    virtual void bbRecursiveFinalizeProcessing() {}
    //==================================================================

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

  private:
    //==================================================================
    friend class Connection;
    friend class ComplexBlackBox;

    void bbSetParent(BlackBox::Pointer p) { bbmParent = p; }

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


    virtual void bbConnectInput( const std::string& name,
                                 Connection* c);
    virtual void bbConnectOutput( const std::string& name,
                                  Connection* c);
    virtual void bbDisconnectInput( const std::string& name,
                                    Connection* c);
    virtual void bbDisconnectOutput( const std::string& name,
                                     Connection* c);
    //==================================================================

    virtual bool bbCanReact() const;

    bool bbGetExecuting() const { return bbmExecuting; }
    void bbSetExecuting(bool b) { bbmExecuting = b; }

  protected:

    //==================================================================
  protected:


     //==================================================================
    struct BBTK_EXPORT Deleter : public Object::Deleter
    {
      Deleter();
      int Delete(Object* p);
    };
    //==================================================================

    //==================================================================
    template <class U>
    static boost::shared_ptr<U> MakeBlackBoxPointer(U* s, bool lock = false)
    {
      return MakePointer(s,BlackBox::Deleter(),lock);
    }
    //==================================================================

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

//JCP 21-09-20 09 delete this throws and exception change due to compiler version changing and boost version
    virtual int bbDelete() { delete this; 
                             return 0; }
    //==================================================================


    //==================================================================
  private:
    //==================================================================

    //==================================================================
    // ATTRIBUTES
    bool bbmInitialized;
    bool bbmExecuting;
    std::string bbmName;
    std::string bbmPackageName;
    std::string bbmBoxProcessMode;
    BlackBox::WeakPointer bbmParent;
    //==================================================================


   //==================================================================
    // ATTRIBUTES
    OutputConnectorMapType mOutputConnectorMap;
    InputConnectorMapType mInputConnectorMap;
    //==================================================================
 };
  // Class BlackBox


#define BBTK_MAKE_OUTPUT_OBSERVER(OBJECT,METHOD) \
    boost::bind( METHOD, OBJECT, _1, _2, _3)

}
// namespace bbtk
#endif