text:
// ************************************************************
// DO NOT EDIT.
// THIS FILE IS AUTO-GENERATED BY codecgen.
// ************************************************************

package v1beta1

import (
	"errors"
	"fmt"
	codec1978 "github.com/ugorji/go/codec"
	pkg1_unversioned "k8s.io/kubernetes/pkg/api/unversioned"
	"reflect"
	"runtime"
)

const (
	// ----- content types ----
	codecSelferC_UTF81234 = 1
	codecSelferC_RAW1234  = 0
	// ----- value types used ----
	codecSelferValueTypeArray1234 = 10
	codecSelferValueTypeMap1234   = 9
	// ----- containerStateValues ----
	codecSelfer_containerMapKey1234    = 2
	codecSelfer_containerMapValue1234  = 3
	codecSelfer_containerMapEnd1234    = 4
	codecSelfer_containerArrayElem1234 = 6
	codecSelfer_containerArrayEnd1234  = 7
)

var (
	codecSelferBitsize1234                         = uint8(reflect.TypeOf(uint(0)).Bits())
	codecSelferOnlyMapOrArrayEncodeToStructErr1234 = errors.New(`only encoded map or array can be decoded into a struct`)
)

type codecSelfer1234 struct{}

func init() {
	if codec1978.GenVersion != 5 {
		_, file, _, _ := runtime.Caller(0)
		err := fmt.Errorf("codecgen version mismatch: current: %v, need %v. Re-generate file: %v",
			5, codec1978.GenVersion, file)
		panic(err)
	}
	if false { // reference the types, but skip this branch at build/run time
		var v0 pkg1_unversioned.TypeMeta
		_ = v0
	}
}

