bool convertValueToStringValue(const Value value, Value &stringValue)
{
bool could_convert;
time_t rtvalue;
abstime_t atvalue;
string string_representation;
ClassAdUnParser unparser;
switch(value.GetType()) {
case Value::UNDEFINED_VALUE:
stringValue.SetUndefinedValue();
could_convert = false;
break;
case Value::ERROR_VALUE:
stringValue.SetErrorValue();
could_convert = false;
break;
case Value::STRING_VALUE:
stringValue.CopyFrom(value);
could_convert = true;
break;
case Value::CLASSAD_VALUE:
case Value::LIST_VALUE:
case Value::SLIST_VALUE:
case Value::BOOLEAN_VALUE:
case Value::INTEGER_VALUE:
case Value::REAL_VALUE:
unparser.Unparse(string_representation, value);
stringValue.SetStringValue(string_representation);
could_convert = true;
break;
case Value::ABSOLUTE_TIME_VALUE:
value.IsAbsoluteTimeValue(atvalue);
absTimeToString(atvalue, string_representation);
stringValue.SetStringValue(string_representation);
could_convert = true;
break;
case Value::RELATIVE_TIME_VALUE:
value.IsRelativeTimeValue(rtvalue);
relTimeToString(rtvalue, string_representation);
stringValue.SetStringValue(string_representation);
could_convert = true;
break;
default:
could_convert = false; // Make gcc's -Wuninitalized happy
CLASSAD_EXCEPT( "Should not reach here" );
break;
}
return could_convert;
}
void ClassAdJsonUnParser::
Unparse( string &buffer, const Value &val )
{
char tempBuf[512];
switch( val.GetType( ) ) {
case Value::NULL_VALUE:
buffer += "(null-value)";
break;
case Value::STRING_VALUE: {
string s;
val.IsStringValue( s );
buffer += '"';
UnparseAuxEscapeString( buffer, s );
buffer += '"';
return;
}
case Value::INTEGER_VALUE: {
long long i;
val.IsIntegerValue( i );
sprintf( tempBuf, "%lld", i );
buffer += tempBuf;
return;
}
case Value::REAL_VALUE: {
double real;
val.IsRealValue(real);
if (real == 0.0) {
// It might be positive or negative and it's
// hard to tell. printf is good at telling though.
// We also want to print it with as few
// digits as possible, which is why we don't use the
// case below.
sprintf(tempBuf, "%.1f", real);
buffer += tempBuf;
} else if (classad_isnan(real)) {
UnparseAuxQuoteExpr( buffer, "real(\"NaN\")" );
} else if (classad_isinf(real) == -1){
UnparseAuxQuoteExpr( buffer, "real(\"-INF\")" );
} else if (classad_isinf(real) == 1) {
UnparseAuxQuoteExpr( buffer, "real(\"INF\")" );
} else {
// Use the more user-friendly formatting of reals
// that we use for old ClassAds format
sprintf(tempBuf, "%.16G", real);
// %G may print something that looks like an integer or exponent.
// In that case, tack on a ".0"
if (tempBuf[strcspn(tempBuf, ".Ee")] == '\0') {
strcat(tempBuf, ".0");
}
buffer += tempBuf;
}
return;
}
case Value::BOOLEAN_VALUE: {
bool b;
val.IsBooleanValue( b );
buffer += b ? "true" : "false";
return;
}
case Value::UNDEFINED_VALUE: {
buffer += "null";
return;
}
case Value::ERROR_VALUE: {
UnparseAuxQuoteExpr( buffer, "error" );
return;
}
case Value::ABSOLUTE_TIME_VALUE: {
abstime_t asecs;
string s;
val.IsAbsoluteTimeValue(asecs);
s += "absTime(\"";
absTimeToString(asecs, s);
s += "\")";
UnparseAuxQuoteExpr( buffer, s );
return;
}
case Value::RELATIVE_TIME_VALUE: {
double rsecs;
string s;
val.IsRelativeTimeValue(rsecs);
s += "relTime(\"";
relTimeToString(rsecs, s);
s += "\")";
UnparseAuxQuoteExpr( buffer, s );
return;
}
case Value::SCLASSAD_VALUE:
case Value::CLASSAD_VALUE: {
const ClassAd *ad = NULL;
val.IsClassAdValue( ad );
Unparse( buffer, ad );
return;
}
case Value::SLIST_VALUE:
case Value::LIST_VALUE: {
const ExprList *el = NULL;
val.IsListValue( el );
Unparse( buffer, el );
return;
}
default:
break;
}
}