builder.h   builder.h 
skipping to change at line 73 skipping to change at line 73
/// packet (possibly with Data::ReleaseBuffer()). /// packet (possibly with Data::ReleaseBuffer()).
virtual void BuildFields(Data &data, size_t &offset) = 0; virtual void BuildFields(Data &data, size_t &offset) = 0;
}; };
// //
// RecordBuilder template class // RecordBuilder template class
// //
/// Template class for easy creation of specific protocol packet builder /// Template class for easy creation of specific protocol packet builder
/// objects. This template takes the following template arguments: /// objects. This template takes the following template arguments:
/// ///
/// - Record: One of the record classes in record.h /// - RecordT: One of the record classes in record.h
/// - Storage: A custom storage functor class. An object of this type /// - StorageT: A custom storage functor class. An object of this type
/// will be called as a function with empty Record as an /// will be called as a function with empty Record as an
/// argument. The storage class is expected to fill the /// argument. The storage class is expected to fill the
/// record object in preparation for building the packet /// record object in preparation for building the packet
/// out of that data. These calls happen on the fly as the data /// out of that data. These calls happen on the fly as the data
/// is sent to the device over USB, so it should not block forev er. /// is sent to the device over USB, so it should not block forev er.
/// ///
/// Example SaveDatabase() call: /// Example SaveDatabase() call:
/// ///
/// <pre> /// <pre>
/// FIXME /// FIXME
/// </pre> /// </pre>
/// ///
template <class Record, class Storage> template <class RecordT, class StorageT>
class RecordBuilder : public Builder class RecordBuilder : public Builder
{ {
Storage *m_storage; StorageT *m_storage;
bool m_owned; bool m_owned;
Record m_rec; RecordT m_rec;
public: public:
/// Constructor that references an externally managed storage object . /// Constructor that references an externally managed storage object .
RecordBuilder(Storage &storage) RecordBuilder(StorageT &storage)
: m_storage(&storage), m_owned(false) {} : m_storage(&storage), m_owned(false) {}
/// Constructor that references a locally managed storage object. /// Constructor that references a locally managed storage object.
/// The pointer passed in will be stored, and freed when this class /// The pointer passed in will be stored, and freed when this class
/// is destroyed. It is safe to call this constructor with /// is destroyed. It is safe to call this constructor with
/// a 'new'ly created storage object. /// a 'new'ly created storage object.
RecordBuilder(Storage *storage) RecordBuilder(StorageT *storage)
: m_storage(storage), m_owned(true) {} : m_storage(storage), m_owned(true) {}
~RecordBuilder() ~RecordBuilder()
{ {
if( this->m_owned ) if( this->m_owned )
delete m_storage; delete m_storage;
} }
virtual bool Retrieve(unsigned int databaseId) virtual bool Retrieve(unsigned int databaseId)
{ {
 End of changes. 6 change blocks. 
7 lines changed or deleted 7 lines changed or added


 data.h   data.h 
skipping to change at line 98 skipping to change at line 98
public: public:
Diff(const Data &old, const Data &new_); Diff(const Data &old, const Data &new_);
void Dump(std::ostream &os) const; void Dump(std::ostream &os) const;
}; };
std::ostream& operator<< (std::ostream &os, const Diff &diff); std::ostream& operator<< (std::ostream &os, const Diff &diff);
// utility functions // utility functions
bool LoadDataArray(const std::string &filename, std::vector<Data> &array); bool LoadDataArray(const std::string &filename, std::vector<Data> &array);
bool ReadDataArray(std::istream &is, std::vector<Data> &array);
} // namespace Barry } // namespace Barry
#endif #endif
 End of changes. 1 change blocks. 
0 lines changed or deleted 1 lines changed or added


