integrate imc::object into parsing workflow

lib/imc_block.hpp

@@ -37,14 +37,14 @@ namespace imc
     // w.r.t. to first byte of block (=0)
     std::vector<imc::parameter> parameters_;
 
-    // particular imc object
+    // particular imc object represented by this block
     imc::rawobject imc_object_;
 
   public:
 
     // constructor
     block(key thekey, unsigned long int begin, unsigned long int end,
-                      std::string raw_file, std::vector<unsigned char>* buffer):
+                      std::string raw_file, const std::vector<unsigned char>* buffer):
       thekey_(thekey)
     {
       if ( keys.count(thekey.name_) != 1 ) throw std::logic_error("unknown key");
@@ -68,11 +68,14 @@ namespace imc
 
       try {
         parse_parameters();
+        parse_object();
       } catch (const std::exception& e) {
         throw std::runtime_error("block: failed to parse parameters");
       }
     }
 
+  private:
+
     // identify/parse parameters in block
     void parse_parameters()
     {
@@ -94,6 +97,14 @@ namespace imc
       parameters_.back().end( this->end_ - 1 );
     }
 
+    // pass buffer and parameters associated to block to generate corres. object
+    void parse_object()
+    {
+      imc_object_.parse(thekey_,buffer_,parameters_);
+    }
+
+  public:
+
     // access members
     imc::key get_key() { return thekey_; }
     unsigned long int get_begin() { return begin_; }
@@ -119,7 +130,7 @@ namespace imc
     }
 
     // get info string
-    std::string get_info(int width = 20)
+    std::string get_info(bool include_object = true, int width = 20)
     {
       // summarize parameters in single string
       std::string prsstr("{");
@@ -129,12 +140,22 @@ namespace imc
 
       // construct block info string
       std::stringstream ss;
-      ss<<std::setw(width)<<std::left<<"block-key:"<<thekey_.name_<<"\n"
+      ss<<std::setw(width)<<std::left<<"block:"<<thekey_.name_
+                                     <<" ("<<thekey_.description_<<")"<<"\n"
         <<std::setw(width)<<std::left<<"begin:"<<begin_<<"\n"
         <<std::setw(width)<<std::left<<"end:"<<end_<<"\n"
         <<std::setw(width)<<std::left<<"rawfile:"<<raw_file_<<"\n"
         <<std::setw(width)<<std::left<<"buffersize:"<<buffer_->size()<<"\n"
         <<std::setw(width)<<std::left<<"parameters:"<<prsstr<<"\n";
+
+      // include meta data of specific object
+      if ( include_object )
+      {
+        ss<<std::setfill('-')<<std::left<<std::setw(60)<<""<<std::setfill(' ')<<"\n";
+        // ss<<thekey_.description_<<"\n";
+        ss<<imc_object_.get_info()<<"\n";
+      }
+
       return ss.str();
     }
 

lib/imc_key.hpp

@@ -45,7 +45,7 @@ namespace imc
       std::stringstream ss;
       ss<<std::setw(width)<<std::left<<"critical:"<<(critical_?"yes":"no")<<"\n"
         <<std::setw(width)<<std::left<<"name:"<<name_<<"\n"
-        <<std::setw(width)<<std::left<<"decription:"<<description_<<"\n"
+        <<std::setw(width)<<std::left<<"description:"<<description_<<"\n"
         <<std::setw(width)<<std::left<<"version:"<<version_<<"\n";
       return ss.str();
     }

lib/imc_object.hpp

@@ -9,6 +9,30 @@
 
 namespace imc
 {
+  // format and processor (corresponds to key CF)
+  struct format
+  {
+    int fileformat_;
+    int processor_;
+
+    // construct members by parsing particular parameters from buffer
+    void parse(const std::vector<unsigned char>* buffer, const std::vector<parameter> parameters)
+    {
+
+    }
+
+    format(): fileformat_(-1), processor_(-1) {}
+
+    // get info string
+    std::string get_info(int width = 20)
+    {
+      std::stringstream ss;
+      ss<<std::setw(width)<<std::left<<"format:"<<fileformat_<<"\n"
+        <<std::setw(width)<<std::left<<"processor:"<<processor_<<"\n";
+      return ss.str();
+    }
+  };
+
   // start of group of keys (corresponds to key CK)
   struct keygroup
   {
@@ -52,7 +76,7 @@ namespace imc
       std::stringstream ss;
       ss<<std::setw(width)<<std::left<<"group-index:"<<group_index_<<"\n"
         <<std::setw(width)<<std::left<<"name:"<<name_<<"\n"
-        <<std::setw(width)<<std::left<<"comment_:"<<comment_<<"\n";
+        <<std::setw(width)<<std::left<<"comment:"<<comment_<<"\n";
       return ss.str();
     }
   };
