| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 // This file is autogenerated by: | |
| 6 // mojo/public/tools/bindings/mojom_bindings_generator.py | |
| 7 // For: | |
| 8 // mojo/public/interfaces/bindings/mojom_files.mojom | |
| 9 // | |
| 10 | |
| 11 package mojom_files | |
| 12 | |
| 13 import ( | |
| 14 fmt "fmt" | |
| 15 bindings "mojo/public/go/bindings" | |
| 16 mojom_types "mojom/mojom_tool/generated/mojom_types" | |
| 17 sort "sort" | |
| 18 ) | |
| 19 | |
| 20 type MojomFile struct { | |
| 21 FileName string | |
| 22 SpecifiedFileName *string | |
| 23 ModuleNamespace *string | |
| 24 Attributes *[]mojom_types.Attribute | |
| 25 Imports *[]string | |
| 26 DeclaredMojomObjects KeysByType | |
| 27 SerializedRuntimeTypeInfo *string | |
| 28 } | |
| 29 | |
| 30 func (s *MojomFile) Encode(encoder *bindings.Encoder) error { | |
| 31 encoder.StartStruct(56, 0) | |
| 32 if err := encoder.WritePointer(); err != nil { | |
| 33 return err | |
| 34 } | |
| 35 if err := encoder.WriteString(s.FileName); err != nil { | |
| 36 return err | |
| 37 } | |
| 38 if s.SpecifiedFileName == nil { | |
| 39 encoder.WriteNullPointer() | |
| 40 } else { | |
| 41 if err := encoder.WritePointer(); err != nil { | |
| 42 return err | |
| 43 } | |
| 44 if err := encoder.WriteString((*s.SpecifiedFileName)); err != ni
l { | |
| 45 return err | |
| 46 } | |
| 47 } | |
| 48 if s.ModuleNamespace == nil { | |
| 49 encoder.WriteNullPointer() | |
| 50 } else { | |
| 51 if err := encoder.WritePointer(); err != nil { | |
| 52 return err | |
| 53 } | |
| 54 if err := encoder.WriteString((*s.ModuleNamespace)); err != nil
{ | |
| 55 return err | |
| 56 } | |
| 57 } | |
| 58 if s.Attributes == nil { | |
| 59 encoder.WriteNullPointer() | |
| 60 } else { | |
| 61 if err := encoder.WritePointer(); err != nil { | |
| 62 return err | |
| 63 } | |
| 64 encoder.StartArray(uint32(len((*s.Attributes))), 64) | |
| 65 for _, elem0 := range *s.Attributes { | |
| 66 if err := encoder.WritePointer(); err != nil { | |
| 67 return err | |
| 68 } | |
| 69 if err := elem0.Encode(encoder); err != nil { | |
| 70 return err | |
| 71 } | |
| 72 } | |
| 73 if err := encoder.Finish(); err != nil { | |
| 74 return err | |
| 75 } | |
| 76 } | |
| 77 if s.Imports == nil { | |
| 78 encoder.WriteNullPointer() | |
| 79 } else { | |
| 80 if err := encoder.WritePointer(); err != nil { | |
| 81 return err | |
| 82 } | |
| 83 encoder.StartArray(uint32(len((*s.Imports))), 64) | |
| 84 for _, elem0 := range *s.Imports { | |
| 85 if err := encoder.WritePointer(); err != nil { | |
| 86 return err | |
| 87 } | |
| 88 if err := encoder.WriteString(elem0); err != nil { | |
| 89 return err | |
| 90 } | |
| 91 } | |
| 92 if err := encoder.Finish(); err != nil { | |
| 93 return err | |
| 94 } | |
| 95 } | |
| 96 if err := encoder.WritePointer(); err != nil { | |
| 97 return err | |
| 98 } | |
| 99 if err := s.DeclaredMojomObjects.Encode(encoder); err != nil { | |
| 100 return err | |
| 101 } | |
| 102 if s.SerializedRuntimeTypeInfo == nil { | |
| 103 encoder.WriteNullPointer() | |
| 104 } else { | |
| 105 if err := encoder.WritePointer(); err != nil { | |
| 106 return err | |
| 107 } | |
| 108 if err := encoder.WriteString((*s.SerializedRuntimeTypeInfo)); e
rr != nil { | |
| 109 return err | |
| 110 } | |
| 111 } | |
| 112 if err := encoder.Finish(); err != nil { | |
| 113 return err | |
| 114 } | |
| 115 return nil | |
| 116 } | |
| 117 | |
| 118 var mojomFile_Versions []bindings.DataHeader = []bindings.DataHeader{ | |
| 119 bindings.DataHeader{64, 0}, | |
| 120 } | |
| 121 | |
| 122 func (s *MojomFile) Decode(decoder *bindings.Decoder) error { | |
| 123 header, err := decoder.StartStruct() | |
| 124 if err != nil { | |
| 125 return err | |
| 126 } | |
| 127 index := sort.Search(len(mojomFile_Versions), func(i int) bool { | |
| 128 return mojomFile_Versions[i].ElementsOrVersion >= header.Element
sOrVersion | |
| 129 }) | |
| 130 if index < len(mojomFile_Versions) { | |
| 131 if mojomFile_Versions[index].ElementsOrVersion > header.Elements
OrVersion { | |
| 132 index-- | |
| 133 } | |
| 134 expectedSize := mojomFile_Versions[index].Size | |
| 135 if expectedSize != header.Size { | |
| 136 return &bindings.ValidationError{bindings.UnexpectedStru
ctHeader, | |
| 137 fmt.Sprintf("invalid struct header size: should
be %d, but was %d", expectedSize, header.Size), | |
| 138 } | |
| 139 } | |
| 140 } | |
| 141 if header.ElementsOrVersion >= 0 { | |
| 142 pointer0, err := decoder.ReadPointer() | |
| 143 if err != nil { | |
| 144 return err | |
| 145 } | |
| 146 if pointer0 == 0 { | |
| 147 return &bindings.ValidationError{bindings.UnexpectedNull
Pointer, "unexpected null pointer"} | |
| 148 } else { | |
| 149 value0, err := decoder.ReadString() | |
| 150 if err != nil { | |
| 151 return err | |
| 152 } | |
| 153 s.FileName = value0 | |
| 154 } | |
| 155 } | |
| 156 if header.ElementsOrVersion >= 0 { | |
| 157 pointer0, err := decoder.ReadPointer() | |
| 158 if err != nil { | |
| 159 return err | |
| 160 } | |
| 161 if pointer0 == 0 { | |
| 162 s.SpecifiedFileName = nil | |
| 163 } else { | |
| 164 s.SpecifiedFileName = new(string) | |
| 165 value0, err := decoder.ReadString() | |
| 166 if err != nil { | |
| 167 return err | |
| 168 } | |
| 169 (*s.SpecifiedFileName) = value0 | |
| 170 } | |
| 171 } | |
| 172 if header.ElementsOrVersion >= 0 { | |
| 173 pointer0, err := decoder.ReadPointer() | |
| 174 if err != nil { | |
| 175 return err | |
| 176 } | |
| 177 if pointer0 == 0 { | |
| 178 s.ModuleNamespace = nil | |
| 179 } else { | |
| 180 s.ModuleNamespace = new(string) | |
| 181 value0, err := decoder.ReadString() | |
| 182 if err != nil { | |
| 183 return err | |
| 184 } | |
| 185 (*s.ModuleNamespace) = value0 | |
| 186 } | |
| 187 } | |
| 188 if header.ElementsOrVersion >= 0 { | |
| 189 pointer0, err := decoder.ReadPointer() | |
| 190 if err != nil { | |
| 191 return err | |
| 192 } | |
| 193 if pointer0 == 0 { | |
| 194 s.Attributes = nil | |
| 195 } else { | |
| 196 s.Attributes = new([]mojom_types.Attribute) | |
| 197 len0, err := decoder.StartArray(64) | |
| 198 if err != nil { | |
| 199 return err | |
| 200 } | |
| 201 (*s.Attributes) = make([]mojom_types.Attribute, len0) | |
| 202 for i0 := uint32(0); i0 < len0; i0++ { | |
| 203 pointer1, err := decoder.ReadPointer() | |
| 204 if err != nil { | |
| 205 return err | |
| 206 } | |
| 207 if pointer1 == 0 { | |
| 208 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 209 } else { | |
| 210 if err := (*s.Attributes)[i0].Decode(dec
oder); err != nil { | |
| 211 return err | |
| 212 } | |
| 213 } | |
| 214 } | |
| 215 if err := decoder.Finish(); err != nil { | |
| 216 return err | |
| 217 } | |
| 218 } | |
| 219 } | |
| 220 if header.ElementsOrVersion >= 0 { | |
| 221 pointer0, err := decoder.ReadPointer() | |
| 222 if err != nil { | |
| 223 return err | |
| 224 } | |
| 225 if pointer0 == 0 { | |
| 226 s.Imports = nil | |
| 227 } else { | |
| 228 s.Imports = new([]string) | |
| 229 len0, err := decoder.StartArray(64) | |
| 230 if err != nil { | |
| 231 return err | |
| 232 } | |
| 233 (*s.Imports) = make([]string, len0) | |
| 234 for i0 := uint32(0); i0 < len0; i0++ { | |
| 235 pointer1, err := decoder.ReadPointer() | |
| 236 if err != nil { | |
| 237 return err | |
| 238 } | |
| 239 if pointer1 == 0 { | |
| 240 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 241 } else { | |
| 242 value1, err := decoder.ReadString() | |
| 243 if err != nil { | |
| 244 return err | |
| 245 } | |
| 246 (*s.Imports)[i0] = value1 | |
| 247 } | |
| 248 } | |
| 249 if err := decoder.Finish(); err != nil { | |
| 250 return err | |
| 251 } | |
| 252 } | |
| 253 } | |
| 254 if header.ElementsOrVersion >= 0 { | |
| 255 pointer0, err := decoder.ReadPointer() | |
| 256 if err != nil { | |
| 257 return err | |
| 258 } | |
| 259 if pointer0 == 0 { | |
| 260 return &bindings.ValidationError{bindings.UnexpectedNull
Pointer, "unexpected null pointer"} | |
| 261 } else { | |
| 262 if err := s.DeclaredMojomObjects.Decode(decoder); err !=
nil { | |
| 263 return err | |
| 264 } | |
| 265 } | |
| 266 } | |
| 267 if header.ElementsOrVersion >= 0 { | |
| 268 pointer0, err := decoder.ReadPointer() | |
| 269 if err != nil { | |
| 270 return err | |
| 271 } | |
| 272 if pointer0 == 0 { | |
| 273 s.SerializedRuntimeTypeInfo = nil | |
| 274 } else { | |
| 275 s.SerializedRuntimeTypeInfo = new(string) | |
| 276 value0, err := decoder.ReadString() | |
| 277 if err != nil { | |
| 278 return err | |
| 279 } | |
| 280 (*s.SerializedRuntimeTypeInfo) = value0 | |
| 281 } | |
| 282 } | |
| 283 if err := decoder.Finish(); err != nil { | |
| 284 return err | |
| 285 } | |
| 286 return nil | |
| 287 } | |
| 288 | |
| 289 type MojomFileGraph struct { | |
| 290 Files map[string]MojomFile | |
| 291 ResolvedTypes map[string]mojom_types.UserDefinedType | |
| 292 ResolvedValues map[string]mojom_types.UserDefinedValue | |
| 293 } | |
| 294 | |
| 295 func (s *MojomFileGraph) Encode(encoder *bindings.Encoder) error { | |
| 296 encoder.StartStruct(24, 0) | |
| 297 if err := encoder.WritePointer(); err != nil { | |
| 298 return err | |
| 299 } | |
| 300 encoder.StartMap() | |
| 301 { | |
| 302 var keys0 []string | |
| 303 var values0 []MojomFile | |
| 304 if encoder.Deterministic() { | |
| 305 for key0, _ := range s.Files { | |
| 306 keys0 = append(keys0, key0) | |
| 307 } | |
| 308 bindings.SortMapKeys(&keys0) | |
| 309 values0 = make([]MojomFile, len(keys0)) | |
| 310 for i, key := range keys0 { | |
| 311 values0[i] = s.Files[key] | |
| 312 } | |
| 313 } else { | |
| 314 for key0, value0 := range s.Files { | |
| 315 keys0 = append(keys0, key0) | |
| 316 values0 = append(values0, value0) | |
| 317 } | |
| 318 } | |
| 319 if err := encoder.WritePointer(); err != nil { | |
| 320 return err | |
| 321 } | |
| 322 encoder.StartArray(uint32(len(keys0)), 64) | |
| 323 for _, elem1 := range keys0 { | |
| 324 if err := encoder.WritePointer(); err != nil { | |
| 325 return err | |
| 326 } | |
| 327 if err := encoder.WriteString(elem1); err != nil { | |
| 328 return err | |
| 329 } | |
| 330 } | |
| 331 if err := encoder.Finish(); err != nil { | |
| 332 return err | |
| 333 } | |
| 334 if err := encoder.WritePointer(); err != nil { | |
| 335 return err | |
| 336 } | |
| 337 encoder.StartArray(uint32(len(values0)), 64) | |
| 338 for _, elem1 := range values0 { | |
| 339 if err := encoder.WritePointer(); err != nil { | |
| 340 return err | |
| 341 } | |
| 342 if err := elem1.Encode(encoder); err != nil { | |
| 343 return err | |
| 344 } | |
| 345 } | |
| 346 if err := encoder.Finish(); err != nil { | |
| 347 return err | |
| 348 } | |
| 349 } | |
| 350 if err := encoder.Finish(); err != nil { | |
| 351 return err | |
| 352 } | |
| 353 if err := encoder.WritePointer(); err != nil { | |
| 354 return err | |
| 355 } | |
| 356 encoder.StartMap() | |
| 357 { | |
| 358 var keys0 []string | |
| 359 var values0 []mojom_types.UserDefinedType | |
| 360 if encoder.Deterministic() { | |
| 361 for key0, _ := range s.ResolvedTypes { | |
| 362 keys0 = append(keys0, key0) | |
| 363 } | |
| 364 bindings.SortMapKeys(&keys0) | |
| 365 values0 = make([]mojom_types.UserDefinedType, len(keys0)
) | |
| 366 for i, key := range keys0 { | |
| 367 values0[i] = s.ResolvedTypes[key] | |
| 368 } | |
| 369 } else { | |
| 370 for key0, value0 := range s.ResolvedTypes { | |
| 371 keys0 = append(keys0, key0) | |
| 372 values0 = append(values0, value0) | |
| 373 } | |
| 374 } | |
| 375 if err := encoder.WritePointer(); err != nil { | |
| 376 return err | |
| 377 } | |
| 378 encoder.StartArray(uint32(len(keys0)), 64) | |
| 379 for _, elem1 := range keys0 { | |
| 380 if err := encoder.WritePointer(); err != nil { | |
| 381 return err | |
| 382 } | |
| 383 if err := encoder.WriteString(elem1); err != nil { | |
| 384 return err | |
| 385 } | |
| 386 } | |
| 387 if err := encoder.Finish(); err != nil { | |
| 388 return err | |
| 389 } | |
| 390 if err := encoder.WritePointer(); err != nil { | |
| 391 return err | |
| 392 } | |
| 393 encoder.StartArray(uint32(len(values0)), 128) | |
| 394 for _, elem1 := range values0 { | |
| 395 if elem1 == nil { | |
| 396 return &bindings.ValidationError{bindings.Unexpe
ctedNullUnion, "unexpected null union"} | |
| 397 } | |
| 398 if err := elem1.Encode(encoder); err != nil { | |
| 399 return err | |
| 400 } | |
| 401 } | |
| 402 if err := encoder.Finish(); err != nil { | |
| 403 return err | |
| 404 } | |
| 405 } | |
| 406 if err := encoder.Finish(); err != nil { | |
| 407 return err | |
| 408 } | |
| 409 if err := encoder.WritePointer(); err != nil { | |
| 410 return err | |
| 411 } | |
| 412 encoder.StartMap() | |
| 413 { | |
| 414 var keys0 []string | |
| 415 var values0 []mojom_types.UserDefinedValue | |
| 416 if encoder.Deterministic() { | |
| 417 for key0, _ := range s.ResolvedValues { | |
| 418 keys0 = append(keys0, key0) | |
| 419 } | |
| 420 bindings.SortMapKeys(&keys0) | |
| 421 values0 = make([]mojom_types.UserDefinedValue, len(keys0
)) | |
| 422 for i, key := range keys0 { | |
| 423 values0[i] = s.ResolvedValues[key] | |
| 424 } | |
| 425 } else { | |
| 426 for key0, value0 := range s.ResolvedValues { | |
| 427 keys0 = append(keys0, key0) | |
| 428 values0 = append(values0, value0) | |
| 429 } | |
| 430 } | |
| 431 if err := encoder.WritePointer(); err != nil { | |
| 432 return err | |
| 433 } | |
| 434 encoder.StartArray(uint32(len(keys0)), 64) | |
| 435 for _, elem1 := range keys0 { | |
| 436 if err := encoder.WritePointer(); err != nil { | |
| 437 return err | |
| 438 } | |
| 439 if err := encoder.WriteString(elem1); err != nil { | |
| 440 return err | |
| 441 } | |
| 442 } | |
| 443 if err := encoder.Finish(); err != nil { | |
| 444 return err | |
| 445 } | |
| 446 if err := encoder.WritePointer(); err != nil { | |
| 447 return err | |
| 448 } | |
| 449 encoder.StartArray(uint32(len(values0)), 128) | |
| 450 for _, elem1 := range values0 { | |
| 451 if elem1 == nil { | |
| 452 return &bindings.ValidationError{bindings.Unexpe
ctedNullUnion, "unexpected null union"} | |
| 453 } | |
| 454 if err := elem1.Encode(encoder); err != nil { | |
| 455 return err | |
| 456 } | |
| 457 } | |
| 458 if err := encoder.Finish(); err != nil { | |
| 459 return err | |
| 460 } | |
| 461 } | |
| 462 if err := encoder.Finish(); err != nil { | |
| 463 return err | |
| 464 } | |
| 465 if err := encoder.Finish(); err != nil { | |
| 466 return err | |
| 467 } | |
| 468 return nil | |
| 469 } | |
| 470 | |
| 471 var mojomFileGraph_Versions []bindings.DataHeader = []bindings.DataHeader{ | |
| 472 bindings.DataHeader{32, 0}, | |
| 473 } | |
| 474 | |
| 475 func (s *MojomFileGraph) Decode(decoder *bindings.Decoder) error { | |
| 476 header, err := decoder.StartStruct() | |
| 477 if err != nil { | |
| 478 return err | |
| 479 } | |
| 480 index := sort.Search(len(mojomFileGraph_Versions), func(i int) bool { | |
| 481 return mojomFileGraph_Versions[i].ElementsOrVersion >= header.El
ementsOrVersion | |
| 482 }) | |
| 483 if index < len(mojomFileGraph_Versions) { | |
| 484 if mojomFileGraph_Versions[index].ElementsOrVersion > header.Ele
mentsOrVersion { | |
| 485 index-- | |
| 486 } | |
| 487 expectedSize := mojomFileGraph_Versions[index].Size | |
| 488 if expectedSize != header.Size { | |
| 489 return &bindings.ValidationError{bindings.UnexpectedStru
ctHeader, | |
| 490 fmt.Sprintf("invalid struct header size: should
be %d, but was %d", expectedSize, header.Size), | |
| 491 } | |
| 492 } | |
| 493 } | |
| 494 if header.ElementsOrVersion >= 0 { | |
| 495 pointer0, err := decoder.ReadPointer() | |
| 496 if err != nil { | |
| 497 return err | |
| 498 } | |
| 499 if pointer0 == 0 { | |
| 500 return &bindings.ValidationError{bindings.UnexpectedNull
Pointer, "unexpected null pointer"} | |
| 501 } else { | |
| 502 if err := decoder.StartMap(); err != nil { | |
| 503 return err | |
| 504 } | |
| 505 var keys0 []string | |
| 506 { | |
| 507 pointer1, err := decoder.ReadPointer() | |
| 508 if err != nil { | |
| 509 return err | |
| 510 } | |
| 511 if pointer1 == 0 { | |
| 512 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 513 } else { | |
| 514 len1, err := decoder.StartArray(64) | |
| 515 if err != nil { | |
| 516 return err | |
| 517 } | |
| 518 keys0 = make([]string, len1) | |
| 519 for i1 := uint32(0); i1 < len1; i1++ { | |
| 520 pointer2, err := decoder.ReadPoi
nter() | |
| 521 if err != nil { | |
| 522 return err | |
| 523 } | |
| 524 if pointer2 == 0 { | |
| 525 return &bindings.Validat
ionError{bindings.UnexpectedNullPointer, "unexpected null pointer"} | |
| 526 } else { | |
| 527 value2, err := decoder.R
eadString() | |
| 528 if err != nil { | |
| 529 return err | |
| 530 } | |
| 531 keys0[i1] = value2 | |
| 532 } | |
| 533 } | |
| 534 if err := decoder.Finish(); err != nil { | |
| 535 return err | |
| 536 } | |
| 537 } | |
| 538 } | |
| 539 var values0 []MojomFile | |
| 540 { | |
| 541 pointer1, err := decoder.ReadPointer() | |
| 542 if err != nil { | |
| 543 return err | |
| 544 } | |
| 545 if pointer1 == 0 { | |
| 546 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 547 } else { | |
| 548 len1, err := decoder.StartArray(64) | |
| 549 if err != nil { | |
| 550 return err | |
| 551 } | |
| 552 values0 = make([]MojomFile, len1) | |
| 553 for i1 := uint32(0); i1 < len1; i1++ { | |
| 554 pointer2, err := decoder.ReadPoi
nter() | |
| 555 if err != nil { | |
| 556 return err | |
| 557 } | |
| 558 if pointer2 == 0 { | |
| 559 return &bindings.Validat
ionError{bindings.UnexpectedNullPointer, "unexpected null pointer"} | |
| 560 } else { | |
| 561 if err := values0[i1].De
code(decoder); err != nil { | |
| 562 return err | |
| 563 } | |
| 564 } | |
| 565 } | |
| 566 if err := decoder.Finish(); err != nil { | |
| 567 return err | |
| 568 } | |
| 569 } | |
| 570 } | |
| 571 if len(keys0) != len(values0) { | |
| 572 return &bindings.ValidationError{bindings.Differ
entSizedArraysInMap, | |
| 573 fmt.Sprintf("Number of keys %d is differ
ent from number of values %d", len(keys0), len(values0)), | |
| 574 } | |
| 575 } | |
| 576 if err := decoder.Finish(); err != nil { | |
| 577 return err | |
| 578 } | |
| 579 len0 := len(keys0) | |
| 580 map0 := make(map[string]MojomFile) | |
| 581 for i0 := 0; i0 < len0; i0++ { | |
| 582 map0[keys0[i0]] = values0[i0] | |
| 583 } | |
| 584 s.Files = map0 | |
| 585 } | |
| 586 } | |
| 587 if header.ElementsOrVersion >= 0 { | |
| 588 pointer0, err := decoder.ReadPointer() | |
| 589 if err != nil { | |
| 590 return err | |
| 591 } | |
| 592 if pointer0 == 0 { | |
| 593 return &bindings.ValidationError{bindings.UnexpectedNull
Pointer, "unexpected null pointer"} | |
| 594 } else { | |
| 595 if err := decoder.StartMap(); err != nil { | |
| 596 return err | |
| 597 } | |
| 598 var keys0 []string | |
| 599 { | |
| 600 pointer1, err := decoder.ReadPointer() | |
| 601 if err != nil { | |
| 602 return err | |
| 603 } | |
| 604 if pointer1 == 0 { | |
| 605 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 606 } else { | |
| 607 len1, err := decoder.StartArray(64) | |
| 608 if err != nil { | |
| 609 return err | |
| 610 } | |
| 611 keys0 = make([]string, len1) | |
| 612 for i1 := uint32(0); i1 < len1; i1++ { | |
| 613 pointer2, err := decoder.ReadPoi
nter() | |
| 614 if err != nil { | |
| 615 return err | |
| 616 } | |
| 617 if pointer2 == 0 { | |
| 618 return &bindings.Validat
ionError{bindings.UnexpectedNullPointer, "unexpected null pointer"} | |
| 619 } else { | |
| 620 value2, err := decoder.R
eadString() | |
| 621 if err != nil { | |
| 622 return err | |
| 623 } | |
| 624 keys0[i1] = value2 | |
| 625 } | |
| 626 } | |
| 627 if err := decoder.Finish(); err != nil { | |
| 628 return err | |
| 629 } | |
| 630 } | |
| 631 } | |
| 632 var values0 []mojom_types.UserDefinedType | |
| 633 { | |
| 634 pointer1, err := decoder.ReadPointer() | |
| 635 if err != nil { | |
| 636 return err | |
| 637 } | |
| 638 if pointer1 == 0 { | |
| 639 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 640 } else { | |
| 641 len1, err := decoder.StartArray(128) | |
| 642 if err != nil { | |
| 643 return err | |
| 644 } | |
| 645 values0 = make([]mojom_types.UserDefined
Type, len1) | |
| 646 for i1 := uint32(0); i1 < len1; i1++ { | |
| 647 var err error | |
| 648 values0[i1], err = mojom_types.D
ecodeUserDefinedType(decoder) | |
| 649 if err != nil { | |
| 650 return err | |
| 651 } | |
| 652 if values0[i1] == nil { | |
| 653 return &bindings.Validat
ionError{bindings.UnexpectedNullUnion, "unexpected null union"} | |
| 654 } | |
| 655 } | |
| 656 if err := decoder.Finish(); err != nil { | |
| 657 return err | |
| 658 } | |
| 659 } | |
| 660 } | |
| 661 if len(keys0) != len(values0) { | |
| 662 return &bindings.ValidationError{bindings.Differ
entSizedArraysInMap, | |
| 663 fmt.Sprintf("Number of keys %d is differ
ent from number of values %d", len(keys0), len(values0)), | |
| 664 } | |
| 665 } | |
| 666 if err := decoder.Finish(); err != nil { | |
| 667 return err | |
| 668 } | |
| 669 len0 := len(keys0) | |
| 670 map0 := make(map[string]mojom_types.UserDefinedType) | |
| 671 for i0 := 0; i0 < len0; i0++ { | |
| 672 map0[keys0[i0]] = values0[i0] | |
| 673 } | |
| 674 s.ResolvedTypes = map0 | |
| 675 } | |
| 676 } | |
| 677 if header.ElementsOrVersion >= 0 { | |
| 678 pointer0, err := decoder.ReadPointer() | |
| 679 if err != nil { | |
| 680 return err | |
| 681 } | |
| 682 if pointer0 == 0 { | |
| 683 return &bindings.ValidationError{bindings.UnexpectedNull
Pointer, "unexpected null pointer"} | |
| 684 } else { | |
| 685 if err := decoder.StartMap(); err != nil { | |
| 686 return err | |
| 687 } | |
| 688 var keys0 []string | |
| 689 { | |
| 690 pointer1, err := decoder.ReadPointer() | |
| 691 if err != nil { | |
| 692 return err | |
| 693 } | |
| 694 if pointer1 == 0 { | |
| 695 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 696 } else { | |
| 697 len1, err := decoder.StartArray(64) | |
| 698 if err != nil { | |
| 699 return err | |
| 700 } | |
| 701 keys0 = make([]string, len1) | |
| 702 for i1 := uint32(0); i1 < len1; i1++ { | |
| 703 pointer2, err := decoder.ReadPoi
nter() | |
| 704 if err != nil { | |
| 705 return err | |
| 706 } | |
| 707 if pointer2 == 0 { | |
| 708 return &bindings.Validat
ionError{bindings.UnexpectedNullPointer, "unexpected null pointer"} | |
| 709 } else { | |
| 710 value2, err := decoder.R
eadString() | |
| 711 if err != nil { | |
| 712 return err | |
| 713 } | |
| 714 keys0[i1] = value2 | |
| 715 } | |
| 716 } | |
| 717 if err := decoder.Finish(); err != nil { | |
| 718 return err | |
| 719 } | |
| 720 } | |
| 721 } | |
| 722 var values0 []mojom_types.UserDefinedValue | |
| 723 { | |
| 724 pointer1, err := decoder.ReadPointer() | |
| 725 if err != nil { | |
| 726 return err | |
| 727 } | |
| 728 if pointer1 == 0 { | |
| 729 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 730 } else { | |
| 731 len1, err := decoder.StartArray(128) | |
| 732 if err != nil { | |
| 733 return err | |
| 734 } | |
| 735 values0 = make([]mojom_types.UserDefined
Value, len1) | |
| 736 for i1 := uint32(0); i1 < len1; i1++ { | |
| 737 var err error | |
| 738 values0[i1], err = mojom_types.D
ecodeUserDefinedValue(decoder) | |
| 739 if err != nil { | |
| 740 return err | |
| 741 } | |
| 742 if values0[i1] == nil { | |
| 743 return &bindings.Validat
ionError{bindings.UnexpectedNullUnion, "unexpected null union"} | |
| 744 } | |
| 745 } | |
| 746 if err := decoder.Finish(); err != nil { | |
| 747 return err | |
| 748 } | |
| 749 } | |
| 750 } | |
| 751 if len(keys0) != len(values0) { | |
| 752 return &bindings.ValidationError{bindings.Differ
entSizedArraysInMap, | |
| 753 fmt.Sprintf("Number of keys %d is differ
ent from number of values %d", len(keys0), len(values0)), | |
| 754 } | |
| 755 } | |
| 756 if err := decoder.Finish(); err != nil { | |
| 757 return err | |
| 758 } | |
| 759 len0 := len(keys0) | |
| 760 map0 := make(map[string]mojom_types.UserDefinedValue) | |
| 761 for i0 := 0; i0 < len0; i0++ { | |
| 762 map0[keys0[i0]] = values0[i0] | |
| 763 } | |
| 764 s.ResolvedValues = map0 | |
| 765 } | |
| 766 } | |
| 767 if err := decoder.Finish(); err != nil { | |
| 768 return err | |
| 769 } | |
| 770 return nil | |
| 771 } | |
| 772 | |
| 773 type KeysByType struct { | |
| 774 Interfaces *[]string | |
| 775 Structs *[]string | |
| 776 Unions *[]string | |
| 777 TopLevelEnums *[]string | |
| 778 EmbeddedEnums *[]string | |
| 779 TopLevelConstants *[]string | |
| 780 EmbeddedConstants *[]string | |
| 781 } | |
| 782 | |
| 783 func (s *KeysByType) Encode(encoder *bindings.Encoder) error { | |
| 784 encoder.StartStruct(56, 0) | |
| 785 if s.Interfaces == nil { | |
| 786 encoder.WriteNullPointer() | |
| 787 } else { | |
| 788 if err := encoder.WritePointer(); err != nil { | |
| 789 return err | |
| 790 } | |
| 791 encoder.StartArray(uint32(len((*s.Interfaces))), 64) | |
| 792 for _, elem0 := range *s.Interfaces { | |
| 793 if err := encoder.WritePointer(); err != nil { | |
| 794 return err | |
| 795 } | |
| 796 if err := encoder.WriteString(elem0); err != nil { | |
| 797 return err | |
| 798 } | |
| 799 } | |
| 800 if err := encoder.Finish(); err != nil { | |
| 801 return err | |
| 802 } | |
| 803 } | |
| 804 if s.Structs == nil { | |
| 805 encoder.WriteNullPointer() | |
| 806 } else { | |
| 807 if err := encoder.WritePointer(); err != nil { | |
| 808 return err | |
| 809 } | |
| 810 encoder.StartArray(uint32(len((*s.Structs))), 64) | |
| 811 for _, elem0 := range *s.Structs { | |
| 812 if err := encoder.WritePointer(); err != nil { | |
| 813 return err | |
| 814 } | |
| 815 if err := encoder.WriteString(elem0); err != nil { | |
| 816 return err | |
| 817 } | |
| 818 } | |
| 819 if err := encoder.Finish(); err != nil { | |
| 820 return err | |
| 821 } | |
| 822 } | |
| 823 if s.Unions == nil { | |
| 824 encoder.WriteNullPointer() | |
| 825 } else { | |
| 826 if err := encoder.WritePointer(); err != nil { | |
| 827 return err | |
| 828 } | |
| 829 encoder.StartArray(uint32(len((*s.Unions))), 64) | |
| 830 for _, elem0 := range *s.Unions { | |
| 831 if err := encoder.WritePointer(); err != nil { | |
| 832 return err | |
| 833 } | |
| 834 if err := encoder.WriteString(elem0); err != nil { | |
| 835 return err | |
| 836 } | |
| 837 } | |
| 838 if err := encoder.Finish(); err != nil { | |
| 839 return err | |
| 840 } | |
| 841 } | |
| 842 if s.TopLevelEnums == nil { | |
| 843 encoder.WriteNullPointer() | |
| 844 } else { | |
| 845 if err := encoder.WritePointer(); err != nil { | |
| 846 return err | |
| 847 } | |
| 848 encoder.StartArray(uint32(len((*s.TopLevelEnums))), 64) | |
| 849 for _, elem0 := range *s.TopLevelEnums { | |
| 850 if err := encoder.WritePointer(); err != nil { | |
| 851 return err | |
| 852 } | |
| 853 if err := encoder.WriteString(elem0); err != nil { | |
| 854 return err | |
| 855 } | |
| 856 } | |
| 857 if err := encoder.Finish(); err != nil { | |
| 858 return err | |
| 859 } | |
| 860 } | |
| 861 if s.EmbeddedEnums == nil { | |
| 862 encoder.WriteNullPointer() | |
| 863 } else { | |
| 864 if err := encoder.WritePointer(); err != nil { | |
| 865 return err | |
| 866 } | |
| 867 encoder.StartArray(uint32(len((*s.EmbeddedEnums))), 64) | |
| 868 for _, elem0 := range *s.EmbeddedEnums { | |
| 869 if err := encoder.WritePointer(); err != nil { | |
| 870 return err | |
| 871 } | |
| 872 if err := encoder.WriteString(elem0); err != nil { | |
| 873 return err | |
| 874 } | |
| 875 } | |
| 876 if err := encoder.Finish(); err != nil { | |
| 877 return err | |
| 878 } | |
| 879 } | |
| 880 if s.TopLevelConstants == nil { | |
| 881 encoder.WriteNullPointer() | |
| 882 } else { | |
| 883 if err := encoder.WritePointer(); err != nil { | |
| 884 return err | |
| 885 } | |
| 886 encoder.StartArray(uint32(len((*s.TopLevelConstants))), 64) | |
| 887 for _, elem0 := range *s.TopLevelConstants { | |
| 888 if err := encoder.WritePointer(); err != nil { | |
| 889 return err | |
| 890 } | |
| 891 if err := encoder.WriteString(elem0); err != nil { | |
| 892 return err | |
| 893 } | |
| 894 } | |
| 895 if err := encoder.Finish(); err != nil { | |
| 896 return err | |
| 897 } | |
| 898 } | |
| 899 if s.EmbeddedConstants == nil { | |
| 900 encoder.WriteNullPointer() | |
| 901 } else { | |
| 902 if err := encoder.WritePointer(); err != nil { | |
| 903 return err | |
| 904 } | |
| 905 encoder.StartArray(uint32(len((*s.EmbeddedConstants))), 64) | |
| 906 for _, elem0 := range *s.EmbeddedConstants { | |
| 907 if err := encoder.WritePointer(); err != nil { | |
| 908 return err | |
| 909 } | |
| 910 if err := encoder.WriteString(elem0); err != nil { | |
| 911 return err | |
| 912 } | |
| 913 } | |
| 914 if err := encoder.Finish(); err != nil { | |
| 915 return err | |
| 916 } | |
| 917 } | |
| 918 if err := encoder.Finish(); err != nil { | |
| 919 return err | |
| 920 } | |
| 921 return nil | |
| 922 } | |
| 923 | |
| 924 var keysByType_Versions []bindings.DataHeader = []bindings.DataHeader{ | |
| 925 bindings.DataHeader{64, 0}, | |
| 926 } | |
| 927 | |
| 928 func (s *KeysByType) Decode(decoder *bindings.Decoder) error { | |
| 929 header, err := decoder.StartStruct() | |
| 930 if err != nil { | |
| 931 return err | |
| 932 } | |
| 933 index := sort.Search(len(keysByType_Versions), func(i int) bool { | |
| 934 return keysByType_Versions[i].ElementsOrVersion >= header.Elemen
tsOrVersion | |
| 935 }) | |
| 936 if index < len(keysByType_Versions) { | |
| 937 if keysByType_Versions[index].ElementsOrVersion > header.Element
sOrVersion { | |
| 938 index-- | |
| 939 } | |
| 940 expectedSize := keysByType_Versions[index].Size | |
| 941 if expectedSize != header.Size { | |
| 942 return &bindings.ValidationError{bindings.UnexpectedStru
ctHeader, | |
| 943 fmt.Sprintf("invalid struct header size: should
be %d, but was %d", expectedSize, header.Size), | |
| 944 } | |
| 945 } | |
| 946 } | |
| 947 if header.ElementsOrVersion >= 0 { | |
| 948 pointer0, err := decoder.ReadPointer() | |
| 949 if err != nil { | |
| 950 return err | |
| 951 } | |
| 952 if pointer0 == 0 { | |
| 953 s.Interfaces = nil | |
| 954 } else { | |
| 955 s.Interfaces = new([]string) | |
| 956 len0, err := decoder.StartArray(64) | |
| 957 if err != nil { | |
| 958 return err | |
| 959 } | |
| 960 (*s.Interfaces) = make([]string, len0) | |
| 961 for i0 := uint32(0); i0 < len0; i0++ { | |
| 962 pointer1, err := decoder.ReadPointer() | |
| 963 if err != nil { | |
| 964 return err | |
| 965 } | |
| 966 if pointer1 == 0 { | |
| 967 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 968 } else { | |
| 969 value1, err := decoder.ReadString() | |
| 970 if err != nil { | |
| 971 return err | |
| 972 } | |
| 973 (*s.Interfaces)[i0] = value1 | |
| 974 } | |
| 975 } | |
| 976 if err := decoder.Finish(); err != nil { | |
| 977 return err | |
| 978 } | |
| 979 } | |
| 980 } | |
| 981 if header.ElementsOrVersion >= 0 { | |
| 982 pointer0, err := decoder.ReadPointer() | |
| 983 if err != nil { | |
| 984 return err | |
| 985 } | |
| 986 if pointer0 == 0 { | |
| 987 s.Structs = nil | |
| 988 } else { | |
| 989 s.Structs = new([]string) | |
| 990 len0, err := decoder.StartArray(64) | |
| 991 if err != nil { | |
| 992 return err | |
| 993 } | |
| 994 (*s.Structs) = make([]string, len0) | |
| 995 for i0 := uint32(0); i0 < len0; i0++ { | |
| 996 pointer1, err := decoder.ReadPointer() | |
| 997 if err != nil { | |
| 998 return err | |
| 999 } | |
| 1000 if pointer1 == 0 { | |
| 1001 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 1002 } else { | |
| 1003 value1, err := decoder.ReadString() | |
| 1004 if err != nil { | |
| 1005 return err | |
| 1006 } | |
| 1007 (*s.Structs)[i0] = value1 | |
| 1008 } | |
| 1009 } | |
| 1010 if err := decoder.Finish(); err != nil { | |
| 1011 return err | |
| 1012 } | |
| 1013 } | |
| 1014 } | |
| 1015 if header.ElementsOrVersion >= 0 { | |
| 1016 pointer0, err := decoder.ReadPointer() | |
| 1017 if err != nil { | |
| 1018 return err | |
| 1019 } | |
| 1020 if pointer0 == 0 { | |
| 1021 s.Unions = nil | |
| 1022 } else { | |
| 1023 s.Unions = new([]string) | |
| 1024 len0, err := decoder.StartArray(64) | |
| 1025 if err != nil { | |
| 1026 return err | |
| 1027 } | |
| 1028 (*s.Unions) = make([]string, len0) | |
| 1029 for i0 := uint32(0); i0 < len0; i0++ { | |
| 1030 pointer1, err := decoder.ReadPointer() | |
| 1031 if err != nil { | |
| 1032 return err | |
| 1033 } | |
| 1034 if pointer1 == 0 { | |
| 1035 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 1036 } else { | |
| 1037 value1, err := decoder.ReadString() | |
| 1038 if err != nil { | |
| 1039 return err | |
| 1040 } | |
| 1041 (*s.Unions)[i0] = value1 | |
| 1042 } | |
| 1043 } | |
| 1044 if err := decoder.Finish(); err != nil { | |
| 1045 return err | |
| 1046 } | |
| 1047 } | |
| 1048 } | |
| 1049 if header.ElementsOrVersion >= 0 { | |
| 1050 pointer0, err := decoder.ReadPointer() | |
| 1051 if err != nil { | |
| 1052 return err | |
| 1053 } | |
| 1054 if pointer0 == 0 { | |
| 1055 s.TopLevelEnums = nil | |
| 1056 } else { | |
| 1057 s.TopLevelEnums = new([]string) | |
| 1058 len0, err := decoder.StartArray(64) | |
| 1059 if err != nil { | |
| 1060 return err | |
| 1061 } | |
| 1062 (*s.TopLevelEnums) = make([]string, len0) | |
| 1063 for i0 := uint32(0); i0 < len0; i0++ { | |
| 1064 pointer1, err := decoder.ReadPointer() | |
| 1065 if err != nil { | |
| 1066 return err | |
| 1067 } | |
| 1068 if pointer1 == 0 { | |
| 1069 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 1070 } else { | |
| 1071 value1, err := decoder.ReadString() | |
| 1072 if err != nil { | |
| 1073 return err | |
| 1074 } | |
| 1075 (*s.TopLevelEnums)[i0] = value1 | |
| 1076 } | |
| 1077 } | |
| 1078 if err := decoder.Finish(); err != nil { | |
| 1079 return err | |
| 1080 } | |
| 1081 } | |
| 1082 } | |
| 1083 if header.ElementsOrVersion >= 0 { | |
| 1084 pointer0, err := decoder.ReadPointer() | |
| 1085 if err != nil { | |
| 1086 return err | |
| 1087 } | |
| 1088 if pointer0 == 0 { | |
| 1089 s.EmbeddedEnums = nil | |
| 1090 } else { | |
| 1091 s.EmbeddedEnums = new([]string) | |
| 1092 len0, err := decoder.StartArray(64) | |
| 1093 if err != nil { | |
| 1094 return err | |
| 1095 } | |
| 1096 (*s.EmbeddedEnums) = make([]string, len0) | |
| 1097 for i0 := uint32(0); i0 < len0; i0++ { | |
| 1098 pointer1, err := decoder.ReadPointer() | |
| 1099 if err != nil { | |
| 1100 return err | |
| 1101 } | |
| 1102 if pointer1 == 0 { | |
| 1103 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 1104 } else { | |
| 1105 value1, err := decoder.ReadString() | |
| 1106 if err != nil { | |
| 1107 return err | |
| 1108 } | |
| 1109 (*s.EmbeddedEnums)[i0] = value1 | |
| 1110 } | |
| 1111 } | |
| 1112 if err := decoder.Finish(); err != nil { | |
| 1113 return err | |
| 1114 } | |
| 1115 } | |
| 1116 } | |
| 1117 if header.ElementsOrVersion >= 0 { | |
| 1118 pointer0, err := decoder.ReadPointer() | |
| 1119 if err != nil { | |
| 1120 return err | |
| 1121 } | |
| 1122 if pointer0 == 0 { | |
| 1123 s.TopLevelConstants = nil | |
| 1124 } else { | |
| 1125 s.TopLevelConstants = new([]string) | |
| 1126 len0, err := decoder.StartArray(64) | |
| 1127 if err != nil { | |
| 1128 return err | |
| 1129 } | |
| 1130 (*s.TopLevelConstants) = make([]string, len0) | |
| 1131 for i0 := uint32(0); i0 < len0; i0++ { | |
| 1132 pointer1, err := decoder.ReadPointer() | |
| 1133 if err != nil { | |
| 1134 return err | |
| 1135 } | |
| 1136 if pointer1 == 0 { | |
| 1137 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 1138 } else { | |
| 1139 value1, err := decoder.ReadString() | |
| 1140 if err != nil { | |
| 1141 return err | |
| 1142 } | |
| 1143 (*s.TopLevelConstants)[i0] = value1 | |
| 1144 } | |
| 1145 } | |
| 1146 if err := decoder.Finish(); err != nil { | |
| 1147 return err | |
| 1148 } | |
| 1149 } | |
| 1150 } | |
| 1151 if header.ElementsOrVersion >= 0 { | |
| 1152 pointer0, err := decoder.ReadPointer() | |
| 1153 if err != nil { | |
| 1154 return err | |
| 1155 } | |
| 1156 if pointer0 == 0 { | |
| 1157 s.EmbeddedConstants = nil | |
| 1158 } else { | |
| 1159 s.EmbeddedConstants = new([]string) | |
| 1160 len0, err := decoder.StartArray(64) | |
| 1161 if err != nil { | |
| 1162 return err | |
| 1163 } | |
| 1164 (*s.EmbeddedConstants) = make([]string, len0) | |
| 1165 for i0 := uint32(0); i0 < len0; i0++ { | |
| 1166 pointer1, err := decoder.ReadPointer() | |
| 1167 if err != nil { | |
| 1168 return err | |
| 1169 } | |
| 1170 if pointer1 == 0 { | |
| 1171 return &bindings.ValidationError{binding
s.UnexpectedNullPointer, "unexpected null pointer"} | |
| 1172 } else { | |
| 1173 value1, err := decoder.ReadString() | |
| 1174 if err != nil { | |
| 1175 return err | |
| 1176 } | |
| 1177 (*s.EmbeddedConstants)[i0] = value1 | |
| 1178 } | |
| 1179 } | |
| 1180 if err := decoder.Finish(); err != nil { | |
| 1181 return err | |
| 1182 } | |
| 1183 } | |
| 1184 } | |
| 1185 if err := decoder.Finish(); err != nil { | |
| 1186 return err | |
| 1187 } | |
| 1188 return nil | |
| 1189 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1930603004:
mojom: move mojom/mojom_tool/generated -> mojom/generated. Update consumers (Closed)
Base URL: https://github.com/domokit/mojo.git@master