AgataKeyFactory.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_DefaultKeyFactory
#include "AgataKeyFactory.h"
#endif
#include <sstream>
#include <iomanip>

// common to all agata keys
void ADF::AgataKey::Print(std::ostream &out) const
{
        out << "[AgataKey" 
        << " (" << GetVersion().GetMajor() << "," << GetVersion().GetMinor() << ")] " 
        << std::dec     << std::setw(4)         << GetFrameLength() 
        << " 0x" << std::hex                << GetMessage()
        << " " << std::dec << std::setw(15) << GetEventNumber()
        << " "  << std::setw(16)            << GetTimeStamp();
        //<< std::endl;   // user should decide, like in Key::Print()
} 

    
Bool_t ADF::AgataKey::Convert(const Key *akey) 
{       
        // reset status
        fBuffer->SetStatus();
        
        if ( IsAKey(akey) ) { // this is also an agatakey !!
        
                const ADF::AgataKey *agatakey = dynamic_cast<const AgataKey *>(akey);
        
                SetDataLength(agatakey->GetDataLength());       
                SetMessage(agatakey->GetMessage());
                SetEventNumber(agatakey->GetEventNumber());
                SetTimeStamp(agatakey->GetTimeStamp());
        }
        else ADF::Key::Convert(akey); // default action of conversion i.e copy just length
        
        return fBuffer->GetStatus() == BaseBuffer::kGood;
}

// specific keys
#include "AgataKeyFactory.icpp"

#include <fstream>

using namespace ADF;

AgataKeyFactory::AgataKeyFactory () :  
        AKeyFactory<AgataKeyFactory>("Agata"), 
        fMessageTable(),
        fHardcodedMessageTable(),
        fIsPatchEvent(false)
{ 
        // Log related
        fLog.GetProcessName() = "ADF::AgataKeyFactory"; 
        
        // DotConf related i.e. current definition
        SetRID("ADF::AgataKeyFactory"); 
        SetWithRecord(true);
        SetMaxVersion(0);
        
        // add hardcoded table : never reset or modified
        fHardcodedMessageTable["agata"] = std::pair<UInt_t,UInt_t>(0x0A000000,0x0F000000);      
        fHardcodedMessageTable["data"]  = std::pair<UInt_t,UInt_t>(0x0A000100,0x0F000F00);      
        fHardcodedMessageTable["meta"]  = std::pair<UInt_t,UInt_t>(0x0A001100,0x0F00FF00);      
        fHardcodedMessageTable["conf"]  = std::pair<UInt_t,UInt_t>(0x0A000200,0x0F000F00);      
        fHardcodedMessageTable["algo"]  = std::pair<UInt_t,UInt_t>(0x0A000300,0x0F000F00);      
        fHardcodedMessageTable["info"]  = std::pair<UInt_t,UInt_t>(0x0A000400,0x0F000F00);      
        fHardcodedMessageTable["rmess"] = std::pair<UInt_t,UInt_t>(0x0A000500,0x0F000F00);      
        fHardcodedMessageTable["cmess"] = std::pair<UInt_t,UInt_t>(0x0A000600,0x0F000F00);      
        fHardcodedMessageTable["event"] = std::pair<UInt_t,UInt_t>(0xCA000000,0xFF000000);              
}

void AgataKeyFactory::Reset(const Char_t * /*opt*/) 
{ 
        // reset patch, set again @ reading of the keys. by default for version -1
        fIsPatchEvent = false;

        // clear message table BUT NOT the hard coded part
        fMessageTable.clear(); 
}

