tables.H

Go to the documentation of this file.

#ifndef _TABLES_H_
#define _TABLES_H_

#include <fstream>
#include <sstream>
#include <string>
#include <iomanip>
#include <iostream>
#include <list>
using namespace std;




template <class T> class Tuple {

 protected:
  long tuple_size; 
  T* data;       
  char sep;     
  
 public:

  Tuple<T>(){
    data=0;
    tuple_size=0;
    sep=' ';
  }


  Tuple<T>(long thesize){
    data=new T[thesize];   
    tuple_size=thesize;
    sep=' ';
  }

  Tuple<T>(const Tuple<T>& that){
    data=0;
    tuple_size=0; 
    copy(that);
  }

  ~Tuple<T>(){
    delete[] data;
  }

  void block_copy(T *dest, const T *source, long amount){
    long i;

    for(i=0; i < amount; i++)
      dest[i]= source[i];
  }



  void resize(long thesize){
    T* temp;
    long j;
    
    if(thesize==tuple_size) {return;}
    temp=new T[thesize];
    j=(thesize > tuple_size) ? tuple_size : thesize; // j=min taille, tuplue_size
    block_copy(temp, data, j);
    delete[] data;
    data=temp;
    tuple_size=thesize; 
  }

  void copy(const Tuple<T>& that){
    if(tuple_size != that.tuple_size){
      tuple_size= that.tuple_size;      
      delete[] data;
      data=new T[tuple_size];
    }
    block_copy(data, that.data, tuple_size);
    sep=that.sep;
  }

  Tuple<T>& operator=(const Tuple<T>& that){
    copy(that);
    return *this;
  }

  void steal(Tuple<T>& that){

    delete[] data;
    data= that.data;
    tuple_size= that.tuple_size;
    // now erase that
    that.data= 0;
    that.tuple_size= 0;
  }
  long size() const {return tuple_size;}
  void set_sep(const char s){
    sep= s;
  }


  T& operator[](long i) {
    return data[i];
    }

  const T& operator[](long i) const {
    return data[i];
    }

  bool operator==(const Tuple<T>& that) const {
    long i=0;

     if(tuple_size != that.tuple_size){
       return false;
    }
    else {
      for(i=0; (i< tuple_size) && (data[i]==that.data[i]);i++);
      return i==tuple_size;
    }
  }



  friend ostream& operator<<(ostream& os, const Tuple<T>& M){
    long i;

    if(M.tuple_size == 0)
      return os;

    if(M.sep != 0) {    
      for(i=0; i < M.tuple_size-1; i++ )
        os << M[i] << M.sep;
      os << M[i];
    }
    else{
      for(i=0; i < M.tuple_size; i++ )
        {os << M[i];}
    }
    
    return os;
  }

  friend ofstream& operator<<(ofstream& file, Tuple<T>& M){

    file << M.tuple_size << " ";
    for(long i=0; i< M.tuple_size; i++)
      file << M.data[i] << " ";
    return file;
  }
  friend void operator>>(ifstream& file, Tuple<T>& M){
    long n;
    
    file >> n;
    M.resize(n);
    for(long i=0; i < M.tuple_size; i++)
      file >> M.data[i];
  }

};




template <class T> class Table : public Tuple<T> {
 protected:
  T** pdata;                  
  long nb_lines, nb_cols;    
  char left, right;           
  

  long col_width() const {            
    string s="";               
    ostringstream os;          
    long i,j,l;
    long n=0;
    
    for(i=0; i< nb_lines; i++)
      for(j=0; j< nb_cols; j++){
        os << pdata[i][j];
        s= os.str();
        l=s.length();
        n=(l>n) ? l : n;
        s="";
        os.str("");
      }
    
    return n; 
  }


  void write_ptrs(){
    pdata=new T*[nb_lines];
    for(long i=0; i < nb_lines; i++)
      pdata[i]=this->data + i*nb_cols;
  }
  
 public:

  Table<T>() : Tuple<T>() {
    nb_lines=0;
    nb_cols=0;
    pdata=0;
    left=right='|';
  }

  Table<T>(long i, long j) : Tuple<T>(i*j){
    nb_lines=i;
    nb_cols=j;
    write_ptrs();
    left=right='|';
  }
  Table<T>(const Table<T>& that) : Tuple<T>() {
    nb_lines=0;
    nb_cols=0;
    pdata=0;
    copy(that);
  }

  ~Table<T>(){
    delete[] pdata;
  }

  


  void resize(long i, long j){
    T *temp, *dest, *source; 
    long mi,mj,n,amount;

    if( i==nb_lines && j==nb_cols )
      return;
    temp=new T[i*j];        // creates new table;
    mi= i > nb_lines ? nb_lines : i; 
    mj= j > nb_cols ? nb_cols : j;
    for(n=0, dest=temp, source=this->data, amount=mj; n < mi; n++){ 
      block_copy(dest, source, amount); //populates temp
      dest+=j;
      source+=nb_cols;
    }
    delete[] this->data;
    this->data=temp;
    nb_lines=i;
    nb_cols=j;
    this->tuple_size=i*j;
    delete[] pdata;
    write_ptrs();
  }
  void copy(const Table<T>& that){
    Tuple<T>::copy(that);
    nb_lines=that.nb_lines;
    nb_cols=that.nb_cols;
    delete[] pdata;
    write_ptrs();
    left=that.left;
    right=that.right;
  }
  void steal(Table<T>& that){
    Tuple<T>::steal(that);
    delete[] pdata;
    pdata= that.pdata;
    nb_lines= that.nb_lines;
    nb_cols= that.nb_cols;
    // finish erasing that
    that.nb_lines= 0;
    that.nb_cols= 0;
    that.pdata= 0;
  }

  Table<T> operator=(const Table<T>& that){
    copy(that);
    return *this;
  }

  

  void readline(long i, const Tuple<T>& line){
    block_copy(pdata[i], &line[0], nb_cols);
  }
  
  void get_data_from_tuple_list(const list< Tuple<T> >& L){
    long li, col, i, j;
    typename list< Tuple<T> >::const_iterator it;
    
    //find out number of lines and cols
    li= col= 0;
    for(it= L.begin(); it!= L.end(); it++){
      li++;
      col= col > it->size() ? col : it->size();
    }
    //get the memory for it
    delete[] this->data;
    this->data= new T[col*li];
    nb_lines= li;
    nb_cols= col;
    this->tuple_size= col*li;
    delete[] pdata;
    write_ptrs();

    //now copy
    for(i=0, it=L.begin(); i<li; i++, it++)
      for(j=0; j< it->size(); j++)
        pdata[i][j]= (*it)[j];

  }


  
  T& operator()(long i, long j) {
    return pdata[i][j];
  }

  const T& operator()(long i, long j) const {
    return pdata[i][j];
  }
  long nlines() const {return nb_lines;}
  long ncols() const {return nb_cols;}
  void set_delim(char theleft, char theright){
    left=theleft;
    right=theright;
  }
  friend ostream& operator<<(ostream& os, const Table<T>& M){
    long w;
    long i,j;
    ostringstream s;

    w=M.col_width();
    for(i=0; i<M.nb_lines; i++){
      os << M.left;
      for(j=0; j< M.nb_cols-1; j++){
        s << M(i,j);        //using s seems necessary because of setw
        os << setw(w) << s.str(); // setw is only for the next operation, 
        s.str("");          // and printing M(i,j) might require several.
        os << M.sep;}
      s << M(i,j);
      os << setw(w) << s.str();
      s.str("");
      os << M.right << endl;
    }
    return os;
  }


};


#endif

---