+580 -49

api/tangled/cbor_gen.go

Reviewed

··· 11476 11476 } 11477 11477 11478 11478 cw := cbg.NewCborWriter(w) 11479 11479 + fieldCount := 7 11479 11480 11480 11480 - if _, err := cw.Write([]byte{165}); err != nil { 11481 11481 + if t.Contents == nil { 11482 11482 + fieldCount-- 11483 11483 + } 11484 11484 + 11485 11485 + if t.Description == nil { 11486 11486 + fieldCount-- 11487 11487 + } 11488 11488 + 11489 11489 + if t.Filename == nil { 11490 11490 + fieldCount-- 11491 11491 + } 11492 11492 + 11493 11493 + if t.Title == nil { 11494 11494 + fieldCount-- 11495 11495 + } 11496 11496 + 11497 11497 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 11481 11498 return err 11482 11499 } 11483 11500 ··· 11500 11517 return err 11501 11518 } 11502 11519 11503 11503 - // t.Contents (string) (string) 11504 11504 - if len("contents") > 1000000 { 11505 11505 - return xerrors.Errorf("Value in field \"contents\" was too long") 11520 11520 + // t.Files ([]*tangled.String_File) (slice) 11521 11521 + if len("files") > 1000000 { 11522 11522 + return xerrors.Errorf("Value in field \"files\" was too long") 11506 11523 } 11507 11524 11508 11508 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil { 11525 11525 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("files"))); err != nil { 11509 11526 return err 11510 11527 } 11511 11511 - if _, err := cw.WriteString(string("contents")); err != nil { 11528 11528 + if _, err := cw.WriteString(string("files")); err != nil { 11512 11529 return err 11513 11530 } 11514 11531 11515 11515 - if len(t.Contents) > 1000000 { 11516 11516 - return xerrors.Errorf("Value in field t.Contents was too long") 11532 11532 + if len(t.Files) > 8192 { 11533 11533 + return xerrors.Errorf("Slice value in field t.Files was too long") 11517 11534 } 11518 11535 11519 11519 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Contents))); err != nil { 11536 11536 + if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Files))); err != nil { 11520 11537 return err 11521 11538 } 11522 11522 - if _, err := cw.WriteString(string(t.Contents)); err != nil { 11523 11523 - return err 11539 11539 + for _, v := range t.Files { 11540 11540 + if err := v.MarshalCBOR(cw); err != nil { 11541 11541 + return err 11542 11542 + } 11543 11543 + 11524 11544 } 11525 11545 11526 11526 - // t.Filename (string) (string) 11527 11527 - if len("filename") > 1000000 { 11528 11528 - return xerrors.Errorf("Value in field \"filename\" was too long") 11529 11529 - } 11546 11546 + // t.Title (string) (string) 11547 11547 + if t.Title != nil { 11530 11548 11531 11531 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil { 11532 11532 - return err 11533 11533 - } 11534 11534 - if _, err := cw.WriteString(string("filename")); err != nil { 11535 11535 - return err 11536 11536 - } 11549 11549 + if len("title") > 1000000 { 11550 11550 + return xerrors.Errorf("Value in field \"title\" was too long") 11551 11551 + } 11552 11552 + 11553 11553 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("title"))); err != nil { 11554 11554 + return err 11555 11555 + } 11556 11556 + if _, err := cw.WriteString(string("title")); err != nil { 11557 11557 + return err 11558 11558 + } 11559 11559 + 11560 11560 + if t.Title == nil { 11561 11561 + if _, err := cw.Write(cbg.CborNull); err != nil { 11562 11562 + return err 11563 11563 + } 11564 11564 + } else { 11565 11565 + if len(*t.Title) > 1000000 { 11566 11566 + return xerrors.Errorf("Value in field t.Title was too long") 11567 11567 + } 11537 11568 11538 11538 - if len(t.Filename) > 1000000 { 11539 11539 - return xerrors.Errorf("Value in field t.Filename was too long") 11569 11569 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Title))); err != nil { 11570 11570 + return err 11571 11571 + } 11572 11572 + if _, err := cw.WriteString(string(*t.Title)); err != nil { 11573 11573 + return err 11574 11574 + } 11575 11575 + } 11540 11576 } 11541 11577 11542 11542 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Filename))); err != nil { 11543 11543 - return err 11578 11578 + // t.Contents (string) (string) 11579 11579 + if t.Contents != nil { 11580 11580 + 11581 11581 + if len("contents") > 1000000 { 11582 11582 + return xerrors.Errorf("Value in field \"contents\" was too long") 11583 11583 + } 11584 11584 + 11585 11585 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("contents"))); err != nil { 11586 11586 + return err 11587 11587 + } 11588 11588 + if _, err := cw.WriteString(string("contents")); err != nil { 11589 11589 + return err 11590 11590 + } 11591 11591 + 11592 11592 + if t.Contents == nil { 11593 11593 + if _, err := cw.Write(cbg.CborNull); err != nil { 11594 11594 + return err 11595 11595 + } 11596 11596 + } else { 11597 11597 + if len(*t.Contents) > 1000000 { 11598 11598 + return xerrors.Errorf("Value in field t.Contents was too long") 11599 11599 + } 11600 11600 + 11601 11601 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Contents))); err != nil { 11602 11602 + return err 11603 11603 + } 11604 11604 + if _, err := cw.WriteString(string(*t.Contents)); err != nil { 11605 11605 + return err 11606 11606 + } 11607 11607 + } 11544 11608 } 11545 11545 - if _, err := cw.WriteString(string(t.Filename)); err != nil { 11546 11546 - return err 11609 11609 + 11610 11610 + // t.Filename (string) (string) 11611 11611 + if t.Filename != nil { 11612 11612 + 11613 11613 + if len("filename") > 1000000 { 11614 11614 + return xerrors.Errorf("Value in field \"filename\" was too long") 11615 11615 + } 11616 11616 + 11617 11617 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("filename"))); err != nil { 11618 11618 + return err 11619 11619 + } 11620 11620 + if _, err := cw.WriteString(string("filename")); err != nil { 11621 11621 + return err 11622 11622 + } 11623 11623 + 11624 11624 + if t.Filename == nil { 11625 11625 + if _, err := cw.Write(cbg.CborNull); err != nil { 11626 11626 + return err 11627 11627 + } 11628 11628 + } else { 11629 11629 + if len(*t.Filename) > 1000000 { 11630 11630 + return xerrors.Errorf("Value in field t.Filename was too long") 11631 11631 + } 11632 11632 + 11633 11633 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Filename))); err != nil { 11634 11634 + return err 11635 11635 + } 11636 11636 + if _, err := cw.WriteString(string(*t.Filename)); err != nil { 11637 11637 + return err 11638 11638 + } 11639 11639 + } 11547 11640 } 11548 11641 11549 11642 // t.CreatedAt (string) (string) ··· 11570 11663 } 11571 11664 11572 11665 // t.Description (string) (string) 11573 11573 - if len("description") > 1000000 { 11574 11574 - return xerrors.Errorf("Value in field \"description\" was too long") 11575 11575 - } 11666 11666 + if t.Description != nil { 11667 11667 + 11668 11668 + if len("description") > 1000000 { 11669 11669 + return xerrors.Errorf("Value in field \"description\" was too long") 11670 11670 + } 11576 11671 11577 11577 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 11578 11578 - return err 11579 11579 - } 11580 11580 - if _, err := cw.WriteString(string("description")); err != nil { 11581 11581 - return err 11582 11582 - } 11672 11672 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("description"))); err != nil { 11673 11673 + return err 11674 11674 + } 11675 11675 + if _, err := cw.WriteString(string("description")); err != nil { 11676 11676 + return err 11677 11677 + } 11583 11678 11584 11584 - if len(t.Description) > 1000000 { 11585 11585 - return xerrors.Errorf("Value in field t.Description was too long") 11586 11586 - } 11679 11679 + if t.Description == nil { 11680 11680 + if _, err := cw.Write(cbg.CborNull); err != nil { 11681 11681 + return err 11682 11682 + } 11683 11683 + } else { 11684 11684 + if len(*t.Description) > 1000000 { 11685 11685 + return xerrors.Errorf("Value in field t.Description was too long") 11686 11686 + } 11587 11687 11588 11588 - if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Description))); err != nil { 11589 11589 - return err 11590 11590 - } 11591 11591 - if _, err := cw.WriteString(string(t.Description)); err != nil { 11592 11592 - return err 11688 11688 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(*t.Description))); err != nil { 11689 11689 + return err 11690 11690 + } 11691 11691 + if _, err := cw.WriteString(string(*t.Description)); err != nil { 11692 11692 + return err 11693 11693 + } 11694 11694 + } 11593 11695 } 11594 11696 return nil 11595 11697 } ··· 11646 11748 11647 11749 t.LexiconTypeID = string(sval) 11648 11750 } 11751 11751 + // t.Files ([]*tangled.String_File) (slice) 11752 11752 + case "files": 11753 11753 + 11754 11754 + maj, extra, err = cr.ReadHeader() 11755 11755 + if err != nil { 11756 11756 + return err 11757 11757 + } 11758 11758 + 11759 11759 + if extra > 8192 { 11760 11760 + return fmt.Errorf("t.Files: array too large (%d)", extra) 11761 11761 + } 11762 11762 + 11763 11763 + if maj != cbg.MajArray { 11764 11764 + return fmt.Errorf("expected cbor array") 11765 11765 + } 11766 11766 + 11767 11767 + if extra > 0 { 11768 11768 + t.Files = make([]*String_File, extra) 11769 11769 + } 11770 11770 + 11771 11771 + for i := 0; i < int(extra); i++ { 11772 11772 + { 11773 11773 + var maj byte 11774 11774 + var extra uint64 11775 11775 + var err error 11776 11776 + _ = maj 11777 11777 + _ = extra 11778 11778 + _ = err 11779 11779 + 11780 11780 + { 11781 11781 + 11782 11782 + b, err := cr.ReadByte() 11783 11783 + if err != nil { 11784 11784 + return err 11785 11785 + } 11786 11786 + if b != cbg.CborNull[0] { 11787 11787 + if err := cr.UnreadByte(); err != nil { 11788 11788 + return err 11789 11789 + } 11790 11790 + t.Files[i] = new(String_File) 11791 11791 + if err := t.Files[i].UnmarshalCBOR(cr); err != nil { 11792 11792 + return xerrors.Errorf("unmarshaling t.Files[i] pointer: %w", err) 11793 11793 + } 11794 11794 + } 11795 11795 + 11796 11796 + } 11797 11797 + 11798 11798 + } 11799 11799 + } 11800 11800 + // t.Title (string) (string) 11801 11801 + case "title": 11802 11802 + 11803 11803 + { 11804 11804 + b, err := cr.ReadByte() 11805 11805 + if err != nil { 11806 11806 + return err 11807 11807 + } 11808 11808 + if b != cbg.CborNull[0] { 11809 11809 + if err := cr.UnreadByte(); err != nil { 11810 11810 + return err 11811 11811 + } 11812 11812 + 11813 11813 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11814 11814 + if err != nil { 11815 11815 + return err 11816 11816 + } 11817 11817 + 11818 11818 + t.Title = (*string)(&sval) 11819 11819 + } 11820 11820 + } 11649 11821 // t.Contents (string) (string) 11650 11822 case "contents": 11651 11823 11652 11824 { 11653 11653 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 11825 11825 + b, err := cr.ReadByte() 11654 11826 if err != nil { 11655 11827 return err 11656 11828 } 11829 11829 + if b != cbg.CborNull[0] { 11830 11830 + if err := cr.UnreadByte(); err != nil { 11831 11831 + return err 11832 11832 + } 11657 11833 11658 11658 - t.Contents = string(sval) 11834 11834 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11835 11835 + if err != nil { 11836 11836 + return err 11837 11837 + } 11838 11838 + 11839 11839 + t.Contents = (*string)(&sval) 11840 11840 + } 11659 11841 } 11660 11842 // t.Filename (string) (string) 11661 11843 case "filename": 11662 11844 11663 11845 { 11664 11664 - sval, err := cbg.ReadStringWithMax(cr, 1000000) 11846 11846 + b, err := cr.ReadByte() 11665 11847 if err != nil { 11666 11848 return err 11667 11849 } 11850 11850 + if b != cbg.CborNull[0] { 11851 11851 + if err := cr.UnreadByte(); err != nil { 11852 11852 + return err 11853 11853 + } 11668 11854 11669 11669 - t.Filename = string(sval) 11855 11855 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11856 11856 + if err != nil { 11857 11857 + return err 11858 11858 + } 11859 11859 + 11860 11860 + t.Filename = (*string)(&sval) 11861 11861 + } 11670 11862 } 11671 11863 // t.CreatedAt (string) (string) 11672 11864 case "createdAt": ··· 11683 11875 case "description": 11684 11876 11685 11877 { 11878 11878 + b, err := cr.ReadByte() 11879 11879 + if err != nil { 11880 11880 + return err 11881 11881 + } 11882 11882 + if b != cbg.CborNull[0] { 11883 11883 + if err := cr.UnreadByte(); err != nil { 11884 11884 + return err 11885 11885 + } 11886 11886 + 11887 11887 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 11888 11888 + if err != nil { 11889 11889 + return err 11890 11890 + } 11891 11891 + 11892 11892 + t.Description = (*string)(&sval) 11893 11893 + } 11894 11894 + } 11895 11895 + 11896 11896 + default: 11897 11897 + // Field doesn't exist on this type, so ignore it 11898 11898 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 11899 11899 + return err 11900 11900 + } 11901 11901 + } 11902 11902 + } 11903 11903 + 11904 11904 + return nil 11905 11905 + } 11906 11906 + func (t *String_File) MarshalCBOR(w io.Writer) error { 11907 11907 + if t == nil { 11908 11908 + _, err := w.Write(cbg.CborNull) 11909 11909 + return err 11910 11910 + } 11911 11911 + 11912 11912 + cw := cbg.NewCborWriter(w) 11913 11913 + fieldCount := 3 11914 11914 + 11915 11915 + if t.Gzip == nil { 11916 11916 + fieldCount-- 11917 11917 + } 11918 11918 + 11919 11919 + if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil { 11920 11920 + return err 11921 11921 + } 11922 11922 + 11923 11923 + // t.Gzip (tangled.String_File_Gzip) (struct) 11924 11924 + if t.Gzip != nil { 11925 11925 + 11926 11926 + if len("gzip") > 1000000 { 11927 11927 + return xerrors.Errorf("Value in field \"gzip\" was too long") 11928 11928 + } 11929 11929 + 11930 11930 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("gzip"))); err != nil { 11931 11931 + return err 11932 11932 + } 11933 11933 + if _, err := cw.WriteString(string("gzip")); err != nil { 11934 11934 + return err 11935 11935 + } 11936 11936 + 11937 11937 + if err := t.Gzip.MarshalCBOR(cw); err != nil { 11938 11938 + return err 11939 11939 + } 11940 11940 + } 11941 11941 + 11942 11942 + // t.Name (string) (string) 11943 11943 + if len("name") > 1000000 { 11944 11944 + return xerrors.Errorf("Value in field \"name\" was too long") 11945 11945 + } 11946 11946 + 11947 11947 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil { 11948 11948 + return err 11949 11949 + } 11950 11950 + if _, err := cw.WriteString(string("name")); err != nil { 11951 11951 + return err 11952 11952 + } 11953 11953 + 11954 11954 + if len(t.Name) > 1000000 { 11955 11955 + return xerrors.Errorf("Value in field t.Name was too long") 11956 11956 + } 11957 11957 + 11958 11958 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil { 11959 11959 + return err 11960 11960 + } 11961 11961 + if _, err := cw.WriteString(string(t.Name)); err != nil { 11962 11962 + return err 11963 11963 + } 11964 11964 + 11965 11965 + // t.Content (util.LexBlob) (struct) 11966 11966 + if len("content") > 1000000 { 11967 11967 + return xerrors.Errorf("Value in field \"content\" was too long") 11968 11968 + } 11969 11969 + 11970 11970 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("content"))); err != nil { 11971 11971 + return err 11972 11972 + } 11973 11973 + if _, err := cw.WriteString(string("content")); err != nil { 11974 11974 + return err 11975 11975 + } 11976 11976 + 11977 11977 + if err := t.Content.MarshalCBOR(cw); err != nil { 11978 11978 + return err 11979 11979 + } 11980 11980 + return nil 11981 11981 + } 11982 11982 + 11983 11983 + func (t *String_File) UnmarshalCBOR(r io.Reader) (err error) { 11984 11984 + *t = String_File{} 11985 11985 + 11986 11986 + cr := cbg.NewCborReader(r) 11987 11987 + 11988 11988 + maj, extra, err := cr.ReadHeader() 11989 11989 + if err != nil { 11990 11990 + return err 11991 11991 + } 11992 11992 + defer func() { 11993 11993 + if err == io.EOF { 11994 11994 + err = io.ErrUnexpectedEOF 11995 11995 + } 11996 11996 + }() 11997 11997 + 11998 11998 + if maj != cbg.MajMap { 11999 11999 + return fmt.Errorf("cbor input should be of type map") 12000 12000 + } 12001 12001 + 12002 12002 + if extra > cbg.MaxLength { 12003 12003 + return fmt.Errorf("String_File: map struct too large (%d)", extra) 12004 12004 + } 12005 12005 + 12006 12006 + n := extra 12007 12007 + 12008 12008 + nameBuf := make([]byte, 7) 12009 12009 + for i := uint64(0); i < n; i++ { 12010 12010 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 12011 12011 + if err != nil { 12012 12012 + return err 12013 12013 + } 12014 12014 + 12015 12015 + if !ok { 12016 12016 + // Field doesn't exist on this type, so ignore it 12017 12017 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 12018 12018 + return err 12019 12019 + } 12020 12020 + continue 12021 12021 + } 12022 12022 + 12023 12023 + switch string(nameBuf[:nameLen]) { 12024 12024 + // t.Gzip (tangled.String_File_Gzip) (struct) 12025 12025 + case "gzip": 12026 12026 + 12027 12027 + { 12028 12028 + 12029 12029 + b, err := cr.ReadByte() 12030 12030 + if err != nil { 12031 12031 + return err 12032 12032 + } 12033 12033 + if b != cbg.CborNull[0] { 12034 12034 + if err := cr.UnreadByte(); err != nil { 12035 12035 + return err 12036 12036 + } 12037 12037 + t.Gzip = new(String_File_Gzip) 12038 12038 + if err := t.Gzip.UnmarshalCBOR(cr); err != nil { 12039 12039 + return xerrors.Errorf("unmarshaling t.Gzip pointer: %w", err) 12040 12040 + } 12041 12041 + } 12042 12042 + 12043 12043 + } 12044 12044 + // t.Name (string) (string) 12045 12045 + case "name": 12046 12046 + 12047 12047 + { 11686 12048 sval, err := cbg.ReadStringWithMax(cr, 1000000) 11687 12049 if err != nil { 11688 12050 return err 11689 12051 } 11690 12052 11691 11691 - t.Description = string(sval) 12053 12053 + t.Name = string(sval) 12054 12054 + } 12055 12055 + // t.Content (util.LexBlob) (struct) 12056 12056 + case "content": 12057 12057 + 12058 12058 + { 12059 12059 + 12060 12060 + b, err := cr.ReadByte() 12061 12061 + if err != nil { 12062 12062 + return err 12063 12063 + } 12064 12064 + if b != cbg.CborNull[0] { 12065 12065 + if err := cr.UnreadByte(); err != nil { 12066 12066 + return err 12067 12067 + } 12068 12068 + t.Content = new(util.LexBlob) 12069 12069 + if err := t.Content.UnmarshalCBOR(cr); err != nil { 12070 12070 + return xerrors.Errorf("unmarshaling t.Content pointer: %w", err) 12071 12071 + } 12072 12072 + } 12073 12073 + 12074 12074 + } 12075 12075 + 12076 12076 + default: 12077 12077 + // Field doesn't exist on this type, so ignore it 12078 12078 + if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil { 12079 12079 + return err 12080 12080 + } 12081 12081 + } 12082 12082 + } 12083 12083 + 12084 12084 + return nil 12085 12085 + } 12086 12086 + func (t *String_File_Gzip) MarshalCBOR(w io.Writer) error { 12087 12087 + if t == nil { 12088 12088 + _, err := w.Write(cbg.CborNull) 12089 12089 + return err 12090 12090 + } 12091 12091 + 12092 12092 + cw := cbg.NewCborWriter(w) 12093 12093 + 12094 12094 + if _, err := cw.Write([]byte{162}); err != nil { 12095 12095 + return err 12096 12096 + } 12097 12097 + 12098 12098 + // t.RealMime (string) (string) 12099 12099 + if len("realMime") > 1000000 { 12100 12100 + return xerrors.Errorf("Value in field \"realMime\" was too long") 12101 12101 + } 12102 12102 + 12103 12103 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("realMime"))); err != nil { 12104 12104 + return err 12105 12105 + } 12106 12106 + if _, err := cw.WriteString(string("realMime")); err != nil { 12107 12107 + return err 12108 12108 + } 12109 12109 + 12110 12110 + if len(t.RealMime) > 1000000 { 12111 12111 + return xerrors.Errorf("Value in field t.RealMime was too long") 12112 12112 + } 12113 12113 + 12114 12114 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.RealMime))); err != nil { 12115 12115 + return err 12116 12116 + } 12117 12117 + if _, err := cw.WriteString(string(t.RealMime)); err != nil { 12118 12118 + return err 12119 12119 + } 12120 12120 + 12121 12121 + // t.RealSize (int64) (int64) 12122 12122 + if len("realSize") > 1000000 { 12123 12123 + return xerrors.Errorf("Value in field \"realSize\" was too long") 12124 12124 + } 12125 12125 + 12126 12126 + if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("realSize"))); err != nil { 12127 12127 + return err 12128 12128 + } 12129 12129 + if _, err := cw.WriteString(string("realSize")); err != nil { 12130 12130 + return err 12131 12131 + } 12132 12132 + 12133 12133 + if t.RealSize >= 0 { 12134 12134 + if err := cw.WriteMajorTypeHeader(cbg.MajUnsignedInt, uint64(t.RealSize)); err != nil { 12135 12135 + return err 12136 12136 + } 12137 12137 + } else { 12138 12138 + if err := cw.WriteMajorTypeHeader(cbg.MajNegativeInt, uint64(-t.RealSize-1)); err != nil { 12139 12139 + return err 12140 12140 + } 12141 12141 + } 12142 12142 + 12143 12143 + return nil 12144 12144 + } 12145 12145 + 12146 12146 + func (t *String_File_Gzip) UnmarshalCBOR(r io.Reader) (err error) { 12147 12147 + *t = String_File_Gzip{} 12148 12148 + 12149 12149 + cr := cbg.NewCborReader(r) 12150 12150 + 12151 12151 + maj, extra, err := cr.ReadHeader() 12152 12152 + if err != nil { 12153 12153 + return err 12154 12154 + } 12155 12155 + defer func() { 12156 12156 + if err == io.EOF { 12157 12157 + err = io.ErrUnexpectedEOF 12158 12158 + } 12159 12159 + }() 12160 12160 + 12161 12161 + if maj != cbg.MajMap { 12162 12162 + return fmt.Errorf("cbor input should be of type map") 12163 12163 + } 12164 12164 + 12165 12165 + if extra > cbg.MaxLength { 12166 12166 + return fmt.Errorf("String_File_Gzip: map struct too large (%d)", extra) 12167 12167 + } 12168 12168 + 12169 12169 + n := extra 12170 12170 + 12171 12171 + nameBuf := make([]byte, 8) 12172 12172 + for i := uint64(0); i < n; i++ { 12173 12173 + nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000) 12174 12174 + if err != nil { 12175 12175 + return err 12176 12176 + } 12177 12177 + 12178 12178 + if !ok { 12179 12179 + // Field doesn't exist on this type, so ignore it 12180 12180 + if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil { 12181 12181 + return err 12182 12182 + } 12183 12183 + continue 12184 12184 + } 12185 12185 + 12186 12186 + switch string(nameBuf[:nameLen]) { 12187 12187 + // t.RealMime (string) (string) 12188 12188 + case "realMime": 12189 12189 + 12190 12190 + { 12191 12191 + sval, err := cbg.ReadStringWithMax(cr, 1000000) 12192 12192 + if err != nil { 12193 12193 + return err 12194 12194 + } 12195 12195 + 12196 12196 + t.RealMime = string(sval) 12197 12197 + } 12198 12198 + // t.RealSize (int64) (int64) 12199 12199 + case "realSize": 12200 12200 + { 12201 12201 + maj, extra, err := cr.ReadHeader() 12202 12202 + if err != nil { 12203 12203 + return err 12204 12204 + } 12205 12205 + var extraI int64 12206 12206 + switch maj { 12207 12207 + case cbg.MajUnsignedInt: 12208 12208 + extraI = int64(extra) 12209 12209 + if extraI < 0 { 12210 12210 + return fmt.Errorf("int64 positive overflow") 12211 12211 + } 12212 12212 + case cbg.MajNegativeInt: 12213 12213 + extraI = int64(extra) 12214 12214 + if extraI < 0 { 12215 12215 + return fmt.Errorf("int64 negative overflow") 12216 12216 + } 12217 12217 + extraI = -1 - extraI 12218 12218 + default: 12219 12219 + return fmt.Errorf("wrong type for int64 field: %d", maj) 12220 12220 + } 12221 12221 + 12222 12222 + t.RealSize = int64(extraI) 11692 12223 } 11693 12224 11694 12225 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

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

+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 }