src/parser.cc

   1 ///
   2 /// \file       parser.cc
   3 ///             Virtual parser wrapper
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2012, 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 "i18n.h"
  23 #include "parser.h"
  24 #include "r_calendar.h"
  25 #include "r_calllog.h"
  26 #include "r_bookmark.h"
  27 #include "r_contact.h"
  28 #include "r_memo.h"
  29 #include "r_message.h"
  30 #include "r_servicebook.h"
  31 #include "r_task.h"
  32 #include "r_pin_message.h"
  33 #include "r_saved_message.h"
  34 #include "r_sms.h"
  35 #include "r_folder.h"
  36 #include "r_timezone.h"
  37 #include "r_cstore.h"
  38 #include "r_hhagent.h"
  39 #include "ios_state.h"
  40
  41 #include <iostream>
  42 #include <memory>
  43
  44 using namespace std;
  45
  46 namespace Barry {
  47
  48 //////////////////////////////////////////////////////////////////////////////
  49 // HexDumpParser class
  50
  51 HexDumpParser::HexDumpParser(std::ostream &os)
  52         : m_os(os)
  53 {
  54 }
  55
  56 void HexDumpParser::ParseRecord(const Barry::DBData &data,
  57                                 const IConverter *ic)
  58 {
  59         ios_format_state state(m_os);
  60
  61         if( m_last_dbname != data.GetDBName() ) {
  62                 m_os << _("Records for database: ") << data.GetDBName() << endl;
  63                 m_last_dbname = data.GetDBName();
  64         }
  65
  66         m_os << _("Raw record dump for record: ") << "0x"
  67                 << hex << data.GetUniqueId()
  68                 << ", " << _("type: ")
  69                 << "0x" << hex << (unsigned int) data.GetRecType()
  70                 << ", " << _("offset: ")
  71                 << "0x" << hex << data.GetOffset()
  72                 << endl;
  73         m_os << data.GetData() << endl;
  74 }
  75
  76
  77 //////////////////////////////////////////////////////////////////////////////
  78 // MultiRecordParser class
  79
  80 // takes ownership of default_parser!
  81 MultiRecordParser::MultiRecordParser(Parser *default_parser)
  82         : m_delete_default(default_parser) // takes ownership
  83         , m_default(default_parser)
  84 {
  85 }
  86
  87 // does not take ownership of the default_parser
  88 MultiRecordParser::MultiRecordParser(Parser &default_parser)
  89         : m_delete_default(0)   // no ownership of reference
  90         , m_default(&default_parser)
  91 {
  92 }
  93
  94 MultiRecordParser::~MultiRecordParser()
  95 {
  96         map_type::iterator i = m_parsers.begin();
  97         for( ; i != m_parsers.end(); ++i ) {
  98                 delete i->second;
  99         }
 100
 101         // and the default parser
 102         delete m_delete_default;
 103 }
 104
 105 void MultiRecordParser::Add(const std::string &dbname, Parser *parser)
 106 {
 107         std::auto_ptr<Parser> p(parser);
 108
 109         map_type::iterator i = m_parsers.find(dbname);
 110         if( i != m_parsers.end() ) {
 111                 // found existing parser, so delete it first
 112                 delete i->second;
 113
 114                 // assign it
 115                 i->second = p.release();
 116         }
 117         else {
 118                 m_parsers[dbname] = p.get();
 119                 p.release();
 120         }
 121 }
 122
 123 // takes ownership of parser!
 124 void MultiRecordParser::Add(RecordParserBase *parser)
 125 {
 126         std::auto_ptr<Parser> p(parser);
 127         std::string name = parser->GetDBName();
 128         Add(name, p.release());
 129 }
 130
 131 bool MultiRecordParser::Add(const std::string &dbname,
 132                                 std::ostream &os)
 133 {
 134         std::auto_ptr<Parser> p;
 135
 136 #undef HANDLE_PARSER
 137 #define HANDLE_PARSER(tname) if( dbname == tname::GetDBName() ) { p.reset( new RecordParser<tname, DumpStore<tname> > (new DumpStore<tname>(os)) ); }
 138
 139         // check for recognized database names
 140         ALL_KNOWN_PARSER_TYPES
 141
 142         if( !p.get() ) {
 143                 // name not known
 144                 return false;
 145         }
 146
 147         Add(dbname, p.release());
 148         return true;
 149 }
 150
 151 bool MultiRecordParser::Add(const std::string &dbname, AllRecordStore &store)
 152 {
 153 #undef HANDLE_PARSER
 154 #define HANDLE_PARSER(tname) \
 155         if( dbname == tname::GetDBName() ) { \
 156                 Add(dbname, new RecordParser<tname, AllRecordStore>(store)); \
 157                 return true; \
 158         }
 159
 160         // check for recognized database names
 161         ALL_KNOWN_PARSER_TYPES
 162
 163         // if we get here, record was not found
 164         return false;
 165 }
 166
 167 // Parser overrides
 168 void MultiRecordParser::ParseRecord(const DBData &data, const IConverter *ic)
 169 {
 170         // search for a named parser
 171         map_type::iterator i = m_parsers.find(data.GetDBName());
 172         if( i != m_parsers.end() ) {
 173                 // found one, use it
 174                 i->second->ParseRecord(data, ic);
 175         }
 176         else if( m_default ) {
 177                 // use default parser
 178                 m_default->ParseRecord(data, ic);
 179         }
 180 }
 181
 182
 183 //////////////////////////////////////////////////////////////////////////////
 184 // AllRecordDumpStore class
 185
 186 // Use the macro here to implement the overrides, so that
 187 // the compiler will catch if we are missing any.
 188 #undef HANDLE_PARSER
 189 #define HANDLE_PARSER(tname) \
 190         void AllRecordDumpStore::operator() (const Barry::tname &r) \
 191         { \
 192                 m_os << r << std::endl; \
 193         }
 194
 195 ALL_KNOWN_PARSER_TYPES
 196
 197
 198 //////////////////////////////////////////////////////////////////////////////
 199 // AllRecordDumpParser class
 200
 201 AllRecordParser::AllRecordParser(std::ostream &os,
 202                                 Parser *default_parser,
 203                                 AllRecordStore *store)
 204         : MultiRecordParser(default_parser)
 205         , m_store(store)        // takes ownership here
 206 {
 207         AddRecords(&os, store);
 208 }
 209
 210 // does not take ownership of default_parser or store
 211 AllRecordParser::AllRecordParser(Parser &default_parser, AllRecordStore &store)
 212         : MultiRecordParser(default_parser)
 213         , m_store(0)
 214 {
 215         AddRecords(0, &store);
 216 }
 217
 218 AllRecordParser::~AllRecordParser()
 219 {
 220         delete m_store;
 221 }
 222
 223 void AllRecordParser::AddRecords(std::ostream *os, AllRecordStore *store)
 224 {
 225         // Does not allow RecordParser<> to own store, since we're using
 226         // it multiple times as the same store for each record type.
 227 #undef HANDLE_PARSER
 228 #define HANDLE_PARSER(tname) \
 229         if( store ) { \
 230                 Add( new RecordParser<tname, AllRecordStore>(*store)); \
 231         } else if( os ) { \
 232                 Add(tname::GetDBName(), *os); \
 233         }
 234
 235         ALL_KNOWN_PARSER_TYPES;
 236 }
 237
 238
 239 //////////////////////////////////////////////////////////////////////////////
 240 // TeeParser class
 241
 242 TeeParser::TeeParser()
 243 {
 244 }
 245
 246 TeeParser::~TeeParser()
 247 {
 248         // free all the owned parser pointers
 249         for( parser_list_type::iterator i = m_owned_parsers.begin();
 250                 i != m_owned_parsers.end();
 251                 ++i )
 252         {
 253                 delete *i;
 254         }
 255 }
 256
 257 // takes ownership of the pointer!
 258 void TeeParser::Add(Parser *p)
 259 {
 260         std::auto_ptr<Parser> ap(p);
 261         m_owned_parsers.push_back(ap.get());
 262         ap.release();
 263 }
 264
 265 // does NOT take ownership
 266 void TeeParser::Add(Parser &p)
 267 {
 268         m_external_parsers.push_back(&p);
 269 }
 270
 271 void TeeParser::ParseRecord(const DBData &data, const IConverter *ic)
 272 {
 273         // call all owned parsers
 274         for( parser_list_type::iterator i = m_owned_parsers.begin();
 275                 i != m_owned_parsers.end();
 276                 ++i )
 277         {
 278                 (*i)->ParseRecord(data, ic);
 279         }
 280
 281         // call all external parsers
 282         for( parser_list_type::iterator i = m_external_parsers.begin();
 283                 i != m_external_parsers.end();
 284                 ++i )
 285         {
 286                 (*i)->ParseRecord(data, ic);
 287         }
 288 }
 289
 290 } // namespace Barry
 291