CompositeFrame.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_CompositeFrame
#include "CompositeFrame.h"
#endif

using namespace ADF; 

CompositeFrame::CompositeFrame(Key *key) : 
        ConcreteFrame(key), 
        fSubKey(0x0), 
        fSubKeyConst(0x0), 
        fCurrentKeys(), 
        fStackOfKeys()
{
        // clone the key with the help of the main factory
        fSubKey = 
                MainKeyFactory::theMainFactory().Clone(key); 
        fSubKeyConst =
                MainKeyFactory::theMainFactory().Clone(key);     
        
        // only one owns the keys
        fCurrentKeys.SetOwner(false); fStackOfKeys.SetOwner(true);
}  
 
CompositeFrame::CompositeFrame(Key *key,const FactoryItem &secondary_key) : 
        ConcreteFrame(key), 
        fSubKey(0x0), 
        fSubKeyConst(0x0), 
        fCurrentKeys(), 
        fStackOfKeys()
{
        fSubKey = 
                MainKeyFactory::theMainFactory().New(secondary_key); 
        fSubKeyConst =
                MainKeyFactory::theMainFactory().New(secondary_key);
        
        // it does not own the keys.
        fCurrentKeys.SetOwner(false); fStackOfKeys.SetOwner(true);
}     

CompositeFrame::~CompositeFrame()
{
        if ( fSubKey ) 
                { delete fSubKey; fSubKey = 0x0; }
        if ( fSubKeyConst ) 
                { delete fSubKeyConst; fSubKeyConst = 0x0; }
        
        fCurrentKeys.Clear(); fStackOfKeys.Delete();
}

Key *CompositeFrame::NewSubKey()
{
        // to know the current number of keys found in this frame
        UInt_t nb_current = fCurrentKeys.GetSize();
        
        // to get the next key on the stack
        Key *key = fStackOfKeys.At(nb_current); 
        
        // no more available, a new one is created by cloning the constant key and added on the top 
        // of the stack to be deleted properly at the end.
        if ( key == 0x0 ) { 
                key = MainKeyFactory::theMainFactory().Clone(fSubKeyConst); 
                if ( key ) 
                        fStackOfKeys.Add(key);
        }
        return key;
}
    
UInt_t CompositeFrame::Scan() 
{ 
        UInt_t sum_data_size = 0u;
        if ( fSubKey == 0x0 || fSubKeyConst == 0x0 ) return sum_data_size; // should not be necessary

        // clear the current stack of keys, set the level of the stack of allocated keys to 0
        // and rewind the buffer to extract the current keys
        fCurrentKeys.Clear(); fStackOfKeys.SetBottom(); fBuffer->SetOffset(); 
        while ( 1 ) {
                // try to get the next key from the frame
                if ( ! fSubKey->Link((*fBuffer),fBuffer->Offset(),fSubKeyConst->GetKeyLength()) ) break;
                
//              fSubKey->Print(); fSubKeyConst->Print();
                
                // check if the current key is of the expected type 
                if ( fSubKeyConst->IsAKey(fSubKey) ) {
                        Key *nextsubkey = NewSubKey();  
                        if ( nextsubkey ) {
                                nextsubkey->Link((*fBuffer),fBuffer->Offset(),fSubKeyConst->GetKeyLength());
                                fCurrentKeys.Add(nextsubkey);
                                
                                sum_data_size += nextsubkey->GetDataLength();
                        }
                        fBuffer->SetOffset(fBuffer->Offset()+fSubKey->GetKeyLength()+fSubKey->GetDataLength()); 
                }
                else break; // cannot scan anymore ... unknown type of key
        }       
        return sum_data_size; 
}  

Bool_t CompositeFrame::IsASubFrame(const Frame &frame)
{
        if ( fSubKeyConst->IsAKey(frame.GetKey()) )
                return true;
        return false;
}       
        
