bool ndt::categorical_kind_type::operator==(const base_type &rhs) const {
if (this == &rhs) {
return true;
} else {
return rhs.is_symbolic() && rhs.get_id() == categorical_id;
}
}
bool ndt::int_kind_sym_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
else {
return rhs.get_id() == int_sym_id;
}
}
bool ndt::cuda_device_type::operator==(const base_type &rhs) const {
if (this == &rhs) {
return true;
} else if (rhs.get_id() != cuda_device_id) {
return false;
} else {
const cuda_device_type *tp = static_cast<const cuda_device_type *>(&rhs);
return m_element_tp == tp->m_element_tp;
}
}
bool ndt::option_type::operator==(const base_type &rhs) const {
if (this == &rhs) {
return true;
} else if (rhs.get_id() != option_id) {
return false;
} else {
const option_type *ot = static_cast<const option_type *>(&rhs);
return m_value_tp == ot->m_value_tp;
}
}
bool ndt::callable_type::operator==(const base_type &rhs) const {
if (this == &rhs) {
return true;
} else if (rhs.get_id() != callable_id) {
return false;
} else {
const callable_type *fpt = static_cast<const callable_type *>(&rhs);
return m_return_type == fpt->m_return_type && m_pos_tuple == fpt->m_pos_tuple && m_kwd_struct == fpt->m_kwd_struct;
}
}
bool ndt::dim_fragment_type::operator==(const base_type &rhs) const {
if (this == &rhs) {
return true;
} else if (rhs.get_id() != dim_fragment_id) {
return false;
} else {
const dim_fragment_type *dft = static_cast<const dim_fragment_type *>(&rhs);
return get_ndim() == rhs.get_ndim() &&
memcmp(m_tagged_dims.get(), dft->m_tagged_dims.get(), get_ndim() * sizeof(intptr_t)) == 0;
}
}
bool ndt::adapt_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
if (rhs.get_id() != adapt_id) {
return false;
}
return false;
}
bool ndt::type_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
else if (rhs.get_id() != type_id) {
return false;
}
else {
return m_pattern_tp == static_cast<const type_type *>(&rhs)->m_pattern_tp;
}
}
bool ndt::string_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
else if (rhs.get_id() != string_id) {
return false;
}
else {
return true;
}
}
bool ndt::typevar_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
else if (rhs.get_id() != typevar_id) {
return false;
}
else {
const typevar_type *tvt = static_cast<const typevar_type *>(&rhs);
return m_name == tvt->m_name;
}
}
bool ndt::pointer_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
else if (rhs.get_id() != pointer_id) {
return false;
}
else {
const pointer_type *dt = static_cast<const pointer_type *>(&rhs);
return m_target_tp == dt->m_target_tp;
}
}
bool ndt::pow_dimsym_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
else if (rhs.get_id() != pow_dimsym_id) {
return false;
}
else {
const pow_dimsym_type *tvt = static_cast<const pow_dimsym_type *>(&rhs);
return m_exponent == tvt->m_exponent && m_base_tp == tvt->m_base_tp && m_element_tp == tvt->m_element_tp;
}
}
bool ndt::tuple_type::operator==(const base_type &rhs) const
{
if (this == &rhs) {
return true;
}
else if (rhs.get_id() != tuple_id) {
return false;
}
else {
const tuple_type *dt = static_cast<const tuple_type *>(&rhs);
return get_data_alignment() == dt->get_data_alignment() && m_field_types == dt->m_field_types &&
m_variadic == dt->m_variadic;
}
}
bool ndt::categorical_type::operator==(const base_type &rhs) const
{
if (this == &rhs)
return true;
if (rhs.get_id() != categorical_id)
return false;
if (!m_categories.equals_exact(static_cast<const categorical_type &>(rhs).m_categories))
return false;
if (!m_category_index_to_value.equals_exact(static_cast<const categorical_type &>(rhs).m_category_index_to_value))
return false;
if (!m_value_to_category_index.equals_exact(static_cast<const categorical_type &>(rhs).m_value_to_category_index))
return false;
return true;
}
bool operator==(const base_type &rhs) const { return this == &rhs || rhs.get_id() == bytes_kind_id; }
bool ndt::type_type::operator==(const base_type &rhs) const { return this == &rhs || rhs.get_id() == type_id; }
bool ndt::fixed_dim_type::operator==(const base_type &rhs) const
{
return this == &rhs || (rhs.get_id() == fixed_dim_id && static_cast<const base_fixed_dim_type *>(&rhs)->is_sized() &&
m_element_tp == static_cast<const fixed_dim_type *>(&rhs)->m_element_tp &&
m_dim_size == static_cast<const fixed_dim_type *>(&rhs)->m_dim_size);
}
bool ndt::fixed_dim_kind_type::operator==(const base_type &rhs) const {
return this == &rhs || (rhs.get_id() == fixed_dim_kind_id &&
m_element_tp == reinterpret_cast<const fixed_dim_kind_type *>(&rhs)->m_element_tp);
}
