3 /// vformat support routines in base class
7 Copyright (C) 2006-2012, 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"
26 #include "r_contact.h" // for CategoryList
36 namespace Barry
{ namespace Sync
{
38 //////////////////////////////////////////////////////////////////////////////
41 std::string
vTimeConverter::unix2vtime(const time_t *timestamp
)
44 if( !gmtime_r(timestamp
, &split
) ) {
46 oss
<< "gmtime_r() failed on time_t of ";
50 oss
<< "(null pointer)";
51 throw Barry::ConvertError(oss
.str());
54 return tm_to_iso(&split
, true);
57 time_t vTimeConverter::vtime2unix(const char *vtime
)
59 return TzWrapper::iso_mktime(vtime
);
63 // The following implementation is taken from opensync's
64 // opensync_time.c implementation with the following copyright
65 // notices at the top as of July 2010:
67 // * Copyright (C) 2004-2005 Armin Bauer <armin.bauer@opensync.org>
68 // * Copyright (C) 2006-2008 Daniel Gollub <gollub@b1-systems.de>
69 // * Copyright (C) 2007 Chris Frey <cdfrey@netdirect.ca>
71 // License: LGPL 2.1 or later
73 int vTimeConverter::alarmduration2sec(const char *alarm
)
75 int i
, secs
, digits
= 0;
77 int sign
= 1; // when ical stamp doesn't start with '-' => seconds after event
78 int days
= 0, weeks
= 0, hours
= 0, minutes
= 0, seconds
= 0;
79 int len
= strlen(alarm
);
81 for (i
=0; i
< len
; i
++) {
85 sign
= -1; // seconds before event - change the sign
123 if (sscanf((char*)(alarm
+i
),"%d",&digits
) == EOF
)
131 secs
= (weeks
* 7 * 24 * 3600) + (days
* 24 * 3600) + (hours
* 3600) + (minutes
* 60) + seconds
;
133 secs
= secs
* sign
; // change sign if the alarm is in seconds before event (leading '-')
140 //////////////////////////////////////////////////////////////////////////////
143 std::string
vAttr::GetName()
150 const char *name
= b_vformat_attribute_get_name(m_attr
);
156 std::string
vAttr::GetValue(int nth
)
159 const char *value
= 0;
162 if( b_vformat_attribute_is_single_valued(m_attr
) ) {
164 value
= b_vformat_attribute_get_value(m_attr
);
167 value
= b_vformat_attribute_get_nth_value(m_attr
, nth
);
177 std::string
vAttr::GetDecodedValue()
180 GString
*value
= NULL
;
183 if( b_vformat_attribute_is_single_valued(m_attr
) ) {
184 value
= b_vformat_attribute_get_value_decoded(m_attr
);
189 ret
.assign(value
->str
, value
->len
);
194 std::string
vAttr::GetParam(const char *name
, int nth
)
201 b_VFormatParam
*param
= b_vformat_attribute_find_param(m_attr
, name
, 0);
205 const char *value
= b_vformat_attribute_param_get_nth_value(param
, nth
);
212 /// Does an exhaustive search through the attribute, searching for all
213 /// param values that exist for the given name, and returns all values
214 /// in a comma delimited string.
215 std::string
vAttr::GetAllParams(const char *name
)
222 b_VFormatParam
*param
= 0;
224 (param
= b_vformat_attribute_find_param(m_attr
, name
, level
));
227 const char *value
= 0;
229 (value
= b_vformat_attribute_param_get_nth_value(param
, nth
));
242 //////////////////////////////////////////////////////////////////////////////
246 : m_format(b_vformat_new())
250 vBase::vBase(b_VFormat
*format
)
254 throw Barry::Error("Cannot construct vBase with null format");
260 b_vformat_free(m_format
);
265 void vBase::SetFormat(b_VFormat
*format
)
268 throw Barry::Error("Cannot set vBase with null format");
271 b_vformat_free(m_format
);
280 b_vformat_free(m_format
);
281 m_format
= b_vformat_new();
285 vAttrPtr
vBase::NewAttr(const char *name
)
287 // Trace trace("vBase::NewAttr");
289 // trace.logf("creating valueless attr: %s", name);
291 vAttrPtr
attr(b_vformat_attribute_new(NULL
, name
));
293 throw Barry::ConvertError("resource error allocating vformat attribute");
297 vAttrPtr
vBase::NewAttr(const char *name
, const char *value
)
299 // Trace trace("vBase::NewAttr");
302 some vCard values are positional (like name), so blank should be allowed...
304 if( strlen(value) == 0 ) {
305 trace.logf("attribute '%s' contains no data, skipping", name);
310 // trace.logf("creating attr: %s, %s", name, value);
312 vAttrPtr
attr(b_vformat_attribute_new(NULL
, name
));
314 throw ConvertError("resource error allocating vformat attribute");
316 b_vformat_attribute_add_value(attr
.Get(), value
);
320 void vBase::AddAttr(vAttrPtr attr
)
322 // Trace trace("vBase::AddAttr");
325 // trace.log("attribute contains no data, skipping");
329 b_vformat_add_attribute(m_format
, attr
.Extract());
332 void vBase::AddValue(vAttrPtr
&attr
, const char *value
)
334 // Trace trace("vBase::AddValue");
336 // trace.log("attribute pointer contains no data, skipping");
340 if( strlen(value) == 0 ) {
341 trace.log("attribute value is empty, skipping");
345 b_vformat_attribute_add_value(attr
.Get(), value
);
348 void vBase::AddEncodedValue(vAttrPtr
&attr
, b_VFormatEncoding encoding
, const char *value
, int len
)
350 // Trace trace("vBase::AddValue");
352 // trace.log("attribute pointer contains no data, skipping");
356 attr
.Get()->encoding
= encoding
;
357 attr
.Get()->encoding_set
= TRUE
;
359 b_vformat_attribute_add_value_decoded(attr
.Get(), value
, len
);
362 void vBase::AddParam(vAttrPtr
&attr
, const char *name
, const char *value
)
364 // Trace trace("vBase::AddParam");
367 // trace.log("attribute pointer contains no data, skipping");
371 if( strlen(value) == 0 ) {
372 trace.log("parameter value is empty, skipping");
377 b_VFormatParam
*pParam
= b_vformat_attribute_param_new(name
);
378 b_vformat_attribute_param_add_value(pParam
, value
);
379 b_vformat_attribute_add_param(attr
.Get(), pParam
);
382 void vBase::AddCategories(const Barry::CategoryList
&categories
)
384 if( !categories
.size() )
387 vAttrPtr cat
= NewAttr("CATEGORIES"); // RFC 2426, 3.6.1
388 Barry::CategoryList::const_iterator i
= categories
.begin();
389 for( ; i
< categories
.end(); ++i
) {
390 AddValue(cat
, i
->c_str());
395 std::string
vBase::GetAttr(const char *attrname
, const char *block
)
397 // Trace trace("vBase::GetAttr");
398 // trace.logf("getting attr: %s", attrname);
401 const char *value
= 0;
403 bool needs_freeing
= false;
405 b_VFormatAttribute
*attr
= b_vformat_find_attribute(m_format
, attrname
, 0, block
);
407 if( b_vformat_attribute_is_single_valued(attr
) ) {
408 value
= b_vformat_attribute_get_value(attr
);
409 needs_freeing
= true;
412 // FIXME, this is hardcoded
413 value
= b_vformat_attribute_get_nth_value(attr
, 0);
421 g_free((char *)value
);
423 // trace.logf("attr value: %s", ret.c_str());
427 std::vector
<std::string
> vBase::GetValueVector(const char *attrname
, const char *block
)
429 // Trace trace("vBase::GetValueVector");
430 // trace.logf("getting value vector for: %s", attrname);
432 std::vector
<std::string
> ret
;
433 const char *value
= 0;
434 bool needs_freeing
= false;
436 b_VFormatAttribute
*attr
= b_vformat_find_attribute(m_format
, attrname
, 0, block
);
438 if( b_vformat_attribute_is_single_valued(attr
) ) {
439 value
= b_vformat_attribute_get_value(attr
);
440 needs_freeing
= true;
442 // nasty, but avoids tweaking vformat.
445 value
= b_vformat_attribute_get_nth_value(attr
, idx
++);
447 ret
.push_back(value
);
454 g_free((char *)value
);
459 vAttr
vBase::GetAttrObj(const char *attrname
, int nth
, const char *block
)
461 // Trace trace("vBase::GetAttrObj");
462 // trace.logf("getting attr: %s", attrname);
464 return vAttr(b_vformat_find_attribute(m_format
, attrname
, nth
, block
));
467 std::vector
<std::string
> vBase::Tokenize(const std::string
& str
, const char delim
)
469 std::vector
<std::string
> tokens
;
470 std::string::size_type delimPos
= 0, tokenPos
= 0, pos
= 0;
472 if( str
.length() < 1 ) {
477 delimPos
= str
.find_first_of(delim
, pos
);
478 tokenPos
= str
.find_first_not_of(delim
, pos
);
480 if( std::string::npos
!= delimPos
) {
481 if( std::string::npos
!= tokenPos
) {
482 if( tokenPos
< delimPos
) {
483 tokens
.push_back(str
.substr(pos
, delimPos
-pos
));
485 tokens
.push_back("");
488 tokens
.push_back("");
492 if( std::string::npos
!= tokenPos
){
493 tokens
.push_back(str
.substr(pos
));
495 tokens
.push_back("");
503 std::string
vBase::ToStringList(const std::vector
<std::string
> &list
, const char delim
)
506 for( unsigned int idx
= 0; idx
< list
.size(); idx
++ ) {
515 }} // namespace Barry::Sync