Merge pull request #607 from izaid/kind2

Removed uses of get_kind()

Author: izaid

dynd/include/array_functions.hpp

@@ -53,7 +53,7 @@ inline dynd::nd::array make_strided_array(const dynd::ndt::type &dtp,
 
   dynd::intrusive_ptr<dynd::memory_block_data> result;
   char *data_ptr = NULL;
-  if (array_tp.get_kind() == dynd::memory_kind) {
+  if (array_tp.get_base_id() == dynd::memory_id) {
     result = dynd::make_array_memory_block(array_tp.get_arrmeta_size());
     array_tp.extended<dynd::ndt::base_memory_type>()->data_alloc(&data_ptr,
                                                                  data_size);
@@ -66,7 +66,7 @@ inline dynd::nd::array make_strided_array(const dynd::ndt::type &dtp,
   }
 
   if (array_tp.get_flags() & dynd::type_flag_zeroinit) {
-    if (array_tp.get_kind() == dynd::memory_kind) {
+    if (array_tp.get_base_id() == dynd::memory_id) {
       array_tp.extended<dynd::ndt::base_memory_type>()->data_zeroinit(
           data_ptr, data_size);
     }
@@ -163,12 +163,12 @@ inline std::string array_repr(const dynd::nd::array &n)
 inline PyObject *array_nonzero(const dynd::nd::array &n)
 {
   // Implements the nonzero/conversion to boolean slot
-  switch (n.get_type().value_type().get_kind()) {
-  case dynd::bool_kind:
-  case dynd::uint_kind:
-  case dynd::sint_kind:
-  case dynd::real_kind:
-  case dynd::complex_kind:
+  switch (n.get_type().value_type().get_base_id()) {
+  case dynd::bool_kind_id:
+  case dynd::uint_kind_id:
+  case dynd::int_kind_id:
+  case dynd::float_kind_id:
+  case dynd::complex_kind_id:
     // Follow Python in not raising errors here
     if (n.as<bool>(dynd::assign_error_nocheck)) {
       Py_INCREF(Py_True);
@@ -178,7 +178,7 @@ inline PyObject *array_nonzero(const dynd::nd::array &n)
       Py_INCREF(Py_False);
       return Py_False;
     }
-  case dynd::string_kind: {
+  case dynd::string_kind_id: {
     // Follow Python, return True if the string is nonempty, False otherwise
     dynd::nd::array n_eval = n.eval();
     const dynd::ndt::base_string_type *bsd =
@@ -195,7 +195,7 @@ inline PyObject *array_nonzero(const dynd::nd::array &n)
       return Py_False;
     }
   }
-  case dynd::bytes_kind: {
+  case dynd::bytes_kind_id: {
     // Return True if there is a non-zero byte, False otherwise
     dynd::nd::array n_eval = n.eval();
     const dynd::ndt::base_bytes_type *bbd =
@@ -215,12 +215,6 @@ inline PyObject *array_nonzero(const dynd::nd::array &n)
     Py_INCREF(Py_False);
     return Py_False;
   }
-  case dynd::datetime_kind: {
-    // Dates and datetimes are never zero
-    // TODO: What to do with NA value?
-    Py_INCREF(Py_True);
-    return Py_True;
-  }
   default:
     // TODO: Implement nd.any and nd.all, mention them
     //       here like NumPy does.
@@ -401,7 +395,7 @@ inline dynd::nd::array nd_fields(const dynd::nd::array &n, PyObject *field_list)
 
   // TODO: Move this implementation into dynd
   dynd::ndt::type fdt = n.get_dtype();
-  if (fdt.get_kind() != dynd::struct_kind) {
+  if (fdt.get_id() != dynd::struct_id) {
     std::stringstream ss;
     ss << "nd.fields must be given a dynd array of 'struct' kind, not ";
     ss << fdt;
@@ -457,7 +451,7 @@ inline dynd::nd::array nd_fields(const dynd::nd::array &n, PyObject *field_list)
   char *dst_arrmeta = result.get()->metadata();
   const char *src_arrmeta = n.get()->metadata();
   while (tmp_dt.get_ndim() > 0) {
-    if (tmp_dt.get_kind() != dynd::dim_kind) {
+    if (tmp_dt.get_base_id() != dynd::dim_kind_id) {
       throw std::runtime_error(
           "nd.fields doesn't support dimensions with pointers yet");
     }

dynd/include/kernels/assign_from_pyobject_kernel.hpp

@@ -531,7 +531,7 @@ struct assign_from_pyobject_kernel<option_id, any_kind_id>
       pydynd::nd::typed_data_assign(dst_tp, dst_arrmeta, dst,
                                     pydynd::array_to_cpp_ref(src_obj));
     }
-    else if (dst_tp.get_kind() != dynd::string_kind &&
+    else if (dst_tp.get_base_id() != dynd::string_kind_id &&
              PyUnicode_Check(src_obj)) {
       // Copy from the string
       pydynd::pyobject_ownref utf8(PyUnicode_AsUTF8String(src_obj));
@@ -549,7 +549,7 @@ struct assign_from_pyobject_kernel<option_id, any_kind_id>
                                     reinterpret_cast<const char *>(&str_d));
 #if PY_VERSION_HEX < 0x03000000
     }
-    else if (dst_tp.get_kind() != dynd::string_kind &&
+    else if (dst_tp.get_base_id() != dynd::string_kind_id &&
              PyString_Check(src_obj)) {
       // Copy from the string
       char *s = NULL;

dynd/include/kernels/assign_to_pyarrayobject_kernel.hpp

@@ -82,8 +82,8 @@ struct assign_to_pyarrayobject_kernel
     }
 
     if (PyDataType_HASFIELDS(dtype)) {
-      if (src_tp[0].get_kind() != dynd::struct_kind &&
-          src_tp[0].get_kind() != dynd::tuple_kind) {
+      if (src_tp[0].get_id() != dynd::struct_id &&
+          src_tp[0].get_id() != dynd::tuple_id) {
         std::stringstream ss;
         pydynd::pyobject_ownref dtype_str(PyObject_Str((PyObject *)dtype));
         ss << "Cannot assign from source dynd type " << src_tp[0]
@@ -110,7 +110,7 @@ struct assign_to_pyarrayobject_kernel
       // Permute the numpy fields to match with the dynd fields
       std::vector<PyArray_Descr *> field_dtypes;
       std::vector<size_t> field_offsets;
-      if (src_tp[0].get_kind() == dynd::struct_kind) {
+      if (src_tp[0].get_id() == dynd::struct_id) {
         field_dtypes.resize(field_count);
         field_offsets.resize(field_count);
         for (intptr_t i = 0; i < field_count; ++i) {

dynd/include/numpy_interop.hpp

@@ -456,18 +456,18 @@ dynd::ndt::type array_from_numpy_scalar2(PyObject *obj);
  */
 inline char numpy_kindchar_of(const dynd::ndt::type &d)
 {
-  switch (d.get_kind()) {
-  case dynd::bool_kind:
+  switch (d.get_base_id()) {
+  case dynd::bool_kind_id:
     return 'b';
-  case dynd::sint_kind:
+  case dynd::int_kind_id:
     return 'i';
   case dynd::uint_kind:
     return 'u';
-  case dynd::real_kind:
+  case dynd::float_kind_id:
     return 'f';
-  case dynd::complex_kind:
+  case dynd::complex_kind_id:
     return 'c';
-  case dynd::string_kind:
+  case dynd::string_kind_id:
     if (d.get_id() == dynd::fixed_string_id) {
       const dynd::ndt::base_string_type *esd =
           d.extended<dynd::ndt::base_string_type>();

dynd/src/array_as_numpy.cpp

@@ -226,7 +226,7 @@ static void make_numpy_dtype_for_copy(pyobject_ownref *out_numpy_dtype,
   }
   }
 
-  if (dt.get_kind() == expr_kind) {
+  if (dt.get_base_id() == expr_kind_id) {
     // Convert the value type for the copy
     make_numpy_dtype_for_copy(out_numpy_dtype, ndim, dt.value_type(), NULL);
     return;
@@ -433,7 +433,7 @@ static void as_numpy_analysis(pyobject_ownref *out_numpy_dtype,
   }
   }
 
-  if (dt.get_kind() == expr_kind) {
+  if (dt.get_base_id() == expr_kind_id) {
     // If none of the prior checks caught this expression,
     // a copy is required.
     out_numpy_dtype->clear();
@@ -545,12 +545,12 @@ PyObject *pydynd::array_as_numpy(PyObject *a_obj, bool allow_copy)
       // Because 'allow_copy' is true
       // we can evaluate any expressions and
       // make copies of strings
-      if (a.get_type().get_kind() == expr_kind) {
+      if (a.get_type().get_base_id() == expr_kind_id) {
         // If it's an expression kind
         pyobject_ownref n_tmp(pydynd::array_from_cpp(a.eval()));
         return array_as_numpy(n_tmp.get(), true);
       }
-      else if (a.get_type().get_kind() == string_kind) {
+      else if (a.get_type().get_base_id() == string_kind_id) {
         nd::array res = nd::empty(ndt::make_type<pyobject_type>());
         res.assign(a);
         PyObject *res_obj = *reinterpret_cast<PyObject **>(res.data());

dynd/src/array_from_py_typededuction.cpp

@@ -33,13 +33,13 @@ void pydynd::init_array_from_py_typededuction()
 
 size_t pydynd::get_nonragged_dim_count(const ndt::type &tp, size_t max_count)
 {
-  switch (tp.get_kind()) {
-  case kind_kind:
-  case pattern_kind:
+  if (tp.is_symbolic()) {
     if (tp.is_scalar()) {
       return 0;
     }
-  case dim_kind:
+  }
+
+  if (!tp.is_scalar()) {
     if (max_count <= 1) {
       return max_count;
     }
@@ -50,8 +50,11 @@ size_t pydynd::get_nonragged_dim_count(const ndt::type &tp, size_t max_count)
                              ->get_element_type(),
                          max_count - 1));
     }
-  case struct_kind:
-  case tuple_kind:
+  }
+
+  switch (tp.get_id()) {
+  case struct_id:
+  case tuple_id:
     if (max_count <= 1) {
       return max_count;
     }
@@ -150,7 +153,7 @@ void pydynd::deduce_pyseq_shape_using_dtype(PyObject *obj, const ndt::type &tp,
       if (initial_pass) {
         shape.push_back(size);
       }
-      else if (tp.get_kind() == struct_kind || tp.get_kind() == tuple_kind) {
+      else if (tp.get_id() == struct_id || tp.get_id() == tuple_id) {
         // Signal that this is a dimension which is sometimes scalar, to allow
         // for
         // raggedness in the struct type's fields
@@ -176,7 +179,7 @@ void pydynd::deduce_pyseq_shape_using_dtype(PyObject *obj, const ndt::type &tp,
     }
   }
   else {
-    if (PyDict_Check(obj) && tp.get_kind() == struct_kind) {
+    if (PyDict_Check(obj) && tp.get_id() == struct_id) {
       if (shape.size() == current_axis) {
         shape.push_back(pydynd_shape_deduction_dict);
       }
@@ -185,7 +188,7 @@ void pydynd::deduce_pyseq_shape_using_dtype(PyObject *obj, const ndt::type &tp,
       }
     }
     else if (shape.size() != current_axis) {
-      if (tp.get_kind() == struct_kind || tp.get_kind() == tuple_kind) {
+      if (tp.get_id() == struct_id || tp.get_id() == tuple_id) {
         shape[current_axis] = pydynd_shape_deduction_ragged;
       }
       else {
@@ -207,10 +210,10 @@ static intptr_t get_leading_dim_count(const dynd::ndt::type &tp)
   if (ndim) {
     return ndim + get_leading_dim_count(tp.get_dtype());
   }
-  else if (tp.get_kind() == expr_kind) {
+  else if (tp.get_base_id() == expr_kind_id) {
     return get_leading_dim_count(tp.value_type());
   }
-  else if (tp.get_kind() == tuple_kind || tp.get_kind() == struct_kind) {
+  else if (tp.get_id() == tuple_id || tp.get_id() == struct_id) {
     if (tp.extended<ndt::tuple_type>()->get_field_count() == 0) {
       return 1;
     }
@@ -234,7 +237,7 @@ bool pydynd::broadcast_as_scalar(const dynd::ndt::type &tp, PyObject *obj)
   for (;;) {
     // Don't treat these types as sequences
     if (PyDict_Check(v)) {
-      if (tp.get_dtype().get_kind() == struct_kind) {
+      if (tp.get_dtype().get_id() == struct_id) {
         // If the object to assign to a dynd struct ends in a dict, apply
         // the dict as the struct's value
         return (tp.get_ndim() > obj_ndim);

dynd/src/copy_from_numpy_arrfunc.cpp

@@ -71,8 +71,8 @@ void pydynd::nd::copy_from_numpy_kernel::instantiate(
     return;
   }
   else if (PyDataType_HASFIELDS(dtype)) {
-    if (dst_tp.get_kind() != dynd::struct_kind &&
-        dst_tp.get_kind() != dynd::tuple_kind) {
+    if (dst_tp.get_id() != dynd::struct_id &&
+        dst_tp.get_id() != dynd::tuple_id) {
       stringstream ss;
       ss << "Cannot assign from numpy type " << pyobject_repr((PyObject *)dtype)
          << " to dynd type " << dst_tp;
@@ -97,7 +97,7 @@ void pydynd::nd::copy_from_numpy_kernel::instantiate(
     // Permute the numpy fields to match with the dynd fields
     vector<PyArray_Descr *> field_dtypes;
     vector<size_t> field_offsets;
-    if (dst_tp.get_kind() == dynd::struct_kind) {
+    if (dst_tp.get_id() == dynd::struct_id) {
       field_dtypes.resize(field_count);
       field_offsets.resize(field_count);
       for (intptr_t i = 0; i < field_count; ++i) {