def typed_update(self, parsed_value):
int_value = parsed_value.value
to_add = parsed_value.to_add
updated_counts = []
if (int_value == None):
parsed_range_value = parsed_value.range_value
if (parsed_range_value is None):
self.range_list.increment(to_add)
else:
self.add_range_list(parsed_range_value)
elif (int_value.__class__ == LiteralIntValue):
value = int_value.value
self.add_range_list(RangeList([RangeNode(value, value, \
to_add)], \
self.as_list))
elif (int_value.__class__ == AssignmentsIntValue):
right = int_value.main_value.right
if (right == None):
self.range_list.increment(to_add)
else:
right_ranges = right.ranges
new_ranges = []
for rr in right_ranges:
new_ranges.append(RangeNode(rr[0], \
rr[1], \
to_add))
range_list = RangeList(new_ranges, \
self.as_list)
if (len(new_ranges) == 0):
range_list.increment(to_add)
self.add_range_list(range_list)
else:
throw_error(str(int_value) + \
" is of unknown integer type, " + \
str(int_value.__class__))
if (len(self.range_list.ranges) == 0):
rest_count = None
if (self.range_list.as_list):
rest_count = len(self.range_list.rest)
else:
rest_count = self.range_list.rest
if (rest_count == 0):
throw_error("No ranges added")
return updated_counts
class IntegerStat(ValueStat):
def __init__(self, as_list=False):
ValueStat.__init__(self, INT_TYPE_START, as_list)
self.range_list = RangeList([], as_list)
self.bound_ranges = RangeList([], False, rest=RangeBinder())
def add_range_list(self, new_range_list):
self.bound_ranges.add(new_range_list.clone_binder())
self.range_list.add(new_range_list)
def typed_update(self, parsed_value):
int_value = parsed_value.value
to_add = parsed_value.to_add
updated_counts = []
if (int_value == None):
parsed_range_value = parsed_value.range_value
if (parsed_range_value is None):
self.range_list.increment(to_add)
else:
self.add_range_list(parsed_range_value)
elif (int_value.__class__ == LiteralIntValue):
value = int_value.value
self.add_range_list(RangeList([RangeNode(value, value, \
to_add)], \
self.as_list))
elif (int_value.__class__ == AssignmentsIntValue):
right = int_value.main_value.right
if (right == None):
self.range_list.increment(to_add)
else:
right_ranges = right.ranges
new_ranges = []
for rr in right_ranges:
new_ranges.append(RangeNode(rr[0], \
rr[1], \
to_add))
range_list = RangeList(new_ranges, \
self.as_list)
if (len(new_ranges) == 0):
range_list.increment(to_add)
self.add_range_list(range_list)
else:
throw_error(str(int_value) + \
" is of unknown integer type, " + \
str(int_value.__class__))
if (len(self.range_list.ranges) == 0):
rest_count = None
if (self.range_list.as_list):
rest_count = len(self.range_list.rest)
else:
rest_count = self.range_list.rest
if (rest_count == 0):
throw_error("No ranges added")
return updated_counts
def show_data(self):
return "%s; %s"%(str(self.total_count), \
str(self.range_list))
def _gen_unnormalized(self):
unnormalized = IntegerStat()
base = None
if (self.as_list):
base = [1]
else:
base = 1
unnormalized.range_list = \
self.range_list.gen_normalized(base)
return unnormalized
def _gen_normalized(self):
normalized = IntegerStat()
normalized.range_list = \
self.range_list.gen_normalized(self.total_count)
return normalized
def _add(self, other):
total = IntegerStat(self.as_list)
total.range_list = self.range_list.clone_flat()
total.range_list.add(other.range_list)
return total
def __iter__(self):
return IntegerIter(self)
def short_str(self):
return range_list.short_str()
def is_wanted_key(self, target_key, candidate_key):
if (target_key is None):
return candidate_key is None
elif (candidate_key is None):
return False
return target_key.contains(candidate_key)
def key_is_unknown(self, key):
return key == None
def has_unknown(self):
return self.range_list.has_rest()
def covers(self, key):
if (self.range_list.has_rest()):
if (key is None):
return (COVER_EXACT, None)
else:
return (COVER_OVER, UNKNOWN_STR)
elif (key is None):
return (COVER_UNDER, UNKNOWN_STR)
coverers = self.bound_ranges.get_coverers(key)
if (len(coverers) == 0):
return (COVER_UNDER, key.short_str())
least = key.least
most = key.most
beginning = coverers[0].least
if (beginning < least):
return (COVER_OVER, coverers[0].short_str())
if (beginning > least):
missing = RangeNode(least, beginning - 1)
return (COVER_UNDER, missing.short_str())
end = coverers[-1].most
if (end > most):
return (COVER_OVER, coverers[-1].short_str())
if (end < most):
missing = RangeNode(end + 1, most)
return (COVER_UNDER, missing.short_str())
last_end = least
found_over = False
over = None
for coverer in coverers:
binder = coverer.count
for bound in binder:
if (bound.least < least or most < bound.most):
over = bound
found_over = True
pre_gap = coverer.least - 1
if (last_end < pre_gap):
missing = RangeNode(last_end, pre_gap)
return (COVER_UNDER, missing.short_str())
last_end = coverer.most + 1
if (found_over):
return (COVER_OVER, over.short_str())
return (COVER_EXACT, None)
def contains_parsed(self, parsed_value):
if (self.range_list.has_rest):
return True
else:
smooth = smoothen(self.range_list)
return smooth.contains_list(parsed_value.range_value)
def get_overlaps(self, other):
return self.range_list.find_overlaps(other.range_list)
def get_parsed_overlaps(self, other):
return self.range_list.find_overlaps(other.range_value)