+580 -49

api/tangled/cbor_gen.go

Reviewed

··· 11324 11324 } 11325 11325 11326 11326 cw := cbg.NewCborWriter(w) 11327 11327 + fieldCount := 7 11327 11328 11328 11328 - if _, err := cw.Write([]byte{165}); err != nil { 11329 11329 + if t.Contents == nil { 11330 11330 + fieldCount-- 11331 11331 + } 11332 11332 + 11333 11333 + if t.Description == nil { 11334 11334 + fieldCount-- 11335 11335 + } 11336 11336 + 11337 11337 + if t.Filename == nil { 11338 11338 + fieldCount-- 11339 11339 + } 11340 11340 + 11341 11341 + if t.Title == nil { 11342 11342 + fieldCount-- 11343 11343 + } 11344 11344 + 11345 11345 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 11329 11346 return err 11330 11347 } 11331 11348 ··· 11348 11365 return err 11349 11366 } 11350 11367 11351 11351 - // t.Contents (string) (string) 11352 11352 - if len("contents") > 1000000 { 11353 11353 - return xerrors.Errorf("Value in field \"contents\" was too long") 11368 11368 + // t.Files ([]*tangled.String_File) (slice) 11369 11369 + if len("files") > 1000000 { 11370 11370 + return xerrors.Errorf("Value in field \"files\" was too long") 11354 11371 } 11355 11372 11356 11356 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil { 11373 11373 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("files"))); err != nil { 11357 11374 return err 11358 11375 } 11359 11359 - if _, err := cw.WriteString(string("contents")); err != nil { 11376 11376 + if _, err := cw.WriteString(string("files")); err != nil { 11360 11377 return err 11361 11378 } 11362 11379 11363 11363 - if len(t.Contents) > 1000000 { 11364 11364 - return xerrors.Errorf("Value in field t.Contents was too long") 11380 11380 + if len(t.Files) > 8192 { 11381 11381 + return xerrors.Errorf("Slice value in field t.Files was too long") 11365 11382 } 11366 11383 11367 11367 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil { 11384 11384 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Files))); err != nil { 11368 11385 return err 11369 11386 } 11370 11370 - if _, err := cw.WriteString(string(t.Contents)); err != nil { 11371 11371 - return err 11387 11387 + for _, v := range t.Files { 11388 11388 + if err := v.MarshalCBOR(cw); err != nil { 11389 11389 + return err 11390 11390 + } 11391 11391 + 11372 11392 } 11373 11393 11374 11374 - // t.Filename (string) (string) 11375 11375 - if len("filename") > 1000000 { 11376 11376 - return xerrors.Errorf("Value in field \"filename\" was too long") 11377 11377 - } 11394 11394 + // t.Title (string) (string) 11395 11395 + if t.Title != nil { 11378 11396 11379 11379 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil { 11380 11380 - return err 11381 11381 - } 11382 11382 - if _, err := cw.WriteString(string("filename")); err != nil { 11383 11383 - return err 11384 11384 - } 11397 11397 + if len("title") > 1000000 { 11398 11398 + return xerrors.Errorf("Value in field \"title\" was too long") 11399 11399 + } 11400 11400 + 11401 11401 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 11402 11402 + return err 11403 11403 + } 11404 11404 + if _, err := cw.WriteString(string("title")); err != nil { 11405 11405 + return err 11406 11406 + } 11407 11407 + 11408 11408 + if t.Title == nil { 11409 11409 + if _, err := cw.Write(cbg.CborNull); err != nil { 11410 11410 + return err 11411 11411 + } 11412 11412 + } else { 11413 11413 + if len(*t.Title) > 1000000 { 11414 11414 + return xerrors.Errorf("Value in field t.Title was too long") 11415 11415 + } 11385 11416 11386 11386 - if len(t.Filename) > 1000000 { 11387 11387 - return xerrors.Errorf("Value in field t.Filename was too long") 11417 11417 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Title))); err != nil { 11418 11418 + return err 11419 11419 + } 11420 11420 + if _, err := cw.WriteString(string(*t.Title)); err != nil { 11421 11421 + return err 11422 11422 + } 11423 11423 + } 11388 11424 } 11389 11425 11390 11390 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil { 11391 11391 - return err 11426 11426 + // t.Contents (string) (string) 11427 11427 + if t.Contents != nil { 11428 11428 + 11429 11429 + if len("contents") > 1000000 { 11430 11430 + return xerrors.Errorf("Value in field \"contents\" was too long") 11431 11431 + } 11432 11432 + 11433 11433 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil { 11434 11434 + return err 11435 11435 + } 11436 11436 + if _, err := cw.WriteString(string("contents")); err != nil { 11437 11437 + return err 11438 11438 + } 11439 11439 + 11440 11440 + if t.Contents == nil { 11441 11441 + if _, err := cw.Write(cbg.CborNull); err != nil { 11442 11442 + return err 11443 11443 + } 11444 11444 + } else { 11445 11445 + if len(*t.Contents) > 1000000 { 11446 11446 + return xerrors.Errorf("Value in field t.Contents was too long") 11447 11447 + } 11448 11448 + 11449 11449 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Contents))); err != nil { 11450 11450 + return err 11451 11451 + } 11452 11452 + if _, err := cw.WriteString(string(*t.Contents)); err != nil { 11453 11453 + return err 11454 11454 + } 11455 11455 + } 11392 11456 } 11393 11393 - if _, err := cw.WriteString(string(t.Filename)); err != nil { 11394 11394 - return err 11457 11457 + 11458 11458 + // t.Filename (string) (string) 11459 11459 + if t.Filename != nil { 11460 11460 + 11461 11461 + if len("filename") > 1000000 { 11462 11462 + return xerrors.Errorf("Value in field \"filename\" was too long") 11463 11463 + } 11464 11464 + 11465 11465 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil { 11466 11466 + return err 11467 11467 + } 11468 11468 + if _, err := cw.WriteString(string("filename")); err != nil { 11469 11469 + return err 11470 11470 + } 11471 11471 + 11472 11472 + if t.Filename == nil { 11473 11473 + if _, err := cw.Write(cbg.CborNull); err != nil { 11474 11474 + return err 11475 11475 + } 11476 11476 + } else { 11477 11477 + if len(*t.Filename) > 1000000 { 11478 11478 + return xerrors.Errorf("Value in field t.Filename was too long") 11479 11479 + } 11480 11480 + 11481 11481 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Filename))); err != nil { 11482 11482 + return err 11483 11483 + } 11484 11484 + if _, err := cw.WriteString(string(*t.Filename)); err != nil { 11485 11485 + return err 11486 11486 + } 11487 11487 + } 11395 11488 } 11396 11489 11397 11490 // t.CreatedAt (string) (string) ··· 11418 11511 } 11419 11512 11420 11513 // t.Description (string) (string) 11421 11421 - if len("description") > 1000000 { 11422 11422 - return xerrors.Errorf("Value in field \"description\" was too long") 11423 11423 - } 11514 11514 + if t.Description != nil { 11515 11515 + 11516 11516 + if len("description") > 1000000 { 11517 11517 + return xerrors.Errorf("Value in field \"description\" was too long") 11518 11518 + } 11424 11519 11425 11425 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 11426 11426 - return err 11427 11427 - } 11428 11428 - if _, err := cw.WriteString(string("description")); err != nil { 11429 11429 - return err 11430 11430 - } 11520 11520 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 11521 11521 + return err 11522 11522 + } 11523 11523 + if _, err := cw.WriteString(string("description")); err != nil { 11524 11524 + return err 11525 11525 + } 11431 11526 11432 11432 - if len(t.Description) > 1000000 { 11433 11433 - return xerrors.Errorf("Value in field t.Description was too long") 11434 11434 - } 11527 11527 + if t.Description == nil { 11528 11528 + if _, err := cw.Write(cbg.CborNull); err != nil { 11529 11529 + return err 11530 11530 + } 11531 11531 + } else { 11532 11532 + if len(*t.Description) > 1000000 { 11533 11533 + return xerrors.Errorf("Value in field t.Description was too long") 11534 11534 + } 11435 11535 11436 11436 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil { 11437 11437 - return err 11438 11438 - } 11439 11439 - if _, err := cw.WriteString(string(t.Description)); err != nil { 11440 11440 - return err 11536 11536 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 11537 11537 + return err 11538 11538 + } 11539 11539 + if _, err := cw.WriteString(string(*t.Description)); err != nil { 11540 11540 + return err 11541 11541 + } 11542 11542 + } 11441 11543 } 11442 11544 return nil 11443 11545 } ··· 11494 11596 11495 11597 t.LexiconTypeID = string(sval) 11496 11598 } 11599 11599 + // t.Files ([]*tangled.String_File) (slice) 11600 11600 + case "files": 11601 11601 + 11602 11602 + maj, extra, err = cr.ReadHeader() 11603 11603 + if err != nil { 11604 11604 + return err 11605 11605 + } 11606 11606 + 11607 11607 + if extra > 8192 { 11608 11608 + return fmt.Errorf("t.Files: array too large (%d)", extra) 11609 11609 + } 11610 11610 + 11611 11611 + if maj != cbg.MajArray { 11612 11612 + return fmt.Errorf("expected cbor array") 11613 11613 + } 11614 11614 + 11615 11615 + if extra > 0 { 11616 11616 + t.Files = make([]*String_File, extra) 11617 11617 + } 11618 11618 + 11619 11619 + for i := 0; i < int(extra); i++ { 11620 11620 + { 11621 11621 + var maj byte 11622 11622 + var extra uint64 11623 11623 + var err error 11624 11624 + _ = maj 11625 11625 + _ = extra 11626 11626 + _ = err 11627 11627 + 11628 11628 + { 11629 11629 + 11630 11630 + b, err := cr.ReadByte() 11631 11631 + if err != nil { 11632 11632 + return err 11633 11633 + } 11634 11634 + if b != cbg.CborNull[0] { 11635 11635 + if err := cr.UnreadByte(); err != nil { 11636 11636 + return err 11637 11637 + } 11638 11638 + t.Files[i] = new(String_File) 11639 11639 + if err := t.Files[i].UnmarshalCBOR(cr); err != nil { 11640 11640 + return xerrors.Errorf("unmarshaling t.Files[i] pointer: %w", err) 11641 11641 + } 11642 11642 + } 11643 11643 + 11644 11644 + } 11645 11645 + 11646 11646 + } 11647 11647 + } 11648 11648 + // t.Title (string) (string) 11649 11649 + case "title": 11650 11650 + 11651 11651 + { 11652 11652 + b, err := cr.ReadByte() 11653 11653 + if err != nil { 11654 11654 + return err 11655 11655 + } 11656 11656 + if b != cbg.CborNull[0] { 11657 11657 + if err := cr.UnreadByte(); err != nil { 11658 11658 + return err 11659 11659 + } 11660 11660 + 11661 11661 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11662 11662 + if err != nil { 11663 11663 + return err 11664 11664 + } 11665 11665 + 11666 11666 + t.Title = (*string)(&sval) 11667 11667 + } 11668 11668 + } 11497 11669 // t.Contents (string) (string) 11498 11670 case "contents": 11499 11671 11500 11672 { 11501 11501 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 11673 11673 + b, err := cr.ReadByte() 11502 11674 if err != nil { 11503 11675 return err 11504 11676 } 11677 11677 + if b != cbg.CborNull[0] { 11678 11678 + if err := cr.UnreadByte(); err != nil { 11679 11679 + return err 11680 11680 + } 11505 11681 11506 11506 - t.Contents = string(sval) 11682 11682 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11683 11683 + if err != nil { 11684 11684 + return err 11685 11685 + } 11686 11686 + 11687 11687 + t.Contents = (*string)(&sval) 11688 11688 + } 11507 11689 } 11508 11690 // t.Filename (string) (string) 11509 11691 case "filename": 11510 11692 11511 11693 { 11512 11512 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 11694 11694 + b, err := cr.ReadByte() 11513 11695 if err != nil { 11514 11696 return err 11515 11697 } 11698 11698 + if b != cbg.CborNull[0] { 11699 11699 + if err := cr.UnreadByte(); err != nil { 11700 11700 + return err 11701 11701 + } 11516 11702 11517 11517 - t.Filename = string(sval) 11703 11703 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11704 11704 + if err != nil { 11705 11705 + return err 11706 11706 + } 11707 11707 + 11708 11708 + t.Filename = (*string)(&sval) 11709 11709 + } 11518 11710 } 11519 11711 // t.CreatedAt (string) (string) 11520 11712 case "createdAt": ··· 11531 11723 case "description": 11532 11724 11533 11725 { 11726 11726 + b, err := cr.ReadByte() 11727 11727 + if err != nil { 11728 11728 + return err 11729 11729 + } 11730 11730 + if b != cbg.CborNull[0] { 11731 11731 + if err := cr.UnreadByte(); err != nil { 11732 11732 + return err 11733 11733 + } 11734 11734 + 11735 11735 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11736 11736 + if err != nil { 11737 11737 + return err 11738 11738 + } 11739 11739 + 11740 11740 + t.Description = (*string)(&sval) 11741 11741 + } 11742 11742 + } 11743 11743 + 11744 11744 + default: 11745 11745 + // Field doesn't exist on this type, so ignore it 11746 11746 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 11747 11747 + return err 11748 11748 + } 11749 11749 + } 11750 11750 + } 11751 11751 + 11752 11752 + return nil 11753 11753 + } 11754 11754 + func (t *String_File) MarshalCBOR(w io.Writer) error { 11755 11755 + if t == nil { 11756 11756 + _, err := w.Write(cbg.CborNull) 11757 11757 + return err 11758 11758 + } 11759 11759 + 11760 11760 + cw := cbg.NewCborWriter(w) 11761 11761 + fieldCount := 3 11762 11762 + 11763 11763 + if t.Gzip == nil { 11764 11764 + fieldCount-- 11765 11765 + } 11766 11766 + 11767 11767 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 11768 11768 + return err 11769 11769 + } 11770 11770 + 11771 11771 + // t.Gzip (tangled.String_File_Gzip) (struct) 11772 11772 + if t.Gzip != nil { 11773 11773 + 11774 11774 + if len("gzip") > 1000000 { 11775 11775 + return xerrors.Errorf("Value in field \"gzip\" was too long") 11776 11776 + } 11777 11777 + 11778 11778 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("gzip"))); err != nil { 11779 11779 + return err 11780 11780 + } 11781 11781 + if _, err := cw.WriteString(string("gzip")); err != nil { 11782 11782 + return err 11783 11783 + } 11784 11784 + 11785 11785 + if err := t.Gzip.MarshalCBOR(cw); err != nil { 11786 11786 + return err 11787 11787 + } 11788 11788 + } 11789 11789 + 11790 11790 + // t.Name (string) (string) 11791 11791 + if len("name") > 1000000 { 11792 11792 + return xerrors.Errorf("Value in field \"name\" was too long") 11793 11793 + } 11794 11794 + 11795 11795 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 11796 11796 + return err 11797 11797 + } 11798 11798 + if _, err := cw.WriteString(string("name")); err != nil { 11799 11799 + return err 11800 11800 + } 11801 11801 + 11802 11802 + if len(t.Name) > 1000000 { 11803 11803 + return xerrors.Errorf("Value in field t.Name was too long") 11804 11804 + } 11805 11805 + 11806 11806 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 11807 11807 + return err 11808 11808 + } 11809 11809 + if _, err := cw.WriteString(string(t.Name)); err != nil { 11810 11810 + return err 11811 11811 + } 11812 11812 + 11813 11813 + // t.Content (util.LexBlob) (struct) 11814 11814 + if len("content") > 1000000 { 11815 11815 + return xerrors.Errorf("Value in field \"content\" was too long") 11816 11816 + } 11817 11817 + 11818 11818 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("content"))); err != nil { 11819 11819 + return err 11820 11820 + } 11821 11821 + if _, err := cw.WriteString(string("content")); err != nil { 11822 11822 + return err 11823 11823 + } 11824 11824 + 11825 11825 + if err := t.Content.MarshalCBOR(cw); err != nil { 11826 11826 + return err 11827 11827 + } 11828 11828 + return nil 11829 11829 + } 11830 11830 + 11831 11831 + func (t *String_File) UnmarshalCBOR(r io.Reader) (err error) { 11832 11832 + *t = String_File{} 11833 11833 + 11834 11834 + cr := cbg.NewCborReader(r) 11835 11835 + 11836 11836 + maj, extra, err := cr.ReadHeader() 11837 11837 + if err != nil { 11838 11838 + return err 11839 11839 + } 11840 11840 + defer func() { 11841 11841 + if err == io.EOF { 11842 11842 + err = io.ErrUnexpectedEOF 11843 11843 + } 11844 11844 + }() 11845 11845 + 11846 11846 + if maj != cbg.MajMap { 11847 11847 + return fmt.Errorf("cbor input should be of type map") 11848 11848 + } 11849 11849 + 11850 11850 + if extra > cbg.MaxLength { 11851 11851 + return fmt.Errorf("String_File: map struct too large (%d)", extra) 11852 11852 + } 11853 11853 + 11854 11854 + n := extra 11855 11855 + 11856 11856 + nameBuf := make([]byte, 7) 11857 11857 + for i := uint64(0); i < n; i++ { 11858 11858 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 11859 11859 + if err != nil { 11860 11860 + return err 11861 11861 + } 11862 11862 + 11863 11863 + if !ok { 11864 11864 + // Field doesn't exist on this type, so ignore it 11865 11865 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 11866 11866 + return err 11867 11867 + } 11868 11868 + continue 11869 11869 + } 11870 11870 + 11871 11871 + switch string(nameBuf[:nameLen]) { 11872 11872 + // t.Gzip (tangled.String_File_Gzip) (struct) 11873 11873 + case "gzip": 11874 11874 + 11875 11875 + { 11876 11876 + 11877 11877 + b, err := cr.ReadByte() 11878 11878 + if err != nil { 11879 11879 + return err 11880 11880 + } 11881 11881 + if b != cbg.CborNull[0] { 11882 11882 + if err := cr.UnreadByte(); err != nil { 11883 11883 + return err 11884 11884 + } 11885 11885 + t.Gzip = new(String_File_Gzip) 11886 11886 + if err := t.Gzip.UnmarshalCBOR(cr); err != nil { 11887 11887 + return xerrors.Errorf("unmarshaling t.Gzip pointer: %w", err) 11888 11888 + } 11889 11889 + } 11890 11890 + 11891 11891 + } 11892 11892 + // t.Name (string) (string) 11893 11893 + case "name": 11894 11894 + 11895 11895 + { 11534 11896 sval, err := cbg.ReadStringWithMax(cr, 1000000) 11535 11897 if err != nil { 11536 11898 return err 11537 11899 } 11538 11900 11539 11539 - t.Description = string(sval) 11901 11901 + t.Name = string(sval) 11902 11902 + } 11903 11903 + // t.Content (util.LexBlob) (struct) 11904 11904 + case "content": 11905 11905 + 11906 11906 + { 11907 11907 + 11908 11908 + b, err := cr.ReadByte() 11909 11909 + if err != nil { 11910 11910 + return err 11911 11911 + } 11912 11912 + if b != cbg.CborNull[0] { 11913 11913 + if err := cr.UnreadByte(); err != nil { 11914 11914 + return err 11915 11915 + } 11916 11916 + t.Content = new(util.LexBlob) 11917 11917 + if err := t.Content.UnmarshalCBOR(cr); err != nil { 11918 11918 + return xerrors.Errorf("unmarshaling t.Content pointer: %w", err) 11919 11919 + } 11920 11920 + } 11921 11921 + 11922 11922 + } 11923 11923 + 11924 11924 + default: 11925 11925 + // Field doesn't exist on this type, so ignore it 11926 11926 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 11927 11927 + return err 11928 11928 + } 11929 11929 + } 11930 11930 + } 11931 11931 + 11932 11932 + return nil 11933 11933 + } 11934 11934 + func (t *String_File_Gzip) MarshalCBOR(w io.Writer) error { 11935 11935 + if t == nil { 11936 11936 + _, err := w.Write(cbg.CborNull) 11937 11937 + return err 11938 11938 + } 11939 11939 + 11940 11940 + cw := cbg.NewCborWriter(w) 11941 11941 + 11942 11942 + if _, err := cw.Write([]byte{162}); err != nil { 11943 11943 + return err 11944 11944 + } 11945 11945 + 11946 11946 + // t.RealMime (string) (string) 11947 11947 + if len("realMime") > 1000000 { 11948 11948 + return xerrors.Errorf("Value in field \"realMime\" was too long") 11949 11949 + } 11950 11950 + 11951 11951 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("realMime"))); err != nil { 11952 11952 + return err 11953 11953 + } 11954 11954 + if _, err := cw.WriteString(string("realMime")); err != nil { 11955 11955 + return err 11956 11956 + } 11957 11957 + 11958 11958 + if len(t.RealMime) > 1000000 { 11959 11959 + return xerrors.Errorf("Value in field t.RealMime was too long") 11960 11960 + } 11961 11961 + 11962 11962 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RealMime))); err != nil { 11963 11963 + return err 11964 11964 + } 11965 11965 + if _, err := cw.WriteString(string(t.RealMime)); err != nil { 11966 11966 + return err 11967 11967 + } 11968 11968 + 11969 11969 + // t.RealSize (int64) (int64) 11970 11970 + if len("realSize") > 1000000 { 11971 11971 + return xerrors.Errorf("Value in field \"realSize\" was too long") 11972 11972 + } 11973 11973 + 11974 11974 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("realSize"))); err != nil { 11975 11975 + return err 11976 11976 + } 11977 11977 + if _, err := cw.WriteString(string("realSize")); err != nil { 11978 11978 + return err 11979 11979 + } 11980 11980 + 11981 11981 + if t.RealSize >= 0 { 11982 11982 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.RealSize)); err != nil { 11983 11983 + return err 11984 11984 + } 11985 11985 + } else { 11986 11986 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.RealSize-1)); err != nil { 11987 11987 + return err 11988 11988 + } 11989 11989 + } 11990 11990 + 11991 11991 + return nil 11992 11992 + } 11993 11993 + 11994 11994 + func (t *String_File_Gzip) UnmarshalCBOR(r io.Reader) (err error) { 11995 11995 + *t = String_File_Gzip{} 11996 11996 + 11997 11997 + cr := cbg.NewCborReader(r) 11998 11998 + 11999 11999 + maj, extra, err := cr.ReadHeader() 12000 12000 + if err != nil { 12001 12001 + return err 12002 12002 + } 12003 12003 + defer func() { 12004 12004 + if err == io.EOF { 12005 12005 + err = io.ErrUnexpectedEOF 12006 12006 + } 12007 12007 + }() 12008 12008 + 12009 12009 + if maj != cbg.MajMap { 12010 12010 + return fmt.Errorf("cbor input should be of type map") 12011 12011 + } 12012 12012 + 12013 12013 + if extra > cbg.MaxLength { 12014 12014 + return fmt.Errorf("String_File_Gzip: map struct too large (%d)", extra) 12015 12015 + } 12016 12016 + 12017 12017 + n := extra 12018 12018 + 12019 12019 + nameBuf := make([]byte, 8) 12020 12020 + for i := uint64(0); i < n; i++ { 12021 12021 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 12022 12022 + if err != nil { 12023 12023 + return err 12024 12024 + } 12025 12025 + 12026 12026 + if !ok { 12027 12027 + // Field doesn't exist on this type, so ignore it 12028 12028 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 12029 12029 + return err 12030 12030 + } 12031 12031 + continue 12032 12032 + } 12033 12033 + 12034 12034 + switch string(nameBuf[:nameLen]) { 12035 12035 + // t.RealMime (string) (string) 12036 12036 + case "realMime": 12037 12037 + 12038 12038 + { 12039 12039 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 12040 12040 + if err != nil { 12041 12041 + return err 12042 12042 + } 12043 12043 + 12044 12044 + t.RealMime = string(sval) 12045 12045 + } 12046 12046 + // t.RealSize (int64) (int64) 12047 12047 + case "realSize": 12048 12048 + { 12049 12049 + maj, extra, err := cr.ReadHeader() 12050 12050 + if err != nil { 12051 12051 + return err 12052 12052 + } 12053 12053 + var extraI int64 12054 12054 + switch maj { 12055 12055 + case cbg.MajUnsignedInt: 12056 12056 + extraI = int64(extra) 12057 12057 + if extraI < 0 { 12058 12058 + return fmt.Errorf("int64 positive overflow") 12059 12059 + } 12060 12060 + case cbg.MajNegativeInt: 12061 12061 + extraI = int64(extra) 12062 12062 + if extraI < 0 { 12063 12063 + return fmt.Errorf("int64 negative overflow") 12064 12064 + } 12065 12065 + extraI = -1 - extraI 12066 12066 + default: 12067 12067 + return fmt.Errorf("wrong type for int64 field: %d", maj) 12068 12068 + } 12069 12069 + 12070 12070 + t.RealSize = int64(extraI) 11540 12071 } 11541 12072 11542 12073 default:

