C++ output_data::write方法代码示例

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());
    }
    */
}

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());
  }
}