func (x *SubjectAccessReview) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym1 := z.EncBinary()
		_ = yym1
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep2 := !z.EncBinary()
			yy2arr2 := z.EncBasicHandle().StructToArray
			var yyq2 [4]bool
			_, _, _ = yysep2, yyq2, yy2arr2
			const yyr2 bool = false
			yyq2[0] = x.Kind != ""
			yyq2[1] = x.APIVersion != ""
			yyq2[3] = true
			var yynn2 int
			if yyr2 || yy2arr2 {
				r.EncodeArrayStart(4)
			} else {
				yynn2 = 1
				for _, b := range yyq2 {
					if b {
						yynn2++
					}
				}
				r.EncodeMapStart(yynn2)
				yynn2 = 0
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[0] {
					yym4 := z.EncBinary()
					_ = yym4
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq2[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym5 := z.EncBinary()
					_ = yym5
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[1] {
					yym7 := z.EncBinary()
					_ = yym7
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq2[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym8 := z.EncBinary()
					_ = yym8
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy10 := &x.Spec
				yy10.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("spec"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy11 := &x.Spec
				yy11.CodecEncodeSelf(e)
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq2[3] {
					yy13 := &x.Status
					yy13.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq2[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy14 := &x.Status
					yy14.CodecEncodeSelf(e)
				}
			}
			if yyr2 || yy2arr2 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SubjectAccessReview) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym15 := z.DecBinary()
	_ = yym15
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct16 := r.ContainerType()
		if yyct16 == codecSelferValueTypeMap1234 {
			yyl16 := r.ReadMapStart()
			if yyl16 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl16, d)
			}
		} else if yyct16 == codecSelferValueTypeArray1234 {
			yyl16 := r.ReadArrayStart()
			if yyl16 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl16, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SubjectAccessReview) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys17Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys17Slc
	var yyhl17 bool = l >= 0
	for yyj17 := 0; ; yyj17++ {
		if yyhl17 {
			if yyj17 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys17Slc = r.DecodeBytes(yys17Slc, true, true)
		yys17 := string(yys17Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys17 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = SubjectAccessReviewSpec{}
			} else {
				yyv20 := &x.Spec
				yyv20.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = SubjectAccessReviewStatus{}
			} else {
				yyv21 := &x.Status
				yyv21.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys17)
		} // end switch yys17
	} // end for yyj17
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SubjectAccessReview) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj22 int
	var yyb22 bool
	var yyhl22 bool = l >= 0
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = SubjectAccessReviewSpec{}
	} else {
		yyv25 := &x.Spec
		yyv25.CodecDecodeSelf(d)
	}
	yyj22++
	if yyhl22 {
		yyb22 = yyj22 > l
	} else {
		yyb22 = r.CheckBreak()
	}
	if yyb22 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = SubjectAccessReviewStatus{}
	} else {
		yyv26 := &x.Status
		yyv26.CodecDecodeSelf(d)
	}
	for {
		yyj22++
		if yyhl22 {
			yyb22 = yyj22 > l
		} else {
			yyb22 = r.CheckBreak()
		}
		if yyb22 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj22-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *SelfSubjectAccessReview) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym27 := z.EncBinary()
		_ = yym27
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep28 := !z.EncBinary()
			yy2arr28 := z.EncBasicHandle().StructToArray
			var yyq28 [4]bool
			_, _, _ = yysep28, yyq28, yy2arr28
			const yyr28 bool = false
			yyq28[0] = x.Kind != ""
			yyq28[1] = x.APIVersion != ""
			yyq28[3] = true
			var yynn28 int
			if yyr28 || yy2arr28 {
				r.EncodeArrayStart(4)
			} else {
				yynn28 = 1
				for _, b := range yyq28 {
					if b {
						yynn28++
					}
				}
				r.EncodeMapStart(yynn28)
				yynn28 = 0
			}
			if yyr28 || yy2arr28 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq28[0] {
					yym30 := z.EncBinary()
					_ = yym30
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq28[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym31 := z.EncBinary()
					_ = yym31
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr28 || yy2arr28 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq28[1] {
					yym33 := z.EncBinary()
					_ = yym33
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq28[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym34 := z.EncBinary()
					_ = yym34
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr28 || yy2arr28 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy36 := &x.Spec
				yy36.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("spec"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy37 := &x.Spec
				yy37.CodecEncodeSelf(e)
			}
			if yyr28 || yy2arr28 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq28[3] {
					yy39 := &x.Status
					yy39.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq28[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy40 := &x.Status
					yy40.CodecEncodeSelf(e)
				}
			}
			if yyr28 || yy2arr28 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SelfSubjectAccessReview) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym41 := z.DecBinary()
	_ = yym41
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct42 := r.ContainerType()
		if yyct42 == codecSelferValueTypeMap1234 {
			yyl42 := r.ReadMapStart()
			if yyl42 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl42, d)
			}
		} else if yyct42 == codecSelferValueTypeArray1234 {
			yyl42 := r.ReadArrayStart()
			if yyl42 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl42, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SelfSubjectAccessReview) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys43Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys43Slc
	var yyhl43 bool = l >= 0
	for yyj43 := 0; ; yyj43++ {
		if yyhl43 {
			if yyj43 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys43Slc = r.DecodeBytes(yys43Slc, true, true)
		yys43 := string(yys43Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys43 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = SelfSubjectAccessReviewSpec{}
			} else {
				yyv46 := &x.Spec
				yyv46.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = SubjectAccessReviewStatus{}
			} else {
				yyv47 := &x.Status
				yyv47.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys43)
		} // end switch yys43
	} // end for yyj43
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SelfSubjectAccessReview) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj48 int
	var yyb48 bool
	var yyhl48 bool = l >= 0
	yyj48++
	if yyhl48 {
		yyb48 = yyj48 > l
	} else {
		yyb48 = r.CheckBreak()
	}
	if yyb48 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj48++
	if yyhl48 {
		yyb48 = yyj48 > l
	} else {
		yyb48 = r.CheckBreak()
	}
	if yyb48 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj48++
	if yyhl48 {
		yyb48 = yyj48 > l
	} else {
		yyb48 = r.CheckBreak()
	}
	if yyb48 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = SelfSubjectAccessReviewSpec{}
	} else {
		yyv51 := &x.Spec
		yyv51.CodecDecodeSelf(d)
	}
	yyj48++
	if yyhl48 {
		yyb48 = yyj48 > l
	} else {
		yyb48 = r.CheckBreak()
	}
	if yyb48 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = SubjectAccessReviewStatus{}
	} else {
		yyv52 := &x.Status
		yyv52.CodecDecodeSelf(d)
	}
	for {
		yyj48++
		if yyhl48 {
			yyb48 = yyj48 > l
		} else {
			yyb48 = r.CheckBreak()
		}
		if yyb48 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj48-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *LocalSubjectAccessReview) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym53 := z.EncBinary()
		_ = yym53
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep54 := !z.EncBinary()
			yy2arr54 := z.EncBasicHandle().StructToArray
			var yyq54 [4]bool
			_, _, _ = yysep54, yyq54, yy2arr54
			const yyr54 bool = false
			yyq54[0] = x.Kind != ""
			yyq54[1] = x.APIVersion != ""
			yyq54[3] = true
			var yynn54 int
			if yyr54 || yy2arr54 {
				r.EncodeArrayStart(4)
			} else {
				yynn54 = 1
				for _, b := range yyq54 {
					if b {
						yynn54++
					}
				}
				r.EncodeMapStart(yynn54)
				yynn54 = 0
			}
			if yyr54 || yy2arr54 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq54[0] {
					yym56 := z.EncBinary()
					_ = yym56
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq54[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("kind"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym57 := z.EncBinary()
					_ = yym57
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Kind))
					}
				}
			}
			if yyr54 || yy2arr54 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq54[1] {
					yym59 := z.EncBinary()
					_ = yym59
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq54[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("apiVersion"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym60 := z.EncBinary()
					_ = yym60
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.APIVersion))
					}
				}
			}
			if yyr54 || yy2arr54 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yy62 := &x.Spec
				yy62.CodecEncodeSelf(e)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("spec"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yy63 := &x.Spec
				yy63.CodecEncodeSelf(e)
			}
			if yyr54 || yy2arr54 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq54[3] {
					yy65 := &x.Status
					yy65.CodecEncodeSelf(e)
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq54[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("status"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yy66 := &x.Status
					yy66.CodecEncodeSelf(e)
				}
			}
			if yyr54 || yy2arr54 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *LocalSubjectAccessReview) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym67 := z.DecBinary()
	_ = yym67
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct68 := r.ContainerType()
		if yyct68 == codecSelferValueTypeMap1234 {
			yyl68 := r.ReadMapStart()
			if yyl68 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl68, d)
			}
		} else if yyct68 == codecSelferValueTypeArray1234 {
			yyl68 := r.ReadArrayStart()
			if yyl68 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl68, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *LocalSubjectAccessReview) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys69Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys69Slc
	var yyhl69 bool = l >= 0
	for yyj69 := 0; ; yyj69++ {
		if yyhl69 {
			if yyj69 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys69Slc = r.DecodeBytes(yys69Slc, true, true)
		yys69 := string(yys69Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys69 {
		case "kind":
			if r.TryDecodeAsNil() {
				x.Kind = ""
			} else {
				x.Kind = string(r.DecodeString())
			}
		case "apiVersion":
			if r.TryDecodeAsNil() {
				x.APIVersion = ""
			} else {
				x.APIVersion = string(r.DecodeString())
			}
		case "spec":
			if r.TryDecodeAsNil() {
				x.Spec = SubjectAccessReviewSpec{}
			} else {
				yyv72 := &x.Spec
				yyv72.CodecDecodeSelf(d)
			}
		case "status":
			if r.TryDecodeAsNil() {
				x.Status = SubjectAccessReviewStatus{}
			} else {
				yyv73 := &x.Status
				yyv73.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys69)
		} // end switch yys69
	} // end for yyj69
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *LocalSubjectAccessReview) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj74 int
	var yyb74 bool
	var yyhl74 bool = l >= 0
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Kind = ""
	} else {
		x.Kind = string(r.DecodeString())
	}
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.APIVersion = ""
	} else {
		x.APIVersion = string(r.DecodeString())
	}
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Spec = SubjectAccessReviewSpec{}
	} else {
		yyv77 := &x.Spec
		yyv77.CodecDecodeSelf(d)
	}
	yyj74++
	if yyhl74 {
		yyb74 = yyj74 > l
	} else {
		yyb74 = r.CheckBreak()
	}
	if yyb74 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Status = SubjectAccessReviewStatus{}
	} else {
		yyv78 := &x.Status
		yyv78.CodecDecodeSelf(d)
	}
	for {
		yyj74++
		if yyhl74 {
			yyb74 = yyj74 > l
		} else {
			yyb74 = r.CheckBreak()
		}
		if yyb74 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj74-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *ResourceAttributes) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym79 := z.EncBinary()
		_ = yym79
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep80 := !z.EncBinary()
			yy2arr80 := z.EncBasicHandle().StructToArray
			var yyq80 [7]bool
			_, _, _ = yysep80, yyq80, yy2arr80
			const yyr80 bool = false
			yyq80[0] = x.Namespace != ""
			yyq80[1] = x.Verb != ""
			yyq80[2] = x.Group != ""
			yyq80[3] = x.Version != ""
			yyq80[4] = x.Resource != ""
			yyq80[5] = x.Subresource != ""
			yyq80[6] = x.Name != ""
			var yynn80 int
			if yyr80 || yy2arr80 {
				r.EncodeArrayStart(7)
			} else {
				yynn80 = 0
				for _, b := range yyq80 {
					if b {
						yynn80++
					}
				}
				r.EncodeMapStart(yynn80)
				yynn80 = 0
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq80[0] {
					yym82 := z.EncBinary()
					_ = yym82
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq80[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("namespace"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym83 := z.EncBinary()
					_ = yym83
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Namespace))
					}
				}
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq80[1] {
					yym85 := z.EncBinary()
					_ = yym85
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Verb))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq80[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("verb"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym86 := z.EncBinary()
					_ = yym86
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Verb))
					}
				}
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq80[2] {
					yym88 := z.EncBinary()
					_ = yym88
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Group))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq80[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("group"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym89 := z.EncBinary()
					_ = yym89
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Group))
					}
				}
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq80[3] {
					yym91 := z.EncBinary()
					_ = yym91
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Version))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq80[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("version"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym92 := z.EncBinary()
					_ = yym92
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Version))
					}
				}
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq80[4] {
					yym94 := z.EncBinary()
					_ = yym94
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Resource))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq80[4] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("resource"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym95 := z.EncBinary()
					_ = yym95
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Resource))
					}
				}
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq80[5] {
					yym97 := z.EncBinary()
					_ = yym97
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq80[5] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("subresource"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym98 := z.EncBinary()
					_ = yym98
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Subresource))
					}
				}
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq80[6] {
					yym100 := z.EncBinary()
					_ = yym100
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq80[6] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("name"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym101 := z.EncBinary()
					_ = yym101
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Name))
					}
				}
			}
			if yyr80 || yy2arr80 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *ResourceAttributes) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym102 := z.DecBinary()
	_ = yym102
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct103 := r.ContainerType()
		if yyct103 == codecSelferValueTypeMap1234 {
			yyl103 := r.ReadMapStart()
			if yyl103 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl103, d)
			}
		} else if yyct103 == codecSelferValueTypeArray1234 {
			yyl103 := r.ReadArrayStart()
			if yyl103 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl103, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *ResourceAttributes) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys104Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys104Slc
	var yyhl104 bool = l >= 0
	for yyj104 := 0; ; yyj104++ {
		if yyhl104 {
			if yyj104 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys104Slc = r.DecodeBytes(yys104Slc, true, true)
		yys104 := string(yys104Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys104 {
		case "namespace":
			if r.TryDecodeAsNil() {
				x.Namespace = ""
			} else {
				x.Namespace = string(r.DecodeString())
			}
		case "verb":
			if r.TryDecodeAsNil() {
				x.Verb = ""
			} else {
				x.Verb = string(r.DecodeString())
			}
		case "group":
			if r.TryDecodeAsNil() {
				x.Group = ""
			} else {
				x.Group = string(r.DecodeString())
			}
		case "version":
			if r.TryDecodeAsNil() {
				x.Version = ""
			} else {
				x.Version = string(r.DecodeString())
			}
		case "resource":
			if r.TryDecodeAsNil() {
				x.Resource = ""
			} else {
				x.Resource = string(r.DecodeString())
			}
		case "subresource":
			if r.TryDecodeAsNil() {
				x.Subresource = ""
			} else {
				x.Subresource = string(r.DecodeString())
			}
		case "name":
			if r.TryDecodeAsNil() {
				x.Name = ""
			} else {
				x.Name = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys104)
		} // end switch yys104
	} // end for yyj104
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *ResourceAttributes) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj112 int
	var yyb112 bool
	var yyhl112 bool = l >= 0
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Namespace = ""
	} else {
		x.Namespace = string(r.DecodeString())
	}
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Verb = ""
	} else {
		x.Verb = string(r.DecodeString())
	}
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Group = ""
	} else {
		x.Group = string(r.DecodeString())
	}
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Version = ""
	} else {
		x.Version = string(r.DecodeString())
	}
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Resource = ""
	} else {
		x.Resource = string(r.DecodeString())
	}
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Subresource = ""
	} else {
		x.Subresource = string(r.DecodeString())
	}
	yyj112++
	if yyhl112 {
		yyb112 = yyj112 > l
	} else {
		yyb112 = r.CheckBreak()
	}
	if yyb112 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Name = ""
	} else {
		x.Name = string(r.DecodeString())
	}
	for {
		yyj112++
		if yyhl112 {
			yyb112 = yyj112 > l
		} else {
			yyb112 = r.CheckBreak()
		}
		if yyb112 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj112-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *NonResourceAttributes) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym120 := z.EncBinary()
		_ = yym120
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep121 := !z.EncBinary()
			yy2arr121 := z.EncBasicHandle().StructToArray
			var yyq121 [2]bool
			_, _, _ = yysep121, yyq121, yy2arr121
			const yyr121 bool = false
			yyq121[0] = x.Path != ""
			yyq121[1] = x.Verb != ""
			var yynn121 int
			if yyr121 || yy2arr121 {
				r.EncodeArrayStart(2)
			} else {
				yynn121 = 0
				for _, b := range yyq121 {
					if b {
						yynn121++
					}
				}
				r.EncodeMapStart(yynn121)
				yynn121 = 0
			}
			if yyr121 || yy2arr121 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq121[0] {
					yym123 := z.EncBinary()
					_ = yym123
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq121[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("path"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym124 := z.EncBinary()
					_ = yym124
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Path))
					}
				}
			}
			if yyr121 || yy2arr121 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq121[1] {
					yym126 := z.EncBinary()
					_ = yym126
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Verb))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq121[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("verb"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym127 := z.EncBinary()
					_ = yym127
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Verb))
					}
				}
			}
			if yyr121 || yy2arr121 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *NonResourceAttributes) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym128 := z.DecBinary()
	_ = yym128
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct129 := r.ContainerType()
		if yyct129 == codecSelferValueTypeMap1234 {
			yyl129 := r.ReadMapStart()
			if yyl129 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl129, d)
			}
		} else if yyct129 == codecSelferValueTypeArray1234 {
			yyl129 := r.ReadArrayStart()
			if yyl129 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl129, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *NonResourceAttributes) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys130Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys130Slc
	var yyhl130 bool = l >= 0
	for yyj130 := 0; ; yyj130++ {
		if yyhl130 {
			if yyj130 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys130Slc = r.DecodeBytes(yys130Slc, true, true)
		yys130 := string(yys130Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys130 {
		case "path":
			if r.TryDecodeAsNil() {
				x.Path = ""
			} else {
				x.Path = string(r.DecodeString())
			}
		case "verb":
			if r.TryDecodeAsNil() {
				x.Verb = ""
			} else {
				x.Verb = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys130)
		} // end switch yys130
	} // end for yyj130
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *NonResourceAttributes) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj133 int
	var yyb133 bool
	var yyhl133 bool = l >= 0
	yyj133++
	if yyhl133 {
		yyb133 = yyj133 > l
	} else {
		yyb133 = r.CheckBreak()
	}
	if yyb133 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Path = ""
	} else {
		x.Path = string(r.DecodeString())
	}
	yyj133++
	if yyhl133 {
		yyb133 = yyj133 > l
	} else {
		yyb133 = r.CheckBreak()
	}
	if yyb133 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Verb = ""
	} else {
		x.Verb = string(r.DecodeString())
	}
	for {
		yyj133++
		if yyhl133 {
			yyb133 = yyj133 > l
		} else {
			yyb133 = r.CheckBreak()
		}
		if yyb133 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj133-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *SubjectAccessReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym136 := z.EncBinary()
		_ = yym136
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep137 := !z.EncBinary()
			yy2arr137 := z.EncBasicHandle().StructToArray
			var yyq137 [4]bool
			_, _, _ = yysep137, yyq137, yy2arr137
			const yyr137 bool = false
			yyq137[0] = x.ResourceAttributes != nil
			yyq137[1] = x.NonResourceAttributes != nil
			yyq137[2] = x.User != ""
			yyq137[3] = len(x.Groups) != 0
			var yynn137 int
			if yyr137 || yy2arr137 {
				r.EncodeArrayStart(4)
			} else {
				yynn137 = 0
				for _, b := range yyq137 {
					if b {
						yynn137++
					}
				}
				r.EncodeMapStart(yynn137)
				yynn137 = 0
			}
			if yyr137 || yy2arr137 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq137[0] {
					if x.ResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.ResourceAttributes.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq137[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("resourceAttributes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.ResourceAttributes.CodecEncodeSelf(e)
					}
				}
			}
			if yyr137 || yy2arr137 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq137[1] {
					if x.NonResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.NonResourceAttributes.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq137[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("nonResourceAttributes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.NonResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.NonResourceAttributes.CodecEncodeSelf(e)
					}
				}
			}
			if yyr137 || yy2arr137 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq137[2] {
					yym141 := z.EncBinary()
					_ = yym141
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.User))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq137[2] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("user"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym142 := z.EncBinary()
					_ = yym142
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.User))
					}
				}
			}
			if yyr137 || yy2arr137 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq137[3] {
					if x.Groups == nil {
						r.EncodeNil()
					} else {
						yym144 := z.EncBinary()
						_ = yym144
						if false {
						} else {
							z.F.EncSliceStringV(x.Groups, false, e)
						}
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq137[3] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("group"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.Groups == nil {
						r.EncodeNil()
					} else {
						yym145 := z.EncBinary()
						_ = yym145
						if false {
						} else {
							z.F.EncSliceStringV(x.Groups, false, e)
						}
					}
				}
			}
			if yyr137 || yy2arr137 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SubjectAccessReviewSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym146 := z.DecBinary()
	_ = yym146
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct147 := r.ContainerType()
		if yyct147 == codecSelferValueTypeMap1234 {
			yyl147 := r.ReadMapStart()
			if yyl147 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl147, d)
			}
		} else if yyct147 == codecSelferValueTypeArray1234 {
			yyl147 := r.ReadArrayStart()
			if yyl147 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl147, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SubjectAccessReviewSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys148Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys148Slc
	var yyhl148 bool = l >= 0
	for yyj148 := 0; ; yyj148++ {
		if yyhl148 {
			if yyj148 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys148Slc = r.DecodeBytes(yys148Slc, true, true)
		yys148 := string(yys148Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys148 {
		case "resourceAttributes":
			if r.TryDecodeAsNil() {
				if x.ResourceAttributes != nil {
					x.ResourceAttributes = nil
				}
			} else {
				if x.ResourceAttributes == nil {
					x.ResourceAttributes = new(ResourceAttributes)
				}
				x.ResourceAttributes.CodecDecodeSelf(d)
			}
		case "nonResourceAttributes":
			if r.TryDecodeAsNil() {
				if x.NonResourceAttributes != nil {
					x.NonResourceAttributes = nil
				}
			} else {
				if x.NonResourceAttributes == nil {
					x.NonResourceAttributes = new(NonResourceAttributes)
				}
				x.NonResourceAttributes.CodecDecodeSelf(d)
			}
		case "user":
			if r.TryDecodeAsNil() {
				x.User = ""
			} else {
				x.User = string(r.DecodeString())
			}
		case "group":
			if r.TryDecodeAsNil() {
				x.Groups = nil
			} else {
				yyv152 := &x.Groups
				yym153 := z.DecBinary()
				_ = yym153
				if false {
				} else {
					z.F.DecSliceStringX(yyv152, false, d)
				}
			}
		default:
			z.DecStructFieldNotFound(-1, yys148)
		} // end switch yys148
	} // end for yyj148
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj154 int
	var yyb154 bool
	var yyhl154 bool = l >= 0
	yyj154++
	if yyhl154 {
		yyb154 = yyj154 > l
	} else {
		yyb154 = r.CheckBreak()
	}
	if yyb154 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.ResourceAttributes != nil {
			x.ResourceAttributes = nil
		}
	} else {
		if x.ResourceAttributes == nil {
			x.ResourceAttributes = new(ResourceAttributes)
		}
		x.ResourceAttributes.CodecDecodeSelf(d)
	}
	yyj154++
	if yyhl154 {
		yyb154 = yyj154 > l
	} else {
		yyb154 = r.CheckBreak()
	}
	if yyb154 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.NonResourceAttributes != nil {
			x.NonResourceAttributes = nil
		}
	} else {
		if x.NonResourceAttributes == nil {
			x.NonResourceAttributes = new(NonResourceAttributes)
		}
		x.NonResourceAttributes.CodecDecodeSelf(d)
	}
	yyj154++
	if yyhl154 {
		yyb154 = yyj154 > l
	} else {
		yyb154 = r.CheckBreak()
	}
	if yyb154 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.User = ""
	} else {
		x.User = string(r.DecodeString())
	}
	yyj154++
	if yyhl154 {
		yyb154 = yyj154 > l
	} else {
		yyb154 = r.CheckBreak()
	}
	if yyb154 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Groups = nil
	} else {
		yyv158 := &x.Groups
		yym159 := z.DecBinary()
		_ = yym159
		if false {
		} else {
			z.F.DecSliceStringX(yyv158, false, d)
		}
	}
	for {
		yyj154++
		if yyhl154 {
			yyb154 = yyj154 > l
		} else {
			yyb154 = r.CheckBreak()
		}
		if yyb154 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj154-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *SelfSubjectAccessReviewSpec) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym160 := z.EncBinary()
		_ = yym160
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep161 := !z.EncBinary()
			yy2arr161 := z.EncBasicHandle().StructToArray
			var yyq161 [2]bool
			_, _, _ = yysep161, yyq161, yy2arr161
			const yyr161 bool = false
			yyq161[0] = x.ResourceAttributes != nil
			yyq161[1] = x.NonResourceAttributes != nil
			var yynn161 int
			if yyr161 || yy2arr161 {
				r.EncodeArrayStart(2)
			} else {
				yynn161 = 0
				for _, b := range yyq161 {
					if b {
						yynn161++
					}
				}
				r.EncodeMapStart(yynn161)
				yynn161 = 0
			}
			if yyr161 || yy2arr161 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq161[0] {
					if x.ResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.ResourceAttributes.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq161[0] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("resourceAttributes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.ResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.ResourceAttributes.CodecEncodeSelf(e)
					}
				}
			}
			if yyr161 || yy2arr161 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq161[1] {
					if x.NonResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.NonResourceAttributes.CodecEncodeSelf(e)
					}
				} else {
					r.EncodeNil()
				}
			} else {
				if yyq161[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("nonResourceAttributes"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					if x.NonResourceAttributes == nil {
						r.EncodeNil()
					} else {
						x.NonResourceAttributes.CodecEncodeSelf(e)
					}
				}
			}
			if yyr161 || yy2arr161 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SelfSubjectAccessReviewSpec) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym164 := z.DecBinary()
	_ = yym164
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct165 := r.ContainerType()
		if yyct165 == codecSelferValueTypeMap1234 {
			yyl165 := r.ReadMapStart()
			if yyl165 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl165, d)
			}
		} else if yyct165 == codecSelferValueTypeArray1234 {
			yyl165 := r.ReadArrayStart()
			if yyl165 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl165, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SelfSubjectAccessReviewSpec) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys166Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys166Slc
	var yyhl166 bool = l >= 0
	for yyj166 := 0; ; yyj166++ {
		if yyhl166 {
			if yyj166 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys166Slc = r.DecodeBytes(yys166Slc, true, true)
		yys166 := string(yys166Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys166 {
		case "resourceAttributes":
			if r.TryDecodeAsNil() {
				if x.ResourceAttributes != nil {
					x.ResourceAttributes = nil
				}
			} else {
				if x.ResourceAttributes == nil {
					x.ResourceAttributes = new(ResourceAttributes)
				}
				x.ResourceAttributes.CodecDecodeSelf(d)
			}
		case "nonResourceAttributes":
			if r.TryDecodeAsNil() {
				if x.NonResourceAttributes != nil {
					x.NonResourceAttributes = nil
				}
			} else {
				if x.NonResourceAttributes == nil {
					x.NonResourceAttributes = new(NonResourceAttributes)
				}
				x.NonResourceAttributes.CodecDecodeSelf(d)
			}
		default:
			z.DecStructFieldNotFound(-1, yys166)
		} // end switch yys166
	} // end for yyj166
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SelfSubjectAccessReviewSpec) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj169 int
	var yyb169 bool
	var yyhl169 bool = l >= 0
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.ResourceAttributes != nil {
			x.ResourceAttributes = nil
		}
	} else {
		if x.ResourceAttributes == nil {
			x.ResourceAttributes = new(ResourceAttributes)
		}
		x.ResourceAttributes.CodecDecodeSelf(d)
	}
	yyj169++
	if yyhl169 {
		yyb169 = yyj169 > l
	} else {
		yyb169 = r.CheckBreak()
	}
	if yyb169 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		if x.NonResourceAttributes != nil {
			x.NonResourceAttributes = nil
		}
	} else {
		if x.NonResourceAttributes == nil {
			x.NonResourceAttributes = new(NonResourceAttributes)
		}
		x.NonResourceAttributes.CodecDecodeSelf(d)
	}
	for {
		yyj169++
		if yyhl169 {
			yyb169 = yyj169 > l
		} else {
			yyb169 = r.CheckBreak()
		}
		if yyb169 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj169-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}

