src/parser.cc

   1 ///
   2 /// \file       parser.cc
   3 ///             Virtual parser wrapper
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2010, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "parser.h"
  23 #include "r_calendar.h"
  24 #include "r_calllog.h"
  25 #include "r_bookmark.h"
  26 #include "r_contact.h"
  27 #include "r_memo.h"
  28 #include "r_message.h"
  29 #include "r_servicebook.h"
  30 #include "r_task.h"
  31 #include "r_pin_message.h"
  32 #include "r_saved_message.h"
  33 #include "r_sms.h"
  34 #include "r_folder.h"
  35 #include "r_timezone.h"
  36
  37 #include <iostream>
  38 #include <memory>
  39
  40 using namespace std;
  41
  42 namespace Barry {
  43
  44 //////////////////////////////////////////////////////////////////////////////
  45 // HexDumpParser class
  46
  47 HexDumpParser::HexDumpParser(std::ostream &os)
  48         : m_os(os)
  49 {
  50 }
  51
  52 void HexDumpParser::ParseRecord(const Barry::DBData &data,
  53                                 const IConverter *ic)
  54 {
  55         m_os << "Raw record dump for record: 0x"
  56                 << hex << data.GetUniqueId()
  57                 << ", type: 0x" << hex << data.GetRecType()
  58                 << ", offset: 0x" << hex << data.GetOffset()
  59                 << endl;
  60         m_os << data.GetData() << std::endl;
  61 }
  62
  63
  64 //////////////////////////////////////////////////////////////////////////////
  65 // MultiRecordParser class
  66
  67 // takes ownership of default_parser!
  68 MultiRecordParser::MultiRecordParser(Parser *default_parser)
  69         : m_default(default_parser)
  70 {
  71 }
  72
  73 MultiRecordParser::~MultiRecordParser()
  74 {
  75         map_type::iterator i = m_parsers.begin();
  76         for( ; i != m_parsers.end(); ++i ) {
  77                 delete i->second;
  78         }
  79
  80         // and the default parser
  81         delete m_default;
  82 }
  83
  84 void MultiRecordParser::Add(const std::string &dbname, Parser *parser)
  85 {
  86         std::auto_ptr<Parser> p(parser);
  87
  88         map_type::iterator i = m_parsers.find(dbname);
  89         if( i != m_parsers.end() ) {
  90                 // found existing parser, so delete it first
  91                 delete i->second;
  92
  93                 // assign it
  94                 i->second = p.release();
  95         }
  96         else {
  97                 m_parsers[dbname] = p.get();
  98                 p.release();
  99         }
 100 }
 101
 102 // takes ownership of parser!
 103 void MultiRecordParser::Add(RecordParserBase *parser)
 104 {
 105         std::auto_ptr<Parser> p(parser);
 106         std::string name = parser->GetDBName();
 107         Add(name, p.release());
 108 }
 109
 110 bool MultiRecordParser::Add(const std::string &dbname,
 111                                 std::ostream &os)
 112 {
 113         std::auto_ptr<Parser> p;
 114
 115 #undef HANDLE_PARSER
 116 #define HANDLE_PARSER(tname) if( dbname == tname::GetDBName() ) { p.reset( new RecordParser<tname, DumpStore<tname> > (new DumpStore<tname>(os)) ); }
 117
 118         // check for recognized database names
 119         ALL_KNOWN_PARSER_TYPES
 120
 121         if( !p.get() ) {
 122                 // name not known
 123                 return false;
 124         }
 125
 126         Add(dbname, p.release());
 127         return true;
 128 }
 129
 130 bool MultiRecordParser::Add(const std::string &dbname, AllRecordStore &store)
 131 {
 132 #undef HANDLE_PARSER
 133 #define HANDLE_PARSER(tname) \
 134         if( dbname == tname::GetDBName() ) { \
 135                 Add(dbname, new RecordParser<tname, AllRecordStore>(store)); \
 136                 return true; \
 137         }
 138
 139         // check for recognized database names
 140         ALL_KNOWN_PARSER_TYPES
 141
 142         // if we get here, record was not found
 143         return false;
 144 }
 145
 146 // Parser overrides
 147 void MultiRecordParser::ParseRecord(const DBData &data, const IConverter *ic)
 148 {
 149         // search for a named parser
 150         map_type::iterator i = m_parsers.find(data.GetDBName());
 151         if( i != m_parsers.end() ) {
 152                 // found one, use it
 153                 i->second->ParseRecord(data, ic);
 154         }
 155         else if( m_default ) {
 156                 // use default parser
 157                 m_default->ParseRecord(data, ic);
 158         }
 159 }
 160
 161
 162 //////////////////////////////////////////////////////////////////////////////
 163 // AllRecordDumpStore class
 164
 165 // Use the macro here to implement the overrides, so that
 166 // the compiler will catch if we are missing any.
 167 #undef HANDLE_PARSER
 168 #define HANDLE_PARSER(tname) \
 169         void AllRecordDumpStore::operator() (const Barry::tname &r) \
 170         { \
 171                 m_os << r << std::endl; \
 172         }
 173
 174 ALL_KNOWN_PARSER_TYPES
 175
 176
 177 //////////////////////////////////////////////////////////////////////////////
 178 // AllRecordDumpParser class
 179
 180 AllRecordParser::AllRecordParser(std::ostream &os,
 181                                 Parser *default_parser,
 182                                 AllRecordStore *store)
 183         : MultiRecordParser(default_parser)
 184         , m_store(store)
 185 {
 186 #undef HANDLE_PARSER
 187 #define HANDLE_PARSER(tname) if( m_store ) { Add( new RecordParser<tname, AllRecordStore>(*m_store)); } else { Add(tname::GetDBName(), os); }
 188
 189         ALL_KNOWN_PARSER_TYPES;
 190 }
 191
 192 AllRecordParser::~AllRecordParser()
 193 {
 194         delete m_store;
 195 }
 196
 197
 198 //////////////////////////////////////////////////////////////////////////////
 199 // TeeParser class
 200
 201 TeeParser::TeeParser()
 202 {
 203 }
 204
 205 TeeParser::~TeeParser()
 206 {
 207         // free all the owned parser pointers
 208         for( parser_list_type::iterator i = m_owned_parsers.begin();
 209                 i != m_owned_parsers.end();
 210                 ++i )
 211         {
 212                 delete *i;
 213         }
 214 }
 215
 216 // takes ownership of the pointer!
 217 void TeeParser::Add(Parser *p)
 218 {
 219         std::auto_ptr<Parser> ap(p);
 220         m_owned_parsers.push_back(ap.get());
 221         ap.release();
 222 }
 223
 224 // does NOT take ownership
 225 void TeeParser::Add(Parser &p)
 226 {
 227         m_external_parsers.push_back(&p);
 228 }
 229
 230 void TeeParser::ParseRecord(const DBData &data, const IConverter *ic)
 231 {
 232         // call all owned parsers
 233         for( parser_list_type::iterator i = m_owned_parsers.begin();
 234                 i != m_owned_parsers.end();
 235                 ++i )
 236         {
 237                 (*i)->ParseRecord(data, ic);
 238         }
 239
 240         // call all external parsers
 241         for( parser_list_type::iterator i = m_external_parsers.begin();
 242                 i != m_external_parsers.end();
 243                 ++i )
 244         {
 245                 (*i)->ParseRecord(data, ic);
 246         }
 247 }
 248
 249 } // namespace Barry
 250