BinarySearchTree

#include #include #include #include "CSVparser.hpp"

namespace csv {

Parser::Parser(const std::string& data, const DataType& type, char sep) : _type(type), _sep(sep) { std::string line; if (type == eFILE) { _file = data; std::ifstream ifile(_file.c_str()); if (ifile.is_open()) { while (ifile.good()) { getline(ifile, line); if (line != "") _originalFile.push_back(line); } ifile.close();

if (_originalFile.size() == 0) throw Error(std::string("No Data in ").append(_file));

parseHeader(); parseContent(); } else throw Error(std::string("Failed to open ").append(_file)); } else { std::istringstream stream(data); while (std::getline(stream, line)) if (line != "") _originalFile.push_back(line); if (_originalFile.size() == 0) throw Error(std::string("No Data in pure content"));

parseHeader(); parseContent(); } }

Parser::~Parser(void) { std::vector::iterator it;

for (it = _content.begin(); it != _content.end(); it++) delete* it; }

void Parser::parseHeader(void) { std::stringstream ss(_originalFile[0]); std::string item;

while (std::getline(ss, item, _sep)) _header.push_back(item); }

void Parser::parseContent(void) { std::vector<:string>::iterator it;

it = _originalFile.begin(); it++; // skip header

for (; it != _originalFile.end(); it++) { bool quoted = false; int tokenStart = 0; unsigned int i = 0;

Row* row = new Row(_header);

for (; i != it->length(); i++) { if (it->at(i) == '"') quoted = ((quoted) ? (false) : (true)); else if (it->at(i) == ',' && !quoted) { row->push(it->substr(tokenStart, i - tokenStart)); tokenStart = i + 1; } }

//end row->push(it->substr(tokenStart, it->length() - tokenStart));

// if value(s) missing if (row->size() != _header.size()) throw Error("corrupted data !"); _content.push_back(row); } }

Row& Parser::getRow(unsigned int rowPosition) const { if (rowPosition

Row& Parser::operator[](unsigned int rowPosition) const { return Parser::getRow(rowPosition); }

unsigned int Parser::rowCount(void) const { return _content.size(); }

unsigned int Parser::columnCount(void) const { return _header.size(); }

std::vector<:string> Parser::getHeader(void) const { return _header; }

const std::string Parser::getHeaderElement(unsigned int pos) const { if (pos >= _header.size()) throw Error("can't return this header (doesn't exist)"); return _header[pos]; }

bool Parser::deleteRow(unsigned int pos) { if (pos

bool Parser::addRow(unsigned int pos, const std::vector<:string>& r) { Row* row = new Row(_header);

for (auto it = r.begin(); it != r.end(); it++) row->push(*it);

if (pos

void Parser::sync(void) const { if (_type == DataType::eFILE) { std::ofstream f; f.open(_file, std::ios::out | std::ios::trunc);

// header unsigned int i = 0; for (auto it = _header.begin(); it != _header.end(); it++) { f

for (auto it = _content.begin(); it != _content.end(); it++) f

const std::string& Parser::getFileName(void) const { return _file; }

/* ** ROW */

Row::Row(const std::vector<:string>& header) : _header(header) {}

Row::~Row(void) {}

unsigned int Row::size(void) const { return _values.size(); }

void Row::push(const std::string& value) { _values.push_back(value); }

bool Row::set(const std::string& key, const std::string& value) { std::vector<:string>::const_iterator it; int pos = 0;

for (it = _header.begin(); it != _header.end(); it++) { if (key == *it) { _values[pos] = value; return true; } pos++; } return false; }

const std::string Row::operator[](unsigned int valuePosition) const { if (valuePosition

const std::string Row::operator[](const std::string& key) const { std::vector<:string>::const_iterator it; int pos = 0;

for (it = _header.begin(); it != _header.end(); it++) { if (key == *it) return _values[pos]; pos++; }

throw Error("can't return this value (doesn't exist)"); }

std::ostream& operator

return os; }

std::ofstream& operator

I need it to display 98223: Chair | 71.88 | General Fund time: 183 clock ticks time: 0.000183 seconds

when clicking choice 3

save you time. Look for where you have used a node structure to implement a linked list. Here is sample output from running the completed program: > . /BinarySearchTree ~/Downloads/eBid_Monthly_Sales . csv > BinarySearchTree . exe Downloads\\eBid_Monthly_Sales . csv Load bids from CSV and display the binary tree contents: Example Choice: 1 Choice: 3 Input Menu: Menu: 1. Load Bids 1. Load Bids 2. Display All Bids 2. Display All Bids Display 3. Find Bid 3. Find Bid 4. Remove Bid 4. Remove Bid 9. Exit 9. Exit Enter choice: 1 Enter choice: 3 Loading CSV file 98223: Chair | eBid_Monthly_Sales.csv 71.88 | General Fund Output 12,023 bids read time: 183 clock ticks time: 6795773 clock ticks time: 0.000183 time: 6.79577 seconds seconds Note that it took only 183 clock ticks to search over 12,000 records in a binary tree. Specifically, you must address the following rubric criteria: Code Reflection: Briefly describe the purpose of code, techniques implemented to solve problems, challenges encountered, and approaches to overcome the challenges. . Pseudocode or Flowchart: Provide a pseudocode or flowchart description of the code that is clear and understandable and captures accurate logic to translate to the programming language. Specifications and Correctness: Source code must meet its specifications and behave as desired. Correct code produces the correct output as defined by the data and problem. However, you should also produce fully functioning code with no errors that aligns with as many of the specifications as possible. You should write your code in a way that the submitted file executes, even if it does not produce the correct output. You will be given credit for partially correct output that can be viewed and seen to be partially correct. Annotation and Documentation: All code should also be well commented. Commenting is a practiced art that requires striking a balance between commenting everything, which adds unneeded noise to the code, and commenting nothing. Well-annotated code requires you to perform the following actions: Explain the purpose of lines or sections of your code, detailing the approach and method you took to achieve a specific task in the code. . Document any section of code that is producing errors or incorrect results. . Modular and Reusable: Programmers should develop code that is modular and reusable. Code is more flexible and maintainable if it contains functionality and responsibility in distinct methods. Your code should adhere to the single responsibility principle. Classes and methods should do only one job. If you can use a different method without changing other parts of your code, you have succeeded in