···

       
2728
       
 
       


     

       
2729
       
 
       
	return nil

     

       
2730
       
 
       
}

     

       
2731
       
-
       
func (t *Pipeline_Dependency) MarshalCBOR(w io.Writer) error {

     

       
2732
       
-
       
	if t == nil {

     

       
2733
       
-
       
		_, err := w.Write(cbg.CborNull)

     

       
2734
       
-
       
		return err

     

       
2735
       
-
       
	}

     

       
2736
       
-
       


     

       
2737
       
-
       
	cw := cbg.NewCborWriter(w)

     

       
2738
       
-
       


     

       
2739
       
-
       
	if _, err := cw.Write([]byte{162}); err != nil {

     

       
2740
       
-
       
		return err

     

       
2741
       
-
       
	}

     

       
2742
       
-
       


     

       
2743
       
-
       
	// t.Packages ([]string) (slice)

     

       
2744
       
-
       
	if len("packages") > 1000000 {

     

       
2745
       
-
       
		return xerrors.Errorf("Value in field \"packages\" was too long")

     

       
2746
       
-
       
	}

     

       
2747
       
-
       


     

       
2748
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("packages"))); err != nil {

     

       
2749
       
-
       
		return err

     

       
2750
       
-
       
	}

     

       
2751
       
-
       
	if _, err := cw.WriteString(string("packages")); err != nil {

     

       
2752
       
-
       
		return err

     

       
2753
       
-
       
	}

     

       
2754
       
-
       


     

       
2755
       
-
       
	if len(t.Packages) > 8192 {

     

       
2756
       
-
       
		return xerrors.Errorf("Slice value in field t.Packages was too long")

     

       
2757
       
-
       
	}

     

       
2758
       
-
       


     

       
2759
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Packages))); err != nil {

     

       
2760
       
-
       
		return err

     

       
2761
       
-
       
	}

     

       
2762
       
-
       
	for _, v := range t.Packages {

     

       
2763
       
-
       
		if len(v) > 1000000 {

     

       
2764
       
-
       
			return xerrors.Errorf("Value in field v was too long")

     

       
2765
       
-
       
		}

     

       
2766
       
-
       


     

       
2767
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(v))); err != nil {

     

       
2768
       
-
       
			return err

     

       
2769
       
-
       
		}

     

       
2770
       
-
       
		if _, err := cw.WriteString(string(v)); err != nil {

     

       
2771
       
-
       
			return err

     

       
2772
       
-
       
		}

     

       
2773
       
-
       


     

       
2774
       
-
       
	}

     

       
2775
       
-
       


     

       
2776
       
-
       
	// t.Registry (string) (string)

     

       
2777
       
-
       
	if len("registry") > 1000000 {

     

       
2778
       
-
       
		return xerrors.Errorf("Value in field \"registry\" was too long")

     

       
2779
       
-
       
	}

     

       
2780
       
-
       


     

       
2781
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("registry"))); err != nil {

     

       
2782
       
-
       
		return err

     

       
2783
       
-
       
	}

     

       
2784
       
-
       
	if _, err := cw.WriteString(string("registry")); err != nil {

     

       
2785
       
-
       
		return err

     

       
2786
       
-
       
	}

     

       
2787
       
-
       


     

       
2788
       
-
       
	if len(t.Registry) > 1000000 {

     

       
2789
       
-
       
		return xerrors.Errorf("Value in field t.Registry was too long")

     

       
2790
       
-
       
	}

     

       
2791
       
-
       


     

       
2792
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Registry))); err != nil {

     

       
2793
       
-
       
		return err

     

       
2794
       
-
       
	}

     

       
2795
       
-
       
	if _, err := cw.WriteString(string(t.Registry)); err != nil {

     

       
2796
       
-
       
		return err

     

       
2797
       
-
       
	}

     

       
2798
       
-
       
	return nil

     

       
2799
       
-
       
}

     

       
2800
       
-
       


     

       
2801
       
-
       
