Frame.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_KeyFactory
#include "KeyFactory.h"
#endif
#ifndef ADF_Frame
#include "Frame.h"
#endif
#ifndef ADF_ConfigurationFrame
#include "ConfigurationFrame.h"
#endif
#include <sstream>
#include <fstream>

using namespace ADF; 


Frame::Frame(): 
fSignature("Default","",Version(0,0)), 
// Migration SharedFP   fZombie(false),
// Migration SharedFP   fKeyChange(ChangeOfVersion),
// Migration SharedFP   fFrameChange(NoChange),
fCheckLevel(0)
{
} 


Frame::Frame(Key *): 
fSignature("Default","",Version(0,0)), 
fCheckLevel(0)  
{
} 

Frame::~Frame()
{
}

Bool_t Frame::Configure(const char *name, const char *option)
{       
        Bool_t ok; std::string opt = option;
        if ( opt == "in" ) {
                std::ifstream filein(name);
                if ( filein.is_open() == true ) { 
                        ok = DoConfigure(filein);
                }
                else 
                        ok = false;     
                filein.close();
        }
        else {
                std::ofstream fileout(name);
                if ( fileout.is_open() == true ) { 
                        ok = DoConfigure(fileout);
                }
                else 
                        ok = false;
                fileout.close();
        }
        return ok;
}

Bool_t Frame::Configure(ConfigurationFrame *confframe,  const char *option)
{
        Bool_t ok; std::string opt = option;
        
        if ( opt == "in" ) {
                // load the content of the frame in the string
                confframe->Read();
                // use stream facility 
                std::istringstream in;
                in.clear();
                in.str((confframe->String()));
                ok = DoConfigure(in);
        }
        else {
                // use stream facility 
                std::ostringstream out;
                ok = DoConfigure(out);
                confframe->String() = out.str();
                confframe->Write();
        }
        return ok;
}

/*
 ConcreteFrame::ConcreteFrame(): 
 Frame(), 
 fBuffer(0), 
 fKey(0)
 {
 fBuffer = new BufferIO(); Reset(); // default is length 1 byte, endian type of the system
 }
 */

ConcreteFrame::ConcreteFrame(Key *key): 
Frame(), 
fBuffer(0), 
fKey(key)
{       
        // same endian as the key and extract the length from it.
        BaseBuffer::EEndian e = BaseBuffer::SysEndian(); UInt_t s = aByte;
        if ( fKey ) 
        { e = fKey->GetEndian(); s = fKey->GetDataLength(); }
        //
        fBuffer = BufferIO::New(e,s); 
        //
        Reset();
}   

ConcreteFrame::~ConcreteFrame()
{
        // destructor
        if ( fKey ) 
                delete fKey; 
        fKey = 0x0; 
        
        if ( fBuffer ) 
                delete fBuffer; 
        fBuffer = 0x0;
}

Bool_t ConcreteFrame::Copy(const Frame *frame)
{
        Bool_t ok;
        
        // have to be the same frame and the same key
        //      if ( !(GetSignature() == frame->GetSignature()) ) 
        //              return false;
        // only the true implemtation should be the same
        if ( !(fKey->GetSignature() == frame->GetKey()->GetSignature()) ) 
                return false;   
        if ( !(GetSignature() == frame->GetSignature()) ) 
                return false;
        
        ok = Copy(frame->GetKey()->GetRealBuffer()->GetAddress(),frame->GetKey()->GetKeyLength(),'k');
        ok = ok && 
        Copy(frame->GetRealBuffer()->GetAddress(),frame->GetKey()->GetDataLength(),'f');
        
        return ok;
}

