record.h

Go to the documentation of this file.
00001 ///
00002 /// \file       record.h
00003 ///             Blackberry database record classes.  Help translate data
00004 ///             from data packets to useful structurs, and back.
00005 ///             This header provides the common types and classes
00006 ///             used by the general record parser classes in the
00007 ///             r_*.h files.  Only application-safe API stuff goes in
00008 ///             here.  Internal library types go in record-internal.h
00009 ///
00010 
00011 /*
00012     Copyright (C) 2005-2011, Net Direct Inc. (http://www.netdirect.ca/)
00013 
00014     This program is free software; you can redistribute it and/or modify
00015     it under the terms of the GNU General Public License as published by
00016     the Free Software Foundation; either version 2 of the License, or
00017     (at your option) any later version.
00018 
00019     This program is distributed in the hope that it will be useful,
00020     but WITHOUT ANY WARRANTY; without even the implied warranty of
00021     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
00022 
00023     See the GNU General Public License in the COPYING file at the
00024     root directory of this project for more details.
00025 */
00026 
00027 #ifndef __BARRY_RECORD_H__
00028 #define __BARRY_RECORD_H__
00029 
00030 #include "dll.h"
00031 #include <iosfwd>
00032 #include <string>
00033 #include <vector>
00034 #include <map>
00035 #include <stdint.h>
00036 
00037 // forward declarations
00038 namespace Barry { class Data; }
00039 
00040 namespace Barry {
00041 
00042 //
00043 // NOTE:  All classes here must be container-safe!  Perhaps add sorting
00044 //        operators in the future.
00045 //
00046 
00047 
00048 // stream-based wrapper to avoid printing strings that contain
00049 // the \r carriage return characters
00050 class BXEXPORT Cr2LfWrapper
00051 {
00052         friend std::ostream& operator<< (std::ostream &os, const Cr2LfWrapper &str);
00053         const std::string &m_str;
00054 public:
00055         explicit Cr2LfWrapper(const std::string &str)
00056                 : m_str(str)
00057         {
00058         }
00059 };
00060 BXEXPORT std::ostream& operator<< (std::ostream &os, const Cr2LfWrapper &str);
00061 
00062 struct BXEXPORT CommandTableCommand
00063 {
00064         unsigned int Code;
00065         std::string Name;
00066 };
00067 
00068 class BXEXPORT CommandTable
00069 {
00070 public:
00071         typedef CommandTableCommand Command;
00072         typedef std::vector<Command> CommandArrayType;
00073 
00074         CommandArrayType Commands;
00075 
00076 private:
00077         BXLOCAL const unsigned char* ParseField(const unsigned char *begin,
00078                 const unsigned char *end);
00079 public:
00080         CommandTable();
00081         ~CommandTable();
00082 
00083         void Parse(const Data &data, size_t offset);
00084         void Clear();
00085 
00086         // returns 0 if unable to find command name, which is safe, since
00087         // 0 is a special command that shouldn't be in the table anyway
00088         unsigned int GetCommand(const std::string &name) const;
00089 
00090         void Dump(std::ostream &os) const;
00091 };
00092 
00093 BXEXPORT inline std::ostream& operator<< (std::ostream &os, const CommandTable &command) {
00094         command.Dump(os);
00095         return os;
00096 }
00097 
00098 
00099 
00100 struct BXEXPORT RecordStateTableState
00101 {
00102         unsigned int Index;
00103         uint32_t RecordId;
00104         bool Dirty;
00105         unsigned int RecType;
00106         std::string Unknown2;
00107 };
00108 
00109 class BXEXPORT RecordStateTable
00110 {
00111 public:
00112         typedef RecordStateTableState State;
00113         typedef unsigned int IndexType;
00114         typedef std::map<IndexType, State> StateMapType;
00115 
00116         StateMapType StateMap;
00117 
00118 private:
00119         mutable IndexType m_LastNewRecordId;
00120 
00121 private:
00122         BXLOCAL const unsigned char* ParseField(const unsigned char *begin,
00123                 const unsigned char *end);
00124 
00125 public:
00126         RecordStateTable();
00127         ~RecordStateTable();
00128 
00129         void Parse(const Data &data);
00130         void Clear();
00131 
00132         bool GetIndex(uint32_t RecordId, IndexType *pFoundIndex = 0) const;
00133         uint32_t MakeNewRecordId() const;
00134 
00135         void Dump(std::ostream &os) const;
00136 };
00137 
00138 BXEXPORT inline std::ostream& operator<< (std::ostream &os, const RecordStateTable &rst) {
00139         rst.Dump(os);
00140         return os;
00141 }
00142 
00143 
00144 
00145 struct BXEXPORT DatabaseItem
00146 {
00147         unsigned int Number;
00148         unsigned int RecordCount;
00149         std::string Name;
00150 };
00151 
00152 class BXEXPORT DatabaseDatabase
00153 {
00154 public:
00155         typedef DatabaseItem Database;
00156         typedef std::vector<Database> DatabaseArrayType;
00157 
00158         DatabaseArrayType Databases;
00159 
00160 private:
00161         template <class RecordType, class FieldType>
00162         void ParseRec(const RecordType &rec, const unsigned char *end);
00163 
00164         template <class FieldType>
00165         const unsigned char* ParseField(const unsigned char *begin,
00166                 const unsigned char *end);
00167 
00168 public:
00169         DatabaseDatabase();
00170         ~DatabaseDatabase();
00171 
00172         void Parse(const Data &data);
00173         void Clear();
00174 
00175         void SortByName();
00176 
00177         // returns true on success, and fills target
00178         bool GetDBNumber(const std::string &name, unsigned int &number) const;
00179         bool GetDBName(unsigned int number, std::string &name) const;
00180 
00181         void Dump(std::ostream &os) const;
00182 };
00183 
00184 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const DatabaseDatabase &dbdb) {
00185         dbdb.Dump(os);
00186         return os;
00187 }
00188 
00189 struct UnknownData
00190 {
00191         std::string raw_data;
00192 
00193         const std::string::value_type* data() const { return raw_data.data(); }
00194         std::string::size_type size() const { return raw_data.size(); }
00195         void assign(const std::string::value_type *s, std::string::size_type n)
00196                 { raw_data.assign(s, n); }
00197 };
00198 
00199 struct BXEXPORT UnknownField
00200 {
00201         uint8_t type;
00202         UnknownData data;
00203 };
00204 typedef std::vector<UnknownField> UnknownsType;
00205 BXEXPORT std::ostream& operator<< (std::ostream &os, const UnknownsType &unknowns);
00206 
00207 struct BXEXPORT EmailAddress
00208 {
00209         std::string Name;
00210         std::string Email;
00211 
00212         void clear()
00213         {
00214                 Name.clear();
00215                 Email.clear();
00216         }
00217 
00218         size_t size() const
00219         {
00220                 return Name.size() + Email.size();
00221         }
00222 };
00223 BXEXPORT std::ostream& operator<<(std::ostream &os, const EmailAddress &msga);
00224 
00225 typedef std::vector<EmailAddress>       EmailAddressList;
00226 BXEXPORT std::ostream& operator<<(std::ostream &os, const EmailAddressList &elist);
00227 
00228 struct BXEXPORT PostalAddress
00229 {
00230         std::string
00231                 Address1,
00232                 Address2,
00233                 Address3,
00234                 City,
00235                 Province,
00236                 PostalCode,
00237                 Country;
00238 
00239         std::string GetLabel() const;
00240         void Clear();
00241 
00242         bool HasData() const { return Address1.size() || Address2.size() ||
00243                 Address3.size() || City.size() || Province.size() ||
00244                 PostalCode.size() || Country.size(); }
00245 };
00246 BXEXPORT std::ostream& operator<<(std::ostream &os, const PostalAddress &msga);
00247 
00248 struct BXEXPORT Date
00249 {
00250         int Month;                      // 0 to 11
00251         int Day;                        // 1 to 31
00252         int Year;                       // exact number, eg. 2008
00253 
00254         Date() : Month(0), Day(0), Year(0) {}
00255         explicit Date(const struct tm *timep);
00256 
00257         bool HasData() const { return Month || Day || Year; }
00258         void Clear();
00259 
00260         void ToTm(struct tm *timep) const;
00261         std::string ToYYYYMMDD() const;
00262         std::string ToBBString() const; // converts to Blackberry string
00263                                         // format of DD/MM/YYYY
00264 
00265         bool FromTm(const struct tm *timep);
00266         bool FromBBString(const std::string &str);
00267         bool FromYYYYMMDD(const std::string &str);
00268 };
00269 BXEXPORT std::ostream& operator<<(std::ostream &os, const Date &date);
00270 
00271 class BXEXPORT CategoryList : public std::vector<std::string>
00272 {
00273 public:
00274         /// Parses the given comma delimited category string into
00275         /// this CategoryList object, appending each token to the vector.
00276         /// Will clear vector beforehand.
00277         void CategoryStr2List(const std::string &str);
00278 
00279         /// Turns the current vectory into a comma delimited category
00280         /// string suitable for use in Calendar, Task, and Memo
00281         /// protocol values.
00282         void CategoryList2Str(std::string &str) const;
00283 
00284         using std::vector<std::string>::operator=;
00285 };
00286 
00287 
00288 /// \addtogroup RecordParserClasses
00289 ///             Parser and data storage classes.  These classes take a
00290 ///             Database Database record and convert them into C++ objects.
00291 ///             Each of these classes are safe to be used in standard
00292 ///             containers, and are meant to be used in conjunction with the
00293 ///             RecordParser<> template when calling Controller::LoadDatabase().
00294 /// @{
00295 /// @}
00296 
00297 } // namespace Barry
00298 
00299 #ifndef __BARRY_LIBRARY_BUILD__
00300 // Include all parser classes, to make it easy for the application to use.
00301 #include "r_calendar.h"
00302 #include "r_calllog.h"
00303 #include "r_bookmark.h"
00304 #include "r_contact.h"
00305 #include "r_cstore.h"
00306 #include "r_memo.h"
00307 #include "r_message.h"
00308 #include "r_servicebook.h"
00309 #include "r_task.h"
00310 #include "r_pin_message.h"
00311 #include "r_saved_message.h"
00312 #include "r_sms.h"
00313 #include "r_folder.h"
00314 #include "r_timezone.h"
00315 #endif
00316 
00317 #endif
00318 

Generated on Tue Mar 1 17:50:16 2011 for Barry by  doxygen 1.5.6