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 "tzwrapper.h"
  26 #include <stdio.h>
  27 #include <stdarg.h>
  28 #include <stdint.h>
  29 #include <string.h>
  30 #include <glib.h>
  31 #include <sstream>
  32
  33 using namespace std;
  34
  35 namespace Barry { namespace Sync {
  36
  37 //////////////////////////////////////////////////////////////////////////////
  38 // vTimeConverter
  39
  40 std::string vTimeConverter::unix2vtime(const time_t *timestamp)
  41 {
  42         struct tm split;
  43         if( !gmtime_r(timestamp, &split) ) {
  44                 ostringstream oss;
  45                 oss << "gmtime_r() failed on time_t of ";
  46                 if( timestamp )
  47                         oss << *timestamp;
  48                 else
  49                         oss << "(null pointer)";
  50                 throw Barry::ConvertError(oss.str());
  51         }
  52
  53         return tm_to_iso(&split, true);
  54 }
  55
  56 time_t vTimeConverter::vtime2unix(const char *vtime)
  57 {
  58         return TzWrapper::iso_mktime(vtime);
  59 }
  60
  61 //
  62 // The following implementation is taken from opensync's
  63 // opensync_time.c implementation with the following copyright
  64 // notices at the top as of July 2010:
  65 //
  66 //  * Copyright (C) 2004-2005  Armin Bauer <armin.bauer@opensync.org>
  67 //  * Copyright (C) 2006-2008 Daniel Gollub <gollub@b1-systems.de>
  68 //  * Copyright (C) 2007 Chris Frey <cdfrey@netdirect.ca>
  69 //
  70 // License: LGPL 2.1 or later
  71 //
  72 int vTimeConverter::alarmduration2sec(const char *alarm)
  73 {
  74         int i, secs, digits = 0;
  75         int is_digit = 0;
  76         int sign = 1;   // when ical stamp doesn't start with '-' => seconds after event
  77         int days = 0, weeks = 0, hours = 0, minutes = 0, seconds = 0;
  78         int len = strlen(alarm);
  79
  80         for (i=0; i < len; i++) {
  81
  82                 switch (alarm[i]) {
  83                 case '-':
  84                         sign = -1; // seconds before event - change the sign
  85                 case 'P':
  86                 case 'T':
  87                         is_digit = 0;
  88                         break;
  89                 case 'W':
  90                         is_digit = 0;
  91                         weeks = digits;
  92                         break;
  93                 case 'D':
  94                         is_digit = 0;
  95                         days = digits;
  96                         break;
  97                 case 'H':
  98                         is_digit = 0;
  99                         hours = digits;
 100                         break;
 101                 case 'M':
 102                         is_digit = 0;
 103                         minutes = digits;
 104                         break;
 105                 case 'S':
 106                         is_digit = 0;
 107                         seconds = digits;
 108                         break;
 109                 case '0':
 110                 case '1':
 111                 case '2':
 112                 case '3':
 113                 case '4':
 114                 case '5':
 115                 case '6':
 116                 case '7':
 117                 case '8':
 118                 case '9':
 119                         if (is_digit)
 120                                 break;
 121
 122                         if (sscanf((char*)(alarm+i),"%d",&digits) == EOF)
 123                                 return -1;
 124
 125                         is_digit = 1;
 126                         break;
 127                 }
 128         }
 129
 130         secs = (weeks * 7 * 24 * 3600) + (days * 24 * 3600) + (hours * 3600) + (minutes * 60) + seconds;
 131
 132         secs = secs * sign;     // change sign if the alarm is in seconds before event (leading '-')
 133
 134         return secs;
 135
 136 }
 137
 138
 139 //////////////////////////////////////////////////////////////////////////////
 140 // vAttr
 141
 142 std::string vAttr::GetName()
 143 {
 144         std::string ret;
 145
 146         if( !m_attr )
 147                 return ret;
 148
 149         const char *name = b_vformat_attribute_get_name(m_attr);
 150         if( name )
 151                 ret = name;
 152         return ret;
 153 }
 154
 155 std::string vAttr::GetValue(int nth)
 156 {
 157         std::string ret;
 158         const char *value = 0;
 159
 160         if( m_attr ) {
 161                 if( b_vformat_attribute_is_single_valued(m_attr) ) {
 162                         if( nth == 0 )
 163                                 value = b_vformat_attribute_get_value(m_attr);
 164                 }
 165                 else {
 166                         value = b_vformat_attribute_get_nth_value(m_attr, nth);
 167                 }
 168         }
 169
 170         if( value )
 171                 ret = value;
 172
 173         return ret;
 174 }
 175
 176 std::string vAttr::GetDecodedValue()
 177 {
 178         std::string ret;
 179         GString *value = NULL;
 180
 181         if( m_attr ) {
 182                 if( b_vformat_attribute_is_single_valued(m_attr) ) {
 183                         value = b_vformat_attribute_get_value_decoded(m_attr);
 184                 }
 185         }
 186
 187         if( value )
 188                 ret.assign(value->str, value->len);
 189
 190         return ret;
 191 }
 192
 193 std::string vAttr::GetParam(const char *name, int nth)
 194 {
 195         std::string ret;
 196
 197         if( !m_attr )
 198                 return ret;
 199
 200         b_VFormatParam *param = b_vformat_attribute_find_param(m_attr, name, 0);
 201         if( !param )
 202                 return ret;
 203
 204         const char *value = b_vformat_attribute_param_get_nth_value(param, nth);
 205         if( value )
 206                 ret = value;
 207
 208         return ret;
 209 }
 210
 211 /// Does an exhaustive search through the attribute, searching for all
 212 /// param values that exist for the given name, and returns all values
 213 /// in a comma delimited string.
 214 std::string vAttr::GetAllParams(const char *name)
 215 {
 216         std::string ret;
 217
 218         if( !m_attr )
 219                 return ret;
 220
 221         b_VFormatParam *param = 0;
 222         for( int level = 0;
 223              (param = b_vformat_attribute_find_param(m_attr, name, level));
 224              level++ )
 225         {
 226                 const char *value = 0;
 227                 for( int nth = 0;
 228                      (value = b_vformat_attribute_param_get_nth_value(param, nth));
 229                      nth++ )
 230                 {
 231                         if( ret.size() )
 232                                 ret += ",";
 233                         ret += value;
 234                 }
 235         }
 236
 237         return ret;
 238 }
 239
 240
 241 //////////////////////////////////////////////////////////////////////////////
 242 // vCalendar
 243
 244 vBase::vBase()
 245         : m_format(b_vformat_new())
 246 {
 247 }
 248
 249 vBase::vBase(b_VFormat *format)
 250         : m_format(format)
 251 {
 252         if( !format )
 253                 throw Barry::Error("Cannot construct vBase with null format");
 254 }
 255
 256 vBase::~vBase()
 257 {
 258         if( m_format ) {
 259                 b_vformat_free(m_format);
 260                 m_format = 0;
 261         }
 262 }
 263
 264 void vBase::SetFormat(b_VFormat *format)
 265 {
 266         if( !format )
 267                 throw Barry::Error("Cannot set vBase with null format");
 268
 269         if( m_format ) {
 270                 b_vformat_free(m_format);
 271                 m_format = 0;
 272         }
 273         m_format = format;
 274 }
 275
 276 void vBase::Clear()
 277 {
 278         if( m_format ) {
 279                 b_vformat_free(m_format);
 280                 m_format = b_vformat_new();
 281         }
 282 }
 283
 284 vAttrPtr vBase::NewAttr(const char *name)
 285 {
 286 //      Trace trace("vBase::NewAttr");
 287
 288 //      trace.logf("creating valueless attr: %s", name);
 289
 290         vAttrPtr attr(b_vformat_attribute_new(NULL, name));
 291         if( !attr.Get() )
 292                 throw Barry::ConvertError("resource error allocating vformat attribute");
 293         return attr;
 294 }
 295
 296 vAttrPtr vBase::NewAttr(const char *name, const char *value)
 297 {
 298 //      Trace trace("vBase::NewAttr");
 299
 300 /*
 301 some vCard values are positional (like name), so blank should be allowed...
 302
 303         if( strlen(value) == 0 ) {
 304                 trace.logf("attribute '%s' contains no data, skipping", name);
 305                 return vAttrPtr();
 306         }
 307 */
 308
 309 //      trace.logf("creating attr: %s, %s", name, value);
 310
 311         vAttrPtr attr(b_vformat_attribute_new(NULL, name));
 312         if( !attr.Get() )
 313                 throw ConvertError("resource error allocating vformat attribute");
 314
 315         b_vformat_attribute_add_value(attr.Get(), value);
 316         return attr;
 317 }
 318
 319 void vBase::AddAttr(vAttrPtr attr)
 320 {
 321 //      Trace trace("vBase::AddAttr");
 322
 323         if( !attr.Get() ) {
 324 //              trace.log("attribute contains no data, skipping");
 325                 return;
 326         }
 327
 328         b_vformat_add_attribute(m_format, attr.Extract());
 329 }
 330
 331 void vBase::AddValue(vAttrPtr &attr, const char *value)
 332 {
 333 //      Trace trace("vBase::AddValue");
 334         if( !attr.Get() ) {
 335 //              trace.log("attribute pointer contains no data, skipping");
 336                 return;
 337         }
 338 /*
 339         if( strlen(value) == 0 ) {
 340                 trace.log("attribute value is empty, skipping");
 341                 return;
 342         }
 343 */
 344         b_vformat_attribute_add_value(attr.Get(), value);
 345 }
 346
 347 void vBase::AddEncodedValue(vAttrPtr &attr, b_VFormatEncoding encoding, const char *value, int len)
 348 {
 349 //      Trace trace("vBase::AddValue");
 350         if( !attr.Get() ) {
 351 //              trace.log("attribute pointer contains no data, skipping");
 352                 return;
 353         }
 354
 355         attr.Get()->encoding = encoding;
 356         attr.Get()->encoding_set = TRUE;
 357
 358         b_vformat_attribute_add_value_decoded(attr.Get(), value, len);
 359 }
 360
 361 void vBase::AddParam(vAttrPtr &attr, const char *name, const char *value)
 362 {
 363 //      Trace trace("vBase::AddParam");
 364
 365         if( !attr.Get() ) {
 366 //              trace.log("attribute pointer contains no data, skipping");
 367                 return;
 368         }
 369 /*
 370         if( strlen(value) == 0 ) {
 371                 trace.log("parameter value is empty, skipping");
 372                 return;
 373         }
 374 */
 375
 376         b_VFormatParam *pParam = b_vformat_attribute_param_new(name);
 377         b_vformat_attribute_param_add_value(pParam, value);
 378         b_vformat_attribute_add_param(attr.Get(), pParam);
 379 }
 380
 381 std::string vBase::GetAttr(const char *attrname, const char *block)
 382 {
 383 //      Trace trace("vBase::GetAttr");
 384 //      trace.logf("getting attr: %s", attrname);
 385
 386         std::string ret;
 387         const char *value = 0;
 388
 389         bool needs_freeing = false;
 390
 391         b_VFormatAttribute *attr = b_vformat_find_attribute(m_format, attrname, 0, block);
 392         if( attr ) {
 393                 if( b_vformat_attribute_is_single_valued(attr) ) {
 394                         value = b_vformat_attribute_get_value(attr);
 395                         needs_freeing = true;
 396                 }
 397                 else {
 398                         // FIXME, this is hardcoded
 399                         value = b_vformat_attribute_get_nth_value(attr, 0);
 400                 }
 401         }
 402
 403         if( value )
 404                 ret = value;
 405
 406         if( needs_freeing )
 407                 g_free((char *)value);
 408
 409 //      trace.logf("attr value: %s", ret.c_str());
 410         return ret;
 411 }
 412
 413 std::vector<std::string> vBase::GetValueVector(const char *attrname, const char *block)
 414 {
 415 //      Trace trace("vBase::GetValueVector");
 416 //      trace.logf("getting value vector for: %s", attrname);
 417
 418         std::vector<std::string> ret;
 419         const char *value = 0;
 420         bool needs_freeing = false;
 421
 422         b_VFormatAttribute *attr = b_vformat_find_attribute(m_format, attrname, 0, block);
 423         if( attr ) {
 424                 if( b_vformat_attribute_is_single_valued(attr) ) {
 425                         value = b_vformat_attribute_get_value(attr);
 426                         needs_freeing = true;
 427                 } else {
 428                         // nasty, but avoids tweaking vformat.
 429                         int idx = 0;
 430                         do {
 431                                 value = b_vformat_attribute_get_nth_value(attr, idx++);
 432                                 if( value ) {
 433                                         ret.push_back(value);
 434                                 }
 435                         } while( value );
 436                 }
 437         }
 438
 439         if( needs_freeing )
 440                 g_free((char *)value);
 441
 442         return ret;
 443 }
 444
 445 vAttr vBase::GetAttrObj(const char *attrname, int nth, const char *block)
 446 {
 447 //      Trace trace("vBase::GetAttrObj");
 448 //      trace.logf("getting attr: %s", attrname);
 449
 450         return vAttr(b_vformat_find_attribute(m_format, attrname, nth, block));
 451 }
 452
 453 std::vector<std::string> vBase::Tokenize(const std::string& str, const char delim)
 454 {
 455         std::vector<std::string> tokens;
 456         std::string::size_type delimPos = 0, tokenPos = 0, pos = 0;
 457
 458         if( str.length() < 1 ) {
 459                 return tokens;
 460         }
 461
 462         while( 1 ) {
 463                 delimPos = str.find_first_of(delim, pos);
 464                 tokenPos = str.find_first_not_of(delim, pos);
 465
 466                 if( std::string::npos != delimPos ) {
 467                         if( std::string::npos != tokenPos ) {
 468                                 if( tokenPos < delimPos ) {
 469                                         tokens.push_back(str.substr(pos, delimPos-pos));
 470                                 } else {
 471                                         tokens.push_back("");
 472                                 }
 473                         } else {
 474                                 tokens.push_back("");
 475                         }
 476                         pos = delimPos + 1;
 477                 } else {
 478                         if( std::string::npos != tokenPos ){
 479                                 tokens.push_back(str.substr(pos));
 480                         } else {
 481                                 tokens.push_back("");
 482                         }
 483                         break;
 484                 }
 485         }
 486         return tokens;
 487 }
 488
 489 std::string vBase::ToStringList(const std::vector<std::string> &list, const char delim)
 490 {
 491         std::string str;
 492         for( unsigned int idx = 0; idx < list.size(); idx++ ) {
 493                 if( idx ) {
 494                         str += delim;
 495                 }
 496                 str += list[idx];
 497         }
 498         return str;
 499 }
 500
 501 }} // namespace Barry::Sync
 502