src/record.h

   1 ///
   2 /// \file       record.h
   3 ///             Blackberry database record classes.  Help translate data
   4 ///             from data packets to useful structurs, and back.
   5 ///
   6
   7 /*
   8     Copyright (C) 2005, Net Direct Inc. (http://www.netdirect.ca/)
   9
  10     This program is free software; you can redistribute it and/or modify
  11     it under the terms of the GNU General Public License as published by
  12     the Free Software Foundation; either version 2 of the License, or
  13     (at your option) any later version.
  14
  15     This program is distributed in the hope that it will be useful,
  16     but WITHOUT ANY WARRANTY; without even the implied warranty of
  17     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  18
  19     See the GNU General Public License in the COPYING file at the
  20     root directory of this project for more details.
  21 */
  22
  23 #ifndef __BARRY_RECORD_H__
  24 #define __BARRY_RECORD_H__
  25
  26 #include <iosfwd>
  27 #include <string>
  28 #include <vector>
  29 #include <stdint.h>
  30
  31 // forward declarations
  32 class Data;
  33
  34 namespace Barry {
  35
  36 //
  37 // NOTE:  All classes here must be container-safe!  Perhaps add sorting
  38 //        operators in the future.
  39 //
  40
  41
  42
  43 class CommandTable
  44 {
  45 public:
  46         struct Command
  47         {
  48                 unsigned int Code;
  49                 std::string Name;
  50         };
  51
  52         typedef std::vector<Command> CommandArrayType;
  53
  54         CommandArrayType Commands;
  55
  56 private:
  57         const unsigned char* ParseField(const unsigned char *begin,
  58                 const unsigned char *end);
  59 public:
  60         CommandTable();
  61         ~CommandTable();
  62
  63         void Parse(const Data &data, int offset);
  64         void Clear();
  65
  66         // returns 0 if unable to find command name, which is safe, since
  67         // 0 is a special command that shouldn't be in the table anyway
  68         unsigned int GetCommand(const std::string &name) const;
  69
  70         void Dump(std::ostream &os) const;
  71 };
  72
  73 inline std::ostream& operator<< (std::ostream &os, const CommandTable &command) {
  74         command.Dump(os);
  75         return os;
  76 }
  77
  78
  79
  80 class DatabaseDatabase
  81 {
  82 public:
  83         struct Database
  84         {
  85                 unsigned int Number;
  86                 unsigned int RecordCount;
  87                 std::string Name;
  88         };
  89
  90         typedef std::vector<Database> DatabaseArrayType;
  91
  92         DatabaseArrayType Databases;
  93
  94 private:
  95         template <class RecordType, class FieldType>
  96         void ParseRec(const RecordType &rec, const unsigned char *end);
  97
  98         template <class FieldType>
  99         const unsigned char* ParseField(const unsigned char *begin,
 100                 const unsigned char *end);
 101
 102 public:
 103         DatabaseDatabase();
 104         ~DatabaseDatabase();
 105
 106         void Parse(const Data &data);
 107         void Clear();
 108
 109         // FIXME - returns 0 on error here, but that's a valid DBNumber
 110         unsigned int GetDBNumber(const std::string &name) const;
 111
 112         void Dump(std::ostream &os) const;
 113 };
 114
 115 inline std::ostream& operator<<(std::ostream &os, const DatabaseDatabase &dbdb) {
 116         dbdb.Dump(os);
 117         return os;
 118 }
 119
 120
 121
 122 struct UnknownField
 123 {
 124         uint8_t type;
 125         std::string data;
 126 };
 127 std::ostream& operator<< (std::ostream &os, const std::vector<UnknownField> &unknowns);
 128
 129
 130 /// \addtogroup RecordParserClasses
 131 ///             Parser and data storage classes.  These classes take a
 132 ///             Database Database record and convert them into C++ objects.
 133 ///             Each of these classes are safe to be used in standard
 134 ///             containers, and are meant to be used in conjunction with the
 135 ///             RecordParser<> template when calling Controller::LoadDatabase().
 136 /// @{
 137
 138 class Contact
 139 {
 140 private:
 141         // private contact management data
 142         uint64_t m_recordId;
 143
 144 public:
 145         // contact specific data
 146         std::string
 147                 Email,
 148                 Phone,
 149                 Fax,
 150                 WorkPhone,
 151                 HomePhone,
 152                 MobilePhone,
 153                 Pager,
 154                 PIN,
 155                 FirstName,
 156                 LastName,
 157                 Company,
 158                 DefaultCommunicationsMethod,
 159                 Address1,
 160                 Address2,
 161                 Address3,
 162                 City,
 163                 Province,
 164                 PostalCode,
 165                 Country,
 166                 Title,
 167                 PublicKey,
 168                 Notes;
 169
 170         std::vector<uint64_t> GroupLinks;
 171         std::vector<UnknownField> Unknowns;
 172
 173
 174 //protected:
 175 public:
 176         const unsigned char* ParseField(const unsigned char *begin,
 177                 const unsigned char *end);
 178
 179 public:
 180         Contact();
 181         ~Contact();
 182
 183         uint64_t GetID() const { return m_recordId; }
 184         std::string GetPostalAddress() const;
 185
 186         void Parse(const Data &data, unsigned int operation);
 187         void Clear();                   // erase everything
 188
 189         void Dump(std::ostream &os) const;
 190         void DumpLdif(std::ostream &os, const std::string &baseDN) const;
 191
 192         // protocol record sizes
 193         static size_t GetOldProtocolRecordSize();
 194         static size_t GetProtocolRecordSize();
 195 };
 196
 197 inline std::ostream& operator<< (std::ostream &os, const Contact &contact) {
 198         contact.Dump(os);
 199         return os;
 200 }
 201
 202 class Message
 203 {
 204 public:
 205         struct Address
 206         {
 207                 std::string Name;
 208                 std::string Email;
 209         };
 210
 211
 212         Address From;
 213         Address To;
 214         Address Cc;
 215         std::string Subject;
 216         std::string Body;
 217         std::vector<UnknownField> Unknowns;
 218
 219 public:
 220         Message();
 221         ~Message();
 222
 223         const unsigned char* ParseField(const unsigned char *begin,
 224                 const unsigned char *end);
 225         void Parse(const Data &data, unsigned int operation);
 226         void Clear();
 227
 228         void Dump(std::ostream &os) const;
 229
 230         // protocol record sizes
 231         static size_t GetOldProtocolRecordSize();
 232         static size_t GetProtocolRecordSize();
 233 };
 234
 235 inline std::ostream& operator<<(std::ostream &os, const Message &msg) {
 236         msg.Dump(os);
 237         return os;
 238 }
 239
 240 std::ostream& operator<<(std::ostream &os, const Message::Address &msga);
 241
 242
 243 class Calendar
 244 {
 245 private:
 246         uint64_t m_recordId;
 247
 248 public:
 249         std::string Subject;
 250         std::string Notes;
 251         std::string Location;
 252         time_t NotificationTime;
 253         time_t StartTime;
 254         time_t EndTime;
 255         std::vector<UnknownField> Unknowns;
 256
 257 public:
 258         Calendar();
 259         ~Calendar();
 260
 261         const unsigned char* ParseField(const unsigned char *begin,
 262                 const unsigned char *end);
 263         void Parse(const Data &data, unsigned int operation);
 264         void Clear();
 265
 266         void Dump(std::ostream &os) const;
 267
 268         // protocol record sizes
 269         static size_t GetOldProtocolRecordSize();
 270         static size_t GetProtocolRecordSize();
 271 };
 272
 273 inline std::ostream& operator<<(std::ostream &os, const Calendar &msg) {
 274         msg.Dump(os);
 275         return os;
 276 }
 277
 278 /// @}
 279
 280 } // namespace Barry
 281
 282 #endif
 283