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