fixed issue with empty when inserting from BED file

cli/include/BEDReader.hpp

@@ -5,6 +5,7 @@
 #include <string>
 #include <filesystem>
 #include <istream>
+#include <fstream>
 #include <algorithm>
 
 // Class
@@ -18,9 +19,10 @@ class BEDReader : public FileReader {
         bool readNext(FileEntry& entry) override;
         bool hasNext() override;
         std::string getErrorMessage() override;
+        size_t getCurrentLine() override;
 
     private:
-        std::unique_ptr<std::istream> inputStream;
+        std::unique_ptr<std::ifstream> inputStream;
         std::string errorMessage;
         size_t lineNum;
 };

cli/include/FileReader.hpp

@@ -10,6 +10,7 @@ class FileReader {
         virtual bool readNext(FileEntry& entry) = 0;
         virtual bool hasNext() = 0;
         virtual std::string getErrorMessage() = 0;
+        virtual size_t getCurrentLine() = 0;
         virtual ~FileReader() = default;
 };
 

cli/include/Index.hpp

@@ -7,7 +7,11 @@
 // Class
 #include "genogrove/all.hpp"
 #include "Subcall.hpp"
-#include "FileValidatorFactory.hpp"
+#include "FileReader.hpp"
+#include "BEDReader.hpp"
+#include "FileEntry.hpp"
+#include "FileTypeDetector.hpp"
+#include "FileReaderFactory.hpp"
 
 // CXXopts
 #include "cxxopts.hpp"

cli/src/BEDReader.cpp

@@ -6,7 +6,10 @@ BEDReader::BEDReader(const std::filesystem::path& filepath, bool gzipped) {
     if(gzipped) {
         // open file gzipped
     } else {
-//        inputStream = std::make_unique<std::ifstream>(filepath);
+        inputStream = std::make_unique<std::ifstream>(filepath);
+        if(!inputStream->is_open()) {
+            throw std::runtime_error("Failed to open file: " + filepath.string());
+        }
     }
 }
 
@@ -39,7 +42,12 @@ bool BEDReader::readNext(FileEntry& entry) {
             errorMessage = "Start coordinate must be less than end coordinate at line " + std::to_string(lineNum);
             return false;
         }
-        FileEntry entry(chrom, genogrove::Interval{startNum, endNum}, '\0');
+
+        // modify the passen entry
+        entry.chrom = chrom;
+        entry.interval = genogrove::Interval{startNum, endNum};
+        entry.strand = '.';
+
         lineNum++;
         return true;
 
@@ -57,3 +65,7 @@ std::string BEDReader::getErrorMessage() {
     return errorMessage;
 }
 
+size_t BEDReader::getCurrentLine() {
+    return lineNum;
+}
+

cli/src/Index.cpp

@@ -21,46 +21,34 @@ cxxopts::Options Index::parseArgs(int argc, char** argv) {
 
 void Index::execute(const cxxopts::ParseResult& args) {
     std::cout << "Indexing file: " << args["inputfile"].as<std::string>() << std::endl;
-    genogrove::IBPTree tree(args["order"].as<int>());
-    genogrove::BEDfileValidator validator;
 
-    std::string inputfile = args["inputfile"].as<std::string>();
-    // detect the file type
-    auto [filetype, gzipped] = genogrove::FileTypeDetector().detectFileType(inputfile);
-    // validate the file
-    std::string errorMessage;
-    if(!genogrove::FileValidatorFactory::validate(inputfile, filetype, gzipped, errorMessage)) {
-        std::cerr << "Error validating file: " << errorMessage << "\n";
-        return;
+    std::filesystem::path inputfile = std::filesystem::path(args["inputfile"].as<std::string>());
+    auto [filetype, gzipped] = FileTypeDetector().detectFileType(inputfile); // detect the file type
+    // create the reader (according to the file type) - FileReaderFactory
+    std::unique_ptr<FileReader> reader = FileReaderFactory::create(inputfile, filetype, gzipped);
+
+    genogrove::IBPTree tree(args["order"].as<int>()); // create the tree (with the specified order)
+    FileEntry entry;
+    while(reader->hasNext()) {
+//        std::cout << "Reading entry: " << reader->getCurrentLine() << std::endl;
+        if(!reader->readNext(entry)) {
+            std::cerr << reader->getErrorMessage() << std::endl;
+            return;
+        }
+        std::cout << "chrom: " << entry.chrom << std::endl;
+        tree.insertData(entry.chrom, entry.interval, entry.strand);
     }
 
-    std::cout << "Successfully validated file\n";
-
-
-
-
-
-
-//    if(!validator.validate(inputfile)) {
-//        std::cerr << validator.getErrorMessage() << std::endl;
-//        return;
-//    }
-//
-//
-
-
-
-
-
-
-
-    if(args.count("inputfile")) {
-        std::string inputfile = args["inputfile"].as<std::string>();
-        std::cout << "Indexing file: " << inputfile << std::endl;
-    }
-
-    if(args.count("outputfile")) {
-        std::string outputfile = args["outputfile"].as<std::string>();
+    // write the tree to a file
+    std::filesystem::path outputfile;
+    if(args.count("outputfile")) { // check if an output file was specified
+        outputfile = std::filesystem::path(args["outputfile"].as<std::string>());
+    } else { // if not, write to inputfile.gg (with a .gg extension)
+        outputfile = inputfile.replace_extension(".gg");
         std::cout << "Writing index to file: " << outputfile << std::endl;
     }
+
+    // serialize the tree
+    tree.store(outputfile);
+
 }

include/genogrove/IBPTree.hpp

@@ -62,6 +62,7 @@ namespace genogrove {
              */
             void insertData(std::string chrom, Interval intvl, char strand) {
                 Key key(intvl, strand, nullptr);
+                insert(chrom, key);
             }