@@ -78,7 +102,7 @@ namespace imc
       ss<<std::setw(width)<<std::left<<"group-index:"<<group_index_<<"\n"
         <<std::setw(width)<<std::left<<"name:"<<name_<<"\n"
         <<std::setw(width)<<std::left<<"text:"<<text_<<"\n"
-        <<std::setw(width)<<std::left<<"comment_:"<<comment_<<"\n";
+        <<std::setw(width)<<std::left<<"comment:"<<comment_<<"\n";
       return ss.str();
     }
   };
@@ -111,7 +135,7 @@ namespace imc
       std::stringstream ss;
       ss<<std::setw(width)<<std::left<<"#components:"<<number_components_<<"\n"
         <<std::setw(width)<<std::left<<"fieldtype:"<<fldtype_<<"\n"
-        <<std::setw(width)<<std::left<<"dimension_:"<<dimension_<<"\n";
+        <<std::setw(width)<<std::left<<"dimension:"<<dimension_<<"\n";
       return ss.str();
     }
   };
@@ -347,7 +371,7 @@ namespace imc
       std::stringstream ss;
       ss<<std::setw(width)<<std::left<<"origin:"<<(origin_?"verrechnet":"Original")<<"\n"
         <<std::setw(width)<<std::left<<"generator:"<<generator_<<"\n"
-        <<std::setw(width)<<std::left<<"comment_:"<<comment_<<"\n";
+        <<std::setw(width)<<std::left<<"comment:"<<comment_<<"\n";
       return ss.str();
     }
   };
