3 /// Blackberry database record classes. Help translate data
4 /// from data packets to useful structurs, and back.
5 /// This header provides the common types and classes
6 /// used by the general record parser classes in the
7 /// r_*.h files. Only application-safe API stuff goes in
8 /// here. Internal library types go in record-internal.h
12 Copyright (C) 2005-2012, Net Direct Inc. (http://www.netdirect.ca/)
14 This program is free software; you can redistribute it and/or modify
15 it under the terms of the GNU General Public License as published by
16 the Free Software Foundation; either version 2 of the License, or
17 (at your option) any later version.
19 This program is distributed in the hope that it will be useful,
20 but WITHOUT ANY WARRANTY; without even the implied warranty of
21 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
23 See the GNU General Public License in the COPYING file at the
24 root directory of this project for more details.
27 #ifndef __BARRY_RECORD_H__
28 #define __BARRY_RECORD_H__
38 // forward declarations
39 namespace Barry
{ class Data
; }
44 // NOTE: All classes here must be container-safe! Perhaps add sorting
45 // operators in the future.
49 // stream-based wrapper to avoid printing strings that contain
50 // the \r carriage return characters
51 class BXEXPORT Cr2LfWrapper
53 friend std::ostream
& operator<< (std::ostream
&os
, const Cr2LfWrapper
&str
);
54 const std::string
&m_str
;
56 explicit Cr2LfWrapper(const std::string
&str
)
61 BXEXPORT
std::ostream
& operator<< (std::ostream
&os
, const Cr2LfWrapper
&str
);
63 struct BXEXPORT CommandTableCommand
69 class BXEXPORT CommandTable
72 typedef CommandTableCommand Command
;
73 typedef std::vector
<Command
> CommandArrayType
;
75 CommandArrayType Commands
;
78 BXLOCAL
const unsigned char* ParseField(const unsigned char *begin
,
79 const unsigned char *end
);
84 void Parse(const Data
&data
, size_t offset
);
87 // returns 0 if unable to find command name, which is safe, since
88 // 0 is a special command that shouldn't be in the table anyway
89 unsigned int GetCommand(const std::string
&name
) const;
91 void Dump(std::ostream
&os
) const;
94 BXEXPORT
inline std::ostream
& operator<< (std::ostream
&os
, const CommandTable
&command
) {
101 struct BXEXPORT RecordStateTableState
106 unsigned int RecType
;
107 std::string Unknown2
;
110 class BXEXPORT RecordStateTable
113 typedef RecordStateTableState State
;
114 typedef unsigned int IndexType
;
115 typedef std::map
<IndexType
, State
> StateMapType
;
117 StateMapType StateMap
;
120 mutable IndexType m_LastNewRecordId
;
123 BXLOCAL
const unsigned char* ParseField(const unsigned char *begin
,
124 const unsigned char *end
);
130 void Parse(const Data
&data
);
133 bool GetIndex(uint32_t RecordId
, IndexType
*pFoundIndex
= 0) const;
134 uint32_t MakeNewRecordId() const;
136 void Dump(std::ostream
&os
) const;
139 BXEXPORT
inline std::ostream
& operator<< (std::ostream
&os
, const RecordStateTable
&rst
) {
146 struct BXEXPORT DatabaseItem
149 unsigned int RecordCount
;
153 class BXEXPORT DatabaseDatabase
156 typedef DatabaseItem Database
;
157 typedef std::vector
<Database
> DatabaseArrayType
;
159 DatabaseArrayType Databases
;
162 template <class RecordType
, class FieldType
>
163 void ParseRec(const RecordType
&rec
, const unsigned char *end
);
165 template <class FieldType
>
166 const unsigned char* ParseField(const unsigned char *begin
,
167 const unsigned char *end
);
173 void Parse(const Data
&data
);
177 unsigned int GetTotalRecordCount() const;
179 // returns true on success, and fills target
180 bool GetDBNumber(const std::string
&name
, unsigned int &number
) const;
181 bool GetDBName(unsigned int number
, std::string
&name
) const;
183 void Dump(std::ostream
&os
) const;
186 BXEXPORT
inline std::ostream
& operator<<(std::ostream
&os
, const DatabaseDatabase
&dbdb
) {
193 std::string raw_data
;
195 const std::string::value_type
* data() const { return raw_data
.data(); }
196 std::string::size_type
size() const { return raw_data
.size(); }
197 void assign(const std::string::value_type
*s
, std::string::size_type n
)
198 { raw_data
.assign(s
, n
); }
200 bool operator==(const UnknownData
&other
) const
202 return raw_data
== other
.raw_data
;
205 bool operator!=(const UnknownData
&other
) const
207 return !operator==(other
);
211 struct BXEXPORT UnknownField
216 bool operator==(const UnknownField
&other
) const
218 return type
== other
.type
&&
222 bool operator!=(const UnknownField
&other
) const
224 return !operator==(other
);
227 typedef std::vector
<UnknownField
> UnknownsType
;
228 BXEXPORT
std::ostream
& operator<< (std::ostream
&os
, const UnknownsType
&unknowns
);
230 // simple email type and list
231 typedef std::string EmailType
;
232 typedef std::vector
<EmailType
> EmailList
;
234 // struct, attempting to combine name + email address, for mail
235 struct BXEXPORT EmailAddress
244 /// Converts "Name <address@host.com>" into Name + Address
245 /// Will also handle just a plain address too.
246 explicit EmailAddress(const std::string
&complex_address
);
256 return Name
.size() + Email
.size();
259 bool operator==(const EmailAddress
&other
) const
261 return Name
== other
.Name
&&
262 Email
== other
.Email
;
265 bool operator!=(const EmailAddress
&other
) const
267 return !operator==(other
);
270 BXEXPORT
std::ostream
& operator<<(std::ostream
&os
, const EmailAddress
&msga
);
272 class BXEXPORT EmailAddressList
: public std::vector
<EmailAddress
>
275 std::string
ToCommaSeparated() const;
276 void AddCommaSeparated(const std::string
&list
);
279 BXEXPORT
std::ostream
& operator<<(std::ostream
&os
, const EmailAddressList
&elist
);
281 struct BXEXPORT PostalAddress
292 std::string
GetLabel() const;
295 bool HasData() const { return Address1
.size() || Address2
.size() ||
296 Address3
.size() || City
.size() || Province
.size() ||
297 PostalCode
.size() || Country
.size(); }
299 bool operator==(const PostalAddress
&other
) const
301 return Address1
== other
.Address1
&&
302 Address2
== other
.Address2
&&
303 Address3
== other
.Address3
&&
304 City
== other
.City
&&
305 Province
== other
.Province
&&
306 PostalCode
== other
.PostalCode
&&
307 Country
== other
.Country
;
309 bool operator!=(const PostalAddress
&other
) const
311 return !operator==(other
);
314 BXEXPORT
std::ostream
& operator<<(std::ostream
&os
, const PostalAddress
&msga
);
318 int Month
; // 0 to 11
320 int Year
; // exact number, eg. 2008
322 Date() : Month(0), Day(0), Year(0) {}
323 explicit Date(const struct tm
*timep
);
325 bool HasData() const { return Month
|| Day
|| Year
; }
328 void ToTm(struct tm
*timep
) const;
329 std::string
ToYYYYMMDD() const;
330 std::string
ToBBString() const; // converts to Blackberry string
331 // format of DD/MM/YYYY
333 bool FromTm(const struct tm
*timep
);
334 bool FromBBString(const std::string
&str
);
335 bool FromYYYYMMDD(const std::string
&str
);
337 bool operator==(const Date
&other
) const
339 return Month
== other
.Month
&&
343 bool operator!=(const Date
&other
) const
345 return !operator==(other
);
348 BXEXPORT
std::ostream
& operator<<(std::ostream
&os
, const Date
&date
);
350 class BXEXPORT CategoryList
: public std::vector
<std::string
>
353 /// Parses the given comma delimited category string into
354 /// this CategoryList object, appending each token to the vector.
355 /// Will clear vector beforehand.
356 void CategoryStr2List(const std::string
&str
);
358 /// Turns the current vectory into a comma delimited category
359 /// string suitable for use in Calendar, Task, and Memo
361 void CategoryList2Str(std::string
&str
) const;
363 using std::vector
<std::string
>::operator=;
368 //////////////////////////////////////////////////////////////////////////////
369 // Generic Field Handles
371 /// \addtogroup GenericFieldHandles
372 /// Generic field handle classes, used to reference and work
373 /// with record members in a flexible, indirect way.
375 /// There are two ways to access device record data. The obvious
376 /// way is to instantiate a record class, such as Contact, and
377 /// access the public data members of that class to read and
378 /// write. If you always work with the same record class, this
381 /// The other way is to have a list of pointers to members.
382 /// For example, you may wish to compare two records, without
383 /// actually caring what data is in each one. You can compare
384 /// at the record class level, with Contact one, two; and then
385 /// if( one == two ), but this will not tell you what field in
386 /// the record changed.
388 /// This last feature is what Generic Field Handles are meant to
389 /// fix. Each record class will contain a GetFieldHandles()
390 /// member function, which will return a vector of FieldHandle<>
391 /// objects, for that specific record. For example, Contact
392 /// would fill a vector with FieldHandle<Contact> objects.
393 /// Each FieldHandle<> object contains a C++ pointer-to-member,
394 /// which the FieldHandle refers to, as well as a FieldIdentity
395 /// object. The FieldIdentity object contains various identitying
396 /// information, such as the C++ variable name, an English
397 /// (or localized language) display name of the field, suitable
398 /// for user prompts, and other data more useful to the library.
400 /// The FieldHandle<> object has two member functions: Value()
403 /// Value() will call a callback function with the _value_ of
404 /// the variable that FieldHandle<> points to. For example,
405 /// if the FieldHandle<> points to a std::string record member
406 /// variable, then Value() will pass that string value in as
407 /// an argument, along with a reference to the FieldIdentity
408 /// object. Value() requires a callback object and a record
409 /// object to perform this callback.
411 /// Member() will call a callback function/functor with the
412 /// pointer-to-member pointer and the FieldIdentity object.
413 /// This allows the programmer to create a functor with multiple
414 /// record objects, perhaps two objects to compare individual
415 /// fields, and use the pointer-to-member to access the field
418 /// For now, all data and callbacks are const, meaning that it
419 /// is not possible (without const_casting) to write to the
420 /// record via the pointers-to-members. This design decision
421 /// may need to be revisited someday, depending on its usefulness.
428 /// This class holds data that identifies a given field in a record.
429 /// This is fairly constant data, referenced by the FieldHandle class.
430 /// The information in here should be enough to show the user what kind
431 /// of field this is.
433 struct BXEXPORT FieldIdentity
435 // useful public data
436 const char *Name
; // C++ name of field member variable in
438 std::string DisplayName
; // localized display name of field
440 // FIXME - should we leave localization
441 // to the application?
443 // subfield detection
444 bool HasSubfields
; // true if this field has subfields
445 const char *ParentName
; // name of field member variable that
446 // this field is a member of, or NULL
447 // if this field is a member of the
449 // For example, Contact::PostalAddress
450 // would have HasSubfields == true,
451 // and ParentName == NULL, while all
452 // its subfield strings would have
453 // HasSubfields == false and
454 // ParentName == "WorkAddress" or
456 // The application could then decide
457 // whether to process only main fields,
458 // some of which have subfields,
459 // or only individual subfields.
461 // internal field data
462 int FieldTypeCode
; // device type code for this field.
463 // if -1, then this is a conglomerate
464 // C++ field, such as
465 // Contact::PostalAddress, not a device
467 // If -1, then none of the following
469 const char *Ldif
; // matching LDIF field name, or NULL
470 const char *ObjectClass
; // matching LDIF object class, or NULL
471 bool IconvNeeded
; // if true, the device's data needs to
472 // be passed through an IConverter
474 FieldIdentity(const char *name
, const std::string
&display_name
,
476 bool iconvneeded
= false,
477 const char *ldif
= 0, const char *oclass
= 0,
478 bool has_sub
= false, const char *parent
= 0
481 , DisplayName(display_name
)
482 , HasSubfields(has_sub
)
484 , FieldTypeCode(type_code
)
486 , ObjectClass(oclass
)
487 , IconvNeeded(iconvneeded
)
495 /// This is the base class for the hierarchy of classes to define
496 /// enum record members. This is the base class, which contains the
497 /// common code for creating and defining a list of enum constants for
498 /// a given enum field. The next derived class is EnumFieldBase<RecordT>,
499 /// which defines the virtual API for talking to a given enum field
500 /// in a given record. The next derived class is EnumField<RecordT, EnumT>,
501 /// which implements the pointer-to-member and virtual API for a given
502 /// enum type in a given record class.
504 /// For example, the Bookmark record class has the following enum field:
507 /// enum BrowserIdentityType
509 /// IdentityAuto = 0,
510 /// IdentityBlackBerry,
512 /// IdentityInternetExplorer,
515 /// BrowserIdentityType BrowserIdentity;
518 /// The EnumConstants class will hold a vector of EnumConstant structs
519 /// defining each of the identity constants: Auto, BlackBerry, FireFox,
520 /// InternetExplorer, and Unknown.
522 /// The derived class EnumFieldBase<Bookmark> will define two additional
523 /// pure virtual API calls: GetValue(const Bookmark&) and
524 /// SetValue(Bookmark&, int).
526 /// Finally, the derived class EnumField<Bookmark,Bookmark::BrowserIdentityType>
527 /// will implement the virtual API, and contain a pointer-to-member to
528 /// the Bookmark::BrowserIdentity member field.
530 /// The FieldHandle<Bookmark> class will hold a pointer to
531 /// EnumFieldBase<Bookmark>, which can hold a pointer to a specific
532 /// EnumField<> object, one object for each of Bookmark's enum types,
533 /// of which there are currently 3.
535 class BXEXPORT EnumConstants
538 /// This defines one of the enum constants being defined.
539 /// For example, for an enum declaration like:
540 /// enum Mine { A, B, C }; then this struct could contain
541 /// a definition for A, B, or C, but only one at at time.
542 /// All three would be defined by the EnumConstantList.
545 const char *Name
; //< C++ name of enum constant
546 std::string DisplayName
; //< user-friendly name / meaning
547 int Value
; //< constant enum value
549 EnumConstant(const char *name
, const std::string
&display
,
552 , DisplayName(display
)
558 typedef std::vector
<EnumConstant
> EnumConstantList
;
561 EnumConstantList m_constants
;
564 virtual ~EnumConstants() {}
566 /// Adds a constant definition to the list
567 void AddConstant(const char *name
, const std::string
&display
, int val
);
569 /// Returns a vector of EnumConstant objects, describing all enum
570 /// constants valid for this enum field.
571 const EnumConstantList
& GetConstantList() const { return m_constants
; }
573 /// Returns the EnumConstant for the given value.
574 /// Throws std::logic_error if not found.
575 const EnumConstant
& GetConstant(int value
) const;
577 /// Returns the constant name (C++ name) based on the given value.
578 /// Throws std::logic_error if not found.
579 const char* GetName(int value
) const;
581 /// Returns the display name based on the given value.
582 /// Throws std::logic_error if not found.
583 const std::string
& GetDisplayName(int value
) const;
585 /// Returns true if the value matches one of the constants in the list.
586 bool IsConstantValid(int value
) const;
590 // FieldValueHandlerBase
592 /// This is a pure virtual base class, defining the various types that
593 /// record fields can be. To be able to handle all the types of data
594 /// in all records, override these virtual functions to do with the
595 /// data as you wish.
597 /// All data from the records and fields will be passed in by value.
598 /// i.e. if field is string data, the overloaded std::string handler
599 /// will be called, and a refernce to the string will be passed in.
601 /// The advantage of using this virtual class is that less code will be
602 /// generated by templates. The disadvantage is that this is less flexible.
603 /// You will only get called for one field and record at a time.
604 /// So you can't do comparisons this way.
606 class BXEXPORT FieldValueHandlerBase
609 virtual ~FieldValueHandlerBase() {}
611 /// For type std::string
612 virtual void operator()(const std::string
&v
,
613 const FieldIdentity
&id
) const = 0;
614 /// For type EmailAddressList
615 virtual void operator()(const EmailAddressList
&v
,
616 const FieldIdentity
&id
) const = 0;
618 virtual void operator()(const time_t &v
,
619 const FieldIdentity
&id
) const = 0;
621 virtual void operator()(const uint8_t &v
,
622 const FieldIdentity
&id
) const = 0;
623 /// For type uint16_t
624 virtual void operator()(const uint16_t &v
,
625 const FieldIdentity
&id
) const = 0;
626 /// For type uint32_t
627 virtual void operator()(const uint32_t &v
,
628 const FieldIdentity
&id
) const = 0;
629 /// For type uint64_t
630 virtual void operator()(const uint64_t &v
,
631 const FieldIdentity
&id
) const = 0;
633 virtual void operator()(const bool &v
,
634 const FieldIdentity
&id
) const = 0;
636 virtual void operator()(const int32_t &v
,
637 const FieldIdentity
&id
) const = 0;
638 /// For type EmailList
639 virtual void operator()(const EmailList
&v
,
640 const FieldIdentity
&id
) const = 0;
642 virtual void operator()(const Date
&v
,
643 const FieldIdentity
&id
) const = 0;
644 /// For type CategoryList
645 virtual void operator()(const CategoryList
&v
,
646 const FieldIdentity
&id
) const = 0;
647 /// For type PostalAddress
648 virtual void operator()(const PostalAddress
&v
,
649 const FieldIdentity
&id
) const = 0;
650 /// For type UnknownsType
651 virtual void operator()(const UnknownsType
&v
,
652 const FieldIdentity
&id
) const = 0;
656 /// EnumFieldBase<RecordT>
658 template <class RecordT
>
659 class EnumFieldBase
: public EnumConstants
662 /// Return value of enum in rec
663 virtual int GetValue(const RecordT
&rec
) const = 0;
664 /// Set value of enum in rec
665 /// Throws std::logic_error if value is out of range
666 virtual void SetValue(RecordT
&rec
, int value
) = 0;
670 /// EnumField<RecordT, EnumT>
672 template <class RecordT
, class EnumT
>
673 class EnumField
: public EnumFieldBase
<RecordT
>
675 EnumT
RecordT::* m_mp
;
678 explicit EnumField(EnumT
RecordT::* mp
)
683 virtual int GetValue(const RecordT
&rec
) const
688 virtual void SetValue(RecordT
&rec
, int value
)
690 if( !this->IsConstantValid(value
) )
691 throw std::logic_error("Bad enum value in EnumField");
692 rec
.*m_mp
= (EnumT
) value
;
697 // FieldHandle<RecordT>
699 /// This is a template class that handles pointers to members of multiple
700 /// types of data and multiple types of records.
702 /// This class contains a union of all known data pointers in all records.
703 /// Therefore this class can hold a pointer to member of any record class.
705 /// To do something with the field that this FieldHandle<> class refers to,
706 /// call either Value() or Member() with appropriate callback functors.
707 /// Value will pass a reference to the field. You can use an object
708 /// derived from FieldValueHandlerBase here. Member() will pass a pointer
709 /// to member. Your functor will need to contain the record data in order
710 /// to access its data via the pointer to member.
712 /// The template functor callback that you pass into member must be
716 /// template <class RecordT>
721 /// void operator()(typename FieldHandle<RecordT>::PostalPointer pp,
722 /// const FieldIdentity &id) const
724 /// PostalAddress pa = m_rec.*(pp.m_PostalAddress);
725 /// std::string val = pa.*(pp.m_PostalField);
729 /// template <class TypeT>
730 /// void operator()(TypeT RecordT::* mp,
731 /// const FieldIdentity &id) const
733 /// TypeT val = m_rec.*mp;
739 /// You don't have to use a TypeT template, but if you don't, then you must
740 /// support all field types that the record class you're processing uses.
743 template <class RecordT
>
747 // Need to use this in the union, so no constructor allowed
750 PostalAddress
RecordT::* m_PostalAddress
;
751 std::string
PostalAddress::* m_PostalField
;
754 // So use a factory function
755 static PostalPointer
MakePostalPointer(PostalAddress
RecordT::* p1
,
756 std::string
PostalAddress::* p2
)
759 pp
.m_PostalAddress
= p1
;
760 pp
.m_PostalField
= p2
;
767 std::string
RecordT::* m_string
; // index 0
768 EmailAddressList
RecordT::* m_EmailAddressList
; // 1
769 time_t RecordT::* m_time
; // 2
770 PostalPointer m_postal
; // 3
771 uint8_t RecordT::* m_uint8
; // 4
772 uint32_t RecordT::* m_uint32
; // 5
773 EmailList
RecordT::* m_EmailList
; // 6
774 Date
RecordT::* m_Date
; // 7
775 CategoryList
RecordT::* m_CategoryList
; // 8
776 // GroupLinksType RecordT::* m_GroupLinksType; // 9
777 UnknownsType
RecordT::* m_UnknownsType
; // 10
778 bool RecordT::* m_bool
; // 11
779 uint64_t RecordT::* m_uint64
; // 12
780 uint16_t RecordT::* m_uint16
; // 13
781 PostalAddress
RecordT::* m_PostalAddress
; // 14
782 // used by non-union m_enum below: // 15
783 int32_t RecordT::* m_int32
; // 16
787 PointerUnion m_union
;
788 EnumFieldBase
<RecordT
> *m_enum
; // never freed, since this is a
789 // static list, existing to end of
796 FieldHandle(std::string
RecordT::* mp
, const FieldIdentity
&id
)
801 m_union
.m_string
= mp
;
805 FieldHandle(EmailAddressList
RecordT::* mp
, const FieldIdentity
&id
)
810 m_union
.m_EmailAddressList
= mp
;
814 FieldHandle(time_t RecordT::* mp
, const FieldIdentity
&id
)
823 FieldHandle(const PostalPointer
&pp
, const FieldIdentity
&id
)
828 m_union
.m_postal
= pp
;
832 FieldHandle(uint8_t RecordT::* mp
, const FieldIdentity
&id
)
837 m_union
.m_uint8
= mp
;
841 FieldHandle(uint32_t RecordT::* mp
, const FieldIdentity
&id
)
846 m_union
.m_uint32
= mp
;
850 FieldHandle(EmailList
RecordT::* mp
, const FieldIdentity
&id
)
855 m_union
.m_EmailList
= mp
;
859 FieldHandle(Date
RecordT::* mp
, const FieldIdentity
&id
)
868 FieldHandle(CategoryList
RecordT::* mp
, const FieldIdentity
&id
)
873 m_union
.m_CategoryList
= mp
;
877 // FieldHandle(GroupLinksType RecordT::* mp, const FieldIdentity &id)
882 // m_union.m_GroupLinksType = mp;
886 FieldHandle(UnknownsType
RecordT::* mp
, const FieldIdentity
&id
)
891 m_union
.m_UnknownsType
= mp
;
895 FieldHandle(bool RecordT::* mp
, const FieldIdentity
&id
)
904 FieldHandle(uint64_t RecordT::* mp
, const FieldIdentity
&id
)
909 m_union
.m_uint64
= mp
;
913 FieldHandle(uint16_t RecordT::* mp
, const FieldIdentity
&id
)
918 m_union
.m_uint16
= mp
;
922 FieldHandle(PostalAddress
RecordT::* mp
, const FieldIdentity
&id
)
927 m_union
.m_PostalAddress
= mp
;
931 FieldHandle(EnumFieldBase
<RecordT
> *enum_
, const FieldIdentity
&id
)
939 FieldHandle(int32_t RecordT::* mp
, const FieldIdentity
&id
)
944 m_union
.m_int32
= mp
;
947 /// Extracts FieldIdentity object from FieldHandle<>
948 const FieldIdentity
& GetIdentity() const { return m_id
; }
950 /// Calls the matching virtual function in FieldValueHandlerBase,
951 /// passing in the value of the field that this FieldHandle<>
952 /// refers to, and a referenct to the FieldIdentity object.
953 /// Caller must pass in a RecordT object as well.
954 void Value(const FieldValueHandlerBase
&vh
, const RecordT
&rec
) const
956 switch( m_type_index
)
959 vh(rec
.*(m_union
.m_string
), m_id
);
962 vh(rec
.*(m_union
.m_EmailAddressList
), m_id
);
965 vh(rec
.*(m_union
.m_time
), m_id
);
968 vh(rec
.*(m_union
.m_postal
.m_PostalAddress
).*(m_union
.m_postal
.m_PostalField
), m_id
);
971 vh(rec
.*(m_union
.m_uint8
), m_id
);
974 vh(rec
.*(m_union
.m_uint32
), m_id
);
977 vh(rec
.*(m_union
.m_EmailList
), m_id
);
980 vh(rec
.*(m_union
.m_Date
), m_id
);
983 vh(rec
.*(m_union
.m_CategoryList
), m_id
);
986 // vh(rec.*(m_union.m_GroupLinksType), m_id);
989 vh(rec
.*(m_union
.m_UnknownsType
), m_id
);
992 vh(rec
.*(m_union
.m_bool
), m_id
);
995 vh(rec
.*(m_union
.m_uint64
), m_id
);
998 vh(rec
.*(m_union
.m_uint16
), m_id
);
1001 vh(rec
.*(m_union
.m_PostalAddress
), m_id
);
1004 vh(m_enum
->GetValue(rec
), m_id
);
1007 vh(rec
.*(m_union
.m_int32
), m_id
);
1010 throw std::logic_error("Unknown field handle type index");
1014 /// Calls the callback functor with two arguments: the pointer to
1015 /// member that this FieldHandle<> contains, and the FieldIdentity
1016 /// object. It is assumed that the functor will either contain
1017 /// or know where to find one or more records of type RecordT.
1018 template <class CallbackT
>
1019 void Member(const CallbackT
&func
) const
1021 switch( m_type_index
)
1024 func(m_union
.m_string
, m_id
);
1027 func(m_union
.m_EmailAddressList
, m_id
);
1030 func(m_union
.m_time
, m_id
);
1033 func(m_union
.m_postal
, m_id
);
1036 func(m_union
.m_uint8
, m_id
);
1039 func(m_union
.m_uint32
, m_id
);
1042 func(m_union
.m_EmailList
, m_id
);
1045 func(m_union
.m_Date
, m_id
);
1048 func(m_union
.m_CategoryList
, m_id
);
1051 // func(m_union.m_GroupLinksType, m_id);
1054 func(m_union
.m_UnknownsType
, m_id
);
1057 func(m_union
.m_bool
, m_id
);
1060 func(m_union
.m_uint64
, m_id
);
1063 func(m_union
.m_uint16
, m_id
);
1066 func(m_union
.m_PostalAddress
, m_id
);
1072 func(m_union
.m_int32
, m_id
);
1075 throw std::logic_error("Unknown field handle type index");
1080 /// Factory function to create a FieldHandle<> object.
1081 template <class RecordT
, class TypeT
>
1082 FieldHandle
<RecordT
> MakeFieldHandle(TypeT
RecordT::* tp
,
1083 const FieldIdentity
&id
)
1085 return FieldHandle
<RecordT
>(tp
, id
);
1088 /// Calls FileHandle<>::Member() for each defined field for a given record type.
1089 /// Takes a vector of FileHandle<> objects, and calls Member(func) for each one.
1090 template <class HandlesT
, class CallbackT
>
1091 void ForEachField(const HandlesT
&handles
, const CallbackT
&func
)
1093 typename
HandlesT::const_iterator
1094 b
= handles
.begin(),
1096 for( ; b
!= e
; ++b
) {
1101 /// Calls FileHandle<>::Value() for each defined field for a given record.
1102 /// Takes a RecordT object and calls Value(vh, rec) for each FileHandle<>
1103 /// object in the record's FileHandles set.
1104 template <class RecordT
>
1105 void ForEachFieldValue(const RecordT
&rec
, const FieldValueHandlerBase
&vh
)
1107 typename
std::vector
<FieldHandle
<RecordT
> >::const_iterator
1108 b
= RecordT::GetFieldHandles().begin(),
1109 e
= RecordT::GetFieldHandles().end();
1110 for( ; b
!= e
; ++b
) {
1116 // FieldHandle setup macros
1118 // #undef and #define the following macros to override these macros for you:
1120 // CONTAINER_OBJECT_NAME - the new FieldHandles will be .push_back()'d into
1122 // RECORD_CLASS_NAME - the name of the record class you are defining,
1123 // i.e. Barry::Contact, or Barry::Calendar
1126 // plain field, no connection to device field
1127 #define FHP(name, display) \
1128 CONTAINER_OBJECT_NAME.push_back( \
1129 FieldHandle<RECORD_CLASS_NAME>(&RECORD_CLASS_NAME::name, \
1130 FieldIdentity(#name, display)))
1131 // record field with direct connection to device field, no LDIF data
1132 #define FHD(name, display, type_code, iconv) \
1133 CONTAINER_OBJECT_NAME.push_back( \
1134 FieldHandle<RECORD_CLASS_NAME>(&RECORD_CLASS_NAME::name, \
1135 FieldIdentity(#name, display, type_code, iconv, \
1137 // record field with direct connection to device field, with LDIF data
1138 #define FHL(name, display, type_code, iconv, ldif, oclass) \
1139 CONTAINER_OBJECT_NAME.push_back( \
1140 FieldHandle<RECORD_CLASS_NAME>(&RECORD_CLASS_NAME::name, \
1141 FieldIdentity(#name, display, type_code, iconv, \
1143 // a subfield of a conglomerate field, with direct connection to device field,
1145 #define FHS(name, subname, display, type, iconv, ldif, oclass) \
1146 CONTAINER_OBJECT_NAME.push_back( \
1147 FieldHandle<RECORD_CLASS_NAME>( \
1148 FieldHandle<RECORD_CLASS_NAME>::MakePostalPointer( \
1149 &RECORD_CLASS_NAME::name, \
1150 &PostalAddress::subname), \
1151 FieldIdentity(#name "::" #subname, display, \
1152 type, iconv, ldif, oclass, \
1154 // record conglomerate field, which has subfields
1155 #define FHC(name, display) \
1156 CONTAINER_OBJECT_NAME.push_back( \
1157 FieldHandle<RECORD_CLASS_NAME>(&RECORD_CLASS_NAME::name, \
1158 FieldIdentity(#name, display, \
1159 -1, false, 0, 0, true, 0)))
1160 // create a new EnumField<> and add it to the list... use the new_var_name
1161 // to add constants with FHE_CONST below
1162 #define FHE(new_var_name, record_field_type, record_field_name, display) \
1163 EnumField<RECORD_CLASS_NAME, RECORD_CLASS_NAME::record_field_type> \
1164 *new_var_name = new \
1165 EnumField<RECORD_CLASS_NAME, RECORD_CLASS_NAME::record_field_type> \
1166 (&RECORD_CLASS_NAME::record_field_name); \
1167 CONTAINER_OBJECT_NAME.push_back( \
1168 FieldHandle<RECORD_CLASS_NAME>(new_var_name, \
1169 FieldIdentity(#record_field_name, display)))
1170 // same as FHE, but for when RECORD_CLASS_NAME is a template argument
1171 #define FHET(new_var_name, record_field_type, record_field_name, display) \
1172 EnumField<RECORD_CLASS_NAME, typename RECORD_CLASS_NAME::record_field_type> \
1173 *new_var_name = new \
1174 EnumField<RECORD_CLASS_NAME, typename RECORD_CLASS_NAME::record_field_type> \
1175 (&RECORD_CLASS_NAME::record_field_name); \
1176 CONTAINER_OBJECT_NAME.push_back( \
1177 FieldHandle<RECORD_CLASS_NAME>(new_var_name, \
1178 FieldIdentity(#record_field_name, display)))
1179 // add constant to enum created above
1180 #define FHE_CONST(var, name, display) \
1181 var->AddConstant(#name, display, RECORD_CLASS_NAME::name)
1185 } // namespace Barry
1188 /// \addtogroup RecordParserClasses
1189 /// Parser and data storage classes. These classes take a
1190 /// Database Database record and convert them into C++ objects.
1191 /// Each of these classes are safe to be used in standard
1192 /// containers, and are meant to be used in conjunction with the
1193 /// RecordParser<> template when calling Controller::LoadDatabase().
1197 #ifndef __BARRY_LIBRARY_BUILD__
1198 // Include all parser classes, to make it easy for the application to use.
1199 #include "r_calendar.h"
1200 #include "r_calllog.h"
1201 #include "r_bookmark.h"
1202 #include "r_contact.h"
1203 #include "r_cstore.h"
1205 #include "r_message.h"
1206 #include "r_servicebook.h"
1208 #include "r_pin_message.h"
1209 #include "r_saved_message.h"
1211 #include "r_folder.h"
1212 #include "r_timezone.h"
1213 #include "r_hhagent.h"