func (x *SubjectAccessReviewStatus) CodecEncodeSelf(e *codec1978.Encoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperEncoder(e)
	_, _, _ = h, z, r
	if x == nil {
		r.EncodeNil()
	} else {
		yym172 := z.EncBinary()
		_ = yym172
		if false {
		} else if z.HasExtensions() && z.EncExt(x) {
		} else {
			yysep173 := !z.EncBinary()
			yy2arr173 := z.EncBasicHandle().StructToArray
			var yyq173 [2]bool
			_, _, _ = yysep173, yyq173, yy2arr173
			const yyr173 bool = false
			yyq173[1] = x.Reason != ""
			var yynn173 int
			if yyr173 || yy2arr173 {
				r.EncodeArrayStart(2)
			} else {
				yynn173 = 1
				for _, b := range yyq173 {
					if b {
						yynn173++
					}
				}
				r.EncodeMapStart(yynn173)
				yynn173 = 0
			}
			if yyr173 || yy2arr173 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				yym175 := z.EncBinary()
				_ = yym175
				if false {
				} else {
					r.EncodeBool(bool(x.Allowed))
				}
			} else {
				z.EncSendContainerState(codecSelfer_containerMapKey1234)
				r.EncodeString(codecSelferC_UTF81234, string("allowed"))
				z.EncSendContainerState(codecSelfer_containerMapValue1234)
				yym176 := z.EncBinary()
				_ = yym176
				if false {
				} else {
					r.EncodeBool(bool(x.Allowed))
				}
			}
			if yyr173 || yy2arr173 {
				z.EncSendContainerState(codecSelfer_containerArrayElem1234)
				if yyq173[1] {
					yym178 := z.EncBinary()
					_ = yym178
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				} else {
					r.EncodeString(codecSelferC_UTF81234, "")
				}
			} else {
				if yyq173[1] {
					z.EncSendContainerState(codecSelfer_containerMapKey1234)
					r.EncodeString(codecSelferC_UTF81234, string("reason"))
					z.EncSendContainerState(codecSelfer_containerMapValue1234)
					yym179 := z.EncBinary()
					_ = yym179
					if false {
					} else {
						r.EncodeString(codecSelferC_UTF81234, string(x.Reason))
					}
				}
			}
			if yyr173 || yy2arr173 {
				z.EncSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				z.EncSendContainerState(codecSelfer_containerMapEnd1234)
			}
		}
	}
}

