ISStreamerWrapper.h

#ifndef SCT_ISSTREAMERWRAPPER_H
#define SCT_ISSTREAMERWRAPPER_H
#include "Streamer.h"
#include "LogicErrors.h"
#include "IoExceptions.h"
#include "ISOStreamWrapper.h"
#include "ISIStreamWrapper.h"
#include "ISSerializableWrapper.h"
#include "is/isinfo.h"

namespace Sct{
class OStream;
class IStream;
class Streamable;
class IOManager;
template<class T>
class ISStreamerWrapper : public virtual Streamer {
 public:
  virtual void write(OStream& out, const Streamable& ob, const IOManager& manager) const;

  virtual shared_ptr<Streamable> read(IStream& in, const IOManager& manager) const;

  virtual void read(IStream& in, Streamable& ob, const IOManager& manager) const;

  ISStreamerWrapper() {; }

  virtual unsigned getVersion() const throw();
 protected:
  class InnerClass : public ISInfo {
  public:
    InnerClass(ISInfo& ob) : m_ob(ob) {}
    virtual void publishGuts( ISostream & out ) {m_ob.publishGuts(out);}
    virtual void refreshGuts( ISistream & in ) {m_ob.refreshGuts(in);}
  private:
    InnerClass();
    ISInfo& m_ob;
  };
};


template<class T>
inline unsigned ISStreamerWrapper<T>::getVersion() const throw() {
  T t;
  return t.version;
}

template<class T>
inline void ISStreamerWrapper<T>::write(OStream& out, const Streamable& ob, const IOManager& manager) const {
  // wrap the stream
  //#warning probable slow memory leak forced by using Sct/isstream_bugfix.h
  ISOStreamWrapper isosw(out);

  // cast the Streamable as a ISSerializableWrapper
  const ISSerializableWrapper<T>& wrapper = 
    dynamic_cast <const ISSerializableWrapper<T>&> ( ob );

  // use the inner class to make the publishGuts method public:
  InnerClass inner( const_cast<T&> ( *wrapper.getWrappedObject()) );

  // use the publishGuts method to stream.
  inner.publishGuts(isosw);
}

template<class T> 
 inline void ISStreamerWrapper<T>::read(IStream& in, Sct::Streamable& ob, const IOManager& manager) const{
    // cast the Streamable as a ISSerializableWrapper
  const ISSerializableWrapper<T>& wrapper = 
    dynamic_cast <const ISSerializableWrapper<T>&> ( ob );

   // make an InnerClass to make the refreshGuts public:
  InnerClass inner( const_cast<T&> (*wrapper.getWrappedObject()) );

  //#warning forced slow memory leak below. The ISIStreamWrapper destructor has problems because we have kludged the ISistream in file isstream_bugfix.h
   // convert the stream
  ISIStreamWrapper isisw(in);
  
   // use the refreshGuts to update.
  inner.refreshGuts(isisw);
  wrapper.constructUniqueID();
 }

template<class T>
inline shared_ptr<Streamable> ISStreamerWrapper<T>::read(IStream& in, const IOManager& manager) const {
  // wrap it as a serializable
  shared_ptr<ISSerializableWrapper<T> > ob = shared_ptr<ISSerializableWrapper<T> >( new ISSerializableWrapper<T>() ) ;
  read(in, *ob, manager);
  return ob;
}

}

#endif //SCT_ISSTREAMERWRAPPER_H

---