inline void init(const ndt::type& tp0, const char *metadata0, char *data0)
{
m_array_tp = tp0;
m_iter_ndim = m_array_tp.get_ndim();
m_itersize = 1;
if (m_iter_ndim != 0) {
m_iterindex.init(m_iter_ndim);
memset(m_iterindex.get(), 0, sizeof(intptr_t) * m_iter_ndim);
m_itershape.init(m_iter_ndim);
m_array_tp.extended()->get_shape(m_iter_ndim, 0, m_itershape.get(), metadata0);
size_t iterdata_size = m_array_tp.extended()->get_iterdata_size(m_iter_ndim);
m_iterdata = reinterpret_cast<iterdata_common *>(malloc(iterdata_size));
if (!m_iterdata) {
throw std::bad_alloc();
}
m_metadata = metadata0;
m_array_tp.iterdata_construct(m_iterdata,
&m_metadata, m_iter_ndim, m_itershape.get(), m_uniform_tp);
m_data = m_iterdata->reset(m_iterdata, data0, m_iter_ndim);
for (size_t i = 0, i_end = m_iter_ndim; i != i_end; ++i) {
m_itersize *= m_itershape[i];
}
} else {
m_iterdata = NULL;
m_uniform_tp = m_array_tp;
m_data = data0;
m_metadata = metadata0;
}
}
size_t fixedbytes_type::make_assignment_kernel(
ckernel_builder *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *dst_arrmeta, const ndt::type &src_tp, const char *src_arrmeta,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
switch (src_tp.get_type_id()) {
case fixedbytes_type_id: {
const fixedbytes_type *src_fs = src_tp.tcast<fixedbytes_type>();
if (get_data_size() != src_fs->get_data_size()) {
throw runtime_error("cannot assign to a fixedbytes type of a different size");
}
return ::make_pod_typed_data_assignment_kernel(ckb, ckb_offset,
get_data_size(), std::min(get_data_alignment(), src_fs->get_data_alignment()),
kernreq);
}
default: {
return src_tp.extended()->make_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_tp, src_arrmeta,
kernreq, ectx);
}
}
} else {
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw dynd::type_error(ss.str());
}
}
size_t fixedstring_type::make_comparison_kernel(
void *ckb, intptr_t ckb_offset, const ndt::type &src0_dt,
const char *src0_arrmeta, const ndt::type &src1_dt,
const char *src1_arrmeta, comparison_type_t comptype,
const eval::eval_context *ectx) const
{
if (this == src0_dt.extended()) {
if (*this == *src1_dt.extended()) {
return make_fixedstring_comparison_kernel(ckb, ckb_offset,
m_stringsize, m_encoding,
comptype, ectx);
} else if (src1_dt.get_kind() == string_kind) {
return make_general_string_comparison_kernel(ckb, ckb_offset,
src0_dt, src0_arrmeta,
src1_dt, src1_arrmeta,
comptype, ectx);
} else if (!src1_dt.is_builtin()) {
return src1_dt.extended()->make_comparison_kernel(ckb, ckb_offset,
src0_dt, src0_arrmeta,
src1_dt, src1_arrmeta,
comptype, ectx);
}
}
throw not_comparable_error(src0_dt, src1_dt, comptype);
}
size_t cstruct_type::make_assignment_kernel(
ckernel_builder *out, size_t offset_out,
const ndt::type& dst_tp, const char *dst_metadata,
const ndt::type& src_tp, const char *src_metadata,
kernel_request_t kernreq, assign_error_mode errmode,
const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
if (this == src_tp.extended()) {
return make_struct_identical_assignment_kernel(out, offset_out,
dst_tp,
dst_metadata, src_metadata,
kernreq, errmode, ectx);
} else if (src_tp.get_kind() == struct_kind) {
return make_struct_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
} else if (!src_tp.is_builtin()) {
return src_tp.extended()->make_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
}
}
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw runtime_error(ss.str());
}
size_t string_type::make_comparison_kernel(
ckernel_builder *out, size_t offset_out,
const ndt::type& src0_dt, const char *src0_metadata,
const ndt::type& src1_dt, const char *src1_metadata,
comparison_type_t comptype,
const eval::eval_context *ectx) const
{
if (this == src0_dt.extended()) {
if (*this == *src1_dt.extended()) {
return make_string_comparison_kernel(out, offset_out,
m_encoding,
comptype, ectx);
} else if (src1_dt.get_kind() == string_kind) {
return make_general_string_comparison_kernel(out, offset_out,
src0_dt, src0_metadata,
src1_dt, src1_metadata,
comptype, ectx);
} else if (!src1_dt.is_builtin()) {
return src1_dt.extended()->make_comparison_kernel(out, offset_out,
src0_dt, src0_metadata,
src1_dt, src1_metadata,
comptype, ectx);
}
}
throw not_comparable_error(src0_dt, src1_dt, comptype);
}
size_t bytes_type::make_assignment_kernel(
void *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *dst_arrmeta, const ndt::type &src_tp, const char *src_arrmeta,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
switch (src_tp.get_type_id()) {
case bytes_type_id: {
return make_blockref_bytes_assignment_kernel(ckb, ckb_offset,
get_data_alignment(), dst_arrmeta,
src_tp.get_data_alignment(), src_arrmeta,
kernreq, ectx);
}
case fixedbytes_type_id: {
return make_fixedbytes_to_blockref_bytes_assignment_kernel(ckb, ckb_offset,
get_data_alignment(), dst_arrmeta,
src_tp.get_data_size(), src_tp.get_data_alignment(),
kernreq, ectx);
}
default: {
if (!src_tp.is_builtin()) {
src_tp.extended()->make_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_tp,
src_arrmeta, kernreq, ectx);
}
break;
}
}
}
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw runtime_error(ss.str());
}
size_t cfixed_dim_type::make_assignment_kernel(
ckernel_builder *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *dst_arrmeta, const ndt::type &src_tp, const char *src_arrmeta,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
intptr_t src_size, src_stride;
ndt::type src_el_tp;
const char *src_el_arrmeta;
if (src_tp.get_ndim() < dst_tp.get_ndim()) {
kernels::strided_assign_ck *self =
kernels::strided_assign_ck::create(ckb, kernreq, ckb_offset);
self->m_size = get_fixed_dim_size();
self->m_dst_stride = get_fixed_stride();
// If the src has fewer dimensions, broadcast it across this one
self->m_src_stride = 0;
return ::make_assignment_kernel(
ckb, ckb_offset, m_element_tp,
dst_arrmeta + sizeof(cfixed_dim_type_arrmeta), src_tp, src_arrmeta,
kernel_request_strided, ectx);
} else if (src_tp.get_as_strided(src_arrmeta, &src_size, &src_stride,
&src_el_tp, &src_el_arrmeta)) {
kernels::strided_assign_ck *self =
kernels::strided_assign_ck::create(ckb, kernreq, ckb_offset);
self->m_size = get_fixed_dim_size();
self->m_dst_stride = get_fixed_stride();
self->m_src_stride = src_stride;
// Check for a broadcasting error
if (src_size != 1 && get_fixed_dim_size() != src_size) {
throw broadcast_error(dst_tp, dst_arrmeta, src_tp, src_arrmeta);
}
return ::make_assignment_kernel(
ckb, ckb_offset, m_element_tp,
dst_arrmeta + sizeof(cfixed_dim_type_arrmeta), src_el_tp,
src_el_arrmeta, kernel_request_strided, ectx);
} else if (!src_tp.is_builtin()) {
// Give the src type a chance to make a kernel
return src_tp.extended()->make_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_tp, src_arrmeta,
kernreq, ectx);
} else {
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw dynd::type_error(ss.str());
}
} else if (dst_tp.get_kind() == string_kind) {
return make_any_to_string_assignment_kernel(ckb, ckb_offset, dst_tp,
dst_arrmeta, src_tp,
src_arrmeta, kernreq, ectx);
} else if (dst_tp.get_ndim() < src_tp.get_ndim()) {
throw broadcast_error(dst_tp, dst_arrmeta, src_tp, src_arrmeta);
} else {
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw dynd::type_error(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(']');
}
~buffer_storage()
{
if (m_storage && m_type.get_flags()&type_flag_destructor) {
m_type.extended()->data_destruct_strided(m_arrmeta, m_storage, m_stride,
DYND_BUFFER_CHUNK_SIZE);
}
delete[] m_storage;
if (m_arrmeta) {
m_type.extended()->arrmeta_destruct(m_arrmeta);
delete[] m_arrmeta;
}
}
bool typevar_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == typevar_type_id) {
return *dst_tp.extended() == *src_tp.extended();
}
}
return false;
}
size_t datetime_type::make_assignment_kernel(
ckernel_builder *out, size_t offset_out,
const ndt::type& dst_tp, const char *dst_metadata,
const ndt::type& src_tp, const char *src_metadata,
kernel_request_t kernreq, assign_error_mode errmode,
const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
if (src_tp == dst_tp) {
return make_pod_typed_data_assignment_kernel(out, offset_out,
get_data_size(), get_data_alignment(), kernreq);
} else if (src_tp.get_kind() == string_kind) {
// Assignment from strings
return make_string_to_datetime_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
} else if (src_tp.get_kind() == struct_kind) {
// Convert to struct using the "struct" property
return ::make_assignment_kernel(out, offset_out,
ndt::make_property(dst_tp, "struct"), dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
} else if (!src_tp.is_builtin()) {
return src_tp.extended()->make_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
}
} else {
if (dst_tp.get_kind() == string_kind) {
// Assignment to strings
return make_datetime_to_string_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
} else if (dst_tp.get_kind() == struct_kind) {
// Convert to struct using the "struct" property
return ::make_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
ndt::make_property(src_tp, "struct"), src_metadata,
kernreq, errmode, ectx);
}
// TODO
}
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw runtime_error(ss.str());
}
bool categorical_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
// Casting from identical types
return true;
} else {
return false; // TODO
}
} else {
return ::is_lossless_assignment(dst_tp, m_category_tp); // TODO
}
}
size_t string_type::make_assignment_kernel(
ckernel_builder *out, size_t offset_out,
const ndt::type& dst_tp, const char *dst_metadata,
const ndt::type& src_tp, const char *src_metadata,
kernel_request_t kernreq, assign_error_mode errmode,
const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
switch (src_tp.get_type_id()) {
case string_type_id: {
return make_blockref_string_assignment_kernel(out, offset_out,
dst_metadata, get_encoding(),
src_metadata, static_cast<const base_string_type *>(src_tp.extended())->get_encoding(),
kernreq, errmode, ectx);
}
case fixedstring_type_id: {
return make_fixedstring_to_blockref_string_assignment_kernel(out, offset_out,
dst_metadata, get_encoding(),
src_tp.get_data_size(),
static_cast<const base_string_type *>(src_tp.extended())->get_encoding(),
kernreq, errmode, ectx);
}
default: {
if (!src_tp.is_builtin()) {
return src_tp.extended()->make_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp, src_metadata,
kernreq, errmode, ectx);
} else {
return make_builtin_to_string_assignment_kernel(out, offset_out,
dst_tp, dst_metadata,
src_tp.get_type_id(),
kernreq, errmode, ectx);
}
}
}
} else {
if (dst_tp.is_builtin()) {
return make_string_to_builtin_assignment_kernel(out, offset_out,
dst_tp.get_type_id(),
src_tp, src_metadata,
kernreq, errmode, ectx);
} else {
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw dynd::type_error(ss.str());
}
}
}
bool fixedbytes_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == fixedbytes_type_id) {
const fixedbytes_type *src_fs = static_cast<const fixedbytes_type*>(src_tp.extended());
return get_data_size() == src_fs->get_data_size();
} else {
return false;
}
} else {
return false;
}
}
bool datetime_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == date_type_id) {
// There is only one possibility for the date type (TODO: timezones!)
return true;
} else {
return false;
}
} else {
return false;
}
}
/**
* Scans through the types, and tries to view data
* for 'tp'/'arrmeta' as 'view_tp'. For this to be
* possible, one must be able to construct
* arrmeta for 'tp' corresponding to the same data.
*
* \param tp The type of the data.
* \param arrmeta The array arrmeta of the data.
* \param view_tp The type the data should be viewed as.
* \param view_arrmeta The array arrmeta of the view, which should be populated.
* \param embedded_reference The containing memory block in case the data was embedded.
*
* \returns If it worked, returns true, otherwise false.
*/
static bool try_view(const ndt::type &tp, const char *arrmeta, const ndt::type &view_tp, char *view_arrmeta,
dynd::memory_block_data *embedded_reference)
{
switch (tp.get_type_id()) {
case fixed_dim_type_id: {
// All the strided dim types share the same arrmeta, so can be
// treated uniformly here
const ndt::base_dim_type *sdt = tp.extended<ndt::base_dim_type>();
const fixed_dim_type_arrmeta *md = reinterpret_cast<const fixed_dim_type_arrmeta *>(arrmeta);
switch (view_tp.get_type_id()) {
case fixed_dim_type_id: { // strided as fixed
const ndt::fixed_dim_type *view_fdt = view_tp.extended<ndt::fixed_dim_type>();
// The size must match exactly in this case
if (md->dim_size != view_fdt->get_fixed_dim_size()) {
return false;
}
fixed_dim_type_arrmeta *view_md = reinterpret_cast<fixed_dim_type_arrmeta *>(view_arrmeta);
if (try_view(sdt->get_element_type(), arrmeta + sizeof(fixed_dim_type_arrmeta), view_fdt->get_element_type(),
view_arrmeta + sizeof(fixed_dim_type_arrmeta), embedded_reference)) {
*view_md = *md;
return true;
} else {
return false;
}
}
default: // other cases cannot be handled
return false;
}
}
default:
if (tp == view_tp) {
// require equal types otherwise
if (tp.get_arrmeta_size() > 0) {
tp.extended()->arrmeta_copy_construct(view_arrmeta, arrmeta, embedded_reference);
}
return true;
} else if (tp.is_pod() && view_tp.is_pod() && tp.get_data_size() == view_tp.get_data_size() &&
tp.get_data_alignment() >= view_tp.get_data_alignment()) {
// POD types with matching properties
if (view_tp.get_arrmeta_size() > 0) {
view_tp.extended()->arrmeta_default_construct(view_arrmeta, true);
}
return true;
} else {
return false;
}
}
}
adapt_type::adapt_type(const ndt::type &operand_type,
const ndt::type &value_type, const nd::string &op)
: base_expr_type(
adapt_type_id, expr_kind, operand_type.get_data_size(),
operand_type.get_data_alignment(),
inherited_flags(value_type.get_flags(), operand_type.get_flags()), 0),
m_value_type(value_type), m_operand_type(operand_type), m_op(op)
{
if (!value_type.is_builtin() &&
value_type.extended()->adapt_type(operand_type.value_type(), op,
m_forward, m_reverse)) {
} else if (!operand_type.value_type().is_builtin() &&
operand_type.value_type().extended()->reverse_adapt_type(
value_type, op, m_forward, m_reverse)) {
} else {
stringstream ss;
ss << "Cannot create type ";
print_type(ss);
throw type_error(ss.str());
}
// If the operand is an expression, make a buffering arrfunc
if (m_operand_type.get_kind() == expr_kind && !m_forward.is_null() &&
m_operand_type != m_forward.get_type()->get_arg_type(0)) {
m_forward = make_chain_arrfunc(
make_arrfunc_from_assignment(m_forward.get_type()->get_arg_type(0),
m_operand_type, assign_error_default),
m_forward, m_forward.get_type()->get_arg_type(0));
}
}
expr_type::expr_type(const ndt::type& value_type, const ndt::type& operand_type,
const expr_kernel_generator *kgen)
: base_expression_type(expr_type_id, expression_kind,
operand_type.get_data_size(), operand_type.get_data_alignment(),
inherited_flags(value_type.get_flags(), operand_type.get_flags()),
operand_type.get_metadata_size(), value_type.get_ndim()),
m_value_type(value_type), m_operand_type(operand_type),
m_kgen(kgen)
{
if (operand_type.get_type_id() != cstruct_type_id) {
stringstream ss;
ss << "expr_type can only be constructed with a cstruct as its operand, given ";
ss << operand_type;
throw runtime_error(ss.str());
}
const cstruct_type *fsd = static_cast<const cstruct_type *>(operand_type.extended());
size_t field_count = fsd->get_field_count();
if (field_count == 1) {
throw runtime_error("expr_type is for 2 or more operands, use unary_expr_type for 1 operand");
}
const ndt::type *field_types = fsd->get_field_types();
for (size_t i = 0; i != field_count; ++i) {
if (field_types[i].get_type_id() != pointer_type_id) {
stringstream ss;
ss << "each field of the expr_type's operand must be a pointer, field " << i;
ss << " is " << field_types[i];
throw runtime_error(ss.str());
}
}
}
~objectarray_memory_block() {
for (size_t i = 0, i_end = m_memory_handles.size(); i != i_end; ++i) {
memory_chunk &mc = m_memory_handles[i];
m_dt.extended()->data_destruct_strided(m_arrmeta + arrmeta_size, mc.memory, m_stride, mc.used_count);
free(mc.memory);
}
}
void get_dynamic_array_functions(
const std::pair<std::string, gfunc::callable> **out_functions,
size_t *out_count) const
{
if (!m_value_type.is_builtin()) {
m_value_type.extended()->get_dynamic_array_functions(out_functions, out_count);
}
}
bool dynd::busdate_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
if (dst_tp.extended() == this) {
if (src_tp.extended() == this) {
return true;
} else if (src_tp.get_type_id() == date_type_id) {
const busdate_type *src_fs = static_cast<const busdate_type*>(src_tp.extended());
// No need to compare the roll policy, just the weekmask and holidays determine this
return memcmp(m_workweek, src_fs->m_workweek, sizeof(m_workweek)) == 0 &&
m_holidays.equals_exact(src_fs->m_holidays);
} else {
return false;
}
} else {
return false;
}
}
void reset() {
if (m_memory_handles.size() > 1) {
// If there are more than one allocated memory chunks,
// throw them all away except the last
for (size_t i = 0, i_end = m_memory_handles.size() - 1; i != i_end; ++i) {
memory_chunk &mc = m_memory_handles[i];
m_dt.extended()->data_destruct_strided(m_arrmeta, mc.memory, m_stride, mc.used_count);
free(mc.memory);
}
m_memory_handles.front() = m_memory_handles.back();
m_memory_handles.resize(1);
// Reset to zero used elements in the chunk
memory_chunk &mc = m_memory_handles.front();
m_dt.extended()->data_destruct_strided(m_arrmeta, mc.memory, m_stride, mc.used_count);
mc.used_count = 0;
}
}
bool byteswap_type::is_lossless_assignment(const ndt::type& dst_tp, const ndt::type& src_tp) const
{
// Treat this type as the value type for whether assignment is always lossless
if (src_tp.extended() == this) {
return ::dynd::is_lossless_assignment(dst_tp, m_value_type);
} else {
return ::dynd::is_lossless_assignment(m_value_type, src_tp);
}
}
bool pointer_type::is_lossless_assignment(const ndt::type &dst_tp,
const ndt::type &src_tp) const
{
if (dst_tp.extended() == this) {
return ::is_lossless_assignment(m_target_tp, src_tp);
} else {
return ::is_lossless_assignment(dst_tp, m_target_tp);
}
}
static void parse_struct_json(const ndt::type& tp, const char *metadata, char *out_data,
const char *&begin, const char *end, const eval::eval_context *ectx)
{
const base_struct_type *fsd = static_cast<const base_struct_type *>(tp.extended());
size_t field_count = fsd->get_field_count();
const string *field_names = fsd->get_field_names();
const ndt::type *field_types = fsd->get_field_types();
const size_t *data_offsets = fsd->get_data_offsets(metadata);
const size_t *metadata_offsets = fsd->get_metadata_offsets();
// Keep track of which fields we've seen
shortvector<bool> populated_fields(field_count);
memset(populated_fields.get(), 0, sizeof(bool) * field_count);
const char *saved_begin = begin;
if (!parse_token(begin, end, "{")) {
throw json_parse_error(begin, "expected object dict starting with '{'", tp);
}
// If it's not an empty object, start the loop parsing the elements
if (!parse_token(begin, end, "}")) {
for (;;) {
string name;
if (!parse_json_string(begin, end, name)) {
throw json_parse_error(begin, "expected string for name in object dict", tp);
}
if (!parse_token(begin, end, ":")) {
throw json_parse_error(begin, "expected ':' separating name from value in object dict", tp);
}
intptr_t i = fsd->get_field_index(name);
if (i == -1) {
// TODO: Add an error policy to this parser of whether to throw an error
// or not. For now, just throw away fields not in the destination.
skip_json_value(begin, end);
} else {
parse_json(field_types[i], metadata + metadata_offsets[i],
out_data + data_offsets[i], begin, end, ectx);
populated_fields[i] = true;
}
if (!parse_token(begin, end, ",")) {
break;
}
}
if (!parse_token(begin, end, "}")) {
throw json_parse_error(begin, "expected object dict separator ',' or terminator '}'", tp);
}
}
for (size_t i = 0; i < field_count; ++i) {
if (!populated_fields[i]) {
stringstream ss;
ss << "object dict does not contain the field ";
print_escaped_utf8_string(ss, field_names[i]);
ss << " as required by the data type";
throw json_parse_error(skip_whitespace(saved_begin, end), ss.str(), tp);
}
}
}
size_t fixedstring_type::make_assignment_kernel(
void *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *dst_arrmeta, const ndt::type &src_tp, const char *src_arrmeta,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
switch (src_tp.get_type_id()) {
case fixedstring_type_id: {
const fixedstring_type *src_fs = src_tp.extended<fixedstring_type>();
return make_fixedstring_assignment_kernel(
ckb, ckb_offset, get_data_size(), m_encoding,
src_fs->get_data_size(), src_fs->m_encoding, kernreq, ectx);
}
case string_type_id: {
const base_string_type *src_fs = src_tp.extended<base_string_type>();
return make_blockref_string_to_fixedstring_assignment_kernel(
ckb, ckb_offset, get_data_size(), m_encoding,
src_fs->get_encoding(), kernreq, ectx);
}
default: {
if (!src_tp.is_builtin()) {
return src_tp.extended()->make_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_tp,
src_arrmeta, kernreq, ectx);
} else {
return make_builtin_to_string_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta,
src_tp.get_type_id(), kernreq, ectx);
}
}
}
} else {
if (dst_tp.is_builtin()) {
return make_string_to_builtin_assignment_kernel(
ckb, ckb_offset, dst_tp.get_type_id(), src_tp, src_arrmeta,
kernreq, ectx);
} else {
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw dynd::type_error(ss.str());
}
}
}
static void parse_jsonstring_json(const ndt::type& tp, const char *metadata, char *out_data,
const char *&begin, const char *end)
{
const char *saved_begin = skip_whitespace(begin, end);
skip_json_value(begin, end);
const base_string_type *bsd = static_cast<const base_string_type *>(tp.extended());
// The skipped JSON value gets copied verbatim into the json string
bsd->set_utf8_string(metadata, out_data, assign_error_none,
saved_begin, begin);
}
size_t time_type::make_assignment_kernel(
void *ckb, intptr_t ckb_offset, const ndt::type &dst_tp,
const char *dst_arrmeta, const ndt::type &src_tp, const char *src_arrmeta,
kernel_request_t kernreq, const eval::eval_context *ectx) const
{
if (this == dst_tp.extended()) {
if (src_tp.get_type_id() == time_type_id) {
return make_pod_typed_data_assignment_kernel(ckb, ckb_offset,
get_data_size(), get_data_alignment(), kernreq);
} else if (src_tp.get_kind() == string_kind) {
// Assignment from strings
return make_string_to_time_assignment_kernel(
ckb, ckb_offset, dst_tp, src_tp, src_arrmeta, kernreq, ectx);
} else if (src_tp.get_kind() == struct_kind) {
// Convert to struct using the "struct" property
return ::make_assignment_kernel(
ckb, ckb_offset, ndt::make_property(dst_tp, "struct"),
dst_arrmeta, src_tp, src_arrmeta, kernreq, ectx);
} else if (!src_tp.is_builtin()) {
return src_tp.extended()->make_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_tp, src_arrmeta,
kernreq, ectx);
}
} else {
if (dst_tp.get_kind() == string_kind) {
// Assignment to strings
return make_time_to_string_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta, src_tp, kernreq, ectx);
} else if (dst_tp.get_kind() == struct_kind) {
// Convert to struct using the "struct" property
return ::make_assignment_kernel(
ckb, ckb_offset, dst_tp, dst_arrmeta,
ndt::make_property(src_tp, "struct"), src_arrmeta, kernreq,
ectx);
}
// TODO
}
stringstream ss;
ss << "Cannot assign from " << src_tp << " to " << dst_tp;
throw dynd::type_error(ss.str());
}
ndt::type byteswap_type::with_replaced_storage_type(const ndt::type& replacement_type) const
{
if (m_operand_type.get_kind() != expr_kind) {
// If there's no expression in the operand, just try substituting (the constructor will error-check)
return ndt::type(new byteswap_type(m_value_type, replacement_type), false);
} else {
// With an expression operand, replace it farther down the chain
return ndt::type(new byteswap_type(m_value_type,
reinterpret_cast<const base_expr_type *>(replacement_type.extended())->with_replaced_storage_type(replacement_type)), false);
}
}
nd::array dynd::parse_json(const ndt::type &tp, const char *json_begin, const char *json_end,
const eval::eval_context *ectx)
{
nd::array result;
result = nd::empty(tp);
parse_json(result, json_begin, json_end, ectx);
if (!tp.is_builtin()) {
tp.extended()->arrmeta_finalize_buffers(result.get()->metadata());
}
return result;
}