NarvalInterface.cpp

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2004 by Olivier Stezowski                               *
 *   stezow(AT)ipnl.in2p3.fr                                               *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 *   This program is distributed in the hope that it will be useful,       *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
 *   GNU General Public License for more details.                          *
 *                                                                         *
 *   You should have received a copy of the GNU General Public License     *
 *   along with this program; if not, write to the                         *
 *   Free Software Foundation, Inc.,                                       *
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
 ***************************************************************************/

#ifndef ADF_NarvalInterface
#include "NarvalInterface.h"
#endif

#ifndef ADF_FrameIO
#include "FrameIO.h"
#endif

#ifndef ADF_KeyFactory
#include "KeyFactory.h"
#endif

#ifndef ADF_FrameFactory
#include "FrameFactory.h"
#endif

#include <iostream>
#include <fstream>    
#include <cstdlib>

#if HAVE_NARVAL_H == 1
// function to access narval paramerters
extern "C" {
        void ada_add_new_parameter(const char *,int *);
        //      void ada_get_parameter("c_param2", buffer, 20, &loc_error_code);
        void ada_get_parameter(const char *, const char *, int, int *);
        //  ada_set_parameter ("c_param2", buffer, &loc_error_code);    
        void ada_set_parameter(const char *, const char *,int *);
} // extern C
// used to exchange parameter informations with narval 
namespace { 
        const UShort_t gMaxSizeBufferNarvalParameters = 512; 
        Char_t gBufferNarvalParameters[gMaxSizeBufferNarvalParameters]; 
}
#endif

using namespace ADF;

/*
 template<typename Data_T> class NarvalParameter : public NamedItem<Data_T>
 {
 const Int_t gDefaultMaxSize = 20; 
 
 private:
 mutable Int_t fLastError;
 mutable Int_t fMaxSize;
 
 mutable Int_t fBuffer;
 
 public:
 NarvalParameter(const char *name, Data_T d = 0, Int_t max_size = gDefaultMaxSize):
 NamedItem<Data_T>(name,d), fLastError(0), fMaxSize(0), fBuffer(0x0)  { SetMaxSize(max_size); }
 virtual ~NarvalParameter() 
 { SetMaxSize(0); // delete fBuffer }   
 
 void SetMaxSize(Int_t max_size)
 {
 fMaxSize = max_size;
 if ( fBuffer ) 
 delete [] fBuffer;
 fBuffer = new Char_t [fMaxSize];
 }
 virtual void Set(Data_T t) 
 {
 fLastError = 0;
 {
 std::ostringstream oss;
 oss << t;
 ada_set_parameter (NamedItem<Data_T>::Name().data(), oss.str().c_str(), &fLastError);
 }                              
 }
 
 virtual Data_T Get() const
 { 
 Data_T t;
 
 fLastError = 0;
 ada_get_parameter (NamedItem<Data_T>::GetName().data(), fBuffer, fMaxSize, &fLastError);
 
 if ( fLastError == 0 ) {
 std::istringstream iss(fBuffer);
 iss >> t;
 }      
 
 return t; 
 }
 };
 */

//------------------------------------------------------------------------------------

// default local for configuration path
std::string NarvalInterface::G::ConfPath = "./";
// to init process id
UInt_t NarvalInterface::G::ProcessID = 0u;  

NarvalInterface::NarvalInterface(): 
fProcessID(0u), 
fConfPath(), 
fVersion(), 
Log("NarvalInterface")
{
        fConfPath  = G::ConfPath;
        fProcessID = G::ProcessID++; 
        Log.SetPID(fProcessID);
}
NarvalInterface::~NarvalInterface() 
{
        ;
} 

#if HAVE_NARVAL_H == 1
Int_t NarvalInterface::GetGlobalParameter(const char *name, UShort_t &val)
#else
Int_t NarvalInterface::GetGlobalParameter(const char * /*name*/, UShort_t & /*val*/)
#endif
{
#if HAVE_NARVAL_H == 1
        // should be locked ?
        UShort_t t;
        
        Int_t err = 0;
        ada_get_parameter (name, gBufferNarvalParameters, gMaxSizeBufferNarvalParameters, &err);
        if ( err == 0 ) {
                std::istringstream iss(gBufferNarvalParameters);
                iss >> t;
                if ( iss.fail() )
                        err = 2;
                else 
                        val = t;        
        }       
        return err;
#else 
        return -1;
#endif
}

