def _cmp_values(base_op, first, second):
if is_boolean(first) or is_boolean(second):
return base_op(1 if boolean(first) else 0, 1 if boolean(second) else 0)
elif is_number(first) or is_number(second):
return base_op(number(first), number(second))
else:
return base_op(string(first), string(second))
def evaluate(hash):
for key, value in hash.items():
if key in tag_names:
verbose_print(
'JSON hash constructor number filter converting attribute "{0}" value(s) to numbers'
.format(key))
if isinstance(value, list):
hash[key] = [number(v).value for v in value]
else:
hash[key] = number(value).value
def evaluate(hash):
for key, value in hash.items():
if key in tag_names:
verbose_print(
'JSON hash constructor number filter converting attribute "{0}" value(s) to numbers'.format(key)
)
if isinstance(value, list):
hash[key] = [number(v).value for v in value]
else:
hash[key] = number(value).value
def _cmp_value_to_nodes(base_op, first, second):
node_values = set([number(node) for node in second])
first = number(first)
verbose_print('Comparing {0} nodes in node set to value "{1}"'.format(len(node_values), first))
for node_value in node_values:
if base_op(first, node_value):
verbose_print('Comparison succeeded for value "{0}" and node value "{1}'.format(first, node_value))
return True
verbose_print('Comparison failed for all nodes in the node set.')
return False
def _cmp_nodes_to_value(base_op, first, second):
node_values = set([number(node) for node in first])
second = number(second)
verbose_print('Comparing {0} nodes in node set to value {1}'.format(len(node_values), second))
for node_value in node_values:
if base_op(node_value, second):
verbose_print('Comparison succeeded for node value "{0}" and value "{1}"'.format(node_value, second))
return True
verbose_print('Comparison failed for all nodes in the node set.')
return False
def _cmp_node_sets(base_op, first, second):
first_values = set([number(node) for node in first])
second_values = set([number(node) for node in second])
verbose_print('Comparing two nodes sets (size {0} and {1}).'.format(len(first_values), len(second_values)))
for first_value in first_values:
for second_value in second_values:
if base_op(first_value, second_value):
msg = 'Comparison succeeded for "{0}" from first node set and "{1}" in second node set'
verbose_print(msg.format(first_value, second_value))
return True
verbose_print('Comparison failed for all nodes in both node sets.')
return False
def accept_context_node():
context = peek_context()
format_str = u'Evaluating predicate expression for context node at position {0} of {1}: {2}.'
verbose_print(lambda: format_str.format(context.position, context.size, debug_dump_node(context.node)))
value = expression_fn()
if is_number(value):
accept = number(context.position) == value
else:
accept = bool(value)
verbose_print(lambda: u'{0} node {1}'.format('Accepted' if accept else 'Rejected',
debug_dump_node(context.node)))
return [context.node] if accept else []
def _eq_node_set_vs_number(nodes_val, num_val):
verbose_print('(=) comparing number {0} to {1} nodes'.format(num_val, len(nodes_val)))
for node in nodes_val:
node_str_val = string_value(node)
node_num_val = number(node_str_val)
verbose_print('(=) node string value "{0}" is{1} equal to "{2}"'.format(
node_num_val,
(' not' if node_num_val == num_val else ''),
num_val))
if node_num_val == num_val:
return True
return False
def string_length(*args):
value = args[0] if len(args) == 1 else string_value(get_context_node())
if not is_string(value):
raise HqueryEvaluationError('string_length() expecting a string, got a {0}'.format(value.__class__.__name__))
return number(len(value))
def evaluate():
left_value, right_value = self._evaluate_binary_operands(left,
right,
constructor=number,
type_name='number')
return list(number(x) for x in range(int(left_value), int(right_value + 1)))
def nud(self):
return lambda: number(self.value)
def position():
return number(peek_context().position)
def last():
return number(peek_context().size)
def count(sequence):
HqueryEvaluationError.must_be_node_set_or_sequence(sequence)
return number(len(sequence))
def _eq_num_vs_string(num_val, string_val):
return num_val == number(string_val)