+24 -4

api/tangled/tangledstring.go

Reviewed

··· 18 18 // RECORDTYPE: String 19 19 type String struct { 20 20 LexiconTypeID string `json:"$type,const=sh.tangled.string" cborgen:"$type,const=sh.tangled.string"` 21 21 - Contents string `json:"contents" cborgen:"contents"` 22 22 - CreatedAt string `json:"createdAt" cborgen:"createdAt"` 23 23 - Description string `json:"description" cborgen:"description"` 24 24 - Filename string `json:"filename" cborgen:"filename"` 21 21 + // contents: DEPRECATED - use files[0].content instead 22 22 + Contents *string `json:"contents,omitempty" cborgen:"contents,omitempty"` 23 23 + CreatedAt string `json:"createdAt" cborgen:"createdAt"` 24 24 + Description *string `json:"description,omitempty" cborgen:"description,omitempty"` 25 25 + // filename: DEPRECATED - use title instead 26 26 + Filename *string `json:"filename,omitempty" cborgen:"filename,omitempty"` 27 27 + Files []*String_File `json:"files" cborgen:"files"` 28 28 + Title *string `json:"title,omitempty" cborgen:"title,omitempty"` 29 29 + } 30 30 + 31 31 + // String_File is a "file" in the sh.tangled.string schema. 32 32 + type String_File struct { 33 33 + // content: file content 34 34 + Content *util.LexBlob `json:"content" cborgen:"content"` 35 35 + // gzip: underlying blob metadata. provided when we are using gzip hack for text/* mimetype 36 36 + Gzip *String_File_Gzip `json:"gzip,omitempty" cborgen:"gzip,omitempty"` 37 37 + // name: filename including extension 38 38 + Name string `json:"name" cborgen:"name"` 39 39 + } 40 40 + 41 41 + // underlying blob metadata. provided when we are using gzip hack for text/* mimetype 42 42 + type String_File_Gzip struct { 43 43 + RealMime string `json:"realMime" cborgen:"realMime"` 44 44 + RealSize int64 `json:"realSize" cborgen:"realSize"` 25 45 }

