codebase / stimlib

  #ifndef STIM_TABLE_H
  #define STIM_TABLE_H

  #include <type_traits>

  #include <vector>
  #include <sstream>
  #include <fstream>
  
  namespace stim{
  
  	class table{
  
  		std::vector< std::vector< std::string > > TABLE;
  
  		size_t x;											//current x and y positions for adding elements to the table
  		size_t y;
  
  		void init(){
  			x = y = 0;
  			TABLE.resize(1);								//create a single row
  			TABLE[0].clear();								//make sure that the row is empty
  		}
  	public:
  
  		table(){
  			init();
  		}
  
  		void new_column(){
  			x = 0;											//reset to the first position of the column
  			y++;											//increment the current row position
  			TABLE.push_back( std::vector<std::string>() );	//push an empty row
  		}
  
  		template<typename T>
  		T operator<<(T i){
  			std::stringstream ss;

  			if(std::is_fundamental<T>())						//if the data type is numeric
  				ss<<std::setprecision(std::numeric_limits<T>::digits10 + 3);	//set the precision to account for all digits

  			ss<<i;
  			TABLE[y].push_back(ss.str());
  			x++;
  			return i;
  		}
  
  		std::string str(){
  			std::stringstream ss;
  			for(size_t yi = 0; yi < TABLE.size(); yi++){
  				for(size_t xi = 0; xi < TABLE[yi].size(); xi++){
  					if(xi != 0) ss<<", ";
  					ss<<TABLE[yi][xi];
  				}
  				ss<<std::endl;
  			}
  			return ss.str();
  		}
  
  		void save_ascii(std::string filename, char col_delim = ',', char row_delim = '\n'){

  			std::ofstream outfile(filename);

  			for(size_t yi = 0; yi < TABLE.size(); yi++){
  				if(yi != 0 && TABLE[yi].size() > 0) outfile<<row_delim;
  				for(size_t xi = 0; xi < TABLE[yi].size(); xi++){
  					if(xi != 0) outfile<<col_delim;
  					outfile<<TABLE[yi][xi];
  				}
  			}
  		}
  
  		void read_ascii(std::string filename, char col_delim = ',', char row_delim = '\n'){

  			std::ifstream infile(filename);						//open an ascii file for reading

  			TABLE.clear();									//empty out the table
  
  			std::string line;
  			while(!infile.eof()){
  				std::getline(infile, line, row_delim);		//read a line from the file using the row delimiter
  				size_t pos = 0;
  				std::string token;
  				std::vector< std::string > row;
  				while ((pos = line.find(col_delim)) != std::string::npos) {
  					token = line.substr(0, pos);
  					row.push_back(token);
  					line.erase(0, pos + 1);
  				}
  				token = line.substr(0, std::string::npos);		//read the last column
  				row.push_back(token);							//push it into the table
  				TABLE.push_back(row);		//add an empty vector to the table
  			}
  		}
  
  		/// Returns a vector representation of the table by casting to the specified template
  		template<typename T>
  		std::vector< std::vector<T> > get_vector(){
  			std::vector< std::vector<T> > result;
  			result.resize(TABLE.size());							//initialize the first dimension of the returned table
  			for(size_t i = 0; i < TABLE.size(); i++){				//for each row
  				result[i].resize(TABLE[i].size());					//initialize the number of columns in this row
  				for(size_t j = 0; j < TABLE[i].size(); j++){			//for each column
  					std::stringstream ss(TABLE[i][j]);
  					ss >> result[i][j];
  				}
  			}
  			return result;											//return the casted table
  		}
  

  		size_t rows(){
  			return TABLE.size();
  		}
  
  		size_t cols(size_t ri){
  			return TABLE[ri].size();
  		}
  
  		//returns the maximum number of columns in the table
  		size_t cols(){
  			size_t max_c = 0;
  			for(size_t ri = 0; ri < rows(); ri++){
  				max_c = std::max(max_c, cols(ri));
  			}
  			return max_c;
  		}
  
  		std::string operator()(size_t ri, size_t ci){
  			return TABLE[ri][ci];
  		}
  

  	};
  };
  
  

  #endif