#ifndef TDBIVALIDITYREC_H
#define TDBIVALIDITYREC_H

/**
 *
 * $Id: IDbiValidityRec.hxx,v 1.1 2011/01/18 05:49:20 finch Exp $
 *
 * \class COMET::IDbiValidityRec
 *
 *
 * \brief
 * <b>Concept</b> A concrete data type corresponding to a single row in
 *  an  auxillary validity range database table.
 *
 * \brief
 * <b>Purpose</b> To resolve ambiguities in the case of multiple matches
 *   to a query and to record results of validity range trimming due to
 *   neighbouring database entries.
 *
 * Contact: A.Finch@lancaster.ac.uk
 *
 *
 */

#include "IDbi.hxx"
#include "IDbiTableRow.hxx"
#include "IVldRange.hxx"
#include "IVldTimeStamp.hxx"

#include <iosfwd>
#include <string>

namespace COMET {
class IDbiBinaryFile;
class IDbiTableProxy;
class IDbiValidityRec;
}

ostream& operator<<(ostream& s, const COMET::IDbiValidityRec& vRec);

namespace COMET {
class IDbiValidityRec : public IDbiTableRow
{


public:

// Constructors and destructors.
           IDbiValidityRec(Int_t dbNo = -1, Bool_t isGap = kTRUE);
           IDbiValidityRec(const IDbiValidityRec& from);
           IDbiValidityRec(const COMET::IVldRange& range,
                          IDbi::Task task,
                          Int_t aggNo,
                          UInt_t seqNo,
                          Int_t dbNo = -1,
                          Bool_t isGap = kFALSE,
                          COMET::IVldTimeStamp time = COMET::IVldTimeStamp(),
			  UInt_t epoch = 0);
  virtual ~IDbiValidityRec();

// State testing member functions

  virtual IDbiTableRow* CreateTableRow() const {
                                           return new IDbiValidityRec; }
        	 Int_t GetAggregateNo() const { return fAggregateNo; }
          COMET::IVldTimeStamp GetCreationDate() const { return fCreationDate; }
        	UInt_t GetDbNo() const { return fDbNo; }
        	UInt_t GetEpoch() const { return fEpoch; }
          COMET::IVldTimeStamp GetInsertDate() const { return fInsertDate; }
             IDbi::Task GetTask() const { return fTask; }
	   std::string GetL2CacheName() const;
        	UInt_t GetSeqNo() const { return fSeqNo; }
  const IDbiTableProxy* GetTableProxy() const { return fTableProxy; }
       const COMET::IVldRange& GetVldRange() const { return fVldRange;}
                Bool_t HasExpired(const IDbiValidityRec& other) const;
                Bool_t HasExpired(const COMET::IVldContext& vc,
                                  const IDbi::Task& task) const;
               Bool_t IsCompatible(const COMET::IVldContext& vc,
                                    const IDbi::Task& task) const;
                Bool_t IsGap() const { return fIsGap; }
                Bool_t IsHigherPriority(const IDbiValidityRec& that,
					Bool_t useCreationDate = false) const;

static     std::string GetL2CacheName(UInt_t seqLo, UInt_t seqHi, COMET::IVldTimeStamp ts);

// State changing member functions
        void AndTimeWindow(const COMET::IVldTimeStamp& start,
                           const COMET::IVldTimeStamp& end);
        void SetAggregateNo(Int_t aggNo) { fAggregateNo = aggNo; }
        void SetDbNo(Int_t dbNo) { fDbNo = dbNo; }
        void SetEpoch(UInt_t epoch) { fEpoch = epoch; }
        void SetTableProxy(const IDbiTableProxy* tp) { fTableProxy = tp; }
        void SetTimeWindow(const COMET::IVldTimeStamp& start,
                           const COMET::IVldTimeStamp& end);
        void SetVldRange(const COMET::IVldRange& range) { fVldRange=range;}
        void Trim(const COMET::IVldTimeStamp& queryTime,
                  const IDbiValidityRec& other);

// I/O  member functions
  virtual void Fill(IDbiInRowStream& rs,
                    const IDbiValidityRec* vrec);
  virtual void Store(IDbiOutRowStream& ors,
                    const IDbiValidityRec* vrec) const;
          void Streamer(IDbiBinaryFile& file);

private:

// Data members


/// Aggregate number or:-
///    -1 Non-aggregated data or multiple aggregates
///    -2 undefined aggregates
  Int_t fAggregateNo;

///  Creation date
  COMET::IVldTimeStamp fCreationDate;

/// Cascade no. of source db =-1 unknown
  Int_t fDbNo;

///  Insertion date
  COMET::IVldTimeStamp fInsertDate;

///  kTRUE if corresponds to a gap.
    Bool_t fIsGap;

/// Task number
  IDbi::Task fTask;

/// Sequence number or 0 if compound.
  Int_t fSeqNo;


/// IDbiTableProxy that filled this (if any).
  const IDbiTableProxy* fTableProxy;

/// Validity range of record.
  COMET::IVldRange fVldRange;

/// Calibration Epoch
  UInt_t fEpoch;

/// Reality (for possible, but improbable future use)
  UInt_t fReality;

ClassDef(IDbiValidityRec,0)  // Validity range table row.

};
};


#endif  // TDBIVALIDITYREC_H