+1287 -715

api/yoten/cbor_gen.go

View file Reviewed

··· 18 18 var _ = math.E 19 19 var _ = sort.Sort 20 20 21 21 - func (t *ActivityDef) MarshalCBOR(w io.Writer) error { 21 21 + func (t *ActorProfile) MarshalCBOR(w io.Writer) error { 22 22 if t == nil { 23 23 _, err := w.Write(cbg.CborNull) 24 24 return err 25 25 } 26 26 27 27 cw := cbg.NewCborWriter(w) 28 28 - 29 29 - if _, err := cw.Write([]byte{165}); err != nil { 30 30 - return err 31 31 - } 28 28 + fieldCount := 6 32 29 33 33 - // t.Name (string) (string) 34 34 - if len("name") > 1000000 { 35 35 - return xerrors.Errorf("Value in field \"name\" was too long") 30 30 + if t.Description == nil { 31 31 + fieldCount-- 36 32 } 37 33 38 38 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 39 39 - return err 40 40 - } 41 41 - if _, err := cw.WriteString(string("name")); err != nil { 42 42 - return err 34 34 + if t.Languages == nil { 35 35 + fieldCount-- 43 36 } 44 37 45 45 - if len(t.Name) > 1000000 { 46 46 - return xerrors.Errorf("Value in field t.Name was too long") 38 38 + if t.Location == nil { 39 39 + fieldCount-- 47 40 } 48 41 49 49 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 50 50 - return err 51 51 - } 52 52 - if _, err := cw.WriteString(string(t.Name)); err != nil { 42 42 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 53 43 return err 54 44 } 55 45 ··· 65 55 return err 66 56 } 67 57 68 68 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.activity.def"))); err != nil { 58 58 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.actor.profile"))); err != nil { 69 59 return err 70 60 } 71 71 - if _, err := cw.WriteString(string("app.yoten.activity.def")); err != nil { 61 61 + if _, err := cw.WriteString(string("app.yoten.actor.profile")); err != nil { 72 62 return err 73 63 } 74 64 65 65 + // t.Location (string) (string) 66 66 + if t.Location != nil { 67 67 + 68 68 + if len("location") > 1000000 { 69 69 + return xerrors.Errorf("Value in field \"location\" was too long") 70 70 + } 71 71 + 72 72 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil { 73 73 + return err 74 74 + } 75 75 + if _, err := cw.WriteString(string("location")); err != nil { 76 76 + return err 77 77 + } 78 78 + 79 79 + if t.Location == nil { 80 80 + if _, err := cw.Write(cbg.CborNull); err != nil { 81 81 + return err 82 82 + } 83 83 + } else { 84 84 + if len(*t.Location) > 1000000 { 85 85 + return xerrors.Errorf("Value in field t.Location was too long") 86 86 + } 87 87 + 88 88 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil { 89 89 + return err 90 90 + } 91 91 + if _, err := cw.WriteString(string(*t.Location)); err != nil { 92 92 + return err 93 93 + } 94 94 + } 95 95 + } 96 96 + 75 97 // t.CreatedAt (string) (string) 76 98 if len("createdAt") > 1000000 { 77 99 return xerrors.Errorf("Value in field \"createdAt\" was too long") ··· 95 117 return err 96 118 } 97 119 98 98 - // t.Categories ([]string) (slice) 99 99 - if len("categories") > 1000000 { 100 100 - return xerrors.Errorf("Value in field \"categories\" was too long") 101 101 - } 120 120 + // t.Languages ([]string) (slice) 121 121 + if t.Languages != nil { 122 122 + 123 123 + if len("languages") > 1000000 { 124 124 + return xerrors.Errorf("Value in field \"languages\" was too long") 125 125 + } 126 126 + 127 127 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("languages"))); err != nil { 128 128 + return err 129 129 + } 130 130 + if _, err := cw.WriteString(string("languages")); err != nil { 131 131 + return err 132 132 + } 133 133 + 134 134 + if len(t.Languages) > 8192 { 135 135 + return xerrors.Errorf("Slice value in field t.Languages was too long") 136 136 + } 137 137 + 138 138 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Languages))); err != nil { 139 139 + return err 140 140 + } 141 141 + for _, v := range t.Languages { 142 142 + if len(v) > 1000000 { 143 143 + return xerrors.Errorf("Value in field v was too long") 144 144 + } 145 145 + 146 146 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 147 147 + return err 148 148 + } 149 149 + if _, err := cw.WriteString(string(v)); err != nil { 150 150 + return err 151 151 + } 102 152 103 103 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("categories"))); err != nil { 104 104 - return err 105 105 - } 106 106 - if _, err := cw.WriteString(string("categories")); err != nil { 107 107 - return err 153 153 + } 108 154 } 109 155 110 110 - if len(t.Categories) > 8192 { 111 111 - return xerrors.Errorf("Slice value in field t.Categories was too long") 112 112 - } 156 156 + // t.Description (string) (string) 157 157 + if t.Description != nil { 113 158 114 114 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Categories))); err != nil { 115 115 - return err 116 116 - } 117 117 - for _, v := range t.Categories { 118 118 - if len(v) > 1000000 { 119 119 - return xerrors.Errorf("Value in field v was too long") 159 159 + if len("description") > 1000000 { 160 160 + return xerrors.Errorf("Value in field \"description\" was too long") 120 161 } 121 162 122 122 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 163 163 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 123 164 return err 124 165 } 125 125 - if _, err := cw.WriteString(string(v)); err != nil { 166 166 + if _, err := cw.WriteString(string("description")); err != nil { 126 167 return err 127 168 } 128 169 170 170 + if t.Description == nil { 171 171 + if _, err := cw.Write(cbg.CborNull); err != nil { 172 172 + return err 173 173 + } 174 174 + } else { 175 175 + if len(*t.Description) > 1000000 { 176 176 + return xerrors.Errorf("Value in field t.Description was too long") 177 177 + } 178 178 + 179 179 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 180 180 + return err 181 181 + } 182 182 + if _, err := cw.WriteString(string(*t.Description)); err != nil { 183 183 + return err 184 184 + } 185 185 + } 129 186 } 130 187 131 131 - // t.Description (string) (string) 132 132 - if len("description") > 1000000 { 133 133 - return xerrors.Errorf("Value in field \"description\" was too long") 188 188 + // t.DisplayName (string) (string) 189 189 + if len("displayName") > 1000000 { 190 190 + return xerrors.Errorf("Value in field \"displayName\" was too long") 134 191 } 135 192 136 136 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 193 193 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("displayName"))); err != nil { 137 194 return err 138 195 } 139 139 - if _, err := cw.WriteString(string("description")); err != nil { 196 196 + if _, err := cw.WriteString(string("displayName")); err != nil { 140 197 return err 141 198 } 142 199 143 143 - if len(t.Description) > 1000000 { 144 144 - return xerrors.Errorf("Value in field t.Description was too long") 200 200 + if len(t.DisplayName) > 1000000 { 201 201 + return xerrors.Errorf("Value in field t.DisplayName was too long") 145 202 } 146 203 147 147 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil { 204 204 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DisplayName))); err != nil { 148 205 return err 149 206 } 150 150 - if _, err := cw.WriteString(string(t.Description)); err != nil { 207 207 + if _, err := cw.WriteString(string(t.DisplayName)); err != nil { 151 208 return err 152 209 } 153 210 return nil 154 211 } 155 212 156 156 - func (t *ActivityDef) UnmarshalCBOR(r io.Reader) (err error) { 157 157 - *t = ActivityDef{} 213 213 + func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) { 214 214 + *t = ActorProfile{} 158 215 159 216 cr := cbg.NewCborReader(r) 160 217 ··· 173 230 } 174 231 175 232 if extra > cbg.MaxLength { 176 176 - return fmt.Errorf("ActivityDef: map struct too large (%d)", extra) 233 233 + return fmt.Errorf("ActorProfile: map struct too large (%d)", extra) 177 234 } 178 235 179 236 n := extra ··· 194 251 } 195 252 196 253 switch string(nameBuf[:nameLen]) { 197 197 - // t.Name (string) (string) 198 198 - case "name": 254 254 + // t.LexiconTypeID (string) (string) 255 255 + case "$type": 199 256 200 257 { 201 258 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 203 260 return err 204 261 } 205 262 206 206 - t.Name = string(sval) 263 263 + t.LexiconTypeID = string(sval) 207 264 } 208 208 - // t.LexiconTypeID (string) (string) 209 209 - case "$type": 265 265 + // t.Location (string) (string) 266 266 + case "location": 210 267 211 268 { 212 212 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 269 269 + b, err := cr.ReadByte() 213 270 if err != nil { 214 271 return err 215 272 } 273 273 + if b != cbg.CborNull[0] { 274 274 + if err := cr.UnreadByte(); err != nil { 275 275 + return err 276 276 + } 216 277 217 217 - t.LexiconTypeID = string(sval) 278 278 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 279 279 + if err != nil { 280 280 + return err 281 281 + } 282 282 + 283 283 + t.Location = (*string)(&sval) 284 284 + } 218 285 } 219 286 // t.CreatedAt (string) (string) 220 287 case "createdAt": ··· 227 294 228 295 t.CreatedAt = string(sval) 229 296 } 230 230 - // t.Categories ([]string) (slice) 231 231 - case "categories": 297 297 + // t.Languages ([]string) (slice) 298 298 + case "languages": 232 299 233 300 maj, extra, err = cr.ReadHeader() 234 301 if err != nil { ··· 236 303 } 237 304 238 305 if extra > 8192 { 239 239 - return fmt.Errorf("t.Categories: array too large (%d)", extra) 306 306 + return fmt.Errorf("t.Languages: array too large (%d)", extra) 240 307 } 241 308 242 309 if maj != cbg.MajArray { ··· 244 311 } 245 312 246 313 if extra > 0 { 247 247 - t.Categories = make([]string, extra) 314 314 + t.Languages = make([]string, extra) 248 315 } 249 316 250 317 for i := 0; i < int(extra); i++ { ··· 262 329 return err 263 330 } 264 331 265 265 - t.Categories[i] = string(sval) 332 332 + t.Languages[i] = string(sval) 266 333 } 267 334 268 335 } ··· 271 338 case "description": 272 339 273 340 { 341 341 + b, err := cr.ReadByte() 342 342 + if err != nil { 343 343 + return err 344 344 + } 345 345 + if b != cbg.CborNull[0] { 346 346 + if err := cr.UnreadByte(); err != nil { 347 347 + return err 348 348 + } 349 349 + 350 350 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 351 351 + if err != nil { 352 352 + return err 353 353 + } 354 354 + 355 355 + t.Description = (*string)(&sval) 356 356 + } 357 357 + } 358 358 + // t.DisplayName (string) (string) 359 359 + case "displayName": 360 360 + 361 361 + { 274 362 sval, err := cbg.ReadStringWithMax(cr, 1000000) 275 363 if err != nil { 276 364 return err 277 365 } 278 366 279 279 - t.Description = string(sval) 367 367 + t.DisplayName = string(sval) 280 368 } 281 369 282 370 default: ··· 289 377 290 378 return nil 291 379 } 292 292 - func (t *ActorProfile) MarshalCBOR(w io.Writer) error { 380 380 + func (t *FeedSession) MarshalCBOR(w io.Writer) error { 293 381 if t == nil { 294 382 _, err := w.Write(cbg.CborNull) 295 383 return err 296 384 } 297 385 298 386 cw := cbg.NewCborWriter(w) 299 299 - fieldCount := 6 387 387 + fieldCount := 9 300 388 301 389 if t.Description == nil { 302 390 fieldCount-- 303 391 } 304 392 305 305 - if t.Languages == nil { 393 393 + if t.PredefinedActivityName == nil { 306 394 fieldCount-- 307 395 } 308 396 309 309 - if t.Location == nil { 397 397 + if t.Resource == nil { 398 398 + fieldCount-- 399 399 + } 400 400 + 401 401 + if t.UserActivityRef == nil { 310 402 fieldCount-- 311 403 } 312 404 ··· 314 406 return err 315 407 } 316 408 409 409 + // t.Date (string) (string) 410 410 + if len("date") > 1000000 { 411 411 + return xerrors.Errorf("Value in field \"date\" was too long") 412 412 + } 413 413 + 414 414 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("date"))); err != nil { 415 415 + return err 416 416 + } 417 417 + if _, err := cw.WriteString(string("date")); err != nil { 418 418 + return err 419 419 + } 420 420 + 421 421 + if len(t.Date) > 1000000 { 422 422 + return xerrors.Errorf("Value in field t.Date was too long") 423 423 + } 424 424 + 425 425 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Date))); err != nil { 426 426 + return err 427 427 + } 428 428 + if _, err := cw.WriteString(string(t.Date)); err != nil { 429 429 + return err 430 430 + } 431 431 + 317 432 // t.LexiconTypeID (string) (string) 318 433 if len("$type") > 1000000 { 319 434 return xerrors.Errorf("Value in field \"$type\" was too long") ··· 326 441 return err 327 442 } 328 443 329 329 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.actor.profile"))); err != nil { 444 444 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.feed.session"))); err != nil { 330 445 return err 331 446 } 332 332 - if _, err := cw.WriteString(string("app.yoten.actor.profile")); err != nil { 447 447 + if _, err := cw.WriteString(string("app.yoten.feed.session")); err != nil { 333 448 return err 334 449 } 335 450 336 336 - // t.Location (string) (string) 337 337 - if t.Location != nil { 451 451 + // t.Duration (int64) (int64) 452 452 + if len("duration") > 1000000 { 453 453 + return xerrors.Errorf("Value in field \"duration\" was too long") 454 454 + } 455 455 + 456 456 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("duration"))); err != nil { 457 457 + return err 458 458 + } 459 459 + if _, err := cw.WriteString(string("duration")); err != nil { 460 460 + return err 461 461 + } 462 462 + 463 463 + if t.Duration >= 0 { 464 464 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Duration)); err != nil { 465 465 + return err 466 466 + } 467 467 + } else { 468 468 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Duration-1)); err != nil { 469 469 + return err 470 470 + } 471 471 + } 472 472 + 473 473 + // t.Resource (yoten.FeedResource) (struct) 474 474 + if t.Resource != nil { 338 475 339 339 - if len("location") > 1000000 { 340 340 - return xerrors.Errorf("Value in field \"location\" was too long") 476 476 + if len("resource") > 1000000 { 477 477 + return xerrors.Errorf("Value in field \"resource\" was too long") 341 478 } 342 479 343 343 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("location"))); err != nil { 480 480 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("resource"))); err != nil { 344 481 return err 345 482 } 346 346 - if _, err := cw.WriteString(string("location")); err != nil { 483 483 + if _, err := cw.WriteString(string("resource")); err != nil { 347 484 return err 348 485 } 349 486 350 350 - if t.Location == nil { 351 351 - if _, err := cw.Write(cbg.CborNull); err != nil { 352 352 - return err 353 353 - } 354 354 - } else { 355 355 - if len(*t.Location) > 1000000 { 356 356 - return xerrors.Errorf("Value in field t.Location was too long") 357 357 - } 358 358 - 359 359 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Location))); err != nil { 360 360 - return err 361 361 - } 362 362 - if _, err := cw.WriteString(string(*t.Location)); err != nil { 363 363 - return err 364 364 - } 487 487 + if err := t.Resource.MarshalCBOR(cw); err != nil { 488 488 + return err 365 489 } 366 490 } 367 491 ··· 388 512 return err 389 513 } 390 514 391 391 - // t.Languages ([]string) (slice) 392 392 - if t.Languages != nil { 393 393 - 394 394 - if len("languages") > 1000000 { 395 395 - return xerrors.Errorf("Value in field \"languages\" was too long") 396 396 - } 397 397 - 398 398 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("languages"))); err != nil { 399 399 - return err 400 400 - } 401 401 - if _, err := cw.WriteString(string("languages")); err != nil { 402 402 - return err 403 403 - } 404 404 - 405 405 - if len(t.Languages) > 8192 { 406 406 - return xerrors.Errorf("Slice value in field t.Languages was too long") 407 407 - } 408 408 - 409 409 - if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Languages))); err != nil { 410 410 - return err 411 411 - } 412 412 - for _, v := range t.Languages { 413 413 - if len(v) > 1000000 { 414 414 - return xerrors.Errorf("Value in field v was too long") 415 415 - } 416 416 - 417 417 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 418 418 - return err 419 419 - } 420 420 - if _, err := cw.WriteString(string(v)); err != nil { 421 421 - return err 422 422 - } 423 423 - 424 424 - } 425 425 - } 426 426 - 427 515 // t.Description (string) (string) 428 516 if t.Description != nil { 429 517 ··· 456 544 } 457 545 } 458 546 459 459 - // t.DisplayName (string) (string) 460 460 - if len("displayName") > 1000000 { 461 461 - return xerrors.Errorf("Value in field \"displayName\" was too long") 547 547 + // t.LanguageCode (string) (string) 548 548 + if len("languageCode") > 1000000 { 549 549 + return xerrors.Errorf("Value in field \"languageCode\" was too long") 462 550 } 463 551 464 464 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("displayName"))); err != nil { 552 552 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("languageCode"))); err != nil { 465 553 return err 466 554 } 467 467 - if _, err := cw.WriteString(string("displayName")); err != nil { 555 555 + if _, err := cw.WriteString(string("languageCode")); err != nil { 468 556 return err 469 557 } 470 558 471 471 - if len(t.DisplayName) > 1000000 { 472 472 - return xerrors.Errorf("Value in field t.DisplayName was too long") 559 559 + if len(t.LanguageCode) > 1000000 { 560 560 + return xerrors.Errorf("Value in field t.LanguageCode was too long") 473 561 } 474 562 475 475 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.DisplayName))); err != nil { 563 563 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.LanguageCode))); err != nil { 476 564 return err 477 565 } 478 478 - if _, err := cw.WriteString(string(t.DisplayName)); err != nil { 566 566 + if _, err := cw.WriteString(string(t.LanguageCode)); err != nil { 479 567 return err 480 568 } 569 569 + 570 570 + // t.UserActivityRef (yoten.ActivityDef) (struct) 571 571 + if t.UserActivityRef != nil { 572 572 + 573 573 + if len("userActivityRef") > 1000000 { 574 574 + return xerrors.Errorf("Value in field \"userActivityRef\" was too long") 575 575 + } 576 576 + 577 577 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("userActivityRef"))); err != nil { 578 578 + return err 579 579 + } 580 580 + if _, err := cw.WriteString(string("userActivityRef")); err != nil { 581 581 + return err 582 582 + } 583 583 + 584 584 + if err := t.UserActivityRef.MarshalCBOR(cw); err != nil { 585 585 + return err 586 586 + } 587 587 + } 588 588 + 589 589 + // t.PredefinedActivityName (string) (string) 590 590 + if t.PredefinedActivityName != nil { 591 591 + 592 592 + if len("predefinedActivityName") > 1000000 { 593 593 + return xerrors.Errorf("Value in field \"predefinedActivityName\" was too long") 594 594 + } 595 595 + 596 596 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("predefinedActivityName"))); err != nil { 597 597 + return err 598 598 + } 599 599 + if _, err := cw.WriteString(string("predefinedActivityName")); err != nil { 600 600 + return err 601 601 + } 602 602 + 603 603 + if t.PredefinedActivityName == nil { 604 604 + if _, err := cw.Write(cbg.CborNull); err != nil { 605 605 + return err 606 606 + } 607 607 + } else { 608 608 + if len(*t.PredefinedActivityName) > 1000000 { 609 609 + return xerrors.Errorf("Value in field t.PredefinedActivityName was too long") 610 610 + } 611 611 + 612 612 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.PredefinedActivityName))); err != nil { 613 613 + return err 614 614 + } 615 615 + if _, err := cw.WriteString(string(*t.PredefinedActivityName)); err != nil { 616 616 + return err 617 617 + } 618 618 + } 619 619 + } 481 620 return nil 482 621 } 483 622 484 484 - func (t *ActorProfile) UnmarshalCBOR(r io.Reader) (err error) { 485 485 - *t = ActorProfile{} 623 623 + func (t *FeedSession) UnmarshalCBOR(r io.Reader) (err error) { 624 624 + *t = FeedSession{} 486 625 487 626 cr := cbg.NewCborReader(r) 488 627 ··· 501 640 } 502 641 503 642 if extra > cbg.MaxLength { 504 504 - return fmt.Errorf("ActorProfile: map struct too large (%d)", extra) 643 643 + return fmt.Errorf("FeedSession: map struct too large (%d)", extra) 505 644 } 506 645 507 646 n := extra 508 647 509 509 - nameBuf := make([]byte, 11) 648 648 + nameBuf := make([]byte, 22) 510 649 for i := uint64(0); i < n; i++ { 511 650 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 512 651 if err != nil { ··· 522 661 } 523 662 524 663 switch string(nameBuf[:nameLen]) { 525 525 - // t.LexiconTypeID (string) (string) 664 664 + // t.Date (string) (string) 665 665 + case "date": 666 666 + 667 667 + { 668 668 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 669 669 + if err != nil { 670 670 + return err 671 671 + } 672 672 + 673 673 + t.Date = string(sval) 674 674 + } 675 675 + // t.LexiconTypeID (string) (string) 526 676 case "$type": 527 677 528 678 { ··· 533 683 534 684 t.LexiconTypeID = string(sval) 535 685 } 536 536 - // t.Location (string) (string) 537 537 - case "location": 686 686 + // t.Duration (int64) (int64) 687 687 + case "duration": 688 688 + { 689 689 + maj, extra, err := cr.ReadHeader() 690 690 + if err != nil { 691 691 + return err 692 692 + } 693 693 + var extraI int64 694 694 + switch maj { 695 695 + case cbg.MajUnsignedInt: 696 696 + extraI = int64(extra) 697 697 + if extraI < 0 { 698 698 + return fmt.Errorf("int64 positive overflow") 699 699 + } 700 700 + case cbg.MajNegativeInt: 701 701 + extraI = int64(extra) 702 702 + if extraI < 0 { 703 703 + return fmt.Errorf("int64 negative overflow") 704 704 + } 705 705 + extraI = -1 - extraI 706 706 + default: 707 707 + return fmt.Errorf("wrong type for int64 field: %d", maj) 708 708 + } 709 709 + 710 710 + t.Duration = int64(extraI) 711 711 + } 712 712 + // t.Resource (yoten.FeedResource) (struct) 713 713 + case "resource": 538 714 539 715 { 716 716 + 540 717 b, err := cr.ReadByte() 541 718 if err != nil { 542 719 return err ··· 545 722 if err := cr.UnreadByte(); err != nil { 546 723 return err 547 724 } 548 548 - 549 549 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 550 550 - if err != nil { 551 551 - return err 725 725 + t.Resource = new(FeedResource) 726 726 + if err := t.Resource.UnmarshalCBOR(cr); err != nil { 727 727 + return xerrors.Errorf("unmarshaling t.Resource pointer: %w", err) 552 728 } 729 729 + } 553 730 554 554 - t.Location = (*string)(&sval) 555 555 - } 556 731 } 557 732 // t.CreatedAt (string) (string) 558 733 case "createdAt": ··· 565 740 566 741 t.CreatedAt = string(sval) 567 742 } 568 568 - // t.Languages ([]string) (slice) 569 569 - case "languages": 743 743 + // t.Description (string) (string) 744 744 + case "description": 745 745 + 746 746 + { 747 747 + b, err := cr.ReadByte() 748 748 + if err != nil { 749 749 + return err 750 750 + } 751 751 + if b != cbg.CborNull[0] { 752 752 + if err := cr.UnreadByte(); err != nil { 753 753 + return err 754 754 + } 570 755 571 571 - maj, extra, err = cr.ReadHeader() 572 572 - if err != nil { 573 573 - return err 574 574 - } 756 756 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 757 757 + if err != nil { 758 758 + return err 759 759 + } 575 760 576 576 - if extra > 8192 { 577 577 - return fmt.Errorf("t.Languages: array too large (%d)", extra) 761 761 + t.Description = (*string)(&sval) 762 762 + } 578 763 } 764 764 + // t.LanguageCode (string) (string) 765 765 + case "languageCode": 579 766 580 580 - if maj != cbg.MajArray { 581 581 - return fmt.Errorf("expected cbor array") 582 582 - } 767 767 + { 768 768 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 769 769 + if err != nil { 770 770 + return err 771 771 + } 583 772 584 584 - if extra > 0 { 585 585 - t.Languages = make([]string, extra) 773 773 + t.LanguageCode = string(sval) 586 774 } 775 775 + // t.UserActivityRef (yoten.ActivityDef) (struct) 776 776 + case "userActivityRef": 587 777 588 588 - for i := 0; i < int(extra); i++ { 589 589 - { 590 590 - var maj byte 591 591 - var extra uint64 592 592 - var err error 593 593 - _ = maj 594 594 - _ = extra 595 595 - _ = err 778 778 + { 596 779 597 597 - { 598 598 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 599 599 - if err != nil { 600 600 - return err 601 601 - } 602 602 - 603 603 - t.Languages[i] = string(sval) 780 780 + b, err := cr.ReadByte() 781 781 + if err != nil { 782 782 + return err 783 783 + } 784 784 + if b != cbg.CborNull[0] { 785 785 + if err := cr.UnreadByte(); err != nil { 786 786 + return err 604 787 } 605 605 - 788 788 + t.UserActivityRef = new(ActivityDef) 789 789 + if err := t.UserActivityRef.UnmarshalCBOR(cr); err != nil { 790 790 + return xerrors.Errorf("unmarshaling t.UserActivityRef pointer: %w", err) 791 791 + } 606 792 } 793 793 + 607 794 } 608 608 - // t.Description (string) (string) 609 609 - case "description": 795 795 + // t.PredefinedActivityName (string) (string) 796 796 + case "predefinedActivityName": 610 797 611 798 { 612 799 b, err := cr.ReadByte() ··· 623 810 return err 624 811 } 625 812 626 626 - t.Description = (*string)(&sval) 813 813 + t.PredefinedActivityName = (*string)(&sval) 627 814 } 628 628 - } 629 629 - // t.DisplayName (string) (string) 630 630 - case "displayName": 631 631 - 632 632 - { 633 633 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 634 634 - if err != nil { 635 635 - return err 636 636 - } 637 637 - 638 638 - t.DisplayName = string(sval) 639 815 } 640 816 641 817 default: ··· 648 824 649 825 return nil 650 826 } 651 651 - func (t *FeedComment) MarshalCBOR(w io.Writer) error { 827 827 + func (t *FeedResource) MarshalCBOR(w io.Writer) error { 652 828 if t == nil { 653 829 _, err := w.Write(cbg.CborNull) 654 830 return err 655 831 } 656 832 657 833 cw := cbg.NewCborWriter(w) 658 658 - fieldCount := 5 834 834 + fieldCount := 7 659 835 660 660 - if t.Reply == nil { 836 836 + if t.Link == nil { 661 837 fieldCount-- 662 838 } 663 839 ··· 665 841 return err 666 842 } 667 843 668 668 - // t.Body (string) (string) 669 669 - if len("body") > 1000000 { 670 670 - return xerrors.Errorf("Value in field \"body\" was too long") 844 844 + // t.Link (string) (string) 845 845 + if t.Link != nil { 846 846 + 847 847 + if len("link") > 1000000 { 848 848 + return xerrors.Errorf("Value in field \"link\" was too long") 849 849 + } 850 850 + 851 851 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("link"))); err != nil { 852 852 + return err 853 853 + } 854 854 + if _, err := cw.WriteString(string("link")); err != nil { 855 855 + return err 856 856 + } 857 857 + 858 858 + if t.Link == nil { 859 859 + if _, err := cw.Write(cbg.CborNull); err != nil { 860 860 + return err 861 861 + } 862 862 + } else { 863 863 + if len(*t.Link) > 1000000 { 864 864 + return xerrors.Errorf("Value in field t.Link was too long") 865 865 + } 866 866 + 867 867 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Link))); err != nil { 868 868 + return err 869 869 + } 870 870 + if _, err := cw.WriteString(string(*t.Link)); err != nil { 871 871 + return err 872 872 + } 873 873 + } 671 874 } 672 875 673 673 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 876 876 + // t.Type (string) (string) 877 877 + if len("type") > 1000000 { 878 878 + return xerrors.Errorf("Value in field \"type\" was too long") 879 879 + } 880 880 + 881 881 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil { 674 882 return err 675 883 } 676 676 - if _, err := cw.WriteString(string("body")); err != nil { 884 884 + if _, err := cw.WriteString(string("type")); err != nil { 677 885 return err 678 886 } 679 887 680 680 - if len(t.Body) > 1000000 { 681 681 - return xerrors.Errorf("Value in field t.Body was too long") 888 888 + if len(t.Type) > 1000000 { 889 889 + return xerrors.Errorf("Value in field t.Type was too long") 682 890 } 683 891 684 684 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 892 892 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil { 685 893 return err 686 894 } 687 687 - if _, err := cw.WriteString(string(t.Body)); err != nil { 895 895 + if _, err := cw.WriteString(string(t.Type)); err != nil { 688 896 return err 689 897 } 690 898 ··· 700 908 return err 701 909 } 702 910 703 703 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.feed.comment"))); err != nil { 911 911 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.feed.resource"))); err != nil { 704 912 return err 705 913 } 706 706 - if _, err := cw.WriteString(string("app.yoten.feed.comment")); err != nil { 914 914 + if _, err := cw.WriteString(string("app.yoten.feed.resource")); err != nil { 707 915 return err 708 916 } 709 917 710 710 - // t.Reply (yoten.FeedComment_Reply) (struct) 711 711 - if t.Reply != nil { 918 918 + // t.Title (string) (string) 919 919 + if len("title") > 1000000 { 920 920 + return xerrors.Errorf("Value in field \"title\" was too long") 921 921 + } 712 922 713 713 - if len("reply") > 1000000 { 714 714 - return xerrors.Errorf("Value in field \"reply\" was too long") 715 715 - } 923 923 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 924 924 + return err 925 925 + } 926 926 + if _, err := cw.WriteString(string("title")); err != nil { 927 927 + return err 928 928 + } 716 929 717 717 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reply"))); err != nil { 718 718 - return err 719 719 - } 720 720 - if _, err := cw.WriteString(string("reply")); err != nil { 721 721 - return err 722 722 - } 930 930 + if len(t.Title) > 1000000 { 931 931 + return xerrors.Errorf("Value in field t.Title was too long") 932 932 + } 723 933 724 724 - if err := t.Reply.MarshalCBOR(cw); err != nil { 725 725 - return err 726 726 - } 934 934 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil { 935 935 + return err 936 936 + } 937 937 + if _, err := cw.WriteString(string(t.Title)); err != nil { 938 938 + return err 727 939 } 728 940 729 729 - // t.Subject (string) (string) 730 730 - if len("subject") > 1000000 { 731 731 - return xerrors.Errorf("Value in field \"subject\" was too long") 941 941 + // t.Author (string) (string) 942 942 + if len("author") > 1000000 { 943 943 + return xerrors.Errorf("Value in field \"author\" was too long") 732 944 } 733 945 734 734 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 946 946 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("author"))); err != nil { 735 947 return err 736 948 } 737 737 - if _, err := cw.WriteString(string("subject")); err != nil { 949 949 + if _, err := cw.WriteString(string("author")); err != nil { 738 950 return err 739 951 } 740 952 741 741 - if len(t.Subject) > 1000000 { 742 742 - return xerrors.Errorf("Value in field t.Subject was too long") 953 953 + if len(t.Author) > 1000000 { 954 954 + return xerrors.Errorf("Value in field t.Author was too long") 743 955 } 744 956 745 745 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 957 957 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Author))); err != nil { 746 958 return err 747 959 } 748 748 - if _, err := cw.WriteString(string(t.Subject)); err != nil { 960 960 + if _, err := cw.WriteString(string(t.Author)); err != nil { 749 961 return err 750 962 } 751 963 ··· 771 983 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 772 984 return err 773 985 } 986 986 + 987 987 + // t.Description (string) (string) 988 988 + if len("description") > 1000000 { 989 989 + return xerrors.Errorf("Value in field \"description\" was too long") 990 990 + } 991 991 + 992 992 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 993 993 + return err 994 994 + } 995 995 + if _, err := cw.WriteString(string("description")); err != nil { 996 996 + return err 997 997 + } 998 998 + 999 999 + if len(t.Description) > 1000000 { 1000 1000 + return xerrors.Errorf("Value in field t.Description was too long") 1001 1001 + } 1002 1002 + 1003 1003 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil { 1004 1004 + return err 1005 1005 + } 1006 1006 + if _, err := cw.WriteString(string(t.Description)); err != nil { 1007 1007 + return err 1008 1008 + } 774 1009 return nil 775 1010 } 776 1011 777 777 - func (t *FeedComment) UnmarshalCBOR(r io.Reader) (err error) { 778 778 - *t = FeedComment{} 1012 1012 + func (t *FeedResource) UnmarshalCBOR(r io.Reader) (err error) { 1013 1013 + *t = FeedResource{} 779 1014 780 1015 cr := cbg.NewCborReader(r) 781 1016 ··· 794 1029 } 795 1030 796 1031 if extra > cbg.MaxLength { 797 797 - return fmt.Errorf("FeedComment: map struct too large (%d)", extra) 1032 1032 + return fmt.Errorf("FeedResource: map struct too large (%d)", extra) 798 1033 } 799 1034 800 1035 n := extra 801 1036 802 802 - nameBuf := make([]byte, 9) 1037 1037 + nameBuf := make([]byte, 11) 803 1038 for i := uint64(0); i < n; i++ { 804 1039 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 805 1040 if err != nil { ··· 815 1050 } 816 1051 817 1052 switch string(nameBuf[:nameLen]) { 818 818 - // t.Body (string) (string) 819 819 - case "body": 1053 1053 + // t.Link (string) (string) 1054 1054 + case "link": 1055 1055 + 1056 1056 + { 1057 1057 + b, err := cr.ReadByte() 1058 1058 + if err != nil { 1059 1059 + return err 1060 1060 + } 1061 1061 + if b != cbg.CborNull[0] { 1062 1062 + if err := cr.UnreadByte(); err != nil { 1063 1063 + return err 1064 1064 + } 1065 1065 + 1066 1066 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1067 1067 + if err != nil { 1068 1068 + return err 1069 1069 + } 1070 1070 + 1071 1071 + t.Link = (*string)(&sval) 1072 1072 + } 1073 1073 + } 1074 1074 + // t.Type (string) (string) 1075 1075 + case "type": 820 1076 821 1077 { 822 1078 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 824 1080 return err 825 1081 } 826 1082 827 827 - t.Body = string(sval) 1083 1083 + t.Type = string(sval) 828 1084 } 829 1085 // t.LexiconTypeID (string) (string) 830 1086 case "$type": ··· 837 1093 838 1094 t.LexiconTypeID = string(sval) 839 1095 } 840 840 - // t.Reply (yoten.FeedComment_Reply) (struct) 841 841 - case "reply": 1096 1096 + // t.Title (string) (string) 1097 1097 + case "title": 842 1098 843 1099 { 1100 1100 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1101 1101 + if err != nil { 1102 1102 + return err 1103 1103 + } 844 1104 845 845 - b, err := cr.ReadByte() 1105 1105 + t.Title = string(sval) 1106 1106 + } 1107 1107 + // t.Author (string) (string) 1108 1108 + case "author": 1109 1109 + 1110 1110 + { 1111 1111 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 846 1112 if err != nil { 847 1113 return err 848 1114 } 849 849 - if b != cbg.CborNull[0] { 850 850 - if err := cr.UnreadByte(); err != nil { 851 851 - return err 852 852 - } 853 853 - t.Reply = new(FeedComment_Reply) 854 854 - if err := t.Reply.UnmarshalCBOR(cr); err != nil { 855 855 - return xerrors.Errorf("unmarshaling t.Reply pointer: %w", err) 856 856 - } 1115 1115 + 1116 1116 + t.Author = string(sval) 1117 1117 + } 1118 1118 + // t.CreatedAt (string) (string) 1119 1119 + case "createdAt": 1120 1120 + 1121 1121 + { 1122 1122 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1123 1123 + if err != nil { 1124 1124 + return err 857 1125 } 858 1126 1127 1127 + t.CreatedAt = string(sval) 859 1128 } 860 860 - // t.Subject (string) (string) 861 861 - case "subject": 1129 1129 + // t.Description (string) (string) 1130 1130 + case "description": 862 1131 863 1132 { 864 1133 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 866 1135 return err 867 1136 } 868 1137 869 869 - t.Subject = string(sval) 1138 1138 + t.Description = string(sval) 1139 1139 + } 1140 1140 + 1141 1141 + default: 1142 1142 + // Field doesn't exist on this type, so ignore it 1143 1143 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1144 1144 + return err 1145 1145 + } 1146 1146 + } 1147 1147 + } 1148 1148 + 1149 1149 + return nil 1150 1150 + } 1151 1151 + func (t *ActivityDef) MarshalCBOR(w io.Writer) error { 1152 1152 + if t == nil { 1153 1153 + _, err := w.Write(cbg.CborNull) 1154 1154 + return err 1155 1155 + } 1156 1156 + 1157 1157 + cw := cbg.NewCborWriter(w) 1158 1158 + 1159 1159 + if _, err := cw.Write([]byte{165}); err != nil { 1160 1160 + return err 1161 1161 + } 1162 1162 + 1163 1163 + // t.Name (string) (string) 1164 1164 + if len("name") > 1000000 { 1165 1165 + return xerrors.Errorf("Value in field \"name\" was too long") 1166 1166 + } 1167 1167 + 1168 1168 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 1169 1169 + return err 1170 1170 + } 1171 1171 + if _, err := cw.WriteString(string("name")); err != nil { 1172 1172 + return err 1173 1173 + } 1174 1174 + 1175 1175 + if len(t.Name) > 1000000 { 1176 1176 + return xerrors.Errorf("Value in field t.Name was too long") 1177 1177 + } 1178 1178 + 1179 1179 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 1180 1180 + return err 1181 1181 + } 1182 1182 + if _, err := cw.WriteString(string(t.Name)); err != nil { 1183 1183 + return err 1184 1184 + } 1185 1185 + 1186 1186 + // t.LexiconTypeID (string) (string) 1187 1187 + if len("$type") > 1000000 { 1188 1188 + return xerrors.Errorf("Value in field \"$type\" was too long") 1189 1189 + } 1190 1190 + 1191 1191 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 1192 1192 + return err 1193 1193 + } 1194 1194 + if _, err := cw.WriteString(string("$type")); err != nil { 1195 1195 + return err 1196 1196 + } 1197 1197 + 1198 1198 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.activity.def"))); err != nil { 1199 1199 + return err 1200 1200 + } 1201 1201 + if _, err := cw.WriteString(string("app.yoten.activity.def")); err != nil { 1202 1202 + return err 1203 1203 + } 1204 1204 + 1205 1205 + // t.CreatedAt (string) (string) 1206 1206 + if len("createdAt") > 1000000 { 1207 1207 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 1208 1208 + } 1209 1209 + 1210 1210 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 1211 1211 + return err 1212 1212 + } 1213 1213 + if _, err := cw.WriteString(string("createdAt")); err != nil { 1214 1214 + return err 1215 1215 + } 1216 1216 + 1217 1217 + if len(t.CreatedAt) > 1000000 { 1218 1218 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 1219 1219 + } 1220 1220 + 1221 1221 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 1222 1222 + return err 1223 1223 + } 1224 1224 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 1225 1225 + return err 1226 1226 + } 1227 1227 + 1228 1228 + // t.Categories ([]string) (slice) 1229 1229 + if len("categories") > 1000000 { 1230 1230 + return xerrors.Errorf("Value in field \"categories\" was too long") 1231 1231 + } 1232 1232 + 1233 1233 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("categories"))); err != nil { 1234 1234 + return err 1235 1235 + } 1236 1236 + if _, err := cw.WriteString(string("categories")); err != nil { 1237 1237 + return err 1238 1238 + } 1239 1239 + 1240 1240 + if len(t.Categories) > 8192 { 1241 1241 + return xerrors.Errorf("Slice value in field t.Categories was too long") 1242 1242 + } 1243 1243 + 1244 1244 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Categories))); err != nil { 1245 1245 + return err 1246 1246 + } 1247 1247 + for _, v := range t.Categories { 1248 1248 + if len(v) > 1000000 { 1249 1249 + return xerrors.Errorf("Value in field v was too long") 1250 1250 + } 1251 1251 + 1252 1252 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil { 1253 1253 + return err 1254 1254 + } 1255 1255 + if _, err := cw.WriteString(string(v)); err != nil { 1256 1256 + return err 1257 1257 + } 1258 1258 + 1259 1259 + } 1260 1260 + 1261 1261 + // t.Description (string) (string) 1262 1262 + if len("description") > 1000000 { 1263 1263 + return xerrors.Errorf("Value in field \"description\" was too long") 1264 1264 + } 1265 1265 + 1266 1266 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 1267 1267 + return err 1268 1268 + } 1269 1269 + if _, err := cw.WriteString(string("description")); err != nil { 1270 1270 + return err 1271 1271 + } 1272 1272 + 1273 1273 + if len(t.Description) > 1000000 { 1274 1274 + return xerrors.Errorf("Value in field t.Description was too long") 1275 1275 + } 1276 1276 + 1277 1277 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil { 1278 1278 + return err 1279 1279 + } 1280 1280 + if _, err := cw.WriteString(string(t.Description)); err != nil { 1281 1281 + return err 1282 1282 + } 1283 1283 + return nil 1284 1284 + } 1285 1285 + 1286 1286 + func (t *ActivityDef) UnmarshalCBOR(r io.Reader) (err error) { 1287 1287 + *t = ActivityDef{} 1288 1288 + 1289 1289 + cr := cbg.NewCborReader(r) 1290 1290 + 1291 1291 + maj, extra, err := cr.ReadHeader() 1292 1292 + if err != nil { 1293 1293 + return err 1294 1294 + } 1295 1295 + defer func() { 1296 1296 + if err == io.EOF { 1297 1297 + err = io.ErrUnexpectedEOF 1298 1298 + } 1299 1299 + }() 1300 1300 + 1301 1301 + if maj != cbg.MajMap { 1302 1302 + return fmt.Errorf("cbor input should be of type map") 1303 1303 + } 1304 1304 + 1305 1305 + if extra > cbg.MaxLength { 1306 1306 + return fmt.Errorf("ActivityDef: map struct too large (%d)", extra) 1307 1307 + } 1308 1308 + 1309 1309 + n := extra 1310 1310 + 1311 1311 + nameBuf := make([]byte, 11) 1312 1312 + for i := uint64(0); i < n; i++ { 1313 1313 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1314 1314 + if err != nil { 1315 1315 + return err 1316 1316 + } 1317 1317 + 1318 1318 + if !ok { 1319 1319 + // Field doesn't exist on this type, so ignore it 1320 1320 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1321 1321 + return err 1322 1322 + } 1323 1323 + continue 1324 1324 + } 1325 1325 + 1326 1326 + switch string(nameBuf[:nameLen]) { 1327 1327 + // t.Name (string) (string) 1328 1328 + case "name": 1329 1329 + 1330 1330 + { 1331 1331 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1332 1332 + if err != nil { 1333 1333 + return err 1334 1334 + } 1335 1335 + 1336 1336 + t.Name = string(sval) 1337 1337 + } 1338 1338 + // t.LexiconTypeID (string) (string) 1339 1339 + case "$type": 1340 1340 + 1341 1341 + { 1342 1342 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1343 1343 + if err != nil { 1344 1344 + return err 1345 1345 + } 1346 1346 + 1347 1347 + t.LexiconTypeID = string(sval) 870 1348 } 871 1349 // t.CreatedAt (string) (string) 872 1350 case "createdAt": ··· 878 1356 } 879 1357 880 1358 t.CreatedAt = string(sval) 1359 1359 + } 1360 1360 + // t.Categories ([]string) (slice) 1361 1361 + case "categories": 1362 1362 + 1363 1363 + maj, extra, err = cr.ReadHeader() 1364 1364 + if err != nil { 1365 1365 + return err 1366 1366 + } 1367 1367 + 1368 1368 + if extra > 8192 { 1369 1369 + return fmt.Errorf("t.Categories: array too large (%d)", extra) 1370 1370 + } 1371 1371 + 1372 1372 + if maj != cbg.MajArray { 1373 1373 + return fmt.Errorf("expected cbor array") 1374 1374 + } 1375 1375 + 1376 1376 + if extra > 0 { 1377 1377 + t.Categories = make([]string, extra) 1378 1378 + } 1379 1379 + 1380 1380 + for i := 0; i < int(extra); i++ { 1381 1381 + { 1382 1382 + var maj byte 1383 1383 + var extra uint64 1384 1384 + var err error 1385 1385 + _ = maj 1386 1386 + _ = extra 1387 1387 + _ = err 1388 1388 + 1389 1389 + { 1390 1390 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1391 1391 + if err != nil { 1392 1392 + return err 1393 1393 + } 1394 1394 + 1395 1395 + t.Categories[i] = string(sval) 1396 1396 + } 1397 1397 + 1398 1398 + } 1399 1399 + } 1400 1400 + // t.Description (string) (string) 1401 1401 + case "description": 1402 1402 + 1403 1403 + { 1404 1404 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1405 1405 + if err != nil { 1406 1406 + return err 1407 1407 + } 1408 1408 + 1409 1409 + t.Description = string(sval) 881 1410 } 882 1411 883 1412 default: ··· 890 1419 891 1420 return nil 892 1421 } 893 893 - func (t *FeedComment_Reply) MarshalCBOR(w io.Writer) error { 1422 1422 + func (t *GraphFollow) MarshalCBOR(w io.Writer) error { 894 1423 if t == nil { 895 1424 _, err := w.Write(cbg.CborNull) 896 1425 return err ··· 898 1427 899 1428 cw := cbg.NewCborWriter(w) 900 1429 901 901 - if _, err := cw.Write([]byte{162}); err != nil { 1430 1430 + if _, err := cw.Write([]byte{163}); err != nil { 902 1431 return err 903 1432 } 904 1433 905 905 - // t.Root (string) (string) 906 906 - if len("root") > 1000000 { 907 907 - return xerrors.Errorf("Value in field \"root\" was too long") 1434 1434 + // t.LexiconTypeID (string) (string) 1435 1435 + if len("$type") > 1000000 { 1436 1436 + return xerrors.Errorf("Value in field \"$type\" was too long") 908 1437 } 909 1438 910 910 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("root"))); err != nil { 1439 1439 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 911 1440 return err 912 1441 } 913 913 - if _, err := cw.WriteString(string("root")); err != nil { 1442 1442 + if _, err := cw.WriteString(string("$type")); err != nil { 914 1443 return err 915 1444 } 916 1445 917 917 - if len(t.Root) > 1000000 { 918 918 - return xerrors.Errorf("Value in field t.Root was too long") 1446 1446 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.graph.follow"))); err != nil { 1447 1447 + return err 1448 1448 + } 1449 1449 + if _, err := cw.WriteString(string("app.yoten.graph.follow")); err != nil { 1450 1450 + return err 1451 1451 + } 1452 1452 + 1453 1453 + // t.Subject (string) (string) 1454 1454 + if len("subject") > 1000000 { 1455 1455 + return xerrors.Errorf("Value in field \"subject\" was too long") 919 1456 } 920 1457 921 921 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Root))); err != nil { 1458 1458 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 922 1459 return err 923 1460 } 924 924 - if _, err := cw.WriteString(string(t.Root)); err != nil { 1461 1461 + if _, err := cw.WriteString(string("subject")); err != nil { 925 1462 return err 926 1463 } 927 1464 928 928 - // t.Parent (string) (string) 929 929 - if len("parent") > 1000000 { 930 930 - return xerrors.Errorf("Value in field \"parent\" was too long") 1465 1465 + if len(t.Subject) > 1000000 { 1466 1466 + return xerrors.Errorf("Value in field t.Subject was too long") 1467 1467 + } 1468 1468 + 1469 1469 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 1470 1470 + return err 1471 1471 + } 1472 1472 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 1473 1473 + return err 1474 1474 + } 1475 1475 + 1476 1476 + // t.CreatedAt (string) (string) 1477 1477 + if len("createdAt") > 1000000 { 1478 1478 + return xerrors.Errorf("Value in field \"createdAt\" was too long") 931 1479 } 932 1480 933 933 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("parent"))); err != nil { 1481 1481 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 934 1482 return err 935 1483 } 936 936 - if _, err := cw.WriteString(string("parent")); err != nil { 1484 1484 + if _, err := cw.WriteString(string("createdAt")); err != nil { 937 1485 return err 938 1486 } 939 1487 940 940 - if len(t.Parent) > 1000000 { 941 941 - return xerrors.Errorf("Value in field t.Parent was too long") 1488 1488 + if len(t.CreatedAt) > 1000000 { 1489 1489 + return xerrors.Errorf("Value in field t.CreatedAt was too long") 942 1490 } 943 1491 944 944 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Parent))); err != nil { 1492 1492 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 945 1493 return err 946 1494 } 947 947 - if _, err := cw.WriteString(string(t.Parent)); err != nil { 1495 1495 + if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 948 1496 return err 949 1497 } 950 1498 return nil 951 1499 } 952 1500 953 953 - func (t *FeedComment_Reply) UnmarshalCBOR(r io.Reader) (err error) { 954 954 - *t = FeedComment_Reply{} 1501 1501 + func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) { 1502 1502 + *t = GraphFollow{} 955 1503 956 1504 cr := cbg.NewCborReader(r) 957 1505 ··· 970 1518 } 971 1519 972 1520 if extra > cbg.MaxLength { 973 973 - return fmt.Errorf("FeedComment_Reply: map struct too large (%d)", extra) 1521 1521 + return fmt.Errorf("GraphFollow: map struct too large (%d)", extra) 974 1522 } 975 1523 976 1524 n := extra 977 1525 978 978 - nameBuf := make([]byte, 6) 1526 1526 + nameBuf := make([]byte, 9) 979 1527 for i := uint64(0); i < n; i++ { 980 1528 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 981 1529 if err != nil { ··· 991 1539 } 992 1540 993 1541 switch string(nameBuf[:nameLen]) { 994 994 - // t.Root (string) (string) 995 995 - case "root": 1542 1542 + // t.LexiconTypeID (string) (string) 1543 1543 + case "$type": 996 1544 997 1545 { 998 1546 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1000 1548 return err 1001 1549 } 1002 1550 1003 1003 - t.Root = string(sval) 1551 1551 + t.LexiconTypeID = string(sval) 1004 1552 } 1005 1005 - // t.Parent (string) (string) 1006 1006 - case "parent": 1553 1553 + // t.Subject (string) (string) 1554 1554 + case "subject": 1007 1555 1008 1556 { 1009 1557 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1011 1559 return err 1012 1560 } 1013 1561 1014 1014 - t.Parent = string(sval) 1562 1562 + t.Subject = string(sval) 1563 1563 + } 1564 1564 + // t.CreatedAt (string) (string) 1565 1565 + case "createdAt": 1566 1566 + 1567 1567 + { 1568 1568 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 1569 1569 + if err != nil { 1570 1570 + return err 1571 1571 + } 1572 1572 + 1573 1573 + t.CreatedAt = string(sval) 1015 1574 } 1016 1575 1017 1576 default: ··· 1222 1781 1223 1782 return nil 1224 1783 } 1225 1225 - func (t *FeedResource) MarshalCBOR(w io.Writer) error { 1784 1784 + func (t *FeedComment) MarshalCBOR(w io.Writer) error { 1226 1785 if t == nil { 1227 1786 _, err := w.Write(cbg.CborNull) 1228 1787 return err 1229 1788 } 1230 1789 1231 1790 cw := cbg.NewCborWriter(w) 1232 1232 - fieldCount := 7 1791 1791 + fieldCount := 5 1233 1792 1234 1234 - if t.Link == nil { 1793 1793 + if t.Reply == nil { 1235 1794 fieldCount-- 1236 1795 } 1237 1796 ··· 1239 1798 return err 1240 1799 } 1241 1800 1242 1242 - // t.Link (string) (string) 1243 1243 - if t.Link != nil { 1244 1244 - 1245 1245 - if len("link") > 1000000 { 1246 1246 - return xerrors.Errorf("Value in field \"link\" was too long") 1247 1247 - } 1248 1248 - 1249 1249 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("link"))); err != nil { 1250 1250 - return err 1251 1251 - } 1252 1252 - if _, err := cw.WriteString(string("link")); err != nil { 1253 1253 - return err 1254 1254 - } 1255 1255 - 1256 1256 - if t.Link == nil { 1257 1257 - if _, err := cw.Write(cbg.CborNull); err != nil { 1258 1258 - return err 1259 1259 - } 1260 1260 - } else { 1261 1261 - if len(*t.Link) > 1000000 { 1262 1262 - return xerrors.Errorf("Value in field t.Link was too long") 1263 1263 - } 1264 1264 - 1265 1265 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Link))); err != nil { 1266 1266 - return err 1267 1267 - } 1268 1268 - if _, err := cw.WriteString(string(*t.Link)); err != nil { 1269 1269 - return err 1270 1270 - } 1271 1271 - } 1272 1272 - } 1273 1273 - 1274 1274 - // t.Type (string) (string) 1275 1275 - if len("type") > 1000000 { 1276 1276 - return xerrors.Errorf("Value in field \"type\" was too long") 1801 1801 + // t.Body (string) (string) 1802 1802 + if len("body") > 1000000 { 1803 1803 + return xerrors.Errorf("Value in field \"body\" was too long") 1277 1804 } 1278 1805 1279 1279 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("type"))); err != nil { 1806 1806 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("body"))); err != nil { 1280 1807 return err 1281 1808 } 1282 1282 - if _, err := cw.WriteString(string("type")); err != nil { 1809 1809 + if _, err := cw.WriteString(string("body")); err != nil { 1283 1810 return err 1284 1811 } 1285 1812 1286 1286 - if len(t.Type) > 1000000 { 1287 1287 - return xerrors.Errorf("Value in field t.Type was too long") 1813 1813 + if len(t.Body) > 1000000 { 1814 1814 + return xerrors.Errorf("Value in field t.Body was too long") 1288 1815 } 1289 1816 1290 1290 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Type))); err != nil { 1817 1817 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Body))); err != nil { 1291 1818 return err 1292 1819 } 1293 1293 - if _, err := cw.WriteString(string(t.Type)); err != nil { 1820 1820 + if _, err := cw.WriteString(string(t.Body)); err != nil { 1294 1821 return err 1295 1822 } 1296 1823 ··· 1306 1833 return err 1307 1834 } 1308 1835 1309 1309 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.feed.resource"))); err != nil { 1836 1836 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.feed.comment"))); err != nil { 1310 1837 return err 1311 1838 } 1312 1312 - if _, err := cw.WriteString(string("app.yoten.feed.resource")); err != nil { 1839 1839 + if _, err := cw.WriteString(string("app.yoten.feed.comment")); err != nil { 1313 1840 return err 1314 1841 } 1315 1842 1316 1316 - // t.Title (string) (string) 1317 1317 - if len("title") > 1000000 { 1318 1318 - return xerrors.Errorf("Value in field \"title\" was too long") 1319 1319 - } 1843 1843 + // t.Reply (yoten.FeedComment_Reply) (struct) 1844 1844 + if t.Reply != nil { 1320 1845 1321 1321 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 1322 1322 - return err 1323 1323 - } 1324 1324 - if _, err := cw.WriteString(string("title")); err != nil { 1325 1325 - return err 1326 1326 - } 1846 1846 + if len("reply") > 1000000 { 1847 1847 + return xerrors.Errorf("Value in field \"reply\" was too long") 1848 1848 + } 1327 1849 1328 1328 - if len(t.Title) > 1000000 { 1329 1329 - return xerrors.Errorf("Value in field t.Title was too long") 1330 1330 - } 1850 1850 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("reply"))); err != nil { 1851 1851 + return err 1852 1852 + } 1853 1853 + if _, err := cw.WriteString(string("reply")); err != nil { 1854 1854 + return err 1855 1855 + } 1331 1856 1332 1332 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Title))); err != nil { 1333 1333 - return err 1334 1334 - } 1335 1335 - if _, err := cw.WriteString(string(t.Title)); err != nil { 1336 1336 - return err 1857 1857 + if err := t.Reply.MarshalCBOR(cw); err != nil { 1858 1858 + return err 1859 1859 + } 1337 1860 } 1338 1861 1339 1339 - // t.Author (string) (string) 1340 1340 - if len("author") > 1000000 { 1341 1341 - return xerrors.Errorf("Value in field \"author\" was too long") 1862 1862 + // t.Subject (string) (string) 1863 1863 + if len("subject") > 1000000 { 1864 1864 + return xerrors.Errorf("Value in field \"subject\" was too long") 1342 1865 } 1343 1866 1344 1344 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("author"))); err != nil { 1867 1867 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 1345 1868 return err 1346 1869 } 1347 1347 - if _, err := cw.WriteString(string("author")); err != nil { 1870 1870 + if _, err := cw.WriteString(string("subject")); err != nil { 1348 1871 return err 1349 1872 } 1350 1873 1351 1351 - if len(t.Author) > 1000000 { 1352 1352 - return xerrors.Errorf("Value in field t.Author was too long") 1874 1874 + if len(t.Subject) > 1000000 { 1875 1875 + return xerrors.Errorf("Value in field t.Subject was too long") 1353 1876 } 1354 1877 1355 1355 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Author))); err != nil { 1878 1878 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 1356 1879 return err 1357 1880 } 1358 1358 - if _, err := cw.WriteString(string(t.Author)); err != nil { 1881 1881 + if _, err := cw.WriteString(string(t.Subject)); err != nil { 1359 1882 return err 1360 1883 } 1361 1884 ··· 1381 1904 if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 1382 1905 return err 1383 1906 } 1384 1384 - 1385 1385 - // t.Description (string) (string) 1386 1386 - if len("description") > 1000000 { 1387 1387 - return xerrors.Errorf("Value in field \"description\" was too long") 1388 1388 - } 1389 1389 - 1390 1390 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 1391 1391 - return err 1392 1392 - } 1393 1393 - if _, err := cw.WriteString(string("description")); err != nil { 1394 1394 - return err 1395 1395 - } 1396 1396 - 1397 1397 - if len(t.Description) > 1000000 { 1398 1398 - return xerrors.Errorf("Value in field t.Description was too long") 1399 1399 - } 1400 1400 - 1401 1401 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil { 1402 1402 - return err 1403 1403 - } 1404 1404 - if _, err := cw.WriteString(string(t.Description)); err != nil { 1405 1405 - return err 1406 1406 - } 1407 1907 return nil 1408 1908 } 1409 1909 1410 1410 - func (t *FeedResource) UnmarshalCBOR(r io.Reader) (err error) { 1411 1411 - *t = FeedResource{} 1910 1910 + func (t *FeedComment) UnmarshalCBOR(r io.Reader) (err error) { 1911 1911 + *t = FeedComment{} 1412 1912 1413 1913 cr := cbg.NewCborReader(r) 1414 1914 ··· 1427 1927 } 1428 1928 1429 1929 if extra > cbg.MaxLength { 1430 1430 - return fmt.Errorf("FeedResource: map struct too large (%d)", extra) 1930 1930 + return fmt.Errorf("FeedComment: map struct too large (%d)", extra) 1431 1931 } 1432 1932 1433 1933 n := extra 1434 1934 1435 1435 - nameBuf := make([]byte, 11) 1935 1935 + nameBuf := make([]byte, 9) 1436 1936 for i := uint64(0); i < n; i++ { 1437 1937 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1438 1938 if err != nil { ··· 1448 1948 } 1449 1949 1450 1950 switch string(nameBuf[:nameLen]) { 1451 1451 - // t.Link (string) (string) 1452 1452 - case "link": 1453 1453 - 1454 1454 - { 1455 1455 - b, err := cr.ReadByte() 1456 1456 - if err != nil { 1457 1457 - return err 1458 1458 - } 1459 1459 - if b != cbg.CborNull[0] { 1460 1460 - if err := cr.UnreadByte(); err != nil { 1461 1461 - return err 1462 1462 - } 1463 1463 - 1464 1464 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1465 1465 - if err != nil { 1466 1466 - return err 1467 1467 - } 1468 1468 - 1469 1469 - t.Link = (*string)(&sval) 1470 1470 - } 1471 1471 - } 1472 1472 - // t.Type (string) (string) 1473 1473 - case "type": 1951 1951 + // t.Body (string) (string) 1952 1952 + case "body": 1474 1953 1475 1954 { 1476 1955 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1478 1957 return err 1479 1958 } 1480 1959 1481 1481 - t.Type = string(sval) 1960 1960 + t.Body = string(sval) 1482 1961 } 1483 1962 // t.LexiconTypeID (string) (string) 1484 1963 case "$type": ··· 1491 1970 1492 1971 t.LexiconTypeID = string(sval) 1493 1972 } 1494 1494 - // t.Title (string) (string) 1495 1495 - case "title": 1973 1973 + // t.Reply (yoten.FeedComment_Reply) (struct) 1974 1974 + case "reply": 1496 1975 1497 1976 { 1498 1498 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1977 1977 + 1978 1978 + b, err := cr.ReadByte() 1499 1979 if err != nil { 1500 1980 return err 1501 1981 } 1982 1982 + if b != cbg.CborNull[0] { 1983 1983 + if err := cr.UnreadByte(); err != nil { 1984 1984 + return err 1985 1985 + } 1986 1986 + t.Reply = new(FeedComment_Reply) 1987 1987 + if err := t.Reply.UnmarshalCBOR(cr); err != nil { 1988 1988 + return xerrors.Errorf("unmarshaling t.Reply pointer: %w", err) 1989 1989 + } 1990 1990 + } 1502 1991 1503 1503 - t.Title = string(sval) 1504 1992 } 1505 1505 - // t.Author (string) (string) 1506 1506 - case "author": 1993 1993 + // t.Subject (string) (string) 1994 1994 + case "subject": 1507 1995 1508 1996 { 1509 1997 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 1511 1999 return err 1512 2000 } 1513 2001 1514 1514 - t.Author = string(sval) 2002 2002 + t.Subject = string(sval) 1515 2003 } 1516 2004 // t.CreatedAt (string) (string) 1517 2005 case "createdAt": ··· 1524 2012 1525 2013 t.CreatedAt = string(sval) 1526 2014 } 1527 1527 - // t.Description (string) (string) 1528 1528 - case "description": 1529 1529 - 1530 1530 - { 1531 1531 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1532 1532 - if err != nil { 1533 1533 - return err 1534 1534 - } 1535 1535 - 1536 1536 - t.Description = string(sval) 1537 1537 - } 1538 2015 1539 2016 default: 1540 2017 // Field doesn't exist on this type, so ignore it ··· 1546 2023 1547 2024 return nil 1548 2025 } 1549 1549 - func (t *FeedSession) MarshalCBOR(w io.Writer) error { 2026 2026 + func (t *FeedComment_Reply) MarshalCBOR(w io.Writer) error { 1550 2027 if t == nil { 1551 2028 _, err := w.Write(cbg.CborNull) 1552 2029 return err 1553 2030 } 1554 2031 1555 2032 cw := cbg.NewCborWriter(w) 1556 1556 - fieldCount := 9 1557 2033 1558 1558 - if t.Description == nil { 1559 1559 - fieldCount-- 2034 2034 + if _, err := cw.Write([]byte{162}); err != nil { 2035 2035 + return err 1560 2036 } 1561 2037 1562 1562 - if t.PredefinedActivityName == nil { 1563 1563 - fieldCount-- 2038 2038 + // t.Root (string) (string) 2039 2039 + if len("root") > 1000000 { 2040 2040 + return xerrors.Errorf("Value in field \"root\" was too long") 1564 2041 } 1565 2042 1566 1566 - if t.Resource == nil { 1567 1567 - fieldCount-- 2043 2043 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("root"))); err != nil { 2044 2044 + return err 1568 2045 } 1569 1569 - 1570 1570 - if t.UserActivityRef == nil { 1571 1571 - fieldCount-- 1572 1572 - } 1573 1573 - 1574 1574 - if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 2046 2046 + if _, err := cw.WriteString(string("root")); err != nil { 1575 2047 return err 1576 2048 } 1577 2049 1578 1578 - // t.Date (string) (string) 1579 1579 - if len("date") > 1000000 { 1580 1580 - return xerrors.Errorf("Value in field \"date\" was too long") 2050 2050 + if len(t.Root) > 1000000 { 2051 2051 + return xerrors.Errorf("Value in field t.Root was too long") 1581 2052 } 1582 2053 1583 1583 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("date"))); err != nil { 2054 2054 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Root))); err != nil { 1584 2055 return err 1585 2056 } 1586 1586 - if _, err := cw.WriteString(string("date")); err != nil { 2057 2057 + if _, err := cw.WriteString(string(t.Root)); err != nil { 1587 2058 return err 1588 2059 } 1589 2060 1590 1590 - if len(t.Date) > 1000000 { 1591 1591 - return xerrors.Errorf("Value in field t.Date was too long") 2061 2061 + // t.Parent (string) (string) 2062 2062 + if len("parent") > 1000000 { 2063 2063 + return xerrors.Errorf("Value in field \"parent\" was too long") 1592 2064 } 1593 2065 1594 1594 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Date))); err != nil { 2066 2066 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("parent"))); err != nil { 1595 2067 return err 1596 2068 } 1597 1597 - if _, err := cw.WriteString(string(t.Date)); err != nil { 2069 2069 + if _, err := cw.WriteString(string("parent")); err != nil { 1598 2070 return err 1599 2071 } 1600 2072 1601 1601 - // t.LexiconTypeID (string) (string) 1602 1602 - if len("$type") > 1000000 { 1603 1603 - return xerrors.Errorf("Value in field \"$type\" was too long") 2073 2073 + if len(t.Parent) > 1000000 { 2074 2074 + return xerrors.Errorf("Value in field t.Parent was too long") 1604 2075 } 1605 2076 1606 1606 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2077 2077 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Parent))); err != nil { 1607 2078 return err 1608 2079 } 1609 1609 - if _, err := cw.WriteString(string("$type")); err != nil { 2080 2080 + if _, err := cw.WriteString(string(t.Parent)); err != nil { 1610 2081 return err 1611 2082 } 2083 2083 + return nil 2084 2084 + } 1612 2085 1613 1613 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.feed.session"))); err != nil { 1614 1614 - return err 1615 1615 - } 1616 1616 - if _, err := cw.WriteString(string("app.yoten.feed.session")); err != nil { 2086 2086 + func (t *FeedComment_Reply) UnmarshalCBOR(r io.Reader) (err error) { 2087 2087 + *t = FeedComment_Reply{} 2088 2088 + 2089 2089 + cr := cbg.NewCborReader(r) 2090 2090 + 2091 2091 + maj, extra, err := cr.ReadHeader() 2092 2092 + if err != nil { 1617 2093 return err 1618 2094 } 2095 2095 + defer func() { 2096 2096 + if err == io.EOF { 2097 2097 + err = io.ErrUnexpectedEOF 2098 2098 + } 2099 2099 + }() 1619 2100 1620 1620 - // t.Duration (int64) (int64) 1621 1621 - if len("duration") > 1000000 { 1622 1622 - return xerrors.Errorf("Value in field \"duration\" was too long") 2101 2101 + if maj != cbg.MajMap { 2102 2102 + return fmt.Errorf("cbor input should be of type map") 1623 2103 } 1624 2104 1625 1625 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("duration"))); err != nil { 1626 1626 - return err 1627 1627 - } 1628 1628 - if _, err := cw.WriteString(string("duration")); err != nil { 1629 1629 - return err 2105 2105 + if extra > cbg.MaxLength { 2106 2106 + return fmt.Errorf("FeedComment_Reply: map struct too large (%d)", extra) 1630 2107 } 1631 2108 1632 1632 - if t.Duration >= 0 { 1633 1633 - if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.Duration)); err != nil { 2109 2109 + n := extra 2110 2110 + 2111 2111 + nameBuf := make([]byte, 6) 2112 2112 + for i := uint64(0); i < n; i++ { 2113 2113 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2114 2114 + if err != nil { 1634 2115 return err 1635 2116 } 1636 1636 - } else { 1637 1637 - if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.Duration-1)); err != nil { 1638 1638 - return err 2117 2117 + 2118 2118 + if !ok { 2119 2119 + // Field doesn't exist on this type, so ignore it 2120 2120 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2121 2121 + return err 2122 2122 + } 2123 2123 + continue 1639 2124 } 1640 1640 - } 2125 2125 + 2126 2126 + switch string(nameBuf[:nameLen]) { 2127 2127 + // t.Root (string) (string) 2128 2128 + case "root": 2129 2129 + 2130 2130 + { 2131 2131 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2132 2132 + if err != nil { 2133 2133 + return err 2134 2134 + } 2135 2135 + 2136 2136 + t.Root = string(sval) 2137 2137 + } 2138 2138 + // t.Parent (string) (string) 2139 2139 + case "parent": 2140 2140 + 2141 2141 + { 2142 2142 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 2143 2143 + if err != nil { 2144 2144 + return err 2145 2145 + } 1641 2146 1642 1642 - // t.Resource (yoten.FeedResource) (struct) 1643 1643 - if t.Resource != nil { 2147 2147 + t.Parent = string(sval) 2148 2148 + } 1644 2149 1645 1645 - if len("resource") > 1000000 { 1646 1646 - return xerrors.Errorf("Value in field \"resource\" was too long") 2150 2150 + default: 2151 2151 + // Field doesn't exist on this type, so ignore it 2152 2152 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2153 2153 + return err 2154 2154 + } 1647 2155 } 2156 2156 + } 1648 2157 1649 1649 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("resource"))); err != nil { 1650 1650 - return err 1651 1651 - } 1652 1652 - if _, err := cw.WriteString(string("resource")); err != nil { 1653 1653 - return err 1654 1654 - } 2158 2158 + return nil 2159 2159 + } 2160 2160 + func (t *RichtextFacet) MarshalCBOR(w io.Writer) error { 2161 2161 + if t == nil { 2162 2162 + _, err := w.Write(cbg.CborNull) 2163 2163 + return err 2164 2164 + } 1655 2165 1656 1656 - if err := t.Resource.MarshalCBOR(cw); err != nil { 1657 1657 - return err 1658 1658 - } 2166 2166 + cw := cbg.NewCborWriter(w) 2167 2167 + 2168 2168 + if _, err := cw.Write([]byte{162}); err != nil { 2169 2169 + return err 1659 2170 } 1660 2171 1661 1661 - // t.CreatedAt (string) (string) 1662 1662 - if len("createdAt") > 1000000 { 1663 1663 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 2172 2172 + // t.Index (yoten.RichtextFacet_ByteSlice) (struct) 2173 2173 + if len("index") > 1000000 { 2174 2174 + return xerrors.Errorf("Value in field \"index\" was too long") 1664 2175 } 1665 2176 1666 1666 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2177 2177 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("index"))); err != nil { 2178 2178 + return err 2179 2179 + } 2180 2180 + if _, err := cw.WriteString(string("index")); err != nil { 1667 2181 return err 1668 2182 } 1669 1669 - if _, err := cw.WriteString(string("createdAt")); err != nil { 2183 2183 + 2184 2184 + if err := t.Index.MarshalCBOR(cw); err != nil { 1670 2185 return err 1671 2186 } 1672 2187 1673 1673 - if len(t.CreatedAt) > 1000000 { 1674 1674 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 2188 2188 + // t.Features ([]*yoten.RichtextFacet_Features_Elem) (slice) 2189 2189 + if len("features") > 1000000 { 2190 2190 + return xerrors.Errorf("Value in field \"features\" was too long") 1675 2191 } 1676 2192 1677 1677 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2193 2193 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("features"))); err != nil { 1678 2194 return err 1679 2195 } 1680 1680 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2196 2196 + if _, err := cw.WriteString(string("features")); err != nil { 1681 2197 return err 1682 2198 } 1683 2199 1684 1684 - // t.Description (string) (string) 1685 1685 - if t.Description != nil { 2200 2200 + if len(t.Features) > 8192 { 2201 2201 + return xerrors.Errorf("Slice value in field t.Features was too long") 2202 2202 + } 1686 2203 1687 1687 - if len("description") > 1000000 { 1688 1688 - return xerrors.Errorf("Value in field \"description\" was too long") 2204 2204 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Features))); err != nil { 2205 2205 + return err 2206 2206 + } 2207 2207 + for _, v := range t.Features { 2208 2208 + if err := v.MarshalCBOR(cw); err != nil { 2209 2209 + return err 1689 2210 } 1690 2211 1691 1691 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 1692 1692 - return err 2212 2212 + } 2213 2213 + return nil 2214 2214 + } 2215 2215 + 2216 2216 + func (t *RichtextFacet) UnmarshalCBOR(r io.Reader) (err error) { 2217 2217 + *t = RichtextFacet{} 2218 2218 + 2219 2219 + cr := cbg.NewCborReader(r) 2220 2220 + 2221 2221 + maj, extra, err := cr.ReadHeader() 2222 2222 + if err != nil { 2223 2223 + return err 2224 2224 + } 2225 2225 + defer func() { 2226 2226 + if err == io.EOF { 2227 2227 + err = io.ErrUnexpectedEOF 1693 2228 } 1694 1694 - if _, err := cw.WriteString(string("description")); err != nil { 2229 2229 + }() 2230 2230 + 2231 2231 + if maj != cbg.MajMap { 2232 2232 + return fmt.Errorf("cbor input should be of type map") 2233 2233 + } 2234 2234 + 2235 2235 + if extra > cbg.MaxLength { 2236 2236 + return fmt.Errorf("RichtextFacet: map struct too large (%d)", extra) 2237 2237 + } 2238 2238 + 2239 2239 + n := extra 2240 2240 + 2241 2241 + nameBuf := make([]byte, 8) 2242 2242 + for i := uint64(0); i < n; i++ { 2243 2243 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2244 2244 + if err != nil { 1695 2245 return err 1696 2246 } 1697 2247 1698 1698 - if t.Description == nil { 1699 1699 - if _, err := cw.Write(cbg.CborNull); err != nil { 2248 2248 + if !ok { 2249 2249 + // Field doesn't exist on this type, so ignore it 2250 2250 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 1700 2251 return err 1701 2252 } 1702 1702 - } else { 1703 1703 - if len(*t.Description) > 1000000 { 1704 1704 - return xerrors.Errorf("Value in field t.Description was too long") 2253 2253 + continue 2254 2254 + } 2255 2255 + 2256 2256 + switch string(nameBuf[:nameLen]) { 2257 2257 + // t.Index (yoten.RichtextFacet_ByteSlice) (struct) 2258 2258 + case "index": 2259 2259 + 2260 2260 + { 2261 2261 + 2262 2262 + b, err := cr.ReadByte() 2263 2263 + if err != nil { 2264 2264 + return err 2265 2265 + } 2266 2266 + if b != cbg.CborNull[0] { 2267 2267 + if err := cr.UnreadByte(); err != nil { 2268 2268 + return err 2269 2269 + } 2270 2270 + t.Index = new(RichtextFacet_ByteSlice) 2271 2271 + if err := t.Index.UnmarshalCBOR(cr); err != nil { 2272 2272 + return xerrors.Errorf("unmarshaling t.Index pointer: %w", err) 2273 2273 + } 2274 2274 + } 2275 2275 + 1705 2276 } 2277 2277 + // t.Features ([]*yoten.RichtextFacet_Features_Elem) (slice) 2278 2278 + case "features": 1706 2279 1707 1707 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 2280 2280 + maj, extra, err = cr.ReadHeader() 2281 2281 + if err != nil { 1708 2282 return err 1709 2283 } 1710 1710 - if _, err := cw.WriteString(string(*t.Description)); err != nil { 2284 2284 + 2285 2285 + if extra > 8192 { 2286 2286 + return fmt.Errorf("t.Features: array too large (%d)", extra) 2287 2287 + } 2288 2288 + 2289 2289 + if maj != cbg.MajArray { 2290 2290 + return fmt.Errorf("expected cbor array") 2291 2291 + } 2292 2292 + 2293 2293 + if extra > 0 { 2294 2294 + t.Features = make([]*RichtextFacet_Features_Elem, extra) 2295 2295 + } 2296 2296 + 2297 2297 + for i := 0; i < int(extra); i++ { 2298 2298 + { 2299 2299 + var maj byte 2300 2300 + var extra uint64 2301 2301 + var err error 2302 2302 + _ = maj 2303 2303 + _ = extra 2304 2304 + _ = err 2305 2305 + 2306 2306 + { 2307 2307 + 2308 2308 + b, err := cr.ReadByte() 2309 2309 + if err != nil { 2310 2310 + return err 2311 2311 + } 2312 2312 + if b != cbg.CborNull[0] { 2313 2313 + if err := cr.UnreadByte(); err != nil { 2314 2314 + return err 2315 2315 + } 2316 2316 + t.Features[i] = new(RichtextFacet_Features_Elem) 2317 2317 + if err := t.Features[i].UnmarshalCBOR(cr); err != nil { 2318 2318 + return xerrors.Errorf("unmarshaling t.Features[i] pointer: %w", err) 2319 2319 + } 2320 2320 + } 2321 2321 + 2322 2322 + } 2323 2323 + 2324 2324 + } 2325 2325 + } 2326 2326 + 2327 2327 + default: 2328 2328 + // Field doesn't exist on this type, so ignore it 2329 2329 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 1711 2330 return err 1712 2331 } 1713 2332 } 1714 2333 } 1715 2334 1716 1716 - // t.LanguageCode (string) (string) 1717 1717 - if len("languageCode") > 1000000 { 1718 1718 - return xerrors.Errorf("Value in field \"languageCode\" was too long") 1719 1719 - } 1720 1720 - 1721 1721 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("languageCode"))); err != nil { 2335 2335 + return nil 2336 2336 + } 2337 2337 + func (t *RichtextFacet_ByteSlice) MarshalCBOR(w io.Writer) error { 2338 2338 + if t == nil { 2339 2339 + _, err := w.Write(cbg.CborNull) 1722 2340 return err 1723 2341 } 1724 1724 - if _, err := cw.WriteString(string("languageCode")); err != nil { 2342 2342 + 2343 2343 + cw := cbg.NewCborWriter(w) 2344 2344 + 2345 2345 + if _, err := cw.Write([]byte{162}); err != nil { 1725 2346 return err 1726 2347 } 1727 2348 1728 1728 - if len(t.LanguageCode) > 1000000 { 1729 1729 - return xerrors.Errorf("Value in field t.LanguageCode was too long") 2349 2349 + // t.ByteEnd (int64) (int64) 2350 2350 + if len("byteEnd") > 1000000 { 2351 2351 + return xerrors.Errorf("Value in field \"byteEnd\" was too long") 1730 2352 } 1731 2353 1732 1732 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.LanguageCode))); err != nil { 2354 2354 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byteEnd"))); err != nil { 1733 2355 return err 1734 2356 } 1735 1735 - if _, err := cw.WriteString(string(t.LanguageCode)); err != nil { 2357 2357 + if _, err := cw.WriteString(string("byteEnd")); err != nil { 1736 2358 return err 1737 2359 } 1738 2360 1739 1739 - // t.UserActivityRef (yoten.ActivityDef) (struct) 1740 1740 - if t.UserActivityRef != nil { 1741 1741 - 1742 1742 - if len("userActivityRef") > 1000000 { 1743 1743 - return xerrors.Errorf("Value in field \"userActivityRef\" was too long") 1744 1744 - } 1745 1745 - 1746 1746 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("userActivityRef"))); err != nil { 2361 2361 + if t.ByteEnd >= 0 { 2362 2362 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ByteEnd)); err != nil { 1747 2363 return err 1748 2364 } 1749 1749 - if _, err := cw.WriteString(string("userActivityRef")); err != nil { 2365 2365 + } else { 2366 2366 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.ByteEnd-1)); err != nil { 1750 2367 return err 1751 2368 } 2369 2369 + } 1752 2370 1753 1753 - if err := t.UserActivityRef.MarshalCBOR(cw); err != nil { 1754 1754 - return err 1755 1755 - } 2371 2371 + // t.ByteStart (int64) (int64) 2372 2372 + if len("byteStart") > 1000000 { 2373 2373 + return xerrors.Errorf("Value in field \"byteStart\" was too long") 1756 2374 } 1757 2375 1758 1758 - // t.PredefinedActivityName (string) (string) 1759 1759 - if t.PredefinedActivityName != nil { 2376 2376 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("byteStart"))); err != nil { 2377 2377 + return err 2378 2378 + } 2379 2379 + if _, err := cw.WriteString(string("byteStart")); err != nil { 2380 2380 + return err 2381 2381 + } 1760 2382 1761 1761 - if len("predefinedActivityName") > 1000000 { 1762 1762 - return xerrors.Errorf("Value in field \"predefinedActivityName\" was too long") 1763 1763 - } 1764 1764 - 1765 1765 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("predefinedActivityName"))); err != nil { 2383 2383 + if t.ByteStart >= 0 { 2384 2384 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.ByteStart)); err != nil { 1766 2385 return err 1767 2386 } 1768 1768 - if _, err := cw.WriteString(string("predefinedActivityName")); err != nil { 2387 2387 + } else { 2388 2388 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.ByteStart-1)); err != nil { 1769 2389 return err 1770 2390 } 1771 1771 - 1772 1772 - if t.PredefinedActivityName == nil { 1773 1773 - if _, err := cw.Write(cbg.CborNull); err != nil { 1774 1774 - return err 1775 1775 - } 1776 1776 - } else { 1777 1777 - if len(*t.PredefinedActivityName) > 1000000 { 1778 1778 - return xerrors.Errorf("Value in field t.PredefinedActivityName was too long") 1779 1779 - } 2391 2391 + } 1780 2392 1781 1781 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.PredefinedActivityName))); err != nil { 1782 1782 - return err 1783 1783 - } 1784 1784 - if _, err := cw.WriteString(string(*t.PredefinedActivityName)); err != nil { 1785 1785 - return err 1786 1786 - } 1787 1787 - } 1788 1788 - } 1789 2393 return nil 1790 2394 } 1791 2395 1792 1792 - func (t *FeedSession) UnmarshalCBOR(r io.Reader) (err error) { 1793 1793 - *t = FeedSession{} 2396 2396 + func (t *RichtextFacet_ByteSlice) UnmarshalCBOR(r io.Reader) (err error) { 2397 2397 + *t = RichtextFacet_ByteSlice{} 1794 2398 1795 2399 cr := cbg.NewCborReader(r) 1796 2400 ··· 1809 2413 } 1810 2414 1811 2415 if extra > cbg.MaxLength { 1812 1812 - return fmt.Errorf("FeedSession: map struct too large (%d)", extra) 2416 2416 + return fmt.Errorf("RichtextFacet_ByteSlice: map struct too large (%d)", extra) 1813 2417 } 1814 2418 1815 2419 n := extra 1816 2420 1817 1817 - nameBuf := make([]byte, 22) 2421 2421 + nameBuf := make([]byte, 9) 1818 2422 for i := uint64(0); i < n; i++ { 1819 2423 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 1820 2424 if err != nil { ··· 1830 2434 } 1831 2435 1832 2436 switch string(nameBuf[:nameLen]) { 1833 1833 - // t.Date (string) (string) 1834 1834 - case "date": 1835 1835 - 2437 2437 + // t.ByteEnd (int64) (int64) 2438 2438 + case "byteEnd": 1836 2439 { 1837 1837 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2440 2440 + maj, extra, err := cr.ReadHeader() 1838 2441 if err != nil { 1839 2442 return err 1840 2443 } 1841 1841 - 1842 1842 - t.Date = string(sval) 1843 1843 - } 1844 1844 - // t.LexiconTypeID (string) (string) 1845 1845 - case "$type": 1846 1846 - 1847 1847 - { 1848 1848 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1849 1849 - if err != nil { 1850 1850 - return err 2444 2444 + var extraI int64 2445 2445 + switch maj { 2446 2446 + case cbg.MajUnsignedInt: 2447 2447 + extraI = int64(extra) 2448 2448 + if extraI < 0 { 2449 2449 + return fmt.Errorf("int64 positive overflow") 2450 2450 + } 2451 2451 + case cbg.MajNegativeInt: 2452 2452 + extraI = int64(extra) 2453 2453 + if extraI < 0 { 2454 2454 + return fmt.Errorf("int64 negative overflow") 2455 2455 + } 2456 2456 + extraI = -1 - extraI 2457 2457 + default: 2458 2458 + return fmt.Errorf("wrong type for int64 field: %d", maj) 1851 2459 } 1852 2460 1853 1853 - t.LexiconTypeID = string(sval) 2461 2461 + t.ByteEnd = int64(extraI) 1854 2462 } 1855 1855 - // t.Duration (int64) (int64) 1856 1856 - case "duration": 2463 2463 + // t.ByteStart (int64) (int64) 2464 2464 + case "byteStart": 1857 2465 { 1858 2466 maj, extra, err := cr.ReadHeader() 1859 2467 if err != nil { ··· 1876 2484 return fmt.Errorf("wrong type for int64 field: %d", maj) 1877 2485 } 1878 2486 1879 1879 - t.Duration = int64(extraI) 2487 2487 + t.ByteStart = int64(extraI) 1880 2488 } 1881 1881 - // t.Resource (yoten.FeedResource) (struct) 1882 1882 - case "resource": 1883 2489 1884 1884 - { 2490 2490 + default: 2491 2491 + // Field doesn't exist on this type, so ignore it 2492 2492 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 2493 2493 + return err 2494 2494 + } 2495 2495 + } 2496 2496 + } 1885 2497 1886 1886 - b, err := cr.ReadByte() 1887 1887 - if err != nil { 1888 1888 - return err 1889 1889 - } 1890 1890 - if b != cbg.CborNull[0] { 1891 1891 - if err := cr.UnreadByte(); err != nil { 1892 1892 - return err 1893 1893 - } 1894 1894 - t.Resource = new(FeedResource) 1895 1895 - if err := t.Resource.UnmarshalCBOR(cr); err != nil { 1896 1896 - return xerrors.Errorf("unmarshaling t.Resource pointer: %w", err) 1897 1897 - } 1898 1898 - } 2498 2498 + return nil 2499 2499 + } 2500 2500 + func (t *RichtextFacet_Features_Elem) MarshalCBOR(w io.Writer) error { 2501 2501 + if t == nil { 2502 2502 + _, err := w.Write(cbg.CborNull) 2503 2503 + return err 2504 2504 + } 1899 2505 1900 1900 - } 1901 1901 - // t.CreatedAt (string) (string) 1902 1902 - case "createdAt": 2506 2506 + cw := cbg.NewCborWriter(w) 1903 2507 1904 1904 - { 1905 1905 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1906 1906 - if err != nil { 1907 1907 - return err 1908 1908 - } 2508 2508 + if _, err := cw.Write([]byte{161}); err != nil { 2509 2509 + return err 2510 2510 + } 1909 2511 1910 1910 - t.CreatedAt = string(sval) 1911 1911 - } 1912 1912 - // t.Description (string) (string) 1913 1913 - case "description": 2512 2512 + // t.RichtextFacet_Mention (yoten.RichtextFacet_Mention) (struct) 2513 2513 + if len("RichtextFacet_Mention") > 1000000 { 2514 2514 + return xerrors.Errorf("Value in field \"RichtextFacet_Mention\" was too long") 2515 2515 + } 1914 2516 1915 1915 - { 1916 1916 - b, err := cr.ReadByte() 1917 1917 - if err != nil { 1918 1918 - return err 1919 1919 - } 1920 1920 - if b != cbg.CborNull[0] { 1921 1921 - if err := cr.UnreadByte(); err != nil { 1922 1922 - return err 1923 1923 - } 2517 2517 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("RichtextFacet_Mention"))); err != nil { 2518 2518 + return err 2519 2519 + } 2520 2520 + if _, err := cw.WriteString(string("RichtextFacet_Mention")); err != nil { 2521 2521 + return err 2522 2522 + } 1924 2523 1925 1925 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1926 1926 - if err != nil { 1927 1927 - return err 1928 1928 - } 2524 2524 + if err := t.RichtextFacet_Mention.MarshalCBOR(cw); err != nil { 2525 2525 + return err 2526 2526 + } 2527 2527 + return nil 2528 2528 + } 1929 2529 1930 1930 - t.Description = (*string)(&sval) 1931 1931 - } 1932 1932 - } 1933 1933 - // t.LanguageCode (string) (string) 1934 1934 - case "languageCode": 2530 2530 + func (t *RichtextFacet_Features_Elem) UnmarshalCBOR(r io.Reader) (err error) { 2531 2531 + *t = RichtextFacet_Features_Elem{} 1935 2532 1936 1936 - { 1937 1937 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1938 1938 - if err != nil { 1939 1939 - return err 1940 1940 - } 2533 2533 + cr := cbg.NewCborReader(r) 1941 2534 1942 1942 - t.LanguageCode = string(sval) 1943 1943 - } 1944 1944 - // t.UserActivityRef (yoten.ActivityDef) (struct) 1945 1945 - case "userActivityRef": 2535 2535 + maj, extra, err := cr.ReadHeader() 2536 2536 + if err != nil { 2537 2537 + return err 2538 2538 + } 2539 2539 + defer func() { 2540 2540 + if err == io.EOF { 2541 2541 + err = io.ErrUnexpectedEOF 2542 2542 + } 2543 2543 + }() 1946 2544 1947 1947 - { 2545 2545 + if maj != cbg.MajMap { 2546 2546 + return fmt.Errorf("cbor input should be of type map") 2547 2547 + } 1948 2548 1949 1949 - b, err := cr.ReadByte() 1950 1950 - if err != nil { 1951 1951 - return err 1952 1952 - } 1953 1953 - if b != cbg.CborNull[0] { 1954 1954 - if err := cr.UnreadByte(); err != nil { 1955 1955 - return err 1956 1956 - } 1957 1957 - t.UserActivityRef = new(ActivityDef) 1958 1958 - if err := t.UserActivityRef.UnmarshalCBOR(cr); err != nil { 1959 1959 - return xerrors.Errorf("unmarshaling t.UserActivityRef pointer: %w", err) 1960 1960 - } 1961 1961 - } 2549 2549 + if extra > cbg.MaxLength { 2550 2550 + return fmt.Errorf("RichtextFacet_Features_Elem: map struct too large (%d)", extra) 2551 2551 + } 1962 2552 2553 2553 + n := extra 2554 2554 + 2555 2555 + nameBuf := make([]byte, 21) 2556 2556 + for i := uint64(0); i < n; i++ { 2557 2557 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2558 2558 + if err != nil { 2559 2559 + return err 2560 2560 + } 2561 2561 + 2562 2562 + if !ok { 2563 2563 + // Field doesn't exist on this type, so ignore it 2564 2564 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 2565 2565 + return err 1963 2566 } 1964 1964 - // t.PredefinedActivityName (string) (string) 1965 1965 - case "predefinedActivityName": 2567 2567 + continue 2568 2568 + } 2569 2569 + 2570 2570 + switch string(nameBuf[:nameLen]) { 2571 2571 + // t.RichtextFacet_Mention (yoten.RichtextFacet_Mention) (struct) 2572 2572 + case "RichtextFacet_Mention": 1966 2573 1967 2574 { 2575 2575 + 1968 2576 b, err := cr.ReadByte() 1969 2577 if err != nil { 1970 2578 return err ··· 1973 2581 if err := cr.UnreadByte(); err != nil { 1974 2582 return err 1975 2583 } 1976 1976 - 1977 1977 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 1978 1978 - if err != nil { 1979 1979 - return err 2584 2584 + t.RichtextFacet_Mention = new(RichtextFacet_Mention) 2585 2585 + if err := t.RichtextFacet_Mention.UnmarshalCBOR(cr); err != nil { 2586 2586 + return xerrors.Errorf("unmarshaling t.RichtextFacet_Mention pointer: %w", err) 1980 2587 } 2588 2588 + } 1981 2589 1982 1982 - t.PredefinedActivityName = (*string)(&sval) 1983 1983 - } 1984 2590 } 1985 2591 1986 2592 default: ··· 1993 2599 1994 2600 return nil 1995 2601 } 1996 1996 - func (t *GraphFollow) MarshalCBOR(w io.Writer) error { 2602 2602 + func (t *RichtextFacet_Mention) MarshalCBOR(w io.Writer) error { 1997 2603 if t == nil { 1998 2604 _, err := w.Write(cbg.CborNull) 1999 2605 return err ··· 2001 2607 2002 2608 cw := cbg.NewCborWriter(w) 2003 2609 2004 2004 - if _, err := cw.Write([]byte{163}); err != nil { 2610 2610 + if _, err := cw.Write([]byte{162}); err != nil { 2005 2611 return err 2006 2612 } 2007 2613 2008 2008 - // t.LexiconTypeID (string) (string) 2009 2009 - if len("$type") > 1000000 { 2010 2010 - return xerrors.Errorf("Value in field \"$type\" was too long") 2614 2614 + // t.Did (string) (string) 2615 2615 + if len("did") > 1000000 { 2616 2616 + return xerrors.Errorf("Value in field \"did\" was too long") 2011 2617 } 2012 2618 2013 2013 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2619 2619 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("did"))); err != nil { 2014 2620 return err 2015 2621 } 2016 2016 - if _, err := cw.WriteString(string("$type")); err != nil { 2622 2622 + if _, err := cw.WriteString(string("did")); err != nil { 2017 2623 return err 2018 2624 } 2019 2625 2020 2020 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.graph.follow"))); err != nil { 2021 2021 - return err 2022 2022 - } 2023 2023 - if _, err := cw.WriteString(string("app.yoten.graph.follow")); err != nil { 2024 2024 - return err 2626 2626 + if len(t.Did) > 1000000 { 2627 2627 + return xerrors.Errorf("Value in field t.Did was too long") 2025 2628 } 2026 2629 2027 2027 - // t.Subject (string) (string) 2028 2028 - if len("subject") > 1000000 { 2029 2029 - return xerrors.Errorf("Value in field \"subject\" was too long") 2030 2030 - } 2031 2031 - 2032 2032 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("subject"))); err != nil { 2630 2630 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Did))); err != nil { 2033 2631 return err 2034 2632 } 2035 2035 - if _, err := cw.WriteString(string("subject")); err != nil { 2633 2633 + if _, err := cw.WriteString(string(t.Did)); err != nil { 2036 2634 return err 2037 2635 } 2038 2636 2039 2039 - if len(t.Subject) > 1000000 { 2040 2040 - return xerrors.Errorf("Value in field t.Subject was too long") 2637 2637 + // t.LexiconTypeID (string) (string) 2638 2638 + if len("$type") > 1000000 { 2639 2639 + return xerrors.Errorf("Value in field \"$type\" was too long") 2041 2640 } 2042 2641 2043 2043 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Subject))); err != nil { 2642 2642 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("$type"))); err != nil { 2044 2643 return err 2045 2644 } 2046 2046 - if _, err := cw.WriteString(string(t.Subject)); err != nil { 2645 2645 + if _, err := cw.WriteString(string("$type")); err != nil { 2047 2646 return err 2048 2647 } 2049 2648 2050 2050 - // t.CreatedAt (string) (string) 2051 2051 - if len("createdAt") > 1000000 { 2052 2052 - return xerrors.Errorf("Value in field \"createdAt\" was too long") 2053 2053 - } 2054 2054 - 2055 2055 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("createdAt"))); err != nil { 2649 2649 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("app.yoten.richtext.facet#mention"))); err != nil { 2056 2650 return err 2057 2651 } 2058 2058 - if _, err := cw.WriteString(string("createdAt")); err != nil { 2059 2059 - return err 2060 2060 - } 2061 2061 - 2062 2062 - if len(t.CreatedAt) > 1000000 { 2063 2063 - return xerrors.Errorf("Value in field t.CreatedAt was too long") 2064 2064 - } 2065 2065 - 2066 2066 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.CreatedAt))); err != nil { 2067 2067 - return err 2068 2068 - } 2069 2069 - if _, err := cw.WriteString(string(t.CreatedAt)); err != nil { 2652 2652 + if _, err := cw.WriteString(string("app.yoten.richtext.facet#mention")); err != nil { 2070 2653 return err 2071 2654 } 2072 2655 return nil 2073 2656 } 2074 2657 2075 2075 - func (t *GraphFollow) UnmarshalCBOR(r io.Reader) (err error) { 2076 2076 - *t = GraphFollow{} 2658 2658 + func (t *RichtextFacet_Mention) UnmarshalCBOR(r io.Reader) (err error) { 2659 2659 + *t = RichtextFacet_Mention{} 2077 2660 2078 2661 cr := cbg.NewCborReader(r) 2079 2662 ··· 2092 2675 } 2093 2676 2094 2677 if extra > cbg.MaxLength { 2095 2095 - return fmt.Errorf("GraphFollow: map struct too large (%d)", extra) 2678 2678 + return fmt.Errorf("RichtextFacet_Mention: map struct too large (%d)", extra) 2096 2679 } 2097 2680 2098 2681 n := extra 2099 2682 2100 2100 - nameBuf := make([]byte, 9) 2683 2683 + nameBuf := make([]byte, 5) 2101 2684 for i := uint64(0); i < n; i++ { 2102 2685 nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 2103 2686 if err != nil { ··· 2113 2696 } 2114 2697 2115 2698 switch string(nameBuf[:nameLen]) { 2116 2116 - // t.LexiconTypeID (string) (string) 2117 2117 - case "$type": 2699 2699 + // t.Did (string) (string) 2700 2700 + case "did": 2118 2701 2119 2702 { 2120 2703 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 2122 2705 return err 2123 2706 } 2124 2707 2125 2125 - t.LexiconTypeID = string(sval) 2708 2708 + t.Did = string(sval) 2126 2709 } 2127 2127 - // t.Subject (string) (string) 2128 2128 - case "subject": 2710 2710 + // t.LexiconTypeID (string) (string) 2711 2711 + case "$type": 2129 2712 2130 2713 { 2131 2714 sval, err := cbg.ReadStringWithMax(cr, 1000000) ··· 2133 2716 return err 2134 2717 } 2135 2718 2136 2136 - t.Subject = string(sval) 2137 2137 - } 2138 2138 - // t.CreatedAt (string) (string) 2139 2139 - case "createdAt": 2140 2140 - 2141 2141 - { 2142 2142 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 2143 2143 - if err != nil { 2144 2144 - return err 2145 2145 - } 2146 2146 - 2147 2147 - t.CreatedAt = string(sval) 2719 2719 + t.LexiconTypeID = string(sval) 2148 2720 } 2149 2721 2150 2722 default:

+8 -31

cmd/cborgen.go

View file Reviewed

··· 1 1 package main 2 2 3 3 import ( 4 4 - "maps" 5 5 - "reflect" 6 6 - "strings" 7 7 - 8 8 - "github.com/bluesky-social/indigo/mst" 9 4 cbg "github.com/whyrusleeping/cbor-gen" 10 10 - 11 5 "yoten.app/api/yoten" 12 6 ) 13 7 14 8 func main() { 15 15 - var typVals []any 16 16 - for _, typ := range mst.CBORTypes() { 17 17 - typVals = append(typVals, reflect.New(typ).Elem().Interface()) 18 18 - } 19 19 - 20 9 genCfg := cbg.Gen{ 21 10 MaxStringLength: 1_000_000, 22 11 } 23 12 24 24 - yotenTypes := []any{ 13 13 + if err := genCfg.WriteMapEncodersToFile( 14 14 + "api/yoten/cbor_gen.go", 15 15 + "yoten", 25 16 yoten.ActorProfile{}, 26 17 yoten.FeedSession{}, 27 18 yoten.FeedResource{}, ··· 30 21 yoten.FeedReaction{}, 31 22 yoten.FeedComment{}, 32 23 yoten.FeedComment_Reply{}, 33 33 - } 34 34 - 35 35 - for name, rt := range AllLexTypes() { 36 36 - if strings.HasPrefix(name, "app.yoten.") { 37 37 - yotenTypes = append(yotenTypes, reflect.New(rt).Interface()) 38 38 - } 39 39 - } 40 40 - yotenGenCfg := genCfg 41 41 - yotenGenCfg.SortTypeNames = true 42 42 - 43 43 - if err := yotenGenCfg.WriteMapEncodersToFile("api/yoten/cbor_gen.go", "yoten", yotenTypes...); err != nil { 24 24 + yoten.RichtextFacet{}, 25 25 + yoten.RichtextFacet_ByteSlice{}, 26 26 + yoten.RichtextFacet_Features_Elem{}, 27 27 + yoten.RichtextFacet_Mention{}, 28 28 + ); err != nil { 44 29 panic(err) 45 30 } 46 31 } 47 47 - 48 48 - var lexTypesMap map[string]reflect.Type 49 49 - 50 50 - func AllLexTypes() map[string]reflect.Type { 51 51 - out := make(map[string]reflect.Type, len(lexTypesMap)) 52 52 - maps.Copy(out, lexTypesMap) 53 53 - return out 54 54 - }

+21 -13

generate-lexicons.sh

View file Reviewed

··· 1 1 #! /bin/bash 2 2 3 3 - go run github.com/bluesky-social/indigo/cmd/lexgen \ 4 4 - --package yoten \ 5 5 - --outdir api/yoten \ 6 6 - --build-file lexicon-build-config.json \ 7 7 - lexicons/ 3 3 + # https://tangled.org/oppi.li/indigo 4 4 + # generates NSID consts for types 5 5 + 6 6 + rm -f api/yoten/* 7 7 + 8 8 + /usr/bin/lexgen \ 9 9 + --build-file lexicon-build-config.json \ 10 10 + lexicons 11 11 + 12 12 + sed -i.bak 's/\tutil/\/\/\tutil/' api/yoten/* 8 13 9 9 - find ./api/shelf -type f -exec sed -i.bak 's/\lexutil/\/\/\lexutil/' {} + 10 10 - find ./api/shelf -type f -exec sed -i.bak -E 's/^(.+)github(.+)//' {} + 14 14 + # lexgen generates incomplete Marshaler/Unmarshaler for union types 15 15 + find api/yoten/*.go -not -name "cbor_gen.go" -exec \ 16 16 + sed -i '/^func.*\(MarshalCBOR\|MarshalJSON\|UnmarshalJSON\|UnmarshalCBOR\)/,/^}/ s/^/\/\/ /' {} + 17 17 + 18 18 + goimports -w api/yoten/* 19 19 + 11 20 go run ./cmd/cborgen.go 12 21 13 13 - go run github.com/bluesky-social/indigo/cmd/lexgen \ 14 14 - --package yoten \ 15 15 - --outdir api/yoten \ 16 16 - --build-file lexicon-build-config.json \ 17 17 - lexicons/ 22 22 + /usr/bin/lexgen \ 23 23 + --build-file lexicon-build-config.json \ 24 24 + lexicons 18 25 19 19 - rm -rf ./api/yoten/*.bak 26 26 + rm api/yoten/*.bak 27 27 +