seqvec.h

/***************************************************************************
                          seqvec.h  -  description
                             -------------------
    begin                : Mon Aug 19 2002
    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 SEQVEC_H
#define SEQVEC_H

#include <odinseq/seqclass.h>

class SeqCounter; // forward declaration
class SeqReorderVector; // forward declaration


enum encodingScheme {linearEncoding=0, reverseEncoding, centerOutEncoding, centerInEncoding, maxDistEncoding};


enum reorderScheme {noReorder=0,rotateReorder,blockedSegmented,interleavedSegmented};



enum nestingRelation {noRelation=0, reorderInner, vecInner, unrolledLoop};


class SeqVector : public ListItem<SeqVector>, public Handled<const SeqVector*>, public virtual SeqClass {

 public:

  SeqVector(const STD_string& object_label="unnamedSeqVector");

  SeqVector(const STD_string& object_label, unsigned int nindices, int slope=1, int offset=0 );

  SeqVector(const SeqVector& sv);

  virtual ~SeqVector();

  SeqVector& operator = (const SeqVector& sv);


  virtual unsigned int get_vectorsize() const {return indexvec.size();}


  virtual unsigned int get_numof_iterations() const;


  virtual bool needs_unrolling_check() const {return false;}


  virtual bool prep_iteration() const {return true;}


  virtual int get_current_index() const;

  int get_acq_index() const;

  virtual bool is_qualvector() const;

  virtual bool is_acq_vector() const;

  virtual bool is_obj_vector() const {return false;}


  virtual svector get_vector_commands(const STD_string& iterator) const {return svector();}


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


  SeqVector& set_indexvec(const ivector& iv) {indexvec=iv; return *this;}

  ivector get_indexvec() const {return indexvec;}


  SeqVector& set_reorder_scheme(reorderScheme scheme, unsigned int nsegments=1);

  SeqVector& set_encoding_scheme(encodingScheme scheme);


  const SeqVector& get_reorder_vector() const;


  virtual nestingRelation get_nesting_relation() const;


  iarray get_index_matrix() const;

  int get_current_reord_index() const;

  STD_string get_reord_iterator(const STD_string& iterator) const;


 protected:

  virtual svector get_reord_vector_commands(const STD_string& iterator) const {return svector();}

  bool is_handled() const {return vechandler.get_handled();}

 private:
  friend class SeqReorderVector;
  friend class SeqCounter;
  friend class SeqObjLoop;
  friend class SeqSimultanVector;

#ifdef SELF_FRIEND_CLASS
  friend class SeqVector; // making the class itself a friend is required for MSVC6 !!
#endif

  bool loopcounter_is_active() const;

  int get_loopcounter() const;


  void common_int();


  virtual const SeqVector& set_vechandler(const SeqCounter *sc) const;

  ivector indexvec;

  Handler<const SeqCounter*> vechandler;
  Handler<const SeqVector*>  simhandler;

  mutable SeqReorderVector* reordvec;

  mutable nestingRelation nr_cache;
  mutable bool nr_cache_up2date;
};




class SeqReorderVector : public SeqVector {

 public:
  SeqReorderVector(const SeqVector* user, const SeqReorderVector* copy_templ=0);

  unsigned int get_reordered_size(unsigned int vecsize) const;

  int get_reordered_index(int counter) const {return get_reordered_index(counter,get_current_index());}

  
 private:
  friend class SeqVector;
 
  // implemented virtual functions of SeqVector
  unsigned int get_vectorsize() const;
  bool needs_unrolling_check() const {return reord_scheme!=noReorder;}
  bool prep_iteration() const {return reorder_user->prep_iteration();}
  bool is_qualvector() const {return reorder_user->is_qualvector();}
  bool is_acq_vector() const {return reorder_user->is_acq_vector();}
  svector get_vector_commands(const STD_string& iterator) const;


  int get_reordered_index(int counter, int reord_iteration) const;

  STD_string get_reordered_iterator(const STD_string& iterator) const;

  void clear_cache() {reord_iterator_cache="";}

  reorderScheme reord_scheme;
  unsigned int n_reord_segments;

  encodingScheme encoding_scheme;

  const SeqVector* reorder_user;

  mutable STD_string reord_iterator_cache;
};


#endif