Key *AgataKeyFactory::DoNew(const FactoryItem &item)
{
        // cannot deal with request asking for a version greater that what can manage this version
        if ( item.GetFactoryVersion() > GetMaxVersion() ) 
                return 0x0;
        
        AgataKey *key = 0x0; std::string keytype = item.GetItemName(); 

        // set the correct version
        if (  item.GetVersion() == Version(0,0)  ) { 
                key = new AgataKey_0_0(GetEndian()); 
        }
        if (  item.GetVersion() == Version(1,0)  ) { 
                key = new AgataKey_1_0(GetEndian()); 
        }
        if (  item.GetVersion() == Version(2,0)  ) { 
                key = new AgataKey_2_0(GetEndian()); 
        }
        if (  item.GetVersion() == Version(4,0)  ) { 
                key = new AgataKey_4_0(GetEndian()); 
        }
        
        // set message type for that key
        if ( key ) {
                // in case message table is not loaded or wrong, default is a generic agata key 
                UInt_t message = fHardcodedMessageTable["agata"].first, mask = fHardcodedMessageTable["agata"].second ; 
                
                // patch to deal with unversionned version (-1) which was defining event key like standard algorithms
                if ( fIsPatchEvent && keytype == "event:data:psa" )
                        keytype = "data:eb";
                if ( fIsPatchEvent && keytype == "event:data" )
                        keytype = "data:merger";                
        
                // iterator on the map 
                std::map<std::string,std::pair<UInt_t,UInt_t> >::iterator im; 
        
                // look if it exists
                Short_t isin = 0;
                for (im = fMessageTable.begin() ; im !=  fMessageTable.end() ; im++ ) { 
                        if ( im->first == keytype ) { isin = 1; break; }
                }
                for (im = fHardcodedMessageTable.begin() ; im !=  fHardcodedMessageTable.end() ; im++ ) { 
                        if ( im->first == keytype ) { isin = 2; break; }
                }               
                switch (isin) {
                        case 0:
                                delete key; key = 0x0;
                                break;
                        case 1:
                                message = fMessageTable[keytype].first;  
                                mask    = fMessageTable[keytype].second; 
                                break;
                        case 2:
                                message = fHardcodedMessageTable[keytype].first;  
                                mask    = fHardcodedMessageTable[keytype].second; 
                                break;
                }       
                if ( key )
                        { key->ChangeType(message,mask); key->SetMessage(message); }
                else {
                        fLog << error << " Key type " << item << " has not been found in the Agata key factory, version " << GetVersion() << nline; 
                        if ( fLog.IsDebug(1) ) {
                                fLog.SetLevel(LogMessage::kError,1);
                                DoConfigure( fLog() );
                                fLog.SetLevel(LogMessage::kError,0);
                        }
                }
        }
        else {
                fLog << error << " Key " << item << " is not known by the Agata key factory, version " << nline; 
                if ( fLog.IsDebug(1) ) {
                        fLog.SetLevel(LogMessage::kError,1);
                        DoConfigure( fLog() );
                        fLog.SetLevel(LogMessage::kError,0);
                }
        }

        return key;
}

Bool_t AgataKeyFactory::ProcessLine(const std::string &aline)
{               
        UInt_t ui1, ui2; std::pair<UInt_t,UInt_t> tmpp; std::string tmp, keytype, stream_option = GetStreamOption(); Bool_t ok = true;
        
        // decode the line
        std::istringstream decode(aline);
        // just to be sure ...
        decode.clear(); 
        decode >> tmp >> std::hex >> ui1 >> ui2 ;
        
        if ( !decode.good() ) { // not the expected format
                return false;
        }
        else {
                tmpp.first  = ui1;
                tmpp.second = ui2;
                keytype = tmp; 
        }

        if ( GetVersion() == -1 && stream_option.find("Init") == std::string::npos ) {
                // in the very first version (unversionned, -1) of the factory, the treatment of the event key was not global enough.
                // the factory has been modified so that :
                // it inits with version -1 but a more complete set of keys
                // it allows to work with version 0 of the factory that includes has a general approach of events and allows to add new keys.
                
                // as a consequence, any attempt to reconfigure/init this for version -1 is blocked there ... only the version # is modified once the record header is read. 
                // another consequence is the patch set in the DoNew method to deal with the two particular cases of event:data:psa and event:data
                // NOTE : reading data produced with version -1 force keeping version -1 way of coding event:data:psa and event:data 
                
                // test : if version -1, check if it is there . true if yes otherwise false
                if ( fMessageTable.count(tmp) == 1 )
                        return true;
                if ( fHardcodedMessageTable.count(tmp) == 1 )
                        return true;    
                
                return false;
        }
        // 
        if ( GetVersion() == -1 && keytype == "data:eb" && ui1 == 0xFA010103 ) {
                if ( fLog.IsDebug(5) )
                        fLog << info << " Switch to patch == true for version - 1 " << keytype << nline; // 
                fIsPatchEvent = true;
        } // @ this level in init mode ==> put it in the message table
        if ( GetVersion() == -1 && keytype == "event:data:psa" && ui1 == 0xCA010102 ) {
                if ( fLog.IsDebug(5) )
                        fLog << info << " Switch to patch == true for version - 1 " << keytype <<  nline; //    
                fIsPatchEvent = true;
        } // @ this level in init mode ==> put it in the message table ... second check, jsut to be sure in case one is accidentally erase in conf file
        
        // check whether or not it is an harcoded key 
        if ( fHardcodedMessageTable.count(tmp) == 1 ) {
                if ( fLog.IsDebug(5) )
                        fLog << info << " Attemp to modify an hard coded key " << tmp << " ... ignored "<< nline; // cannot be changed
        }
        else {
                // because the key in the std::map is unique, it is change automatically in case the key is already in the map
                if ( fMessageTable.count(keytype) == 1 ) { // already in the table, change definition
                        if ( stream_option.find("==") != std::string::npos || stream_option.find("Init") != std::string::npos )
                                fMessageTable[keytype] = tmpp;  
                        else 
                                ok = false;
                }
                if ( fMessageTable.count(keytype) == 0 ) { // not yet in the table
                        if ( stream_option.find("+") != std::string::npos || stream_option.find("Init") != std::string::npos )
                                fMessageTable[keytype] = tmpp;  
                        else 
                                ok = false;
                }
        }
        //      printf("TABLE SIZE %d\n",fMessageTable.size());
        return ok;
}

