#ifndef VEGA_VFrameChannel
#define VEGA_VFrameChannel

//*-- Author :    Damir Buskulic   19/11/01

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// VFrameChannel                                                        //
//                                                                      //
// Frame data access engine                                             //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include "VFramesBuffer.h"
#include "FrameL.h"
#include "VVirtualFrameChannel.h"
#include "VVirtualFrameChannelPlayer.h"
#include "VMetaData.h"
#include "VNtuple.h"

class VFramesBuffer;

class VFrameChannel : public VVirtualFrameChannel
{
private :

   string                mInfoDBName;
   VMetaData*            mCurMetaData;
   VFramesBuffer*        mFramesBuffer;
   string                mCurFrFileName;
   FrFile*               mCurFrFile;
   string                mCurVectName;
   VVirtualFrameChannelPlayer* mPlayer;
   
public :
    
// Opening and building the frame channel and the associated frame info database

   VFrameChannel();
   VFrameChannel(char* infodb, Option_t* mode="READ", char* frameInfoBuild="");
   virtual ~VFrameChannel();

   virtual Bool_t        Connect(char* pathtoDB, Option_t* openopt = "READ");
// Disconnect() is defined in the virtual base class;
   virtual void          BuildInfoDB(char* nameDB, char* frameFiles, Option_t* opt);

// Methods related to player, viewer and processing of data in a loop
   VFramesBuffer* GetFramesBuffer() {return mFramesBuffer;}
   VVirtualFrameChannelPlayer* GetPlayer();
   Int_t            MakeSelector(const char *selector=0);
   Int_t            MakeClass(const char *classname=0, const char* cond="", Option_t *option="");
   const char*      GetProcessList();
   Double_t         GetProcessStart();
   Double_t         GetProcessLength();
   Double_t         GetProcessStep();
   void             SetProcessList(const char* list);
   void             SetProcessStart(Double_t start);
   void             SetProcessLength(Double_t length);
   void             SetProcessStep(Double_t step);
   Int_t            Process(const char *filename, const char* cond="",Option_t *option="");
   Int_t            Process(VSelector *selector, const char* cond="",Option_t *option="");
   Int_t            Process(const char *filename, double starttime, double length, const char* cond="",Option_t *option="");
   Int_t            Process(VSelector *selector, double starttime, double length, const char* cond="",Option_t *option="");
   Int_t            ProcessVect(const char *filename,const char* vectlist, const char* cond="",Option_t *option="");
   Int_t            ProcessVect(VSelector *selector,const char* vectlist, const char* cond="",Option_t *option="");
   Int_t            ProcessVect(const char *filename, double starttime, double length, const char* vectlist, const char* cond="",Option_t *option="");
   Int_t            ProcessVect(VSelector *selector, double starttime, double length,const char* vectlist, const char* cond="",Option_t *option="");
   void             StartViewer(int mode=0);
   double           GetViewerTime();

// Drawing and getting information about the metadatabase
   
   virtual void          DrawCondition(const char* selexp, const char* selection="", Option_t* option = "", Double_t start = 0, Double_t length = 0);
   virtual Double_t      GetStart();
   virtual Double_t      GetEnd();
   virtual void          Print(Option_t* opt="");
   
// Factory part. Creating objects exchanged by the database
   
   virtual VConditionSet* CreateConditionSet(const char* condfs, const char* selfs=0);

// Getting/set the current status of the database
           const char*   GetInfoDBName() {return mInfoDBName.c_str();}
   
// Get frames directly

   virtual FrameH*       GetFrameDirectB(VMetaData* meta, Option_t* opt="full");
   virtual FrameH*       GetFrameDirectB(char* vectname, VMetaData* meta, Option_t* opt="full");
   virtual FrameH*       GetFrame(Double_t time);
   virtual FrameH*       GetFrameR(Double_t time);
   virtual FrameH*       GetNextFrame(Double_t time, const char* selection);
   virtual FrameH*       GetNextFrame(Double_t time, VConditionSet* conds);
   virtual FrameH*       GetNextFrame(VConditionSet* condset);
   virtual FrameH*       GetNextFrameR(Double_t time, const char* selection);
   virtual FrameH*       GetNextFrameR(Double_t time, VConditionSet* conds=0);
           FrameH*       GetNextFrameB(Double_t time, VConditionSet* conds=0);
           FrameH*       GetNextFrameB(VConditionSet* condset);
           FrameH*       GetNextFrameB();

// Get vectors directly

   virtual FrVect*        GetVect(char* nameofvect, Double_t start, Double_t length, Option_t* opt="");
   virtual FrVect*        GetVectR(char* nameofvect, Double_t start, Double_t length, Option_t* opt="");
   virtual FrVect*        GetNextVect(char* nameofvect, Double_t gpstime, const char* selection, Option_t* opt="");
   virtual FrVect*        GetNextVectR(char* nameofvect, Double_t gpstime, const char* selection, Option_t* opt="");
   virtual VFrVectObject* GetSignal(char* nameofvect, Double_t start, Double_t length, Option_t* opt="");
   virtual VFrVectObject* GetSignalR(char* nameofvect, Double_t start, Double_t length, Option_t* opt="");
   virtual VFrVectObject* GetNextSignal(char* nameofvect, Double_t gpstime, const char* selection, Option_t* opt="");
   virtual VFrVectObject* GetNextSignalR(char* nameofvect, Double_t gpstime, const char* selection, Option_t* opt="");
           FrVect*        GetNextVectB(Double_t gpstime, char* vectname, VConditionSet* conds=0);
   virtual FrAdcData*     GetAdcDirectB(VMetaData* meta, char* vectname);
   virtual FrProcData*    GetProcDirectB(VMetaData* meta, char* vectname);
   virtual FrSimData*     GetSimDirectB(VMetaData* meta, char* vectname);
   
// Get frames sequentialy

   virtual FrameH*        GetNextFrame();
   virtual FrameH*        GetPreviousFrame();
           FrameH*        GetPreviousFrameB();

// Get vectors sequentialy

   virtual FrVect*        GetNextVect(char* nameofvect, VConditionSet* condset, Option_t* opt="");
   virtual VFrVectObject* GetNextSignal(char* nameofvect, VConditionSet* condset, Option_t* opt="");

// Get slow monitoring data
   
   virtual VNtuple*      ExtractSMS(char* ntname, char* listofnames, Double_t start, Double_t length);
   virtual VNtuple*      ExtractSMSR(char* ntname, char* listofnames, Double_t start, Double_t length);
   virtual FrVect*       ExtractSMSVect(char* name0, Double_t start, Double_t length);
   virtual FrVect*       ExtractSMSVectR(char* name0, Double_t start, Double_t length);
   
   ClassDef(VFrameChannel,0) // frame channel
};
#endif