src/vbase.cc

   1 //
   2 // \file        vbase.cc
   3 //              vformat support routines in base class
   4 //
   5
   6 /*
   7     Copyright (C) 2006-2010, 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 namespace Barry { namespace Sync {
  30
  31 //////////////////////////////////////////////////////////////////////////////
  32 // vAttr
  33
  34 std::string vAttr::GetName()
  35 {
  36         std::string ret;
  37
  38         if( !m_attr )
  39                 return ret;
  40
  41         const char *name = b_vformat_attribute_get_name(m_attr);
  42         if( name )
  43                 ret = name;
  44         return ret;
  45 }
  46
  47 std::string vAttr::GetValue(int nth)
  48 {
  49         std::string ret;
  50         const char *value = 0;
  51
  52         if( m_attr ) {
  53                 if( b_vformat_attribute_is_single_valued(m_attr) ) {
  54                         if( nth == 0 )
  55                                 value = b_vformat_attribute_get_value(m_attr);
  56                 }
  57                 else {
  58                         value = b_vformat_attribute_get_nth_value(m_attr, nth);
  59                 }
  60         }
  61
  62         if( value )
  63                 ret = value;
  64
  65         return ret;
  66 }
  67
  68 std::string vAttr::GetDecodedValue()
  69 {
  70         std::string ret;
  71         GString *value = NULL;
  72
  73         if( m_attr ) {
  74                 if( b_vformat_attribute_is_single_valued(m_attr) ) {
  75                         value = b_vformat_attribute_get_value_decoded(m_attr);
  76                 }
  77         }
  78
  79         if( value )
  80                 ret.assign(value->str, value->len);
  81
  82         return ret;
  83 }
  84
  85 std::string vAttr::GetParam(const char *name, int nth)
  86 {
  87         std::string ret;
  88
  89         if( !m_attr )
  90                 return ret;
  91
  92         b_VFormatParam *param = b_vformat_attribute_find_param(m_attr, name, 0);
  93         if( !param )
  94                 return ret;
  95
  96         const char *value = b_vformat_attribute_param_get_nth_value(param, nth);
  97         if( value )
  98                 ret = value;
  99
 100         return ret;
 101 }
 102
 103 /// Does an exhaustive search through the attribute, searching for all
 104 /// param values that exist for the given name, and returns all values
 105 /// in a comma delimited string.
 106 std::string vAttr::GetAllParams(const char *name)
 107 {
 108         std::string ret;
 109
 110         if( !m_attr )
 111                 return ret;
 112
 113         b_VFormatParam *param = 0;
 114         for( int level = 0;
 115              (param = b_vformat_attribute_find_param(m_attr, name, level));
 116              level++ )
 117         {
 118                 const char *value = 0;
 119                 for( int nth = 0;
 120                      (value = b_vformat_attribute_param_get_nth_value(param, nth));
 121                      nth++ )
 122                 {
 123                         if( ret.size() )
 124                                 ret += ",";
 125                         ret += value;
 126                 }
 127         }
 128
 129         return ret;
 130 }
 131
 132
 133 //////////////////////////////////////////////////////////////////////////////
 134 // vCalendar
 135
 136 vBase::vBase()
 137         : m_format(0)
 138 {
 139 }
 140
 141 vBase::~vBase()
 142 {
 143         if( m_format ) {
 144                 b_vformat_free(m_format);
 145         }
 146 }
 147
 148 void vBase::SetFormat(b_VFormat *format)
 149 {
 150         if( m_format ) {
 151                 b_vformat_free(m_format);
 152                 m_format = 0;
 153         }
 154         m_format = format;
 155 }
 156
 157 void vBase::Clear()
 158 {
 159         if( m_format ) {
 160                 b_vformat_free(m_format);
 161                 m_format = 0;
 162         }
 163 }
 164
 165 vAttrPtr vBase::NewAttr(const char *name)
 166 {
 167 //      Trace trace("vBase::NewAttr");
 168
 169 //      trace.logf("creating valueless attr: %s", name);
 170
 171         vAttrPtr attr(b_vformat_attribute_new(NULL, name));
 172         if( !attr.Get() )
 173                 throw Barry::ConvertError("resource error allocating vformat attribute");
 174         return attr;
 175 }
 176
 177 vAttrPtr vBase::NewAttr(const char *name, const char *value)
 178 {
 179 //      Trace trace("vBase::NewAttr");
 180
 181 /*
 182 some vCard values are positional (like name), so blank should be allowed...
 183
 184         if( strlen(value) == 0 ) {
 185                 trace.logf("attribute '%s' contains no data, skipping", name);
 186                 return vAttrPtr();
 187         }
 188 */
 189
 190 //      trace.logf("creating attr: %s, %s", name, value);
 191
 192         vAttrPtr attr(b_vformat_attribute_new(NULL, name));
 193         if( !attr.Get() )
 194                 throw ConvertError("resource error allocating vformat attribute");
 195
 196         b_vformat_attribute_add_value(attr.Get(), value);
 197         return attr;
 198 }
 199
 200 void vBase::AddAttr(vAttrPtr attr)
 201 {
 202 //      Trace trace("vBase::AddAttr");
 203
 204         if( !attr.Get() ) {
 205 //              trace.log("attribute contains no data, skipping");
 206                 return;
 207         }
 208
 209         b_vformat_add_attribute(m_format, attr.Extract());
 210 }
 211
 212 void vBase::AddValue(vAttrPtr &attr, const char *value)
 213 {
 214 //      Trace trace("vBase::AddValue");
 215         if( !attr.Get() ) {
 216 //              trace.log("attribute pointer contains no data, skipping");
 217                 return;
 218         }
 219 /*
 220         if( strlen(value) == 0 ) {
 221                 trace.log("attribute value is empty, skipping");
 222                 return;
 223         }
 224 */
 225         b_vformat_attribute_add_value(attr.Get(), value);
 226 }
 227
 228 void vBase::AddEncodedValue(vAttrPtr &attr, b_VFormatEncoding encoding, const char *value, int len)
 229 {
 230 //      Trace trace("vBase::AddValue");
 231         if( !attr.Get() ) {
 232 //              trace.log("attribute pointer contains no data, skipping");
 233                 return;
 234         }
 235
 236         attr.Get()->encoding = encoding;
 237         attr.Get()->encoding_set = TRUE;
 238
 239         b_vformat_attribute_add_value_decoded(attr.Get(), value, len);
 240 }
 241
 242 void vBase::AddParam(vAttrPtr &attr, const char *name, const char *value)
 243 {
 244 //      Trace trace("vBase::AddParam");
 245
 246         if( !attr.Get() ) {
 247 //              trace.log("attribute pointer contains no data, skipping");
 248                 return;
 249         }
 250 /*
 251         if( strlen(value) == 0 ) {
 252                 trace.log("parameter value is empty, skipping");
 253                 return;
 254         }
 255 */
 256
 257         b_VFormatParam *pParam = b_vformat_attribute_param_new(name);
 258         b_vformat_attribute_param_add_value(pParam, value);
 259         b_vformat_attribute_add_param(attr.Get(), pParam);
 260 }
 261
 262 std::string vBase::GetAttr(const char *attrname, const char *block)
 263 {
 264 //      Trace trace("vBase::GetAttr");
 265 //      trace.logf("getting attr: %s", attrname);
 266
 267         std::string ret;
 268         const char *value = 0;
 269
 270         bool needs_freeing = false;
 271
 272         b_VFormatAttribute *attr = b_vformat_find_attribute(m_format, attrname, 0, block);
 273         if( attr ) {
 274                 if( b_vformat_attribute_is_single_valued(attr) ) {
 275                         value = b_vformat_attribute_get_value(attr);
 276                         needs_freeing = true;
 277                 }
 278                 else {
 279                         // FIXME, this is hardcoded
 280                         value = b_vformat_attribute_get_nth_value(attr, 0);
 281                 }
 282         }
 283
 284         if( value )
 285                 ret = value;
 286
 287         if( needs_freeing )
 288                 g_free((char *)value);
 289
 290 //      trace.logf("attr value: %s", ret.c_str());
 291         return ret;
 292 }
 293
 294 vAttr vBase::GetAttrObj(const char *attrname, int nth, const char *block)
 295 {
 296 //      Trace trace("vBase::GetAttrObj");
 297 //      trace.logf("getting attr: %s", attrname);
 298
 299         return vAttr(b_vformat_find_attribute(m_format, attrname, nth, block));
 300 }
 301
 302 }} // namespace Barry::Sync
 303