#if HAVE_NARVAL_H == 1
Int_t NarvalInterface::SetGlobalParameter(const char *name, const UShort_t &val)
#else
Int_t NarvalInterface::SetGlobalParameter(const char * /*name*/, const UShort_t & /*val*/)
#endif
{
#if HAVE_NARVAL_H == 1
        // should be locked ?
        Int_t err = 0;
        {
                std::ostringstream oss1;
                oss1 << val;    
                ada_set_parameter (name, oss1.str().c_str(), &err);
                if ( err == 1 ) { // unknown parameter, try to add a new parameter 
                        std::ostringstream oss2;
                        oss2 << name << ";unsigned_8_type;read_write;" << val;
                        // send the request to narval 
                        ada_add_new_parameter (oss2.str().c_str(),&err);
                }
        }       
        return err;
#else 
        return -1;
#endif
}

#if HAVE_NARVAL_H == 1
Int_t NarvalInterface::GetGlobalParameter(const char *name, Int_t &val)
#else
Int_t NarvalInterface::GetGlobalParameter(const char * /*name*/, Int_t & /*val*/)
#endif
{
#if HAVE_NARVAL_H == 1
        // should be locked ?
        Int_t err = 0;
        {
                std::ostringstream oss1;
                oss1 << val;    
                ada_set_parameter (name, oss1.str().c_str(), &err);
                if ( err == 1 ) { // unknown parameter, try to add a new parameter 
                        std::ostringstream oss2;
                        oss2 << name << ";integer_type;read_write;" << val;
                        // send the request to narval 
                        ada_add_new_parameter (oss2.str().c_str(),&err);
                }               
        }
        return err;
#else 
        return -1;
#endif
}       

#if HAVE_NARVAL_H == 1
Int_t NarvalInterface::GetGlobalParameter(const char *name, std::string &val)
#else
Int_t NarvalInterface::GetGlobalParameter(const char * /*name*/, std::string & /*val*/)
#endif
{
#if HAVE_NARVAL_H == 1
        // should be locked ?
        std::string t;
        
        Int_t err = 0;
        ada_get_parameter (name, gBufferNarvalParameters, gMaxSizeBufferNarvalParameters, &err);
        if ( err == 0 ) {
                std::istringstream iss(gBufferNarvalParameters);
                iss >> t;
                if ( iss.fail() )
                        err = 2;
                else 
                        val = t;        
        }       
        return err;
#else 
        return -1;
#endif
}

#if HAVE_NARVAL_H == 1
Int_t NarvalInterface::SetGlobalParameter(const char *name, const std::string &val)
#else
Int_t NarvalInterface::SetGlobalParameter(const char * /*name*/, const std::string & /*val*/)
#endif
{
#if HAVE_NARVAL_H == 1
        // should be locked ?
        Int_t err = 0;
        {
                std::ostringstream oss1;
                oss1 << val;    
                ada_set_parameter (name, oss1.str().c_str(), &err);
                if ( err == 1 ) { // unknown parameter, try to add a new parameter 
                        std::ostringstream oss2;
                        oss2 << name << ";string_type;read_write;" << val;
                        // send the request to narval 
                        ada_add_new_parameter (oss2.str().c_str(),&err);
                }
        }       
        return err;
#else 
        return -1;
#endif
}

ConfAgent *NarvalInterface::GetConfAgent() const 
{ 
        return ConfAgent::theGlobalAgent(); 
}