 ldif.h   ldif.h 
skipping to change at line 171 skipping to change at line 171
virtual std::string LastName(const Barry::Contact &con) const; virtual std::string LastName(const Barry::Contact &con) const;
virtual std::string Company(const Barry::Contact &con) const; virtual std::string Company(const Barry::Contact &con) const;
virtual std::string DefaultCommunicationsMethod(const Barry::Contact &con) const; virtual std::string DefaultCommunicationsMethod(const Barry::Contact &con) const;
virtual std::string Address1(const Barry::Contact &con) const; virtual std::string Address1(const Barry::Contact &con) const;
virtual std::string Address2(const Barry::Contact &con) const; virtual std::string Address2(const Barry::Contact &con) const;
virtual std::string Address3(const Barry::Contact &con) const; virtual std::string Address3(const Barry::Contact &con) const;
virtual std::string City(const Barry::Contact &con) const; virtual std::string City(const Barry::Contact &con) const;
virtual std::string Province(const Barry::Contact &con) const; virtual std::string Province(const Barry::Contact &con) const;
virtual std::string PostalCode(const Barry::Contact &con) const; virtual std::string PostalCode(const Barry::Contact &con) const;
virtual std::string Country(const Barry::Contact &con) const; virtual std::string Country(const Barry::Contact &con) const;
virtual std::string Title(const Barry::Contact &con) const; virtual std::string JobTitle(const Barry::Contact &con) const;
virtual std::string PublicKey(const Barry::Contact &con) const; virtual std::string PublicKey(const Barry::Contact &con) const;
virtual std::string Notes(const Barry::Contact &con) const; virtual std::string Notes(const Barry::Contact &con) const;
// calculated values... // calculated values...
virtual std::string PostalAddress(const Barry::Contact &con) const; virtual std::string PostalAddress(const Barry::Contact &con) const;
virtual std::string FullName(const Barry::Contact &con) const; virtual std::string FullName(const Barry::Contact &con) const;
virtual std::string FQDN(const Barry::Contact &con) const; virtual std::string FQDN(const Barry::Contact &con) const;
// //
// Write functions // Write functions
// //
skipping to change at line 202 skipping to change at line 202
virtual void SetLastName(Barry::Contact &con, const std::string &val ) const; virtual void SetLastName(Barry::Contact &con, const std::string &val ) const;
virtual void SetCompany(Barry::Contact &con, const std::string &val) const; virtual void SetCompany(Barry::Contact &con, const std::string &val) const;
virtual void SetDefaultCommunicationsMethod(Barry::Contact &con, con st std::string &val) const; virtual void SetDefaultCommunicationsMethod(Barry::Contact &con, con st std::string &val) const;
virtual void SetAddress1(Barry::Contact &con, const std::string &val ) const; virtual void SetAddress1(Barry::Contact &con, const std::string &val ) const;
virtual void SetAddress2(Barry::Contact &con, const std::string &val ) const; virtual void SetAddress2(Barry::Contact &con, const std::string &val ) const;
virtual void SetAddress3(Barry::Contact &con, const std::string &val ) const; virtual void SetAddress3(Barry::Contact &con, const std::string &val ) const;
virtual void SetCity(Barry::Contact &con, const std::string &val) co nst; virtual void SetCity(Barry::Contact &con, const std::string &val) co nst;
virtual void SetProvince(Barry::Contact &con, const std::string &val ) const; virtual void SetProvince(Barry::Contact &con, const std::string &val ) const;
virtual void SetPostalCode(Barry::Contact &con, const std::string &v al) const; virtual void SetPostalCode(Barry::Contact &con, const std::string &v al) const;
virtual void SetCountry(Barry::Contact &con, const std::string &val) const; virtual void SetCountry(Barry::Contact &con, const std::string &val) const;
virtual void SetTitle(Barry::Contact &con, const std::string &val) c onst; virtual void SetJobTitle(Barry::Contact &con, const std::string &val ) const;
virtual void SetPublicKey(Barry::Contact &con, const std::string &va l) const; virtual void SetPublicKey(Barry::Contact &con, const std::string &va l) const;
virtual void SetNotes(Barry::Contact &con, const std::string &val) c onst; virtual void SetNotes(Barry::Contact &con, const std::string &val) c onst;
virtual void SetPostalAddress(Barry::Contact &con, const std::string &val) const; virtual void SetPostalAddress(Barry::Contact &con, const std::string &val) const;
virtual void SetFullName(Barry::Contact &con, const std::string &val ) const; virtual void SetFullName(Barry::Contact &con, const std::string &val ) const;
virtual void SetFQDN(Barry::Contact &con, const std::string &val) co nst; virtual void SetFQDN(Barry::Contact &con, const std::string &val) co nst;
// //
// Name heuristics // Name heuristics
// //
 End of changes. 2 change blocks. 
2 lines changed or deleted 2 lines changed or added


