seqvec.h

/***************************************************************************
                          seqvec.h  -  description
                             -------------------
    begin                : Mon Aug 19 2002
    copyright            : (C) 2000-2021 by Thies H. Jochimsen
    email                : thies@jochimsen.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
#ifndef USING_GCC
  friend class SeqVector; // making the class itself a friend is required for MSVC6 !!
#endif
#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