'''Class used to represent the encoded size of a field or a message.
Consists of a combination of symbolic sizes and integer sizes.'''
def __init__(self, value = 0, symbols = []):
- if isinstance(value, strtypes + (Names,)):
- symbols = [str(value)]
- value = 0
- self.value = value
- self.symbols = symbols
+ if isinstance(value, EncodedSize):
+ self.value = value.value
+ self.symbols = value.symbols
+ elif isinstance(value, strtypes + (Names,)):
+ self.symbols = [str(value)]
+ self.value = 0
+ else:
+ self.value = value
+ self.symbols = symbols
def __add__(self, other):
if isinstance(other, int):
'''
if self.rules == 'ONEOF':
- result = ' PB_ONEOF_FIELD(%s, ' % self.union_name
+ if self.anonymous:
+ result = ' PB_ANONYMOUS_ONEOF_FIELD(%s, ' % self.union_name
+ else:
+ result = ' PB_ONEOF_FIELD(%s, ' % self.union_name
else:
result = ' PB_FIELD('
return result
+ def get_last_field_name(self):
+ return self.name
+
def largest_field_value(self):
'''Determine if this field needs 16bit or 32bit pb_field_t structure to compile properly.
Returns numeric value or a C-expression for assert.'''
if self.rules == 'REPEATED' and self.allocation == 'STATIC':
check.append('pb_membersize(%s, %s[0])' % (self.struct_name, self.name))
elif self.rules == 'ONEOF':
- check.append('pb_membersize(%s, %s.%s)' % (self.struct_name, self.union_name, self.name))
+ if self.anonymous:
+ check.append('pb_membersize(%s, %s)' % (self.struct_name, self.name))
+ else:
+ check.append('pb_membersize(%s, %s.%s)' % (self.struct_name, self.union_name, self.name))
else:
check.append('pb_membersize(%s, %s)' % (self.struct_name, self.name))
self.allocation = 'ONEOF'
self.default = None
self.rules = 'ONEOF'
+ self.anonymous = False
def add_field(self, field):
if field.allocation == 'CALLBACK':
field.union_name = self.name
field.rules = 'ONEOF'
+ field.anonymous = self.anonymous
self.fields.append(field)
self.fields.sort(key = lambda f: f.tag)
result += ' union {\n'
for f in self.fields:
result += ' ' + str(f).replace('\n', '\n ') + '\n'
- result += ' } ' + self.name + ';'
+ if self.anonymous:
+ result += ' };'
+ else:
+ result += ' } ' + self.name + ';'
return result
def types(self):
return None
def tags(self):
- return '\n'.join([f.tags() for f in self.fields])
+ return ''.join([f.tags() for f in self.fields])
def pb_field_t(self, prev_field_name):
result = ',\n'.join([f.pb_field_t(prev_field_name) for f in self.fields])
return result
+ def get_last_field_name(self):
+ if self.anonymous:
+ return self.fields[-1].name
+ else:
+ return self.name + '.' + self.fields[-1].name
+
def largest_field_value(self):
largest = FieldMaxSize()
for f in self.fields:
return largest
def encoded_size(self, dependencies):
+ '''Returns the size of the largest oneof field.'''
largest = EncodedSize(0)
for f in self.fields:
- size = f.encoded_size(dependencies)
- if size is None:
+ size = EncodedSize(f.encoded_size(dependencies))
+ if size.value is None:
return None
elif size.symbols:
return None # Cannot resolve maximum of symbols
pass # No union and skip fields also
else:
oneof = OneOf(self.name, f)
+ if oneof_options.anonymous_oneof:
+ oneof.anonymous = True
self.oneofs[i] = oneof
self.fields.append(oneof)
for field in self.ordered_fields:
result += field.pb_field_t(prev)
result += ',\n'
- if isinstance(field, OneOf):
- prev = field.name + '.' + field.fields[-1].name
- else:
- prev = field.name
+ prev = field.get_last_field_name()
result += ' PB_LAST_FIELD\n};'
return result