int gs_heatmapNToJSON(const struct gs_heatmap gsh, char * jsonOutput, int jsonOutputAllocatedSize){
char jsonLat[21];
char jsonLon[22];
char latitude[DecimalWidth];
char longitude[DecimalWidth];
char jsonSeconds[27+sizeof(long)];
int jsonLatWritten;
int jsonLonWritten;
int jsonSecondsWritten;
bzero(latitude,DecimalWidth);
bzero(longitude,DecimalWidth);
bzero(jsonLat,21);
bzero(jsonLon,21);
bzero(jsonSeconds,27+sizeof(long));
formatDecimal(gsh.latitude,latitude);
formatDecimal(gsh.longitude,longitude);
jsonLatWritten = snprintf(jsonLat,21+DecimalWidth,"{\"latDegrees\" : %s,", latitude);
jsonLonWritten = snprintf(jsonLon,22+DecimalWidth," \"lonDegrees\" : %s,", longitude);
jsonSecondsWritten = snprintf(jsonSeconds,27+sizeof(long)," \"secondsWorked\" : %ld }",gsh.intensity);
if(jsonLonWritten + jsonLatWritten + jsonSecondsWritten > jsonOutputAllocatedSize-1){
fprintf(stderr, "%s\n", "gs_heatmapNToJSON may have returned partial JSON output due to not allocating enough memory");
#ifdef RETURN_ON_JSON_RISK
RETURN_ON_JSON_RISK;
#endif
}
return snprintf(jsonOutput, jsonOutputAllocatedSize-1,"%s%s%s",jsonLat, jsonLon, jsonSeconds);
}
/*
{ "id" : 3324523452345,
"latDegrees" : 24.53,
"lonDegrees" : 43.2,
"type" : "COMMENT",
"message" : "I need help with the trash on Colchester ave",
"messageId" : 32,
"addressed" : false }
*/
int gs_markerCommentNToJSON(const struct gs_marker * gsm, const struct gs_comment * gsc ,char * jsonOutput, int jsonOutputAllocatedSize){
char jsonMarkerId[16]; /*{"id":%ld,*/
char jsonLat[32]; /*"latDegrees":%s,*/
char jsonLon[32]; /*"lonDegrees":%s,*/
char jsonType[32]; /*"type":"%s",*/
char jsonMessage[32 + (GS_COMMENT_MAX_LENGTH*4)+1]; /*"message":"%s",*/
char jsonAddressed[32]; /*"addressed":%s}*/
char jsonMessageId[32]; /*"messageId":%d*/
char latlon[DecimalWidth];
char escaped[(GS_COMMENT_MAX_LENGTH*4)+1];
int jsonMarkerIdWritten;
int jsonLatWritten;
int jsonLonWritten;
int jsonTypeWritten;
int jsonMessageWritten;
int jsonAddressedWritten;
int jsonMessageIdWritten;
bzero(jsonMarkerId,sizeof jsonMarkerId);
bzero(jsonLat,sizeof jsonLat);
bzero(jsonLon,sizeof jsonLon);
bzero(jsonType, sizeof jsonType);
bzero(jsonMessage, sizeof jsonMessage);
bzero(jsonAddressed, sizeof jsonAddressed);
bzero(latlon,sizeof latlon);
bzero(escaped, sizeof escaped);
bzero(jsonMessageId, sizeof jsonMessageId);
jsonMarkerIdWritten = snprintf(jsonMarkerId,sizeof jsonMarkerId, "{\"id\":%ld,", gsm->id);
formatDecimal(gsm->latitude,latlon);
jsonLatWritten = snprintf(jsonLat, sizeof jsonLat,"\"latDegrees\":%s,", latlon);
formatDecimal(gsm->longitude,latlon);
jsonLonWritten = snprintf(jsonLon, sizeof jsonLat,"\"lonDegrees\":%s,", latlon);
jsonTypeWritten = snprintf(jsonType, sizeof jsonType,"\"type\":\"%s\",",gsc->cType);
_escapeJSON(gsc->content, strlen(gsc->content), escaped);
jsonMessageWritten = snprintf(jsonMessage, sizeof jsonMessage,"\"message\":\"%s\",",escaped);
jsonMessageIdWritten = snprintf(jsonMessageId,sizeof jsonMessageId, "\"messageId\":%ld,", gsc->id);
jsonAddressedWritten = snprintf(jsonAddressed, sizeof jsonAddressed,"\"addressed\":%s}",gsm->addressed == ADDRESSED_TRUE ? "true" : "false");
if(jsonMarkerIdWritten + jsonLatWritten + jsonLonWritten + jsonTypeWritten + jsonMessageWritten + jsonAddressedWritten + jsonMessageIdWritten > jsonOutputAllocatedSize){
fprintf(stderr, "%s\n", "gs_markerCommentNToJSON may have returned partial JSON output due to not allocating enough memory");
#ifdef RETURN_ON_JSON_RISK
RETURN_ON_JSON_RISK;
#endif
}
return snprintf(jsonOutput,jsonOutputAllocatedSize-1, "%s%s%s%s%s%s%s", jsonMarkerId,jsonLat,jsonLon,jsonType,jsonMessage,jsonMessageId,jsonAddressed);
}
/* Recommend at least 128 for safety*/
int gs_heatmapToJSON(const struct gs_heatmap gsh, char * jsonOutput){
char * json;
char latitude[DecimalWidth];
char longitude[DecimalWidth];
bzero(latitude,DecimalWidth);
bzero(longitude,DecimalWidth);
formatDecimal(gsh.latitude,latitude);
formatDecimal(gsh.longitude,longitude);
json = "{\"latDegrees\" : %s, \"lonDegrees\" : %s, \"secondsWorked\" : %ld }";
return sprintf( jsonOutput,
json,
latitude,
longitude,
gsh.intensity
);
}
/* I'd recommend at least 110 bytes to be specified. Probably 128 for safety*/
int gs_markerToJSON(const struct gs_marker gsm, char * jsonOutput){
char * json;
char latitude[DecimalWidth];
char longitude[DecimalWidth];
bzero(latitude,DecimalWidth);
bzero(longitude,DecimalWidth);
formatDecimal(gsm.latitude,latitude);
formatDecimal(gsm.longitude,longitude);
json = "{\"id\" : %ld, \"commentId\" : %ld, \"timestamp\" : \"%s\", \"latitude\" : %s, \"longitude\" : %s, \"addressed\" : %s }";
return sprintf( jsonOutput,
json,
gsm.id,
gsm.commentId,
gsm.createdTime,
latitude,
longitude,
gsm.addressed == ADDRESSED_TRUE ? "true" : "false");
}
int gs_markerNToJSON(const struct gs_marker gsm, char * jsonOutput, int jsonOutputAllocatedSize){
char jsonId[15+sizeof(long)]; /*{\"id\" : %ld, */
char jsonCommId[21+sizeof(long)];/*\"commentId\" : %ld, */
char jsonTimestamp[25+GS_MARKER_CREATED_TIME_LENGTH+1];/* \"timestamp\" : \"%s\", */
char jsonLat[21+DecimalWidth];/* \"latitude\" : %s, */
char jsonLon[21+DecimalWidth];/* \"longitude\" : %s }*/
char latitude[DecimalWidth];
char longitude[DecimalWidth];
char addressed[25];
int jsonIdWritten;
int jsonCommIdWritten;
int jsonTimestampWritten;
int jsonLatWritten;
int jsonLonWritten;
int jsonAddressedWritten;
bzero(jsonId, sizeof jsonId );
bzero(jsonCommId, sizeof jsonCommId );
bzero(jsonTimestamp, sizeof jsonTimestamp );
bzero(jsonLat, sizeof jsonLat);
bzero(jsonLon, sizeof jsonLon );
bzero(addressed, sizeof addressed);
bzero(latitude, sizeof latitude);
bzero(longitude, sizeof longitude);
formatDecimal(gsm.latitude,latitude);
formatDecimal(gsm.longitude,longitude);
jsonIdWritten = snprintf(jsonId, sizeof jsonId, "{\"id\" : %ld, ", gsm.id);
jsonCommIdWritten = snprintf(jsonCommId, sizeof jsonCommId, "\"commentId\" : %ld, ", gsm.commentId);
jsonTimestampWritten = snprintf(jsonTimestamp, sizeof jsonTimestamp, " \"timestamp\" : \"%s\", ", gsm.createdTime);
jsonLatWritten = snprintf(jsonLat, sizeof jsonLat, " \"latitude\" : %s, ", latitude);
jsonLonWritten = snprintf(jsonLon, sizeof jsonLon, " \"longitude\" : %s,", longitude);
jsonAddressedWritten = snprintf(addressed, sizeof addressed, "\"addressed\" : %s}", gsm.addressed == ADDRESSED_TRUE ? "true" : "false");
if(jsonIdWritten + jsonCommIdWritten + jsonTimestampWritten + jsonLonWritten + jsonLatWritten + jsonAddressedWritten > jsonOutputAllocatedSize-1){
fprintf(stderr, "%s\n", "gs_markerNToJSON may have returned partial JSON output due to not allocating enough memory");
#ifdef RETURN_ON_JSON_RISK
RETURN_ON_JSON_RISK;
#endif
}
return snprintf(jsonOutput,jsonOutputAllocatedSize-1,"%s%s%s%s%s%s",jsonId, jsonCommId,jsonTimestamp,jsonLat,jsonLon, addressed);
}
QString hoursAndMinutes( int duration )
{
if ( duration == 0 ) {
if ( CONFIGURATION.durationFormat == Configuration::Minutes )
return QObject::tr( "00:00" );
else
return formatDecimal( 0.0 );
}
int minutes = duration / 60;
int hours = minutes / 60;
minutes = minutes % 60;
if ( CONFIGURATION.durationFormat == Configuration::Minutes ) {
QString text;
QTextStream stream( &text );
stream << qSetFieldWidth( 2 ) << qSetPadChar( QLatin1Char('0' ) )
<< hours << qSetFieldWidth( 0 ) << ":" << qSetFieldWidth( 2 ) << minutes;
return text;
} else { //Decimal
return formatDecimal(hours + minutes / 60.0 );
}
}
/**
* Formats the given length in the given format.
*
* @param length The length in the current unit of the drawing.
* @param format Format of the string.
* @param prec Precision of the value (e.g. 0.001 or 1/128 = 0.0078125)
& @param showUnit Append unit to the value.
*/
QString RS_Units::formatLinear(double length, RS2::Unit unit,
RS2::LinearFormat format,
int prec, bool showUnit) {
QString ret;
// unit appended to value (e.g. 'mm'):
/*QString unitString = "";
if (showUnit) {
unitString = unitToSign(unit);
}*/
// barbarian display: show as fraction:
switch (format) {
case RS2::Scientific:
ret = formatScientific(length, unit, prec, showUnit);
break;
case RS2::Decimal:
ret = formatDecimal(length, unit, prec, showUnit);
break;
case RS2::Engineering:
ret = formatEngineering(length, unit, prec, showUnit);
break;
case RS2::Architectural:
ret = formatArchitectural(length, unit, prec, showUnit);
break;
case RS2::Fractional:
ret = formatFractional(length, unit, prec, showUnit);
break;
case RS2::ArchitecturalMetric:
ret = formatArchitecturalMetric(length, unit, prec, showUnit);
break;
default:
RS_DEBUG->print(RS_Debug::D_WARNING,
"RS_Units::formatLinear: Unknown format");
ret = "";
break;
}
return ret;
}
/**
* Formats the given length in the given format.
*
* \param length The length in the current unit of the drawing.
* \param format Format of the string.
* \param prec Precision of the value (e.g. 0.001 or 1/128 = 0.0078125)
& \param showUnit Append unit to the value.
*/
QString RUnit::formatLinear(double length, RS::Unit unit,
RS::LinearFormat format,
int prec, bool showUnit,
bool showLeadingZeroes,
bool showTrailingZeroes,
bool onlyPreciseResult) {
QString ret;
// imperial display: show as fraction:
switch (format) {
case RS::Scientific:
ret = formatScientific(length, unit, prec, showUnit,
showLeadingZeroes, showTrailingZeroes, onlyPreciseResult);
break;
case RS::Decimal:
ret = formatDecimal(length, unit, prec, showUnit,
showLeadingZeroes, showTrailingZeroes, onlyPreciseResult);
break;
case RS::Engineering:
ret = formatEngineering(length, unit, prec, showUnit,
showLeadingZeroes, showTrailingZeroes, onlyPreciseResult);
break;
case RS::Architectural:
case RS::ArchitecturalStacked:
ret = formatArchitectural(length, unit, prec, showUnit,
showLeadingZeroes, showTrailingZeroes, onlyPreciseResult);
break;
case RS::Fractional:
case RS::FractionalStacked:
ret = formatFractional(length, unit, prec, showUnit,
showLeadingZeroes, showTrailingZeroes, onlyPreciseResult);
break;
default:
qWarning() << "RUnit::formatLinear: Unknown format";
ret = "";
break;
}
return ret;
}