func (t *Pipeline_Dependency) UnmarshalCBOR(r io.Reader) (err error) {

     

       
2802
       
-
       
	*t = Pipeline_Dependency{}

     

       
2803
       
-
       


     

       
2804
       
-
       
	cr := cbg.NewCborReader(r)

     

       
2805
       
-
       


     

       
2806
       
-
       
	maj, extra, err := cr.ReadHeader()

     

       
2807
       
-
       
	if err != nil {

     

       
2808
       
-
       
		return err

     

       
2809
       
-
       
	}

     

       
2810
       
-
       
	defer func() {

     

       
2811
       
-
       
		if err == io.EOF {

     

       
2812
       
-
       
			err = io.ErrUnexpectedEOF

     

       
2813
       
-
       
		}

     

       
2814
       
-
       
	}()

     

       
2815
       
-
       


     

       
2816
       
-
       
	if maj != cbg.MajMap {

     

       
2817
       
-
       
		return fmt.Errorf("cbor input should be of type map")

     

       
2818
       
-
       
	}

     

       
2819
       
-
       


     

       
2820
       
-
       
	if extra > cbg.MaxLength {

     

       
2821
       
-
       
		return fmt.Errorf("Pipeline_Dependency: map struct too large (%d)", extra)

     

       
2822
       
-
       
	}

     

       
2823
       
-
       


     

       
2824
       
-
       
	n := extra

     

       
2825
       
-
       


     

       
2826
       
-
       
	nameBuf := make([]byte, 8)

     

       
2827
       
-
       
	for i := uint64(0); i < n; i++ {

     

       
2828
       
-
       
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       
2829
       
-
       
		if err != nil {

     

       
2830
       
-
       
			return err

     

       
2831
       
-
       
		}

     

       
2832
       
-
       


     

       
2833
       
-
       
		if !ok {

     

       
2834
       
-
       
			// Field doesn't exist on this type, so ignore it

     

       
2835
       
-
       
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {

     

       
2836
       
-
       
				return err

     

       
2837
       
-
       
			}

     

       
2838
       
-
       
			continue

     

       
2839
       
-
       
		}

     

       
2840
       
-
       


     

       
2841
       
-
       
		switch string(nameBuf[:nameLen]) {

     

       
2842
       
-
       
		// t.Packages ([]string) (slice)

     

       
2843
       
-
       
		case "packages":

     

       
2844
       
-
       


     

       
2845
       
-
       
			maj, extra, err = cr.ReadHeader()

     

       
2846
       
-
       
			if err != nil {

     

       
2847
       
-
       
				return err

     

       
2848
       
-
       
			}

     

       
2849
       
-
       


     

       
2850
       
-
       
			if extra > 8192 {

     

       
2851
       
-
       
				return fmt.Errorf("t.Packages: array too large (%d)", extra)

     

       
2852
       
-
       
			}

     

       
2853
       
-
       


     

       
2854
       
-
       
			if maj != cbg.MajArray {

     

       
2855
       
-
       
				return fmt.Errorf("expected cbor array")

     

       
2856
       
-
       
			}

     

       
2857
       
-
       


     

       
2858
       
-
       
			if extra > 0 {

     

       
2859
       
-
       
				t.Packages = make([]string, extra)

     

       
2860
       
-
       
			}

     

       
2861
       
-
       


     

       
2862
       
-
       
			for i := 0; i < int(extra); i++ {

     

       
2863
       
-
       
				{

     

       
2864
       
-
       
					var maj byte

     

       
2865
       
-
       
					var extra uint64

     

       
2866
       
-
       
					var err error

     

       
2867
       
-
       
					_ = maj

     

       
2868
       
-
       
					_ = extra

     

       
2869
       
-
       
					_ = err

     

       
2870
       
-
       


     

       
2871
       
-
       
					{

     

       
2872
       
-
       
						sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       
2873
       
-
       
						if err != nil {

     

       
2874
       
-
       
							return err

     

       
2875
       
-
       
						}

     

       
2876
       
-
       


     

       
2877
       
-
       
						t.Packages[i] = string(sval)

     

       
2878
       
-
       
					}

     

       
2879
       
-
       


     

       
2880
       
-
       
				}

     

       
2881
       
-
       
			}

     

       
2882
       
-
       
			// t.Registry (string) (string)

     

       
2883
       
-
       
		case "registry":

     

       
2884
       
-
       


     

       
2885
       
-
       
			{

     

       
2886
       
-
       
				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       
2887
       
-
       
				if err != nil {

     

       
2888
       
-
       
					return err

     

       
2889
       
-
       
				}

     

       
2890
       
-
       


     

       
2891
       
-
       
				t.Registry = string(sval)

     

       
2892
       
-
       
			}

     

       
2893
       
-
       


     

       
2894
       
-
       
		default:

     

       
2895
       
-
       
			// Field doesn't exist on this type, so ignore it

     

       
2896
       
-
       
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {

     

       
2897
       
-
       
				return err

     

       
2898
       
-
       
			}

     

       
2899
       
-
       
		}

     

       
2900
       
-
       
	}

     

       
2901
       
-
       


     

       
2902
       
-
       
	return nil

     

       
2903
       
-
       
}

     

       
2904
       
 
       
func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {

     

       
2905
       
 
       
	if t == nil {

     

       
2906
       
 
       
		_, err := w.Write(cbg.CborNull)

     
···

       
3916
       
 
       


     

       
3917
       
 
       
	return nil

     

       
3918
       
 
       
}

     

       
3919
       
-
       
func (t *Pipeline_Step) MarshalCBOR(w io.Writer) error {

     

       
3920
       
-
       
	if t == nil {

     

       
3921
       
-
       
		_, err := w.Write(cbg.CborNull)

     

       
3922
       
-
       
		return err

     

       
3923
       
-
       
	}

     

       
3924
       
-
       


     

       
3925
       
-
       
	cw := cbg.NewCborWriter(w)

     

       
3926
       
-
       
	fieldCount := 3

     

       
3927
       
-
       


     

       
3928
       
-
       
	if t.Environment == nil {

     

       
3929
       
-
       
		fieldCount--

     

       
3930
       
-
       
	}

     

       
3931
       
-
       


     

       
3932
       
-
       
	if _, err := cw.Write(cbg.CborEncodeMajorType(cbg.MajMap, uint64(fieldCount))); err != nil {

     

       
3933
       
-
       
		return err

     

       
3934
       
-
       
	}

     

       
3935
       
-
       


     

       
3936
       
-
       
	// t.Name (string) (string)

     

       
3937
       
-
       
	if len("name") > 1000000 {

     

       
3938
       
-
       
		return xerrors.Errorf("Value in field \"name\" was too long")

     

       
3939
       
-
       
	}

     

       
3940
       
-
       


     

       
3941
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("name"))); err != nil {

     

       
3942
       
-
       
		return err

     

       
3943
       
-
       
	}

     

       
3944
       
-
       
	if _, err := cw.WriteString(string("name")); err != nil {

     

       
3945
       
-
       
		return err

     

       
3946
       
-
       
	}

     

       
3947
       
-
       


     

       
3948
       
-
       
	if len(t.Name) > 1000000 {

     

       
3949
       
-
       
		return xerrors.Errorf("Value in field t.Name was too long")

     

       
3950
       
-
       
	}

     

       
3951
       
-
       


     

       
3952
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Name))); err != nil {

     

       
3953
       
-
       
		return err

     

       
3954
       
-
       
	}

     

       
3955
       
-
       
	if _, err := cw.WriteString(string(t.Name)); err != nil {

     

       
3956
       
-
       
		return err

     

       
3957
       
-
       
	}

     

       
