DefaultKeyFactory.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_DefaultKeyFactory
#define ADF_DefaultKeyFactory
#define ADF_DEFAULTKEYFACTORY_H ADF_DefaultKeyFactory

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

#ifndef ADF_Key
#include "Key.h"
#endif

namespace ADF
{ 

class FSKey_0_0 : public Key
{
private:
    static const UShort_t kMaxDataLength = ADF::kMaxUShort_t - sizeof(UShort_t);
    
public:
    FSKey_0_0(BaseBuffer::EEndian e, UInt_t s = sizeof(UShort_t)) : Key(e,s) 
                {;}
    virtual ~FSKey_0_0() 
                {;}    
    

    virtual void SetDataLength(UShort_t s) 
        { 
                UShort_t rs = sizeof(UShort_t); 
                if ( s < kMaxDataLength ) 
                        rs += s; 
                fBuffer->SetOffset(); (*fBuffer) << rs; 
        } 


    virtual void SetDataLength(UInt_t i) 
        { 
                fBuffer->SetOffset(); 
                if ( i < UInt_t(kMaxDataLength) ) { 
                        (*fBuffer) << UShort_t(i+sizeof(UShort_t)); 
                        return; 
                } 
                (*fBuffer) << i; 
    } 

//   virtual UShort_t GetDataLength(UShort_t s) const
//      { s = 0u; fBuffer->SetOffset(); (*fBuffer) >> s; return s; }
                        
    virtual UInt_t GetDataLength() const { 
                UShort_t s = 0u; 
                fBuffer->SetOffset(); 
                (*fBuffer) >> s; 
                return UInt_t(s-sizeof(UShort_t)); 
    }    
        
    virtual UInt_t GetFrameLength() const 
        { UShort_t s = 0u; fBuffer->SetOffset(); (*fBuffer) >> s; return UInt_t(s); }       
};


class FSKey_0_1 : public Key
{
private:
    static const UInt_t kMaxDataLength = ADF::kMaxUInt_t - sizeof(UInt_t);
    
public:
    FSKey_0_1(BaseBuffer::EEndian e, UInt_t s = sizeof(UInt_t)) : Key(e,s) 
                {;}
    virtual ~FSKey_0_1() 
                {;}    
    

    virtual void SetDataLength(UShort_t s) 
        { 
                fBuffer->SetOffset(); 
                (*fBuffer) << UInt_t(s+sizeof(UInt_t));
        } 


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

class UIDKey : public Key
{       
public:
        UIDKey(BaseBuffer::EEndian e, UInt_t s) : Key(e,s)
        {
                ;
        }
        virtual ~UIDKey() 
        {
                ;
        }    
        
        virtual ULong64_t GetUID() const = 0 ;
        virtual void SetUID(ULong64_t) = 0;

        virtual ULong64_t GetEventNumber() const
        {
                return GetUID();
        }
        virtual ULong64_t GetTimeStamp(ULong64_t) const
        {
                return GetUID();
        }
        virtual void SetEventNumber(ULong64_t i)
        {
                SetUID(i);
        }
        virtual void SetTimeStamp(ULong64_t i)
        {
                SetUID(i);
        }
};


class UIDKey_0_0 : public UIDKey
{
private:
        UInt_t fDataSize;
        UInt_t fFrameSize;

public:
        UIDKey_0_0(BaseBuffer::EEndian e, UInt_t s = 4u*aByte) : UIDKey(e,s), fDataSize(0u)
        {
                fFrameSize = fDataSize + 4u*aByte;
        }
        virtual ~UIDKey_0_0() 
        {;}    

        virtual ULong64_t GetUID() const
        {
                UInt_t i = 0u; 
                fBuffer->SetOffset(0u); 
                (*fBuffer) >> i; 
                
                return i;               
        }
        virtual void SetUID(ULong64_t i) 
        {
                fBuffer->SetOffset(0u);
                (*fBuffer) << UInt_t(i);
        }    
        virtual UInt_t GetDataLength() const 
        { 
                return fDataSize;
        }       
        virtual UInt_t GetFrameLength() const 
        { 
                return fFrameSize;
        }       
        virtual void SetDataLength(UInt_t s) 
        { 
                fDataSize = s; fFrameSize = fDataSize + 4u*aByte;
        } 
    virtual void SetDataLength(UShort_t us)
        { ADF::Key::SetDataLength(us);}

        
};
        

class UIDKey_0_1 : public UIDKey
{
private:
        UInt_t fDataSize;
        UInt_t fFrameSize;
        
public:
        UIDKey_0_1(BaseBuffer::EEndian e, UInt_t s = 8u * aByte) : UIDKey(e,s), fDataSize(0u)
        {
                fFrameSize = fDataSize + 8u*aByte;
        }
        virtual ~UIDKey_0_1() 
        {;}    
        
