3 // vformat support routines in base class
7 Copyright (C) 2006-2011, Net Direct Inc. (http://www.netdirect.ca/)
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.
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.
18 See the GNU General Public License in the COPYING file at the
19 root directory of this project for more details.
24 #include "vformat.h" // comes from opensync, but not a public header yet
25 #include "tzwrapper.h"
35 namespace Barry
{ namespace Sync
{
37 //////////////////////////////////////////////////////////////////////////////
40 std::string
vTimeConverter::unix2vtime(const time_t *timestamp
)
43 if( !gmtime_r(timestamp
, &split
) ) {
45 oss
<< "gmtime_r() failed on time_t of ";
49 oss
<< "(null pointer)";
50 throw Barry::ConvertError(oss
.str());
53 return tm_to_iso(&split
, true);
56 time_t vTimeConverter::vtime2unix(const char *vtime
)
58 return TzWrapper::iso_mktime(vtime
);
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:
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>
70 // License: LGPL 2.1 or later
72 int vTimeConverter::alarmduration2sec(const char *alarm
)
74 int i
, secs
, digits
= 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
);
80 for (i
=0; i
< len
; i
++) {
84 sign
= -1; // seconds before event - change the sign
122 if (sscanf((char*)(alarm
+i
),"%d",&digits
) == EOF
)
130 secs
= (weeks
* 7 * 24 * 3600) + (days
* 24 * 3600) + (hours
* 3600) + (minutes
* 60) + seconds
;
132 secs
= secs
* sign
; // change sign if the alarm is in seconds before event (leading '-')
139 //////////////////////////////////////////////////////////////////////////////
142 std::string
vAttr::GetName()
149 const char *name
= b_vformat_attribute_get_name(m_attr
);
155 std::string
vAttr::GetValue(int nth
)
158 const char *value
= 0;
161 if( b_vformat_attribute_is_single_valued(m_attr
) ) {
163 value
= b_vformat_attribute_get_value(m_attr
);
166 value
= b_vformat_attribute_get_nth_value(m_attr
, nth
);
176 std::string
vAttr::GetDecodedValue()
179 GString
*value
= NULL
;
182 if( b_vformat_attribute_is_single_valued(m_attr
) ) {
183 value
= b_vformat_attribute_get_value_decoded(m_attr
);
188 ret
.assign(value
->str
, value
->len
);
193 std::string
vAttr::GetParam(const char *name
, int nth
)
200 b_VFormatParam
*param
= b_vformat_attribute_find_param(m_attr
, name
, 0);
204 const char *value
= b_vformat_attribute_param_get_nth_value(param
, nth
);
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
)
221 b_VFormatParam
*param
= 0;
223 (param
= b_vformat_attribute_find_param(m_attr
, name
, level
));
226 const char *value
= 0;
228 (value
= b_vformat_attribute_param_get_nth_value(param
, nth
));
241 //////////////////////////////////////////////////////////////////////////////
245 : m_format(b_vformat_new())
249 vBase::vBase(b_VFormat
*format
)
253 throw Barry::Error("Cannot construct vBase with null format");
259 b_vformat_free(m_format
);
264 void vBase::SetFormat(b_VFormat
*format
)
267 throw Barry::Error("Cannot set vBase with null format");
270 b_vformat_free(m_format
);
279 b_vformat_free(m_format
);
280 m_format
= b_vformat_new();
284 vAttrPtr
vBase::NewAttr(const char *name
)
286 // Trace trace("vBase::NewAttr");
288 // trace.logf("creating valueless attr: %s", name);
290 vAttrPtr
attr(b_vformat_attribute_new(NULL
, name
));
292 throw Barry::ConvertError("resource error allocating vformat attribute");
296 vAttrPtr
vBase::NewAttr(const char *name
, const char *value
)
298 // Trace trace("vBase::NewAttr");
301 some vCard values are positional (like name), so blank should be allowed...
303 if( strlen(value) == 0 ) {
304 trace.logf("attribute '%s' contains no data, skipping", name);
309 // trace.logf("creating attr: %s, %s", name, value);
311 vAttrPtr
attr(b_vformat_attribute_new(NULL
, name
));
313 throw ConvertError("resource error allocating vformat attribute");
315 b_vformat_attribute_add_value(attr
.Get(), value
);
319 void vBase::AddAttr(vAttrPtr attr
)
321 // Trace trace("vBase::AddAttr");
324 // trace.log("attribute contains no data, skipping");
328 b_vformat_add_attribute(m_format
, attr
.Extract());
331 void vBase::AddValue(vAttrPtr
&attr
, const char *value
)
333 // Trace trace("vBase::AddValue");
335 // trace.log("attribute pointer contains no data, skipping");
339 if( strlen(value) == 0 ) {
340 trace.log("attribute value is empty, skipping");
344 b_vformat_attribute_add_value(attr
.Get(), value
);
347 void vBase::AddEncodedValue(vAttrPtr
&attr
, b_VFormatEncoding encoding
, const char *value
, int len
)
349 // Trace trace("vBase::AddValue");
351 // trace.log("attribute pointer contains no data, skipping");
355 attr
.Get()->encoding
= encoding
;
356 attr
.Get()->encoding_set
= TRUE
;
358 b_vformat_attribute_add_value_decoded(attr
.Get(), value
, len
);
361 void vBase::AddParam(vAttrPtr
&attr
, const char *name
, const char *value
)
363 // Trace trace("vBase::AddParam");
366 // trace.log("attribute pointer contains no data, skipping");
370 if( strlen(value) == 0 ) {
371 trace.log("parameter value is empty, skipping");
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
);
381 std::string
vBase::GetAttr(const char *attrname
, const char *block
)
383 // Trace trace("vBase::GetAttr");
384 // trace.logf("getting attr: %s", attrname);
387 const char *value
= 0;
389 bool needs_freeing
= false;
391 b_VFormatAttribute
*attr
= b_vformat_find_attribute(m_format
, attrname
, 0, block
);
393 if( b_vformat_attribute_is_single_valued(attr
) ) {
394 value
= b_vformat_attribute_get_value(attr
);
395 needs_freeing
= true;
398 // FIXME, this is hardcoded
399 value
= b_vformat_attribute_get_nth_value(attr
, 0);
407 g_free((char *)value
);
409 // trace.logf("attr value: %s", ret.c_str());
413 std::vector
<std::string
> vBase::GetValueVector(const char *attrname
, const char *block
)
415 // Trace trace("vBase::GetValueVector");
416 // trace.logf("getting value vector for: %s", attrname);
418 std::vector
<std::string
> ret
;
419 const char *value
= 0;
420 bool needs_freeing
= false;
422 b_VFormatAttribute
*attr
= b_vformat_find_attribute(m_format
, attrname
, 0, block
);
424 if( b_vformat_attribute_is_single_valued(attr
) ) {
425 value
= b_vformat_attribute_get_value(attr
);
426 needs_freeing
= true;
428 // nasty, but avoids tweaking vformat.
431 value
= b_vformat_attribute_get_nth_value(attr
, idx
++);
433 ret
.push_back(value
);
440 g_free((char *)value
);
445 vAttr
vBase::GetAttrObj(const char *attrname
, int nth
, const char *block
)
447 // Trace trace("vBase::GetAttrObj");
448 // trace.logf("getting attr: %s", attrname);
450 return vAttr(b_vformat_find_attribute(m_format
, attrname
, nth
, block
));
453 std::vector
<std::string
> vBase::Tokenize(const std::string
& str
, const char delim
)
455 std::vector
<std::string
> tokens
;
456 std::string::size_type delimPos
= 0, tokenPos
= 0, pos
= 0;
458 if( str
.length() < 1 ) {
463 delimPos
= str
.find_first_of(delim
, pos
);
464 tokenPos
= str
.find_first_not_of(delim
, pos
);
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
));
471 tokens
.push_back("");
474 tokens
.push_back("");
478 if( std::string::npos
!= tokenPos
){
479 tokens
.push_back(str
.substr(pos
));
481 tokens
.push_back("");
489 std::string
vBase::ToStringList(const std::vector
<std::string
> &list
, const char delim
)
492 for( unsigned int idx
= 0; idx
< list
.size(); idx
++ ) {
501 }} // namespace Barry::Sync