src/vbase.h

   1 ///
   2 /// \file       vbase.h
   3 ///             Base class for vformat support
   4 ///
   5
   6 /*
   7     Copyright (C) 2006-2012, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #ifndef __BARRY_SYNC_VBASE_H__
  23 #define __BARRY_SYNC_VBASE_H__
  24
  25 #include "dll.h"
  26 #include "vsmartptr.h"
  27 #include "vformat.h"
  28 #include "error.h"
  29 #include <vector>
  30
  31 namespace Barry { namespace Sync {
  32
  33 //
  34 // vTimeConverter
  35 //
  36 /// A virtual base class that the plugins may override, to do
  37 /// time related conversions.  Default implementations for these
  38 /// functions are provided, but may be overrided depending on need.
  39 ///
  40 /// We do this in a "callback" style, so that it doesn't matter what
  41 /// version of the opensync library we link against, in case the
  42 /// user wishes to use the opensync time functions.
  43 ///
  44 class BXEXPORT vTimeConverter
  45 {
  46 public:
  47         virtual ~vTimeConverter() {}
  48
  49         /// Convert a time_t into an ISO timestamp string
  50         /// Throws Barry::ConvertError on error, but these errors
  51         /// must be rare.
  52         virtual std::string unix2vtime(const time_t *timestamp);
  53
  54         /// Convert an ISO timestamp string into a time_t, using
  55         /// the current system timezone if vtime is not in UTC.
  56         /// Returns (time_t)-1 on error.
  57         virtual time_t vtime2unix(const char *vtime);
  58
  59         /// Convert a VEVENT alarm duration string in the format
  60         /// of "[+-]P.W.DT.H.M.S" where the periods represent numbers
  61         /// and each letter besides P and T represent Week, Day,
  62         /// Hour, Minute, and Second respectively.
  63         virtual int alarmduration2sec(const char *alarm);
  64 };
  65
  66
  67 typedef Barry::vSmartPtr<b_VFormatAttribute, b_VFormatAttribute, &b_vformat_attribute_free> vAttrPtr;
  68 typedef Barry::vSmartPtr<b_VFormatParam, b_VFormatParam, &b_vformat_attribute_param_free> vParamPtr;
  69 typedef Barry::vSmartPtr<char, void, &g_free> gStringPtr;
  70
  71
  72 //
  73 // vAttr
  74 //
  75 /// Class for reading a b_VFormatAttribute.  Reading does not require
  76 /// memory management, so none is done.
  77 ///
  78 class BXEXPORT vAttr
  79 {
  80         b_VFormatAttribute *m_attr;
  81
  82 public:
  83         vAttr()
  84                 : m_attr(0)
  85         {
  86         }
  87
  88         vAttr(b_VFormatAttribute *attr)
  89                 : m_attr(attr)
  90         {
  91         }
  92
  93         vAttr& operator=(b_VFormatAttribute *attr)
  94         {
  95                 m_attr = attr;
  96                 return *this;
  97         }
  98
  99         b_VFormatAttribute* Get() { return m_attr; }
 100
 101         // These functions do not throw an error if the value
 102         // is NULL or does not exist (for example, if you ask for
 103         // value #5 and there are only 4).
 104         std::string GetName();
 105         std::string GetValue(int nth = 0);
 106         std::string GetDecodedValue();
 107         std::string GetParam(const char *name, int nth = 0);
 108         std::string GetAllParams(const char *name);
 109 };
 110
 111
 112 //
 113 // vBase
 114 //
 115 /// Base class containing vformat helper API.
 116 ///
 117 class BXEXPORT vBase
 118 {
 119         // internal data for managing the vformat
 120         b_VFormat *m_format;
 121
 122 public:
 123 protected:
 124         vBase();
 125         explicit vBase(b_VFormat *format);
 126         virtual ~vBase();
 127
 128         b_VFormat* Format() { return m_format; }
 129         const b_VFormat* Format() const { return m_format; }
 130         void SetFormat(b_VFormat *format);
 131
 132         void Clear();
 133
 134         vAttrPtr NewAttr(const char *name);
 135         vAttrPtr NewAttr(const char *name, const char *value);
 136         void AddAttr(vAttrPtr attr);
 137         void AddValue(vAttrPtr &attr, const char *value);
 138         void AddEncodedValue(vAttrPtr &attr, b_VFormatEncoding encoding, const char *value, int len);
 139         void AddParam(vAttrPtr &attr, const char *name, const char *value);
 140
 141         std::string GetAttr(const char *attrname, const char *block = 0);
 142         std::vector<std::string> GetValueVector(const char *attrname, const char *block = 0);
 143         vAttr GetAttrObj(const char *attrname, int nth = 0, const char *block = 0);
 144
 145         std::vector<std::string> Tokenize(const std::string &str, const char delim = ',');
 146         std::string ToStringList(const std::vector<std::string> &list, const char delim = ',');
 147 };
 148
 149 }} // namespace Barry::Sync
 150
 151 #endif
 152