#ifndef BINTABLERCT_HEADER
#define BINTABLERCT_HEADER 1
///////////////////////////////////////////////////////////////
//! file="amma/Statist/SparHist/RCBinTable.hh"
//! userlevel=Normal
//! author="Charles Galambos"
//! date="27/11/1996"
//! docentry="Statistics.Histograms"
//! rcsid="$Id: RCBinTable.hh,v 1.3 2000/02/16 14:09:52 ees1cg Exp $"
//! lib=SparHist

#include "amma/BinTable.hh"
#include "amma/BinIter.hh"
#include "amma/RCWrap.hh"
#include "amma/StdType.hh"

template<class IT,class DIT,class BT> class RCBinIterC;

/////////////////////////////////
//: Table of bins.
// Note: This only works for multi-dementional tables.
// use SparsHist1d for 1d histograms.
// SMALL OBJECT <p>
// Template paramiter.            Examples. <p>
//
// IT  - Index Type.              ( Vector2dC ) <p>
// DIT - Descritised index type.  ( Index2dC  ) <p>
// BT  - Bin Type.                (     x     ) <p>
// 

template<class IT,class DIT,class BT>
class RCBinTableC 
  : public RCWrapC<BinTableC<IT,DIT,BT> >
{
public:
  inline RCBinTableC(const IT &nBinSize)
    : RCWrapC<BinTableC<IT,DIT,BT> >(BinTableC<IT,DIT,BT>(nBinSize))
    {}
  //: Default constructor.
  
  inline BT &operator[](const IT &pnt)
    { return Data().Bin(pnt); }
  //: Access a bin.
  
  BT &Bin(const DIT &pnt) 
    { return Body().Bin(pnt); }
  //: Access a bin directly.
  
  void Empty(void) 
    { Body().Empty(); }
  //: Remove all items from table.
  
  const IT &BinSize(void) const 
    { return Body().GetBinSize(); }
  //: Get size of bins.
  
  DIT Scale(const IT &ind) const
    { return Body().Scale(ind); }
  //: Scale and descritise an input point.
  
  IT BinCentre(const IT &at) const
    { return Body().BinCentre(at); }
  //: Get centre of bin containing point at.
  
  friend class RCBinIterC<IT,DIT,BT>;
};

////////////////////////////
//! userlevel=Normal
//: Bin table iterator.

template<class IT,class DIT,class BT>
class RCBinIterC 
  : public RCWrapC<BinIterC<IT,DIT,BT> >
{
public:
  RCBinIterC(const RCBinTableC<IT,DIT,BT> &ntab)
    : RCWrapC<BinIterC<IT,DIT,BT> >(BinIterC<IT,DIT,BT>(ntab)),
      tab(ntab)
    {}
  //: Constructor.
  
  const RCBinIterC<IT,DIT,BT> &operator=(const RCBinTableC<IT,DIT,BT> &oth) 
    {
      (*this) = RCBinIterC<IT,DIT,BT>(oth); 
      return *this;
    }
  //: Assignment to another table.
  
  BooleanT First() 
    { return Body().First(); }
  //: Goto first item in table.
  
  BooleanT Next()
    { return Body().Next(); }
  //: Goto next iterm in table.
  // Once this returns false (or IsElm() is false) this 
  // should not be called again.
  
  BooleanT IsElm(void) const 
    { return Body().IsElm(); }
  //: Pointing to valid element ?

  const DIT &DKey() const 
    { Body().Data().Key(); }
  //: Access descrete key.
  
  const IT &Key() const 
    { Body().Data().Key() * tab.BinSize(); }
  //: Access key.
  
  const BT &Data() const 
    { return Body().Data().Data(); }
  //: Contant access to data.

  BT &Data() 
    { return Body().Data().Data(); }
  //: Access data.
  
protected:
  RCBinTableC<IT,DIT,BT> tab;  
};

#endif