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 #define ALL_KNOWN_RECORD_TYPES \
  41         HANDLE_TYPE(Contact) \
  42         HANDLE_TYPE(Message) \
  43         HANDLE_TYPE(Calendar) \
  44         HANDLE_TYPE(CalendarAll) \
  45         HANDLE_TYPE(CallLog) \
  46         HANDLE_TYPE(Bookmark) \
  47         HANDLE_TYPE(ServiceBook) \
  48         HANDLE_TYPE(Memo) \
  49         HANDLE_TYPE(Task) \
  50         HANDLE_TYPE(PINMessage) \
  51         HANDLE_TYPE(SavedMessage) \
  52         HANDLE_TYPE(Sms) \
  53         HANDLE_TYPE(Folder) \
  54         HANDLE_TYPE(Timezone)
  55
  56 namespace Barry {
  57
  58 //////////////////////////////////////////////////////////////////////////////
  59 // HexDumpParser class
  60
  61 HexDumpParser::HexDumpParser(std::ostream &os)
  62         : m_os(os)
  63 {
  64 }
  65
  66 void HexDumpParser::ParseRecord(const Barry::DBData &data,
  67                                 const IConverter *ic)
  68 {
  69         m_os << "Raw record dump for record: "
  70                 << std::hex << data.GetUniqueId() << std::endl;
  71         m_os << data.GetData() << std::endl;
  72 }
  73
  74
  75 //////////////////////////////////////////////////////////////////////////////
  76 // MultiRecordParser class
  77
  78 // takes ownership of default_parser!
  79 MultiRecordParser::MultiRecordParser(Parser *default_parser)
  80         : m_default(default_parser)
  81 {
  82 }
  83
  84 MultiRecordParser::~MultiRecordParser()
  85 {
  86         map_type::iterator i = m_parsers.begin();
  87         for( ; i != m_parsers.end(); ++i ) {
  88                 delete i->second;
  89         }
  90
  91         // and the default parser
  92         delete m_default;
  93 }
  94
  95 void MultiRecordParser::Add(const std::string &dbname, Parser *parser)
  96 {
  97         std::auto_ptr<Parser> p(parser);
  98
  99         map_type::iterator i = m_parsers.find(dbname);
 100         if( i != m_parsers.end() ) {
 101                 // found existing parser, so delete it first
 102                 delete i->second;
 103
 104                 // assign it
 105                 i->second = p.release();
 106         }
 107         else {
 108                 m_parsers[dbname] = p.get();
 109                 p.release();
 110         }
 111 }
 112
 113 // takes ownership of parser!
 114 void MultiRecordParser::Add(RecordParserBase *parser)
 115 {
 116         std::auto_ptr<Parser> p(parser);
 117         std::string name = parser->GetDBName();
 118         Add(name, p.release());
 119 }
 120
 121 bool MultiRecordParser::Add(const std::string &dbname,
 122                                 std::ostream &os)
 123 {
 124         std::auto_ptr<Parser> p;
 125
 126 #undef HANDLE_TYPE
 127 #define HANDLE_TYPE(tname) if( dbname == tname::GetDBName() ) { p.reset( new RecordParser<tname, DumpStore<tname> > (new DumpStore<tname>(os)) ); }
 128
 129         // check for recognized database names
 130         ALL_KNOWN_RECORD_TYPES
 131
 132         if( !p.get() ) {
 133                 // name not known
 134                 return false;
 135         }
 136
 137         Add(dbname, p.release());
 138         return true;
 139 }
 140
 141 // Parser overrides
 142 void MultiRecordParser::ParseRecord(const DBData &data, const IConverter *ic)
 143 {
 144         // search for a named parser
 145         map_type::iterator i = m_parsers.find(data.GetDBName());
 146         if( i != m_parsers.end() ) {
 147                 // found one, use it
 148                 i->second->ParseRecord(data, ic);
 149         }
 150         else if( m_default ) {
 151                 // use default parser
 152                 m_default->ParseRecord(data, ic);
 153         }
 154 }
 155
 156
 157 //////////////////////////////////////////////////////////////////////////////
 158 // AllRecordDumpStore class
 159
 160 void AllRecordDumpStore::operator() (const Barry::Contact &r)
 161 {
 162         m_os << r << std::endl;
 163 }
 164
 165 void AllRecordDumpStore::operator() (const Barry::Message &r)
 166 {
 167         m_os << r << std::endl;
 168 }
 169
 170 void AllRecordDumpStore::operator() (const Barry::Calendar &r)
 171 {
 172         m_os << r << std::endl;
 173 }
 174
 175 void AllRecordDumpStore::operator() (const Barry::CalendarAll &r)
 176 {
 177         m_os << r << std::endl;
 178 }
 179
 180 void AllRecordDumpStore::operator() (const Barry::CallLog &r)
 181 {
 182         m_os << r << std::endl;
 183 }
 184
 185 void AllRecordDumpStore::operator() (const Barry::Bookmark &r)
 186 {
 187         m_os << r << std::endl;
 188 }
 189
 190 void AllRecordDumpStore::operator() (const Barry::ServiceBook &r)
 191 {
 192         m_os << r << std::endl;
 193 }
 194
 195 void AllRecordDumpStore::operator() (const Barry::Memo &r)
 196 {
 197         m_os << r << std::endl;
 198 }
 199
 200 void AllRecordDumpStore::operator() (const Barry::Task &r)
 201 {
 202         m_os << r << std::endl;
 203 }
 204
 205 void AllRecordDumpStore::operator() (const Barry::PINMessage &r)
 206 {
 207         m_os << r << std::endl;
 208 }
 209
 210 void AllRecordDumpStore::operator() (const Barry::SavedMessage &r)
 211 {
 212         m_os << r << std::endl;
 213 }
 214
 215 void AllRecordDumpStore::operator() (const Barry::Sms &r)
 216 {
 217         m_os << r << std::endl;
 218 }
 219
 220 void AllRecordDumpStore::operator() (const Barry::Folder &r)
 221 {
 222         m_os << r << std::endl;
 223 }
 224
 225 void AllRecordDumpStore::operator() (const Barry::Timezone &r)
 226 {
 227         m_os << r << std::endl;
 228 }
 229
 230
 231 //////////////////////////////////////////////////////////////////////////////
 232 // AllRecordDumpParser class
 233
 234 AllRecordParser::AllRecordParser(std::ostream &os,
 235                                 Parser *default_parser,
 236                                 AllRecordStore *store)
 237         : MultiRecordParser(default_parser)
 238         , m_store(store)
 239 {
 240 #undef HANDLE_TYPE
 241 #define HANDLE_TYPE(tname) if( m_store ) { Add( new RecordParser<tname, AllRecordStore>(*m_store)); } else { Add(tname::GetDBName(), os); }
 242
 243         ALL_KNOWN_RECORD_TYPES;
 244 }
 245
 246 AllRecordParser::~AllRecordParser()
 247 {
 248         delete m_store;
 249 }
 250
 251
 252 //////////////////////////////////////////////////////////////////////////////
 253 // TeeParser class
 254
 255 TeeParser::TeeParser()
 256 {
 257 }
 258
 259 TeeParser::~TeeParser()
 260 {
 261         // free all the owned parser pointers
 262         for( parser_list_type::iterator i = m_owned_parsers.begin();
 263                 i != m_owned_parsers.end();
 264                 ++i )
 265         {
 266                 delete *i;
 267         }
 268 }
 269
 270 // takes ownership of the pointer!
 271 void TeeParser::Add(Parser *p)
 272 {
 273         std::auto_ptr<Parser> ap(p);
 274         m_owned_parsers.push_back(ap.get());
 275         ap.release();
 276 }
 277
 278 // does NOT take ownership
 279 void TeeParser::Add(Parser &p)
 280 {
 281         m_external_parsers.push_back(&p);
 282 }
 283
 284 void TeeParser::ParseRecord(const DBData &data, const IConverter *ic)
 285 {
 286         // call all owned parsers
 287         for( parser_list_type::iterator i = m_owned_parsers.begin();
 288                 i != m_owned_parsers.end();
 289                 ++i )
 290         {
 291                 (*i)->ParseRecord(data, ic);
 292         }
 293
 294         // call all external parsers
 295         for( parser_list_type::iterator i = m_external_parsers.begin();
 296                 i != m_external_parsers.end();
 297                 ++i )
 298         {
 299                 (*i)->ParseRecord(data, ic);
 300         }
 301 }
 302
 303 } // namespace Barry
 304