GObject.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.             *
 ***************************************************************************/

#include "GObject.h"

using namespace ADF; 

GObject::GObject() : 
fDataItems(), 
fDataLinks(), 
fArrayOfItems(),
fArrayOfIdleItems()      
{
}       
GObject::~GObject()
{
        // delete proxy and links
        size_t i, size = fArrayOfItems.size(); 
        for (i = 0; i < size; i++) {
                if ( fArrayOfItems[i].second.first ) { // Is a proxy
                        delete fArrayOfItems[i].second.first;
                        fArrayOfItems[i].second.first = 0x0;
                }
                if ( fArrayOfItems[i].second.second ) { // Is a link
                        UnLink ( fArrayOfItems[i].second.second );      
                }
                
        }
        // delete  proxy and links for idle items
        size = fArrayOfIdleItems.size(); 
        for (i = 0; i < size; i++) {
                if ( fArrayOfIdleItems[i].second.first ) { // Is a proxy
                        delete fArrayOfIdleItems[i].second.first;
                        fArrayOfIdleItems[i].second.first = 0x0;
                }
                if ( fArrayOfIdleItems[i].second.second ) { // Is a link
                        UnLink ( fArrayOfIdleItems[i].second.second );  
                }
        }
        // now item and items car be safely deleted (items needed in UnLink method)
        size = fArrayOfItems.size(); 
        for (i = 0; i < size; i++) {
                delete fArrayOfItems[i].first; fArrayOfItems[i].first = 0x0;
        }
        size = fArrayOfIdleItems.size(); 
        for (i = 0; i < size; i++) {
                delete fArrayOfIdleItems[i].first; fArrayOfIdleItems[i].first = 0x0;
        }       
}
Bool_t GObject::AddItem(ANamedItem *item) 
{
        // check if an item with the same name and type already exist
        size_t i, size = fArrayOfItems.size(); 
        for (i = 0; i < size; i++) {
                if (fArrayOfItems[i].first->Name() == item->Name() && 
                         fArrayOfItems[i].first->Type() == item->Type()) {
                        return false;
                }
        }
        // if not add it to the list of items
        GObject::FullItem p;
        p.first         = item;
        p.second.first  = 0x0; 
        p.second.second = 0x0;  
        
        fArrayOfItems.push_back( p ); fDataItems.push_back( item );
        
        return true;
} 
GObject::FullItem *GObject::IsAnItem(const Char_t *name, const Char_t *type)
{
        size_t i, size = fArrayOfItems.size(); 
        FullItem *item = 0x0;
        
        for (i = 0u; i < size; i++) {
                if ( fArrayOfItems[i].first->Name() == name && fArrayOfItems[i].first->IsType(type) ) {
                        item = &fArrayOfItems[i];
                        break;
                }
        }       
        return item;    
}
GObject::FullItem *GObject::IsAnItem(const ANamedItem *item)
{
        return IsAnItem(item->GetName().data(),item->GetType().data());
}
GObject::FullItem *GObject::IsAIdleItem(const Char_t *name, const Char_t *type)
{
        size_t i, size = fArrayOfIdleItems.size(); 
        FullItem *item = 0x0;
        
        for (i = 0u; i < size; i++) {
                if ( fArrayOfIdleItems[i].first->Name() == name &&
                         fArrayOfIdleItems[i].first->IsType(type) ) {
                        item = &fArrayOfIdleItems[i];
                        break;
                }
        }       
        return item;    
}
Bool_t GObject::LinkItem(const Char_t *name, const Char_t *type, void *extern_address) 
{ 
        std::string t = type;
        
        if ( t == kUShort_t )
                return Link<UShort_t>(name,(UShort_t *)extern_address);
        if ( t == kShort_t )
                return Link<Short_t>(name,(Short_t *)extern_address);
        if ( t == kUInt_t )
                return Link<UInt_t>(name,(UInt_t *)extern_address);
        if ( t == kInt_t )
                return Link<Int_t>(name,(Int_t *)extern_address);
        if ( t == kULong64_t )
                return Link<ULong64_t>(name,(ULong64_t *)extern_address);
        if ( t == kLong64_t )
                return Link<Long64_t>(name,(Long64_t *)extern_address);
        if ( t == kDouble_t )
                return Link<Double_t>(name,(Double_t *)extern_address);
        if ( t == kFloat_t )
                return Link<Float_t>(name,(Float_t *)extern_address);
        
        return false;
}
// Bool_t GObject::LinkItem(const Char_t *name, Bool_t *address) 
//      { return Link<Bool_t>(name,address); }
Bool_t GObject::LinkItem(const Char_t *name, Short_t *address)
{ return Link<Short_t>(name,address); }
Bool_t GObject::LinkItem(const Char_t *name, UShort_t *address)
{ return Link<UShort_t>(name,address); }
Bool_t GObject::LinkItem(const Char_t *name, Int_t *address)
{ return Link<Int_t>(name,address); }
Bool_t GObject::LinkItem(const Char_t *name, UInt_t *address)
{ return Link<UInt_t>(name,address); }
Bool_t GObject::LinkItem(const Char_t *name, Float_t *address)
{ return Link<Float_t>(name,address); }
Bool_t GObject::LinkItem(const Char_t *name, Double_t *address)
{ return Link<Double_t>(name,address); }
Bool_t GObject::LinkItem(const Char_t *name, Long64_t *address)
{ return Link<Long64_t>(name,address); }      
Bool_t GObject::LinkItem(const Char_t *name, ULong64_t *address)             
{ return Link<ULong64_t>(name,address); }  