Bool_t CompositeFrame::AddSubFrame(const Frame &frame)
{       
        Bool_t ok = false;
        
        // check if the given Frame is compatible.
        if ( !IsASubFrame(frame) )
                return false;
        
        // check the size needed to add this sub-frame
        UInt_t needed = frame.GetKey()->GetDataLength() + fSubKeyConst->GetKeyLength();
        
        if ( !fBuffer->Reserve(needed) ) 
                return false; 
                
        // get a new subkey, link it to the inner buffer and fill it by the convertion mechanism
        Key *nextsubkey = 0x0;
        nextsubkey = 
                NewSubKey(); 

        ok = nextsubkey->Link((*fBuffer),fBuffer->Offset(),fSubKeyConst->GetKeyLength());
        ok =  ok 
                && nextsubkey->Convert(frame.GetKey());

        // now copy the data part from the given frame into this (Export moves the cursor into fBuffer)
        fBuffer->SetOffset(fBuffer->Offset()+fSubKeyConst->GetKeyLength());
        ok = ok 
                && frame.ExportData((*fBuffer));
        
        // if ok, change the data size in the current buffer, add the newkey to the list of current subkey
        if ( ok ) { 
                fKey->SetDataLength(fKey->GetDataLength()+needed); 
                fCurrentKeys.Add(nextsubkey);
        }
        return ok;
}

Bool_t CompositeFrame::LinkSubFrame(UInt_t whichsubkey, Frame *subframe)
{
        Key *subkey = fCurrentKeys.At(whichsubkey); 
        if ( subkey == 0x0 ) 
                return false;
        
        // export only the data part, the key is converted.
        UInt_t off = 
                fBuffer->Offset(); 
        fBuffer->SetOffset(subkey->GetAddress()+fSubKeyConst->GetKeyLength());

        Bool_t ok;
        ok = subframe->GetKey()->Convert(subkey);
        ok = ok && 
                subframe->Link(fBuffer->CurrentAddress(),subkey->GetDataLength(),'f'); 
        
        fBuffer->SetOffset(off); // back to previous position
        
        return ok; 
}

Bool_t CompositeFrame::TransfertSubFrame(const Frame &from, UInt_t whichsub)
{
        // both frames must be composite 
        if ( from.IsComposite() == false ) 
                return false; 
        
        const Key *subkey = from.GetSubKey(whichsub);
        if ( subkey == from.GetKey() ) {
                return false;
        } // in case the subkey does not exist
                
        Bool_t ok = true;
        UInt_t needed = 
                subkey->GetFrameLength();
        
        // check if enough place in the destination buffer
        RealBuffer()->SetOffset(GetKey()->GetDataLength());
        if ( needed > RealBuffer()->FreeSize() ) 
                if ( !RealBuffer()->Reserve(needed) ) 
                        return false; 
                
        // copy the subframe in the destination frame
        UInt_t pos_subframe;
        if ( (*from.GetRealBuffer()).IsAnOffset(subkey->GetAddress(),pos_subframe) ) 
                ok = ok && 
                        BufferIO::Copy((*from.GetRealBuffer()),(*RealBuffer()),needed,pos_subframe);
        else 
                ok = false;
                
        // change the key content
        if ( ok ) 
                GetKey()->SetDataLength(GetKey()->GetDataLength()+needed);
        
        return ok;
}
    
/*
Bool_t CompositeFrame::ChangeFrame(const Version &version)
{
        if ( IsZombie() ) 
                return false;

        // define the new key and check it is a valid key
        FactoryItem newkeyitem;
        newkeyitem = 
                fSubKeyConst->GetSignature();
        newkeyitem.SetVersion(version);
        
        Key *newkey = 
                KeyFactory::New(newkeyitem);
        if ( newkey == 0x0 ) 
                return false;
                
        // allocation of new keys       
        Key *sub, *subcst;
        
        sub    = KeyFactory::theMainFactory().Clone(newkey); 
        subcst = KeyFactory::theMainFactory().Clone(newkey); 
        
        delete newkey;
        
        if ( sub && subcst ) {
                if ( fSubKeyConst ) 
                        delete fSubKeyConst;
                if ( fSubKey) 
                        delete fSubKey;
                
                fSubKey = sub; fSubKeyConst = subcst;
                
                fStackOfKeys.Delete();  
                fCurrentKeys.Clear(); 

                return true;
        }
        else {
                if ( sub ) 
                        delete sub;
                if ( subcst ) 
                        delete subcst;
                                        
                return false;
        }
}
*/