 parser.h   parser.h 
skipping to change at line 81 skipping to change at line 81
/// store the final packet somewhere, either in memory, disk, etc. /// store the final packet somewhere, either in memory, disk, etc.
virtual void Store() {} virtual void Store() {}
}; };
// //
// RecordParser template class // RecordParser template class
// //
/// Template class for easy creation of specific parser objects. This temp late /// Template class for easy creation of specific parser objects. This temp late
/// takes the following template arguments: /// takes the following template arguments:
/// ///
/// - Record: One of the record parser classes in record.h /// - RecordT: One of the record parser classes in record.h
/// - Storage: A custom storage functor class. An object of this type /// - StorageT: A custom storage functor class. An object of this type
/// will be called as a function with parsed Record as an /// will be called as a function with parsed Record as an
/// argument. This happens on the fly as the data is retrieved /// argument. This happens on the fly as the data is retrieved
/// from the device over USB, so it should not block forever. /// from the device over USB, so it should not block forever.
/// ///
/// Example LoadDatabase() call: /// Example LoadDatabase() call:
/// ///
/// <pre> /// <pre>
/// struct StoreContact /// struct StoreContact
/// { /// {
/// std::vector<Contact> &amp;array; /// std::vector<Contact> &amp;array;
skipping to change at line 108 skipping to change at line 108
/// }; /// };
/// ///
/// Controller con(probeResult); /// Controller con(probeResult);
/// con.OpenMode(Controller::Desktop); /// con.OpenMode(Controller::Desktop);
/// std::vector<Contact> contactList; /// std::vector<Contact> contactList;
/// StoreContact storage(contactList); /// StoreContact storage(contactList);
/// RecordParser<Contact, StoreContact> parser(storage); /// RecordParser<Contact, StoreContact> parser(storage);
/// con.LoadDatabase(con.GetDBID("Address Book"), parser); /// con.LoadDatabase(con.GetDBID("Address Book"), parser);
/// </pre> /// </pre>
/// ///
template <class Record, class Storage> template <class RecordT, class StorageT>
class RecordParser : public Parser class RecordParser : public Parser
{ {
Storage *m_store; StorageT *m_store;
bool m_owned; bool m_owned;
Record m_rec; RecordT m_rec;
public: public:
/// Constructor that references an externally managed storage object . /// Constructor that references an externally managed storage object .
RecordParser(Storage &storage) RecordParser(StorageT &storage)
: m_store(&storage), m_owned(false) {} : m_store(&storage), m_owned(false) {}
/// Constructor that references a locally managed storage object. /// Constructor that references a locally managed storage object.
/// The pointer passed in will be stored, and freed when this class /// The pointer passed in will be stored, and freed when this class
/// is destroyed. It is safe to call this constructor with /// is destroyed. It is safe to call this constructor with
/// a 'new'ly created storage object. /// a 'new'ly created storage object.
RecordParser(Storage *storage) RecordParser(StorageT *storage)
: m_store(storage), m_owned(true) {} : m_store(storage), m_owned(true) {}
~RecordParser() ~RecordParser()
{ {
if( this->m_owned ) if( this->m_owned )
delete m_store; delete m_store;
} }
virtual void Clear() virtual void Clear()
{ {
m_rec = Record(); m_rec = RecordT();
} }
virtual void SetIds(uint8_t RecType, uint32_t UniqueId) virtual void SetIds(uint8_t RecType, uint32_t UniqueId)
{ {
m_rec.SetIds(RecType, UniqueId); m_rec.SetIds(RecType, UniqueId);
} }
virtual void ParseHeader(const Data &data, size_t &offset) virtual void ParseHeader(const Data &data, size_t &offset)
{ {
m_rec.ParseHeader(data, offset); m_rec.ParseHeader(data, offset);
 End of changes. 7 change blocks. 
8 lines changed or deleted 8 lines changed or added


 record.h   record.h 
/// ///
/// \file record.h /// \file record.h
/// Blackberry database record classes. Help translate data /// Blackberry database record classes. Help translate data
/// from data packets to useful structurs, and back. /// from data packets to useful structurs, and back.
/// This header provides the common types and classes
/// used by the general record parser classes in the
/// r_*.h files. Only application-safe API stuff goes in
/// here. Internal library types go in record-internal.h
/// ///
/* /*
Copyright (C) 2005-2007, Net Direct Inc. (http://www.netdirect.ca/) Copyright (C) 2005-2007, Net Direct Inc. (http://www.netdirect.ca/)
This program is free software; you can redistribute it and/or modify This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
skipping to change at line 167 skipping to change at line 171
return os; return os;
} }
struct UnknownField struct UnknownField
{ {
uint8_t type; uint8_t type;
std::string data; std::string data;
}; };
std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns); std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns);
/// \addtogroup RecordParserClasses struct EmailAddress
/// Parser and data storage classes. These classes take a
/// Database Database record and convert them into C++ objects.
/// Each of these classes are safe to be used in standard
/// containers, and are meant to be used in conjunction with the
/// RecordParser<> template when calling Controller::LoadDatabas
e().
/// @{
class Contact
{ {
public: std::string Name;
struct GroupLink std::string Email;
{
uint32_t Link;
uint16_t Unknown;
GroupLink() : Link(0), Unknown(0) {}
GroupLink(uint32_t link, uint16_t unknown)
: Link(link), Unknown(unknown)
{}
};
typedef std::vector<GroupLink> GroupLinksType; void clear()
typedef std::vector<UnknownField> UnknownsType; {
Name.clear();
Email.clear();
}
};
std::ostream& operator<<(std::ostream &os, const EmailAddress &msga);
// contact specific data struct PostalAddress
uint8_t RecType; {
uint32_t RecordId;
std::string std::string
Email,
Phone,
Fax,
WorkPhone,
HomePhone,
MobilePhone,
Pager,
PIN,
FirstName,
LastName,
Company,
DefaultCommunicationsMethod,
Address1, Address1,
Address2, Address2,
Address3, Address3,
City, City,
Province, Province,
PostalCode, PostalCode,
Country, Country;
Title,
PublicKey,
Notes;
GroupLinksType GroupLinks;
UnknownsType Unknowns;
private:
bool m_FirstNameSeen;
//protected:
public:
const unsigned char* ParseField(const unsigned char *begin,
const unsigned char *end);
public:
Contact();
~Contact();
uint32_t GetID() const { return RecordId; }
std::string GetPostalAddress() const;
// Parser / Builder API (see parser.h / builder.h)
uint8_t GetRecType() const { return RecType; }
uint32_t GetUniqueId() const { return RecordId; }
void SetIds(uint8_t Type, uint32_t Id) { RecType = Type; RecordId =
Id; }
void ParseHeader(const Data &data, size_t &offset);
void ParseFields(const Data &data, size_t &offset);
void BuildHeader(Data &data, size_t &offset) const;
void BuildFields(Data &data, size_t &offset) const;
void Clear(); // erase everything
void Dump(std::ostream &os) const;
// sorting - put group links at the end
bool operator<(const Contact &other) const {
return GroupLinks.size() == 0 && other.GroupLinks.size() > 0
;
// // testing - put group links at the top
// return GroupLinks.size() > 0 && other.GroupLinks.size() == 0
;
}
// database name
static const char * GetDBName() { return "Address Book"; }
static uint8_t GetDefaultRecType() { return 0; }
// helpers
static void SplitName(const std::string &full, std::string &first, s
td::string &last);
};
inline std::ostream& operator<< (std::ostream &os, const Contact &contact)
{
contact.Dump(os);
return os;
}
class Message
{
public:
struct Address
{
std::string Name;
std::string Email;
};
Address From;
Address To;
Address Cc;
std::string Subject;
std::string Body;
std::vector<UnknownField> Unknowns;
public:
const unsigned char* ParseField(const unsigned char *begin,
const unsigned char *end);
public:
Message();
~Message();
// Parser / Builder API (see parser.h / builder.h)
uint8_t GetRecType() const;
uint32_t GetUniqueId() const; // empty API, not required by protoc
ol
void SetIds(uint8_t Type, uint32_t Id); // empty API, not required b
y protocol
void ParseHeader(const Data &data, size_t &offset);
void ParseFields(const Data &data, size_t &offset);
void BuildHeader(Data &data, size_t &offset) const;
void BuildFields(Data &data, size_t &offset) const;
void Clear();
void Dump(std::ostream &os) const;
// sorting
bool operator<(const Message &other) const { return Subject < other.
Subject; }
// database name
static const char * GetDBName() { return "Messages"; }
static uint8_t GetDefaultRecType() { return 0; }
};
inline std::ostream& operator<<(std::ostream &os, const Message &msg) {
msg.Dump(os);
return os;
}
std::ostream& operator<<(std::ostream &os, const Message::Address &msga);
class Calendar
{
public:
typedef std::vector<UnknownField> UnknownsType;
uint8_t RecType;
uint32_t RecordId;
// general data
bool AllDayEvent;
std::string Subject;
std::string Notes;
std::string Location;
time_t NotificationTime;
time_t StartTime;
time_t EndTime;
///
/// Recurring data
///
/// Note: interval can be used on all of these recurring types to
/// make it happen "every other time" or more, etc.
///
enum RecurringCodeType {
Day = 1, //< eg. every day
//< set: nothing
MonthByDate = 3, //< eg. every month on the 12th
//< set: DayOfMonth
MonthByDay = 4, //< eg. every month on 3rd Wed
//< set: DayOfWeek and WeekOfMonth
YearByDate = 5, //< eg. every year on March 5
//< set: DayOfMonth and MonthOfYear
YearByDay = 6, //< eg. every year on 3rd Wed of Jan
//< set: DayOfWeek, WeekOfMonth, and
//< MonthOfYear
Week = 12 //< eg. every week on Mon and Fri
//< set: WeekDays
};
bool Recurring;
RecurringCodeType RecurringType;
unsigned short Interval; // must be >= 1
time_t RecurringEndTime; // only pertains if Recurring is tru
e
// sets the date and time when
// recurrence of this appointment
// should no longer occur
// If a perpetual appointment, this
// is 0xFFFFFFFF in the low level da
ta
// Instead, set the following flag.
bool Perpetual; // if true, this will always recur
unsigned short TimeZoneCode; // the time zone originally used
// for the recurrence data...
// seems to have little use, but
// set to your current time zone
// as a good default
unsigned short // recurring details, depending on t
ype
DayOfWeek, // 0-6
WeekOfMonth, // 1-5
DayOfMonth, // 1-31
MonthOfYear; // 1-12
unsigned char WeekDays; // bitmask, bit 0 = sunday
// FIXME - put these somewhere usable by both C and C++
#define CAL_WD_SUN 0x01
#define CAL_WD_MON 0x02
#define CAL_WD_TUE 0x04
#define CAL_WD_WED 0x08
#define CAL_WD_THU 0x10
#define CAL_WD_FRI 0x20
#define CAL_WD_SAT 0x40
// unknown
UnknownsType Unknowns;
public:
const unsigned char* ParseField(const unsigned char *begin,
const unsigned char *end);
void ParseRecurrenceData(const void *data);
void BuildRecurrenceData(void *data);
public:
Calendar();
~Calendar();
// Parser / Builder API (see parser.h / builder.h)
uint8_t GetRecType() const { return RecType; }
uint32_t GetUniqueId() const { return RecordId; }
void SetIds(uint8_t Type, uint32_t Id) { RecType = Type; RecordId =
Id; }
void ParseHeader(const Data &data, size_t &offset);
void ParseFields(const Data &data, size_t &offset);
void BuildHeader(Data &data, size_t &offset) const;
void BuildFields(Data &data, size_t &offset) const;
void Clear();
void Dump(std::ostream &os) const;
// sorting
bool operator<(const Calendar &other) const { return StartTime < oth
er.StartTime; }
// database name
static const char * GetDBName() { return "Calendar"; }
static uint8_t GetDefaultRecType() { return 5; } // or 0?
};
inline std::ostream& operator<<(std::ostream &os, const Calendar &msg) {
msg.Dump(os);
return os;
}
// This is a packed field, which is a group of fields packed in
// variable length records inside one larger field of a normal record.
class ServiceBookConfig
{
public:
typedef std::vector<UnknownField> UnknownsType;
uint8_t Format;
UnknownsType Unknowns;
public:
const unsigned char* ParseField(const unsigned char *begin,
const unsigned char *end);
public:
ServiceBookConfig();
~ServiceBookConfig();
// Parser / Builder API (see parser.h / builder.h)
void ParseHeader(const Data &data, size_t &offset);
void ParseFields(const Data &data, size_t &offset);
void BuildHeader(Data &data, size_t &offset) const;
void BuildFields(Data &data, size_t &offset) const;
void Clear();
void Dump(std::ostream &os) const;
};
inline std::ostream& operator<<(std::ostream &os, const ServiceBookConfig &
msg) {
msg.Dump(os);
return os;
}
class ServiceBook
{
int NameType, DescType, UniqueIdType;
public:
typedef std::vector<UnknownField> UnknownsType;
uint8_t RecType;
uint32_t RecordId;
std::string Name;
std::string HiddenName;
std::string Description;
std::string DSID;
std::string BesDomain;
std::string UniqueId;
std::string ContentId;
ServiceBookConfig Config;
UnknownsType Unknowns;
public:
const unsigned char* ParseField(const unsigned char *begin,
const unsigned char *end);
public:
ServiceBook();
~ServiceBook();
// Parser / Builder API (see parser.h / builder.h)
uint8_t GetRecType() const { return RecType; }
uint32_t GetUniqueId() const { return RecordId; }
void SetIds(uint8_t Type, uint32_t Id) { RecType = Type; RecordId =
Id; }
void ParseHeader(const Data &data, size_t &offset);
void ParseFields(const Data &data, size_t &offset);
void BuildHeader(Data &data, size_t &offset) const;
void BuildFields(Data &data, size_t &offset) const;
std::string GetLabel() const;
void Clear(); void Clear();
void Dump(std::ostream &os) const; bool HasData() const { return Address1.size() || Address2.size() ||
Address3.size() || City.size() || Province.size() ||
// sorting PostalCode.size() || Country.size(); }
bool operator<(const ServiceBook &other) const { return RecordId < R
ecordId; }
// database name
static const char * GetDBName() { return "Service Book"; }
static uint8_t GetDefaultRecType() { return 0; }
}; };
std::ostream& operator<<(std::ostream &os, const PostalAddress &msga);
inline std::ostream& operator<<(std::ostream &os, const ServiceBook &msg) { /// \addtogroup RecordParserClasses
msg.Dump(os); /// Parser and data storage classes. These classes take a
return os; /// Database Database record and convert them into C++ objects.
} /// Each of these classes are safe to be used in standard
/// containers, and are meant to be used in conjunction with the
/// RecordParser<> template when calling Controller::LoadDatabas
e().
/// @{
/// @} /// @}
} // namespace Barry } // namespace Barry
// Include all parser classes, to make it easy for the application to use.
#include "r_calendar.h"
#include "r_contact.h"
#include "r_memo.h"
#include "r_message.h"
#include "r_servicebook.h"
#include "r_task.h"
#include "r_pin_message.h"
#include "r_saved_message.h"
#include "r_folder.h"
#endif #endif
 End of changes. 12 change blocks. 
357 lines changed or deleted 41 lines changed or added


 s11n-boost.h   s11n-boost.h 
skipping to change at line 48 skipping to change at line 48
// equal or greater than this, only mappable , // equal or greater than this, only mappable ,
// POD data is included in the serialization // POD data is included in the serialization
// //
#define BARRY_BASE_S11N_VERSION 0 #define BARRY_BASE_S11N_VERSION 0
#define BARRY_POD_MAP_VERSION 1000 #define BARRY_POD_MAP_VERSION 1000
// namespace boost::serialization, for the non-intrusive version // namespace boost::serialization, for the non-intrusive version
namespace boost { namespace boost {
namespace serialization { namespace serialization {
template <class Archive> template <class ArchiveT>
void serialize(Archive &ar, Barry::UnknownField &uf, const unsigned int ver void serialize(ArchiveT &ar, Barry::UnknownField &uf, const unsigned int ve
) r)
{ {
ar & make_nvp("type", uf.type); ar & make_nvp("type", uf.type);
ar & make_nvp("data", uf.data); ar & make_nvp("data", uf.data);
} }
template <class Archive> template <class ArchiveT>
void serialize(Archive &ar, Barry::Contact::GroupLink &g, const unsigned in void serialize(ArchiveT &ar, Barry::Contact::GroupLink &g, const unsigned i
t ver) nt ver)
{ {
ar & make_nvp("Link", g.Link); ar & make_nvp("Link", g.Link);
ar & make_nvp("Unknown", g.Unknown); ar & make_nvp("Unknown", g.Unknown);
} }
template <class Archive> template <class ArchiveT>
void serialize(Archive &ar, Barry::Contact &c, const unsigned int ver) void serialize(ArchiveT &ar, Barry::Contact &c, const unsigned int ver)
{ {
ar & make_nvp("RecordId", c.RecordId); ar & make_nvp("RecordId", c.RecordId);
ar & make_nvp("Email", c.Email); ar & make_nvp("Email", c.Email);
ar & make_nvp("Phone", c.Phone); ar & make_nvp("Phone", c.Phone);
ar & make_nvp("Fax", c.Fax); ar & make_nvp("Fax", c.Fax);
ar & make_nvp("WorkPhone", c.WorkPhone); ar & make_nvp("WorkPhone", c.WorkPhone);
ar & make_nvp("HomePhone", c.HomePhone); ar & make_nvp("HomePhone", c.HomePhone);
ar & make_nvp("MobilePhone", c.MobilePhone); ar & make_nvp("MobilePhone", c.MobilePhone);
ar & make_nvp("Pager", c.Pager); ar & make_nvp("Pager", c.Pager);
ar & make_nvp("PIN", c.PIN); ar & make_nvp("PIN", c.PIN);
ar & make_nvp("Radio", c.Radio);
ar & make_nvp("WorkPhone2", c.WorkPhone2);
ar & make_nvp("HomePhone2", c.HomePhone2);
ar & make_nvp("OtherPhone", c.OtherPhone);
ar & make_nvp("FirstName", c.FirstName); ar & make_nvp("FirstName", c.FirstName);
ar & make_nvp("LastName", c.LastName); ar & make_nvp("LastName", c.LastName);
ar & make_nvp("Company", c.Company); ar & make_nvp("Company", c.Company);
ar & make_nvp("DefaultCommunicationsMethod", c.DefaultCommunications Method); ar & make_nvp("DefaultCommunicationsMethod", c.DefaultCommunications Method);
ar & make_nvp("Address1", c.Address1); ar & make_nvp("Address1", c.WorkAddress.Address1);
ar & make_nvp("Address2", c.Address2); ar & make_nvp("Address2", c.WorkAddress.Address2);
ar & make_nvp("Address3", c.Address3); ar & make_nvp("Address3", c.WorkAddress.Address3);
ar & make_nvp("City", c.City); ar & make_nvp("City", c.WorkAddress.City);
ar & make_nvp("Province", c.Province); ar & make_nvp("Province", c.WorkAddress.Province);
ar & make_nvp("PostalCode", c.PostalCode); ar & make_nvp("PostalCode", c.WorkAddress.PostalCode);
ar & make_nvp("Country", c.Country); ar & make_nvp("Country", c.WorkAddress.Country);
ar & make_nvp("Title", c.Title); ar & make_nvp("JobTitle", c.JobTitle);
ar & make_nvp("PublicKey", c.PublicKey); ar & make_nvp("PublicKey", c.PublicKey);
ar & make_nvp("URL", c.URL);
ar & make_nvp("Prefix", c.Prefix);
ar & make_nvp("Category", c.Category);
ar & make_nvp("HomeAddress1", c.HomeAddress.Address1);
ar & make_nvp("HomeAddress2", c.HomeAddress.Address2);
ar & make_nvp("HomeAddress3", c.HomeAddress.Address3);
ar & make_nvp("Notes", c.Notes); ar & make_nvp("Notes", c.Notes);
ar & make_nvp("UserDefined1", c.UserDefined1);
ar & make_nvp("UserDefined2", c.UserDefined2);
ar & make_nvp("UserDefined3", c.UserDefined3);
ar & make_nvp("UserDefined4", c.UserDefined4);
ar & make_nvp("HomeCity", c.HomeAddress.City);
ar & make_nvp("HomeProvince", c.HomeAddress.Province);
ar & make_nvp("HomePostalCode", c.HomeAddress.PostalCode);
ar & make_nvp("HomeCountry", c.HomeAddress.Country);
ar & make_nvp("Image", c.Image);
if( ver < BARRY_POD_MAP_VERSION ) { if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp("GroupLinks", c.GroupLinks); ar & make_nvp("GroupLinks", c.GroupLinks);
ar & make_nvp("Unknowns", c.Unknowns); ar & make_nvp("Unknowns", c.Unknowns);
} }
} }
template <class Archive> template <class ArchiveT>
void serialize(Archive &ar, Barry::Message::Address &a, const unsigned int void serialize(ArchiveT &ar, Barry::EmailAddress &a, const unsigned int ver
ver) )
{ {
ar & make_nvp("Name", a.Name); ar & make_nvp("Name", a.Name);
ar & make_nvp("Email", a.Email); ar & make_nvp("Email", a.Email);
} }
template <class Archive> template <class ArchiveT>
void serialize(Archive &ar, Barry::Message &m, const unsigned int ver) void serialize(ArchiveT &ar, Barry::Message &m, const unsigned int ver)
{ {
ar & make_nvp("From", m.From); ar & make_nvp("From", m.From);
ar & make_nvp("To", m.To); ar & make_nvp("To", m.To);
ar & make_nvp("Cc", m.Cc); ar & make_nvp("Cc", m.Cc);
ar & make_nvp("Sender", m.Sender);
ar & make_nvp("ReplyTo", m.ReplyTo);
ar & make_nvp("Subject", m.Subject); ar & make_nvp("Subject", m.Subject);
ar & make_nvp("Body", m.Body); ar & make_nvp("Body", m.Body);
ar & make_nvp("Attachment", m.Attachment);
if( ver < BARRY_POD_MAP_VERSION ) { if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp("Unknowns", m.Unknowns); ar & make_nvp("Unknowns", m.Unknowns);
} }
} }
template <class Archive> template <class ArchiveT>
void serialize(Archive &ar, Barry::Calendar &c, const unsigned int ver) void serialize(ArchiveT &ar, Barry::Calendar &c, const unsigned int ver)
{ {
ar & make_nvp("RecordId", c.RecordId); ar & make_nvp("RecordId", c.RecordId);
ar & make_nvp("Recurring", c.Recurring); ar & make_nvp("Recurring", c.Recurring);
ar & make_nvp("AllDayEvent", c.AllDayEvent); ar & make_nvp("AllDayEvent", c.AllDayEvent);
ar & make_nvp("Subject", c.Subject); ar & make_nvp("Subject", c.Subject);
ar & make_nvp("Notes", c.Notes); ar & make_nvp("Notes", c.Notes);
ar & make_nvp("Location", c.Location); ar & make_nvp("Location", c.Location);
ar & make_nvp("NotificationTime", c.NotificationTime); ar & make_nvp("NotificationTime", c.NotificationTime);
ar & make_nvp("StartTime", c.StartTime); ar & make_nvp("StartTime", c.StartTime);
ar & make_nvp("EndTime", c.EndTime); ar & make_nvp("EndTime", c.EndTime);
ar & make_nvp("FreeBusyFlag", c.FreeBusyFlag);
ar & make_nvp("ClassFlag", c.ClassFlag);
ar & make_nvp("Recurring", c.Recurring);
ar & make_nvp("RecurringType", c.RecurringType);
ar & make_nvp("Interval", c.Interval);
ar & make_nvp("RecurringEndTime", c.RecurringEndTime);
ar & make_nvp("Perpetual", c.Perpetual);
ar & make_nvp("TimeZoneCode", c.TimeZoneCode);
if( ver < BARRY_POD_MAP_VERSION ) { if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp("Unknowns", c.Unknowns); ar & make_nvp("Unknowns", c.Unknowns);
} }
} }
template <class Archive> template <class ArchiveT>
void serialize(Archive &ar, Barry::ServiceBook &c, const unsigned int ver) void serialize(ArchiveT &ar, Barry::ServiceBook &c, const unsigned int ver)
{ {
ar & make_nvp("RecordId", c.RecordId); ar & make_nvp("RecordId", c.RecordId);
if( ver < BARRY_POD_MAP_VERSION ) { if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp("Unknowns", c.Unknowns); ar & make_nvp("Unknowns", c.Unknowns);
} }
} }
template <class ArchiveT>
void serialize(ArchiveT &ar, Barry::Memo &m, const unsigned int ver)
{
ar & make_nvp("RecordId", m.RecordId);
ar & make_nvp("Title", m.Title);
ar & make_nvp("Body", m.Body);
ar & make_nvp("Category", m.Category);
if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp( "Unknowns", m.Unknowns);
}
}
template <class ArchiveT>
void serialize(ArchiveT &ar, Barry::Task &t, const unsigned int ver)
{
ar & make_nvp("RecordId", t.RecordId);
ar & make_nvp("Summary", t.Summary);
ar & make_nvp("Notes", t.Notes);
ar & make_nvp("Categories", t.Categories);
ar & make_nvp("StartTime", t.StartTime);
ar & make_nvp("AlarmTime", t.AlarmTime);
ar & make_nvp("DueTime", t.DueTime);
ar & make_nvp("TimeZoneCode", t.TimeZoneCode);
ar & make_nvp("AlarmType", t.AlarmType);
ar & make_nvp("Interval", t.Interval);
ar & make_nvp("RecurringType", t.RecurringType);
ar & make_nvp("RecurringEndTime", t.RecurringEndTime);
ar & make_nvp("ClassType", t.ClassType);
ar & make_nvp("PriorityFlag", t.PriorityFlag);
ar & make_nvp("StatusFlag", t.StatusFlag);
ar & make_nvp("Recurring", t.Recurring);
if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp( "Unknowns", t.Unknowns);
}
}
template<class ArchiveT>
void serialize(ArchiveT &ar, Barry::PINMessage &p, const unsigned int ver)
{
ar & make_nvp("From", p.From);
ar & make_nvp("To", p.To);
ar & make_nvp("Cc", p.Cc);
ar & make_nvp("Bcc", p.Bcc);
ar & make_nvp("Subject", p.Subject);
ar & make_nvp("Body", p.Body);
if(ver < BARRY_POD_MAP_VERSION) {
ar & make_nvp("Unknowns", p.Unknowns);
}
}
template <class ArchiveT>
void serialize(ArchiveT &ar, Barry::SavedMessage &m, const unsigned int ver
)
{
ar & make_nvp("From", m.From);
ar & make_nvp("To", m.To);
ar & make_nvp("Cc", m.Cc);
ar & make_nvp("Bcc", m.Bcc);
ar & make_nvp("Sender", m.Sender);
ar & make_nvp("ReplyTo", m.ReplyTo);
ar & make_nvp("Subject", m.Subject);
ar & make_nvp("Body", m.Body);
ar & make_nvp("Attachment", m.Attachment);
if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp("Unknowns", m.Unknowns);
}
}
template <class ArchiveT>
void serialize(ArchiveT &ar, Barry::Folder &f, const unsigned int ver)
{
ar & make_nvp("FolderName", f.FolderName);
if( ver < BARRY_POD_MAP_VERSION ) {
ar & make_nvp( "Unknowns", f.Unknowns);
}
}
}} // namespace boost::serialization }} // namespace boost::serialization
#endif #endif
 End of changes. 15 change blocks. 
25 lines changed or deleted 142 lines changed or added


 time.h   time.h 
skipping to change at line 28 skipping to change at line 28
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the GNU General Public License in the COPYING file at the See the GNU General Public License in the COPYING file at the
root directory of this project for more details. root directory of this project for more details.
*/ */
#ifndef __BARRY_TIME_H__ #ifndef __BARRY_TIME_H__
#define __BARRY_TIME_H__ #define __BARRY_TIME_H__
#include <time.h> #include <time.h>
#include <stdint.h>
// //
// Calculate the number of minutes between Jan 01, 1900 and Jan 01, 1970 // Calculate the number of minutes between Jan 01, 1900 and Jan 01, 1970
// //
// There are 17 leap years between 1900 and 1970 // There are 17 leap years between 1900 and 1970
// (1969-1900) / 4 = 17.25 // (1969-1900) / 4 = 17.25
// //
// 1900 itself is not a leap year (not divisible by 400) // 1900 itself is not a leap year (not divisible by 400)
// //
#define DAY_MINUTES (24 * 60) #define DAY_MINUTES (24 * 60)
skipping to change at line 71 skipping to change at line 72
}; };
// FIXME - put this somewhere for both C and C++ // FIXME - put this somewhere for both C and C++
#define TIME_ZONE_CODE_ERR 0xffff #define TIME_ZONE_CODE_ERR 0xffff
const TimeZone* GetTimeZoneTable(); const TimeZone* GetTimeZoneTable();
const TimeZone* GetTimeZone(unsigned short Code); const TimeZone* GetTimeZone(unsigned short Code);
unsigned short GetTimeZoneCode(signed short HourOffset, unsigned short GetTimeZoneCode(signed short HourOffset,
signed short MinOffset = 0); signed short MinOffset = 0);
// Message time conversion stuff
time_t DayToDate( unsigned short Day );
time_t Message2Time(uint16_t r_date, uint16_t r_time);
} // namespace Barry } // namespace Barry
#endif #endif
 End of changes. 2 change blocks. 
0 lines changed or deleted 5 lines changed or added


