static void format_json_uniform_dim(output_data& out, const ndt::type& dt, const char *metadata, const char *data)
{
out.write('[');
switch (dt.get_type_id()) {
case strided_dim_type_id: {
const strided_dim_type *sad = static_cast<const strided_dim_type *>(dt.extended());
const strided_dim_type_metadata *md = reinterpret_cast<const strided_dim_type_metadata *>(metadata);
ndt::type element_tp = sad->get_element_type();
intptr_t size = md->size, stride = md->stride;
metadata += sizeof(strided_dim_type_metadata);
for (intptr_t i = 0; i < size; ++i) {
::format_json(out, element_tp, metadata, data + i * stride);
if (i != size - 1) {
out.write(',');
}
}
break;
}
case fixed_dim_type_id: {
const fixed_dim_type *fad = static_cast<const fixed_dim_type *>(dt.extended());
ndt::type element_tp = fad->get_element_type();
intptr_t size = (intptr_t)fad->get_fixed_dim_size(), stride = fad->get_fixed_stride();
for (intptr_t i = 0; i < size; ++i) {
::format_json(out, element_tp, metadata, data + i * stride);
if (i != size - 1) {
out.write(',');
}
}
break;
}
case var_dim_type_id: {
const var_dim_type *vad = static_cast<const var_dim_type *>(dt.extended());
const var_dim_type_metadata *md = reinterpret_cast<const var_dim_type_metadata *>(metadata);
const var_dim_type_data *d = reinterpret_cast<const var_dim_type_data *>(data);
ndt::type element_tp = vad->get_element_type();
intptr_t size = d->size, stride = md->stride;
const char *begin = d->begin + md->offset;
metadata += sizeof(var_dim_type_metadata);
for (intptr_t i = 0; i < size; ++i) {
::format_json(out, element_tp, metadata, begin + i * stride);
if (i != size - 1) {
out.write(',');
}
}
break;
}
default: {
stringstream ss;
ss << "Formatting dynd type " << dt << " as JSON is not implemented yet";
throw runtime_error(ss.str());
}
}
out.write(']');
}
static void format_json_bool(output_data &out, const ndt::type &dt, const char *arrmeta, const char *data)
{
bool1 value(false);
if (dt.get_type_id() == bool_type_id) {
value = (*data != 0);
} else {
typed_data_assign(ndt::type::make<bool1>(), NULL, reinterpret_cast<char *>(&value), dt, arrmeta, data);
}
if (value) {
out.write("true");
} else {
out.write("false");
}
}
static void format_json_encoded_string(output_data &out, const char *begin, const char *end, string_encoding_t encoding)
{
uint32_t cp;
next_unicode_codepoint_t next_fn;
append_unicode_codepoint_t append_fn;
next_fn = get_next_unicode_codepoint_function(encoding, assign_error_nocheck);
append_fn = get_append_unicode_codepoint_function(string_encoding_utf_8, assign_error_nocheck);
out.write('\"');
while (begin < end) {
cp = next_fn(begin, end);
print_escaped_unicode_codepoint(out, cp, append_fn);
}
out.write('\"');
}
static void format_json_number(output_data &out, const ndt::type &dt,
const char *arrmeta, const char *data)
{
stringstream ss;
dt.print_data(ss, arrmeta, data);
out.write(ss.str());
}
static void format_json_struct(output_data &out, const ndt::type &dt, const char *arrmeta, const char *data)
{
const ndt::base_struct_type *bsd = dt.extended<ndt::base_struct_type>();
intptr_t field_count = bsd->get_field_count();
const size_t *data_offsets = bsd->get_data_offsets(arrmeta);
const size_t *arrmeta_offsets = bsd->get_arrmeta_offsets_raw();
if (out.struct_as_list) {
out.write('[');
for (intptr_t i = 0; i < field_count; ++i) {
::format_json(out, bsd->get_field_type(i), arrmeta + arrmeta_offsets[i], data + data_offsets[i]);
if (i != field_count - 1) {
out.write(',');
}
}
out.write(']');
} else {
out.write('{');
for (intptr_t i = 0; i < field_count; ++i) {
const dynd::string &fname = bsd->get_field_name_raw(i);
format_json_encoded_string(out, fname.begin(), fname.end(), string_encoding_utf_8);
out.write(':');
::format_json(out, bsd->get_field_type(i), arrmeta + arrmeta_offsets[i], data + data_offsets[i]);
if (i != field_count - 1) {
out.write(',');
}
}
out.write('}');
}
}
static void format_json_option(output_data &out, const ndt::type &dt, const char *arrmeta, const char *data)
{
const ndt::option_type *ot = dt.extended<ndt::option_type>();
if (ot->is_avail(arrmeta, data, &eval::default_eval_context)) {
format_json(out, ot->get_value_type(), arrmeta, data);
} else {
out.write("null");
}
}
static void format_json_struct(output_data& out, const ndt::type& dt, const char *metadata, const char *data)
{
const base_struct_type *bsd = static_cast<const base_struct_type *>(dt.extended());
size_t field_count = bsd->get_field_count();
const string *field_names = bsd->get_field_names();
const ndt::type *field_types = bsd->get_field_types();
const size_t *data_offsets = bsd->get_data_offsets(metadata);
const size_t *metadata_offsets = bsd->get_metadata_offsets();
out.write('{');
for (size_t i = 0; i < field_count; ++i) {
const string& fname = field_names[i];
format_json_encoded_string(out, fname.data(), fname.data() + fname.size(), string_encoding_utf_8);
out.write(':');
::format_json(out, field_types[i], metadata + metadata_offsets[i], data + data_offsets[i]);
if (i != field_count - 1) {
out.write(',');
}
}
out.write('}');
}
static void format_json_string(output_data& out, const ndt::type& dt, const char *metadata, const char *data)
{
if (dt.get_type_id() == json_type_id) {
// Copy the JSON data directly
const json_type_data *d = reinterpret_cast<const json_type_data *>(data);
out.write(d->begin, d->end);
} else {
const base_string_type *bsd = static_cast<const base_string_type *>(dt.extended());
string_encoding_t encoding = bsd->get_encoding();
const char *begin = NULL, *end = NULL;
bsd->get_string_range(&begin, &end, metadata, data);
format_json_encoded_string(out, begin, end, encoding);
}
}
static void format_json_dynamic(output_data &out, const ndt::type &dt,
const char *DYND_UNUSED(arrmeta),
const char *data)
{
if (dt.get_type_id() == json_type_id) {
// Copy the JSON data directly
const json_type_data *d = reinterpret_cast<const json_type_data *>(data);
out.write(d->begin, d->end);
} else {
stringstream ss;
ss << "Formatting dynd type " << dt << " as JSON is not implemented yet";
throw runtime_error(ss.str());
}
}
static void print_escaped_unicode_codepoint(output_data &out, uint32_t cp, append_unicode_codepoint_t append_fn)
{
if (cp < 0x80) {
switch (cp) {
case '\b':
out.write("\\b");
break;
case '\f':
out.write("\\f");
break;
case '\n':
out.write("\\n");
break;
case '\r':
out.write("\\r");
break;
case '\t':
out.write("\\t");
break;
case '\\':
out.write("\\\\");
break;
case '/':
out.write("\\/");
break;
case '\"':
out.write("\\\"");
break;
default:
if (cp < 0x20 || cp == 0x7f) {
stringstream ss;
ss << "\\u";
hexadecimal_print(ss, static_cast<uint16_t>(cp));
out.write(ss.str());
} else {
out.write(static_cast<char>(cp));
}
break;
}
} else {
out.ensure_capacity(16);
append_fn(cp, out.out_end, out.out_capacity_end);
}
// TODO: Could have an ASCII output mode where unicode is always escaped
/*
else if (cp < 0x10000) {
stringstream ss;
ss << "\\u";
hexadecimal_print(ss, static_cast<uint16_t>(cp));
out.write(ss.str());
} else {
stringstream ss;
ss << "\\U";
hexadecimal_print(ss, static_cast<uint32_t>(cp));
out.write(ss.str());
}
*/
}