Bool_t ConcreteFrame::Link(const Frame *frame)
{
        Bool_t ok;
        
        // have to be the same frame and the same key
        //      if ( !(GetSignature() == frame->GetSignature()) ) 
        //              return false;
        if ( !(fKey->GetSignature() == frame->GetKey()->GetSignature()) ) 
                return false;   
        if ( !(GetSignature() == frame->GetSignature()) ) 
                return false;
        
        ok = Link(frame->GetKey()->GetRealBuffer()->GetAddress(),frame->GetKey()->GetKeyLength(),'k');
        ok = ok && Link(frame->GetRealBuffer()->GetAddress(),frame->GetKey()->GetDataLength(),'f');
        
        return ok;
}

void ConcreteFrame::Dump(const Char_t *filename, Bool_t anew) const 
{
        FILE *dfile = NULL;
        
        if ( anew )
                dfile = ::fopen(filename,"wb"); // try to open the file in writting mode
        else
                dfile = ::fopen(filename,"ab"); // try to open the file in append mode
        
        if ( dfile == NULL ) 
                return;
        
        ::fwrite(fKey->GetRealBuffer()->GetAddress(),1,fKey->GetKeyLength(),dfile);
        ::fwrite(fBuffer->GetAddress(),1,fKey->GetDataLength(),dfile); 
        
        fclose(dfile);
}

Bool_t ConcreteFrame::Dump(FILE *dfile) const
{
        size_t count;
        
        count  = 0;
        count += ::fwrite(fKey->GetRealBuffer()->GetAddress(),1,fKey->GetKeyLength(),dfile);
        count += ::fwrite(fBuffer->GetAddress(),1,fKey->GetDataLength(),dfile); 
        
        return count == fKey->GetFrameLength();
}

Bool_t ConcreteFrame::Load(FILE *dfile)
{
        UInt_t count;
        
        // reset the Frame
        Reset();
        
        // check if enough space to read the key part and after the data and do it if all right
        count  = 0u;
        fKey->RealBuffer()->SetOffset();        
        count += fKey->RealBuffer()->Import(dfile,fKey->GetKeyLength());
        
        fBuffer->SetOffset();
        if ( ! fBuffer->Reserve(fKey->GetDataLength()) ) 
                return false;
        count += fBuffer->Import(dfile,fKey->GetDataLength());  
        
        return count == fKey->GetFrameLength();
}

void ConcreteFrame::Stallion(UInt_t repetition)
{
        // to produce 64 bits like stallions
        UInt_t bwritten, offset, toadd; std::string s, send;
        
        send = "||||||||||||"; 
        
        s = "|";        
        s+= GetSignature().GetFactoryName(); 
        s+= ":";
        s+= GetSignature().GetItemName();
        s+= GetSignature().GetVersion().GetString();
        s+= "|";        
        s+= GetSignature().GetFactoryName(); 
        s+= ":";
        s+= GetSignature().GetItemName();
        s+= GetSignature().GetVersion().GetString();    
        s+= "|";
        
        offset = (GetKey()->GetKeyLength() + repetition*s.size()) % 8u;
        toadd = 8u - offset;
        
        Reset(); (*fBuffer).Reserve(repetition*UInt_t(s.size())+toadd);
        bwritten = 0u;  
        for (UInt_t i = 0u; i < repetition; i++ ) {
                if ( (*fBuffer).Import(s.data(),UInt_t(s.size())) != s.size() )
                        break;
                
                bwritten += UInt_t(s.size());
        }
        if ( toadd > 0u ) {
                (*fBuffer).Import(send.data(),toadd); bwritten += toadd;
        }
        fKey->SetDataLength(bwritten);
}


SharedFP::SharedFP(Frame *f): 
fFrame(0x0),
fIsValid(false),
fKeyChange(ChangeOfVersion),    
fFrameChange(ChangeOfVersion)
{
        SetFrame(f);
} 

Frame *SharedFP::SetFrame(Frame *newf)
{
        Frame *oldf = fFrame;
        fFrame = newf;
        
        if ( fFrame ) 
                fIsValid = true;
        else 
                fIsValid = false;
        
        return oldf;
}