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         if( m_last_dbname != data.GetDBName() ) {
  56                 m_os << "Records for database: " << data.GetDBName() << endl;
  57                 m_last_dbname = data.GetDBName();
  58         }
  59
  60         m_os << "Raw record dump for record: 0x"
  61                 << hex << data.GetUniqueId()
  62                 << ", type: 0x" << hex << (unsigned int) data.GetRecType()
  63                 << ", offset: 0x" << hex << data.GetOffset()
  64                 << endl;
  65         m_os << data.GetData() << endl;
  66 }
  67
  68
  69 //////////////////////////////////////////////////////////////////////////////
  70 // MultiRecordParser class
  71
  72 // takes ownership of default_parser!
  73 MultiRecordParser::MultiRecordParser(Parser *default_parser)
  74         : m_default(default_parser)
  75 {
  76 }
  77
  78 MultiRecordParser::~MultiRecordParser()
  79 {
  80         map_type::iterator i = m_parsers.begin();
  81         for( ; i != m_parsers.end(); ++i ) {
  82                 delete i->second;
  83         }
  84
  85         // and the default parser
  86         delete m_default;
  87 }
  88
  89 void MultiRecordParser::Add(const std::string &dbname, Parser *parser)
  90 {
  91         std::auto_ptr<Parser> p(parser);
  92
  93         map_type::iterator i = m_parsers.find(dbname);
  94         if( i != m_parsers.end() ) {
  95                 // found existing parser, so delete it first
  96                 delete i->second;
  97
  98                 // assign it
  99                 i->second = p.release();
 100         }
 101         else {
 102                 m_parsers[dbname] = p.get();
 103                 p.release();
 104         }
 105 }
 106
 107 // takes ownership of parser!
 108 void MultiRecordParser::Add(RecordParserBase *parser)
 109 {
 110         std::auto_ptr<Parser> p(parser);
 111         std::string name = parser->GetDBName();
 112         Add(name, p.release());
 113 }
 114
 115 bool MultiRecordParser::Add(const std::string &dbname,
 116                                 std::ostream &os)
 117 {
 118         std::auto_ptr<Parser> p;
 119
 120 #undef HANDLE_PARSER
 121 #define HANDLE_PARSER(tname) if( dbname == tname::GetDBName() ) { p.reset( new RecordParser<tname, DumpStore<tname> > (new DumpStore<tname>(os)) ); }
 122
 123         // check for recognized database names
 124         ALL_KNOWN_PARSER_TYPES
 125
 126         if( !p.get() ) {
 127                 // name not known
 128                 return false;
 129         }
 130
 131         Add(dbname, p.release());
 132         return true;
 133 }
 134
 135 bool MultiRecordParser::Add(const std::string &dbname, AllRecordStore &store)
 136 {
 137 #undef HANDLE_PARSER
 138 #define HANDLE_PARSER(tname) \
 139         if( dbname == tname::GetDBName() ) { \
 140                 Add(dbname, new RecordParser<tname, AllRecordStore>(store)); \
 141                 return true; \
 142         }
 143
 144         // check for recognized database names
 145         ALL_KNOWN_PARSER_TYPES
 146
 147         // if we get here, record was not found
 148         return false;
 149 }
 150
 151 // Parser overrides
 152 void MultiRecordParser::ParseRecord(const DBData &data, const IConverter *ic)
 153 {
 154         // search for a named parser
 155         map_type::iterator i = m_parsers.find(data.GetDBName());
 156         if( i != m_parsers.end() ) {
 157                 // found one, use it
 158                 i->second->ParseRecord(data, ic);
 159         }
 160         else if( m_default ) {
 161                 // use default parser
 162                 m_default->ParseRecord(data, ic);
 163         }
 164 }
 165
 166
 167 //////////////////////////////////////////////////////////////////////////////
 168 // AllRecordDumpStore class
 169
 170 // Use the macro here to implement the overrides, so that
 171 // the compiler will catch if we are missing any.
 172 #undef HANDLE_PARSER
 173 #define HANDLE_PARSER(tname) \
 174         void AllRecordDumpStore::operator() (const Barry::tname &r) \
 175         { \
 176                 m_os << r << std::endl; \
 177         }
 178
 179 ALL_KNOWN_PARSER_TYPES
 180
 181
 182 //////////////////////////////////////////////////////////////////////////////
 183 // AllRecordDumpParser class
 184
 185 AllRecordParser::AllRecordParser(std::ostream &os,
 186                                 Parser *default_parser,
 187                                 AllRecordStore *store)
 188         : MultiRecordParser(default_parser)
 189         , m_store(store)
 190 {
 191 #undef HANDLE_PARSER
 192 #define HANDLE_PARSER(tname) if( m_store ) { Add( new RecordParser<tname, AllRecordStore>(*m_store)); } else { Add(tname::GetDBName(), os); }
 193
 194         ALL_KNOWN_PARSER_TYPES;
 195 }
 196
 197 AllRecordParser::~AllRecordParser()
 198 {
 199         delete m_store;
 200 }
 201
 202
 203 //////////////////////////////////////////////////////////////////////////////
 204 // TeeParser class
 205
 206 TeeParser::TeeParser()
 207 {
 208 }
 209
 210 TeeParser::~TeeParser()
 211 {
 212         // free all the owned parser pointers
 213         for( parser_list_type::iterator i = m_owned_parsers.begin();
 214                 i != m_owned_parsers.end();
 215                 ++i )
 216         {
 217                 delete *i;
 218         }
 219 }
 220
 221 // takes ownership of the pointer!
 222 void TeeParser::Add(Parser *p)
 223 {
 224         std::auto_ptr<Parser> ap(p);
 225         m_owned_parsers.push_back(ap.get());
 226         ap.release();
 227 }
 228
 229 // does NOT take ownership
 230 void TeeParser::Add(Parser &p)
 231 {
 232         m_external_parsers.push_back(&p);
 233 }
 234
 235 void TeeParser::ParseRecord(const DBData &data, const IConverter *ic)
 236 {
 237         // call all owned parsers
 238         for( parser_list_type::iterator i = m_owned_parsers.begin();
 239                 i != m_owned_parsers.end();
 240                 ++i )
 241         {
 242                 (*i)->ParseRecord(data, ic);
 243         }
 244
 245         // call all external parsers
 246         for( parser_list_type::iterator i = m_external_parsers.begin();
 247                 i != m_external_parsers.end();
 248                 ++i )
 249         {
 250                 (*i)->ParseRecord(data, ic);
 251         }
 252 }
 253
 254 } // namespace Barry
 255