JSON Schema Compiler supports functions as PropertyTypes.

tools/json_schema_compiler/cc_generator.py

 # 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
@@ skipping 134 matching lines @@
       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:
@@ skipping 43 matching lines @@
   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('base::Value* %(value_var)s = NULL;')
     if prop.optional:
-      (c.Sblock(
-          'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {'
+      if prop.type_ == PropertyType.FUNCTION:

[not at google - send to devlin, 2012/07/25 01:32:33]

Comment why you're only generating for optional.

[chebert, 2012/07/25 18:38:30]

the empty dict solved a lot of problems, so a lot of these comments will no
longer be relevant. 

On 2012/07/25 01:32:33, kalman wrote:

+        # For functions, we only want to check the presence, we are not actually
+        # getting a value

[not at google - send to devlin, 2012/07/25 01:32:33]

nit: fullstop

[chebert, 2012/07/25 18:38:30]

Done.

+        (c.Sblock('%s->has_%s = '
+              '%s->GetWithoutPathExpansion("%s", &%s);' %

[not at google - send to devlin, 2012/07/25 01:32:33]

just use HasKey, don't need to Get it too.

+                  (dst, prop.unix_name, src, prop.name, value_var))
         )
-        .Concat(self._GeneratePopulatePropertyFromValue(
-            prop, value_var, dst, 'false'))
-        .Eblock('}')
-      )
+      else:
+        (c.Sblock(
+            'if (%(src)s->GetWithoutPathExpansion("%(key)s", &%(value_var)s)) {'
+          )
+          .Concat(self._GeneratePopulatePropertyFromValue(
+              prop, value_var, dst, 'false'))
+          .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})
     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 prop.optional and not prop.type_ == PropertyType.FUNCTION:

[not at google - send to devlin, 2012/07/25 01:32:33]

nit: assign this condition to a local variable and read it here and below.

[chebert, 2012/07/25 18:38:30]

Done.

           if prop.type_ == PropertyType.ENUM:
             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)
         c.Append('value->SetWithoutPathExpansion("%s", %s);' % (
             prop.name,
             self._CreateValueFromProperty(prop, 'this->' + prop.unix_name)))
-        if prop.optional:
+        if prop.optional and not prop.type_ == PropertyType.FUNCTION:
           c.Eblock();
     (c.Append()
       .Append('return value.Pass();')
       .Eblock('}')
     )
     return c
 
   def _GenerateFunction(self, cpp_namespace, function):
     """Generates the definitions for function structs.
     """
@@ skipping 33 matching lines @@
       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.ENUM:
       return 'CreateEnumValue(%s).release()' % var
+    elif prop.type_ == PropertyType.FUNCTION:

[not at google - send to devlin, 2012/07/25 01:32:33]

Hm, well, for consistency with the way that functions come in from the renderer,
this should return an empty object (i.e. empty DictionaryValue).

I just spent a while looking through how onclick even arrives at the browser in
the first place, and it looks like a bit of a fluke; in V8ValueConverterImpl it
just happens that functions get serialised to an empty object in json; and
that's how they're going to come into json-schema-compiler.

I'm tempted to just ignore going back from has_foo to a value, but you never
know; that might surprise somebody at some point. So let's just make it
seriialize to an empty object.

(Add comment to that effect btw)

[chebert, 2012/07/25 18:38:30]

Done.

+      return 'base::Value::CreateBooleanValue(this->has_%s)' % prop.unix_name
     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,
@@ skipping 131 matching lines @@
           .Append('%(dst)s->%(name)s = temp.Pass();')
         )
       else:
         (c.Append('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;')
         )
+    elif prop.type_ == PropertyType.FUNCTION:
+      c.Append('%s->has_%s = true;' % (dst, prop.unix_name))

[not at google - send to devlin, 2012/07/25 01:32:33]

comment plz, the stuff about the renderer I said in the comment above.

[chebert, 2012/07/25 18:38:30]

Done.

     elif prop.type_ == PropertyType.ANY:
       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) + ';')
     elif self._IsArrayOrArrayRef(prop):
       # util_cc_helper deals with optional and required arrays
       (c.Append('base::ListValue* list = NULL;')
         .Append('if (!%(value_var)s->GetAsList(&list))')
         .Append('  return %(failure_value)s;'))
       if prop.item_type.type_ == PropertyType.ENUM:
@@ skipping 269 matching lines @@
     """
     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)