void NarvalInterface::process_config (const Char_t *directory, UInt_t *error_code, Short_t do_adf_conf)
{
        // just in case
        *error_code = 0u; 
        
        // add / at the end of path in case it is not there
        std::string tmp = directory; 
        if ( tmp.size() > 0 && !(tmp.at(tmp.size()-1) == '/') ) 
                tmp += '/';     
        
        // keep the path in a static variable in case this is needed in Initialise
        G::ConfPath = tmp;
        
        // now try to open an ADF configuration file (if required) and
        // configure/reconfigure (or add information) to the global agent
        switch( do_adf_conf ){
                case 0:
                        break;
                case 1:
                        if ( ! ::getenv("ADF_CONF_PATH") ) {
                                tmp += "ADF.conf"; 
                                ConfAgent::theGlobalAgent()->Configure(tmp.data(),"in");
                                //Log.GetProcessName() = "NarvalInterface::process_config(..,..,1)";    
                                //Log << info << " ADF Reconfiguration with " << tmp.data() << dolog;
                        }
                        //else {
                        //  Log.GetProcessName() = "NarvalInterface::process_config(..,..,1)";  
                        //  Log << info << " No need to reconfigure ADF " << dolog;     
                        //}     
                        break;
                case 2:
                        tmp += "ADF.conf"; 
                        ConfAgent::theGlobalAgent()->Configure(tmp.data(),"in");
                        //Log.GetProcessName() = "NarvalInterface::process_config(..,..,2)";
                        //if ( ::getenv("ADF_CONF_PATH") ) 
                        //  Log << warning << " ADF Reconfiguration with " << tmp.data()  << dolog;
                        //else 
                        //  Log << info << " ADF Reconfiguration with " << tmp.data()  << dolog;
                        break;  
                default:
                        break;
        }
}


//------------------------------------------------------------------------------------
NarvalProducer::NarvalProducer() : 
        NarvalInterface(), 
        fAttachedOutputBlock(0x0),
        fOneBlockOut(1u,ConfAgent::kWrite),
        fFrameIO("FrameIO attached to NarvalProducer") 
{
        Log.GetProcessName() = "NarvalProducer";        
}
NarvalProducer::~NarvalProducer() 
{
        ;
} 
void NarvalProducer::process_config (const Char_t *directory, UInt_t *error_code)
{
        NarvalInterface::process_config(directory,error_code);
        
        if ( (*error_code) == 0u ) {
                // do some additionnal stuff for a producer ?
        }
}
UInt_t NarvalProducer::ProcessBlocks()
{
        Log.SetProcessMethod("ProcessBlocks()");
        
        if ( fAttachedOutputBlock == 0x0 || fAttachedOutputBlock->IsOwner(this) == false ) {
                Log << warning << " No output defined or not owner ... so no process ... so not error ! ==> error = 0u. Block address is " << fAttachedOutputBlock << dolog;
                return 0u; 
        }
        // do the process 
        Bool_t is_rewind = GetFrameIO().DoRewind(false); UInt_t error_code;
        //
        error_code = 
        ProcessBlock( (*fAttachedOutputBlock ) );
        //
        GetFrameIO().DoRewind(is_rewind);
        //
        if ( fAttachedOutputBlock->IsEoB() ) {
                fAttachedOutputBlock->SetOwner(0x0);
        }
        
        Log << dolog;
        
        return error_code;
        
}
void NarvalProducer::process_block ( void *output_buffer,
                                                                                                UInt_t size_of_output_buffer,
                                                                                                UInt_t *used_size_of_output_buffer,
                                                                                                UInt_t *error_code)
{       
        fOneBlockOut.SetBlock((Char_t *)output_buffer,size_of_output_buffer);
        *used_size_of_output_buffer = 0;
        
        (*error_code) = ProcessBlock(fOneBlockOut);     
        (*used_size_of_output_buffer) = UInt_t(fOneBlockOut.GetSize());
}

//------------------------------------------------------------------------------------  
NarvalConsumer::NarvalConsumer() :
        NarvalInterface(), 
        fAttachedInputBlock(0x0),
        fOneBlockIn(1u,ConfAgent::kRead),
        fFrameIO("FrameIO attached to NarvalConsumer") 
{
        Log.GetProcessName() = "NarvalConsumer";        
}

NarvalConsumer::~NarvalConsumer() 
{
        ;
} 

UInt_t NarvalConsumer::ProcessBlocks()
{
        Log.SetProcessMethod("ProcessBlocks()");
        
        if ( fAttachedInputBlock == 0x0 || fAttachedInputBlock->IsOwner(this) == false ) {
                Log << warning << " No input defined or not owner ... so no process ... so not error ! ==> error = 0u. Block address is " << fAttachedInputBlock << dolog;
                return 0u; 
        }
        // do the process 
        Bool_t is_rewind = GetFrameIO().DoRewind(false); UInt_t error_code;
        //
        error_code = 
        ProcessBlock( (*fAttachedInputBlock ) );
        //
        GetFrameIO().DoRewind(is_rewind);
        //
        if ( fAttachedInputBlock->IsEoB() ) {
                fAttachedInputBlock->SetOwner(0x0);
        }
        
        Log << dolog;
        
        return error_code;
}

