BasicReplica.h

Go to the documentation of this file.

/***************************************************************************
 *   Copyright (C) 2010 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 Gw_BasicReplica
#define Gw_BasicReplica

#include "NarvalInterface.h"
#include "FrameBlock.h"
#include "ADFConfig.h"

using namespace ADF;

namespace Gw {
                

class BasicReplica : public ADF::NarvalShunter 
{
private:
        ADF::FrameBlock *fAttachedInputBlock;
        std::vector < ADF::FrameBlock * > fAttachedOutputBlocks;
private:
        ULong64_t fBytesAttachedInputBlock;
        std::vector < ULong64_t > fBytesAttachedOutputBlock;
        
public:
        BasicReplica() : fAttachedInputBlock(0x0), fAttachedOutputBlocks(), fBytesAttachedInputBlock(0UL), fBytesAttachedOutputBlock()
                {;}
        virtual ~BasicReplica() { UInt_t error = 0u; process_reset(&error); } // nothing to be done, Blocks are owned by the emulator
        
        virtual Int_t GetMaxInput() const
        { 
                return 1; 
        }       
        virtual Int_t GetMaxOutput() const
        { 
                return kMaxInt_t; 
        }
        virtual Int_t GetNbOutput() const 
        {
                return Int_t(fAttachedOutputBlocks.size());
        }               

        virtual Int_t AttachInput(ADF::FrameBlock * block, Int_t slot = -1)
        {
                if ( slot < 1 ) {
                        fAttachedInputBlock = block;
                        return 0;
                }
                return -1;
        }

        virtual Int_t AttachOutput(ADF::FrameBlock *block, Int_t slot = -1)
        {
                Int_t rslot = -1; ULong64_t init = 0UL;
                
                if ( slot < 0 ) { // push_back
                        fAttachedOutputBlocks.push_back(block); fBytesAttachedOutputBlock.push_back(init);
                        //
                        rslot = GetNbOutput() - 1;
                }
                else {
                        if ( slot < GetNbOutput() )
                                fAttachedOutputBlocks[slot] = block;
                }
                        
                return rslot;
        }       
        

        virtual void process_initialise (UInt_t * /*error_code*/ ) {;}
        

        virtual void process_reset (UInt_t *error_code) ;
        
        virtual UInt_t ProcessBlocks() ; 

};

} // namespace

#endif