+ cleaning up code base
[qpalma.git] / ParaParser / ParaParser.cpp
index c7c3151..ffbe30e 100644 (file)
@@ -1,11 +1,23 @@
 #include "ParaParser.h"
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/mman.h>
-#include <sys/stat.h>
 #include <string>
 using namespace std;
 
+/*
+ *
+ *
+ */
+
+/*
+bool check_for_well_formed_format_string(const char* fmt) {
+   types_list = (char**) malloc(sizeof(char**)*num_columns);
+   char *pruned_ptr = pruned_format_string;
+   //printf("types list\n");
+   for(size_t f_idx=0;f_idx<num_columns;f_idx++) {
+      char *part = strtok (pruned_ptr, "%");
+      pruned_ptr = NULL;
+
+}
+*/
 
 /**
  * Split string and return pointers to its parts.
@@ -65,11 +77,12 @@ unsigned split_args(char *args, char *** const argv_ptr, const char *delim)
  *
  */
 
-ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries) {
+ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries, storage_mode mode) {
    // check that we have more than zero entries and that the format string
    // contains exactly num_entries format elements.
-   assert(num_entries>0);
-
+   if ( num_entries < 1 )
+      printf("Error: You need at least one field !\n");
+      
    num_columns = (size_t) num_entries;
 
    // count how many entries are parsed in one line (number of %'s)
@@ -88,7 +101,9 @@ ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries) {
    field_names = (char**) malloc(sizeof(char*)*num_columns);
    for(size_t idx=0;idx<num_columns;idx++) {
       field_names[idx] = (char*) malloc(sizeof(char)*buf_size);
-      strncpy(field_names[idx],_fields[idx],strlen(_fields[idx]));
+      strncpy(field_names[idx],_fields[idx],strlen(_fields[idx])+1);
+      field_names[idx][strlen(_fields[idx])] = '\0';
+      //printf("%s\n",field_names[idx]);
    }
 
    char* pruned_format_string = (char*) malloc(sizeof(char)*buf_size);
@@ -115,6 +130,21 @@ ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries) {
       //printf("%s(%d) ",part,strlen(part));
    }
    //printf("\n");
+   //
+   current_mode = mode;
+   if(current_mode !=  IN_VECTOR && current_mode != IN_MAP) {
+      printf("Error: Wrong save mode!");
+      exit(EXIT_FAILURE);
+   }
+}
+
+
+
+ParaParser::~ParaParser() {
+   // unmap parsed file
+   int status = munmap(reads_area,reads_filesize);
+   if(status != 0)
+      perror("munmap");
 }
 
 