func (x *SubjectAccessReviewStatus) CodecDecodeSelf(d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	yym180 := z.DecBinary()
	_ = yym180
	if false {
	} else if z.HasExtensions() && z.DecExt(x) {
	} else {
		yyct181 := r.ContainerType()
		if yyct181 == codecSelferValueTypeMap1234 {
			yyl181 := r.ReadMapStart()
			if yyl181 == 0 {
				z.DecSendContainerState(codecSelfer_containerMapEnd1234)
			} else {
				x.codecDecodeSelfFromMap(yyl181, d)
			}
		} else if yyct181 == codecSelferValueTypeArray1234 {
			yyl181 := r.ReadArrayStart()
			if yyl181 == 0 {
				z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
			} else {
				x.codecDecodeSelfFromArray(yyl181, d)
			}
		} else {
			panic(codecSelferOnlyMapOrArrayEncodeToStructErr1234)
		}
	}
}

func (x *SubjectAccessReviewStatus) codecDecodeSelfFromMap(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yys182Slc = z.DecScratchBuffer() // default slice to decode into
	_ = yys182Slc
	var yyhl182 bool = l >= 0
	for yyj182 := 0; ; yyj182++ {
		if yyhl182 {
			if yyj182 >= l {
				break
			}
		} else {
			if r.CheckBreak() {
				break
			}
		}
		z.DecSendContainerState(codecSelfer_containerMapKey1234)
		yys182Slc = r.DecodeBytes(yys182Slc, true, true)
		yys182 := string(yys182Slc)
		z.DecSendContainerState(codecSelfer_containerMapValue1234)
		switch yys182 {
		case "allowed":
			if r.TryDecodeAsNil() {
				x.Allowed = false
			} else {
				x.Allowed = bool(r.DecodeBool())
			}
		case "reason":
			if r.TryDecodeAsNil() {
				x.Reason = ""
			} else {
				x.Reason = string(r.DecodeString())
			}
		default:
			z.DecStructFieldNotFound(-1, yys182)
		} // end switch yys182
	} // end for yyj182
	z.DecSendContainerState(codecSelfer_containerMapEnd1234)
}

func (x *SubjectAccessReviewStatus) codecDecodeSelfFromArray(l int, d *codec1978.Decoder) {
	var h codecSelfer1234
	z, r := codec1978.GenHelperDecoder(d)
	_, _, _ = h, z, r
	var yyj185 int
	var yyb185 bool
	var yyhl185 bool = l >= 0
	yyj185++
	if yyhl185 {
		yyb185 = yyj185 > l
	} else {
		yyb185 = r.CheckBreak()
	}
	if yyb185 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Allowed = false
	} else {
		x.Allowed = bool(r.DecodeBool())
	}
	yyj185++
	if yyhl185 {
		yyb185 = yyj185 > l
	} else {
		yyb185 = r.CheckBreak()
	}
	if yyb185 {
		z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
		return
	}
	z.DecSendContainerState(codecSelfer_containerArrayElem1234)
	if r.TryDecodeAsNil() {
		x.Reason = ""
	} else {
		x.Reason = string(r.DecodeString())
	}
	for {
		yyj185++
		if yyhl185 {
			yyb185 = yyj185 > l
		} else {
			yyb185 = r.CheckBreak()
		}
		if yyb185 {
			break
		}
		z.DecSendContainerState(codecSelfer_containerArrayElem1234)
		z.DecStructFieldNotFound(yyj185-1, "")
	}
	z.DecSendContainerState(codecSelfer_containerArrayEnd1234)
}


