CSVWrapper Class Reference

Class used to read in/out/print csv tables of mappings written by generateMapping.py in efexControl to use in place of currently missing database solutions. More...

#include <CSVWrapper.h>

Collaboration diagram for CSVWrapper:

Public Types
using	tableline = std::vector<std::string>

Public Member Functions
	CSVWrapper ()
	CSVWrapper (std::ifstream &inputfile)
std::shared_ptr< tableline >	FindLine (const std::vector< std::pair< int, std::string > > &argumentpairs)
std::vector< std::shared_ptr< tableline > >	FindLines (const std::vector< std::pair< int, std::string > > &argumentpairs)
tableline	GetLine (const int element) const
void	PrintTable (bool sample=false) const

Private Member Functions
std::vector< CSVWrapper::tableline >	QueryTable (const std::vector< std::pair< int, std::string > > &argumentpairs)
std::vector< bool >	ComparePreviousSearch (const std::vector< std::pair< int, std::string > > &argumentpairs)

Private Attributes
bool	m_valid
bool	m_firstsearch
std::vector< tableline >	m_table
size_t	m_columnwidth
std::vector< std::pair< int, std::string > >	m_prevsearch
std::vector< std::vector< tableline > >	m_previousresults

Detailed Description

Class used to read in/out/print csv tables of mappings written by generateMapping.py in efexControl to use in place of currently missing database solutions.

Definition at line 8 of file CSVWrapper.h.

Member Typedef Documentation

tableline

using CSVWrapper::tableline = std::vector<std::string>

Definition at line 10 of file CSVWrapper.h.

Constructor & Destructor Documentation

CSVWrapper() [1/2]

CSVWrapper::CSVWrapper

(

)

CSVWrapper() [2/2]

CSVWrapper::CSVWrapper

(

std::ifstream &

inputfile

)

Definition at line 15 of file CSVWrapper.cxx.

                                            :
    m_valid(false) , m_firstsearch(true) , m_table(), m_columnwidth(0)
{
    std::istream_iterator<std::string> file_start{inputfile};
    std::istream_iterator<std::string> file_end;
 
    std::vector<std::string> fileContent;
    std::copy(file_start,file_end,back_inserter(fileContent));  // copy file content into vector
 
    fileContent.erase(begin(fileContent));  // first line is comment
    // WARNING if the line contains spaces, it is 
    // treted as several lines!!!
 
    for (auto& line: fileContent){      // iterate over lines, unpack
        std::vector<std::string>   table_entry;
 
        std::string                cell;
        std::stringstream          lineStream(line);
 
        while(std::getline(lineStream,cell, ','))
            table_entry.push_back(cell);                          
        m_table.push_back(std::move(table_entry));
    }
    m_columnwidth = m_table.at(10).size();
    //Intialise prev results vector
    m_previousresults.push_back(m_table);
    m_valid = true;
}

Member Function Documentation

ComparePreviousSearch()

std::vector< bool > CSVWrapper::ComparePreviousSearch ( const std::vector< std::pair< int, std::string > > & argumentpairs )

private

Definition at line 129 of file CSVWrapper.cxx.

                                                                                                       { 
    std::vector<bool> matchvector(argumentpairs.size(), false);
    if(m_firstsearch){
        m_firstsearch = false;
    }
    else{
        int idx = 0;
        for(const auto& newsearch : argumentpairs){
            matchvector.at(idx) = ((newsearch.first == m_prevsearch.at(idx).first) && 
                                   (newsearch.second == m_prevsearch.at(idx).second));
            if(!matchvector.at(idx)) break; //Escape if match fails
            idx++;
        }
    }
    m_prevsearch = argumentpairs;
    return matchvector;
}

FindLine()

std::shared_ptr< CSVWrapper::tableline > CSVWrapper::FindLine

(

const std::vector< std::pair< int, std::string > > &

argumentpairs

)

Parameters

argumentpairs

a vector of search inputs where the 1st value is the column index and the second

Returns

a shared pointer to a row that uniquely matches critereon

Definition at line 48 of file CSVWrapper.cxx.

                                                           {
    std::vector<CSVWrapper::tableline> result = QueryTable(argumentpairs);
    //Check for unique result, if not throw exception
    if ( result.empty())
    {
      CSVWrapper::tableline returnval;
      std::shared_ptr<CSVWrapper::tableline> return_ptr (
            new CSVWrapper::tableline (std::move(returnval)));
      return return_ptr;
    }
    if(result.size() != 1) {
        std::cout << "Duplicate found!" << std::endl;
        for (const auto & res: result) {
            for (const auto & r: res) {
                std::cout << r << ", ";
            }
            std::cout << std::endl;
        }
        throw  "Non unique result to FindLine";
    }
    
    CSVWrapper::tableline returnval = result.at(0);
    std::shared_ptr<CSVWrapper::tableline> return_ptr (
            new CSVWrapper::tableline (std::move(returnval)));
    return return_ptr;
}

