GObject.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_GObject
#define ADF_GObject

#include "DataHandling.h"
#include "BaseBuffer.h"

#include <vector>
        
namespace ADF
{ 


class GObject
{ 
public: 
        typedef std::pair<ANamedItem *, std::pair<ANamedItem *,DataLink *> > FullItem;
                
private:
        std::vector <ANamedItem *> fDataItems;
        std::vector <DataLink *> fDataLinks;
private:
        void UnLink(DataLink *);
private:
        std::vector< FullItem > fArrayOfItems;
        std::vector< FullItem > fArrayOfIdleItems;
        
private:        
        FullItem *IsAnItem(const Char_t *, const Char_t *);
        FullItem *IsAnItem(const ANamedItem *);
        
        FullItem *IsAIdleItem(const Char_t *, const Char_t *);

public:   
        GObject();
        

        virtual ~GObject();
                

        virtual Bool_t AddItem(ANamedItem *item);
        
        template <typename Data_t> const NamedItem<Data_t> *Get(const char *name)
        { 
                static Data_t t; ANamedItem *proxy = 0x0; FullItem *fitem = 0x0;

                // ckeck if the asked item is an item for that object or not 
                fitem = IsAnItem(name,NamedItemTypeOf(t));  
                if ( fitem ) {
                        if ( fitem->second.first == 0x0 )    // not yet created
                                proxy = fitem->second.first = fitem->first->MakeAProxy();
                        else 
                                proxy = fitem->second.first; // already there
                }
                else { // add it on the list of passed items
                        // check is already in the proxy list
                        fitem = IsAIdleItem(name,NamedItemTypeOf(t));   
                        if ( fitem ) // item in the passed item collection
                                if ( fitem->second.first )
                                        proxy = fitem->second.first;
                                else
                                        proxy = fitem->second.first = fitem->first->MakeAProxy();
                         else { // create an item, its proxy and add it to the list of IdleItems
                         
                                FullItem p;
                                p.first         = new NamedItem<Data_t>(name);
                                p.second.first  = p.first->MakeAProxy(); 
                                p.second.second = 0x0; 
                                
                                fArrayOfIdleItems.push_back( p );
                                
                                proxy = p.second.first;
                        }       
                }
                if ( proxy ) 
                        return dynamic_cast< const NamedItem<Data_t> * >(proxy); 
                else
                        return 0x0;     
        }
        template <typename Data_t> Bool_t Link(const char *name, Data_t *external_address)
        { 
                Bool_t ok = false; FullItem *fitem = 0x0;
                
                // ckeck if the asked item is an item for that object or not 
                fitem = IsAnItem(name,NamedItemTypeOf(*external_address));  
                if ( fitem ) {
                        if ( fitem->second.second == 0x0 ) {   // not yet linked so can do it
                        
                                fitem->second.second = fitem->first->MakeADataLink(external_address);
                                fDataLinks.push_back(fitem->second.second);
                                
                                ok = true;
                        } /* else {;} NO, BECAUSE ONLY ONE LINK POSSIBLE ! */   
                }
                else { // add it on the list of passed items
                        // check is already in the passed list
                        fitem = IsAIdleItem(name,NamedItemTypeOf(*external_address));   
                        if ( fitem ) { //  already there
                                if ( fitem->second.second == 0x0 ) {   // not yet linked so can do it
                        
                                        fitem->second.second = fitem->first->MakeADataLink(external_address);
                                        fDataLinks.push_back(fitem->second.second);

                                } /* else {;} NO, BECAUSE ONLY ONE LINK POSSIBLE ! */
                        }
                        else { // create an item, its proxy and link add it to the list of IdleItems

                                FullItem p;
                                p.first         = new NamedItem<Data_t>(name);
                                p.second.first  = 0x0; 
                                p.second.second = p.first->MakeADataLink(external_address); 
                                
                                fArrayOfIdleItems.push_back( p );
                        }       
                }               
                return ok;
        }
        
        Bool_t LinkItem(const Char_t *, const Char_t *, void *);
//      Bool_t LinkItem(const Char_t *name, Bool_t *address);
        Bool_t LinkItem(const Char_t *name, Short_t *address);
        Bool_t LinkItem(const Char_t *name, UShort_t *address);
        Bool_t LinkItem(const Char_t *name, Int_t *address);
        Bool_t LinkItem(const Char_t *name, UInt_t *address);
        Bool_t LinkItem(const Char_t *name, Float_t *address);
        Bool_t LinkItem(const Char_t *name, Double_t *address);
        Bool_t LinkItem(const Char_t *name, Long64_t *address);      
        Bool_t LinkItem(const Char_t *name, ULong64_t *address);  

        virtual Bool_t IsFullyLinked() const
                { return fDataLinks.size() == fDataItems.size(); }    
                        
        virtual void SetItems(BufferIO &) const;        
        virtual void GetItems(const BufferIO &);
        
        virtual void SetItems();
        virtual void GetItems() const ;      
        
        virtual void  Reset();
        

        void TransferLinkAndProxy(GObject &to);
        
        virtual void Print(std::ostream &out = std::cout) const ;
};


class Anonymous
{
        static const UShort_t kMaxSize = 256u;
public: 
        UShort_t fRealSize;
        Char_t   fData[kMaxSize];
public:
        Anonymous(Char_t c = 0) { fRealSize = 0u; ::memset(fData,c,kMaxSize); }
        virtual ~Anonymous() 
                {;}
                
        template<typename Data_T> Data_T Get(UShort_t offset = 0u) const
        {       
                if ( (offset+sizeof(Data_T)) < kMaxSize ) 
                        return (*(Data_T*)(fData+offset));
                else 
                        return 0;
        }
        template<typename Data_T> void Set(const Data_T data, UShort_t offset = 0u)
        { 
                if ( (offset+sizeof(Data_T)) < kMaxSize ) 
                        *((Data_T*)(fData+offset)) = data;
        }               
        
        friend std::ostream & operator << (std::ostream &, const Anonymous & );
        friend BufferIO & operator << (BufferIO &, const Anonymous & );
        friend const BufferIO & operator >> (const BufferIO &, Anonymous &);

        Anonymous operator = (const Anonymous & a);
        
//      virtual void Print(std::ostream &out = std::cout) const {;}

};
        
std::ostream & operator << (std::ostream &, const Anonymous & );
BufferIO & operator << (BufferIO &, const Anonymous & );
const BufferIO & operator >> (const BufferIO &, Anonymous &);

const char *NamedItemTypeOf(Anonymous/*s*/);


class DataInterface 
{
private: 
        GObject fGObject;
protected:
        void ResetGlobal()
                 { fGObject.Reset(); }
public:
        DataInterface(): 
                fGObject() {;}
        virtual ~DataInterface() 
                {;}

        virtual GObject *Global()
                { return &fGObject; }
};

} // namespace ADF
#endif