////////////////////////////////////////////////////////////////////////
///
/// $Id: IDbiRegistryItemXxx.hxx,v 1.1 2011/01/18 05:49:20 finch Exp $
///
/// \class  COMET::IDbiRegistryItemXxx<T>
///
/// \brief Encapsulates a value of type T (really!).
///
/// Contact: A.Finch@lancaster.ac.uk  bv@bnl.gov
///
///Created on: Wed Oct 25 17:11:44 2000
///
////////////////////////////////////////////////////////////////////////

#ifndef TDBIREGISTRYITEMXXX_H
#define TDBIREGISTRYITEMXXX_H

#include <TBuffer.h>
#include <TObject.h>

#include <IDbiRegistryItem.hxx>

#include <typeinfo>
#include <iostream>
namespace COMET {
/// Encapsulates a value of type T
class IDbiRegistry;
template<class T> class IDbiRegistryItemXxx : public COMET::IDbiRegistryItem
{
public:
    // Only Want IDbiRegistry to call Get/Set/etc methods
    friend class IDbiRegistry;

    IDbiRegistryItemXxx();
    ~IDbiRegistryItemXxx();

    void Dump() const { std::cerr << *fData; }
    void Print(Option_t* /* option */ ="") const { std::cout << *fData; }

    virtual std::ostream& PrintStream(std::ostream& os) const { 
        return os << *fData; 
    }
    virtual std::istream& ReadStream(std::istream& is) {
        if (!fData) fData = new T;
        return is >> *fData;
    }

    virtual const std::type_info& GetType() const { return typeid(T); }
    virtual const char* GetTypeAsString() const { return "void"; }

private:

    IDbiRegistryItemXxx(T* data);
    T* Get(void);               // Only let IDbiRegistry call 
    void Set(T* data);          // these methods.
    IDbiRegistryItem* Dup(void) const;

    T* fData;

    ClassDefT(IDbiRegistryItemXxx<T>,1)
};
ClassDefT2(COMET::IDbiRegistryItemXxx,T)
}


// Provide these so C++ base types act like ROOT types inside 
// a ROOT Streamer function.  This lets the same template to be used.
TBuffer& operator>>(TBuffer &buf, int*& xptr);
TBuffer& operator>>(TBuffer &buf, double*& xptr);
TBuffer& operator>>(TBuffer &buf, float*& xptr);
//TBuffer& operator>>(TBuffer &buf, bool*& xptr);

TBuffer& operator<<(TBuffer &buf, int*& xptr);
TBuffer& operator<<(TBuffer &buf, double*& xptr);
TBuffer& operator<<(TBuffer &buf, float*& xptr);
//TBuffer& operator<<(TBuffer &buf, bool*& xptr);

//TBuffer& operator<<(TBuffer &buf, char*& xptr);

#ifndef __CINT__

#include <iostream>

ClassImpT(IDbiRegistryItemXxx,T)

namespace COMET 
{  
template<class T>
IDbiRegistryItemXxx<T>::IDbiRegistryItemXxx(void) : fData(0) 
{ 
}

template<class T>
IDbiRegistryItemXxx<T>::IDbiRegistryItemXxx(T* data) : fData(data) 
{ 
}

template<class T>
IDbiRegistryItemXxx<T>::~IDbiRegistryItemXxx() 
{ 
    if (fData) delete fData; 
}

template<class T>
IDbiRegistryItem* IDbiRegistryItemXxx<T>::Dup(void) const
{
    return new IDbiRegistryItemXxx<T>(new T (*fData));
}
// see IDbiRegistryItemXxx.cxx for implementation
template<>
IDbiRegistryItem* IDbiRegistryItemXxx<const char*>::Dup(void) const;


template<class T>
T* IDbiRegistryItemXxx<T>::Get(void)
{
    return fData; 
}

template<class T>
void IDbiRegistryItemXxx<T>::Set(T* data) 
{
    if (fData) delete fData;
    fData = data; 
}


// These specialized templates are in IDbiRegistryItemXxx.cxx
// 
template<>
void IDbiRegistryItemXxx<const char*>::Streamer(TBuffer &buf);
template<>
void IDbiRegistryItemXxx<char>::Streamer(TBuffer &buf);
template<>
IDbiRegistryItemXxx<const char*>::~IDbiRegistryItemXxx();

template<> std::ostream& IDbiRegistryItemXxx<const char*>::PrintStream(std::ostream& os) const;
template<> std::istream& IDbiRegistryItemXxx<const char*>::ReadStream(std::istream& is);
template<> const char* IDbiRegistryItemXxx<char>::GetTypeAsString(void) const;
template<> const char* IDbiRegistryItemXxx<int>::GetTypeAsString(void) const;
template<> const char* IDbiRegistryItemXxx<double>::GetTypeAsString(void) const;
template<> const char* IDbiRegistryItemXxx<const char*>::GetTypeAsString(void) const;
template<> const char* IDbiRegistryItemXxx<IDbiRegistry>::GetTypeAsString(void) const;

}
// Only for less than GCC 3.3 - see bug 3797:
// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=3797
#if (__GNUC__ == 3 && __GNUC_MINOR__ < 3) || __GNUC__ == 2

#include <IDbiRegistry.hxx>

template<> const char* IDbiRegistryItemXxx<char>::GetTypeAsString(void) const
{ return "char"; }

template<> const char* IDbiRegistryItemXxx<int>::GetTypeAsString(void) const
{ return "int"; }

template<> const char* IDbiRegistryItemXxx<double>::GetTypeAsString(void) const
{ return "double"; }

template<> const char* IDbiRegistryItemXxx<const char*>::GetTypeAsString(void) const
{ return "string"; }

template<> const char* IDbiRegistryItemXxx<IDbiRegistry>::GetTypeAsString(void) const
{ return "IDbiRegistry"; }

template<> std::ostream& IDbiRegistryItemXxx<IDbiRegistry>::PrintStream(std::ostream& os) const
{ return fData->PrintStream(os); }

template<> std::istream& IDbiRegistryItemXxx<IDbiRegistry>::ReadStream(std::istream& is)
{ if (!fData) fData = new IDbiRegistry(); return fData->ReadStream(is); }
#endif

// This assumes that objects spring forth (like ROOT objects)
namespace COMET
{ 
template<class T>
void IDbiRegistryItemXxx<T>::Streamer(TBuffer &buf)
{
    if (buf.IsReading()) {
        Version_t v = buf.ReadVersion(); 
        if (v) { }
        COMET::IDbiRegistryItem::Streamer(buf);

        buf >> fData;
    } 
    else {
        buf.WriteVersion(IsA());
        COMET::IDbiRegistryItem::Streamer(buf);
        buf << fData;
    }
}
}


#include <IDbiRegistry.hxx>
namespace COMET 
{ 

template<>
std::ostream& IDbiRegistryItemXxx<COMET::IDbiRegistry>::PrintStream(std::ostream& os) const;

template<>
std::istream& IDbiRegistryItemXxx<COMET::IDbiRegistry>::ReadStream(std::istream& is);
} 

#endif // __CINT__


#endif  // TDBIREGISTRYITEMXXX_H