uint32_t TDebugProtocol::endItem() {
//uint32_t size;
switch (write_state_.back()) {
case UNINIT:
// XXX figure out what to do here.
//throw TProtocolException(TProtocolException::INVALID_DATA);
//return writeIndented(str);
return 0;
case STRUCT:
return writePlain(",\n");
case SET:
return writePlain(",\n");
case MAP_KEY:
write_state_.back() = MAP_VALUE;
return 0;
case MAP_VALUE:
write_state_.back() = MAP_KEY;
return writePlain(",\n");
case LIST:
return writePlain(",\n");
default:
throw std::logic_error("Invalid enum value.");
}
}
uint32_t TDebugProtocol::startItem() {
uint32_t size;
switch (write_state_.back()) {
case UNINIT:
// XXX figure out what to do here.
//throw TProtocolException(TProtocolException::INVALID_DATA);
//return writeIndented(str);
return 0;
case STRUCT:
return 0;
case SET:
return writeIndented("");
case MAP_KEY:
return writeIndented("");
case MAP_VALUE:
return writePlain(" -> ");
case LIST:
size = writeIndented(
"[" + boost::lexical_cast<string>(list_idx_.back()) + "] = ");
list_idx_.back()++;
return size;
default:
throw std::logic_error("Invalid enum value.");
}
}
uint32_t TDebugProtocol::writeItem(const std::string& str) {
uint32_t size = 0;
size += startItem();
size += writePlain(str);
size += endItem();
return size;
}
uint32_t TDebugProtocol::writeStructBegin(const char* name) {
uint32_t size = 0;
size += startItem();
size += writePlain(string(name) + " {\n");
indentUp();
write_state_.push_back(STRUCT);
return size;
}
uint32_t DebugProtocolWriter::writeMapBegin(TType keyType,
TType valueType,
uint32_t size) {
startItem();
writePlain("map<{},{}>[{}] {{\n",
fieldTypeName(keyType),
fieldTypeName(valueType),
size);
pushState(MAP_KEY);
return 0;
}
void DebugProtocolWriter::endItem() {
if (writeState_.empty()) { // top level
return;
}
auto& ws = writeState_.back();
++ws.index;
switch (ws.type) {
case LIST:
case STRUCT:
case SET:
writePlain(",\n");
break;
case MAP_KEY:
ws.type = MAP_VALUE;
break;
case MAP_VALUE:
ws.type = MAP_KEY;
writePlain(",\n");
}
}
uint32_t TDebugProtocol::writeSetBegin(const TType elemType,
const uint32_t size) {
// TODO(dreiss): Optimize short sets.
uint32_t bsize = 0;
bsize += startItem();
bsize += writePlain(
"set<" + fieldTypeName(elemType) + ">"
"[" + boost::lexical_cast<string>(size) + "] {\n");
indentUp();
write_state_.push_back(SET);
return bsize;
}
uint32_t TDebugProtocol::writeMapBegin(const TType keyType,
const TType valType,
const uint32_t size) {
// TODO(dreiss): Optimize short maps?
uint32_t bsize = 0;
bsize += startItem();
bsize += writePlain(
"map<" + fieldTypeName(keyType) + "," + fieldTypeName(valType) + ">"
"[" + boost::lexical_cast<string>(size) + "] {\n");
indentUp();
write_state_.push_back(MAP_KEY);
return bsize;
}
void DebugProtocolWriter::startItem() {
if (writeState_.empty()) { // top level
return;
}
auto& ws = writeState_.back();
switch (ws.type) {
case STRUCT:
break;
case SET:
case MAP_KEY:
writeIndent();
break;
case MAP_VALUE:
writePlain(" -> ");
break;
case LIST:
writeIndented("[{}] = ", ws.index);
break;
}
}
uint32_t DebugProtocolWriter::writeSetBegin(TType elemType, uint32_t size) {
startItem();
writePlain("set<{}>[{}] {{\n", fieldTypeName(elemType), size);
pushState(SET);
return 0;
}
uint32_t DebugProtocolWriter::writeStructBegin(const char* name) {
startItem();
writePlain("{} {{\n", name);
pushState(STRUCT);
return 0;
}