3958
       
-
       


     

       
3959
       
-
       
	// t.Command (string) (string)

     

       
3960
       
-
       
	if len("command") > 1000000 {

     

       
3961
       
-
       
		return xerrors.Errorf("Value in field \"command\" was too long")

     

       
3962
       
-
       
	}

     

       
3963
       
-
       


     

       
3964
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("command"))); err != nil {

     

       
3965
       
-
       
		return err

     

       
3966
       
-
       
	}

     

       
3967
       
-
       
	if _, err := cw.WriteString(string("command")); err != nil {

     

       
3968
       
-
       
		return err

     

       
3969
       
-
       
	}

     

       
3970
       
-
       


     

       
3971
       
-
       
	if len(t.Command) > 1000000 {

     

       
3972
       
-
       
		return xerrors.Errorf("Value in field t.Command was too long")

     

       
3973
       
-
       
	}

     

       
3974
       
-
       


     

       
3975
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Command))); err != nil {

     

       
3976
       
-
       
		return err

     

       
3977
       
-
       
	}

     

       
3978
       
-
       
	if _, err := cw.WriteString(string(t.Command)); err != nil {

     

       
3979
       
-
       
		return err

     

       
3980
       
-
       
	}

     

       
3981
       
-
       


     

       
3982
       
-
       
	// t.Environment ([]*tangled.Pipeline_Pair) (slice)

     

       
3983
       
-
       
	if t.Environment != nil {

     

       
3984
       
-
       


     

       
3985
       
-
       
		if len("environment") > 1000000 {

     

       
3986
       
-
       
			return xerrors.Errorf("Value in field \"environment\" was too long")

     

       
3987
       
-
       
		}

     

       
3988
       
-
       


     

       
3989
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {

     

       
3990
       
-
       
			return err

     

       
3991
       
-
       
		}

     

       
3992
       
-
       
		if _, err := cw.WriteString(string("environment")); err != nil {

     

       
3993
       
-
       
			return err

     

       
3994
       
-
       
		}

     

       
3995
       
-
       


     

       
3996
       
-
       
		if len(t.Environment) > 8192 {

     

       
3997
       
-
       
			return xerrors.Errorf("Slice value in field t.Environment was too long")

     

       
3998
       
-
       
		}

     

       
3999
       
-
       


     

       
4000
       
-
       
		if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {

     

       
4001
       
-
       
			return err

     

       
4002
       
-
       
		}

     

       
4003
       
-
       
		for _, v := range t.Environment {

     

       
4004
       
-
       
			if err := v.MarshalCBOR(cw); err != nil {

     

       
4005
       
-
       
				return err

     

       
4006
       
-
       
			}

     

       
4007
       
-
       


     

       
4008
       
-
       
		}

     

       
4009
       
-
       
	}

     

       
4010
       
-
       
	return nil

     

       
4011
       
-
       
}

     

       
4012
       
-
       


     

       
4013
       
-
       
