#ifndef __CESQCOLL_HH
#define __CESQCOLL_HH (1)

#include "Edm/Id.hh"
#include "Edm/Link.hh"
#include "Edm/StorableObject.hh"
#include "Edm/Handle.hh"
#include "Edm/ConstHandle.hh"
#include "EdmUtilities/FixedSizeTypes.hh"
#include "PADSObjects/TRKQTypeDefs.hh"
#include "PADSObjects/TRKQBitMap.hh"
#include "TrackingObjects/Storable/CdfTrackColl.hh"

#ifndef   EDMUTILITIES_BITMASK_HH
#include "EdmUtilities/BitMask.hh"
#endif


class CESQColl;
typedef Handle<CESQColl> CESQColl_h;
typedef ConstHandle<CESQColl> CESQColl_ch;




class CESQColl: public StorableObject
{

public:

  virtual CESQColl* clone(void); // Pseudo-constructor

  CESQColl();
  virtual void destroy(void) ;          // Pseudo-destructor
  virtual void deallocate(void) ;       // For child class use
  virtual std::string class_name(void) const;
  virtual Version_t   class_version(void) const;
  virtual bool postread  (EventRecord* p_record) ;
  virtual bool prewrite  (EventRecord* p_record) ;
  virtual bool activate  (EventRecord* p_record) ;
  virtual bool deactivate(EventRecord* p_record) ;

  virtual void print(std::ostream& output = std::cout) const ;
  
  //--------------------------------------------------------------------------
  // Functions to retrieve the collection from the event
  //--------------------------------------------------------------------------
  
  enum Error
    {
      ERROR,
      OK
    };

  static Error find(CESQColl_ch & setHandle);
  static Error find(CESQColl_ch & setHandle,
		    const StorableObject::Selector & selector ); 
  


  void Fill(uint2 bufferSize, const uint2* chid, const uint2* energy);

  int numberChannels() const;
  const uint2* energy() const;
  const uint2* channelID() const;

  int module(uint2 chid) const;  
  int stripNo(uint2 chid) const;  
  int i_ew(uint2 chid) const;  
  int stripType(uint2 chid) const;  

  enum  { module_nbits     =                   5,
          module_mask  = BitMask::nbits05,
          module_shift =  0,
          module_loval =  0,
          module_hival =  module_mask
  } ;
  
  enum  { stripType_nbits =                     1,
          stripType_mask  = BitMask::nbits01,
          stripType_shift =  5,
          stripType_loval =  0,
          stripType_hival =  stripType_mask
  } ;
  
  enum  { stripNo_nbits =                     7,
          stripNo_mask  = BitMask::nbits07,
          stripNo_shift =  6,
          stripNo_loval =  0,
          stripNo_hival =  stripNo_mask
  } ;
 
  enum  { i_ew_nbits =                     1,
          i_ew_mask  = BitMask::nbits01,
          i_ew_shift =  13,
          i_ew_loval =  0,
          i_ew_hival =  i_ew_mask
  } ;



protected:
  
  //----------------------------------------------------------------
  // Destructor...
  //----------------------------------------------------------------

  virtual ~CESQColl();

private:


  //----------------------------------------------------------------
  // internal streamers to iobuffers...
  //----------------------------------------------------------------

  void writeToBuffer(TBuffer& iobuffer);
  void readFromBuffer(TBuffer& iobuffer);
  void initializeBuffers();

  //----------------------------------------------------------------
  // Data members
  //----------------------------------------------------------------
  
  uint2 _bufferSize;
  
  uint2 *_chid;
  uint2 *_energy;


  //----------------------------------------------------------------
  // Constructors..
  //----------------------------------------------------------------

  ClassDef(CESQColl,2)

};



inline int CESQColl::module(uint2 chid)  const { 
  return ((chid >> module_shift) & module_mask);
}

inline int CESQColl::stripType(uint2 chid)  const { 
  return ((chid >> stripType_shift) &  stripType_mask);
}

inline int CESQColl::i_ew(uint2 chid)  const {
  return ((chid >> i_ew_shift) &  i_ew_mask);
}

inline int CESQColl::stripNo(uint2 chid)  const { 
  return((chid >> stripNo_shift) &  stripNo_mask);
}



#endif