src/r_calllog.h

   1 ///
   2 /// \file       r_calllog.h
   3 ///             Record parsing class for call logs
   4 ///
   5
   6 /*
   7     Copyright (C) 2008-2009, Nicolas VIVIEN
   8     Copyright (C) 2005-2012, 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_CALLLOG_H__
  24 #define __BARRY_RECORD_CALLLOG_H__
  25
  26 #include "dll.h"
  27 #include "record.h"
  28 #include <vector>
  29 #include <string>
  30 #include <stdint.h>
  31
  32 namespace Barry {
  33
  34 // forward declarations
  35 class IConverter;
  36
  37 class BXEXPORT CallLog
  38 {
  39 public:
  40         typedef Barry::UnknownsType             UnknownsType;
  41
  42         uint8_t RecType;
  43         uint32_t RecordId;
  44
  45         uint32_t Duration;              //< duration of call in seconds
  46         uint64_t Timestamp;             //< timestamp of call in milliseconds
  47                                         //< use GetTime() to convert to
  48                                         //< a time_t
  49         std::string ContactName;
  50         std::string PhoneNumber;
  51
  52         enum DirectionFlagType
  53         {
  54                 Receiver = 0,           //< We have received a call
  55                 Emitter,                //< We have composed a call
  56                 Failed,                 //< We have missing a call and the
  57                                         //< emitter is arrived on our
  58                                         //< answering machine
  59                 Missing                 //< We have missing a call. The
  60                                         //< emitter has stopped the
  61                                         //< communication.
  62         };
  63         DirectionFlagType DirectionFlag;
  64
  65         enum StatusFlagType
  66         {
  67                 OK = 0,                 //
  68                 Busy,                   //< We have sent the emitter on our
  69                                         //< answering machine
  70                 NetError,               //< Network communication error
  71                 Unknown                 //< Not supported by Barry CallLog parser
  72         };
  73         StatusFlagType StatusFlag;
  74
  75         enum PhoneTypeFlagType
  76         {
  77                 TypeUndefined = 0,
  78                 TypeOffice,
  79                 TypeHome,
  80                 TypeMobile,
  81                 TypeUnknown             // To be completed (Office2, Home2, Pager ???)
  82         };
  83         PhoneTypeFlagType PhoneTypeFlag;
  84
  85         enum PhoneInfoFlagType
  86         {
  87                 InfoUndefined = 0,
  88                 InfoKnown,              //< PhoneNumber should be set
  89                 InfoUnknown,            //< PhoneNumber isn't set
  90                 InfoPrivate             //< PhoneNumber is private
  91         };
  92         PhoneInfoFlagType PhoneInfoFlag;
  93
  94         UnknownsType Unknowns;
  95
  96 protected:
  97         time_t GetTime() const;
  98
  99         static DirectionFlagType DirectionProto2Rec(uint8_t s);
 100         static uint8_t DirectionRec2Proto(DirectionFlagType s);
 101
 102         static PhoneTypeFlagType PhoneTypeProto2Rec(uint8_t s);
 103         static uint8_t PhoneTypeRec2Proto(PhoneTypeFlagType s);
 104
 105 public:
 106         CallLog();
 107         ~CallLog();
 108
 109         // Parser / Builder API (see parser.h / builder.h)
 110         void Validate() const;
 111         const unsigned char* ParseField(const unsigned char *begin,
 112                 const unsigned char *end, const IConverter *ic = 0);
 113         uint8_t GetRecType() const { return RecType; }
 114         uint32_t GetUniqueId() const { return RecordId; }
 115         void SetIds(uint8_t Type, uint32_t Id) { RecType = Type; RecordId = Id; }
 116         void ParseHeader(const Data &data, size_t &offset);
 117         void ParseFields(const Data &data, size_t &offset, const IConverter *ic = 0);
 118         void BuildHeader(Data &data, size_t &offset) const;
 119         void BuildFields(Data &data, size_t &offset, const IConverter *ic = 0) const;
 120
 121         // operations (common among record classes)
 122         void Clear();
 123         void Dump(std::ostream &os) const;
 124         std::string GetDescription() const;
 125
 126         // Sorting
 127         bool operator<(const CallLog &other) const { return Timestamp < other.Timestamp; }
 128
 129         // database name
 130         static const char * GetDBName() { return "Phone Call Logs"; }
 131         static uint8_t GetDefaultRecType() { return 0; }
 132
 133         // Generic Field Handle support
 134         static const FieldHandle<CallLog>::ListT& GetFieldHandles();
 135 };
 136
 137 BXEXPORT inline std::ostream& operator<<(std::ostream &os, const CallLog &msg) {
 138         msg.Dump(os);
 139         return os;
 140 }
 141
 142 } // namespace Barry
 143
 144 #endif
 145