+ added some assertions
authorfabio <fabio@e1793c9e-67f9-0310-80fc-b846ff1f7b36>
Mon, 2 Jun 2008 14:15:03 +0000 (14:15 +0000)
committerfabio <fabio@e1793c9e-67f9-0310-80fc-b846ff1f7b36>
Mon, 2 Jun 2008 14:15:03 +0000 (14:15 +0000)
+ fixed bug for smaller format strings

git-svn-id: http://svn.tuebingen.mpg.de/ag-raetsch/projects/QPalma@9333 e1793c9e-67f9-0310-80fc-b846ff1f7b36

ParaParser/.ParaParser.cpp.swp
ParaParser/ParaParser.cpp
ParaParser/ParaParser.h
ParaParser/simple_example.py
ParaParser/test.data

index e92973b..43117d0 100644 (file)
Binary files a/ParaParser/.ParaParser.cpp.swp and b/ParaParser/.ParaParser.cpp.swp differ
index 6d019a5..c7c3151 100644 (file)
@@ -3,6 +3,8 @@
 #include <stdlib.h>
 #include <sys/mman.h>
 #include <sys/stat.h>
+#include <string>
+using namespace std;
 
 
 /**
@@ -64,47 +66,45 @@ unsigned split_args(char *args, char *** const argv_ptr, const char *delim)
  */
 
 ParaParser::ParaParser(const char* fmt, char** _fields, int num_entries) {
+   // check that we have more than zero entries and that the format string
+   // contains exactly num_entries format elements.
    assert(num_entries>0);
-   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));
+   num_columns = (size_t) num_entries;
 
    // 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]));
    }
 
-   // 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 +112,20 @@ 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");
+   //printf("\n");
 }
 
+
 /*
  * 
+ *
+ *
  */
 
 void ParaParser::create_entry_from_line(const char* current_line, char* format_string) {
-   printf("current line is %s",current_line);
+   //printf("current line is %s",current_line);
    
    // create an array of void ptrs
    char **current_entries = (char**) malloc(sizeof(char*)*num_columns);
@@ -134,33 +137,37 @@ 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());
+   //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());
 
-   free(mutable_line);
 }
 
 
+/*
+ *
+ *
+ *
+ */
 
 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 +179,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);
@@ -189,7 +196,7 @@ int ParaParser::parseFile(char* reads_filename) {
    off_t reads_filesize = reads_stat.st_size;
    //printf("Reads file is of size %lu bytes\n",(unsigned long) reads_filesize);
 
-   entries = new map<unsigned long,void**,KeyCmp>();
+   entries = new MAP();
 
    // try to acquire file using mmap
    void *reads_area = mmap (NULL,reads_filesize,PROT_READ,MAP_PRIVATE,reads_fid,0);
@@ -199,7 +206,7 @@ int ParaParser::parseFile(char* reads_filename) {
    }
 
    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;     
@@ -223,6 +230,7 @@ int ParaParser::parseFile(char* reads_filename) {
          break;
 
       create_entry_from_line(current_line,format_string);
+
       if (status != 0 )
          printf("Error while parsing line (status=%d).",status);
 
@@ -236,18 +244,14 @@ int ParaParser::parseFile(char* reads_filename) {
       readCtr += 1;
    }
 
-   printf("After parsing lines\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;
 }
 
@@ -259,19 +263,20 @@ int ParaParser::parseFile(char* reads_filename) {
  */
 
 PyObject* ParaParser::fetchEntry(int id) {
-   printf("begin of fetchEntry\n");
    PyObject* line_dict = PyDict_New();
-
-   printf("size of map %d\n",entries->size());
-
-   map<unsigned long,void**,KeyCmp>::iterator find_it = entries->find((unsigned long)id);
+   //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);
+
+   MAP::iterator find_it = entries->find(id);
    if( find_it == entries->end() )
       return line_dict;
 
-   char** current_entry = (char**) (*entries)[id];
-
-   int _id = atoi(current_entry[0]);
-   printf("id is %d\n",_id);
+   char** current_entry = (*entries)[id];
 
    int status;
       
@@ -297,21 +302,20 @@ PyObject* ParaParser::fetchEntry(int id) {
       if (elem == 0)
          printf("Error: type %s/ elem %s\n",current_type,current);
       
-      printf("add item\n");
+      //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");
+   //printf("end of fetchEntry\n");
    return line_dict;
 }
index 2a5ba00..b7cf739 100644 (file)
@@ -6,12 +6,15 @@
 using namespace std;
 
 struct KeyCmp {
-   bool operator()( unsigned long s1, unsigned long s2 ) const {
-          return ( s1 == s2 );
+   //bool operator()( unsigned long s1, unsigned long s2 ) const {
+   bool operator()( int s1, int s2 ) const {
+          return ( s1 < s2 );
    }
 };
 
 
+typedef map<unsigned long,char**,KeyCmp> MAP;
+
 class ParaParser{
 
    private:
@@ -20,7 +23,7 @@ class ParaParser{
       size_t num_columns;
       char** types_list;
 
-      map<unsigned long,void**,KeyCmp> *entries;
+      MAP *entries;
 
    public:
       ParaParser(const char* fmt, char** _fields, int num_entries);
index 1d018b5..9f4bd57 100644 (file)
@@ -7,12 +7,27 @@ from ParaParser import *
 def run(file):
    parser = ParaParser("%d%s%s%d%d",["field0","field1","field2","field3","field4"],5)
    parser.parseFile(file)
-   print "After parseFile call..."
    entry1_dict = parser.fetchEntry(1111)
-   print "Fetching entry..."
    print entry1_dict
    entry2_dict = parser.fetchEntry(2222)
    print entry2_dict
+   entry3_dict = parser.fetchEntry(3333)
+   print entry3_dict
+
+   del parser
+
+   parser2 = ParaParser("%d%s",["field0","field1"],2)
+   file = 'test2.data'
+   parser2.parseFile(file)
+   entry1_dict = parser2.fetchEntry(1111)
+   print entry1_dict
+
+   parser2 = ParaParser("%d%s",["field0","field1"],2)
+   file = 'test2.data'
+   parser2.parseFile(file)
+   entry1_dict = parser2.fetchEntry(1111)
+   print entry1_dict
+
 
 if __name__ == '__main__':
    run('test.data')
index 75f7d37..eba276f 100644 (file)
@@ -1,2 +1,3 @@
 1111   alpha   beta    1       2
 2222   gamma    delta  99      100
+3333   theta    delta  77      101