UnixStreamSocket::UnixStreamSocket(int fd) : ::UnixStreamSocket::UnixStreamSocket(fd, NS_MAX_SIZE) { MS_TRACE_STD(); // Create the JSON reader. { Json::CharReaderBuilder builder; Json::Value settings = Json::nullValue; Json::Value invalid_settings; builder.strictMode(&settings); MS_ASSERT(builder.validate(&invalid_settings), "invalid Json::CharReaderBuilder"); this->jsonReader = builder.newCharReader(); } // Create the JSON writer. { Json::StreamWriterBuilder builder; Json::Value invalid_settings; builder["commentStyle"] = "None"; builder["indentation"] = ""; builder["enableYAMLCompatibility"] = false; builder["dropNullPlaceholders"] = false; MS_ASSERT(builder.validate(&invalid_settings), "invalid Json::StreamWriterBuilder"); this->jsonWriter = builder.newStreamWriter(); } }
std::string JsontoString(Json::Value v) { std::stringstream sstream; Json::StreamWriterBuilder builder; std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter()); writer->write(v, &sstream); std::string result = sstream.str(); return result; }
int main() { char buffer[1024] = {0}; std::streamsize ssize; std::ostringstream osstr; while (std::cin.good()) { osstr << buffer; std::cin.getline(buffer, sizeof(buffer) - 1); ssize = std::cin.gcount(); if (ssize < (sizeof(buffer) - 1)) { buffer[ssize - 1] = '\n'; buffer[ssize] = 0; } } boost::asio::io_service io; tcp::resolver resolver(io); tcp::resolver::query query("0.0.0.0", "4242"); tcp::resolver::iterator endpoint_it = resolver.resolve(query); tcp::socket socket(io); boost::asio::connect(socket, endpoint_it); std::string str = osstr.str(); unsigned int size = str.size(); std::cout << "Will write " << size; size = swapBytes(size); std::cout << ": raw(" << size << ")" << std::endl; std::vector<boost::asio::const_buffer> buffers = { boost::asio::buffer(&size, sizeof(size)), boost::asio::buffer(str) }; boost::asio::write(socket, buffers); //======== boost::asio::read(socket, boost::asio::buffer(&size, sizeof(size))); std::cout << "Will read " << size; size = swapBytes(size); std::cout << ": raw(" << size << ")" << std::endl; char *readBuf = new char[size]; boost::asio::read(socket, boost::asio::buffer(readBuf, size)); Json::Reader reader; Json::Value response; reader.parse(readBuf, readBuf + size - 1, response); Json::StreamWriterBuilder builder; std::shared_ptr<Json::StreamWriter> writer(builder.newStreamWriter()); writer->write(response, &std::cout); std::cout << std::endl; return (0); }
Json::Value Connection::exec_call(const std::string& methodname, Json::Value params) { Json::Value call; call["method"]=methodname; call["params"]=params; call["id"]=0; std::stringstream json_call; Json::StreamWriterBuilder builder; std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter()); writer->write(call, &json_call); std::string json_call_str = json_call.str(); boost::asio::streambuf request; std::ostream request_stream(&request); request_stream << "POST /" << link << " HTTP/1.1\r\n"; request_stream << "Host: " << hostname << "\r\n"; request_stream << "Content-Type: application/json-rpc\r\n"; request_stream << "Content-Length: " << json_call_str.size() << "\r\n"; request_stream << "Connection: keep-alive\r\n\r\n"; request_stream << json_call_str << "\r\n\r\n"; // Send the request. boost::system::error_code ec; boost::asio::write(socket, request, ec); if(ec) { std::cout << ec.message() << std::endl; throw ConnectionError(ec.message()); } boost::asio::streambuf response; boost::asio::read_until(socket, response, "\r\n"); // Check that response is OK. std::istream response_stream(&response); std::string http_version; response_stream >> http_version; unsigned int status_code; response_stream >> status_code; std::string status_message; std::getline(response_stream, status_message); if (!response_stream || http_version.substr(0, 5) != "HTTP/") { std::cout << "Invalid response\n"; throw ConnectionError("Invalid response"); } if (status_code != 200) { std::cout << "Response returned with status code " << status_code << "\n"; std::stringstream error; error << "Response returned with status code " << status_code; throw ConnectionError(error.str()); } // Read the response headers, which are terminated by a blank line. boost::asio::read_until(socket, response, "\r\n\r\n"); // Process the response headers. std::string header; std::stringstream header_stream; while (std::getline(response_stream, header) && header != "\r") header_stream << header << "\n"; header_stream << "\n"; std::stringstream json_result; // Write whatever content we already have to output. if (response.size() > 0) json_result << &response; Json::CharReaderBuilder reader_builder; reader_builder["collectComments"] = false; Json::Value value; std::string errs; bool ok = Json::parseFromStream(reader_builder, json_result, &value, &errs); if(!ok) { throw ConnectionError(errs); } return process_result(value); }
void ResultIO::writeResultContainerToJSON(ResultContainer result, const std::string & filename) { auto root = Json::Value(); root["fasta"] = result.fasta; root["id"] = result.id; root["fastaLabels"] = Json::Value(Json::arrayValue); for (auto & lbl : result.fastaLabels) { root["fastaLabels"].append(lbl); } root["oneshot"] = clusterAnalysisResultToJSON(result, result.oneshot, false); root["bootstraps"] = Json::Value(Json::arrayValue); for (auto & bs : result.bootstraps) { root["bootstraps"].append(clusterAnalysisResultToJSON(result, bs, true)); } if (krakenEnabled) { root["krakenLabels"] = Json::Value(Json::arrayValue); for (auto & lbl : result.fastaLabels) { std::string krakenLbl = "unknown"; if (result.kraken.classification.find(lbl) != result.kraken.classification.end()) { krakenLbl = result.kraken.classification.at(lbl); } root["krakenLabels"].append(krakenLbl); } root["krakenBacterialBackground"] = result.kraken.bacterialBackground; } root["contains16S"] = Json::Value(Json::arrayValue); for (const std::string & s : result._16S) { root["contains16S"].append(!s.empty()); } root["stats"] = Json::Value(); root["stats"]["numBasepairs"] = (unsigned)result.stats.numBasepairs; root["stats"]["gcContent"] = result.stats.gcContent; root["stats"]["contigGcContent"] = Json::Value(); for (const auto & entry : result.stats.contigGcContent) { root["stats"]["contigGcContent"][entry.first] = entry.second; } root["stats"]["contigLength"] = Json::Value(); for (const auto & entry : result.stats.contigLength) { root["stats"]["contigLength"][entry.first] = (unsigned)entry.second; } Json::StreamWriterBuilder builder; std::unique_ptr<Json::StreamWriter> writer(builder.newStreamWriter()); std::ofstream ofs(filename, std::ofstream::out | std::ofstream::app); ofs << "results['" << result.fasta << "'] = "; writer->write(root, &ofs); ofs << ";" << std::endl; ofs.close(); }