mojom: Add associative arrays to the mojom language.

mojo/public/tools/bindings/generators/cpp_templates/struct_macros.tmpl

+{%- macro validate_field(struct, name, kind) %}

[yzshen1, 2014/10/03 18:03:38]

Please validate that both arrays for a map are of the same size.
(And we need to add validation tests, and maybe new validation error enum value,
for it. It is fine if you would like to do this part in a separate CL.)

[Elliot Glaysher, 2014/10/03 21:11:49]

I believe that I've now added the validation code. However, I'm not sure what I
need to do to add a validation test?

+{%-   if kind|is_map_kind %}
+{%-     set name_keys = name + "_keys" %}
+{%-     set name_values = name + "_values" %}
+{{ validate_field(struct, name_keys, kind.key_kind) }}
+{{ validate_field(struct, name_values, kind.value_kind) }}
+{%-   elif kind|is_object_kind %}
+{%-     set wrapper_type = kind|cpp_wrapper_type %}
+{%-     if not kind|is_nullable_kind %}
+  if (!object->{{name}}.offset) {
+    ReportValidationError(
+        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
+        "null {{name}} field in {{struct.name}} struct");
+    return false;
+  }
+{%-     endif %}
+  if (!mojo::internal::ValidateEncodedPointer(&object->{{name}}.offset)) {
+    ReportValidationError(mojo::internal::VALIDATION_ERROR_ILLEGAL_POINTER);
+    return false;
+  }
+{%-     if kind|is_any_array_kind or kind|is_string_kind %}
+  if (!{{wrapper_type}}::Data_::Validate<
+          {{kind|get_array_validate_params|indent(10)}}>(
+              mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
+              bounds_checker)) {
+{%-     else %}
+  if (!{{wrapper_type}}::Data_::Validate(
+          mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
+          bounds_checker)) {
+{%-     endif %}
+    return false;
+  }
+{%-   elif kind|is_any_handle_kind %}
+{%-     if not kind|is_nullable_kind %}
+  if (object->{{name}}.value() == mojo::internal::kEncodedInvalidHandleValue) {
+    ReportValidationError(
+        mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
+        "invalid {{name}} field in {{struct.name}} struct");
+    return false;
+  }
+{%-     endif %}
+  if (!bounds_checker->ClaimHandle(object->{{name}})) {
+    ReportValidationError(mojo::internal::VALIDATION_ERROR_ILLEGAL_HANDLE);
+    return false;
+  }
+{%-   endif %}
+{%- endmacro -%}
+
+
 {%- macro validate(struct, class_name) %}
   if (!data)
     return true;
 
   if (!ValidateStructHeader(
           data, sizeof({{class_name}}),
           {{struct.packed.packed_fields|length}}, bounds_checker)) {
     return false;
   }
 
   const {{class_name}}* MOJO_ALLOW_UNUSED object =
       static_cast<const {{class_name}}*>(data);
 
 {%-   for packed_field in struct.packed.packed_fields %}
 {%-     set name = packed_field.field.name %}
 {%-     set kind = packed_field.field.kind %}
-{%-     if kind|is_object_kind %}
-{%-       set wrapper_type = kind|cpp_wrapper_type %}
-{%-       if not kind|is_nullable_kind %}
-  if (!object->{{name}}.offset) {
-    ReportValidationError(
-        mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
-        "null {{name}} field in {{struct.name}} struct");
-    return false;
-  }
-{%-       endif %}
-  if (!mojo::internal::ValidateEncodedPointer(&object->{{name}}.offset)) {
-    ReportValidationError(mojo::internal::VALIDATION_ERROR_ILLEGAL_POINTER);
-    return false;
-  }
-{%-       if kind|is_any_array_kind or kind|is_string_kind %}
-  if (!{{wrapper_type}}::Data_::Validate<
-          {{kind|get_array_validate_params|indent(10)}}>(
-              mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
-              bounds_checker)) {
-{%-       else %}
-  if (!{{wrapper_type}}::Data_::Validate(
-          mojo::internal::DecodePointerRaw(&object->{{name}}.offset),
-          bounds_checker)) {
-{%-       endif %}
-    return false;
-  }
-{%-     elif kind|is_any_handle_kind %}
-{%-       if not kind|is_nullable_kind %}
-  if (object->{{name}}.value() == mojo::internal::kEncodedInvalidHandleValue) {
-    ReportValidationError(
-        mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_HANDLE,
-        "invalid {{name}} field in {{struct.name}} struct");
-    return false;
-  }
-{%-       endif %}
-  if (!bounds_checker->ClaimHandle(object->{{name}})) {
-    ReportValidationError(mojo::internal::VALIDATION_ERROR_ILLEGAL_HANDLE);
-    return false;
-  }
-{%-     endif %}
+{{ validate_field(struct, name, kind) }}
 {%-   endfor %}
 
   return true;
 {%- endmacro %}
 
 {%- macro field_line(field) %}
-{%-   set type = field.kind|cpp_field_type %}
 {%-   set name = field.name -%}
 {%-   if field.kind.spec == 'b' -%}
   uint8_t {{name}} : 1;
 {%-   elif field.kind|is_enum_kind -%}
   int32_t {{name}};
+{%-   elif field.kind|is_map_kind -%}
+  mojo::internal::ArrayPointer<{{field.kind.key_kind|cpp_type}}> {{name}}_keys;
+  mojo::internal::ArrayPointer<{{field.kind.value_kind|cpp_type}}> {{name}}_values;
 {%-   else -%}
-  {{type}} {{name}};
+  {{field.kind|cpp_field_type}} {{name}};
 {%-   endif %}
 {%- endmacro %}
 
 {%- macro fields(struct) %}
 {%-   for packed_field in struct.packed.packed_fields %}
   {{field_line(packed_field.field)}}
 {%-     if not loop.last %}
 {%-       set next_pf = struct.packed.packed_fields[loop.index0 + 1] %}
 {%-       set pad = next_pf.offset - (packed_field.offset + packed_field.size) %}
 {%-       if pad > 0 %}
   uint8_t pad{{loop.index0}}_[{{pad}}];
 {%-       endif %}
 {%-     endif %}
 {%-   endfor -%}
 
 {%-   set num_fields = struct.packed.packed_fields|length %}
 {%-   if num_fields > 0 %}
 {%-     set last_field = struct.packed.packed_fields[num_fields - 1] %}
 {%-     set offset = last_field.offset + last_field.size %}
 {%-     set pad = offset|get_pad(8) -%}
 {%-     if pad > 0 %}
   uint8_t padfinal_[{{pad}}];
 {%-     endif %}
 {%-   endif %}
 {%- endmacro %}
 
 {%- macro encodes(struct) -%}
 {%-   for pf in struct.packed.packed_fields %}
-{%-     if pf.field.kind|is_object_kind %}
+{%-     if pf.field.kind|is_map_kind %}
+mojo::internal::Encode(&{{pf.field.name}}_keys, handles);
+mojo::internal::Encode(&{{pf.field.name}}_values, handles);
+{%-     elif pf.field.kind|is_object_kind %}
 mojo::internal::Encode(&{{pf.field.name}}, handles);
 {%-     elif pf.field.kind|is_any_handle_kind %}
 mojo::internal::EncodeHandle(&{{pf.field.name}}, handles);
 {%-     endif %}
 {%-   endfor %}
 {%- endmacro -%}
 
 {%- macro decodes(struct) -%}
 {%-   for pf in struct.packed.packed_fields %}
-{%-     if pf.field.kind|is_object_kind %}
+{%-     if pf.field.kind|is_map_kind %}
+mojo::internal::Decode(&{{pf.field.name}}_keys, handles);
+mojo::internal::Decode(&{{pf.field.name}}_values, handles);
+{%-     elif pf.field.kind|is_object_kind %}
 mojo::internal::Decode(&{{pf.field.name}}, handles);
 {%-     elif pf.field.kind|is_any_handle_kind %}
 mojo::internal::DecodeHandle(&{{pf.field.name}}, handles);
 {%-     endif %}
 {%-   endfor %}
 {%- endmacro -%}