func (t *Pipeline_Step) UnmarshalCBOR(r io.Reader) (err error) {

     

       
4014
       
-
       
	*t = Pipeline_Step{}

     

       
4015
       
-
       


     

       
4016
       
-
       
	cr := cbg.NewCborReader(r)

     

       
4017
       
-
       


     

       
4018
       
-
       
	maj, extra, err := cr.ReadHeader()

     

       
4019
       
-
       
	if err != nil {

     

       
4020
       
-
       
		return err

     

       
4021
       
-
       
	}

     

       
4022
       
-
       
	defer func() {

     

       
4023
       
-
       
		if err == io.EOF {

     

       
4024
       
-
       
			err = io.ErrUnexpectedEOF

     

       
4025
       
-
       
		}

     

       
4026
       
-
       
	}()

     

       
4027
       
-
       


     

       
4028
       
-
       
	if maj != cbg.MajMap {

     

       
4029
       
-
       
		return fmt.Errorf("cbor input should be of type map")

     

       
4030
       
-
       
	}

     

       
4031
       
-
       


     

       
4032
       
-
       
	if extra > cbg.MaxLength {

     

       
4033
       
-
       
		return fmt.Errorf("Pipeline_Step: map struct too large (%d)", extra)

     

       
4034
       
-
       
	}

     

       
4035
       
-
       


     

       
4036
       
-
       
	n := extra

     

       
4037
       
-
       


     

       
4038
       
-
       
	nameBuf := make([]byte, 11)

     

       
4039
       
-
       
	for i := uint64(0); i < n; i++ {

     

       
4040
       
-
       
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       
4041
       
-
       
		if err != nil {

     

       
4042
       
-
       
			return err

     

       
4043
       
-
       
		}

     

       
4044
       
-
       


     

       
4045
       
-
       
		if !ok {

     

       
4046
       
-
       
			// Field doesn't exist on this type, so ignore it

     

       
4047
       
-
       
			if err := cbg.ScanForLinks(cr, func(cid.Cid) {}); err != nil {

     

       
4048
       
-
       
				return err

     

       
4049
       
-
       
			}

     

       
4050
       
-
       
			continue

     

       
4051
       
-
       
		}

     

       
4052
       
-
       


     

       
4053
       
-
       
		switch string(nameBuf[:nameLen]) {

     

       
4054
       
-
       
		// t.Name (string) (string)

     

       
4055
       
-
       
		case "name":

     

       
4056
       
-
       


     

       
4057
       
-
       
			{

     

       
4058
       
-
       
				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       
4059
       
-
       
				if err != nil {

     

       
4060
       
-
       
					return err

     

       
4061
       
-
       
				}

     

       
4062
       
-
       


     

       
4063
       
-
       
				t.Name = string(sval)

     

       
4064
       
-
       
			}

     

       
4065
       
-
       
			// t.Command (string) (string)

     

       
4066
       
-
       
		case "command":

     

       
4067
       
-
       


     

       
4068
       
-
       
			{

     

       
4069
       
-
       
				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       
4070
       
-
       
				if err != nil {

     

       
4071
       
-
       
					return err

     

       
4072
       
-
       
				}

     

       
4073
       
-
       


     

       
4074
       
-
       
				t.Command = string(sval)

     

       
4075
       
-
       
			}

     

       
4076
       
-
       
			// t.Environment ([]*tangled.Pipeline_Pair) (slice)

     

       
4077
       
-
       
		case "environment":

     

       
4078
       
-
       


     

       
4079
       
-
       
			maj, extra, err = cr.ReadHeader()

     

       
4080
       
-
       
			if err != nil {

     

       
4081
       
-
       
				return err

     

       
4082
       
-
       
			}

     

       
4083
       
-
       


     

       
4084
       
-
       
			if extra > 8192 {

     

       
4085
       
-
       
				return fmt.Errorf("t.Environment: array too large (%d)", extra)

     

       
4086
       
-
       
			}

     

       
4087
       
-
       


     

       
4088
       
-
       
			if maj != cbg.MajArray {

     

       
4089
       
-
       
				return fmt.Errorf("expected cbor array")

     

       
4090
       
-
       
			}

     

       
4091
       
-
       


     

       
4092
       
-
       
			if extra > 0 {

     

       
4093
       
-
       
				t.Environment = make([]*Pipeline_Pair, extra)

     

       
4094
       
-
       
			}

     

       
4095
       
-
       


     

       
4096
       
-
       
			for i := 0; i < int(extra); i++ {

     

       
4097
       
-
       
				{

     

       
4098
       
-
       
					var maj byte

     

       
4099
       
-
       
					var extra uint64

     

       
4100
       
-
       
					var err error

     

       
4101
       
-
       
					_ = maj

     

       
4102
       
-
       
					_ = extra

     

       
4103
       
-
       
					_ = err

     

       
4104
       
-
       


     

       
4105
       
-
       
					{

     

       
4106
       
-
       


     

       
4107
       
-
       
						b, err := cr.ReadByte()

     

       
4108
       
-
       
						if err != nil {

     

       
4109
       
-
       
							return err

     

       
4110
       
-
       
						}

     

       
4111
       
-
       
						if b != cbg.CborNull[0] {

     

       
4112
       
-
       
							if err := cr.UnreadByte(); err != nil {

     

       
4113
       
-
       
								return err

     

       
4114
       
-
       
							}

     

       
4115
       
-
       
							t.Environment[i] = new(Pipeline_Pair)

     

       
4116
       
-
       
							if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {

     

       
4117
       
-
       
								return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)

     

       
4118
       
-
       
							}

     

       
4119
       
-
       
						}

     

       
4120
       
-
       


     

       
4121
       
-
       
					}

     

       
4122
       
-
       


     

       
4123
       
-
       
				}

     

       
4124
       
-
       
			}

     

       
4125
       
-
       


     

       
4126
       
-
       
		default:

     

       
4127
       
-
       
			// Field doesn't exist on this type, so ignore it

     

       
4128
       
-
       
			if err := cbg.ScanForLinks(r, func(cid.Cid) {}); err != nil {

     

       
4129
       
-
       
				return err

     

       
4130
       
-
       
			}

     

       
4131
       
-
       
		}

     

       
4132
       
-
       
	}

     

       
4133
       
-
       


     

       
4134
       
-
       
	return nil

     

       
4135
       
-
       
}

     

       
4136
       
 
       
func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {

     

       
4137
       
 
       
	if t == nil {

     

       
4138
       
 
       
		_, err := w.Write(cbg.CborNull)

     
···

       
4609
       
 
       


     

       
4610
       
 
       
	cw := cbg.NewCborWriter(w)

     

       
4611
       
 
       


     

       
4612
       
-
       
	if _, err := cw.Write([]byte{165}); err != nil {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4613
       
 
       
		return err

     

       
4614
       
 
       
	}

     

       
4615
       
 
       


     
···

       
4652
       
 
       
		return err

     

       
4653
       
 
       
	}

     

       
4654
       
 
       


     

       
4655
       
-
       
	// t.Steps ([]*tangled.Pipeline_Step) (slice)

     

       
4656
       
-
       
	if len("steps") > 1000000 {

     

       
4657
       
-
       
		return xerrors.Errorf("Value in field \"steps\" was too long")

     

       
4658
       
 
       
	}

     

       
4659
       
 
       


     

       
4660
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("steps"))); err != nil {

     

       
4661
       
-
       
		return err

     

       
4662
       
-
       
	}

     

       
4663
       
-
       
	if _, err := cw.WriteString(string("steps")); err != nil {

     

       
4664
       
 
       
		return err

     

       
4665
       
 
       
	}

     

       
4666
       
-
       


     

       
4667
       
-
       
	if len(t.Steps) > 8192 {

     

       
4668
       
-
       
		return xerrors.Errorf("Slice value in field t.Steps was too long")

     

       
4669
       
-
       
	}

     

       
4670
       
-
       


     

       
4671
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Steps))); err != nil {

     

       
4672
       
-
       
		return err

     

       
4673
       
-
       
	}

     

       
4674
       
-
       
	for _, v := range t.Steps {

     

       
4675
       
-
       
		if err := v.MarshalCBOR(cw); err != nil {

     

       
4676
       
-
       
			return err

     

       
4677
       
-
       
		}

     

       
4678
       
-
       


     

       
4679
       
-
       
	}

     

       
4680
       
-
       


     

       
4681
       
-
       
	// t.Environment ([]*tangled.Pipeline_Pair) (slice)

     

       
4682
       