 usbwrap.h   usbwrap.h 
skipping to change at line 122 skipping to change at line 122
bool InterruptWrite(int ep, const Barry::Data &data, int timeout = - 1); bool InterruptWrite(int ep, const Barry::Data &data, int timeout = - 1);
void BulkDrain(int ep); void BulkDrain(int ep);
}; };
class Interface class Interface
{ {
Device &m_dev; Device &m_dev;
int m_iface; int m_iface;
public: public:
Interface(Device &dev, int iface) Interface(Device &dev, int iface);
: m_dev(dev), m_iface(iface) ~Interface();
{
if( usb_claim_interface(dev.GetHandle(), iface) < 0 )
throw Error("claim interface failed");
}
~Interface()
{
usb_release_interface(m_dev.GetHandle(), m_iface);
}
}; };
// Map of Endpoint numbers (not indexes) to endpoint descriptors // Map of Endpoint numbers (not indexes) to endpoint descriptors
struct EndpointPair struct EndpointPair
{ {
unsigned char read; unsigned char read;
unsigned char write; unsigned char write;
unsigned char type; unsigned char type;
EndpointPair() : read(0), write(0), type(0xff) {} EndpointPair() : read(0), write(0), type(0xff) {}
 End of changes. 1 change blocks. 
11 lines changed or deleted 2 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/