Encoder& TextEncoder::writeStruct(const coda::runtime::Object* value, bool shared) {
size_t stackLen = states.size();
beginValue();
if (value == NULL) {
strm << "null";
} else {
if (shared) {
int32_t index = addShared(value);
if (index >= 0) {
beginValue();
strm << '%' << index;
return *this;
}
}
void* sid = (void*) value;
if (inProgress.find(sid) != inProgress.end()) {
throw EncodingError("Already serializing object of type " +
value->descriptor()->getFullName());
}
inProgress.insert(sid);
writeBeginStruct();
int32_t index = getSharedIndex(value);
assert(index != 0);
if (index >= 0) {
strm << " #" << index;
}
value->encode(this);
writeEndStruct();
inProgress.erase(sid);
}
assert(stackLen == states.size());
return *this;
}
Writer& Writer::writeRawValue(const std::string& value)
{
beginValue();
*m_Stream << value;
m_State = AT_END_OF_VALUE;
return *this;
}
Encoder& TextEncoder::writeString(const runtime::StringRef& value) {
beginValue();
strm << "'";
strm << value; // TODO: Escapes
strm << "'";
return *this;
}
Encoder& TextEncoder::writeBoolean(bool value) {
beginValue();
if (value) {
strm << "true";
} else {
strm << "false";
}
return *this;
}
Encoder& TextEncoder::writeSubtypeHeader(const runtime::StringRef& subtypeName, int32_t subtypeId) {
states.push_back(state);
beginValue();
strm << '$' << subtypeId << " (" << subtypeName << "): {";
indentLevel += 2;
first = true;
state = STRUCT;
return *this;
}
Writer& Writer::writeValue(const std::string& value)
{
beginValue();
*m_Stream << "\"";
if (!Ystring::hasUnescapedCharacters(value))
*m_Stream << value;
else
*m_Stream << Ystring::escape(value);
*m_Stream << "\"";
m_State = AT_END_OF_VALUE;
return *this;
}
Encoder& TextEncoder::writeBeginSet(
coda::descriptors::TypeKind elementKind, size_t length, bool fixed) {
if (states.size() > maxDepth) {
throw EncodingError("Maximum recursion depth exceeded");
}
states.push_back(state);
beginValue();
strm << '[';
indentLevel += 2;
state = CONTAINER;
first = true;
return *this;
}
Writer& Writer::writeIntValueImpl(T value)
{
beginValue();
if (!(m_LanguagExtensions & INTEGERS_AS_HEX))
*m_Stream << value;
else if ((m_LanguagExtensions & INTEGERS_AS_HEX) == INTEGERS_AS_HEX)
*m_Stream << "\"0x" << std::hex << std::uppercase << value << '"' << std::dec;
else if (m_LanguagExtensions & INTEGERS_AS_OCT)
*m_Stream << "\"0o" << std::oct << value << '"' << std::dec;
else if (m_LanguagExtensions & INTEGERS_AS_BIN)
writeBinary(*m_Stream, value);
m_State = AT_END_OF_VALUE;
return *this;
}
Encoder& TextEncoder::writeBeginMap(
coda::descriptors::TypeKind keyKind,
coda::descriptors::TypeKind valueKind,
size_t length) {
if (states.size() > maxDepth) {
throw EncodingError("Maximum recursion depth exceeded");
}
states.push_back(state);
beginValue();
strm << '{';
indentLevel += 2;
state = MAP_KEY;
first = true;
return *this;
}
Writer& Writer::writeBeginStructure(char startChar, char endChar,
Formatting formatting)
{
beginValue();
*m_Stream << startChar;
if (formatting == DEFAULT)
{
formatting = m_Context.empty() ? FORMAT
: m_Context.top().formatting;
}
if (formatting == FORMAT)
indent();
m_Context.push(Context(endChar, formatting));
m_State = AT_START_OF_STRUCTURE;
return *this;
}
//
// value type
//
void
GeneratorBase::doValue(IR__::ValueDef_ptr value)
{
beginValue(value);
IR__::ContainedSeq_var contained_seq = value->contents(CORBA__::dk_all, false);
CORBA::ULong len = contained_seq->length();
for(CORBA::ULong i = 0; i < len; i++)
{
// contained members
if (((*contained_seq)[i])->def_kind() == CORBA__::dk_ValueMember)
{
IR__::ValueMemberDef_var act_member = IR__::ValueMemberDef::_narrow(((*contained_seq)[i]));
doValueMember(act_member);
}
}
endValue(value);
}
Writer& Writer::writeFloatValueImpl(T value)
{
if (std::isfinite(value))
{
beginValue();
*m_Stream << value;
m_State = AT_END_OF_VALUE;
}
else if (!languageExtension(NON_FINITE_FLOATS_AS_STRINGS))
{
YSON_THROW(std::string("Illegal floating point value '")
+ std::to_string(value) + "'");
}
else
{
if (std::isnan(value))
writeValue("NaN");
else if (value < 0)
writeValue("-infinity");
else
writeValue("infinity");
}
return *this;
}
Encoder& TextEncoder::writeDouble(double value) {
beginValue();
strm << value;
return *this;
}
Encoder& TextEncoder::writeFloat(float value) {
beginValue();
strm << value;
return *this;
}
Encoder& TextEncoder::writeFixed64(int64_t value) {
beginValue();
strm << value;
return *this;
}
Encoder& TextEncoder::writeInteger(int32_t value) {
beginValue();
strm << value;
return *this;
}
Encoder& TextEncoder::writeBytes(const runtime::StringRef& value) {
beginValue();
strm << "<[";
strm << "]>";
return *this;
}