-
       
	if len("environment") > 1000000 {

     

       
4683
       
-
       
		return xerrors.Errorf("Value in field \"environment\" was too long")

     

       
4684
       
-
       
	}

     

       
4685
       
-
       


     

       
4686
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("environment"))); err != nil {

     

       
4687
       
-
       
		return err

     

       
4688
       
-
       
	}

     

       
4689
       
-
       
	if _, err := cw.WriteString(string("environment")); err != nil {

     

       
4690
       
-
       
		return err

     

       
4691
       
-
       
	}

     

       
4692
       
-
       


     

       
4693
       
-
       
	if len(t.Environment) > 8192 {

     

       
4694
       
-
       
		return xerrors.Errorf("Slice value in field t.Environment was too long")

     

       
4695
       
-
       
	}

     

       
4696
       
-
       


     

       
4697
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Environment))); err != nil {

     

       
4698
       
 
       
		return err

     

       
4699
       
 
       
	}

     

       
4700
       
-
       
	for _, v := range t.Environment {

     

       
4701
       
-
       
		if err := v.MarshalCBOR(cw); err != nil {

     

       
4702
       
-
       
			return err

     

       
4703
       
-
       
		}

     

       
4704
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
4705
       
 
       
	}

     

       
4706
       
 
       


     

       
4707
       
-
       
	// t.Dependencies ([]*tangled.Pipeline_Dependency) (slice)

     

       
4708
       
-
       
	if len("dependencies") > 1000000 {

     

       
4709
       
-
       
		return xerrors.Errorf("Value in field \"dependencies\" was too long")

     

       
4710
       
-
       
	}

     

       
4711
       
-
       


     

       
4712
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("dependencies"))); err != nil {

     

       
4713
       
 
       
		return err

     

       
4714
       
 
       
	}

     

       
4715
       
-
       
	if _, err := cw.WriteString(string("dependencies")); err != nil {

     

       
4716
       
 
       
		return err

     

       
4717
       
-
       
	}

     

       
4718
       
-
       


     

       
4719
       
-
       
	if len(t.Dependencies) > 8192 {

     

       
4720
       
-
       
		return xerrors.Errorf("Slice value in field t.Dependencies was too long")

     

       
4721
       
-
       
	}

     

       
4722
       
-
       


     

       
4723
       
-
       
	if err := cw.WriteMajorTypeHeader(cbg.MajArray, uint64(len(t.Dependencies))); err != nil {

     

       
4724
       
-
       
		return err

     

       
4725
       
-
       
	}

     

       
4726
       
-
       
	for _, v := range t.Dependencies {

     

       
4727
       
-
       
		if err := v.MarshalCBOR(cw); err != nil {

     

       
4728
       
-
       
			return err

     

       
4729
       
-
       
		}

     

       
4730
       
-
       


     

       
4731
       
 
       
	}

     

       
4732
       
 
       
	return nil

     

       
4733
       
 
       
}

     
···

       
4757
       
 
       


     

       
4758
       
 
       
	n := extra

     

       
4759
       
 
       


     

       
4760
       
-
       
	nameBuf := make([]byte, 12)

     

       
