# 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)