Bool_t AgataKeyFactory::GetMessage(std::string keyName, UInt_t &message, UInt_t &mask)
{
        Bool_t found = false;
        
        // iterator on the map
        std::map<std::string,std::pair<UInt_t,UInt_t> >::iterator im;  
        
        for (im = fMessageTable.begin() ; im != fMessageTable.end() ; im++ ) { 
                if ( im->first == keyName ) { 
                        message = im->second.first; mask = im->second.second;
                        found = true; 
                        break; 
                }
        }
        // in case, look also in the hardcoded ones
        if(!found) {
                for (im = fHardcodedMessageTable.begin() ; im != fHardcodedMessageTable.end() ; im++ ) { 
                        if ( im->first == keyName ) { 
                                message = im->second.first; mask = im->second.second;
                                found = true; 
                                break; 
                        }
                }
        }
        
        return found;   
}

const char *AgataKeyFactory::GetMessage(UInt_t message)
{
        const char *st = 0x0;
        
        // iterator on the map
        std::map<std::string,std::pair<UInt_t,UInt_t> >::iterator im;  
        
        for (im = fMessageTable.begin() ; im != fMessageTable.end() ; im++ ) { 
                if ( im->second.first == message ) { 
                        st = im->first.c_str(); 
                        // patch around version -1
                        if ( fIsPatchEvent && im->first == "data:eb" )
                                st = "event:data:psa";
                        if ( fIsPatchEvent && im->first == "data:merger" )
                                st = "event:data";
                        break; 
                }
        }
        if ( !st ) {
                for (im = fHardcodedMessageTable.begin() ; im != fHardcodedMessageTable.end() ; im++ ) { 
                        if ( im->second.first == message ) {
                                st = im->first.c_str();
                                break;
                        }
                }
        }
        return st ? st : "UnknownKey";
}

Bool_t AgataKeyFactory::DoConfigure (std::ostream & out)
{
        // add a start record
        AddRecord(out,'b');
        
        if ( fMessageTable.size() > 0 ) { // write only non-hardcoded part
                // iterator on the map 
                std::map<std::string,std::pair<UInt_t,UInt_t> >::iterator im; 
                for (im = fMessageTable.begin() ; im !=  fMessageTable.end() ; im++ ) { 
                        out << im->first << "\t\t" 
                                << std::hex << im->second.first << "\t" << im->second.second << std::dec << " \n" ; 
                }               
        }       

        // add an end of record
        AddRecord(out,'e');
        
        return out.good();
}