changed

Author: MJavaadAkhtar

myPage

@@ -1,124 +1,84 @@
-#include <algorithm>
-#include <stdlib.h>
 #include <iostream>
 #include <fstream>
-#include <string.h>
+#include <sstream>
 #include <sys/timeb.h>
+#include <cstring>
 #include "library.h"
 
-int main(int argc, char** argv) {
+int main(int argc, const char * argv[]) {
     if (argc < 4) {
-        std::cout << "Error, usage must be:\n";
-        std::cout << "./write_fixed_len_pages <csv_file> <page_file> <page_size>\n";
-        return 1;
-    }
-
-    bool show_output = true;
-    if (argc == 5 && strcmp(argv[4], "--no-output") == 0) {
-        show_output = false;
-    }
-
-    std::ifstream csv_file;
-    csv_file.open(argv[1]);
-    if (!csv_file) {
-        std::cout << "Error, could not find file " << argv[1] << "\n";
+        std::cout << "Usage: write_fixed_len_pages <csv_file> <page_file> <page_size>";
         return 1;
     }
+    std::string csv_filename(argv[1]);
+    std::string page_filename(argv[2]);
+    int page_size = std::stoi(argv[3]); // 4096 for example
 
+    // Open the page file for writing
     std::ofstream page_file;
-    page_file.open(argv[2]);
-    if (!page_file) {
-        std::cout << "Error, could not find file " << argv[2] << "\n";
-        return 1;
-    }
-
-    int page_size = atoi(argv[3]);
-    int record_size = NUM_ATTRIBUTES * ATTRIBUTE_SIZE;
+    page_file.open(page_filename, std::ios::out | std::ios::binary);
 
+    // Read the CSV file line-by-line:
+    std::ifstream csv_file(csv_filename);
+    std::string line;
     Page page;
-    init_fixed_len_page(&page, page_size, record_size);
-
-    int total_records = 0;
-    int total_pages = 0;
-
-    char* buf;
+    int should_create_new_page = 1;
 
+    // start timer
     struct timeb t;
     ftime(&t);
-    long start_time_in_ms = (t.time * 1000) + t.millitm;
-
-    while (csv_file) {
-        std::string line;
-        csv_file >> line;
-
-        if (line.size() == 0) {
-            // ignore empty lines
-            continue;
+    unsigned long start_ms = t.time * 1000 + t.millitm;
+
+    // for output
+    int number_of_records = 0;
+    int number_of_pages = 0;
+
+    while (std::getline(csv_file, line)) {
+        std::stringstream linestr(line);
+        std::string cell;
+
+        // Read cells into a Record
+        Record record;
+        while (std::getline(linestr, cell, ',')) {
+            char *temp = (char *) malloc(11);
+            std::strncpy(temp, cell.c_str(), 11);
+            record.push_back(temp);
         }
 
-        // remove all commas from the line
-        line.erase(std::remove(line.begin(), line.end(), ','), line.end());
-
-        Record *r = new Record;
-
-        // turn 'line' from string to char*, and read the values into r
-        fixed_len_read((char*)line.c_str(), record_size, r);
-
-        int slot_index = add_fixed_len_page(&page, r);
-
-        if (slot_index == -1) {  // page is full
-
-            total_pages++;
-
-            int buf_size = page.page_size * record_size;
-            buf = new char[buf_size];
-
-            std::vector<Record> *page_data = page.data;
-            for (int i = 0; i < fixed_len_page_capacity(&page); i++) {
-                fixed_len_write(&page_data->at(i), buf);
-            }
-
-            // flush page to file
-            page_file << buf << std::flush;
-
-            // allocate empty page
-            init_fixed_len_page(&page, page_size, record_size);
-            // recalculate slot index
-            slot_index = add_fixed_len_page(&page, r);
+        // First run, the page will not be initialized
+        if (should_create_new_page) {
+            init_fixed_len_page(&page, page_size, fixed_len_sizeof(&record));
+            number_of_pages += 1;
         }
-
-        write_fixed_len_page(&page, slot_index, r);
-
-        total_records++;
-    }
-    // write last page to file if it has records
-    if (page.used_slots > 0) {
-        total_pages++;
-
-        // write page to page_file
-        int buf_size = page.page_size * record_size;
-        buf = new char[buf_size];
-        std::vector<Record> *page_data = page.data;
-        for (int i = 0; i < fixed_len_page_capacity(&page); i++) {
-            if (!page_data->at(i).empty()) {
-                fixed_len_write(&(page_data->at(i)), buf);
-            }
+        should_create_new_page = add_fixed_len_page(&page, &record) == -1;
+        number_of_records += 1;
+
+        // if -1, init a new page and add this record to it
+        if (should_create_new_page) {
+            // Write page.data to page_file
+            page_file.write((const char *) page.data, page.page_size);
+
+            init_fixed_len_page(&page, page_size, fixed_len_sizeof(&record));
+            add_fixed_len_page(&page, &record);
+            should_create_new_page = 0;
+            number_of_pages += 1;
         }
+    }
 
-        // flush page to file
-        page_file << buf << std::flush;
+    if (!should_create_new_page) {
+        // Write page.data to page_file
+        page_file.write((const char *) page.data, page.page_size);
     }
 
+    page_file.close();
+
+    // stop timer
     ftime(&t);
-    long total_run_time = ((t.time * 1000) + t.millitm) - start_time_in_ms;
+    unsigned long stop_ms = t.time * 1000 + t.millitm;
 
-    csv_file.close();
-    page_file.close();
+    std::cout << "NUMBER OF RECORDS: " << number_of_records << "\n";
+    std::cout << "NUMBER OF PAGES: " << number_of_pages << "\n";
+    std::cout << "TIME: " << stop_ms - start_ms << " milliseconds\n";
 
-    if (show_output) {
-        std::cout << "NUMBER OF RECORDS: " << total_records << "\n";
-        std::cout << "NUMBER OF PAGES: " << total_pages << "\n";
-        std::cout << "TOTAL TIME: " << total_run_time << " milliseconds\n";
-    }
     return 0;
 }