4761
       
 
       
	for i := uint64(0); i < n; i++ {

     

       
4762
       
 
       
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       
4763
       
 
       
		if err != nil {

     
···

       
4773
       
 
       
		}

     

       
4774
       
 
       


     

       
4775
       
 
       
		switch string(nameBuf[:nameLen]) {

     

       
4776
       
-
       
		// t.Name (string) (string)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4777
       
 
       
		case "name":

     

       
4778
       
 
       


     

       
4779
       
 
       
			{

     
···

       
4804
       
 
       
				}

     

       
4805
       
 
       


     

       
4806
       
 
       
			}

     

       
4807
       
-
       
			// t.Steps ([]*tangled.Pipeline_Step) (slice)

     

       
4808
       
-
       
		case "steps":

     

       
4809
       
 
       


     

       
4810
       
-
       
			maj, extra, err = cr.ReadHeader()

     

       
4811
       
-
       
			if err != nil {

     

       
4812
       
-
       
				return err

     

       
4813
       
-
       
			}

     

       
4814
       
-
       


     

       
4815
       
-
       
			if extra > 8192 {

     

       
4816
       
-
       
				return fmt.Errorf("t.Steps: array too large (%d)", extra)

     

       
4817
       
-
       
			}

     

       
4818
       
-
       


     

       
4819
       
-
       
			if maj != cbg.MajArray {

     

       
4820
       
-
       
				return fmt.Errorf("expected cbor array")

     

       
4821
       
-
       
			}

     

       
4822
       
-
       


     

       
4823
       
-
       
			if extra > 0 {

     

       
4824
       
-
       
				t.Steps = make([]*Pipeline_Step, extra)

     

       
4825
       
-
       
			}

     

       
4826
       
-
       


     

       
4827
       
-
       
			for i := 0; i < int(extra); i++ {

     

       
4828
       
-
       
				{

     

       
4829
       
-
       
					var maj byte

     

       
4830
       
-
       
					var extra uint64

     

       
4831
       
-
       
					var err error

     

       
4832
       
-
       
					_ = maj

     

       
4833
       
-
       
					_ = extra

     

       
4834
       
-
       
					_ = err

     

       
4835
       
-
       


     

       
4836
       
-
       
					{

     

       
4837
       
-
       


     

       
4838
       
-
       
						b, err := cr.ReadByte()

     

       
4839
       
-
       
						if err != nil {

     

       
4840
       
-
       
							return err

     

       
4841
       
-
       
						}

     

       
4842
       
-
       
						if b != cbg.CborNull[0] {

     

       
4843
       
-
       
							if err := cr.UnreadByte(); err != nil {

     

       
4844
       
-
       
								return err

     

       
4845
       
-
       
							}

     

       
4846
       
-
       
							t.Steps[i] = new(Pipeline_Step)

     

       
4847
       
-
       
							if err := t.Steps[i].UnmarshalCBOR(cr); err != nil {

     

       
4848
       
-
       
								return xerrors.Errorf("unmarshaling t.Steps[i] pointer: %w", err)

     

       
4849
       
-
       
							}

     

       
4850
       
-
       
						}

     

       
4851
       
-
       


     

       
4852
       
-
       
					}

     

       
4853
       
-
       


     

       
4854
       
 
       
				}

     

       
4855
       
-
       
			}

     

       
4856
       
-
       
			// t.Environment ([]*tangled.Pipeline_Pair) (slice)

     

       
4857
       
-
       
		case "environment":

     

       
4858
       
 
       


     

       
4859
       
-
       
			maj, extra, err = cr.ReadHeader()

     

       
4860
       
-
       
			if err != nil {

     

       
4861
       
-
       
				return err

     

       
4862
       
-
       
			}

     

       
4863
       
-
       


     

       
4864
       
-
       
			if extra > 8192 {

     

       
4865
       
-
       
				return fmt.Errorf("t.Environment: array too large (%d)", extra)

     

       
4866
       
-
       
			}

     

       
4867
       
-
       


     

       
4868
       
-
       
			if maj != cbg.MajArray {

     

       
4869
       
-
       
				return fmt.Errorf("expected cbor array")

     

       
4870
       
-
       
			}

     

       
4871
       
-
       


     

       
4872
       
-
       
			if extra > 0 {

     

       
4873
       
-
       
				t.Environment = make([]*Pipeline_Pair, extra)

     

       
4874
       
-
       
			}

     

       
4875
       
-
       


     

       
4876
       
-
       
			for i := 0; i < int(extra); i++ {

     

       
4877
       
-
       
				{

     

       
4878
       
-
       
					var maj byte

     

       
4879
       
-
       
					var extra uint64

     

       
4880
       
-
       
					var err error

     

       
4881
       
-
       
					_ = maj

     

       
4882
       
-
       
					_ = extra

     

       
4883
       
-
       
					_ = err

     

       
4884
       
-
       


     

       
4885
       
-
       
					{

     

       
4886
       
-
       


     

       
4887
       
-
       
						b, err := cr.ReadByte()

     

       
4888
       
-
       
						if err != nil {

     

       
4889
       
-
       
							return err

     

       
4890
       
-
       
						}

     

       
4891
       
-
       
						if b != cbg.CborNull[0] {

     

       
4892
       
-
       
							if err := cr.UnreadByte(); err != nil {

     

       
4893
       
-
       
								return err

     

       
4894
       
-
       
							}

     

       
4895
       
-
       
							t.Environment[i] = new(Pipeline_Pair)

     

       
4896
       
-
       
							if err := t.Environment[i].UnmarshalCBOR(cr); err != nil {

     

       
4897
       
-
       
								return xerrors.Errorf("unmarshaling t.Environment[i] pointer: %w", err)

     

       
4898
       
-
       
							}

     

       
4899
       
-
       
						}

     

       
4900
       
-
       


     

       
4901
       
-
       
					}

     

       
4902
       
-
       


     

       
4903
       
-
       
				}

     

       
4904
       
-
       
			}

     

       
4905
       
-
       
			// t.Dependencies ([]*tangled.Pipeline_Dependency) (slice)

     

       
4906
       
-
       
		case "dependencies":

     

       
4907
       
-
       


     

       
4908
       
-
       
			maj, extra, err = cr.ReadHeader()

     

       
4909
       
-
       
			if err != nil {

     

       
4910
       
-
       
				return err

     

       
4911
       
-
       
			}

     

       
4912
       
-
       


     

       
4913
       
-
       
			if extra > 8192 {

     

       
4914
       
-
       
				return fmt.Errorf("t.Dependencies: array too large (%d)", extra)

     

       
4915
       
-
       
			}

     

       
4916
       
-
       


     

       
4917
       
-
       
			if maj != cbg.MajArray {

     

       
4918
       
-
       
				return fmt.Errorf("expected cbor array")

     

       
4919
       
-
       
			}

     

       
4920
       
-
       


     

       
4921
       
-
       
			if extra > 0 {

     

       
4922
       
-
       
				t.Dependencies = make([]*Pipeline_Dependency, extra)

     

       
4923
       
-
       
			}

     

       
4924
       
-
       


     

       
4925
       
-
       
			for i := 0; i < int(extra); i++ {

     

       
4926
       
-
       
				{

     

       
4927
       
-
       
					var maj byte

     

       
4928
       
-
       
					var extra uint64

     

       
4929
       
-
       
					var err error

     

       
4930
       
-
       
					_ = maj

     

       
4931
       
-
       
					_ = extra

     

       
4932
       
-
       
					_ = err

     

       
4933
       
-
       


     

       
4934
       
-
       
					{

     

       
4935
       
-
       


     

       
4936
       
-
       
						b, err := cr.ReadByte()

     

       
4937
       
-
       
						if err != nil {

     

       
4938
       
-
       
							return err

     

       
4939
       
-
       
						}

     

       
4940
       
-
       
						if b != cbg.CborNull[0] {

     

       
4941
       
-
       
							if err := cr.UnreadByte(); err != nil {

     

       
4942
       
-
       
								return err

     

       
4943
       
-
       
							}

     

       
4944
       
-
       
							t.Dependencies[i] = new(Pipeline_Dependency)

     

       
4945
       
-
       
							if err := t.Dependencies[i].UnmarshalCBOR(cr); err != nil {

     

       
4946
       
-
       
								return xerrors.Errorf("unmarshaling t.Dependencies[i] pointer: %w", err)

     

       
4947
       
-
       
							}

     

       
4948
       
-
       
						}

     

       
4949
       
-
       


     

       
4950
       
-
       
					}

     

       
4951
       
-
       


     

       
4952
       
-
       
				}

     

       
4953
       
 
       
			}

     

       
4954
       
 
       


     

       
4955
       
 
       
		default:

     

···

       
2728
       
 
       


     

       
2729
       
 
       
	return nil

     

       
2730
       
 
       
}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2731
       
 
       