text:
<?php

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

namespace PhpUnitTestGenerator\Generator\Provider\Object;

use PhpUnitTestGenerator\Generator\Provider\Definition\ObjectInterface;

/**
 * Description of Db2PhpEntity
 *
 * @todo implement me
 *
 * @author michaeldoehler
 */
class Db2PhpEntity implements ObjectInterface
{

    /**
     * checks if provider can generate for this object
     *
     * @param \PhpUnitTestGenerator\Testable\Object $object
     * @return boolean
     */
    public function canHandleTestableObject(\PhpUnitTestGenerator\Testable\Object $object)
    {
        if (false === class_exists("IntelliShop\\Framework\\Entity\\Db2PhpEntityBase")) {
            return false;
        }

        return $object->isChildOfClass("IntelliShop\\Framework\\Entity\\Db2PhpEntityBase");
    }

    /**
     * checks if provider can finalize(no other generators required) the object
     *
     * @param \PhpUnitTestGenerator\Testable\Object $object
     * @return boolean
     */
    public function canFinalizeTestableObject(\PhpUnitTestGenerator\Testable\Object $object)
    {
        if (false === class_exists("IntelliShop\\Framework\\Entity\\Db2PhpEntityBase")) {
            return false;
        }

        return $object->isChildOfClass("IntelliShop\\Framework\\Entity\\Db2PhpEntityBase");
    }

    /**
     * fill the test class with tests
     *
     * @todo: Implement me...
     *
     * @param \PhpUnitTestGenerator\Testable\Object $object
     * @param \PhpUnitTestGenerator\Generator\Test $test
     */
    public function handleTestableObject(\PhpUnitTestGenerator\Testable\Object $object, \PhpUnitTestGenerator\Generator\Test $test)
    {

    }

}

redpajama_set_name: RedPajamaGithub


text:
/**
 * Slider which supports vertical or horizontal orientation, keyboard adjustments, configurable snapping, axis clicking
 * and animation. Can be added as an item to any container.
 *
 * Sliders can be created with more than one thumb handle by passing an array of values instead of a single one:
 *
 *     @example
 *     Ext.create('Ext.slider.Multi', {
 *         width: 200,
 *         values: [25, 50, 75],
 *         increment: 5,
 *         minValue: 0,
 *         maxValue: 100,
 *
 *         // this defaults to true, setting to false allows the thumbs to pass each other
 *         constrainThumbs: false,
 *         renderTo: Ext.getBody()
 *     });
 */
