Key.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_Key
#define ADF_Key
#define ADF_KEY_H ADF_Key

#ifndef ADF_BufferIO
#include "BufferIO.h"
#endif

#ifndef ADF_FactoryItem
#include "FactoryItem.h"
#endif

#include <typeinfo>

namespace ADF
{ 

class KeyFactory;
class ConcreteFrame;


class Key
{   
public:
        friend class KeyFactory;  
        friend class ConcreteFrame;  
           
private:
        /*
        class KeySignature : public FactoryItem
        {
        public:
                KeySignature(std::string);
                
                std::string fType;      // type of this key ... corresponding to the interface
                UInt_t  fUniqueID;      // KeyID as delivered by the KeyFactory, helps to compare Keys
        };
        KeySignature fSignature; */
        FactoryItem fSignature;
        
protected:  
        Version GetVersion() const 
                { return fSignature.GetVersion() ; }
            
protected:      

        virtual BufferIO *RealBuffer() 
                { return fBuffer; }     
    
private:    
        void SetDataLength(Int_t)  
                {;}
        void SetDataLength(Short_t)
                {;}
            
protected:
        BufferIO *fBuffer;
           
private:
        Key(); 
    
protected:    

        Key(BaseBuffer::EEndian, UInt_t s);   
      
public:      
        virtual ~Key();
        
        const FactoryItem &GetSignature() const
                { return fSignature; }
                        
        virtual const BufferIO *GetRealBuffer() const 
                { return fBuffer; }
                
        virtual BaseBuffer::EStatus GetKeyStatus() const 
                { return fBuffer->GetStatus();}
        virtual void ClearKeyStatus()              
                { fBuffer->SetStatus(BaseBuffer::kGood);}
        
        virtual BaseBuffer::EEndian GetEndian() const 
                { return fBuffer->GetEndian(); }
        
        virtual void SetDataLength(UShort_t) 
                { fBuffer->SetStatus(BaseBuffer::kCorrupt) ;} 
        virtual void SetDataLength(UInt_t)   
                { fBuffer->SetStatus(BaseBuffer::kCorrupt) ;}   
        
        virtual UInt_t   GetDataLength() const 
                { return 0u; }  
        virtual UInt_t  GetFrameLength() const 
                { return GetKeyLength() + GetDataLength(); }      
        
        virtual const Char_t *GetAddress() const 
                { return fBuffer->GetAddress(); }     
                

        virtual Bool_t Link(const Char_t *, UInt_t);    
                

        virtual Bool_t Link(const BufferIO &buf, UInt_t pos, UInt_t size);
        

        virtual Bool_t Copy(const Char_t *, UInt_t);
                        
        virtual void Unlink() 
                { fBuffer->Unlink(); }
        
        virtual Bool_t IsLinked() const
                { return fBuffer->IsLinked(); }   
        

        virtual Bool_t Copy(const Key *);     
        

        virtual Bool_t Export(BufferIO &buf) const 
        { 
                Bool_t ok = 
                        (buf.Import((*fBuffer),fBuffer->Size()) == fBuffer->Size());
                return ok;
        }  
        

//      UInt_t GetUniqueID() const 
//              { return fSignature.fUniqueID; }
                

//      virtual const std::string &GetKeyType() const 
//              { return fSignature.fType ; }
                

        virtual UInt_t GetKeyLength() const 
                { return fBuffer->Size(); }
        

        virtual Bool_t IsAKey(const Key *akey) const
        {
                return fSignature == akey->GetSignature(); 
        }
        

        virtual Bool_t Convert(const Key *akey) 
        { 
                // to test if the length could be stream from one key to another one (ex : length could be too high converting int to short)
                fBuffer->SetStatus(); 
                // copy data /frame length
                SetDataLength(akey->GetDataLength()); 
                
                return fBuffer->GetStatus() == BaseBuffer::kGood; 
        }
                
        virtual void Print(std::ostream &out = std::cout) const;
};
// Key inline members //////////////////////////////////////////////////////

} // namespace ADF
#endif