func (t *Pipeline_ManualTriggerData) MarshalCBOR(w io.Writer) error {

     

       
2732
       
 
       
	if t == nil {

     

       
2733
       
 
       
		_, err := w.Write(cbg.CborNull)

     
···

       
3743
       
 
       


     

       
3744
       
 
       
	return nil

     

       
3745
       
 
       
}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3746
       
 
       
func (t *Pipeline_TriggerMetadata) MarshalCBOR(w io.Writer) error {

     

       
3747
       
 
       
	if t == nil {

     

       
3748
       
 
       
		_, err := w.Write(cbg.CborNull)

     
···

       
4219
       
 
       


     

       
4220
       
 
       
	cw := cbg.NewCborWriter(w)

     

       
4221
       
 
       


     

       
4222
       
+
       
	if _, err := cw.Write([]byte{164}); err != nil {

     

       
4223
       
+
       
		return err

     

       
4224
       
+
       
	}

     

       
4225
       
+
       


     

       
4226
       
+
       
	// t.Raw (string) (string)

     

       
4227
       
+
       
	if len("raw") > 1000000 {

     

       
4228
       
+
       
		return xerrors.Errorf("Value in field \"raw\" was too long")

     

       
4229
       
+
       
	}

     

       
4230
       
+
       


     

       
4231
       
+
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("raw"))); err != nil {

     

       
4232
       
+
       
		return err

     

       
4233
       
+
       
	}

     

       
4234
       
+
       
	if _, err := cw.WriteString(string("raw")); err != nil {

     

       
4235
       
+
       
		return err

     

       
4236
       
+
       
	}

     

       
4237
       
+
       


     

       
4238
       
+
       
	if len(t.Raw) > 1000000 {

     

       
4239
       
+
       
		return xerrors.Errorf("Value in field t.Raw was too long")

     

       
4240
       
+
       
	}

     

       
4241
       
+
       


     

       
4242
       
+
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Raw))); err != nil {

     

       
4243
       
+
       
		return err

     

       
4244
       
+
       
	}

     

       
4245
       
+
       
	if _, err := cw.WriteString(string(t.Raw)); err != nil {

     

       
4246
       
 
       
		return err

     

       
4247
       
 
       
	}

     

       
4248
       
 
       


     
···

       
4285
       
 
       
		return err

     

       
4286
       
 
       
	}

     

       
4287
       
 
       


     

       
4288
       
+
       
	// t.Engine (string) (string)

     

       
4289
       
+
       
	if len("engine") > 1000000 {

     

       
4290
       
+
       
		return xerrors.Errorf("Value in field \"engine\" was too long")

     

       
4291
       
 
       
	}

     

       
4292
       
 
       


     

       
4293
       
+
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len("engine"))); err != nil {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4294
       
 
       
		return err

     

       
4295
       
 
       
	}

     

       
4296
       
+
       
	if _, err := cw.WriteString(string("engine")); err != nil {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4297
       
 
       
		return err

     

       
4298
       
 
       
	}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4299
       
 
       


     

       
4300
       
+
       
	if len(t.Engine) > 1000000 {

     

       
4301
       
+
       
		return xerrors.Errorf("Value in field t.Engine was too long")

     

       
4302
       
 
       
	}

     

       
4303
       
 
       


     

       
4304
       
+
       
	if err := cw.WriteMajorTypeHeader(cbg.MajTextString, uint64(len(t.Engine))); err != nil {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4305
       
 
       
		return err

     

       
4306
       
 
       
	}

     

       
4307
       
+
       
	if _, err := cw.WriteString(string(t.Engine)); err != nil {

     

       
4308
       
 
       
		return err

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4309
       
 
       
	}

     

       
4310
       
 
       
	return nil

     

       
4311
       
 
       
}

     
···

       
4335
       
 
       


     

       
4336
       
 
       
	n := extra

     

       
4337
       
 
       


     

       
4338
       
+
       
	nameBuf := make([]byte, 6)

     

       
4339
       
 
       
	for i := uint64(0); i < n; i++ {

     

       
4340
       
 
       
		nameLen, ok, err := cbg.ReadFullStringIntoBuf(cr, nameBuf, 1000000)

     

       
4341
       
 
       
		if err != nil {

     
···

       
4351
       
 
       
		}

     

       
4352
       
 
       


     

       
4353
       
 
       
		switch string(nameBuf[:nameLen]) {

     

       
4354
       
+
       
		// t.Raw (string) (string)

     

       
4355
       
+
       
		case "raw":

     

       
4356
       
+
       


     

       
4357
       
+
       
			{

     

       
4358
       
+
       
				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       
4359
       
+
       
				if err != nil {

     

       
4360
       
+
       
					return err

     

       
4361
       
+
       
				}

     

       
4362
       
+
       


     

       
4363
       
+
       
				t.Raw = string(sval)

     

       
4364
       
+
       
			}

     

       
4365
       
+
       
			// t.Name (string) (string)

     

       
4366
       
 
       
		case "name":

     

       
4367
       
 
       


     

       
4368
       
 
       
			{

     
···

       
4393
       
 
       
				}

     

       
4394
       
 
       


     

       
4395
       
 
       
			}

     

       
4396
       
+
       
			// t.Engine (string) (string)

     

       
4397
       
+
       
		case "engine":

     

       
4398
       
 
       


     

       
4399
       
+
       
			{

     

       
4400
       
+
       
				sval, err := cbg.ReadStringWithMax(cr, 1000000)

     

       
4401
       
+
       
				if err != nil {

     

       
4402
       
+
       
					return err

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4403
       
 
       
				}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4404
       
 
       


     

       
4405
       
+
       
				t.Engine = string(sval)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
4406
       
 
       
			}

     

       
4407
       
 
       


     

       
4408
       
 
       
		default:

     

···

       
29
       
 
       
	Submodules bool  `json:"submodules" cborgen:"submodules"`

     

       
30
       
 
       
}

     

       
31
       
 
       


     

       
32
       