        virtual ULong64_t GetUID() const
        {
                ULong64_t i = 0u; 
                fBuffer->SetOffset(0u); 
                (*fBuffer) >> i; 
                
                return i;               
        }
        virtual void SetUID(ULong64_t i) 
        {
                fBuffer->SetOffset(0u);
                (*fBuffer) << i;
        }    
        virtual UInt_t GetDataLength() const 
        { 
                return fDataSize;
        }       
        virtual UInt_t GetFrameLength() const 
        { 
                return fFrameSize;
        }       
        virtual void SetDataLength(UInt_t s) 
        { 
                fDataSize = s; fFrameSize = fDataSize + 8u*aByte;
        } 
        virtual void SetDataLength(UShort_t s) 
        { 
                fDataSize = s; fFrameSize = fDataSize + 8u*aByte;
        }
};
        

class UIDKey_1_0 : public UIDKey
{
        static const UShort_t kKeyLength = 6u*aByte; 

public:
        UIDKey_1_0(BaseBuffer::EEndian e, UInt_t s = kKeyLength ) : UIDKey(e,s)
        {
                ;
        }
        virtual ~UIDKey_1_0() 
        {;}    
        
        virtual ULong64_t GetUID() const
        {
                UInt_t i = 0u; 
                fBuffer->SetOffset(2u); 
                (*fBuffer) >> i; 
                
                return i;               
        }
        virtual void SetUID(ULong64_t i) 
        {
                fBuffer->SetOffset(2u);
                (*fBuffer) << UInt_t(i);
        }       
        virtual UInt_t GetFrameLength() const 
        { 
                UShort_t i = 0u; 
                fBuffer->SetOffset(); 
                (*fBuffer) >> i; 
                return i;
        }       
        virtual UInt_t GetDataLength() const 
        { 
                UShort_t i = 0u; 
                fBuffer->SetOffset(); 
                (*fBuffer) >> i; 
                
                return i - kKeyLength ;
        }        

        virtual void SetDataLength(UShort_t s) 
        { 
                UShort_t si = s + kKeyLength; 
                //
                fBuffer->SetOffset(); 
                (*fBuffer) << si;
        } 
        

        virtual void SetDataLength(UInt_t i) 
        { 
                UShort_t si = i + kKeyLength; 
                //
                fBuffer->SetOffset(); 
                (*fBuffer) << si; 
        }    
};


class UIDKey_1_1 : public UIDKey
{
        static const UShort_t kKeyLength = 10u*aByte; 

public:
        UIDKey_1_1(BaseBuffer::EEndian e, UInt_t s = kKeyLength) : UIDKey(e,s)
        {
                ;
        }
        virtual ~UIDKey_1_1() 
        {;}    
        
        virtual ULong64_t GetUID() const
        {
                ULong64_t i = 0u; 
                fBuffer->SetOffset(2u); 
                (*fBuffer) >> i; 
                
                return i;               
        }
        virtual void SetUID(ULong64_t i) 
        {
                fBuffer->SetOffset(2u);
                (*fBuffer) << i;
        }    

        virtual UInt_t GetFrameLength() const 
        { 
                UShort_t i = 0u; 
                fBuffer->SetOffset(); 
                (*fBuffer) >> i; 
                
                return i;
        }       
        virtual UInt_t GetDataLength() const 
        { 
                UShort_t i = 0u; 
                
                fBuffer->SetOffset(); 
                (*fBuffer) >> i; 
                
                return i - kKeyLength ;
        }               
        

        virtual void SetDataLength(UShort_t s) 
        { 
                UShort_t si = s + kKeyLength; 
                //
                fBuffer->SetOffset(); 
                (*fBuffer) << si;
        } 
        

        virtual void SetDataLength(UInt_t i) 
        { 
                UShort_t si = i + kKeyLength; 
                //
                fBuffer->SetOffset(); 
                (*fBuffer) << si; 
        }    
};


class DefaultKeyFactory : public AKeyFactory<DefaultKeyFactory>
{
    friend class AKeyFactory<DefaultKeyFactory>;

private:
    DefaultKeyFactory () : AKeyFactory<DefaultKeyFactory>("Default") 
        { 
                        fLog.GetProcessName() = "DefaultKeyFactory"; 
        }
    virtual ~DefaultKeyFactory() 
                {;}

protected: 

        virtual Key *DoNew(const FactoryItem &) ;
}; 



} // namespace ADF
#endif