opensync-plugin/src/vbase.cc

   1 //
   2 // \file        vbase.cc
   3 //              vformat support routines in base class
   4 //
   5
   6 /*
   7     Copyright (C) 2006-2007, 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 #include "vbase.h"
  23 #include "trace.h"
  24 #include "vformat.h"            // comes from opensync, but not a public header yet
  25 #include <stdint.h>
  26 #include <glib.h>
  27 #include <sstream>
  28
  29
  30 //////////////////////////////////////////////////////////////////////////////
  31 // vAttr
  32
  33 std::string vAttr::GetName()
  34 {
  35         std::string ret;
  36
  37         if( !m_attr )
  38                 return ret;
  39
  40         const char *name = vformat_attribute_get_name(m_attr);
  41         if( name )
  42                 ret = name;
  43         return ret;
  44 }
  45
  46 std::string vAttr::GetValue(int nth)
  47 {
  48         std::string ret;
  49         const char *value = 0;
  50
  51         if( m_attr ) {
  52                 if( vformat_attribute_is_single_valued(m_attr) ) {
  53                         value = vformat_attribute_get_value(m_attr);
  54                 }
  55                 else {
  56                         value = vformat_attribute_get_nth_value(m_attr, nth);
  57                 }
  58         }
  59
  60         if( value )
  61                 ret = value;
  62
  63         return ret;
  64 }
  65
  66 std::string vAttr::GetParam(const char *name, int nth)
  67 {
  68         std::string ret;
  69
  70         if( !m_attr )
  71                 return ret;
  72
  73         VFormatParam *param = vformat_attribute_find_param(m_attr, name);
  74         if( !param )
  75                 return ret;
  76
  77         const char *value = vformat_attribute_param_get_nth_value(param, nth);
  78         if( value )
  79                 ret = value;
  80
  81         return ret;
  82 }
  83
  84
  85 //////////////////////////////////////////////////////////////////////////////
  86 // vCalendar
  87
  88 vBase::vBase()
  89         : m_format(0)
  90 {
  91 }
  92
  93 vBase::~vBase()
  94 {
  95         if( m_format ) {
  96                 vformat_free(m_format);
  97         }
  98 }
  99
 100 void vBase::SetFormat(VFormat *format)
 101 {
 102         if( m_format ) {
 103                 vformat_free(m_format);
 104                 m_format = 0;
 105         }
 106         m_format = format;
 107 }
 108
 109 void vBase::Clear()
 110 {
 111         if( m_format ) {
 112                 vformat_free(m_format);
 113                 m_format = 0;
 114         }
 115 }
 116
 117 vAttrPtr vBase::NewAttr(const char *name)
 118 {
 119         Trace trace("vBase::NewAttr");
 120
 121         trace.logf("creating valueless attr: %s", name);
 122
 123         vAttrPtr attr(vformat_attribute_new(NULL, name));
 124         if( !attr.Get() )
 125                 throw ConvertError("resource error allocating vformat attribute");
 126         return attr;
 127 }
 128
 129 vAttrPtr vBase::NewAttr(const char *name, const char *value)
 130 {
 131         Trace trace("vBase::NewAttr");
 132
 133 /*
 134 some vCard values are positional (like name), so blank should be allowed...
 135
 136         if( strlen(value) == 0 ) {
 137                 trace.logf("attribute '%s' contains no data, skipping", name);
 138                 return vAttrPtr();
 139         }
 140 */
 141
 142         trace.logf("creating attr: %s, %s", name, value);
 143
 144         vAttrPtr attr(vformat_attribute_new(NULL, name));
 145         if( !attr.Get() )
 146                 throw ConvertError("resource error allocating vformat attribute");
 147
 148         vformat_attribute_add_value(attr.Get(), value);
 149         return attr;
 150 }
 151
 152 void vBase::AddAttr(vAttrPtr attr)
 153 {
 154         Trace trace("vBase::AddAttr");
 155
 156         if( !attr.Get() ) {
 157                 trace.log("attribute contains no data, skipping");
 158                 return;
 159         }
 160
 161         vformat_add_attribute(m_format, attr.Extract());
 162 }
 163
 164 void vBase::AddValue(vAttrPtr &attr, const char *value)
 165 {
 166         Trace trace("vBase::AddValue");
 167         if( !attr.Get() ) {
 168                 trace.log("attribute pointer contains no data, skipping");
 169                 return;
 170         }
 171 /*
 172         if( strlen(value) == 0 ) {
 173                 trace.log("attribute value is empty, skipping");
 174                 return;
 175         }
 176 */
 177         vformat_attribute_add_value(attr.Get(), value);
 178 }
 179
 180 void vBase::AddParam(vAttrPtr &attr, const char *name, const char *value)
 181 {
 182         Trace trace("vBase::AddParam");
 183
 184         if( !attr.Get() ) {
 185                 trace.log("attribute pointer contains no data, skipping");
 186                 return;
 187         }
 188 /*
 189         if( strlen(value) == 0 ) {
 190                 trace.log("parameter value is empty, skipping");
 191                 return;
 192         }
 193 */
 194
 195         VFormatParam *pParam = vformat_attribute_param_new(name);
 196         vformat_attribute_param_add_value(pParam, value);
 197         vformat_attribute_add_param(attr.Get(), pParam);
 198 }
 199
 200 std::string vBase::GetAttr(const char *attrname, const char *block)
 201 {
 202         Trace trace("vBase::GetAttr");
 203         trace.logf("getting attr: %s", attrname);
 204
 205         std::string ret;
 206         const char *value = 0;
 207
 208         bool needs_freeing = false;
 209
 210         VFormatAttribute *attr = vformat_find_attribute(m_format, attrname, 0, block);
 211         if( attr ) {
 212                 if( vformat_attribute_is_single_valued(attr) ) {
 213                         value = vformat_attribute_get_value(attr);
 214                         needs_freeing = true;
 215                 }
 216                 else {
 217                         // FIXME, this is hardcoded
 218                         value = vformat_attribute_get_nth_value(attr, 0);
 219                 }
 220         }
 221
 222         if( value )
 223                 ret = value;
 224
 225         if( needs_freeing )
 226                 g_free((char *)value);
 227
 228         trace.logf("attr value: %s", ret.c_str());
 229         return ret;
 230 }
 231
 232 vAttr vBase::GetAttrObj(const char *attrname, int nth, const char *block)
 233 {
 234         Trace trace("vBase::GetAttrObj");
 235         trace.logf("getting attr: %s", attrname);
 236
 237         return vAttr(vformat_find_attribute(m_format, attrname, nth, block));
 238 }
 239