-
       
// Pipeline_Dependency is a "dependency" in the sh.tangled.pipeline schema.

     

       
33
       
-
       
type Pipeline_Dependency struct {

     

       
34
       
-
       
	Packages []string `json:"packages" cborgen:"packages"`

     

       
35
       
-
       
	Registry string   `json:"registry" cborgen:"registry"`

     

       
36
       
-
       
}

     

       
37
       
-
       


     

       
38
       
 
       
// Pipeline_ManualTriggerData is a "manualTriggerData" in the sh.tangled.pipeline schema.

     

       
39
       
 
       
type Pipeline_ManualTriggerData struct {

     

       
40
       
 
       
	Inputs []*Pipeline_Pair `json:"inputs,omitempty" cborgen:"inputs,omitempty"`

     
···

       
61
       
 
       
	Ref    string `json:"ref" cborgen:"ref"`

     

       
62
       
 
       
}

     

       
63
       
 
       


     

       
64
       
-
       
// Pipeline_Step is a "step" in the sh.tangled.pipeline schema.

     

       
65
       
-
       
type Pipeline_Step struct {

     

       
66
       
-
       
	Command     string           `json:"command" cborgen:"command"`

     

       
67
       
-
       
	Environment []*Pipeline_Pair `json:"environment,omitempty" cborgen:"environment,omitempty"`

     

       
68
       
-
       
	Name        string           `json:"name" cborgen:"name"`

     

       
69
       
-
       
}

     

       
70
       
-
       


     

       
71
       
 
       
// Pipeline_TriggerMetadata is a "triggerMetadata" in the sh.tangled.pipeline schema.

     

       
72
       
 
       
type Pipeline_TriggerMetadata struct {

     

       
73
       
 
       
	Kind        string                           `json:"kind" cborgen:"kind"`

     
···

       
87
       
 
       


     

       
88
       
 
       
// Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema.

     

       
89
       
 
       
type Pipeline_Workflow struct {

     

       
90
       
-
       
	Clone        *Pipeline_CloneOpts    `json:"clone" cborgen:"clone"`

     

       
91
       
-
       
	Dependencies []*Pipeline_Dependency `json:"dependencies" cborgen:"dependencies"`

     

       
92
       
-
       
	Environment  []*Pipeline_Pair       `json:"environment" cborgen:"environment"`

     

       
93
       
-
       
	Name         string                 `json:"name" cborgen:"name"`

     

       
94
       
-
       
	Steps        []*Pipeline_Step       `json:"steps" cborgen:"steps"`

     

       
95
       
 
       
}

     

···

       
29
       
 
       
	Submodules bool  `json:"submodules" cborgen:"submodules"`

     

       
30
       
 
       
}

     

       
31
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
32
       
 
       
// Pipeline_ManualTriggerData is a "manualTriggerData" in the sh.tangled.pipeline schema.

     

       
33
       
 
       
type Pipeline_ManualTriggerData struct {

     

       
34
       
 
       
	Inputs []*Pipeline_Pair `json:"inputs,omitempty" cborgen:"inputs,omitempty"`

     
···

       
55
       
 
       
	Ref    string `json:"ref" cborgen:"ref"`

     

       
56
       
 
       
}

     

       
57
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
58
       
 
       
// Pipeline_TriggerMetadata is a "triggerMetadata" in the sh.tangled.pipeline schema.

     

       
59
       
 
       
type Pipeline_TriggerMetadata struct {

     

       
60
       
 
       
	Kind        string                           `json:"kind" cborgen:"kind"`

     
···

       
74
       
 
       


     

       
75
       
 
       
// Pipeline_Workflow is a "workflow" in the sh.tangled.pipeline schema.

     

       
76
       
 
       
type Pipeline_Workflow struct {

     

       
77
       
+
       
	Clone  *Pipeline_CloneOpts `json:"clone" cborgen:"clone"`

     

       
78
       
+
       
	Engine string              `json:"engine" cborgen:"engine"`

     

       
79
       
+
       
	Name   string              `json:"name" cborgen:"name"`

     

       
80
       
+
       
	Raw    string              `json:"raw" cborgen:"raw"`

     

       
0
       
 
       

     

       
81
       
 
       
}

     

···

       
27
       
 
       
		tangled.KnotMember{},

     

       
28
       
 
       
		tangled.Pipeline{},

     

       
29
       
 
       
		tangled.Pipeline_CloneOpts{},

     

       
30
       
-
       
		tangled.Pipeline_Dependency{},

     

       
31
       
 
       
		tangled.Pipeline_ManualTriggerData{},

     

       
32
       
 
       
		tangled.Pipeline_Pair{},

     

       
33
       
 
       
		tangled.Pipeline_PullRequestTriggerData{},

     

       
34
       
 
       
		tangled.Pipeline_PushTriggerData{},

     

       
35
       
 
       
		tangled.PipelineStatus{},

     

       
36
       
-
       
		tangled.Pipeline_Step{},

     

       
37
       
 
       
		tangled.Pipeline_TriggerMetadata{},

     

       
38
       
 
       
		tangled.Pipeline_TriggerRepo{},

     

       
39
       
 
       
		tangled.Pipeline_Workflow{},