FactoryItem.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_FactoryItem
#define ADF_FactoryItem

#ifndef ADF_ADFConfig
#include "ADFConfig.h"
#endif
#ifndef ADF_Version
#include "Version.h"
#endif

#include <string>
#include <iostream>

namespace ADF
{ 


class FactoryItem
{
private:
        std::string fWhichFactory;
        Short_t         fWhichFactoryVersion;
        std::string fWhichItem; 
        Version     fWhichVersion;
        
private:

        void *          fPtrFactory;
        

public:
        FactoryItem();  
        FactoryItem(const Char_t* factname,const Char_t *whichitem, Version itemversion);
        FactoryItem(const Char_t* factname, Short_t factversion, const Char_t *whichitem, Version itemversion);
        FactoryItem(const FactoryItem &);       
        virtual ~FactoryItem() 
                {;}     
                        
        const std::string &GetFactoryName() const 
                { return fWhichFactory; }
        const std::string &GetItemName() const 
                { return fWhichItem; }
        
        Short_t GetFactoryVersion() const 
                { return fWhichFactoryVersion; }
        void SetFactoryVersion(Short_t v)
                { fWhichFactoryVersion = v; }   
        
        Version GetVersion() const 
                { return fWhichVersion; }
        void SetVersion(const Version v)
                { fWhichVersion = v; }
        
        void *GetFactoryPtr() const 
                { return fPtrFactory; }
        void SetFactoryPtr(void *ptr)
                { fPtrFactory = ptr; }
                        
        void SetItem(const Char_t *whichfactory, const Char_t *whichitem, Version itemversion, Short_t factversion = -1, void *ptr = 0x0);
        void SetItem(const Char_t *whichfactory, Short_t factversion, const Char_t *whichitem, Version itemversion, void *ptr = 0x0);
        
        void SetFactoryName(const char *fname)  
                { fWhichFactory = fname; }
                
        void SetItemName(const char *iname)     
                { fWhichItem = iname; }
                        

        Bool_t operator == (const FactoryItem &) const;
        

        Bool_t IsAVersion(const FactoryItem &) const;
                
        void Print() const;
};

typedef Bool_t (*PF_FactoryItemChange)(const FactoryItem &, const FactoryItem &);

inline Bool_t ChangeOfVersion(const FactoryItem &item_from, const FactoryItem &item_to)
{ 
        return item_from.IsAVersion(item_to); 
}
        
inline Bool_t NoChange(const FactoryItem &item_from, const FactoryItem &item_to)
        { return item_from == item_to; }
        
inline Bool_t AllChange(const FactoryItem & /*item_from*/, const FactoryItem & /*item_to*/)
        { return true; }
                
} // namespace ADF

// operator ta read/write in a std stream
namespace std {
        std::ostream & operator << (std::ostream &  os, const ADF::FactoryItem &item) ;
        std::istream & operator >> (std::istream &  is, ADF::FactoryItem &item);
}

#endif