Ext.define('Ext.slider.Multi', {
    extend: 'Ext.form.field.Base',
    alias: 'widget.multislider',
    alternateClassName: 'Ext.slider.MultiSlider',

    requires: [
        'Ext.slider.Thumb',
        'Ext.slider.Tip',
        'Ext.Number',
        'Ext.util.Format',
        'Ext.Template'
    ],

    /**
     * @cfg {Number} value
     * A value with which to initialize the slider. Setting this will only result in the creation
     * of a single slider thumb; if you want multiple thumbs then use the {@link #values} config instead.
     *
     * Defaults to #minValue.
     */

    /**
     * @cfg {Number[]} values
     * Array of Number values with which to initalize the slider. A separate slider thumb will be created for each value
     * in this array. This will take precedence over the single {@link #value} config.
     */

    /**
     * @cfg {Boolean} vertical
     * Orient the Slider vertically rather than horizontally.
     */
    vertical: false,

    /**
     * @cfg {Number} minValue
     * The minimum value for the Slider.
     */
    minValue: 0,

    /**
     * @cfg {Number} maxValue
     * The maximum value for the Slider.
     */
    maxValue: 100,

    /**
     * @cfg {Number/Boolean} decimalPrecision The number of decimal places to which to round the Slider's value.
     *
     * To disable rounding, configure as **false**.
     */
    decimalPrecision: 0,

    /**
     * @cfg {Number} keyIncrement
     * How many units to change the Slider when adjusting with keyboard navigation. If the increment
     * config is larger, it will be used instead.
     */
    keyIncrement: 1,

    /**
     * @cfg {Number} [pageSize=10]
     * How many units to change the Slider when using PageUp and PageDown keys.
     */
    pageSize: 10,

    /**
     * @cfg {Number} increment
     * How many units to change the slider when adjusting by drag and drop. Use this option to enable 'snapping'.
     */
    increment: 0,

    /**
     * @cfg {Boolean} [zeroBasedSnapping=false]
     * Set to `true` to calculate snap points based on {@link #increment}s from zero as opposed to
     * from this Slider's {@link #minValue}.
     *
     * By Default, valid snap points are calculated starting {@link #increment}s from the {@link #minValue}
     */

    /**
     * @private
     * @property {Number[]} clickRange
     * Determines whether or not a click to the slider component is considered to be a user request to change the value. Specified as an array of [top, bottom],
     * the click event's 'top' property is compared to these numbers and the click only considered a change request if it falls within them. e.g. if the 'top'
     * value of the click event is 4 or 16, the click is not considered a change request as it falls outside of the [5, 15] range
     */
    clickRange: [5,15],

    /**
     * @cfg {Boolean} clickToChange
     * Determines whether or not clicking on the Slider axis will change the slider.
     */
    clickToChange : true,

    /**
     * @cfg {Object/Boolean} animate
     * Turn on or off animation. May be an animation configuration object:
     *
     *     animate: {
     *         duration: 3000,
     *         easing: 'easeIn'
     *     }
     */
    animate: true,

    /**
     * @property {Boolean} dragging
     * True while the thumb is in a drag operation
     */
    dragging: false,

    /**
     * @cfg {Boolean} constrainThumbs
     * True to disallow thumbs from overlapping one another.
     */
    constrainThumbs: true,

    /**
     * @cfg {Object/Boolean} useTips
     * True to use an {@link Ext.slider.Tip} to display tips for the value. This option may also
     * provide a configuration object for an {@link Ext.slider.Tip}.
     */
    useTips : true,

    /**
     * @cfg {Function} [tipText=undefined]
     * A function used to display custom text for the slider tip.
     *
     * Defaults to null, which will use the default on the plugin.
     *
     * @cfg {Ext.slider.Thumb} tipText.thumb The Thumb that the Tip is attached to
     * @cfg {String} tipText.return The text to display in the tip
     */
    tipText : null,

    /**
     * @inheritdoc
     */
    defaultBindProperty: 'values',

    /**
     * @event beforechange
     * Fires before the slider value is changed. By returning false from an event handler, you can cancel the
     * event and prevent the slider from changing.
     * @param {Ext.slider.Multi} slider The slider
     * @param {Number} newValue The new value which the slider is being changed to.
     * @param {Number} oldValue The old value which the slider was previously.
     */

    /**
     * @event change
     * Fires when the slider value is changed.
     * @param {Ext.slider.Multi} slider The slider
     * @param {Number} newValue The new value which the slider has been changed to.
     * @param {Ext.slider.Thumb} thumb The thumb that was changed
     */

    /**
     * @event changecomplete
     * Fires when the slider value is changed by the user and any drag operations have completed.
     * @param {Ext.slider.Multi} slider The slider
     * @param {Number} newValue The new value which the slider has been changed to.
     * @param {Ext.slider.Thumb} thumb The thumb that was changed
     */

    /**
     * @event dragstart
     * Fires after a drag operation has started.
     * @param {Ext.slider.Multi} slider The slider
     * @param {Ext.event.Event} e The event fired from Ext.dd.DragTracker
     */

    /**
     * @event drag
     * Fires continuously during the drag operation while the mouse is moving.
     * @param {Ext.slider.Multi} slider The slider
     * @param {Ext.event.Event} e The event fired from Ext.dd.DragTracker
     */

    /**
     * @event dragend
     * Fires after the drag operation has completed.
     * @param {Ext.slider.Multi} slider The slider
     * @param {Ext.event.Event} e The event fired from Ext.dd.DragTracker
     */

    ariaRole: 'slider',

    focusable: true,
    needArrowKeys: true,
    tabIndex: 0,

    focusCls: 'slider-focus',

    childEls: [
        'endEl', 'innerEl'
    ],

    // note: {id} here is really {inputId}, but {cmpId} is available
    fieldSubTpl: [
        '<div id="{id}" data-ref="inputEl" {inputAttrTpl}',
            ' class="', Ext.baseCSSPrefix, 'slider {fieldCls} {vertical}',
            '{childElCls}"',
            '<tpl if="tabIdx != null"> tabindex="{tabIdx}"</tpl>',
            '<tpl foreach="inputElAriaAttributes"> {$}="{.}"</tpl>',
            '>',
            '
',
                '
',
                    '{%this.renderThumbs(out, values)%}',
                '
',
            '
',
        '
',
        {
            renderThumbs: function(out, values) {
                var me = values.$comp,
                    i = 0,
                    thumbs = me.thumbs,
                    len = thumbs.length,
                    thumb,
                    thumbConfig;

                for (; i < len; i++) {
                    thumb = thumbs[i];
                    thumbConfig = thumb.getElConfig();
                    thumbConfig.id = me.id + '-thumb-' + i;
                    Ext.DomHelper.generateMarkup(thumbConfig, out);
                }
            },
            disableFormats: true
        }
    ],

    horizontalProp: 'left',

    initValue: function() {
        var me = this,
            extValueFrom = Ext.valueFrom,
            // Fallback for initial values: values config -> value config -> minValue config -> 0
            values = extValueFrom(me.values, [extValueFrom(me.value, extValueFrom(me.minValue, 0))]),
            i = 0,
            len = values.length;

        // Store for use in dirty check
        me.originalValue = values;

        // Add a thumb for each value, enforcing configured constraints
        for (; i < len; i++) {
            me.addThumb(me.normalizeValue(values[i]));
        }
    },

    initComponent: function() {
        var me = this,
            tipPlug,
            hasTip,
            p, pLen, plugins;

        /**
         * @property {Array} thumbs
         * Array containing references to each thumb
         */
        me.thumbs = [];

        me.keyIncrement = Math.max(me.increment, me.keyIncrement);

        me.extraFieldBodyCls = Ext.baseCSSPrefix + 'slider-ct-' + (me.vertical ? 'vert' : 'horz');

        me.callParent();

        // only can use it if it exists.
        if (me.useTips) {
            if (Ext.isObject(me.useTips)) {
                tipPlug = Ext.apply({}, me.useTips);
            } else {
                tipPlug = me.tipText ? {getText: me.tipText} : {};
            }

            plugins = me.plugins = me.plugins || [];
            pLen    = plugins.length;

            for (p = 0; p < pLen; p++) {
                if (plugins[p].isSliderTip) {
                    hasTip = true;
                    break;
                }
            }

            if (!hasTip) {
                me.plugins.push(new Ext.slider.Tip(tipPlug));
            }
        }
    },

    /**
     * Creates a new thumb and adds it to the slider
     * @param {Number} [value=0] The initial value to set on the thumb.
     * @return {Ext.slider.Thumb} The thumb
     */
    addThumb: function(value) {
        var me = this,
            thumb = new Ext.slider.Thumb({
                ownerCt     : me,
                value       : value,
                slider      : me,
                index       : me.thumbs.length,
                constrain   : me.constrainThumbs,
                disabled    : !!me.readOnly
            });

        me.thumbs.push(thumb);

        //render the thumb now if needed
        if (me.rendered) {
            thumb.render();
        }

        return thumb;
    },

    /**
     * @private
     * Moves the given thumb above all other by increasing its z-index. This is called when as drag
     * any thumb, so that the thumb that was just dragged is always at the highest z-index. This is
     * required when the thumbs are stacked on top of each other at one of the ends of the slider's
     * range, which can result in the user not being able to move any of them.
     * @param {Ext.slider.Thumb} topThumb The thumb to move to the top
     */
    promoteThumb: function(topThumb) {
        var thumbs = this.thumbStack || (this.thumbStack = Ext.Array.slice(this.thumbs)),
            ln = thumbs.length,
            zIndex = 10000, i;

        // Move topthumb to position zero
        if (thumbs[0] !== topThumb) {
            Ext.Array.remove(thumbs, topThumb);
            thumbs.unshift(topThumb);
        }

        // Then shuffle the zIndices
        for (i = 0; i < ln; i++) {
            thumbs[i].el.setStyle('zIndex', zIndex);
            zIndex -= 1000;
        }
    },

    getSubTplData : function(fieldData) {
        var me = this,
            data, ariaAttr;

        data = Ext.apply(me.callParent([fieldData]), {
            $comp: me,
            vertical: me.vertical ? Ext.baseCSSPrefix + 'slider-vert' : Ext.baseCSSPrefix + 'slider-horz',
            minValue: me.minValue,
            maxValue: me.maxValue,
            value: me.value,
            tabIdx: me.tabIndex,
            childElCls: ''
        });

        ariaAttr = data.inputElAriaAttributes;

        if (ariaAttr) {
            ariaAttr['aria-orientation'] = me.vertical ? 'vertical' : 'horizontal';
            ariaAttr['aria-valuemin'] = me.minValue;
            ariaAttr['aria-valuemax'] = me.maxValue;
            ariaAttr['aria-valuenow'] = me.value;
        }

        return data;
    },

    onRender : function() {
        var me = this,
            thumbs = me.thumbs,
            len = thumbs.length,
            i = 0,
            thumb;

        me.callParent(arguments);

        for (i = 0; i < len; i++) {
            thumb = thumbs[i];
            thumb.el = me.el.getById(me.id + '-thumb-' + i);
            thumb.onRender();
        }
    },

    /**
     * @private
     * Adds keyboard and mouse listeners on this.el. Ignores click events on the internal focus element.
     */
    initEvents : function() {
        var me = this;

        me.callParent();

        me.mon(me.el, {
            scope    : me,
            mousedown: me.onMouseDown,
            keydown  : me.onKeyDown
        });
    },

    onDragStart: Ext.emptyFn,
    onDragEnd: Ext.emptyFn,

    /**
     * @private
     * Given an `[x, y]` position within the slider's track (Points outside the slider's track are coerced to either the minimum or maximum value),
     * calculate how many pixels **from the slider origin** (left for horizontal Sliders and bottom for vertical Sliders) that point is.
     *
     * If the point is outside the range of the Slider's track, the return value is `undefined`
     * @param {Number[]} xy The point to calculate the track point for
     */
    getTrackpoint : function(xy) {
        var me = this,
            vertical = me.vertical,
            sliderTrack = me.innerEl,
            trackLength, result,
            positionProperty;

        if (vertical) {
            positionProperty = 'top';
            trackLength = sliderTrack.getHeight();
        } else {
            positionProperty = me.horizontalProp;
            trackLength = sliderTrack.getWidth();
        }
        xy = me.transformTrackPoints(sliderTrack.translatePoints(xy));
        result = Ext.Number.constrain(xy[positionProperty], 0, trackLength);
        return vertical ? trackLength - result : result;
    },

    transformTrackPoints: Ext.identityFn,

    // Base field checkChange method will fire 'change' event with signature common to all fields,
    // but Slider fires the same event with different signature. Hence we disable checkChange here
    // to avoid breakage.
    checkChange: Ext.emptyFn,

    /**
     * @private
     * Mousedown handler for the slider. If the clickToChange is enabled and the click was not on the draggable 'thumb',
     * this calculates the new value of the slider and tells the implementation (Horizontal or Vertical) to move the thumb
     * @param {Ext.event.Event} e The click event
     */
    onMouseDown : function(e) {
        var me = this,
            thumbClicked = false,
            i = 0,
            thumbs = me.thumbs,
            len = thumbs.length,
            trackPoint;

        if (me.disabled) {
            return;
        }

        //see if the click was on any of the thumbs
        for (; !thumbClicked && i < len; i++) {
            thumbClicked = thumbClicked || e.target === thumbs[i].el.dom;
        }

        // Focus ourselves before setting the value. This allows other
        // fields that have blur handlers (for example, date/number field)
        // to take care of themselves first. This is important for
        // databinding.
        me.focus();

        if (me.clickToChange && !thumbClicked) {
            trackPoint = me.getTrackpoint(e.getXY());
            if (trackPoint !== undefined) {
                me.onClickChange(trackPoint);
            }
        }
    },

    /**
     * @private
     * Moves the thumb to the indicated position.
     * Only changes the value if the click was within this.clickRange.
     * @param {Number} trackPoint local pixel offset **from the origin** (left for horizontal and bottom for vertical) along the Slider's axis at which the click event occured.
     */
    onClickChange : function(trackPoint) {
        var me = this,
            thumb, index;

        // How far along the track *from the origin* was the click.
        // If vertical, the origin is the bottom of the slider track.

        //find the nearest thumb to the click event
        thumb = me.getNearest(trackPoint);
        if (!thumb.disabled) {
            index = thumb.index;
            me.setValue(index, Ext.util.Format.round(me.reversePixelValue(trackPoint), me.decimalPrecision), undefined, true);
        }
    },

    /**
     * @private
     * Returns the nearest thumb to a click event, along with its distance
     * @param {Number} trackPoint local pixel position along the Slider's axis to find the Thumb for
     * @return {Object} The closest thumb object and its distance from the click event
     */
    getNearest: function(trackPoint) {
        var me = this,
            clickValue = me.reversePixelValue(trackPoint),
            nearestDistance = me.getRange() + 5, //add a small fudge for the end of the slider
            nearest = null,
            thumbs = me.thumbs,
            i = 0,
            len = thumbs.length,
            thumb,
            value,
            dist;

        for (; i < len; i++) {
            thumb = me.thumbs[i];
            value = thumb.value;
            dist  = Math.abs(value - clickValue);

            if (Math.abs(dist) <= nearestDistance) {
                // this makes sure that thumbs will stay in order
                if (nearest && nearest.value == value && value > clickValue && thumb.index > nearest.index) {
                    continue;
                }
                nearest = thumb;
                nearestDistance = dist;
            }
        }
        return nearest;
    },

    /**
     * @private
     * Handler for any keypresses captured by the slider. If the key is UP or RIGHT, the thumb is moved along to the right
     * by this.keyIncrement. If DOWN or LEFT it is moved left. Pressing CTRL moves the slider to the end in either direction
     * @param {Ext.event.Event} e The Event object
     */
    onKeyDown: function(e) {
        var me = this,
            ariaDom = me.ariaEl.dom,
            k, val;

        k = e.getKey();

        /*
         * The behaviour for keyboard handling with multiple thumbs is currently undefined.
         * There's no real sane default for it, so leave it like this until we come up
         * with a better way of doing it.
         */
        if (me.disabled || me.thumbs.length !== 1) {
            // Must not mingle with the Tab key!
            if (k !== e.TAB) {
                e.preventDefault();
            }

            return;
        }

        switch (k) {
            case e.UP:
            case e.RIGHT:
                val = e.ctrlKey ? me.maxValue : me.getValue(0) + me.keyIncrement;
                break;

            case e.DOWN:
            case e.LEFT:
                val = e.ctrlKey ? me.minValue : me.getValue(0) - me.keyIncrement;
                break;

            case e.HOME:
                val = me.minValue;
                break;

            case e.END:
                val = me.maxValue;
                break;

            case e.PAGE_UP:
                val = me.getValue(0) + me.pageSize;
                break;

            case e.PAGE_DOWN:
                val = me.getValue(0) - me.pageSize;
                break;
        }

        if (val !== undefined) {
            e.stopEvent();

            val = me.normalizeValue(val);

            me.setValue(0, val, undefined, true);

            if (ariaDom) {
                ariaDom.setAttribute('aria-valuenow', val);
            }
        }
    },

    /**
     * @private
     * Returns a snapped, constrained value when given a desired value
     * @param {Number} value Raw number value
     * @return {Number} The raw value rounded to the correct d.p. and constrained within the set max and min values
     */
    normalizeValue : function(v) {
        var me = this,
            snapFn = me.zeroBasedSnapping ? 'snap' : 'snapInRange';

        v = Ext.Number[snapFn](v, me.increment, me.minValue, me.maxValue);
        v = Ext.util.Format.round(v, me.decimalPrecision);
        v = Ext.Number.constrain(v, me.minValue, me.maxValue);
        return v;
    },

    /**
     * Sets the minimum value for the slider instance. If the current value is less than the minimum value, the current
     * value will be changed.
     * @param {Number} val The new minimum value
     */
    setMinValue: function(val) {
        var me = this,
            thumbs = me.thumbs,
            len = thumbs.length,
            ariaDom = me.ariaEl.dom,
            thumb, i;

        me.minValue = val;

        for (i = 0; i < len; ++i) {
            thumb = thumbs[i];
            if (thumb.value < val) {
                me.setValue(i, val, false);
            }
        }

        if (ariaDom) {
            ariaDom.setAttribute('aria-valuemin', val);
        }

        me.syncThumbs();
    },

    /**
     * Sets the maximum value for the slider instance. If the current value is more than the maximum value, the current
     * value will be changed.
     * @param {Number} val The new maximum value
     */
    setMaxValue: function(val) {
        var me = this,
            thumbs = me.thumbs,
            len = thumbs.length,
            ariaDom = me.ariaEl.dom,
            thumb, i;

        me.maxValue = val;

        for (i = 0; i < len; ++i) {
            thumb = thumbs[i];
            if (thumb.value > val) {
                me.setValue(i, val, false);
            }
        }

        if (ariaDom) {
            ariaDom.setAttribute('aria-valuemax', val);
        }

        me.syncThumbs();
    },

    /**
     * Programmatically sets the value of the Slider. Ensures that the value is constrained within the minValue and
     * maxValue.
     *
     * Setting the second slider's value without animation:
     *
     *     mySlider.setValue(1, 50, false);
     *
     * Setting multiple values with animation:
     *
     *     mySlider.setValue([20, 40, 60], true);
     *
     * @param {Number/Number[]} index Index of the thumb to move. Alternatively, it can be an array of values to set
     * for each thumb in the slider.
     * @param {Number} value The value to set the slider to. (This will be constrained within minValue and maxValue)
     * @param {Object/Boolean} [animate] `false` to not animate. `true` to use the default animation. This may also be an
     * animate configuration object, see {@link #cfg-animate}. If this configuration is omitted, the {@link #cfg-animate} configuration
     * will be used.
     * @return {Ext.slider.Multi} this
     */
    setValue : function(index, value, animate, changeComplete) {
        var me = this,
            thumbs = me.thumbs,
            ariaDom = me.ariaEl.dom,
            thumb, len, i, values;

        if (Ext.isArray(index)) {
            values = index;
            animate = value;

            for (i = 0, len = values.length; i < len; ++i) {
                thumb = thumbs[i];
                if (thumb) {
                    me.setValue(i, values[i], animate);
                }
            }
            return me;
        }

        thumb = me.thumbs[index];
        // ensures value is contstrained and snapped
        value = me.normalizeValue(value);

        if (value !== thumb.value && me.fireEvent('beforechange', me, value, thumb.value, thumb) !== false) {
            thumb.value = value;
            if (me.rendered) {
                if (Ext.isDefined(animate)) {
                    animate = animate === false ? false : animate;
                } else {
                    animate = me.animate;
                }
                thumb.move(me.calculateThumbPosition(value), animate);

                // At this moment we can only handle one thumb wrt ARIA
                if (index === 0 && ariaDom) {
                    ariaDom.setAttribute('aria-valuenow', value);
                }

                me.fireEvent('change', me, value, thumb);
                me.checkDirty();

                if (changeComplete) {
                    me.fireEvent('changecomplete', me, value, thumb);
                }
            }
        }
        return me;
    },

    /**
     * @private
     * Given a value within this Slider's range, calculates a Thumb's percentage CSS position to map that value.
     */
    calculateThumbPosition : function(v) {
        var me = this,
            minValue = me.minValue,
            pos = (v - minValue) / me.getRange() * 100;

        if (isNaN(pos)) {
            pos = 0;
        }

        return pos;
    },

    /**
     * @private
     * Returns the ratio of pixels to mapped values. e.g. if the slider is 200px wide and maxValue - minValue is 100,
     * the ratio is 2
     * @return {Number} The ratio of pixels to mapped values
     */
    getRatio : function() {
        var me = this,
            innerEl = me.innerEl,
            trackLength = me.vertical ? innerEl.getHeight() : innerEl.getWidth(),
            valueRange = me.getRange();

        return valueRange === 0 ? trackLength : (trackLength / valueRange);
    },

    getRange: function(){
        return this.maxValue - this.minValue;
    },

    /**
     * @private
     * Given a pixel location along the slider, returns the mapped slider value for that pixel.
     * E.g. if we have a slider 200px wide with minValue = 100 and maxValue = 500, reversePixelValue(50)
     * returns 200
     * @param {Number} pos The position along the slider to return a mapped value for
     * @return {Number} The mapped value for the given position
     */
    reversePixelValue : function(pos) {
        return this.minValue + (pos / this.getRatio());
    },

    /**
     * @private
     * Given a Thumb's percentage position along the slider, returns the mapped slider value for that pixel.
     * E.g. if we have a slider 200px wide with minValue = 100 and maxValue = 500, reversePercentageValue(25)
     * returns 200
     * @param {Number} pos The percentage along the slider track to return a mapped value for
     * @return {Number} The mapped value for the given position
     */
    reversePercentageValue : function(pos) {
        return this.minValue + this.getRange() * (pos / 100);
    },

    onDisable: function() {
        var me = this,
            i = 0,
            thumbs = me.thumbs,
            len = thumbs.length,
            thumb,
            el,
            xy;

        me.callParent();

        for (; i < len; i++) {
            thumb = thumbs[i];
            el = thumb.el;

            thumb.disable();

            if(Ext.isIE) {
                //IE breaks when using overflow visible and opacity other than 1.
                //Create a place holder for the thumb and display it.
                xy = el.getXY();
                el.hide();

                me.innerEl.addCls(me.disabledCls).dom.disabled = true;

                if (!me.thumbHolder) {
                    me.thumbHolder = me.endEl.createChild({
                        role: 'presentation',
                        cls: Ext.baseCSSPrefix + 'slider-thumb ' + me.disabledCls
                    });
                }

                me.thumbHolder.show().setXY(xy);
            }
        }
    },

    onEnable: function() {
        var me = this,
            i = 0,
            thumbs = me.thumbs,
            len = thumbs.length,
            thumb,
            el;

        this.callParent();

        for (; i < len; i++) {
            thumb = thumbs[i];
            el = thumb.el;

            thumb.enable();

            if (Ext.isIE) {
                me.innerEl.removeCls(me.disabledCls).dom.disabled = false;

                if (me.thumbHolder) {
                    me.thumbHolder.hide();
                }

                el.show();
                me.syncThumbs();
            }
        }
    },

    /**
     * Synchronizes thumbs position to the proper proportion of the total component width based on the current slider
     * {@link #value}. This will be called automatically when the Slider is resized by a layout, but if it is rendered
     * auto width, this method can be called from another resize handler to sync the Slider if necessary.
     */
    syncThumbs : function() {
        if (this.rendered) {
            var thumbs = this.thumbs,
                length = thumbs.length,
                i = 0;

            for (; i < length; i++) {
                thumbs[i].move(this.calculateThumbPosition(thumbs[i].value));
            }
        }
    },

    /**
     * Returns the current value of the slider
     * @param {Number} index The index of the thumb to return a value for
     * @return {Number/Number[]} The current value of the slider at the given index, or an array of all thumb values if
     * no index is given.
     */
    getValue : function(index) {
        return Ext.isNumber(index) ? this.thumbs[index].value : this.getValues();
    },

    /**
     * Returns an array of values - one for the location of each thumb
     * @return {Number[]} The set of thumb values
     */
    getValues: function() {
        var values = [],
            i = 0,
            thumbs = this.thumbs,
            len = thumbs.length;

        for (; i < len; i++) {
            values.push(thumbs[i].value);
        }

        return values;
    },

    getSubmitValue: function() {
        var me = this;
        return (me.disabled || !me.submitValue) ? null : me.getValue();
    },

    reset: function() {
        var me = this,
            arr = [].concat(me.originalValue),
            a     = 0,
            aLen  = arr.length,
            val;

        for (; a < aLen; a++) {
            val = arr[a];

            me.setValue(a, val);
        }

        me.clearInvalid();
        // delete here so we reset back to the original state
        delete me.wasValid;
    },

    setReadOnly: function(readOnly){
        var me = this,
            thumbs = me.thumbs,
            len = thumbs.length,
            i = 0;

        me.callParent(arguments);
        readOnly = me.readOnly;

        for (; i < len; ++i) {
            if (readOnly) {
                thumbs[i].disable();
            } else {
                thumbs[i].enable();
            }

        }

    },

    beforeDestroy: function() {
        var me     = this,
            thumbs = me.thumbs,
            t      = 0,
            tLen   = thumbs.length,
            thumb;

        if (me.rendered) {
            for (; t < tLen; t++) {
                thumb = thumbs[t];

                Ext.destroy(thumb);
            }
        }

        me.callParent();
    }
});


