+ cleaning up code base
[qpalma.git] / ParaParser / ParaParser.cpp
index 6d019a5..ffbe30e 100644 (file)
@@ -1,9 +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.
@@ -63,48 +77,49 @@ unsigned split_args(char *args, char *** const argv_ptr, const char *delim)
  *
  */
 
-ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries) {
-   assert(num_entries>0);
+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.
+   if ( num_entries < 1 )
+      printf("Error: You need at least one field !\n");
+      
    num_columns = (size_t) num_entries;
-   size_t buf_size = 512;
-   format_string = (char*) malloc(sizeof(char)*buf_size);
-   if (strlen(fmt) > buf_size)
-      perror("format string to long!");
-
-   strncpy(format_string,fmt,strlen(fmt));
 
    // count how many entries are parsed in one line (number of %'s)
    size_t format_num_entries = 0;
    for(size_t fidx=0;fidx<strlen(fmt);fidx++)
-      if (format_string[fidx] == '%')
+      if (fmt[fidx] == '%')
          format_num_entries++;
 
-   if (format_num_entries != num_columns) 
-      printf("Error: For every entry in the format string you have to supply a name!");
+   if (format_num_entries != num_columns) {
+      printf("Error: For every entry in the format string you have to supply a name!\n");
+      exit(EXIT_FAILURE);
+   }
 
+   // copy the field names to the member variable
+   size_t buf_size = 512;
    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]);
    }
 
-   // subtract number of tabs as we don't want them in the parsing
-   char* pruned_format_string = (char*)malloc(sizeof(char*)*strlen(format_string)-num_columns+2);
-   int pruned_idx = 0;
-
-   for(size_t idx=0;idx<strlen(format_string);idx++) {
-      if (format_string[idx] == '\t')
-         continue;
-
-      pruned_format_string[pruned_idx] = format_string[idx];
-      pruned_idx++;
+   char* pruned_format_string = (char*) malloc(sizeof(char)*buf_size);
+   size_t pruned_size = 0;
+   for(size_t idx=0;idx<strlen(fmt);idx++) {
+      pruned_format_string[pruned_size] = fmt[idx];
+      pruned_size++;
    }
-   pruned_format_string[strlen(format_string)-num_columns+1] = '%';
+
+   pruned_format_string[pruned_size] = '%';
+   pruned_format_string[++pruned_size] = '\0';
+   //printf("%s\n",pruned_format_string);
 
    types_list = (char**) malloc(sizeof(char**)*num_columns);
-   printf("types list\n");
    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;
@@ -112,17 +127,35 @@ ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries) {
       types_list[f_idx] = (char*) malloc(sizeof(char*)*strlen(part)+1);
       types_list[f_idx][strlen(part)] = '\0';
       strncpy(types_list[f_idx],part,strlen(part));
-      printf("%s(%d) ",part,strlen(part));
+      //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);
    }
-   printf("\n");
 }
 
+
+
+ParaParser::~ParaParser() {
+   // unmap parsed file
+   int status = munmap(reads_area,reads_filesize);
+   if(status != 0)
+      perror("munmap");
+}
+
+
 /*
  * 
+ *
+ *
  */
 
-void ParaParser::create_entry_from_line(const char* current_line, char* format_string) {
-   printf("current line is %s",current_line);
+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
    char **current_entries = (char**) malloc(sizeof(char*)*num_columns);
@@ -134,33 +167,48 @@ void ParaParser::create_entry_from_line(const char* current_line, char* format_s
    char** line_parts;
    size_t num_parts = split_args(mutable_line,&line_parts,"\t");
 
-   printf("size of map %d\n",entries->size());
-
    for(size_t idx=0; idx<num_columns;idx++) {
       char* col = line_parts[idx];
-      char* current_type = types_list[idx];
 
-      printf("elem:%s\n",col);
+      //printf("elem:%s\n",col);
       current_entries[idx] = (char*) malloc(sizeof(char)*strlen(col)+1);
+      //current_entries2[idx] = string(col);
       strncpy(current_entries[idx],col,strlen(col));
       current_entries[idx][strlen(col)] = '\0';
    }
+   free(mutable_line);
 
-   int id = atoi(current_entries[0]);
-   printf("id is %d\n",id);
-   (*entries)[id] = (void**) current_entries;
-   printf("size of map %d\n",entries->size());
+   map_key_t id = strtoul(current_entries[0],NULL,10);
 
-   free(mutable_line);
+   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());
+   }
 }
 
 
+/*
+ *
+ *
+ *
+ */
 
 int ParaParser::parseFile(char* reads_filename) {
    size_t buf_size = 512;
    char* line = (char*) malloc(sizeof(char)*buf_size);
 
-   printf("open %s\n",reads_filename);
+   //printf("open %s\n",reads_filename);
    FILE *input_fs = fopen(reads_filename,"r");
    if (input_fs == NULL)
       perror("fopen");
@@ -172,7 +220,7 @@ int ParaParser::parseFile(char* reads_filename) {
 
    free(line);
 
-   printf("file has %d lines\n",line_ctr);
+   //printf("file has %d lines\n",line_ctr);
 
    if(input_fs == NULL) {
       printf("Error: Could not open file: %s",reads_filename);
@@ -186,13 +234,19 @@ 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);
+
+   if ( current_mode == IN_VECTOR ) {
+      v_entries = new VECTOR();
+      v_ptr_entries = new PTR_VECTOR();
+   }
 
-   entries = new map<unsigned long,void**,KeyCmp>();
+   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);
@@ -218,11 +272,14 @@ 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);
 
@@ -236,18 +293,12 @@ int ParaParser::parseFile(char* reads_filename) {
       readCtr += 1;
    }
 
-   printf("After parsing lines\n");
+   printf("Successfully parsed file !\n");
 
-   // unmap parsed file
-   status = munmap(reads_area,reads_filesize);
-   if(status != 0)
-      perror("munmap");
 
-   printf("After parsing lines\n");
    // free unneeded variables
    free(current_line);
 
-   printf("After parsing lines\n");
    return readCtr;
 }
 
@@ -258,20 +309,46 @@ int ParaParser::parseFile(char* reads_filename) {
  *
  */
 
-PyObject* ParaParser::fetchEntry(int id) {
-   printf("begin of fetchEntry\n");
+PyObject* ParaParser::fetchEntry(map_key_t id) {
    PyObject* line_dict = PyDict_New();
 
-   printf("size of map %d\n",entries->size());
+   //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 %lu\n",id);
+
+   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);
 
-   map<unsigned long,void**,KeyCmp>::iterator find_it = entries->find((unsigned long)id);
-   if( find_it == entries->end() )
-      return line_dict;
+   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;
 
-   char** current_entry = (char**) (*entries)[id];
+      current_entry = (*entries)[id];
+   }
 
-   int _id = atoi(current_entry[0]);
-   printf("id is %d\n",_id);
 
    int status;
       
@@ -292,26 +369,37 @@ 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);
    }
    
    /*
-   //;
    //for(size_t idx=0;idx<current_read->size;idx++) {
    //   status = PyList_SetItem( prb_list, idx, PyInt_FromLong(current_read->prb[idx]-50) );
    //   status = PyList_SetItem( cal_prb_list, idx, PyInt_FromLong(current_read->cal_prb[idx]-64) );
    //   status = PyList_SetItem( chastity_list, idx, PyInt_FromLong(current_read->chastity[idx]+10) );
    //}
-
    */
 
-   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;
 }