| # Copyright (c) 2012 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| from code import Code |
| from model import PropertyType |
| import any_helper |
| import cpp_util |
| import model |
| import schema_util |
| import sys |
| import util_cc_helper |
| |
| class CCGenerator(object): |
| """A .cc generator for a namespace. |
| """ |
| def __init__(self, namespace, cpp_type_generator): |
| self._cpp_type_generator = cpp_type_generator |
| self._namespace = namespace |
| self._target_namespace = ( |
| self._cpp_type_generator.GetCppNamespaceName(self._namespace)) |
| self._util_cc_helper = ( |
| util_cc_helper.UtilCCHelper(self._cpp_type_generator)) |
| self._any_helper = any_helper.AnyHelper() |
| |
| def Generate(self): |
| """Generates a Code object with the .cc for a single namespace. |
| """ |
| c = Code() |
| (c.Append(cpp_util.CHROMIUM_LICENSE) |
| .Append() |
| .Append(cpp_util.GENERATED_FILE_MESSAGE % self._namespace.source_file) |
| .Append() |
| .Append(self._util_cc_helper.GetIncludePath()) |
| .Append('#include "%s/%s.h"' % |
| (self._namespace.source_file_dir, self._namespace.unix_name)) |
| ) |
| includes = self._cpp_type_generator.GenerateIncludes() |
| if not includes.IsEmpty(): |
| (c.Concat(includes) |
| .Append() |
| ) |
| |
| (c.Append() |
| .Concat(self._cpp_type_generator.GetRootNamespaceStart()) |
| .Concat(self._cpp_type_generator.GetNamespaceStart()) |
| .Append() |
| ) |
| if self._namespace.properties: |
| (c.Append('//') |
| .Append('// Properties') |
| .Append('//') |
| .Append() |
| ) |
| for property in self._namespace.properties.values(): |
| property_code = self._cpp_type_generator.GeneratePropertyValues( |
| property, |
| 'const %(type)s %(name)s = %(value)s;', |
| nodoc=True) |
| if property_code: |
| c.Concat(property_code).Append() |
| if self._namespace.types: |
| (c.Append('//') |
| .Append('// Types') |
| .Append('//') |
| .Append() |
| ) |
| for type_ in self._namespace.types.values(): |
| (c.Concat(self._GenerateType( |
| schema_util.StripSchemaNamespace(type_.name), type_)).Append() |
| ) |
| if self._namespace.functions: |
| (c.Append('//') |
| .Append('// Functions') |
| .Append('//') |
| .Append() |
| ) |
| for function in self._namespace.functions.values(): |
| (c.Concat(self._GenerateFunction( |
| cpp_util.Classname(function.name), function)) |
| .Append() |
| ) |
| if self._namespace.events: |
| (c.Append('//') |
| .Append('// Events') |
| .Append('//') |
| .Append() |
| ) |
| for event in self._namespace.events.values(): |
| (c.Concat(self._GenerateCreateCallbackArguments( |
| cpp_util.Classname(event.name), event, generate_to_json=True)) |
| .Append() |
| ) |
| (c.Concat(self._cpp_type_generator.GetNamespaceEnd()) |
| .Concat(self._cpp_type_generator.GetRootNamespaceEnd()) |
| .Append() |
| ) |
| return c |
| |
| def _GenerateType(self, cpp_namespace, type_): |
| """Generates the function definitions for a type. |
| """ |
| classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name)) |
| c = Code() |
| |
| if type_.functions: |
| for function in type_.functions.values(): |
| (c.Concat( |
| self._GenerateFunction( |
| cpp_namespace + '::' + cpp_util.Classname(function.name), |
| function)) |
| .Append()) |
| elif type_.type_ == PropertyType.OBJECT: |
| (c.Concat(self._GeneratePropertyFunctions( |
| cpp_namespace, type_.properties.values())) |
| .Sblock('%(namespace)s::%(classname)s()') |
| .Concat(self._GenerateInitializersAndBody(type_)) |
| .Eblock('%(namespace)s::~%(classname)s() {}') |
| .Append()) |
| if type_.from_json: |
| (c.Concat(self._GenerateTypePopulate(cpp_namespace, type_)) |
| .Append()) |
| if type_.from_client: |
| (c.Concat(self._GenerateTypeToValue(cpp_namespace, type_)) |
| .Append()) |
| elif self._cpp_type_generator.IsEnumOrEnumRef(type_): |
| (c.Concat(self._GenerateCreateEnumTypeValue(cpp_namespace, type_)) |
| .Append() |
| .Concat(self._GenerateEnumFromString(cpp_namespace, type_)) |
| .Append() |
| .Concat(self._GenerateEnumToString(cpp_namespace, type_)) |
| .Append()) |
| c.Substitute({'classname': classname, 'namespace': cpp_namespace}) |
| |
| return c |
| |
| def _GenerateInitializersAndBody(self, type_): |
| items = [] |
| for prop in type_.properties.values(): |
| if prop.optional: |
| continue |
| |
| t = prop.type_ |
| if t == PropertyType.INTEGER: |
| items.append('%s(0)' % prop.unix_name) |
| elif t == PropertyType.DOUBLE: |
| items.append('%s(0.0)' % prop.unix_name) |
| elif t == PropertyType.BOOLEAN: |
| items.append('%s(false)' % prop.unix_name) |
| elif t == PropertyType.BINARY: |
| items.append('%s(NULL)' % prop.unix_name) |
| elif (t == PropertyType.ADDITIONAL_PROPERTIES or |
| t == PropertyType.ANY or |
| t == PropertyType.ARRAY or |
| t == PropertyType.CHOICES or |
| t == PropertyType.ENUM or |
| t == PropertyType.OBJECT or |
| t == PropertyType.FUNCTION or |
| t == PropertyType.REF or |
| t == PropertyType.STRING): |
| # TODO(miket): It would be nice to initialize CHOICES and ENUM, but we |
| # don't presently have the semantics to indicate which one of a set |
| # should be the default. |
| continue |
| else: |
| sys.exit("Unhandled PropertyType: %s" % t) |
| |
| if items: |
| s = ': %s' % (', '.join(items)) |
| else: |
| s = '' |
| s = s + ' {}' |
| return Code().Append(s) |
| |
| def _GenerateTypePopulate(self, cpp_namespace, type_): |
| """Generates the function for populating a type given a pointer to it. |
| |
| E.g for type "Foo", generates Foo::Populate() |
| """ |
| classname = cpp_util.Classname(schema_util.StripSchemaNamespace(type_.name)) |
| c = Code() |
| (c.Append('// static') |
| .Sblock('bool %(namespace)s::Populate' |
| '(const base::Value& value, %(name)s* out) {') |
| .Append('if (!value.IsType(base::Value::TYPE_DICTIONARY))') |
| .Append(' return false;') |
| ) |
| if type_.properties: |
| (c.Append('const base::DictionaryValue* dict = ' |
| 'static_cast<const base::DictionaryValue*>(&value);') |
| .Append() |
| ) |
| for prop in type_.properties.values(): |
| c.Concat(self._InitializePropertyToDefault(prop, 'out')) |
| for prop in type_.properties.values(): |
| if prop.type_ == PropertyType.ADDITIONAL_PROPERTIES: |
| c.Append('out->additional_properties.MergeDictionary(dict);') |
| # remove all keys that are actual properties |
| for cur_prop in type_.properties.values(): |
| if prop != cur_prop: |
| c.Append('out->additional_properties' |
| '.RemoveWithoutPathExpansion("%s", NULL);' % cur_prop.name) |
| c.Append() |
| else: |
| c.Concat(self._GenerateTypePopulateProperty(prop, 'dict', 'out')) |
| (c.Append('return true;') |
| .Eblock('}') |
| ) |
| c.Substitute({'namespace': cpp_namespace, 'name': classname}) |
| return c |
| |
| def _GenerateTypePopulateProperty(self, prop, src, dst): |
| """Generate the code to populate a single property in a type. |
| |
| src: base::DictionaryValue* |
| dst: Type* |
| """ |
| c = Code() |
| value_var = prop.unix_name + '_value' |
| c.Append('const base::Value* %(value_var)s = NULL;') |
| if prop.optional: |
| (c.Sblock( |
| 'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {') |
| .Concat(self._GeneratePopulatePropertyFromValue( |
| prop, value_var, dst, 'false'))) |
| if self._cpp_type_generator.IsEnumOrEnumRef(prop): |
| (c.Append('} else {') |
| .Append('%%(dst)s->%%(name)s = %s;' % |
| self._cpp_type_generator.GetEnumNoneValue(prop))) |
| c.Eblock('}') |
| else: |
| (c.Append( |
| 'if (!%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s))') |
| .Append(' return false;') |
| .Concat(self._GeneratePopulatePropertyFromValue( |
| prop, value_var, dst, 'false')) |
| ) |
| c.Append() |
| c.Substitute({ |
| 'value_var': value_var, |
| 'key': prop.name, |
| 'src': src, |
| 'dst': dst, |
| 'name': prop.unix_name |
| }) |
| return c |
| |
| def _GenerateTypeToValue(self, cpp_namespace, type_): |
| """Generates a function that serializes the type into a |
| |base::DictionaryValue|. |
| |
| E.g. for type "Foo" generates Foo::ToValue() |
| """ |
| c = Code() |
| (c.Sblock('scoped_ptr<base::DictionaryValue> %s::ToValue() const {' % |
| cpp_namespace) |
| .Append('scoped_ptr<base::DictionaryValue> value(' |
| 'new base::DictionaryValue());') |
| .Append() |
| ) |
| for prop in type_.properties.values(): |
| if prop.type_ == PropertyType.ADDITIONAL_PROPERTIES: |
| c.Append('value->MergeDictionary(&%s);' % prop.unix_name) |
| else: |
| if prop.optional: |
| if self._cpp_type_generator.IsEnumOrEnumRef(prop): |
| c.Sblock('if (%s != %s) {' % |
| (prop.unix_name, |
| self._cpp_type_generator.GetEnumNoneValue(prop))) |
| elif prop.type_ == PropertyType.CHOICES: |
| c.Sblock('if (%s_type != %s) {' % |
| (prop.unix_name, |
| self._cpp_type_generator.GetEnumNoneValue(prop))) |
| else: |
| c.Sblock('if (%s.get()) {' % prop.unix_name) |
| |
| if prop.type_ == prop.compiled_type: |
| c.Append('value->SetWithoutPathExpansion("%s", %s);' % ( |
| prop.name, |
| self._CreateValueFromProperty(prop, 'this->' + prop.unix_name))) |
| else: |
| conversion_src = 'this->' + prop.unix_name |
| if prop.optional: |
| conversion_src = '*' + conversion_src |
| (c.Append('%s %s;' % (self._cpp_type_generator.GetType(prop), |
| prop.unix_name)) |
| .Append(cpp_util.GenerateCompiledTypeToTypeConversion( |
| self._cpp_type_generator.GetReferencedProperty(prop), |
| conversion_src, |
| prop.unix_name) + ';') |
| .Append('value->SetWithoutPathExpansion("%s", %s);' % ( |
| prop.unix_name, |
| self._CreateValueFromProperty(prop, prop.unix_name))) |
| ) |
| if prop.optional: |
| c.Eblock('}'); |
| (c.Append() |
| .Append('return value.Pass();') |
| .Eblock('}') |
| ) |
| return c |
| |
| def _GenerateFunction(self, cpp_namespace, function): |
| """Generates the definitions for function structs. |
| """ |
| c = Code() |
| |
| # Params::Populate function |
| if function.params: |
| c.Concat(self._GeneratePropertyFunctions(cpp_namespace + '::Params', |
| function.params)) |
| (c.Append('%(cpp_namespace)s::Params::Params() {}') |
| .Append('%(cpp_namespace)s::Params::~Params() {}') |
| .Append() |
| .Concat(self._GenerateFunctionParamsCreate(cpp_namespace, function)) |
| .Append() |
| ) |
| |
| # Results::Create function |
| if function.callback: |
| c.Concat(self._GenerateCreateCallbackArguments( |
| "%s::Results" % cpp_namespace, function.callback)) |
| |
| c.Substitute({'cpp_namespace': cpp_namespace}) |
| |
| return c |
| |
| def _CreateValueFromProperty(self, prop, var): |
| """Creates a base::Value given a property. Generated code passes ownership |
| to caller. |
| |
| var: variable or variable* |
| |
| E.g for std::string, generate base::Value::CreateStringValue(var) |
| """ |
| if prop.type_ == PropertyType.CHOICES: |
| return 'Get%sChoiceValue().release()' % cpp_util.Classname(prop.name) |
| elif self._IsObjectOrObjectRef(prop): |
| if prop.optional: |
| return '%s->ToValue().release()' % var |
| else: |
| return '%s.ToValue().release()' % var |
| elif prop.type_ == PropertyType.ANY: |
| return '%s.DeepCopy()' % self._any_helper.GetValue(prop, var) |
| elif prop.type_ == PropertyType.ADDITIONAL_PROPERTIES: |
| return '%s.DeepCopy()' % var |
| elif prop.type_ == PropertyType.FUNCTION: |
| if prop.optional: |
| vardot = var + '->' |
| else: |
| vardot = var + '.' |
| return '%sDeepCopy()' % vardot |
| elif self._cpp_type_generator.IsEnumOrEnumRef(prop): |
| return 'base::Value::CreateStringValue(ToString(%s))' % var |
| elif prop.type_ == PropertyType.BINARY: |
| if prop.optional: |
| vardot = var + '->' |
| else: |
| vardot = var + '.' |
| return ('base::BinaryValue::CreateWithCopiedBuffer(%sdata(), %ssize())' % |
| (vardot, vardot)) |
| elif self._IsArrayOrArrayRef(prop): |
| return '%s.release()' % self._util_cc_helper.CreateValueFromArray( |
| self._cpp_type_generator.GetReferencedProperty(prop), var, |
| prop.optional) |
| elif self._IsFundamentalOrFundamentalRef(prop): |
| # If prop.type != prop.compiled_type, then no asterisk is necessary |
| # because the target is a local variable and not a dereferenced scoped |
| # pointer. The asterisk is instead prepended to conversion_src around line |
| # 273. |
| if prop.optional and prop.type_ == prop.compiled_type: |
| var = '*' + var |
| prop = self._cpp_type_generator.GetReferencedProperty(prop); |
| return { |
| PropertyType.STRING: 'base::Value::CreateStringValue(%s)', |
| PropertyType.BOOLEAN: 'base::Value::CreateBooleanValue(%s)', |
| PropertyType.INTEGER: 'base::Value::CreateIntegerValue(%s)', |
| PropertyType.DOUBLE: 'base::Value::CreateDoubleValue(%s)', |
| }[prop.type_] % var |
| else: |
| raise NotImplementedError('Conversion of %s to base::Value not ' |
| 'implemented' % repr(prop.type_)) |
| |
| def _GenerateParamsCheck(self, function, var): |
| """Generates a check for the correct number of arguments when creating |
| Params. |
| """ |
| c = Code() |
| num_required = 0 |
| for param in function.params: |
| if not param.optional: |
| num_required += 1 |
| if num_required == len(function.params): |
| c.Append('if (%(var)s.GetSize() != %(total)d)') |
| elif not num_required: |
| c.Append('if (%(var)s.GetSize() > %(total)d)') |
| else: |
| c.Append('if (%(var)s.GetSize() < %(required)d' |
| ' || %(var)s.GetSize() > %(total)d)') |
| c.Append(' return scoped_ptr<Params>();') |
| c.Substitute({ |
| 'var': var, |
| 'required': num_required, |
| 'total': len(function.params), |
| }) |
| return c |
| |
| def _GenerateFunctionParamsCreate(self, cpp_namespace, function): |
| """Generate function to create an instance of Params. The generated |
| function takes a base::ListValue of arguments. |
| |
| E.g for function "Bar", generate Bar::Params::Create() |
| """ |
| c = Code() |
| (c.Append('// static') |
| .Sblock('scoped_ptr<%(cpp_namespace)s::Params> ' |
| '%(cpp_namespace)s::Params::Create(const base::ListValue& args) {') |
| .Concat(self._GenerateParamsCheck(function, 'args')) |
| .Append('scoped_ptr<Params> params(new Params());') |
| ) |
| c.Substitute({'cpp_namespace': cpp_namespace}) |
| |
| for param in function.params: |
| c.Concat(self._InitializePropertyToDefault(param, 'params')) |
| |
| for i, param in enumerate(function.params): |
| # Any failure will cause this function to return. If any argument is |
| # incorrect or missing, those following it are not processed. Note that |
| # for optional arguments, we allow missing arguments and proceed because |
| # there may be other arguments following it. |
| failure_value = 'scoped_ptr<Params>()' |
| c.Append() |
| value_var = param.unix_name + '_value' |
| (c.Append('const base::Value* %(value_var)s = NULL;') |
| .Append('if (args.Get(%(i)s, &%(value_var)s) &&\n' |
| ' !%(value_var)s->IsType(base::Value::TYPE_NULL))') |
| .Sblock('{') |
| .Concat(self._GeneratePopulatePropertyFromValue( |
| param, value_var, 'params', failure_value)) |
| .Eblock('}') |
| ) |
| if not param.optional: |
| (c.Sblock('else {') |
| .Append('return %s;' % failure_value) |
| .Eblock('}') |
| ) |
| c.Substitute({'value_var': value_var, 'i': i}) |
| (c.Append() |
| .Append('return params.Pass();') |
| .Eblock('}') |
| .Append() |
| ) |
| |
| return c |
| |
| def _GeneratePopulatePropertyFromValue( |
| self, prop, value_var, dst, failure_value, check_type=True): |
| """Generates code to populate a model.Property given a base::Value*. The |
| existence of data inside the base::Value* is assumed so checks for existence |
| should be performed before the code this generates. |
| |
| prop: the property the code is populating. |
| value_var: a base::Value* that should represent |prop|. |
| dst: the object with |prop| as a member. |
| failure_value: the value to return if |prop| cannot be extracted from |
| |value_var| |
| check_type: if true, will check if |value_var| is the correct |
| base::Value::Type |
| """ |
| c = Code() |
| c.Sblock('{') |
| |
| if self._IsFundamentalOrFundamentalRef(prop): |
| self._GenerateFundamentalOrFundamentalRefPopulate(c, prop, value_var, dst) |
| elif self._IsObjectOrObjectRef(prop): |
| self._GenerateObjectOrObjectRefPopulate(c, prop) |
| elif prop.type_ == PropertyType.FUNCTION: |
| self._GenerateFunctionPopulate(c, prop) |
| elif prop.type_ == PropertyType.ANY: |
| self._GenerateAnyPopulate(c, prop, value_var, dst) |
| elif self._IsArrayOrArrayRef(prop): |
| self._GenerateArrayOrArrayRefPopulate(c, prop, dst) |
| elif prop.type_ == PropertyType.CHOICES: |
| self._GenerateChoicePopulate(c, prop, value_var, dst, failure_value) |
| elif self._cpp_type_generator.IsEnumOrEnumRef(prop): |
| self._GenerateEnumPopulate(c, prop, value_var) |
| elif prop.type_ == PropertyType.BINARY: |
| self._GenerateBinaryPopulate(c, prop) |
| else: |
| raise NotImplementedError(prop.type_) |
| c.Eblock('}') |
| sub = { |
| 'value_var': value_var, |
| 'name': prop.unix_name, |
| 'dst': dst, |
| 'failure_value': failure_value, |
| } |
| if prop.type_ not in (PropertyType.CHOICES, PropertyType.ANY): |
| sub['ctype'] = self._cpp_type_generator.GetType(prop) |
| sub['compiled_ctype'] = self._cpp_type_generator.GetCompiledType(prop) |
| sub['value_type'] = cpp_util.GetValueType(self._cpp_type_generator |
| .GetReferencedProperty(prop).type_) |
| c.Substitute(sub) |
| return c |
| |
| def _GenerateFundamentalOrFundamentalRefPopulate(self, |
| c, |
| prop, |
| value_var, |
| dst): |
| if prop.optional: |
| (c.Append('%(ctype)s temp;') |
| .Append('if (!%s)' % |
| cpp_util.GetAsFundamentalValue( |
| self._cpp_type_generator.GetReferencedProperty(prop), |
| value_var, |
| '&temp')) |
| .Append(' return %(failure_value)s;') |
| ) |
| if prop.type_ != prop.compiled_type: |
| (c.Append('%(compiled_ctype)s temp2;') |
| .Append('if (!%s)' % |
| cpp_util.GenerateTypeToCompiledTypeConversion( |
| self._cpp_type_generator.GetReferencedProperty(prop), |
| 'temp', |
| 'temp2')) |
| .Append(' return %(failure_value)s;') |
| .Append('%(dst)s->%(name)s.reset(new %(compiled_ctype)s(temp2));') |
| ) |
| else: |
| c.Append('%(dst)s->%(name)s.reset(new %(ctype)s(temp));') |
| |
| else: |
| if prop.type_ == prop.compiled_type: |
| assignment_target = '&%s->%s' % (dst, prop.unix_name) |
| else: |
| c.Append('%(ctype)s temp;') |
| assignment_target = '&temp' |
| (c.Append('if (!%s)' % |
| cpp_util.GetAsFundamentalValue( |
| self._cpp_type_generator.GetReferencedProperty(prop), |
| value_var, |
| assignment_target)) |
| .Append(' return %(failure_value)s;') |
| ) |
| if prop.type_ != prop.compiled_type: |
| (c.Append('if (!%s)' % |
| cpp_util.GenerateTypeToCompiledTypeConversion( |
| self._cpp_type_generator.GetReferencedProperty(prop), |
| 'temp', |
| '%s->%s' % (dst, prop.unix_name))) |
| .Append(' return %(failure_value)s;') |
| ) |
| |
| def _GenerateObjectOrObjectRefPopulate(self, c, prop): |
| if prop.optional: |
| (c.Append('const base::DictionaryValue* dictionary = NULL;') |
| .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))') |
| .Append(' return %(failure_value)s;') |
| .Append('scoped_ptr<%(ctype)s> temp(new %(ctype)s());') |
| .Append('if (!%(ctype)s::Populate(*dictionary, temp.get()))') |
| .Append(' return %(failure_value)s;') |
| .Append('%(dst)s->%(name)s = temp.Pass();') |
| ) |
| else: |
| (c.Append('const base::DictionaryValue* dictionary = NULL;') |
| .Append('if (!%(value_var)s->GetAsDictionary(&dictionary))') |
| .Append(' return %(failure_value)s;') |
| .Append( |
| 'if (!%(ctype)s::Populate(*dictionary, &%(dst)s->%(name)s))') |
| .Append(' return %(failure_value)s;') |
| ) |
| |
| def _GenerateFunctionPopulate(self, c, prop): |
| if prop.optional: |
| c.Append('%(dst)s->%(name)s.reset(new base::DictionaryValue());') |
| |
| def _GenerateAnyPopulate(self, c, prop, value_var, dst): |
| if prop.optional: |
| c.Append('%(dst)s->%(name)s.reset(new ' + any_helper.ANY_CLASS + '());') |
| c.Append(self._any_helper.Init(prop, value_var, dst) + ';') |
| |
| def _GenerateArrayOrArrayRefPopulate(self, c, prop, dst): |
| # util_cc_helper deals with optional and required arrays |
| (c.Append('const base::ListValue* list = NULL;') |
| .Append('if (!%(value_var)s->GetAsList(&list))') |
| .Append(' return %(failure_value)s;')) |
| if prop.item_type.type_ == PropertyType.ENUM: |
| self._GenerateListValueToEnumArrayConversion(c, prop) |
| else: |
| (c.Append('if (!%s)' % self._util_cc_helper.PopulateArrayFromList( |
| self._cpp_type_generator.GetReferencedProperty(prop), 'list', |
| dst + '->' + prop.unix_name, prop.optional)) |
| .Append(' return %(failure_value)s;') |
| ) |
| |
| def _GenerateChoicePopulate(self, c, prop, value_var, dst, failure_value): |
| type_var = '%(dst)s->%(name)s_type' |
| c.Sblock('switch (%(value_var)s->GetType()) {') |
| for choice in self._cpp_type_generator.ExpandParams([prop]): |
| (c.Sblock('case %s: {' % cpp_util.GetValueType( |
| self._cpp_type_generator.GetReferencedProperty(choice).type_)) |
| .Concat(self._GeneratePopulatePropertyFromValue( |
| choice, value_var, dst, failure_value, check_type=False)) |
| .Append('%s = %s;' % |
| (type_var, |
| self._cpp_type_generator.GetEnumValue( |
| prop, choice.type_.name))) |
| .Append('break;') |
| .Eblock('}') |
| ) |
| (c.Append('default:') |
| .Append(' return %(failure_value)s;') |
| ) |
| c.Eblock('}') |
| |
| def _GenerateEnumPopulate(self, c, prop, value_var): |
| c.Sblock('{') |
| self._GenerateStringToEnumConversion(c, prop, value_var, 'enum_temp') |
| c.Append('%(dst)s->%(name)s = enum_temp;') |
| c.Eblock('}') |
| |
| def _GenerateBinaryPopulate(self, c, prop): |
| (c.Append('if (!%(value_var)s->IsType(%(value_type)s))') |
| .Append(' return %(failure_value)s;') |
| .Append('const base::BinaryValue* binary_value =') |
| .Append(' static_cast<const base::BinaryValue*>(%(value_var)s);') |
| ) |
| if prop.optional: |
| (c.Append('%(dst)s->%(name)s.reset(') |
| .Append(' new std::string(binary_value->GetBuffer(),') |
| .Append(' binary_value->GetSize()));') |
| ) |
| else: |
| (c.Append('%(dst)s->%(name)s.assign(binary_value->GetBuffer(),') |
| .Append(' binary_value->GetSize());') |
| ) |
| |
| def _GenerateListValueToEnumArrayConversion(self, c, prop): |
| """Appends code that converts a ListValue of string contstants to |
| an array of enums in dst. |
| Leaves dst, name, and failure_value unsubstituted. |
| |
| c: the Code object that is being appended to. |
| prop: the property that the code is populating. |
| """ |
| accessor = '.' |
| if prop.optional: |
| c.Append('%(dst)s->%(name)s.reset(new std::vector<' + ( |
| self._cpp_type_generator.GetType(prop.item_type) + '>);')) |
| accessor = '->' |
| c.Sblock('for (ListValue::const_iterator it = list->begin(); ' |
| 'it != list->end(); ++it) {') |
| self._GenerateStringToEnumConversion( |
| c, prop.item_type, '(*it)', 'enum_temp') |
| c.Append('%(dst)s->%(name)s' + accessor + 'push_back(enum_temp);') |
| c.Eblock('}') |
| |
| def _GenerateStringToEnumConversion(self, c, prop, value_var, enum_temp): |
| """Appends code that converts a string to an enum. |
| Leaves failure_value unsubstituted. |
| |
| c: the code that is appended to. |
| prop: the property that the code is populating. |
| value_var: the string value that is being converted. |
| enum_temp: the name used to store the temporary enum value. |
| """ |
| (c.Append('std::string enum_as_string;') |
| .Append('if (!%s->GetAsString(&enum_as_string))' % value_var) |
| .Append(' return %(failure_value)s;') |
| .Append('%(type)s %(enum)s = From%(type)sString(enum_as_string);' % { |
| 'type': self._cpp_type_generator.GetCompiledType(prop), |
| 'enum': enum_temp |
| }) |
| .Append('if (%s == %s)' % |
| (enum_temp, self._cpp_type_generator.GetEnumNoneValue(prop))) |
| .Append(' return %(failure_value)s;')) |
| |
| def _GeneratePropertyFunctions(self, param_namespace, params): |
| """Generate the functions for structures generated by a property such as |
| CreateEnumValue for ENUMs and Populate/ToValue for Params/Results objects. |
| """ |
| c = Code() |
| for param in params: |
| if param.type_ == PropertyType.OBJECT: |
| c.Concat(self._GenerateType( |
| param_namespace + '::' + cpp_util.Classname(param.name), |
| param)) |
| c.Append() |
| elif param.type_ == PropertyType.ARRAY: |
| c.Concat(self._GeneratePropertyFunctions( |
| param_namespace, [param.item_type])) |
| elif param.type_ == PropertyType.CHOICES: |
| c.Concat(self._GeneratePropertyFunctions( |
| param_namespace, param.choices.values())) |
| if param.from_client: |
| c.Concat(self._GenerateGetChoiceValue(param_namespace, param)) |
| elif param.type_ == PropertyType.ENUM: |
| (c.Concat(self._GenerateCreateEnumValue(param_namespace, param)) |
| .Append() |
| .Concat(self._GenerateEnumFromString(param_namespace, |
| param, |
| use_namespace=True)) |
| .Append() |
| .Concat(self._GenerateEnumToString(param_namespace, |
| param, |
| use_namespace=True)) |
| .Append()) |
| return c |
| |
| def _GenerateGetChoiceValue(self, cpp_namespace, prop): |
| """Generates Get<Type>ChoiceValue() that returns a scoped_ptr<base::Value> |
| representing the choice value. |
| """ |
| c = Code() |
| (c.Sblock('scoped_ptr<base::Value> ' |
| '%(cpp_namespace)s::Get%(choice)sChoiceValue() const {') |
| .Sblock('switch (%s_type) {' % prop.unix_name) |
| .Concat(self._GenerateReturnCase( |
| self._cpp_type_generator.GetEnumNoneValue(prop), |
| 'scoped_ptr<base::Value>()'))) |
| for choice in self._cpp_type_generator.ExpandParams([prop]): |
| c.Concat(self._GenerateReturnCase( |
| self._cpp_type_generator.GetEnumValue(prop, choice.type_.name), |
| 'make_scoped_ptr<base::Value>(%s)' % |
| self._CreateValueFromProperty(choice, choice.unix_name))) |
| (c.Eblock('}') |
| .Append('return scoped_ptr<base::Value>();') |
| .Eblock('}') |
| .Append() |
| .Substitute({ |
| 'cpp_namespace': cpp_namespace, |
| 'choice': cpp_util.Classname(prop.name) |
| }) |
| ) |
| return c |
| |
| def _GenerateCreateEnumTypeValue(self, cpp_namespace, prop): |
| """Generates CreateEnumValue() that returns the base::StringValue |
| representation of an enum type. |
| """ |
| c = Code() |
| classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name)) |
| (c.Sblock('scoped_ptr<base::Value> CreateEnumValue(%s %s) {' % |
| (classname, classname.lower())) |
| .Append('std::string enum_temp = ToString(%s);' % classname.lower()) |
| .Append('if (enum_temp.empty())') |
| .Append(' return scoped_ptr<base::Value>();') |
| .Append('return scoped_ptr<base::Value>(' |
| 'base::Value::CreateStringValue(enum_temp));') |
| .Eblock('}')) |
| return c |
| |
| def _GenerateEnumToString(self, cpp_namespace, prop, use_namespace=False): |
| """Generates ToString() which gets the string representation of an enum. |
| """ |
| c = Code() |
| classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name)) |
| if use_namespace: |
| namespace = '%s::' % cpp_namespace |
| else: |
| namespace = '' |
| |
| (c.Append('// static') |
| .Sblock('std::string %(namespace)sToString(%(class)s enum_param) {')) |
| enum_prop = self._cpp_type_generator.GetReferencedProperty(prop) |
| c.Sblock('switch (enum_param) {') |
| for enum_value in enum_prop.enum_values: |
| c.Concat(self._GenerateReturnCase( |
| self._cpp_type_generator.GetEnumValue(prop, enum_value), |
| '"%s"' % enum_value)) |
| (c.Append('case %s:' % self._cpp_type_generator.GetEnumNoneValue(prop)) |
| .Append(' return "";') |
| .Eblock('}') |
| .Append('return "";') |
| .Eblock('}') |
| .Substitute({ |
| 'namespace': namespace, |
| 'class': classname |
| })) |
| return c |
| |
| def _GenerateEnumFromString(self, cpp_namespace, prop, use_namespace=False): |
| """Generates FromClassNameString() which gets an enum from its string |
| representation. |
| """ |
| c = Code() |
| classname = cpp_util.Classname(schema_util.StripSchemaNamespace(prop.name)) |
| if use_namespace: |
| namespace = '%s::' % cpp_namespace |
| else: |
| namespace = '' |
| |
| (c.Append('// static') |
| .Sblock('%(namespace)s%(class)s' |
| ' %(namespace)sFrom%(class)sString(' |
| 'const std::string& enum_string) {')) |
| enum_prop = self._cpp_type_generator.GetReferencedProperty(prop) |
| for i, enum_value in enumerate( |
| self._cpp_type_generator.GetReferencedProperty(prop).enum_values): |
| # This is broken up into all ifs with no else ifs because we get |
| # "fatal error C1061: compiler limit : blocks nested too deeply" |
| # on Windows. |
| (c.Append('if (enum_string == "%s")' % enum_value) |
| .Append(' return %s;' % |
| self._cpp_type_generator.GetEnumValue(prop, enum_value))) |
| (c.Append('return %s;' % |
| self._cpp_type_generator.GetEnumNoneValue(prop)) |
| .Eblock('}') |
| .Substitute({ |
| 'namespace': namespace, |
| 'class': classname |
| })) |
| return c |
| |
| # TODO(chebert): This is basically the same as GenerateCreateEnumTypeValue(). |
| # The plan is to phase out the old-style enums, and make all enums into REF |
| # types. |
| def _GenerateCreateEnumValue(self, cpp_namespace, prop): |
| """Generates CreateEnumValue() that returns the base::StringValue |
| representation of an enum. |
| """ |
| c = Code() |
| (c.Append('// static') |
| .Sblock('scoped_ptr<base::Value> %(cpp_namespace)s::CreateEnumValue(' |
| '%(arg)s) {') |
| .Append('std::string enum_temp = ToString(%s);' % prop.unix_name) |
| .Append('if (enum_temp.empty())') |
| .Append(' return scoped_ptr<base::Value>();') |
| .Append('return scoped_ptr<base::Value>(' |
| 'base::Value::CreateStringValue(enum_temp));') |
| .Eblock('}') |
| .Substitute({ |
| 'cpp_namespace': cpp_namespace, |
| 'arg': cpp_util.GetParameterDeclaration( |
| prop, self._cpp_type_generator.GetType(prop)) |
| })) |
| return c |
| |
| def _GenerateReturnCase(self, case_value, return_value): |
| """Generates a single return case for a switch block. |
| """ |
| c = Code() |
| (c.Append('case %s:' % case_value) |
| .Append(' return %s;' % return_value) |
| ) |
| return c |
| |
| def _GenerateCreateCallbackArguments(self, |
| function_scope, |
| callback, |
| generate_to_json=False): |
| """Generate all functions to create Value parameters for a callback. |
| |
| E.g for function "Bar", generate Bar::Results::Create |
| E.g for event "Baz", generate Baz::Create |
| |
| function_scope: the function scope path, e.g. Foo::Bar for the function |
| Foo::Bar::Baz(). |
| callback: the Function object we are creating callback arguments for. |
| generate_to_json: Generate a ToJson method. |
| """ |
| c = Code() |
| params = callback.params |
| expanded_params = self._cpp_type_generator.ExpandParams(params) |
| c.Concat(self._GeneratePropertyFunctions(function_scope, expanded_params)) |
| |
| param_lists = self._cpp_type_generator.GetAllPossibleParameterLists(params) |
| for param_list in param_lists: |
| (c.Sblock('scoped_ptr<base::ListValue> %(function_scope)s::' |
| 'Create(%(declaration_list)s) {') |
| .Append('scoped_ptr<base::ListValue> create_results(' |
| 'new base::ListValue());') |
| ) |
| declaration_list = [] |
| for param in param_list: |
| # We treat this argument as 'required' to avoid wrapping it in a |
| # scoped_ptr if it's optional. |
| param_copy = param.Copy() |
| param_copy.optional = False |
| declaration_list.append("const %s" % cpp_util.GetParameterDeclaration( |
| param_copy, self._cpp_type_generator.GetCompiledType(param_copy))) |
| param_name = param_copy.unix_name |
| if param_copy.type_ != param_copy.compiled_type: |
| param_name = 'temp_' + param_name |
| (c.Append('%s %s;' % (self._cpp_type_generator.GetType(param_copy), |
| param_name)) |
| .Append(cpp_util.GenerateCompiledTypeToTypeConversion( |
| param_copy, |
| param_copy.unix_name, |
| param_name) + ';') |
| ) |
| c.Append('create_results->Append(%s);' % |
| self._CreateValueFromProperty(param_copy, param_name)) |
| |
| c.Append('return create_results.Pass();') |
| c.Eblock('}') |
| if generate_to_json: |
| c.Append() |
| (c.Sblock('std::string %(function_scope)s::' |
| 'ToJson(%(declaration_list)s) {') |
| .Append('scoped_ptr<base::ListValue> create_results = ' |
| '%(function_scope)s::Create(%(param_list)s);') |
| .Append('std::string json;') |
| .Append('base::JSONWriter::Write(create_results.get(), &json);') |
| .Append('return json;') |
| ) |
| c.Eblock('}') |
| |
| c.Substitute({ |
| 'function_scope': function_scope, |
| 'declaration_list': ', '.join(declaration_list), |
| 'param_list': ', '.join(param.unix_name for param in param_list) |
| }) |
| |
| return c |
| |
| def _InitializePropertyToDefault(self, prop, dst): |
| """Initialize a model.Property to its default value inside an object. |
| |
| E.g for optional enum "state", generate dst->state = STATE_NONE; |
| |
| dst: Type* |
| """ |
| c = Code() |
| if (self._cpp_type_generator.IsEnumOrEnumRef(prop) or |
| prop.type_ == PropertyType.CHOICES): |
| if prop.optional: |
| prop_name = prop.unix_name |
| if prop.type_ == PropertyType.CHOICES: |
| prop_name = prop.unix_name + '_type' |
| c.Append('%s->%s = %s;' % ( |
| dst, |
| prop_name, |
| self._cpp_type_generator.GetEnumNoneValue(prop))) |
| return c |
| |
| def _IsObjectOrObjectRef(self, prop): |
| """Determines if this property is an Object or is a ref to an Object. |
| """ |
| return (self._cpp_type_generator.GetReferencedProperty(prop).type_ == |
| PropertyType.OBJECT) |
| |
| def _IsArrayOrArrayRef(self, prop): |
| """Determines if this property is an Array or is a ref to an Array. |
| """ |
| return (self._cpp_type_generator.GetReferencedProperty(prop).type_ == |
| PropertyType.ARRAY) |
| |
| def _IsFundamentalOrFundamentalRef(self, prop): |
| """Determines if this property is a Fundamental type or is a ref to a |
| Fundamental type. |
| """ |
| return (self._cpp_type_generator.GetReferencedProperty(prop).type_. |
| is_fundamental) |