FindLines()

std::vector< std::shared_ptr< CSVWrapper::tableline > > CSVWrapper::FindLines

(

const std::vector< std::pair< int, std::string > > &

argumentpairs

)

Parameters

argumentpairs

a vector of search inputs where the 1st value is the column index and the second

Returns

a list of shared pointers to all rows that match the critereon

Definition at line 81 of file CSVWrapper.cxx.

                                                           {
    std::vector<CSVWrapper::tableline> result = QueryTable(argumentpairs);
 
    std::vector<std::shared_ptr<CSVWrapper::tableline>> return_vec;
    if ( result.empty())
    {
      CSVWrapper::tableline returnval;
      std::shared_ptr<CSVWrapper::tableline> return_ptr (
            new CSVWrapper::tableline (std::move(returnval)));
      return_vec.push_back(std::move(return_ptr));
    }
    else {
        for (CSVWrapper::tableline returnval: result) {        
            std::shared_ptr<CSVWrapper::tableline> return_ptr (
                new CSVWrapper::tableline (std::move(returnval)));
            return_vec.push_back(std::move(return_ptr));
        }
    }
    return return_vec;
}

GetLine()

CSVWrapper::tableline CSVWrapper::GetLine

(

const int

element

)

const

Definition at line 103 of file CSVWrapper.cxx.

                                                               {
   if (element==-1)
      return m_table.back();
   return m_table.at(element);
}

PrintTable()

void CSVWrapper::PrintTable

(

bool

sample = false

)

const

Parameters

sample

bool defaulted to false that when true prints only the last 100 lines

Definition at line 113 of file CSVWrapper.cxx.

                                            {
    if(m_valid){
        size_t rowidx(0) ;
        for(const auto& row : m_table){
            if(!sample || (m_table.size()-rowidx)<100){
                for(size_t idx(0);idx<row.size();idx++ ){
                    std::cout << row.at(idx) << " , "; 
                }
                std::cout << std::endl;
            }
            rowidx++;
        }
    }
}

QueryTable()

std::vector< CSVWrapper::tableline > CSVWrapper::QueryTable ( const std::vector< std::pair< int, std::string > > & argumentpairs )

private

Definition at line 147 of file CSVWrapper.cxx.

{
   //Loop over every column argument in the find statement
    size_t searchcolumnidx = 0;
    auto matches = this->ComparePreviousSearch(argumentpairs);
    //std::vector<CSVWrapper::tableline> result = m_table;
    std::vector<CSVWrapper::tableline> result;
    for(bool matched : matches ){
        if(!matched){ //If not the same search as before (in this column)
            //Complete one column  search routine
            result = m_previousresults.at(searchcolumnidx); 
            auto search = argumentpairs.at(searchcolumnidx);
            auto findmismatch = [&] (CSVWrapper::tableline row){
                return (row.at(search.first) != search.second);
            };
            result.erase(std::remove_if(result.begin(), result.end(), findmismatch)
                    , result.end() );
            if(m_previousresults.size() <= searchcolumnidx + 1){//If unintialised
                m_previousresults.push_back(result);
            }
            else{
                m_previousresults.at(searchcolumnidx+1) = result;
            }
        }
        searchcolumnidx++;
    }
    //Cover Case that exactly the same search as before
    if(matches.back() == true){result = m_previousresults.at(searchcolumnidx);}
    return result;
}

Member Data Documentation

m_columnwidth

size_t CSVWrapper::m_columnwidth

private

Definition at line 30 of file CSVWrapper.h.

m_firstsearch

bool CSVWrapper::m_firstsearch

private

Definition at line 28 of file CSVWrapper.h.

m_previousresults

std::vector<std::vector<tableline> > CSVWrapper::m_previousresults

private

Definition at line 32 of file CSVWrapper.h.

m_prevsearch

std::vector<std::pair<int,std::string> > CSVWrapper::m_prevsearch

private

Definition at line 31 of file CSVWrapper.h.

m_table

std::vector<tableline> CSVWrapper::m_table

private

Definition at line 29 of file CSVWrapper.h.

m_valid

bool CSVWrapper::m_valid

private

Definition at line 27 of file CSVWrapper.h.

---

The documentation for this class was generated from the following files:

• CSVWrapper.h
• CSVWrapper.cxx