text:
package com.l1.service.impl;

import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.l1.dao.WarehouseDao;
import com.l1.entity.Warehouse;
import com.l1.service.WarehouseService;

@Service("warehouseService")
public class WarehouseServiceImpl implements WarehouseService {
	@Resource
	private WarehouseDao warehouseDao;

	@Override
	public List<Warehouse> find(Map<String, Object> map) {
		return warehouseDao.find(map);
	}

    @Override
    public List<Map<String,String>> findForCombo(Map<String, Object> map){
        return warehouseDao.findForCombo(map);
    }

    @Override
	public Long getTotal(Map<String, Object> map) {
		return warehouseDao.getTotal(map);
	}

	@Override
	public Integer add(Warehouse Warehouse) {
		return warehouseDao.add(Warehouse);
	}

	@Override
	public Integer update(Warehouse Warehouse) {
		return warehouseDao.update(Warehouse);
	}

	@Override
	public Integer delete(Integer id) {
		return warehouseDao.delete(id);
	}

	@Override
	public Warehouse findById(Integer id) {
		return warehouseDao.findById(id);
	}

}


text:
'use strict'
const fs = require('fs');
const path = require('path');

const xpath = require('xpath');
const dom = require('xmldom').DOMParser;

const string = require('./string.js');

const INCLUDE = '<!-- @@(.+) -->'; // Optionally surround path with quotes too
const SELECTOR = '#';
const encoding = {encoding: 'utf8' };

