seqtree.h

/***************************************************************************
                          seqtree.h  -  description
                             -------------------
    begin                : Fri Oct 17 2003
    copyright            : (C) 2001 by Thies H. Jochimsen
    email                : jochimse@cns.mpg.de
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/



#ifndef SEQTREE_H
#define SEQTREE_H

#include <tjutils/tjvallist.h>

#include <odinseq/seqclass.h>
#include <odinseq/seqoperator.h>





class SeqTreeCallbackAbstract {

 public:
  virtual void display_node(const SeqClass* thisnode, const SeqClass* parentnode, int treelevel, const svector& columntext) = 0;

};


class ProgressMeter; // forward declaration

enum eventAction {seqRun=0, printEvent, countEvents};

struct eventContext {
  eventContext() : action(seqRun), noflush(false), seqcheck(false),
                   elapsed(0.0),
                   event_display(0), event_progmeter(0) {}

  // the action to be performed
  eventAction action;

  // do not flush eventblock
  bool noflush;

  // just a test run (e.g. fSEQCheck on Idea)
  bool seqcheck;

  // counter for time elapsed since start of the sequence
  double elapsed;

  // callback pointers to display events in GUI/console
  SeqTreeCallbackAbstract* event_display;

  // pointer for progess meter
  ProgressMeter* event_progmeter;
};


enum freqlistAction {calcDeps=0,calcList,calcAcqList,calcDecList};


enum programMode {brukerPpg=0, brukerGpg, brukerParx, epicCode, epicPg, epicScan, epicPreScan, epicPreScanDummy, numOfProgModes};


struct programContext {
  programContext() : mode(programMode(0)), formatted(true), nestlevel(0), neststatus(false)  {}

  // the type of program to generate
  programMode mode;

  // whether code is nicely formatted (indention, comments), the main
  // use of this flag is to decide whether to blocks of code are the
  // same (despite formatting) and whether they can be wrapped in a loop
  bool formatted;

  // counter for indention if generating pulse programs
  int nestlevel;

  // whether indention is currently enabled
  bool neststatus;
};



class SeqTreeObj; //forward declaration

enum queryAction {count_acqs, checkoccur, check_acq_iter, tag_toplevel_reploop, display_tree};

struct queryContext {
  queryContext() : action(count_acqs), numof_acqs(0),
  checkoccur_sto(0), checkoccur_result(false),
  check_acq_iter_result(false),
  tree_display(0), parentnode(0), treelevel(0),
  repetitions_prot(0) {}

  // the action requested
  queryAction action;

  // stuff for action 'count_acqs'
  unsigned int numof_acqs;

  // stuff for action 'checkoccur'
  const SeqTreeObj* checkoccur_sto;
  bool checkoccur_result;

  bool check_acq_iter_result;
  
  // stuff for action 'display_tree'
  SeqTreeCallbackAbstract* tree_display;
  const SeqTreeObj* parentnode;
  int treelevel;

  // stuff for action 'tag_toplevel_reploop'
  int repetitions_prot; // the number of reps in the protocol
};



struct SeqValList : public ValList<double> {
  SeqValList(const STD_string& object_label="unnamedSeqValList", unsigned int repetitions=1) : ValList<double>(object_label,repetitions) {}
};




class SeqTreeObj : public virtual SeqClass {

 public:

  virtual double get_duration() const = 0;

  virtual STD_string get_program(programContext& context) const {return "";}

  virtual STD_string get_properties() const {return "";}


  virtual unsigned int event(eventContext& context) const { // make inline to speed up event execution
    if(context.action==printEvent) display_event(context);
    context.elapsed+=get_duration();
    return 0; // no real hardware events played out
  }


  virtual RecoValList get_recovallist(unsigned int reptimes, JDXkSpaceCoords& coords) const {return RecoValList();}

  bool contains(const SeqTreeObj* sto) const;

  void tree(SeqTreeCallbackAbstract* display) const;

  virtual SeqValList get_freqvallist(freqlistAction action) const {return SeqValList();}

  virtual SeqValList get_delayvallist() const {return SeqValList();}

  virtual double get_rf_energy() const {return 0.0;}


 protected:
  friend class SeqObjList;
  friend class SeqObjVector;
  friend class SeqParallel;



  SeqTreeObj();

  virtual ~SeqTreeObj() {}

  SeqTreeObj& operator = (const SeqTreeObj& sto) {
    SeqClass::operator =(sto);
    return *this;
  }

  virtual void query(queryContext& context) const;


  static int looplevel;

 private:
  void display_event(eventContext& context) const;

};



#endif