@@ -124,7 +154,7 @@ ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries) {
  *
  */
 
-void ParaParser::create_entry_from_line(const char* current_line, char* format_string) {
+void ParaParser::create_entry_from_line(const char* current_line, char* format_string, char* lineBeginPtr, char* lineEndPtr) {
    //printf("current line is %s",current_line);
    
    // create an array of void ptrs
@@ -148,12 +178,23 @@ void ParaParser::create_entry_from_line(const char* current_line, char* format_s
    }
    free(mutable_line);
 
-   int id = atoi(current_entries[0]);
-   //printf("id is %d\n",id);
-   //printf("size of map %d\n",entries->size());
-   (*entries)[id] = current_entries;
-   //printf("size of map %d\n",entries->size());
+   map_key_t id = strtoul(current_entries[0],NULL,10);
 
+   if ( current_mode == IN_VECTOR ) {
+      //printf("size is %zd\n",v_entries->size());
+      v_entries->push_back(current_entries);
+      pair<char*,char*> p;
+      p.first = lineBeginPtr;
+      p.second = lineEndPtr;
+      v_ptr_entries->push_back(p);
+      //printf("size is %zd\n",v_entries->size());
+   }
+
+   if ( current_mode == IN_MAP ) {
+      //printf("size is %zd\n",entries->size());
+      (*entries)[id] = current_entries;
+      //printf("size is %zd\n",entries->size());
+   }
 }
 
 
@@ -193,20 +234,26 @@ int ParaParser::parseFile(char* reads_filename) {
       exit(EXIT_FAILURE);
    }
 
-   off_t reads_filesize = reads_stat.st_size;
-   //printf("Reads file is of size %lu bytes\n",(unsigned long) reads_filesize);
+   reads_filesize = reads_stat.st_size;
+   printf("Reads file is of size %lu bytes\n",(unsigned long) reads_filesize);
 
-   entries = new MAP();
+   if ( current_mode == IN_VECTOR ) {
+      v_entries = new VECTOR();
+      v_ptr_entries = new PTR_VECTOR();
+   }
+
+   if ( current_mode == IN_MAP )
+      entries = new MAP();
 
    // try to acquire file using mmap
-   void *reads_area = mmap (NULL,reads_filesize,PROT_READ,MAP_PRIVATE,reads_fid,0);
+   reads_area = mmap (NULL,reads_filesize,PROT_READ,MAP_PRIVATE,reads_fid,0);
    if (reads_area == MAP_FAILED) {
       perror("mmap");
       exit(EXIT_FAILURE);
    }
 
    close(reads_fid);
-   //printf("Successfully mapped %lu bytes of reads file into memory\n",(unsigned long)reads_filesize);
+   printf("Successfully mapped %lu bytes of reads file into memory\n",(unsigned long)reads_filesize);
                                       
    char* lineBeginPtr = (char*) reads_area;
    char* lineEndPtr = (char*) reads_area;     
@@ -225,11 +272,13 @@ int ParaParser::parseFile(char* reads_filename) {
    int readCtr = 0;
    int status = 0;
 
+   printf("Starting to parse file...\n");
+
    while(1) {
       if (strcmp(current_line,"") == 0) 
          break;
 
-      create_entry_from_line(current_line,format_string);
+      create_entry_from_line(current_line,format_string,lineBeginPtr,lineEndPtr);
 
       if (status != 0 )
          printf("Error while parsing line (status=%d).",status);
@@ -244,10 +293,8 @@ int ParaParser::parseFile(char* reads_filename) {
       readCtr += 1;
    }
 
-   // unmap parsed file
-   status = munmap(reads_area,reads_filesize);
-   if(status != 0)
-      perror("munmap");
+   printf("Successfully parsed file !\n");
+
 
    // free unneeded variables
    free(current_line);
@@ -262,21 +309,46 @@ int ParaParser::parseFile(char* reads_filename) {
  *
  */
 
-PyObject* ParaParser::fetchEntry(int id) {
+PyObject* ParaParser::fetchEntry(map_key_t id) {
    PyObject* line_dict = PyDict_New();
+
    //printf("begin of fetchEntry\n");
    //printf("size of map %d\n",entries->size());
    //printf("keys:\n");
    //MAP::iterator iter;   
    //for(iter = entries->begin(); iter != entries->end(); iter++)
    //   printf("%d\n", iter->first);
-   //printf("query key is %d\n",id);
+   //printf("query key is %lu\n",id);
 
-   MAP::iterator find_it = entries->find(id);
-   if( find_it == entries->end() )
-      return line_dict;
+   char** current_entry;
+
+   char* lineBeginPtr = 0;
+   char* lineEndPtr = 0;
+
+   if ( current_mode == IN_VECTOR ) {
+      //printf("IN_VECTOR mode\n");
+      if (id >= v_entries->size())
+         return line_dict;
+
+      //printf("size %d\n",v_entries->size());
+      current_entry = (*v_entries)[id];
+      pair<char*,char*> ptr_pair = (*v_ptr_entries)[id];
+      lineBeginPtr = ptr_pair.first;
+      lineEndPtr = ptr_pair.second;
+   }
+
+   assert (lineBeginPtr != 0);
+   assert (lineEndPtr != 0);
+
+   if ( current_mode == IN_MAP ) {
+      //printf("IN_MAP mode\n");
+      MAP::iterator find_it = entries->find(id);
+      if( find_it == entries->end() )
+         return line_dict;
+
+      current_entry = (*entries)[id];
+   }
 
-   char** current_entry = (*entries)[id];
 
    int status;
       
@@ -297,12 +369,13 @@ PyObject* ParaParser::fetchEntry(int id) {
          elem = PyString_FromString(current);
 
       if ( strcmp(current_type,"lu")==0 )
-         elem = PyLong_FromString(current,NULL,10);
+         elem = PyString_FromString(current);
+         //elem = PyInt_FromString(current,NULL,10);
+         //elem = PyLong_FromString(current,NULL,10);
          
       if (elem == 0)
          printf("Error: type %s/ elem %s\n",current_type,current);
       
-      //printf("add item\n");
       free(current);
 
       status = PyDict_SetItem(line_dict, PyString_FromString(field_names[idx]), elem);
@@ -316,6 +389,17 @@ PyObject* ParaParser::fetchEntry(int id) {
    //}
    */
 
-   //printf("end of fetchEntry\n");
-   return line_dict;
+   PyObject *return_value = PyTuple_New(2);
+   PyTuple_SetItem(return_value,0,line_dict);
+
+   char* current_line = (char*) malloc(sizeof(char)*512);
+   memset(current_line,0,512);
+   unsigned long line_size = lineEndPtr - lineBeginPtr;
+   strncpy(current_line,lineBeginPtr,line_size-1);
+
+
+   PyObject *original_line = PyString_FromString(current_line);
+   PyTuple_SetItem(return_value,1,original_line);
+
+   return return_value;
 }