class SelectorError extends Error {
  constructor(path, fileName, xml) {
    super();

    this.path = path;
    this.fileName = fileName;
    this.xml = xml;

    Error.captureStackTrace(this);
  }
  get name() {
    return 'SelectorError';
  }
  get message() {
    return `No match at ${this.path} in ${this.fileName}.`;
  }
}

// function parseInclude()

/**
 * Reads the input stream as UTF-8 text.
 * @param [ReadableStream] readStream
 * @return [Promise]
 */
function readInput(readStream) {
  return new Promise(function(resolve, reject) {
    let buffer = '';
    readStream.setEncoding('utf-8');
    readStream.resume();
    readStream.on('data', chunk => buffer += chunk);
    readStream.on('end', () => resolve(buffer));
  })
}

// TODO: Get file should cache, in the case of workspaces
const getFileSync = (function(resolvedPath, selector, encoding) {
  // FIXME: This won't work in a watch situation where the process
  // stays running. There's no way to invalidate the cache with updated
  // source files.
  const cache = {};
  return function(resolvedPath, selector, encoding) {
    let cached = cache[`${resolvedPath}`];
    if(cached && !selector) {
      return cached;
    }
    let fileContents = fs.readFileSync(resolvedPath, encoding);
    if(selector) {
      let workspace = cached;
      if(!workspace) {
        // Cache DOM, not just string. This means that you can't include an entire workspace.
        cache[`${resolvedPath}`] = workspace = new dom().parseFromString(fileContents);
      }
      const matcher = `/export/workspace/query[@name = "${selector}"]`;
      const nodes = xpath.select(matcher, workspace);
      if(!nodes.length) {
        throw new SelectorError(matcher, resolvedPath, fileContents);
      }
      return nodes[0].firstChild.data;
    } else {
      cache[resolvedPath] = fileContents;
      return fileContents;
    }
  }
})();

/**
 * Processes the template contents synchronously
 *   1. finds the include directives
 *   2. reads the referenced file into a string
 *   3. replaces the the matched directive in-place
 * (Yes, this would probably be better asynchronous for large files.)
 *
 * @param [string] template The text of the template (not its path)
 * @param [WritableStream] out
 * @param [string] wd The working directory against which to resolve relative paths
 * @return [undefined]
 */
function processOutSync(template, out, wd) {
  out.write(
    template.replace(new RegExp(INCLUDE, 'g'),
      (match, include) => {
        const parts = include.split(SELECTOR);
        const file = parts[0];
        const selector = parts[1]; // undefined if no selector

        // Resolves included paths relative to the template
        const resolvedPath = path.resolve(wd, string.stripLeadingTrailingQuotes(file));
        let fileContents = getFileSync(resolvedPath, selector, encoding);
        return fileContents
           .replace(/\&/g, '&')
           .replace(/</g, '<');
      }
    )
  );
}

module.exports = {
  readInput: readInput,
  processOutSync: processOutSync,
  SelectorError: SelectorError
}


text:
<?php

namespace Mcwork\Entity;

use ContentinumComponents\Storage\AbstractStorageEntity;

/**
 * Provide path to logfiles
 *
 * @author Michael Jochum, michael.jochum@jochum-mediaservices.de
 */
class Usr extends AbstractStorageEntity
{

    const FILES_PATH = 'data/locale/usr';

    /**
     *
     * @see \ContentinumComponents\Storage\AbstractStorageEntity::getCurrentPath()
     */
    public function getCurrentPath()
    {
        return self::FILES_PATH;
    }
}


text:
package xml.entity.serialize.transform;

import static org.junit.Assert.assertThat;
import static xml.entity.immutableelement.ImmutableMatchers.hasAttr;
import static xml.entity.immutableelement.ImmutableMatchers.hasChild;
import static xml.entity.immutableelement.ImmutableMatchers.nameIs;

import org.junit.Before;
import org.junit.Test;

import xml.entity.immutableelement.ImmutableElement;
import xml.entity.immutableelement.ImmutableElementFactory;
import xml.entity.mutableelement.Element;
import xml.entity.mutableelement.ElementFactory;
import xml.entity.serilalize.transform.RemoveNamespacePrefixes;

public class TestRemoveNamespacePrefixes
{
    private final ElementFactory factory = ElementFactory.create();
    private RemoveNamespacePrefixes tranformation;

    @Before
    public void setup()
    {
        tranformation = new RemoveNamespacePrefixes(ImmutableElementFactory.create());
    }

    @Test
    public void removeOnAttribute()
    {
        final Element node = factory.createNode("root");
        final String url = "http://somewhere";
        node.attribute("foo:bar").value(url);
        final ImmutableElement element = node.immutableCopy();

        final ImmutableElement transformed = tranformation.apply(element);

        assertThat(transformed, hasAttr("bar").withValue(url));
    }

    @Test
    public void removeOnElement()
    {
        final Element node = factory.createNode("root");
        node.child("foo:bar");
        final ImmutableElement element = node.immutableCopy();

        final ImmutableElement transformed = tranformation.apply(element);

        assertThat(transformed, hasChild(nameIs("bar")));
    }

    @Test
    public void removeOnRoot()
    {
        final Element node = factory.createNode("foo:root");
        final ImmutableElement element = node.immutableCopy();

        final ImmutableElement transformed = tranformation.apply(element);

        assertThat(transformed, nameIs("root"));
    }
}