void NarvalConsumer::process_config (const Char_t *directory, UInt_t *error_code)
{
        NarvalInterface::process_config(directory,error_code);
        
        if ( (*error_code) == 0u ) {
                // do some additionnal stuff for a consumer ?   
        }
}

void NarvalConsumer::process_block (void *input_buffer,
                                                                                                UInt_t size_of_input_buffer,
                                                                                                UInt_t *error_code)
{       
        fOneBlockIn.SetBlock((Char_t *)input_buffer,size_of_input_buffer);
        
        (*error_code) = ProcessBlock(fOneBlockIn);      
}

//------------------------------------------------------------------------------------  

NarvalShunter::NarvalShunter() : 
NarvalInterface()
{
        Log.GetProcessName() = "NarvalShunter";
}
NarvalShunter::~NarvalShunter() 
{
        ;
} 

//------------------------------------------------------------------------------------  
NarvalFilter::NarvalFilter() : 
        NarvalInterface(), 
        fAttachedInputBlock(0x0),
        fAttachedOutputBlock(0x0),
        fOneBlockIn(1u,ConfAgent::kRead),
        fOneBlockOut(1u,ConfAgent::kWrite),
        fFrameIO("FrameIO attached to NarvalFilter")
{
        Log.GetProcessName() = "NarvalFilter";
        
        // Default ... to be sure if there were no triggers evrything 
        // is going through the data flow.
        GetFrameIO().SetModel(ConfAgent::kSafe);        
}
NarvalFilter::~NarvalFilter() 
{
        ;
} 
void NarvalFilter::process_config (const Char_t *directory, UInt_t *error_code)
{
        NarvalInterface::process_config(directory,error_code);
        
        if ( (*error_code) == 0u ) {
                // do some additionnal stuff for a filter ?
        }
}
void NarvalFilter::process_reset (UInt_t *error_code)
{
        *error_code = 0u;
        
        Log.ClearMessage();  Log.SetProcessMethod("process_reset");
        Log << hline << nline ; 
        GetFrameIO().Print( Log() ); 
        Log << hline << dolog;
}

UInt_t NarvalFilter::ProcessBlocks()
{
        Log.SetProcessMethod("ProcessBlocks()");
        
        if ( fAttachedInputBlock == 0x0 || fAttachedInputBlock->IsOwner(this) == false ) {
                Log << warning << " No input defined or not owner ... so no process ... so not error ! ==> error = 0u. Block address is " << fAttachedInputBlock << dolog;
                return 0u; 
        }
        else {
                if ( fAttachedOutputBlock == 0x0 || fAttachedOutputBlock->IsOwner(this) == false ) {
                        Log << warning << " No output defined or not owner ... so no process ... so not error ! ==> error = 0u. Block address is " << fAttachedOutputBlock << dolog;
                        return 0u; 
                }
        }
        
        // do the process 
        Bool_t is_rewind = GetFrameIO().DoRewind(false); UInt_t error_code;
        //
        error_code = 
        ProcessBlock( (*fAttachedInputBlock ), (*fAttachedOutputBlock ) );
        //
        GetFrameIO().DoRewind(is_rewind);
        //
        if ( fAttachedInputBlock->IsEoB() ) {
                fAttachedInputBlock->SetOwner(0x0);
        }
        if ( fAttachedOutputBlock->IsEoB() ) {
                fAttachedOutputBlock->SetOwner(0x0);
        }       
        
        Log << dolog;
        
        return error_code;
}


void NarvalFilter::process_block (void *input_buffer,
                                                                                         UInt_t size_of_input_buffer,
                                                                                         void *output_buffer,
                                                                                         UInt_t size_of_output_buffer,
                                                                                         UInt_t *used_size_of_output_buffer,
                                                                                         UInt_t *error_code)
{               
        fOneBlockIn.SetBlock((Char_t *)input_buffer,size_of_input_buffer);
        fOneBlockOut.SetBlock((Char_t *)output_buffer,size_of_output_buffer);
        *used_size_of_output_buffer = 0;
        
        (*error_code) = ProcessBlock(fOneBlockIn, fOneBlockOut);        
        (*used_size_of_output_buffer) = UInt_t(fOneBlockOut.GetSize());
}