AgataKeyFactory.h

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_AgataKeyFactory
#define ADF_AgataKeyFactory
#define ADF_AGATAKEYFACTORY_H ADF_AgataKeyFactory

#ifndef ADF_KeyFactory
#include "KeyFactory.h"
#endif
#ifndef ADF_Key
#include "Key.h"
#endif
#ifndef ADF_DotConf
#include "DotConf.h"
#endif

#include <iostream>
#include <string>
#include <map>
#include <utility>

namespace ADF
{ 

class AgataKey : public Key
{
public:
        friend class AgataKeyFactory;
    
protected:
        UInt_t kKeyLength     ;
        UInt_t kMaxDataLength ;   
    
protected:
        UInt_t fMessage, fMask;
    
protected:
        virtual void SetMessage(UInt_t)     = 0;  
       
public:
        AgataKey(BaseBuffer::EEndian e, UInt_t s = 4u*aByte) : 
                Key(e,s), 
                fMessage(0x0A000000), 
                fMask(0x0F000000) 
        { 
                kKeyLength = s; 
                kMaxDataLength = ADF::kMaxUInt_t - kKeyLength; 
        }
        virtual ~AgataKey() 
                {;}    
        
        virtual UInt_t GetMessage()  const   = 0;        
        virtual UInt_t GetEventNumber() const = 0;     
        
        virtual void SetEventNumber(UInt_t) = 0;  
        
        virtual ULong64_t GetTimeStamp() const = 0;  
        virtual void SetTimeStamp(ULong64_t)   = 0;       
        

        virtual void SetDataLength(UShort_t s) 
        { 
                fBuffer->SetOffset(); 
                (*fBuffer) << (UInt_t(s)+kKeyLength); 
        } 
        
        virtual void SetDataLength(UInt_t i) 
        { 
                UInt_t ri = kKeyLength; 
                if ( i < kMaxDataLength ) 
                                ri += i; 
                fBuffer->SetOffset(); 
                (*fBuffer) << ri; 
        }     
                
        virtual UInt_t GetDataLength() const 
        { 
                UInt_t i = 0u; 
                fBuffer->SetOffset(); 
                (*fBuffer) >> i; 
                if ( i >= kKeyLength ) 
                        i = i - kKeyLength ; 
                
                return i;
        }        
                
        virtual UInt_t GetFrameLength() const 
        { 
                UInt_t i = kKeyLength; 
                fBuffer->SetOffset(); 
                (*fBuffer) >> i; 
                return i; 
        }
                

        virtual Bool_t IsAKey(const Key *akey) const
        { 
                Bool_t ok = false;
                if ( akey->GetSignature().GetFactoryName() == GetSignature().GetFactoryName() ) { // be sure an agata factory has allocated akey
                        const AgataKey *ckey = dynamic_cast<const AgataKey *> (akey);
                        if ( ckey ) {
                                ok = (fMessage == (ckey->GetMessage() & fMask));                                
                        }
                }
                return ok;
        } 
                
        virtual void ChangeType(UInt_t messtype, UInt_t messmask) 
        { 
                fMessage = messtype; 
                fMask = messmask; 
        }     
        
        virtual void Print(std::ostream &out = std::cout) const;  
        

        virtual Bool_t Convert(const Key *akey);        
};



class AgataKeyFactory : public AKeyFactory<AgataKeyFactory>
{
        friend class AKeyFactory<AgataKeyFactory>;
    
private:
        // correspondance between a string (human readable) and a message type (UInt_t)
        std::map<std::string,std::pair<UInt_t,UInt_t> > fMessageTable; 
    
private:
        std::map<std::string,std::pair<UInt_t,UInt_t> > fHardcodedMessageTable; 
        
private:
        Bool_t fIsPatchEvent; 
        
private:
        AgataKeyFactory();
        virtual ~AgataKeyFactory () 
                {;}

protected: 

        virtual Key *DoNew(const FactoryItem &);
        
        virtual Bool_t ProcessLine(const std::string &); 
        virtual void Reset(const Char_t * = ""); 
        
public:
        virtual void SetEndian(BaseBuffer::EEndian) 
                { KeyFactory::SetEndian(BaseBuffer::kLittle); }

        const std::map<std::string,std::pair<UInt_t,UInt_t> > & GetKnownKeys() const
        {
                return fMessageTable;
        }

        Bool_t GetMessage(std::string keyName, UInt_t &message, UInt_t &mask);
        Bool_t GetMessage(std::string keyName, UInt_t &message)
        {
                UInt_t mask;
                return GetMessage(keyName,message,mask);
        }

        const Char_t *GetMessage(UInt_t);
        
        virtual Bool_t DoConfigure(std::ostream &) ;
        virtual Bool_t DoConfigure(std::istream &in, Bool_t allow_init) 
                { return DotConf::DoConfigure(in, allow_init); }
}; 
// AgataKeyFactory inline members //////////////////////////////////////////////////////


} // namespace ADF
#endif