src/s11n-boost.h

   1 ///
   2 /// \file       s11n-boost.h
   3 ///             Non-intrusive versions of serialization functions for the
   4 ///             record classes.  These template functions make it possible
   5 ///             to use the record classes with the Boost::Serialization
   6 ///             library.
   7 ///
   8
   9 /*
  10     Copyright (C) 2005-2011, Net Direct Inc. (http://www.netdirect.ca/)
  11
  12     This program is free software; you can redistribute it and/or modify
  13     it under the terms of the GNU General Public License as published by
  14     the Free Software Foundation; either version 2 of the License, or
  15     (at your option) any later version.
  16
  17     This program is distributed in the hope that it will be useful,
  18     but WITHOUT ANY WARRANTY; without even the implied warranty of
  19     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  20
  21     See the GNU General Public License in the COPYING file at the
  22     root directory of this project for more details.
  23 */
  24
  25 #ifndef __BARRY_S11N_BOOST_H__
  26 #define __BARRY_S11N_BOOST_H__
  27
  28 #include "dll.h"
  29 #include "record.h"
  30 #include <boost/serialization/vector.hpp>
  31
  32 ///////////////////////////////////////////////////////////////////////////////
  33 // special versions
  34 //
  35 // BARRY_BASE_S11N_VERSION      - the base version where all record data is
  36 //                                stored so it can be fully retrieved and
  37 //                                uploaded to the handheld device later.
  38 // BARRY_POD_MAP_VERSION        - if these templates are called with a version
  39 //                                equal or greater than this, only mappable,
  40 //                                POD data is included in the serialization
  41 //
  42 #define BARRY_BASE_S11N_VERSION         0
  43 #define BARRY_POD_MAP_VERSION           1000
  44
  45 // namespace boost::serialization, for the non-intrusive version
  46 namespace boost {
  47 namespace serialization {
  48
  49 template <class ArchiveT>
  50 void serialize(ArchiveT &ar, Barry::UnknownField &uf, const unsigned int ver)
  51 {
  52         ar & make_nvp("type", uf.type);
  53         ar & make_nvp("data", uf.data.raw_data);
  54 }
  55
  56 template <class ArchiveT>
  57 void serialize(ArchiveT &ar, Barry::Contact::GroupLink &g, const unsigned int ver)
  58 {
  59         ar & make_nvp("Link", g.Link);
  60         ar & make_nvp("Unknown", g.Unknown);
  61 }
  62
  63 template <class ArchiveT>
  64 void serialize(ArchiveT &ar, Barry::CategoryList &cl, const unsigned int ver)
  65 {
  66         std::vector<std::string> &sl = cl;
  67         ar & make_nvp("CategoryList", sl);
  68 }
  69
  70 template <class ArchiveT>
  71 void serialize(ArchiveT &ar, Barry::Contact &c, const unsigned int ver)
  72 {
  73         ar & make_nvp("RecType", c.RecType);
  74         ar & make_nvp("RecordId", c.RecordId);
  75
  76         ar & make_nvp("EmailAddresses", c.EmailAddresses);
  77         ar & make_nvp("Phone", c.Phone);
  78         ar & make_nvp("Fax", c.Fax);
  79         ar & make_nvp("HomeFax", c.HomeFax);
  80         ar & make_nvp("WorkPhone", c.WorkPhone);
  81         ar & make_nvp("HomePhone", c.HomePhone);
  82         ar & make_nvp("MobilePhone", c.MobilePhone);
  83         ar & make_nvp("MobilePhone2", c.MobilePhone2);
  84         ar & make_nvp("Pager", c.Pager);
  85         ar & make_nvp("PIN", c.PIN);
  86         ar & make_nvp("Radio", c.Radio);
  87         ar & make_nvp("WorkPhone2", c.WorkPhone2);
  88         ar & make_nvp("HomePhone2", c.HomePhone2);
  89         ar & make_nvp("OtherPhone", c.OtherPhone);
  90         ar & make_nvp("FirstName", c.FirstName);
  91         ar & make_nvp("LastName", c.LastName);
  92         ar & make_nvp("Company", c.Company);
  93         ar & make_nvp("DefaultCommunicationsMethod", c.DefaultCommunicationsMethod);
  94         ar & make_nvp("Address1", c.WorkAddress.Address1);
  95         ar & make_nvp("Address2", c.WorkAddress.Address2);
  96         ar & make_nvp("Address3", c.WorkAddress.Address3);
  97         ar & make_nvp("City", c.WorkAddress.City);
  98         ar & make_nvp("Province", c.WorkAddress.Province);
  99         ar & make_nvp("PostalCode", c.WorkAddress.PostalCode);
 100         ar & make_nvp("Country", c.WorkAddress.Country);
 101         ar & make_nvp("JobTitle", c.JobTitle);
 102         ar & make_nvp("PublicKey", c.PublicKey);
 103         ar & make_nvp("URL", c.URL);
 104         ar & make_nvp("Prefix", c.Prefix);
 105         ar & make_nvp("Categories", c.Categories);
 106         ar & make_nvp("HomeAddress1", c.HomeAddress.Address1);
 107         ar & make_nvp("HomeAddress2", c.HomeAddress.Address2);
 108         ar & make_nvp("HomeAddress3", c.HomeAddress.Address3);
 109         ar & make_nvp("Notes", c.Notes);
 110         ar & make_nvp("UserDefined1", c.UserDefined1);
 111         ar & make_nvp("UserDefined2", c.UserDefined2);
 112         ar & make_nvp("UserDefined3", c.UserDefined3);
 113         ar & make_nvp("UserDefined4", c.UserDefined4);
 114         ar & make_nvp("HomeCity", c.HomeAddress.City);
 115         ar & make_nvp("HomeProvince", c.HomeAddress.Province);
 116         ar & make_nvp("HomePostalCode", c.HomeAddress.PostalCode);
 117         ar & make_nvp("HomeCountry", c.HomeAddress.Country);
 118         ar & make_nvp("Image", c.Image);
 119         ar & make_nvp("Nickname", c.Nickname);
 120
 121         if( ver < BARRY_POD_MAP_VERSION ) {
 122                 ar & make_nvp("GroupLinks", c.GroupLinks);
 123                 ar & make_nvp("Unknowns", c.Unknowns);
 124         }
 125 }
 126
 127 template <class ArchiveT>
 128 void serialize(ArchiveT &ar, Barry::EmailAddress &a, const unsigned int ver)
 129 {
 130         ar & make_nvp("Name", a.Name);
 131         ar & make_nvp("Email", a.Email);
 132 }
 133
 134 template <class ArchiveT>
 135 void serialize(ArchiveT &ar, Barry::EmailAddressList &eal, const unsigned int ver)
 136 {
 137         std::vector<Barry::EmailAddress> &v = eal;
 138         ar & make_nvp("EmailAddressList", v);
 139 }
 140
 141 template <class ArchiveT>
 142 void serialize(ArchiveT &ar, Barry::Message &m, const unsigned int ver)
 143 {
 144         ar & make_nvp("From", m.From);
 145         ar & make_nvp("To", m.To);
 146         ar & make_nvp("Cc", m.Cc);
 147         ar & make_nvp("Sender", m.Sender);
 148         ar & make_nvp("ReplyTo", m.ReplyTo);
 149         ar & make_nvp("Subject", m.Subject);
 150         ar & make_nvp("Body", m.Body);
 151         ar & make_nvp("Attachment", m.Attachment);
 152         ar & make_nvp("MessageRecordId", m.MessageRecordId);
 153         ar & make_nvp("MessageReplyTo", m.MessageReplyTo);
 154         ar & make_nvp("MessageDateSent", m.MessageDateSent);
 155         ar & make_nvp("MessageDateReceived", m.MessageDateReceived);
 156
 157         ar & make_nvp("MessageTruncated", m.MessageTruncated);
 158         ar & make_nvp("MessageRead", m.MessageRead);
 159         ar & make_nvp("MessageReply", m.MessageReply);
 160         ar & make_nvp("MessageSaved", m.MessageSaved);
 161         ar & make_nvp("MessageSavedDeleted", m.MessageSavedDeleted);
 162
 163         ar & make_nvp("MessagePriority", m.Priority);
 164         ar & make_nvp("MessageSensitivity", m.Sensitivity);
 165
 166         if( ver < BARRY_POD_MAP_VERSION ) {
 167                 ar & make_nvp("Unknowns", m.Unknowns);
 168         }
 169 }
 170
 171 template <class ArchiveT>
 172 void serialize(ArchiveT &ar, Barry::Calendar &c, const unsigned int ver)
 173 {
 174         ar & make_nvp("RecType", c.RecType);
 175         ar & make_nvp("RecordId", c.RecordId);
 176
 177         ar & make_nvp("AllDayEvent", c.AllDayEvent);
 178
 179         ar & make_nvp("Subject", c.Subject);
 180         ar & make_nvp("Notes", c.Notes);
 181         ar & make_nvp("Location", c.Location);
 182
 183         ar & make_nvp("NotificationTime", c.NotificationTime);
 184         ar & make_nvp("StartTime", c.StartTime);
 185         ar & make_nvp("EndTime", c.EndTime);
 186
 187         ar & make_nvp("Organizer", c.Organizer);
 188         ar & make_nvp("AcceptedBy", c.AcceptedBy);
 189         ar & make_nvp("Invited", c.Invited);
 190
 191         ar & make_nvp("FreeBusyFlag", c.FreeBusyFlag);
 192         ar & make_nvp("ClassFlag", c.ClassFlag);
 193
 194         ar & make_nvp("Recurring", c.Recurring);
 195         ar & make_nvp("RecurringType", c.RecurringType);
 196         ar & make_nvp("Interval", c.Interval);
 197         ar & make_nvp("RecurringEndTime", c.RecurringEndTime);
 198         ar & make_nvp("Perpetual", c.Perpetual);
 199         ar & make_nvp("CalendarID", c.CalendarID);
 200         ar & make_nvp("TimeZoneCode", c.TimeZoneCode);
 201         ar & make_nvp("TimeZoneValid", c.TimeZoneValid);
 202
 203         ar & make_nvp("DayOfWeek", c.DayOfWeek);
 204         ar & make_nvp("WeekOfMonth", c.WeekOfMonth);
 205         ar & make_nvp("DayOfMonth", c.DayOfMonth);
 206         ar & make_nvp("MonthOfYear", c.MonthOfYear);
 207         ar & make_nvp("WeekDays", c.WeekDays);
 208
 209         if( ver < BARRY_POD_MAP_VERSION ) {
 210                 ar & make_nvp("Unknowns", c.Unknowns);
 211         }
 212 }
 213
 214 template <class ArchiveT>
 215 void serialize(ArchiveT &ar, Barry::CalendarAll &c, const unsigned int ver)
 216 {
 217         serialize(ar, static_cast<Barry::Calendar&>(c), ver);
 218
 219         ar & make_nvp("MailAccount", c.MailAccount);
 220 }
 221
 222 template <class ArchiveT>
 223 void serialize(ArchiveT &ar, Barry::CallLog &c, const unsigned int ver)
 224 {
 225         ar & make_nvp("RecType", c.RecType);
 226         ar & make_nvp("RecordId", c.RecordId);
 227
 228         ar & make_nvp("Duration", c.Duration);
 229         ar & make_nvp("Timestamp", c.Timestamp);
 230         ar & make_nvp("ContactName", c.ContactName);
 231         ar & make_nvp("PhoneNumber", c.PhoneNumber);
 232
 233         ar & make_nvp("DirectionFlag", c.DirectionFlag);
 234         ar & make_nvp("StatusFlag", c.StatusFlag);
 235         ar & make_nvp("PhoneTypeFlag", c.PhoneTypeFlag);
 236         ar & make_nvp("PhoneInfoFlag", c.PhoneInfoFlag);
 237
 238         if( ver < BARRY_POD_MAP_VERSION ) {
 239                 ar & make_nvp("Unknowns", c.Unknowns);
 240         }
 241 }
 242
 243 template <class ArchiveT>
 244 void serialize(ArchiveT &ar, Barry::Bookmark &c, const unsigned int ver)
 245 {
 246         ar & make_nvp("RecType", c.RecType);
 247         ar & make_nvp("RecordId", c.RecordId);
 248         ar & make_nvp("Index", c.Index);
 249
 250         ar & make_nvp("Name", c.Name);
 251         ar & make_nvp("Icon", c.Icon);
 252         ar & make_nvp("Url", c.Url);
 253
 254         ar & make_nvp("BrowserIdentity", c.BrowserIdentity);
 255         ar & make_nvp("DisplayMode", c.DisplayMode);
 256         ar & make_nvp("JavaScriptMode", c.JavaScriptMode);
 257
 258         if( ver < BARRY_POD_MAP_VERSION ) {
 259                 ar & make_nvp("Unknowns", c.Unknowns);
 260         }
 261 }
 262
 263 template <class ArchiveT>
 264 void serialize(ArchiveT &ar, Barry::ServiceBookConfig &c, const unsigned int ver)
 265 {
 266         ar & make_nvp("Format", c.Format);
 267
 268         if( ver < BARRY_POD_MAP_VERSION ) {
 269                 ar & make_nvp("Unknowns", c.Unknowns);
 270         }
 271 }
 272
 273 template <class ArchiveT>
 274 void serialize(ArchiveT &ar, Barry::ServiceBook &c, const unsigned int ver)
 275 {
 276         ar & make_nvp("RecType", c.RecType);
 277         ar & make_nvp("RecordId", c.RecordId);
 278
 279         ar & make_nvp("Name", c.Name);
 280         ar & make_nvp("HiddenName", c.HiddenName);
 281         ar & make_nvp("Description", c.Description);
 282         ar & make_nvp("DSID", c.DSID);
 283         ar & make_nvp("BesDomain", c.BesDomain);
 284         ar & make_nvp("UniqueId", c.UniqueId);
 285         ar & make_nvp("ContentId", c.ContentId);
 286         ar & make_nvp("Config", c.Config);
 287
 288         if( ver < BARRY_POD_MAP_VERSION ) {
 289                 ar & make_nvp("Unknowns", c.Unknowns);
 290         }
 291 }
 292
 293 template <class ArchiveT>
 294 void serialize(ArchiveT &ar, Barry::Memo &m, const unsigned int ver)
 295 {
 296         ar & make_nvp("RecType", m.RecType);
 297         ar & make_nvp("RecordId", m.RecordId);
 298
 299         ar & make_nvp("Title", m.Title);
 300         ar & make_nvp("Body", m.Body);
 301         ar & make_nvp("Categories", m.Categories);
 302
 303         if( ver < BARRY_POD_MAP_VERSION ) {
 304                 ar & make_nvp( "Unknowns", m.Unknowns);
 305         }
 306 }
 307
 308 template <class ArchiveT>
 309 void serialize(ArchiveT &ar, Barry::Task &t, const unsigned int ver)
 310 {
 311         ar & make_nvp("RecType", t.RecType);
 312         ar & make_nvp("RecordId", t.RecordId);
 313
 314         ar & make_nvp("Summary", t.Summary);
 315         ar & make_nvp("Notes", t.Notes);
 316         ar & make_nvp("Categories", t.Categories);
 317         ar & make_nvp("UID", t.UID);
 318
 319         ar & make_nvp("StartTime", t.StartTime);
 320         ar & make_nvp("DueTime", t.DueTime);
 321         ar & make_nvp("AlarmTime", t.AlarmTime);
 322
 323         ar & make_nvp("TimeZoneCode", t.TimeZoneCode);
 324         ar & make_nvp("TimeZoneValid", t.TimeZoneValid);
 325
 326         ar & make_nvp("AlarmType", t.AlarmType);
 327         ar & make_nvp("Interval", t.Interval);
 328         ar & make_nvp("RecurringType", t.RecurringType);
 329         ar & make_nvp("RecurringEndTime", t.RecurringEndTime);
 330         ar & make_nvp("DayOfWeek", t.DayOfWeek);
 331         ar & make_nvp("WeekOfMonth", t.WeekOfMonth);
 332         ar & make_nvp("DayOfMonth", t.DayOfMonth);
 333         ar & make_nvp("MonthOfYear", t.MonthOfYear);
 334         ar & make_nvp("WeekDays", t.WeekDays);
 335
 336         ar & make_nvp("PriorityFlag", t.PriorityFlag);
 337         ar & make_nvp("StatusFlag", t.StatusFlag);
 338         ar & make_nvp("Recurring", t.Recurring);
 339         ar & make_nvp("Perpetual", t.Perpetual);
 340         ar & make_nvp("DueDateFlag", t.DueDateFlag);
 341
 342         if( ver < BARRY_POD_MAP_VERSION ) {
 343                 ar & make_nvp( "Unknowns", t.Unknowns);
 344         }
 345 }
 346
 347 template<class ArchiveT>
 348 void serialize(ArchiveT &ar, Barry::PINMessage &p, const unsigned int ver)
 349 {
 350         ar & make_nvp("RecType", p.RecType);
 351         ar & make_nvp("RecordId", p.RecordId);
 352
 353         ar & make_nvp("From", p.From);
 354         ar & make_nvp("To", p.To);
 355         ar & make_nvp("Cc", p.Cc);
 356         ar & make_nvp("Bcc", p.Bcc);
 357         ar & make_nvp("Subject", p.Subject);
 358         ar & make_nvp("Body", p.Body);
 359         ar & make_nvp("MessageRecordId", p.MessageRecordId);
 360         ar & make_nvp("MessageReplyTo", p.MessageReplyTo);
 361         ar & make_nvp("MessageDateSent", p.MessageDateSent);
 362         ar & make_nvp("MessageDateReceived", p.MessageDateReceived);
 363
 364         ar & make_nvp("MessageTruncated", p.MessageTruncated);
 365         ar & make_nvp("MessageRead", p.MessageRead);
 366         ar & make_nvp("MessageReply", p.MessageReply);
 367         ar & make_nvp("MessageSaved", p.MessageSaved);
 368         ar & make_nvp("MessageSavedDeleted", p.MessageSavedDeleted);
 369
 370         ar & make_nvp("MessagePriority", p.Priority);
 371         ar & make_nvp("MessageSensitivity", p.Sensitivity);
 372
 373         if(ver < BARRY_POD_MAP_VERSION) {
 374                 ar & make_nvp("Unknowns", p.Unknowns);
 375         }
 376 }
 377
 378 template <class ArchiveT>
 379 void serialize(ArchiveT &ar, Barry::SavedMessage &m, const unsigned int ver)
 380 {
 381         ar & make_nvp("RecType", m.RecType);
 382         ar & make_nvp("RecordId", m.RecordId);
 383
 384         ar & make_nvp("From", m.From);
 385         ar & make_nvp("To", m.To);
 386         ar & make_nvp("Cc", m.Cc);
 387         ar & make_nvp("Bcc", m.Bcc);
 388         ar & make_nvp("Sender", m.Sender);
 389         ar & make_nvp("ReplyTo", m.ReplyTo);
 390         ar & make_nvp("Subject", m.Subject);
 391         ar & make_nvp("Body", m.Body);
 392         ar & make_nvp("Attachment", m.Attachment);
 393         ar & make_nvp("MessageRecordId", m.MessageRecordId);
 394         ar & make_nvp("MessageReplyTo", m.MessageReplyTo);
 395         ar & make_nvp("MessageDateSent", m.MessageDateSent);
 396         ar & make_nvp("MessageDateReceived", m.MessageDateReceived);
 397
 398         ar & make_nvp("MessageTruncated", m.MessageTruncated);
 399         ar & make_nvp("MessageRead", m.MessageRead);
 400         ar & make_nvp("MessageReply", m.MessageReply);
 401         ar & make_nvp("MessageSaved", m.MessageSaved);
 402         ar & make_nvp("MessageSavedDeleted", m.MessageSavedDeleted);
 403
 404         ar & make_nvp("MessagePriority", m.Priority);
 405         ar & make_nvp("MessageSensitivity", m.Sensitivity);
 406
 407         if( ver < BARRY_POD_MAP_VERSION ) {
 408                 ar & make_nvp("Unknowns", m.Unknowns);
 409         }
 410 }
 411
 412 template <class ArchiveT>
 413 void serialize(ArchiveT &ar, Barry::Sms &m, const unsigned int ver)
 414 {
 415         ar & make_nvp("RecType", m.RecType);
 416         ar & make_nvp("RecordId", m.RecordId);
 417
 418         ar & make_nvp("MessageStatus", m.MessageStatus);
 419         ar & make_nvp("DeliveryStatus", m.DeliveryStatus);
 420
 421         ar & make_nvp("IsNew", m.IsNew);
 422         ar & make_nvp("NewConversation", m.NewConversation);
 423         ar & make_nvp("Saved", m.Saved);
 424         ar & make_nvp("Deleted", m.Deleted);
 425         ar & make_nvp("Opened", m.Opened);
 426
 427         ar & make_nvp("Timestamp", m.Timestamp);
 428         ar & make_nvp("ServiceCenterTimestamp", m.ServiceCenterTimestamp);
 429
 430         ar & make_nvp("DataCodingScheme", m.DataCodingScheme);
 431         ar & make_nvp("ErrorId", m.ErrorId);
 432
 433         ar & make_nvp("Addresses", m.Addresses);
 434         ar & make_nvp("Body", m.Body);
 435
 436         if( ver < BARRY_POD_MAP_VERSION ) {
 437                 ar & make_nvp("Unknowns", m.Unknowns);
 438         }
 439 }
 440
 441 template <class ArchiveT>
 442 void serialize(ArchiveT &ar, Barry::Folder &f, const unsigned int ver)
 443 {
 444         ar & make_nvp("RecType", f.RecType);
 445         ar & make_nvp("RecordId", f.RecordId);
 446
 447         ar & make_nvp("FolderName", f.Name);
 448         ar & make_nvp("FolderNumber", f.Number);
 449         ar & make_nvp("FolderLevel", f.Level);
 450         ar & make_nvp("FolderType", f.Type);
 451
 452         if( ver < BARRY_POD_MAP_VERSION ) {
 453                 ar & make_nvp( "Unknowns", f.Unknowns);
 454         }
 455 }
 456
 457 template <class ArchiveT>
 458 void serialize(ArchiveT &ar, Barry::Timezone &t, const unsigned int ver)
 459 {
 460         ar & make_nvp("RecType", t.RecType);
 461         ar & make_nvp("RecordId", t.RecordId);
 462
 463         ar & make_nvp("TZType", t.TZType);
 464         ar & make_nvp("DSTOffset", t.DSTOffset);
 465         ar & make_nvp("Index", t.Index);
 466         ar & make_nvp("Offset", t.Offset);
 467         ar & make_nvp("OffsetFraction", t.OffsetFraction);
 468         ar & make_nvp("StartMonth", t.StartMonth);
 469         ar & make_nvp("EndMonth", t.EndMonth);
 470         ar & make_nvp("Left", t.Left);
 471         ar & make_nvp("UseDST", t.UseDST);
 472
 473         ar & make_nvp("TimeZoneName", t.TimeZoneName);
 474
 475         if( ver < BARRY_POD_MAP_VERSION ) {
 476                 ar & make_nvp("Unknowns", t.Unknowns);
 477         }
 478 }
 479
 480 template <class ArchiveT>
 481 void serialize(ArchiveT &ar, Barry::ContentStore &c, const unsigned int ver)
 482 {
 483         ar & make_nvp("RecType", c.RecType);
 484         ar & make_nvp("RecordId", c.RecordId);
 485
 486         ar & make_nvp("Filename", c.Filename);
 487         ar & make_nvp("FolderFlag", c.FolderFlag);
 488         ar & make_nvp("FileContent", c.FileContent);
 489         ar & make_nvp("FileDescriptor", c.FileDescriptor);
 490
 491         // FileSize is not used for building, so no need to save it here
 492
 493         if( ver < BARRY_POD_MAP_VERSION ) {
 494                 ar & make_nvp("Unknowns", c.Unknowns);
 495         }
 496 }
 497
 498 template <class ArchiveT>
 499 void serialize(ArchiveT &ar, Barry::HandheldAgent &h, const unsigned int ver)
 500 {
 501         ar & make_nvp("RecType", h.RecType);
 502         ar & make_nvp("RecordId", h.RecordId);
 503
 504         ar & make_nvp("MEID", h.MEID);
 505         ar & make_nvp("Model", h.Model);
 506         ar & make_nvp("Bands", h.Bands);
 507         ar & make_nvp("Pin", h.Pin);
 508         ar & make_nvp("Version", h.Version);
 509         ar & make_nvp("PlatformVersion", h.PlatformVersion);
 510         ar & make_nvp("Manufacturer", h.Manufacturer);
 511         ar & make_nvp("Network", h.Network);
 512
 513         if( ver < BARRY_POD_MAP_VERSION ) {
 514                 ar & make_nvp("Unknowns", h.Unknowns);
 515         }
 516 }
 517
 518 }} // namespace boost::serialization
 519
 520
 521 //////////////////////////////////////////////////////////////////////////////
 522 // Helper wrapper templates for loading and saving records to an iostream
 523
 524 namespace Barry {
 525
 526 // Can be used as a Storage class for RecordBuilder<>
 527 template <class RecordT>
 528 class BoostLoader
 529 {
 530 public:
 531         typedef RecordT                         rec_type;
 532         typedef std::vector<rec_type>           list_type;
 533
 534 private:
 535         list_type m_records;
 536         typename list_type::iterator rec_it;
 537
 538 public:
 539         explicit BoostLoader(std::istream &is)
 540         {
 541                 boost::archive::text_iarchive ia(is);
 542                 ia >> m_records;
 543                 rec_it = m_records.begin();
 544         }
 545
 546         list_type& GetRecords() { return m_records; }
 547         const list_type& GetRecords() const { return m_records; }
 548
 549         // retrieval operator
 550         bool operator()(RecordT &rec, Builder &builder)
 551         {
 552                 if( rec_it == m_records.end() )
 553                         return false;
 554                 rec = *rec_it;
 555                 ++rec_it;
 556                 return true;
 557         }
 558 };
 559
 560 // Can be used as a Storage class for RecordParser<>
 561 template <class RecordT>
 562 class BoostSaver
 563 {
 564 public:
 565         typedef RecordT                         rec_type;
 566         typedef std::vector<rec_type>           list_type;
 567
 568 private:
 569         std::ostream &m_os;
 570         list_type m_records;
 571         typename list_type::iterator rec_it;
 572
 573 public:
 574         explicit BoostSaver(std::ostream &os)
 575                 : m_os(os)
 576         {
 577         }
 578
 579         ~BoostSaver()
 580         {
 581                 WriteArchive();
 582         }
 583
 584         void WriteArchive() const
 585         {
 586                 // write dbname first, so parsing is possible
 587                 m_os << RecordT::GetDBName() << std::endl;
 588
 589                 // write boost archive of all records
 590                 boost::archive::text_oarchive oa(m_os);
 591
 592                 // boost is fussy that the vector must be const
 593                 // we do this explicitly, for documentation's sake
 594                 const list_type &recs = m_records;
 595                 oa << recs;
 596                 m_os << std::endl;
 597         }
 598
 599         list_type& GetRecords() { return m_records; }
 600         const list_type& GetRecords() const { return m_records; }
 601
 602         // storage operator
 603         void operator()(const RecordT &rec)
 604         {
 605                 m_records.push_back(rec);
 606         }
 607 };
 608
 609 //
 610 // BoostParser
 611 //
 612 /// This Parser turns incoming records (which can be of any record type
 613 /// included in ALL_KNOWN_PARSER_TYPES) into a Boost Serialization stream
 614 /// on the given iostream.
 615 ///
 616 /// This class is defined completely in the header, so that it is
 617 /// optional for applications to link against the boost libraries.
 618 ///
 619 class BXEXPORT BoostParser : public Barry::Parser
 620 {
 621         std::auto_ptr<Barry::Parser> m_parser;
 622         std::ofstream *m_ofs;
 623         std::ostream &m_os;     // references either an external object,
 624                                 // or *m_ifs... this is the reference to
 625                                 // use in the entire class... the constructor
 626                                 // sets it up
 627
 628         std::string m_current_db;
 629
 630 public:
 631         explicit BoostParser(const std::string &filename)
 632                 : m_ofs( new std::ofstream(filename.c_str()) )
 633                 , m_os(*m_ofs)
 634         {
 635         }
 636
 637         explicit BoostParser(std::ostream &os)
 638                 : m_ofs(0)
 639                 , m_os(os)
 640         {
 641         }
 642
 643         ~BoostParser()
 644         {
 645                 // flush any remaining parser output
 646                 // (note this still potentially uses m_ofs, so do this first)
 647                 m_parser.reset();
 648
 649                 // cleanup the stream
 650                 delete m_ofs;
 651         }
 652
 653         void StartDB(const std::string &dbname)
 654         {
 655                 // done with current parser, flush it's output
 656                 m_parser.reset();
 657
 658 #undef HANDLE_PARSER
 659 #define HANDLE_PARSER(tname) \
 660                 if( dbname == tname::GetDBName() ) { \
 661                         m_parser.reset( \
 662                                 new RecordParser<tname, BoostSaver<tname> >( \
 663                                         new BoostSaver<tname>(m_os) ) ); \
 664                         return; \
 665                 }
 666
 667                 ALL_KNOWN_PARSER_TYPES
 668
 669                 // if we make it here, we don't have a record parser
 670                 // for this dbname, so just dump it to stderr (not stdout,
 671                 // since the user might be sending normal output there)
 672                 m_parser.reset( new HexDumpParser(std::cerr) );
 673         }
 674
 675         void ParseRecord(const DBData &data, const IConverter *ic)
 676         {
 677                 if( m_current_db != data.GetDBName() ) {
 678                         StartDB(data.GetDBName());
 679                         m_current_db = data.GetDBName();
 680                 }
 681
 682                 m_parser->ParseRecord(data, ic);
 683         }
 684 };
 685
 686 //
 687 // BoostBuilder
 688 //
 689 /// This Builder class reads a boost serialization stream, and converts
 690 /// them into DBData records.  Can only produce records for record types
 691 /// in ALL_KNOWN_BUILDER_TYPES.
 692 ///
 693 class BXEXPORT BoostBuilder : public Barry::Builder
 694 {
 695         std::auto_ptr<Builder> m_builder;
 696         std::ifstream *m_ifs;
 697
 698         std::istream &m_is;     // references either an external object,
 699                                 // or *m_ifs... this is the reference to
 700                                 // use in the entire class... the constructor
 701                                 // sets it up
 702
 703 public:
 704         explicit BoostBuilder(const std::string &filename)
 705                 : m_ifs( new std::ifstream(filename.c_str()) )
 706                 , m_is(*m_ifs)
 707         {
 708                 FinishDB();
 709         }
 710
 711         explicit BoostBuilder(std::istream &is)
 712                 : m_ifs(0)
 713                 , m_is(is)
 714         {
 715                 FinishDB();
 716         }
 717
 718         ~BoostBuilder()
 719         {
 720                 delete m_ifs;
 721         }
 722
 723         void FinishDB()
 724         {
 725                 // done with current builder
 726                 m_builder.reset();
 727
 728                 // read the next DBName
 729                 std::string dbName;
 730                 while( getline(m_is, dbName) ) {
 731
 732 #undef HANDLE_BUILDER
 733 #define HANDLE_BUILDER(tname) \
 734                         if( dbName == tname::GetDBName() ) { \
 735                                 m_builder.reset( \
 736                                         new RecordBuilder<tname, BoostLoader<tname> >( \
 737                                                 new BoostLoader<tname>(m_is) ) ); \
 738                                 return; \
 739                         }
 740
 741                         ALL_KNOWN_BUILDER_TYPES
 742                 }
 743         }
 744
 745         bool BuildRecord(DBData &data, size_t &offset, const IConverter *ic)
 746         {
 747                 if( !m_builder.get() )
 748                         return false;
 749
 750                 bool ret = m_builder->BuildRecord(data, offset, ic);
 751                 if( !ret )
 752                         FinishDB();
 753                 return ret;
 754         }
 755
 756         bool FetchRecord(DBData &data, const IConverter *ic)
 757         {
 758                 if( !m_builder.get() )
 759                         return false;
 760
 761                 bool ret = m_builder->FetchRecord(data, ic);
 762                 if( !ret )
 763                         FinishDB();
 764                 return ret;
 765         }
 766
 767         bool EndOfFile() const
 768         {
 769                 return m_builder.get() ? false : true;
 770         }
 771 };
 772
 773
 774 } // namespace Barry
 775
 776 #endif
 777