void GObject::UnLink(DataLink *link)
{
        // remove the link from the list of links to synchronize
        size_t i, i_to_remove = 0u, size = fDataLinks.size(); 
        Bool_t do_erase;
        
        do_erase = false; size = fDataLinks.size();
        for (i = 0; i < size; i++) 
                if ( fDataLinks[i] == link ) 
                { i_to_remove = i; do_erase = true; break; }
        
        if ( do_erase ) 
                fDataLinks.erase(fDataLinks.begin()+i_to_remove);
        
        // now delete it !
        size = fArrayOfItems.size();
        for (i = 0; i < size; i++) 
                if ( fArrayOfItems[i].second.second == link ){ 
                        delete fArrayOfItems[i].second.second; 
                        fArrayOfItems[i].second.second = 0x0; 
                        break; 
                }
        // now delete it !
        size = fArrayOfIdleItems.size();
        for (i = 0; i < size; i++) 
                if ( fArrayOfIdleItems[i].second.second == link ){ 
                        delete fArrayOfIdleItems[i].second.second; 
                        fArrayOfIdleItems[i].second.second = 0x0; 
                        break; 
                }       
}
void GObject::TransferLinkAndProxy(GObject &to) 
{
        UInt_t i; GObject::FullItem *item_from, *item_to;
        
        // loop on items from the from object
        for (i = 0u; i < fArrayOfItems.size(); i++) {
                
                // get the next full item in the from object list
                item_from = &fArrayOfItems[i];
                
                // this item is also is the destination object, so move proxy and link if any
                if ( (item_to = to.IsAnItem(item_from->first)) ) {
                        if ( item_from->second.first )  { // this item has a proxy
                                // copy the proxy in the destination object and change the true value 
                                item_to->second.first = item_from->second.first;
                                AProxyNamedItem *prox = 
                                dynamic_cast<AProxyNamedItem *>(item_to->second.first);
                                prox->SetProxy(item_to->first);
                                
                                // remove the proxy from the source 
                                item_from->second.first = 0x0;
                        }       
                        if ( item_from->second.second ) { // this item is linked
                                // create a link in the destination object and add it to the list of links
                                item_to->second.second =
                                item_to->first->MakeADataLink(item_from->second.second->A2()) ;
                                to.fDataLinks.push_back(item_to->second.second);
                                
                                // unlink properly this one from the source
                                UnLink( item_from->second.second ); 
                        }
                }
                // this item is not in the destination object
                // add a clone, with proxy and link if any, in the fArrayOfIdleItems
                else {
                        FullItem p;
                        p.first = item_from->first->MakeAClone();
                        
                        // if a proxy, set it 
                        if ( item_from->second.first ) {
                                // copy the proxy in the destination object and change the true value 
                                p.second.first = item_from->second.first;
                                AProxyNamedItem *prox = 
                                dynamic_cast<AProxyNamedItem *>(p.second.first);
                                prox->SetProxy(p.first);
                                
                                // remove the proxy from the source 
                                item_from->second.first = 0x0;
                        }
                        else p.second.first = 0x0;      
                        
                        if ( item_from->second.second ) { // this item is linked
                                // create a link in the destination object and add it to the list of links
                                p.second.second =
                                p.first->MakeADataLink(item_from->second.second->A2()) ;
                                
                                // unlink this one
                                UnLink( item_from->second.second ); 
                        } 
                        else p.second.second = 0x0;     
                        
                        to.fArrayOfIdleItems.push_back ( p );
                }
        }
        // loop on passed items from the from object
        for (i = 0u; i < fArrayOfIdleItems.size(); i++) {
                
                // get the next full item in the from object list
                GObject::FullItem *item_from = &fArrayOfIdleItems[i];
                
                // this item is also is the destination object, so move proxy and link if any
                if ( (item_to = to.IsAnItem(item_from->first)) ) {
                        if ( item_from->second.first )  { // this item has a proxy
                                // copy the proxy in the destination object and change the true value 
                                item_to->second.first = item_from->second.first;
                                AProxyNamedItem *prox = 
                                dynamic_cast<AProxyNamedItem *>(item_to->second.first);
                                prox->SetProxy(item_to->first);
                                
                                // remove the proxy from the source 
                                item_from->second.first = 0x0;
                        }       
                        if ( item_from->second.second ) { // this item is linked
                                // create a link in the destination object and add it to the list of links
                                item_to->second.second =
                                item_to->first->MakeADataLink(item_from->second.second->A2()) ;
                                to.fDataLinks.push_back(item_to->second.second);
                                
                                // unlink properly this one from the source
                                UnLink( item_from->second.second ); 
                        }
                }
                // this item is not in the destination object
                // add a clone, with proxy and link if any, in the fArrayOfIdleItems
                else {
                        FullItem p;
                        p.first = item_from->first->MakeAClone();
                        
                        // if a proxy, set it 
                        if ( item_from->second.first ) {
                                // copy the proxy in the destination object and change the true value 
                                p.second.first = item_from->second.first;
                                AProxyNamedItem *prox = 
                                dynamic_cast<AProxyNamedItem *>(p.second.first);
                                prox->SetProxy(p.first);
                                
                                // remove the proxy from the source 
                                item_from->second.first = 0x0;
                        }
                        else p.second.first = 0x0;      
                        
                        if ( item_from->second.second ) { // this item is linked
                                // create a link in the destination object and add it to the list of links
                                p.second.second =
                                p.first->MakeADataLink(item_from->second.second->A2()) ;
                                
                                // unlink this one
                                UnLink( item_from->second.second ); 
                        } 
                        else p.second.second = 0x0;     
                        
                        to.fArrayOfIdleItems.push_back ( p );
                }
        }       
}
void GObject::Print(std::ostream &out) const 
{
        for (UInt_t i = 0u; i < fArrayOfItems.size(); i++) {
                
                out << "Item #" << i << " ";
                
                fArrayOfItems[i].first->Print(out);
                out << " ";
                
                if ( fArrayOfItems[i].second.first ) 
                        out << " [proxy]";
                if ( fArrayOfItems[i].second.second ) 
                        out << " [link]";
                
                out << std::endl;       
        }
        for (UInt_t i = 0u; i < fArrayOfIdleItems.size(); i++) {
                
                out << "IdleItem #" << i << " ";
                
                fArrayOfIdleItems[i].first->Print(out);
                out << " ";
                
                if ( fArrayOfIdleItems[i].second.first ) 
                        out << " [proxy]";
                if ( fArrayOfIdleItems[i].second.second ) 
                        out << " [link]";               
                
                out << std::endl;
        }
}
void GObject::SetItems()
{ 
        size_t i, size = fDataLinks.size(); 
        for (i = 0; i < size; i++) 
                fDataLinks[i]->CopyA2_to_A1(); 
}
void GObject::GetItems() const 
{ 
        size_t i, size = fDataLinks.size(); 
        for (i = 0; i < size; i++) 
                fDataLinks[i]->CopyA1_to_A2(); 
}    
void  GObject::Reset() 
{
        size_t i, size = fDataItems.size(); 
        for (i = 0; i < size; i++) 
                fDataItems[i]->Reset(); 
}         
void GObject::SetItems(BufferIO &buf) const
{
        // first read items 
        size_t i, size = fDataItems.size(); 
        for (i = 0; i < size; i++) 
                fDataItems[i]->SetItem(buf);    
}       
void GObject::GetItems(const BufferIO &buf)
{
        size_t i, size = fDataItems.size(); 
        for (i = 0; i < size; i++) 
                fDataItems[i]->GetItem(buf);    
}  


const char *ADF::NamedItemTypeOf(Anonymous /*s*/) 
{ return "Anonymous"; } 

std::ostream & ADF::operator << (std::ostream &buf, const ADF::Anonymous &a)
{
        buf << "[" << a.fRealSize << "]";
        
        return buf;
}
ADF::BufferIO & ADF::operator << (ADF::BufferIO &buf, const ADF::Anonymous &a)
{
        buf << a.fRealSize;
        if ( a.fRealSize > 0u )         
                buf.Import(a.fData,a.fRealSize) ;
        
        return buf;
}
const ADF::BufferIO & ADF::operator >> (const ADF::BufferIO &buf, ADF::Anonymous & a)
{
        buf >> a.fRealSize;
        if ( a.fRealSize > 0u ) 
                buf.Export(a.fData,a.fRealSize) ;
        
        return buf;
}

ADF::Anonymous ADF::Anonymous::operator = (const  ADF::Anonymous & a)
{
        a.fRealSize > kMaxSize ? fRealSize = kMaxSize : fRealSize = a.fRealSize ;
        
        if ( fRealSize )
                ::memcpy(fData,a.fData,fRealSize);
        return (*this);
}