+2

cmd/cborgen/cborgen.go

Reviewed

··· 61 61 tangled.Spindle{}, 62 62 tangled.SpindleMember{}, 63 63 tangled.String{}, 64 64 + tangled.String_File{}, 65 65 + tangled.String_File_Gzip{}, 64 66 ); err != nil { 65 67 panic(err) 66 68 }

+50 -5

lexicons/string/string.json

Reviewed

··· 10 10 "record": { 11 11 "type": "object", 12 12 "required": [ 13 13 - "filename", 14 14 - "description", 15 13 "createdAt", 16 16 - "contents" 14 14 + "files" 17 15 ], 18 16 "properties": { 19 17 "filename": { 20 18 "type": "string", 21 19 "maxGraphemes": 140, 20 20 + "minGraphemes": 1, 21 21 + "description": "DEPRECATED - use title instead" 22 22 + }, 23 23 + "title": { 24 24 + "type": "string", 25 25 + "maxGraphemes": 140, 22 26 "minGraphemes": 1 23 27 }, 24 28 "description": { 25 29 "type": "string", 26 26 - "maxGraphemes": 280 30 30 + "maxGraphemes": 280, 31 31 + "minGraphemes": 1 27 32 }, 28 33 "createdAt": { 29 34 "type": "string", ··· 31 36 }, 32 37 "contents": { 33 38 "type": "string", 34 34 - "minGraphemes": 1 39 39 + "minGraphemes": 1, 40 40 + "description": "DEPRECATED - use files[0].content instead" 41 41 + }, 42 42 + "files": { 43 43 + "type": "array", 44 44 + "minLength": 1, 45 45 + "maxLength": 50, 46 46 + "items": { 47 47 + "type": "ref", 48 48 + "ref": "#file" 49 49 + } 35 50 } 51 51 + } 52 52 + } 53 53 + }, 54 54 + "file": { 55 55 + "type": "object", 56 56 + "required": [ 57 57 + "name", 58 58 + "content" 59 59 + ], 60 60 + "properties": { 61 61 + "name": { 62 62 + "type": "string", 63 63 + "maxGraphemes": 140, 64 64 + "minGraphemes": 1, 65 65 + "description": "filename including extension" 66 66 + }, 67 67 + "content": { 68 68 + "type": "blob", 69 69 + "accept": ["text/plain", "application/gzip"], 70 70 + "maxSize": 8388608, 71 71 + "description": "file content" 72 72 + }, 73 73 + "gzip": { 74 74 + "type": "object", 75 75 + "required": ["realSize", "realMime"], 76 76 + "properties": { 77 77 + "realSize": { "type": "integer" }, 78 78 + "realMime": { "type": "string" } 79 79 + }, 80 80 + "description": "underlying blob metadata. provided when we are using gzip hack for text/* mimetype" 36 81 } 37 82 } 38 83 }