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