#ifndef DPIOTAP_HEADER
#define DPIOTAP_HEADER 1
///////////////////////////////////////////////////
//! docentry="Data Processing" 
//! rcsid="$Id: IOTap.hh,v 1.8 1999/09/16 13:30:19 ees1cg Exp $"
//! file="amma/StdType/DataProc/IOTap.hh"
//! lib=DataProc
//! author="Charles Galambos"
//! date="20/07/98"

#include "amma/DP/Port.hh"
#include "amma/Tuple2.hh"
#include <assert.h>

////////////////////////////////////
//! userlevel=Develop
//: Tap body

template<class InT,class OutT>
class DPIOTapBodyC : public DPIOPortBodyC<InT,OutT>
{
public:
  DPIOTapBodyC(const DPIOPortC<InT,OutT> &target,const DPOPortC<Tuple2C<OutT,InT> > &ntap);
  //: Constructor.
  
  DPIOTapBodyC(const DPIOTapBodyC<InT,OutT> &oth);
  //: Copy Constructor.
  
  DPIOTapBodyC();
  //: Default Constructor.
  
  DPIOTapBodyC(istream &in);
  //: Stream constructor.
  
  virtual void PutEOS();
  //: Put End Of Stream marker.
  
  virtual BooleanT Put(const OutT &);
  //: Put data.

  virtual BooleanT IsPutReady() const;
  //: Is port ready for data ?
  
  virtual InT Get();
  //: Get next piece of data.
  // May block if not ready, or it will return a constructed
  // with the default constructor.
  
  virtual BooleanT Get(InT &buff);
  //: Try and get next piece of data.
  // This will NOT block, if no data is ready
  // it will return FALSE, and not set buff.
  
  virtual BooleanT IsGetReady() const;
  //: Is some data ready ?
  // TRUE = yes.
  
  virtual BooleanT Save(ostream &out) const;
  //: Save to ostream.
  
  inline DPOPortC<Tuple2C<OutT,InT> > &Tap();
  //: Access to tap.
  
  inline DPIOPortC<InT,OutT> &Target();
  //: Access the object being tapped.
  
protected:
  DPOPortC<Tuple2C<OutT,InT> > tap;
  DPIOPortC<InT,OutT> target;
  Tuple2C<OutT,InT> tapout;
  BooleanT donePut;
};

///////////////////////////////////////
//! userlevel=Normal
//: Tap handle.

template<class InT,class OutT>
class DPIOTapC : public DPIOPortC<InT,OutT>
{
public:
  DPIOTapC(const DPIOPortC<InT,OutT> &target,
	   const DPOPortC<Tuple2C<OutT,InT> > &ntap);
  //: Constructor.
  //= DPOPortC<Tuple2C<OutT,InT> > ()
  
  DPIOTapC(const DPIOTapC<InT,OutT> &oth);
  //: Copy Constructor.
  
  DPIOTapC();
  //: Default Constructor.
  
  DPIOTapC(istream &in);
  //: Stream constructor.
  
  inline DPOPortC<Tuple2C<OutT,InT> > &Tap();
  //: Access to tap.
  
  inline DPIOPortC<InT,OutT> &Target();
  //: Access the object being tapped.
  
  inline DPIOPortC<InT,OutT> &IOPort() { return *this; }
  //: Simlified cast.
  
protected:
  DPIOTapBodyC<InT,OutT> &Body()
    { return dynamic_cast<DPIOTapBodyC<InT,OutT> &>(DPEntityC::Body()); }

  const DPIOTapBodyC<InT,OutT> &Body() const
    { return dynamic_cast<const DPIOTapBodyC<InT,OutT> &>(DPEntityC::Body()); }
};


///////////////////////////////

template<class InT,class OutT>
DPIOTapBodyC<InT,OutT>::DPIOTapBodyC(const DPIOPortC<InT,OutT> &ntarget,
				     const DPOPortC<Tuple2C<OutT,InT> > &ntap) 
  : tap(ntap),
    target(ntarget)
{ assert(target.IsValid()); }

