Organize_Blocks.h

#ifndef QNANO_NEW_ORGANIZE_BLOCKS_DEFINED_H
#define QNANO_NEW_ORGANIZE_BLOCKS_DEFINED_H

#include <vector>
#include <iostream>
#include <cstdlib>
#include "tools/Size_Provider.h"

class Organize_Blocks{
public:
  virtual size_t get_block_size(size_t block) const = 0;
  virtual size_t get_base_index(size_t block) const = 0;
  virtual size_t get_nr_blocks() const = 0;
  virtual size_t get_DIM()const{ return get_base_index(get_nr_blocks()-1)+get_block_size(get_nr_blocks()-1);}

  //Get sum of blocksizes for a range of 'nr_blocks' blocks starting from 'block_start'
  size_t get_range_size(size_t block_start, size_t nr_blocks)const;



  virtual ~Organize_Blocks(){}
};

class Organize_Blocks_Equal: virtual public Organize_Blocks{
protected:
  size_t blocksize, nrblocks;
public:
  void set_block_size(size_t bs){ blocksize=bs; }
  void set_nr_blocks(size_t nr){ nrblocks=nr; }
  virtual size_t get_block_size(size_t block=0)const{ return blocksize;}
  virtual size_t get_base_index(size_t block) const{ return blocksize*block; }
  virtual size_t get_nr_blocks()const{ return nrblocks;}
  virtual size_t get_DIM()const{ return blocksize*nrblocks;}

  Organize_Blocks_Equal(size_t bs=1, size_t nr=0): blocksize(bs), nrblocks(nr) {}
};

class Organize_Blocks_Single: virtual public Organize_Blocks{
protected:
  size_t nrblocks;
public:
  void set_nr_blocks(size_t nr){ nrblocks=nr; }
  virtual size_t get_block_size(size_t block=0)const{ return 1;}
  virtual size_t get_base_index(size_t block) const{ return block; }
  virtual size_t get_nr_blocks()const{ return nrblocks;}
  virtual size_t get_DIM()const{ return nrblocks;}

  Organize_Blocks_Single(size_t nr=0): nrblocks(nr) {}
};

class Organize_Blocks_Single_Forward: virtual public Organize_Blocks{
public:
  Size_Provider *provider;
public:

  virtual size_t get_block_size(size_t block=0)const{ return 1;}
  virtual size_t get_base_index(size_t block) const{ return block; }
  virtual size_t get_nr_blocks()const{ return provider->size();}
  virtual size_t get_DIM()const{ return provider->size();}

  virtual void set_provider(Size_Provider *prov){
    provider=prov;
  }
  virtual void copy(const Organize_Blocks_Single_Forward &other){
    provider=other.provider;
  }
  Organize_Blocks_Single_Forward &operator=(const Organize_Blocks_Single_Forward &other){
    copy(other);
    return *this;
  }
  Organize_Blocks_Single_Forward(const Organize_Blocks_Single_Forward &other){
    copy(other);
  }
  Organize_Blocks_Single_Forward(){
    provider=&Size_Provider_Zero_Instance;
  }
  Organize_Blocks_Single_Forward(Size_Provider *prov){
    provider=prov;
  }
};

class Organize_Blocks_By_List: virtual public Organize_Blocks{
public:
  std::vector<size_t> blocksizes;
  std::vector<size_t> baseindices;
  
  virtual size_t get_block_size(size_t block)const;
  virtual size_t get_base_index(size_t block)const;
  virtual size_t get_nr_blocks()const;
  virtual void calculate_base_indices();


  Organize_Blocks_By_List(){}
  Organize_Blocks_By_List(const std::vector<size_t> &blocksizes_) 
    : blocksizes(blocksizes_) {
    calculate_base_indices();
  }
 
};


#endif