Move declarative API into events API

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 sys
@@ skipping 81 matching lines @@
     # TODO(calamity): Events
     return c
 
   def _GenerateType(self, cpp_namespace, type_):
     """Generates the function definitions for a type.
     """
     classname = cpp_util.Classname(type_.name)
     c = Code()
 
     if type_.functions:
-      # Types with functions are not instantiable in C++ because they are
-      # handled in pure Javascript and hence have no properties or
-      # additionalProperties.
-      if type_.properties:
-        raise NotImplementedError('\n'.join(model.GetModelHierarchy(type_)) +
-            '\nCannot generate both functions and properties on a type')

[battre, 2012/05/09 16:28:08]

The files generated after deleting this exception are sound. You cannot
instantiate the objects in C++ but you get proper function definitions, which
are helpful.

[not at google - send to devlin, 2012/05/10 09:01:25]

I don't quite understand what you mean, can you give an example (for my own
peace of mind)?  But cool.

[battre, 2012/05/10 16:40:29]

Look at the events.json of this CL. The Event object is considered to have
functions and properties. By disabling this check, the following code is
generated, which is useful for me:

namespace Event {

  namespace GetRules {
    struct Params {
      // Name of the event this function affects.
      std::string event_name;

      // If an array is passed, only rules with identifiers contained in this
array
      // are returned.
      scoped_ptr<std::vector<std::string> > rule_identifiers;

      ~Params();

      static scoped_ptr<Params> Create(const ListValue& args);

     private:
      Params();

      DISALLOW_COPY_AND_ASSIGN(Params);
    };

    namespace Result {
      // Rules that were registered, the optional parameters are filled with
      // values.
      Value* Create(const std::vector<linked_ptr<Rule> >& rules);
    };

  };

       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()))
@@ skipping 541 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)