@@ -378,88 +402,149 @@ namespace imc
 namespace imc {
 
   // create wrapper for imc_object types
-  // (not particular memory-efficient but it simplifies the remaining stuff
+  // (not particularly memory-efficient but it simplifies the remaining stuff
-  // considerable and the structs are pretty small anyway! )
+  // considerably and the structs are pretty small anyway!)
   class rawobject
   {
-    keygroup kyg_;    // 0
+    format fmt_;      // 0
-    group grp_;       // 1
+    keygroup kyg_;    // 1
-    text txt_;        // 2
+    group grp_;       // 2
-    datafield dtf_;   // 3
+    text txt_;        // 3
-    abscissa abs_;    // 4
+    datafield dtf_;   // 4
-    component cmt_;   // 5
+    abscissa abs_;    // 5
-    packaging pkg_;   // 6
+    component cmt_;   // 6
-    buffer bfr_;      // 7
+    packaging pkg_;   // 7
-    range rng_;       // 8
+    buffer bfr_;      // 8
-    channel chn_;     // 9
+    range rng_;       // 9
-    data dat_;        // 10
+    channel chn_;     // 10
-    origin_data org_; // 11
+    data dat_;        // 11
-    triggertime trt_; // 12
+    origin_data org_; // 12
+    triggertime trt_; // 13
+    int objidx_;
+
+  public:
+
+    rawobject(): objidx_(-1) { }
 
     void parse(imc::key key, const std::vector<unsigned char>* buffer,
-                             const std::vector<parameter> parameters)
+                             const std::vector<parameter>& parameters)
     {
-      if ( key.name_ == std::string("CK") )
+      if ( key.name_ == std::string("CF") )
+      {
+        fmt_.parse(buffer,parameters);
+        objidx_ = 0;
+      }
+      else if ( key.name_ == std::string("CK") )
       {
         kyg_.parse(buffer,parameters);
+        objidx_ = 1;
       }
       else if ( key.name_ == std::string("CB") )
       {
         grp_.parse(buffer,parameters);
+        objidx_ = 2;
       }
       else if ( key.name_ == std::string("CT") )
       {
         txt_.parse(buffer,parameters);
+        objidx_ = 3;
       }
       else if ( key.name_ == std::string("CG") )
       {
         dtf_.parse(buffer,parameters);
+        objidx_ = 4;
       }
       else if ( key.name_ == std::string("CD") && key.version_ == 1 )
       {
         abs_.parse(buffer,parameters);
+        objidx_ = 5;
       }
       else if ( key.name_ == std::string("CC") )
       {
         cmt_.parse(buffer,parameters);
+        objidx_ = 6;
       }
       else if ( key.name_ == std::string("CP") )
       {
         cmt_.parse(buffer,parameters);
+        objidx_ = 7;
       }
       else if ( key.name_ == std::string("Cb") )
       {
         bfr_.parse(buffer,parameters);
+        objidx_ = 8;
       }
       else if ( key.name_ == std::string("CR") )
       {
         rng_.parse(buffer,parameters);
+        objidx_ = 9;
       }
       else if ( key.name_ == std::string("CN") )
       {
         chn_.parse(buffer,parameters);
+        objidx_ = 10;
       }
       else if ( key.name_ == std::string("CS") )
       {
         dat_.parse(buffer,parameters);
+        objidx_ = 11;
       }
       else if ( key.name_ == std::string("NO") )
       {
         org_.parse(buffer,parameters);
+        objidx_ = 12;
       }
       else if ( key.name_ == std::string("NT") )
       {
         trt_.parse(buffer,parameters);
+        objidx_ = 13;
+      }
+      else
+      {
+        throw std::logic_error(
+          std::string("unsupported block associated to key ") + key.name_
+        );
       }
     }
 
     // provide info string
     std::string get_info(int width = 20)
     {
+      switch (objidx_) {
+        case 0:
+          return fmt_.get_info();
+        case 1:
           return kyg_.get_info();
+        case 2:
+          return grp_.get_info();
+        case 3:
+          return txt_.get_info();
+        case 4:
+          return dtf_.get_info();
+        case 5:
+          return abs_.get_info();
+        case 6:
+          return cmt_.get_info();
+        case 7:
+          return pkg_.get_info();
+        case 8:
+          return bfr_.get_info();
+        case 9:
+          return rng_.get_info();
+        case 10:
+          return chn_.get_info();
+        case 11:
+          return dat_.get_info();
+        case 12:
+          return org_.get_info();
+        case 13:
+          return trt_.get_info();
+        default:
+          return std::string("");
+      }
     }
-  };
 
+  };
 
 }
 

lib/imc_raw.hpp

@@ -114,7 +114,7 @@ namespace imc
                 }
                 unsigned long length = std::stoul(leng);
 
-                // declare corresponding key and block
+                // declare and initialize corresponding key and block
                 imc::key bkey( *(it+1)==imc::key_crit_ , newkey,
                                imc::keys.at(newkey).description_, version );
                 imc::block blk(bkey,it-buffer_.begin(),
@@ -165,14 +165,7 @@ namespace imc
       }
     }
 
-    // // extract imc objects
+    // parse channel's raw data
-    // void list_keygroup()
-    // {
-    //   for ( auto &blk: this->rawblocks_ )
-    //   {
-    //     if ( blk.get_key().name_ == std::string("CK") )
-    //   }
-    // }
 
   public:
 
@@ -194,15 +187,6 @@ namespace imc
       return cplxcnt_;
     }
 
-    // collect meta data
-    void parse_meta()
-    {
-
-
-    }
-
-    // parse channel's raw data
-
   };
 
 }

src/main.cpp

@@ -173,7 +173,7 @@ int main(int argc, char* argv[])
     // list blocks
     for ( imc::block blk: imcraw.blocks() )
     {
-      std::cout<<blk.get_key().get_info()<<"\n";
+      // std::cout<<blk.get_key().get_info()<<"\n";
       std::cout<<blk.get_info()<<"\n";
     }
     std::cout<<"number of blocks: "<<imcraw.blocks().size()<<"\n";