bool BasicComparison::compareTypeInstancesCheckedHelper(const TypeInstance &left, const TypeInstance &right) const { if (!canCompareTypes(left.getType(), right.getType())) { throw OperationInapplicableToType(*this, 2, &left.getType(), &right.getType()); } if (left.isNull() || right.isNull()) { return false; } if (left.getType().getSuperTypeID() == Type::kAsciiString) { ComparisonFunctor<int> comparison_functor; return comparison_functor(strcmpHelper(left, right), 0); } else { const Type *unifier = Type::GetUnifyingType(left.getType(), right.getType()); DEBUG_ASSERT(unifier != NULL); switch (unifier->getTypeID()) { case Type::kInt: { DEBUG_ASSERT(left.supportsNumericInterface()); DEBUG_ASSERT(right.supportsNumericInterface()); ComparisonFunctor<int> comparison_functor; return comparison_functor(left.numericGetIntValue(), right.numericGetIntValue()); } case Type::kLong: { DEBUG_ASSERT(left.supportsNumericInterface()); DEBUG_ASSERT(right.supportsNumericInterface()); ComparisonFunctor<int64_t> comparison_functor; return comparison_functor(left.numericGetLongValue(), right.numericGetLongValue()); } case Type::kFloat: { DEBUG_ASSERT(left.supportsNumericInterface()); DEBUG_ASSERT(right.supportsNumericInterface()); ComparisonFunctor<float> comparison_functor; return comparison_functor(left.numericGetFloatValue(), right.numericGetFloatValue()); } case Type::kDouble: { DEBUG_ASSERT(left.supportsNumericInterface()); DEBUG_ASSERT(right.supportsNumericInterface()); ComparisonFunctor<double> comparison_functor; return comparison_functor(left.numericGetDoubleValue(), right.numericGetDoubleValue()); } default: throw OperationInapplicableToType(*this, 2, &left.getType(), &right.getType()); } } }
UncheckedComparator* BasicComparison::makeUncheckedComparatorForTypesHelper(const Type &left, const Type &right) const { if (!canCompareTypes(left, right)) { throw OperationInapplicableToType(*this, 2, &left, &right); } if (left.getSuperTypeID() == Type::kAsciiString) { return makeStringComparatorOuterHelper<StringComparator>(*this, left, right); } else { return makeComparatorOuterHelper<NumericComparator>(*this, left, right); } }
void ScalarUnaryExpression::initHelper(bool own_children) { if (operation_.canApplyToType(operand_->getType())) { if (operand_->hasStaticValue()) { static_value_ = operation_.applyToChecked(operand_->getStaticValue(), operand_->getType()); } else { fast_operator_.reset(operation_.makeUncheckedUnaryOperatorForType(operand_->getType())); } } else { const Type &operand_type = operand_->getType(); if (!own_children) { operand_.release(); } throw OperationInapplicableToType(operation_.getName(), 1, operand_type.getName().c_str()); } }
void ComparisonPredicate::initHelper(bool own_children) { if (comparison_.canCompareTypes(left_operand_->getType(), right_operand_->getType())) { if (left_operand_->hasStaticValue() && right_operand_->hasStaticValue()) { static_result_ = comparison_.compareTypedValuesChecked(left_operand_->getStaticValue(), left_operand_->getType(), right_operand_->getStaticValue(), right_operand_->getType()); } else { fast_comparator_.reset(comparison_.makeUncheckedComparatorForTypes(left_operand_->getType(), right_operand_->getType())); } } else { const Type &left_operand_type = left_operand_->getType(); const Type &right_operand_type = right_operand_->getType(); if (!own_children) { left_operand_.release(); right_operand_.release(); } throw OperationInapplicableToType(comparison_.getName(), 2, left_operand_type.getName().c_str(), right_operand_type.getName().c_str()); } }