template<class InT,class OutT>
DPIOTapBodyC<InT,OutT>::DPIOTapBodyC()
{}

template<class InT,class OutT>
DPIOTapBodyC<InT,OutT>::DPIOTapBodyC(const DPIOTapBodyC<InT,OutT> &oth)
  : tap(oth.tap),
    target(oth.target)
{}

template<class InT,class OutT>
DPIOTapBodyC<InT,OutT>::DPIOTapBodyC(istream &in)
  : tap(in),
    target(in)
{}

template<class InT,class OutT>
void DPIOTapBodyC<InT,OutT>::PutEOS()
{ 
  target.PutEOS(); 
  tap.PutEOS();
}

template<class InT,class OutT>
BooleanT DPIOTapBodyC<InT,OutT>::Put(const OutT &dat)
{
  assert(target.IsValid());
  if(donePut == TRUE) {
    tapout.Data2() = InT();
    tap.Put(tapout);
  }
  tapout.Data1() = dat;
  donePut = TRUE;
  return target.Put(dat); 
}

template<class InT,class OutT>
BooleanT DPIOTapBodyC<InT,OutT>::IsPutReady() const
{ 
  assert(target.IsValid());
  return target.IsPutReady(); 
}

template<class InT,class OutT>
InT DPIOTapBodyC<InT,OutT>::Get()
{ 
  assert(target.IsValid());
  tapout.Data2() = target.Get();
  if(!donePut)
    tapout.Data1() = OutT();
  tap.Put(tapout);
  donePut=FALSE;
  return tapout.Data2(); 
}

template<class InT,class OutT>
BooleanT DPIOTapBodyC<InT,OutT>::Get(InT &buff)
{ 
  assert(target.IsValid());
  BooleanT ret = target.Get(buff); 
  if(ret) {
    tapout.Data2() = buff;
    if(!donePut)
      tapout.Data1() = OutT();
    tap.Put(tapout);
    donePut=FALSE;
  }
  return ret;
}

template<class InT,class OutT>
BooleanT DPIOTapBodyC<InT,OutT>::IsGetReady() const
{ return target.IsGetReady(); }

template<class InT,class OutT>
BooleanT DPIOTapBodyC<InT,OutT>::Save(ostream &out) const
{
  if(!DPIOPortBodyC<InT,OutT>::Save(out))
    return FALSE;
  if(!tap.Save(out))
    return FALSE;
  if(!target.Save(out))
    return FALSE;
  return TRUE;
}

template<class InT,class OutT>
inline 
DPOPortC<Tuple2C<OutT,InT> > &
DPIOTapBodyC<InT,OutT>::Tap() 
{ return tap; }

template<class InT,class OutT>
inline 
DPIOPortC<InT,OutT> &
DPIOTapBodyC<InT,OutT>::Target()
{ return target; }

///////////////////////////////////////////////////////////

template<class InT,class OutT>
DPIOTapC<InT,OutT>::DPIOTapC(const DPIOPortC<InT,OutT> &ntarget,
			     const DPOPortC<Tuple2C<OutT,InT> > &ntap)
  : DPEntityC(*new DPIOTapBodyC<InT,OutT> (ntarget,ntap))
{}

template<class InT,class OutT>
DPIOTapC<InT,OutT>::DPIOTapC()
  : DPEntityC(*new DPIOTapBodyC<InT,OutT> ())
{}

template<class InT,class OutT>
DPIOTapC<InT,OutT>::DPIOTapC(const DPIOTapC<InT,OutT> &oth)
  : DPEntityC(oth)
{}

template<class InT,class OutT>
DPIOTapC<InT,OutT>::DPIOTapC(istream &in) 
  : DPEntityC(in)
{}

template<class InT,class OutT>
inline 
DPOPortC<Tuple2C<OutT,InT> > &
DPIOTapC<InT,OutT>::Tap()
{ return Body().Tap(); }


template<class InT,class OutT>
inline 
DPIOPortC<InT,OutT> &
DPIOTapC<InT,OutT>::Target()
{ return Body().Target(); }

#endif