|
|
@@ -0,0 +1,3086 @@
|
|
|
+////////////////////////////////////////////////////////////////////////////////
|
|
|
+//
|
|
|
+// DO NOT MODIFY
|
|
|
+//
|
|
|
+// ┻━┻ ︵ヽ(`Д´)ﾉ︵ ┻━┻
|
|
|
+//
|
|
|
+//
|
|
|
+// This source file was automatically generated by bingen.
|
|
|
+//
|
|
|
+////////////////////////////////////////////////////////////////////////////////
|
|
|
+
|
|
|
+package kubemodel
|
|
|
+
|
|
|
+import (
|
|
|
+ "fmt"
|
|
|
+ util "github.com/opencost/opencost/core/pkg/util"
|
|
|
+ "reflect"
|
|
|
+ "strings"
|
|
|
+ "sync"
|
|
|
+ "time"
|
|
|
+)
|
|
|
+
|
|
|
+const (
|
|
|
+ // GeneratorPackageName is the package the generator is targetting
|
|
|
+ GeneratorPackageName string = "kubemodel"
|
|
|
+)
|
|
|
+
|
|
|
+// BinaryTags represent the formatting tag used for specific optimization features
|
|
|
+const (
|
|
|
+ // BinaryTagStringTable is written and/or read prior to the existence of a string
|
|
|
+ // table (where each index is encoded as a string entry in the resource
|
|
|
+ BinaryTagStringTable string = "BGST"
|
|
|
+)
|
|
|
+
|
|
|
+const (
|
|
|
+ // DefaultCodecVersion is used for any resources listed in the Default version set
|
|
|
+ DefaultCodecVersion uint8 = 1
|
|
|
+)
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Type Map
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// Generated type map for resolving interface implementations to
|
|
|
+// to concrete types
|
|
|
+var typeMap map[string]reflect.Type = map[string]reflect.Type{
|
|
|
+ "Cluster": reflect.TypeOf((*Cluster)(nil)).Elem(),
|
|
|
+ "Diagnostic": reflect.TypeOf((*Diagnostic)(nil)).Elem(),
|
|
|
+ "KubeModelSet": reflect.TypeOf((*KubeModelSet)(nil)).Elem(),
|
|
|
+ "Metadata": reflect.TypeOf((*Metadata)(nil)).Elem(),
|
|
|
+ "Namespace": reflect.TypeOf((*Namespace)(nil)).Elem(),
|
|
|
+ "ResourceQuantity": reflect.TypeOf((*ResourceQuantity)(nil)).Elem(),
|
|
|
+ "ResourceQuota": reflect.TypeOf((*ResourceQuota)(nil)).Elem(),
|
|
|
+ "ResourceQuotaSpec": reflect.TypeOf((*ResourceQuotaSpec)(nil)).Elem(),
|
|
|
+ "ResourceQuotaSpecHard": reflect.TypeOf((*ResourceQuotaSpecHard)(nil)).Elem(),
|
|
|
+ "ResourceQuotaStatus": reflect.TypeOf((*ResourceQuotaStatus)(nil)).Elem(),
|
|
|
+ "ResourceQuotaStatusUsed": reflect.TypeOf((*ResourceQuotaStatusUsed)(nil)).Elem(),
|
|
|
+ "Window": reflect.TypeOf((*Window)(nil)).Elem(),
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Type Helpers
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// isBinaryTag returns true when the first bytes in the provided binary matches the tag
|
|
|
+func isBinaryTag(data []byte, tag string) bool {
|
|
|
+ return string(data[:len(tag)]) == tag
|
|
|
+}
|
|
|
+
|
|
|
+// appendBytes combines a and b into a new byte array
|
|
|
+func appendBytes(a []byte, b []byte) []byte {
|
|
|
+ al := len(a)
|
|
|
+ bl := len(b)
|
|
|
+ tl := al + bl
|
|
|
+
|
|
|
+ // allocate a new byte array for the combined
|
|
|
+ // use native copy for speedy byte copying
|
|
|
+ result := make([]byte, tl, tl)
|
|
|
+ copy(result, a)
|
|
|
+ copy(result[al:], b)
|
|
|
+
|
|
|
+ return result
|
|
|
+}
|
|
|
+
|
|
|
+// typeToString determines the basic properties of the type, the qualifier, package path, and
|
|
|
+// type name, and returns the qualified type
|
|
|
+func typeToString(f interface{}) string {
|
|
|
+ qual := ""
|
|
|
+ t := reflect.TypeOf(f)
|
|
|
+ if t.Kind() == reflect.Ptr {
|
|
|
+ t = t.Elem()
|
|
|
+ qual = "*"
|
|
|
+ }
|
|
|
+
|
|
|
+ return fmt.Sprintf("%s%s.%s", qual, t.PkgPath(), t.Name())
|
|
|
+}
|
|
|
+
|
|
|
+// resolveType uses the name of a type and returns the package, base type name, and whether
|
|
|
+// or not it's a pointer.
|
|
|
+func resolveType(t string) (pkg string, name string, isPtr bool) {
|
|
|
+ isPtr = t[:1] == "*"
|
|
|
+ if isPtr {
|
|
|
+ t = t[1:]
|
|
|
+ }
|
|
|
+
|
|
|
+ slashIndex := strings.LastIndex(t, "/")
|
|
|
+ if slashIndex >= 0 {
|
|
|
+ t = t[slashIndex+1:]
|
|
|
+ }
|
|
|
+ parts := strings.Split(t, ".")
|
|
|
+ if parts[0] == GeneratorPackageName {
|
|
|
+ parts[0] = ""
|
|
|
+ }
|
|
|
+
|
|
|
+ pkg = parts[0]
|
|
|
+ name = parts[1]
|
|
|
+ return
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// StringTable
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// StringTable maps strings to specific indices for encoding
|
|
|
+type StringTable struct {
|
|
|
+ l *sync.Mutex
|
|
|
+ indices map[string]int
|
|
|
+ next int
|
|
|
+}
|
|
|
+
|
|
|
+// NewStringTable Creates a new StringTable instance with provided contents
|
|
|
+func NewStringTable(contents ...string) *StringTable {
|
|
|
+ st := &StringTable{
|
|
|
+ l: new(sync.Mutex),
|
|
|
+ indices: make(map[string]int),
|
|
|
+ next: len(contents),
|
|
|
+ }
|
|
|
+
|
|
|
+ for i, entry := range contents {
|
|
|
+ st.indices[entry] = i
|
|
|
+ }
|
|
|
+
|
|
|
+ return st
|
|
|
+}
|
|
|
+
|
|
|
+// AddOrGet atomically retrieves a string entry's index if it exist. Otherwise, it will
|
|
|
+// add the entry and return the index.
|
|
|
+func (st *StringTable) AddOrGet(s string) int {
|
|
|
+ st.l.Lock()
|
|
|
+ defer st.l.Unlock()
|
|
|
+
|
|
|
+ if ind, ok := st.indices[s]; ok {
|
|
|
+ return ind
|
|
|
+ }
|
|
|
+
|
|
|
+ current := st.next
|
|
|
+ st.next++
|
|
|
+
|
|
|
+ st.indices[s] = current
|
|
|
+ return current
|
|
|
+}
|
|
|
+
|
|
|
+// ToSlice Converts the contents to a string array for encoding.
|
|
|
+func (st *StringTable) ToSlice() []string {
|
|
|
+ st.l.Lock()
|
|
|
+ defer st.l.Unlock()
|
|
|
+
|
|
|
+ if st.next == 0 {
|
|
|
+ return []string{}
|
|
|
+ }
|
|
|
+
|
|
|
+ sl := make([]string, st.next, st.next)
|
|
|
+ for s, i := range st.indices {
|
|
|
+ sl[i] = s
|
|
|
+ }
|
|
|
+ return sl
|
|
|
+}
|
|
|
+
|
|
|
+// ToBytes Converts the contents to a binary encoded representation
|
|
|
+func (st *StringTable) ToBytes() []byte {
|
|
|
+ buff := util.NewBuffer()
|
|
|
+ buff.WriteBytes([]byte(BinaryTagStringTable)) // bingen table header
|
|
|
+
|
|
|
+ strs := st.ToSlice()
|
|
|
+
|
|
|
+ buff.WriteInt(len(strs)) // table length
|
|
|
+ for _, s := range strs {
|
|
|
+ buff.WriteString(s)
|
|
|
+ }
|
|
|
+
|
|
|
+ return buff.Bytes()
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Codec Context
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// EncodingContext is a context object passed to the encoders to ensure reuse of buffer
|
|
|
+// and table data
|
|
|
+type EncodingContext struct {
|
|
|
+ Buffer *util.Buffer
|
|
|
+ Table *StringTable
|
|
|
+}
|
|
|
+
|
|
|
+// IsStringTable returns true if the table is available
|
|
|
+func (ec *EncodingContext) IsStringTable() bool {
|
|
|
+ return ec.Table != nil
|
|
|
+}
|
|
|
+
|
|
|
+// DecodingContext is a context object passed to the decoders to ensure parent objects
|
|
|
+// reuse as much data as possible
|
|
|
+type DecodingContext struct {
|
|
|
+ Buffer *util.Buffer
|
|
|
+ Table []string
|
|
|
+}
|
|
|
+
|
|
|
+// IsStringTable returns true if the table is available
|
|
|
+func (dc *DecodingContext) IsStringTable() bool {
|
|
|
+ return len(dc.Table) > 0
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Binary Codec
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// BinEncoder is an encoding interface which defines a context based marshal contract.
|
|
|
+type BinEncoder interface {
|
|
|
+ MarshalBinaryWithContext(*EncodingContext) error
|
|
|
+}
|
|
|
+
|
|
|
+// BinDecoder is a decoding interface which defines a context based unmarshal contract.
|
|
|
+type BinDecoder interface {
|
|
|
+ UnmarshalBinaryWithContext(*DecodingContext) error
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Cluster
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this Cluster instance
|
|
|
+// into a byte array
|
|
|
+func (target *Cluster) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this Cluster instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *Cluster) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ a := ctx.Table.AddOrGet(target.UID)
|
|
|
+ buff.WriteInt(a) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.UID) // write string
|
|
|
+ }
|
|
|
+ // --- [begin][write][alias](Provider) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(string(target.Provider))
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(target.Provider)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Provider) ---
|
|
|
+
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := ctx.Table.AddOrGet(target.Account)
|
|
|
+ buff.WriteInt(c) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.Account) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ d := ctx.Table.AddOrGet(target.Name)
|
|
|
+ buff.WriteInt(d) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.Name) // write string
|
|
|
+ }
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ e, errA := target.Start.MarshalBinary()
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(e))
|
|
|
+ buff.WriteBytes(e)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ f, errB := target.End.MarshalBinary()
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(f))
|
|
|
+ buff.WriteBytes(f)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the Cluster type
|
|
|
+func (target *Cluster) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the Cluster type
|
|
|
+func (target *Cluster) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling Cluster. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var b string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := buff.ReadInt() // read string index
|
|
|
+ b = ctx.Table[c]
|
|
|
+ } else {
|
|
|
+ b = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ a := b
|
|
|
+ target.UID = a
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.UID = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](Provider) ---
|
|
|
+ var d string
|
|
|
+ var f string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ g := buff.ReadInt() // read string index
|
|
|
+ f = ctx.Table[g]
|
|
|
+ } else {
|
|
|
+ f = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ e := f
|
|
|
+ d = e
|
|
|
+
|
|
|
+ target.Provider = Provider(d)
|
|
|
+ // --- [end][read][alias](Provider) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var k string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ l := buff.ReadInt() // read string index
|
|
|
+ k = ctx.Table[l]
|
|
|
+ } else {
|
|
|
+ k = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ h := k
|
|
|
+ target.Account = h
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.Account = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var n string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ o := buff.ReadInt() // read string index
|
|
|
+ n = ctx.Table[o]
|
|
|
+ } else {
|
|
|
+ n = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ m := n
|
|
|
+ target.Name = m
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.Name = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ p := &time.Time{}
|
|
|
+ q := buff.ReadInt() // byte array length
|
|
|
+ r := buff.ReadBytes(q) // byte array
|
|
|
+ errA := p.UnmarshalBinary(r)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Start = *p
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ s := &time.Time{}
|
|
|
+ t := buff.ReadInt() // byte array length
|
|
|
+ u := buff.ReadBytes(t) // byte array
|
|
|
+ errB := s.UnmarshalBinary(u)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ target.End = *s
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Diagnostic
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this Diagnostic instance
|
|
|
+// into a byte array
|
|
|
+func (target *Diagnostic) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this Diagnostic instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *Diagnostic) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ a, errA := target.Timestamp.MarshalBinary()
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(a))
|
|
|
+ buff.WriteBytes(a)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ // --- [begin][write][alias](DiagnosticLevel) ---
|
|
|
+ buff.WriteInt(int(target.Level)) // write int
|
|
|
+ // --- [end][write][alias](DiagnosticLevel) ---
|
|
|
+
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(target.Message)
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.Message) // write string
|
|
|
+ }
|
|
|
+ if target.Details == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[string]string) ---
|
|
|
+ buff.WriteInt(len(target.Details)) // map length
|
|
|
+ for v, z := range target.Details {
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := ctx.Table.AddOrGet(v)
|
|
|
+ buff.WriteInt(c) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(v) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ d := ctx.Table.AddOrGet(z)
|
|
|
+ buff.WriteInt(d) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(z) // write string
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[string]string) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the Diagnostic type
|
|
|
+func (target *Diagnostic) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the Diagnostic type
|
|
|
+func (target *Diagnostic) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling Diagnostic. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ a := &time.Time{}
|
|
|
+ b := buff.ReadInt() // byte array length
|
|
|
+ c := buff.ReadBytes(b) // byte array
|
|
|
+ errA := a.UnmarshalBinary(c)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Timestamp = *a
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](DiagnosticLevel) ---
|
|
|
+ var d int
|
|
|
+ e := buff.ReadInt() // read int
|
|
|
+ d = e
|
|
|
+
|
|
|
+ target.Level = DiagnosticLevel(d)
|
|
|
+ // --- [end][read][alias](DiagnosticLevel) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var g string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ h := buff.ReadInt() // read string index
|
|
|
+ g = ctx.Table[h]
|
|
|
+ } else {
|
|
|
+ g = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ f := g
|
|
|
+ target.Message = f
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.Message = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Details = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[string]string) ---
|
|
|
+ l := buff.ReadInt() // map len
|
|
|
+ k := make(map[string]string, l)
|
|
|
+ for i := 0; i < l; i++ {
|
|
|
+ var v string
|
|
|
+ var n string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ o := buff.ReadInt() // read string index
|
|
|
+ n = ctx.Table[o]
|
|
|
+ } else {
|
|
|
+ n = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ m := n
|
|
|
+ v = m
|
|
|
+
|
|
|
+ var z string
|
|
|
+ var q string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ r := buff.ReadInt() // read string index
|
|
|
+ q = ctx.Table[r]
|
|
|
+ } else {
|
|
|
+ q = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ p := q
|
|
|
+ z = p
|
|
|
+
|
|
|
+ k[v] = z
|
|
|
+ }
|
|
|
+ target.Details = k
|
|
|
+ // --- [end][read][map](map[string]string) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Details = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// KubeModelSet
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this KubeModelSet instance
|
|
|
+// into a byte array
|
|
|
+func (target *KubeModelSet) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: NewStringTable(),
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ sTableBytes := ctx.Table.ToBytes()
|
|
|
+ merged := appendBytes(sTableBytes, encBytes)
|
|
|
+ return merged, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this KubeModelSet instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *KubeModelSet) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ if target.Metadata == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](Metadata) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errA := target.Metadata.MarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](Metadata) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [begin][write][struct](Window) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errB := target.Window.MarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](Window) ---
|
|
|
+
|
|
|
+ if target.Cluster == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](Cluster) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errC := target.Cluster.MarshalBinaryWithContext(ctx)
|
|
|
+ if errC != nil {
|
|
|
+ return errC
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](Cluster) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ if target.Namespaces == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[string]*Namespace) ---
|
|
|
+ buff.WriteInt(len(target.Namespaces)) // map length
|
|
|
+ for v, z := range target.Namespaces {
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ a := ctx.Table.AddOrGet(v)
|
|
|
+ buff.WriteInt(a) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(v) // write string
|
|
|
+ }
|
|
|
+ if z == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](Namespace) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errD := z.MarshalBinaryWithContext(ctx)
|
|
|
+ if errD != nil {
|
|
|
+ return errD
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](Namespace) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[string]*Namespace) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ if target.ResourceQuotas == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[string]*ResourceQuota) ---
|
|
|
+ buff.WriteInt(len(target.ResourceQuotas)) // map length
|
|
|
+ for vv, zz := range target.ResourceQuotas {
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(vv)
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(vv) // write string
|
|
|
+ }
|
|
|
+ if zz == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuota) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errE := zz.MarshalBinaryWithContext(ctx)
|
|
|
+ if errE != nil {
|
|
|
+ return errE
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuota) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[string]*ResourceQuota) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the KubeModelSet type
|
|
|
+func (target *KubeModelSet) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the KubeModelSet type
|
|
|
+func (target *KubeModelSet) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling KubeModelSet. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Metadata = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](Metadata) ---
|
|
|
+ a := &Metadata{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errA := a.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Metadata = a
|
|
|
+ // --- [end][read][struct](Metadata) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Metadata = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][struct](Window) ---
|
|
|
+ b := &Window{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errB := b.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ target.Window = *b
|
|
|
+ // --- [end][read][struct](Window) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Cluster = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](Cluster) ---
|
|
|
+ c := &Cluster{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errC := c.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errC != nil {
|
|
|
+ return errC
|
|
|
+ }
|
|
|
+ target.Cluster = c
|
|
|
+ // --- [end][read][struct](Cluster) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Cluster = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Namespaces = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[string]*Namespace) ---
|
|
|
+ e := buff.ReadInt() // map len
|
|
|
+ d := make(map[string]*Namespace, e)
|
|
|
+ for i := 0; i < e; i++ {
|
|
|
+ var v string
|
|
|
+ var g string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ h := buff.ReadInt() // read string index
|
|
|
+ g = ctx.Table[h]
|
|
|
+ } else {
|
|
|
+ g = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ f := g
|
|
|
+ v = f
|
|
|
+
|
|
|
+ var z *Namespace
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ z = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](Namespace) ---
|
|
|
+ k := &Namespace{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errD := k.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errD != nil {
|
|
|
+ return errD
|
|
|
+ }
|
|
|
+ z = k
|
|
|
+ // --- [end][read][struct](Namespace) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ d[v] = z
|
|
|
+ }
|
|
|
+ target.Namespaces = d
|
|
|
+ // --- [end][read][map](map[string]*Namespace) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Namespaces = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.ResourceQuotas = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[string]*ResourceQuota) ---
|
|
|
+ m := buff.ReadInt() // map len
|
|
|
+ l := make(map[string]*ResourceQuota, m)
|
|
|
+ for j := 0; j < m; j++ {
|
|
|
+ var vv string
|
|
|
+ var o string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ p := buff.ReadInt() // read string index
|
|
|
+ o = ctx.Table[p]
|
|
|
+ } else {
|
|
|
+ o = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ n := o
|
|
|
+ vv = n
|
|
|
+
|
|
|
+ var zz *ResourceQuota
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ zz = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](ResourceQuota) ---
|
|
|
+ q := &ResourceQuota{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errE := q.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errE != nil {
|
|
|
+ return errE
|
|
|
+ }
|
|
|
+ zz = q
|
|
|
+ // --- [end][read][struct](ResourceQuota) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ l[vv] = zz
|
|
|
+ }
|
|
|
+ target.ResourceQuotas = l
|
|
|
+ // --- [end][read][map](map[string]*ResourceQuota) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.ResourceQuotas = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Metadata
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this Metadata instance
|
|
|
+// into a byte array
|
|
|
+func (target *Metadata) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this Metadata instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *Metadata) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ a, errA := target.CreatedAt.MarshalBinary()
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(a))
|
|
|
+ buff.WriteBytes(a)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ b, errB := target.CompletedAt.MarshalBinary()
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(b))
|
|
|
+ buff.WriteBytes(b)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ buff.WriteInt(target.ObjectCount) // write int
|
|
|
+ if target.Diagnostics == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][slice]([]Diagnostic) ---
|
|
|
+ buff.WriteInt(len(target.Diagnostics)) // array length
|
|
|
+ for i := 0; i < len(target.Diagnostics); i++ {
|
|
|
+ // --- [begin][write][struct](Diagnostic) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errC := target.Diagnostics[i].MarshalBinaryWithContext(ctx)
|
|
|
+ if errC != nil {
|
|
|
+ return errC
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](Diagnostic) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][slice]([]Diagnostic) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [begin][write][alias](DiagnosticLevel) ---
|
|
|
+ buff.WriteInt(int(target.DiagnosticLevel)) // write int
|
|
|
+ // --- [end][write][alias](DiagnosticLevel) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the Metadata type
|
|
|
+func (target *Metadata) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the Metadata type
|
|
|
+func (target *Metadata) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling Metadata. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ a := &time.Time{}
|
|
|
+ b := buff.ReadInt() // byte array length
|
|
|
+ c := buff.ReadBytes(b) // byte array
|
|
|
+ errA := a.UnmarshalBinary(c)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.CreatedAt = *a
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ d := &time.Time{}
|
|
|
+ e := buff.ReadInt() // byte array length
|
|
|
+ f := buff.ReadBytes(e) // byte array
|
|
|
+ errB := d.UnmarshalBinary(f)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ target.CompletedAt = *d
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ g := buff.ReadInt() // read int
|
|
|
+ target.ObjectCount = g
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.ObjectCount = int(0) // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Diagnostics = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][slice]([]Diagnostic) ---
|
|
|
+ k := buff.ReadInt() // array len
|
|
|
+ h := make([]Diagnostic, k)
|
|
|
+ for i := 0; i < k; i++ {
|
|
|
+ // --- [begin][read][struct](Diagnostic) ---
|
|
|
+ m := &Diagnostic{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errC := m.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errC != nil {
|
|
|
+ return errC
|
|
|
+ }
|
|
|
+ l := *m
|
|
|
+ // --- [end][read][struct](Diagnostic) ---
|
|
|
+
|
|
|
+ h[i] = l
|
|
|
+ }
|
|
|
+ target.Diagnostics = h
|
|
|
+ // --- [end][read][slice]([]Diagnostic) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Diagnostics = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](DiagnosticLevel) ---
|
|
|
+ var n int
|
|
|
+ o := buff.ReadInt() // read int
|
|
|
+ n = o
|
|
|
+
|
|
|
+ target.DiagnosticLevel = DiagnosticLevel(n)
|
|
|
+ // --- [end][read][alias](DiagnosticLevel) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Namespace
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this Namespace instance
|
|
|
+// into a byte array
|
|
|
+func (target *Namespace) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this Namespace instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *Namespace) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ a := ctx.Table.AddOrGet(target.UID)
|
|
|
+ buff.WriteInt(a) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.UID) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(target.ClusterUID)
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.ClusterUID) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := ctx.Table.AddOrGet(target.Name)
|
|
|
+ buff.WriteInt(c) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.Name) // write string
|
|
|
+ }
|
|
|
+ if target.Labels == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[string]string) ---
|
|
|
+ buff.WriteInt(len(target.Labels)) // map length
|
|
|
+ for v, z := range target.Labels {
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ d := ctx.Table.AddOrGet(v)
|
|
|
+ buff.WriteInt(d) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(v) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ e := ctx.Table.AddOrGet(z)
|
|
|
+ buff.WriteInt(e) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(z) // write string
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[string]string) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ if target.Annotations == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[string]string) ---
|
|
|
+ buff.WriteInt(len(target.Annotations)) // map length
|
|
|
+ for vv, zz := range target.Annotations {
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ f := ctx.Table.AddOrGet(vv)
|
|
|
+ buff.WriteInt(f) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(vv) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ g := ctx.Table.AddOrGet(zz)
|
|
|
+ buff.WriteInt(g) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(zz) // write string
|
|
|
+ }
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[string]string) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ h, errA := target.Start.MarshalBinary()
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(h))
|
|
|
+ buff.WriteBytes(h)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ k, errB := target.End.MarshalBinary()
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(k))
|
|
|
+ buff.WriteBytes(k)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the Namespace type
|
|
|
+func (target *Namespace) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the Namespace type
|
|
|
+func (target *Namespace) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling Namespace. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var b string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := buff.ReadInt() // read string index
|
|
|
+ b = ctx.Table[c]
|
|
|
+ } else {
|
|
|
+ b = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ a := b
|
|
|
+ target.UID = a
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.UID = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var e string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ f := buff.ReadInt() // read string index
|
|
|
+ e = ctx.Table[f]
|
|
|
+ } else {
|
|
|
+ e = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ d := e
|
|
|
+ target.ClusterUID = d
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.ClusterUID = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var h string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ k := buff.ReadInt() // read string index
|
|
|
+ h = ctx.Table[k]
|
|
|
+ } else {
|
|
|
+ h = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ g := h
|
|
|
+ target.Name = g
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.Name = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Labels = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[string]string) ---
|
|
|
+ m := buff.ReadInt() // map len
|
|
|
+ l := make(map[string]string, m)
|
|
|
+ for i := 0; i < m; i++ {
|
|
|
+ var v string
|
|
|
+ var o string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ p := buff.ReadInt() // read string index
|
|
|
+ o = ctx.Table[p]
|
|
|
+ } else {
|
|
|
+ o = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ n := o
|
|
|
+ v = n
|
|
|
+
|
|
|
+ var z string
|
|
|
+ var r string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ s := buff.ReadInt() // read string index
|
|
|
+ r = ctx.Table[s]
|
|
|
+ } else {
|
|
|
+ r = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ q := r
|
|
|
+ z = q
|
|
|
+
|
|
|
+ l[v] = z
|
|
|
+ }
|
|
|
+ target.Labels = l
|
|
|
+ // --- [end][read][map](map[string]string) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Labels = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Annotations = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[string]string) ---
|
|
|
+ u := buff.ReadInt() // map len
|
|
|
+ t := make(map[string]string, u)
|
|
|
+ for j := 0; j < u; j++ {
|
|
|
+ var vv string
|
|
|
+ var x string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ y := buff.ReadInt() // read string index
|
|
|
+ x = ctx.Table[y]
|
|
|
+ } else {
|
|
|
+ x = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ w := x
|
|
|
+ vv = w
|
|
|
+
|
|
|
+ var zz string
|
|
|
+ var bb string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ cc := buff.ReadInt() // read string index
|
|
|
+ bb = ctx.Table[cc]
|
|
|
+ } else {
|
|
|
+ bb = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ aa := bb
|
|
|
+ zz = aa
|
|
|
+
|
|
|
+ t[vv] = zz
|
|
|
+ }
|
|
|
+ target.Annotations = t
|
|
|
+ // --- [end][read][map](map[string]string) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Annotations = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ dd := &time.Time{}
|
|
|
+ ee := buff.ReadInt() // byte array length
|
|
|
+ ff := buff.ReadBytes(ee) // byte array
|
|
|
+ errA := dd.UnmarshalBinary(ff)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Start = *dd
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ gg := &time.Time{}
|
|
|
+ hh := buff.ReadInt() // byte array length
|
|
|
+ kk := buff.ReadBytes(hh) // byte array
|
|
|
+ errB := gg.UnmarshalBinary(kk)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ target.End = *gg
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// ResourceQuantity
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this ResourceQuantity instance
|
|
|
+// into a byte array
|
|
|
+func (target *ResourceQuantity) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this ResourceQuantity instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *ResourceQuantity) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ // --- [begin][write][alias](Resource) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ a := ctx.Table.AddOrGet(string(target.Resource))
|
|
|
+ buff.WriteInt(a) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(target.Resource)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][write][alias](Unit) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(string(target.Unit))
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(target.Unit)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Unit) ---
|
|
|
+
|
|
|
+ // --- [begin][write][alias](Stats) ---
|
|
|
+ if map[StatType]float64(target.Values) == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[StatType]float64) ---
|
|
|
+ buff.WriteInt(len(map[StatType]float64(target.Values))) // map length
|
|
|
+ for v, z := range map[StatType]float64(target.Values) {
|
|
|
+ // --- [begin][write][alias](StatType) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := ctx.Table.AddOrGet(string(v))
|
|
|
+ buff.WriteInt(c) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(v)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](StatType) ---
|
|
|
+
|
|
|
+ buff.WriteFloat64(z) // write float64
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[StatType]float64) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Stats) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the ResourceQuantity type
|
|
|
+func (target *ResourceQuantity) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the ResourceQuantity type
|
|
|
+func (target *ResourceQuantity) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling ResourceQuantity. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](Resource) ---
|
|
|
+ var a string
|
|
|
+ var c string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ d := buff.ReadInt() // read string index
|
|
|
+ c = ctx.Table[d]
|
|
|
+ } else {
|
|
|
+ c = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ b := c
|
|
|
+ a = b
|
|
|
+
|
|
|
+ target.Resource = Resource(a)
|
|
|
+ // --- [end][read][alias](Resource) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](Unit) ---
|
|
|
+ var e string
|
|
|
+ var g string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ h := buff.ReadInt() // read string index
|
|
|
+ g = ctx.Table[h]
|
|
|
+ } else {
|
|
|
+ g = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ f := g
|
|
|
+ e = f
|
|
|
+
|
|
|
+ target.Unit = Unit(e)
|
|
|
+ // --- [end][read][alias](Unit) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](Stats) ---
|
|
|
+ var k map[StatType]float64
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ k = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[StatType]float64) ---
|
|
|
+ m := buff.ReadInt() // map len
|
|
|
+ l := make(map[StatType]float64, m)
|
|
|
+ for i := 0; i < m; i++ {
|
|
|
+ // --- [begin][read][alias](StatType) ---
|
|
|
+ var n string
|
|
|
+ var p string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ q := buff.ReadInt() // read string index
|
|
|
+ p = ctx.Table[q]
|
|
|
+ } else {
|
|
|
+ p = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ o := p
|
|
|
+ n = o
|
|
|
+
|
|
|
+ v := StatType(n)
|
|
|
+ // --- [end][read][alias](StatType) ---
|
|
|
+
|
|
|
+ var z float64
|
|
|
+ r := buff.ReadFloat64() // read float64
|
|
|
+ z = r
|
|
|
+
|
|
|
+ l[v] = z
|
|
|
+ }
|
|
|
+ k = l
|
|
|
+ // --- [end][read][map](map[StatType]float64) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ target.Values = Stats(k)
|
|
|
+ // --- [end][read][alias](Stats) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// ResourceQuota
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this ResourceQuota instance
|
|
|
+// into a byte array
|
|
|
+func (target *ResourceQuota) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this ResourceQuota instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *ResourceQuota) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ a := ctx.Table.AddOrGet(target.UID)
|
|
|
+ buff.WriteInt(a) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.UID) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(target.NamespaceUID)
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.NamespaceUID) // write string
|
|
|
+ }
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := ctx.Table.AddOrGet(target.Name)
|
|
|
+ buff.WriteInt(c) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(target.Name) // write string
|
|
|
+ }
|
|
|
+ if target.Spec == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuotaSpec) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errA := target.Spec.MarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuotaSpec) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ if target.Status == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuotaStatus) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errB := target.Status.MarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuotaStatus) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ d, errC := target.Start.MarshalBinary()
|
|
|
+ if errC != nil {
|
|
|
+ return errC
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(d))
|
|
|
+ buff.WriteBytes(d)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ e, errD := target.End.MarshalBinary()
|
|
|
+ if errD != nil {
|
|
|
+ return errD
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(e))
|
|
|
+ buff.WriteBytes(e)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the ResourceQuota type
|
|
|
+func (target *ResourceQuota) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the ResourceQuota type
|
|
|
+func (target *ResourceQuota) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling ResourceQuota. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var b string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ c := buff.ReadInt() // read string index
|
|
|
+ b = ctx.Table[c]
|
|
|
+ } else {
|
|
|
+ b = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ a := b
|
|
|
+ target.UID = a
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.UID = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var e string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ f := buff.ReadInt() // read string index
|
|
|
+ e = ctx.Table[f]
|
|
|
+ } else {
|
|
|
+ e = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ d := e
|
|
|
+ target.NamespaceUID = d
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.NamespaceUID = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ var h string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ k := buff.ReadInt() // read string index
|
|
|
+ h = ctx.Table[k]
|
|
|
+ } else {
|
|
|
+ h = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ g := h
|
|
|
+ target.Name = g
|
|
|
+
|
|
|
+ } else {
|
|
|
+ target.Name = "" // default
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Spec = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](ResourceQuotaSpec) ---
|
|
|
+ l := &ResourceQuotaSpec{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errA := l.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Spec = l
|
|
|
+ // --- [end][read][struct](ResourceQuotaSpec) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Spec = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Status = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](ResourceQuotaStatus) ---
|
|
|
+ m := &ResourceQuotaStatus{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errB := m.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ target.Status = m
|
|
|
+ // --- [end][read][struct](ResourceQuotaStatus) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Status = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ n := &time.Time{}
|
|
|
+ o := buff.ReadInt() // byte array length
|
|
|
+ p := buff.ReadBytes(o) // byte array
|
|
|
+ errC := n.UnmarshalBinary(p)
|
|
|
+ if errC != nil {
|
|
|
+ return errC
|
|
|
+ }
|
|
|
+ target.Start = *n
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ q := &time.Time{}
|
|
|
+ r := buff.ReadInt() // byte array length
|
|
|
+ s := buff.ReadBytes(r) // byte array
|
|
|
+ errD := q.UnmarshalBinary(s)
|
|
|
+ if errD != nil {
|
|
|
+ return errD
|
|
|
+ }
|
|
|
+ target.End = *q
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// ResourceQuotaSpec
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this ResourceQuotaSpec instance
|
|
|
+// into a byte array
|
|
|
+func (target *ResourceQuotaSpec) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaSpec instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *ResourceQuotaSpec) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ if target.Hard == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuotaSpecHard) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errA := target.Hard.MarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuotaSpecHard) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the ResourceQuotaSpec type
|
|
|
+func (target *ResourceQuotaSpec) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the ResourceQuotaSpec type
|
|
|
+func (target *ResourceQuotaSpec) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling ResourceQuotaSpec. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Hard = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](ResourceQuotaSpecHard) ---
|
|
|
+ a := &ResourceQuotaSpecHard{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errA := a.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Hard = a
|
|
|
+ // --- [end][read][struct](ResourceQuotaSpecHard) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Hard = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// ResourceQuotaSpecHard
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this ResourceQuotaSpecHard instance
|
|
|
+// into a byte array
|
|
|
+func (target *ResourceQuotaSpecHard) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaSpecHard instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *ResourceQuotaSpecHard) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ // --- [begin][write][alias](ResourceQuantities) ---
|
|
|
+ if map[Resource]ResourceQuantity(target.Requests) == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+ buff.WriteInt(len(map[Resource]ResourceQuantity(target.Requests))) // map length
|
|
|
+ for v, z := range map[Resource]ResourceQuantity(target.Requests) {
|
|
|
+ // --- [begin][write][alias](Resource) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ a := ctx.Table.AddOrGet(string(v))
|
|
|
+ buff.WriteInt(a) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(v)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuantity) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errA := z.MarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ // --- [begin][write][alias](ResourceQuantities) ---
|
|
|
+ if map[Resource]ResourceQuantity(target.Limits) == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+ buff.WriteInt(len(map[Resource]ResourceQuantity(target.Limits))) // map length
|
|
|
+ for vv, zz := range map[Resource]ResourceQuantity(target.Limits) {
|
|
|
+ // --- [begin][write][alias](Resource) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(string(vv))
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(vv)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuantity) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errB := zz.MarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the ResourceQuotaSpecHard type
|
|
|
+func (target *ResourceQuotaSpecHard) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the ResourceQuotaSpecHard type
|
|
|
+func (target *ResourceQuotaSpecHard) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling ResourceQuotaSpecHard. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](ResourceQuantities) ---
|
|
|
+ var a map[Resource]ResourceQuantity
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ a = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+ c := buff.ReadInt() // map len
|
|
|
+ b := make(map[Resource]ResourceQuantity, c)
|
|
|
+ for i := 0; i < c; i++ {
|
|
|
+ // --- [begin][read][alias](Resource) ---
|
|
|
+ var d string
|
|
|
+ var f string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ g := buff.ReadInt() // read string index
|
|
|
+ f = ctx.Table[g]
|
|
|
+ } else {
|
|
|
+ f = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ e := f
|
|
|
+ d = e
|
|
|
+
|
|
|
+ v := Resource(d)
|
|
|
+ // --- [end][read][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][read][struct](ResourceQuantity) ---
|
|
|
+ h := &ResourceQuantity{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errA := h.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ z := *h
|
|
|
+ // --- [end][read][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ b[v] = z
|
|
|
+ }
|
|
|
+ a = b
|
|
|
+ // --- [end][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ target.Requests = ResourceQuantities(a)
|
|
|
+ // --- [end][read][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](ResourceQuantities) ---
|
|
|
+ var k map[Resource]ResourceQuantity
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ k = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+ m := buff.ReadInt() // map len
|
|
|
+ l := make(map[Resource]ResourceQuantity, m)
|
|
|
+ for j := 0; j < m; j++ {
|
|
|
+ // --- [begin][read][alias](Resource) ---
|
|
|
+ var n string
|
|
|
+ var p string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ q := buff.ReadInt() // read string index
|
|
|
+ p = ctx.Table[q]
|
|
|
+ } else {
|
|
|
+ p = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ o := p
|
|
|
+ n = o
|
|
|
+
|
|
|
+ vv := Resource(n)
|
|
|
+ // --- [end][read][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][read][struct](ResourceQuantity) ---
|
|
|
+ r := &ResourceQuantity{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errB := r.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ zz := *r
|
|
|
+ // --- [end][read][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ l[vv] = zz
|
|
|
+ }
|
|
|
+ k = l
|
|
|
+ // --- [end][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ target.Limits = ResourceQuantities(k)
|
|
|
+ // --- [end][read][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// ResourceQuotaStatus
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this ResourceQuotaStatus instance
|
|
|
+// into a byte array
|
|
|
+func (target *ResourceQuotaStatus) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaStatus instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *ResourceQuotaStatus) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ if target.Used == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuotaStatusUsed) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errA := target.Used.MarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuotaStatusUsed) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the ResourceQuotaStatus type
|
|
|
+func (target *ResourceQuotaStatus) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the ResourceQuotaStatus type
|
|
|
+func (target *ResourceQuotaStatus) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling ResourceQuotaStatus. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ target.Used = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][struct](ResourceQuotaStatusUsed) ---
|
|
|
+ a := &ResourceQuotaStatusUsed{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errA := a.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Used = a
|
|
|
+ // --- [end][read][struct](ResourceQuotaStatusUsed) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ target.Used = nil
|
|
|
+
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// ResourceQuotaStatusUsed
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this ResourceQuotaStatusUsed instance
|
|
|
+// into a byte array
|
|
|
+func (target *ResourceQuotaStatusUsed) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this ResourceQuotaStatusUsed instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *ResourceQuotaStatusUsed) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ // --- [begin][write][alias](ResourceQuantities) ---
|
|
|
+ if map[Resource]ResourceQuantity(target.Requests) == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+ buff.WriteInt(len(map[Resource]ResourceQuantity(target.Requests))) // map length
|
|
|
+ for v, z := range map[Resource]ResourceQuantity(target.Requests) {
|
|
|
+ // --- [begin][write][alias](Resource) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ a := ctx.Table.AddOrGet(string(v))
|
|
|
+ buff.WriteInt(a) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(v)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuantity) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errA := z.MarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ // --- [begin][write][alias](ResourceQuantities) ---
|
|
|
+ if map[Resource]ResourceQuantity(target.Limits) == nil {
|
|
|
+ buff.WriteUInt8(uint8(0)) // write nil byte
|
|
|
+ } else {
|
|
|
+ buff.WriteUInt8(uint8(1)) // write non-nil byte
|
|
|
+
|
|
|
+ // --- [begin][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+ buff.WriteInt(len(map[Resource]ResourceQuantity(target.Limits))) // map length
|
|
|
+ for vv, zz := range map[Resource]ResourceQuantity(target.Limits) {
|
|
|
+ // --- [begin][write][alias](Resource) ---
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ b := ctx.Table.AddOrGet(string(vv))
|
|
|
+ buff.WriteInt(b) // write table index
|
|
|
+ } else {
|
|
|
+ buff.WriteString(string(vv)) // write string
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][write][struct](ResourceQuantity) ---
|
|
|
+ buff.WriteInt(0) // [compatibility, unused]
|
|
|
+ errB := zz.MarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ // --- [end][write][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ // --- [end][write][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the ResourceQuotaStatusUsed type
|
|
|
+func (target *ResourceQuotaStatusUsed) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the ResourceQuotaStatusUsed type
|
|
|
+func (target *ResourceQuotaStatusUsed) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling ResourceQuotaStatusUsed. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](ResourceQuantities) ---
|
|
|
+ var a map[Resource]ResourceQuantity
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ a = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+ c := buff.ReadInt() // map len
|
|
|
+ b := make(map[Resource]ResourceQuantity, c)
|
|
|
+ for i := 0; i < c; i++ {
|
|
|
+ // --- [begin][read][alias](Resource) ---
|
|
|
+ var d string
|
|
|
+ var f string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ g := buff.ReadInt() // read string index
|
|
|
+ f = ctx.Table[g]
|
|
|
+ } else {
|
|
|
+ f = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ e := f
|
|
|
+ d = e
|
|
|
+
|
|
|
+ v := Resource(d)
|
|
|
+ // --- [end][read][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][read][struct](ResourceQuantity) ---
|
|
|
+ h := &ResourceQuantity{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errA := h.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ z := *h
|
|
|
+ // --- [end][read][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ b[v] = z
|
|
|
+ }
|
|
|
+ a = b
|
|
|
+ // --- [end][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ target.Requests = ResourceQuantities(a)
|
|
|
+ // --- [end][read][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][alias](ResourceQuantities) ---
|
|
|
+ var k map[Resource]ResourceQuantity
|
|
|
+ if buff.ReadUInt8() == uint8(0) {
|
|
|
+ k = nil
|
|
|
+ } else {
|
|
|
+ // --- [begin][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+ m := buff.ReadInt() // map len
|
|
|
+ l := make(map[Resource]ResourceQuantity, m)
|
|
|
+ for j := 0; j < m; j++ {
|
|
|
+ // --- [begin][read][alias](Resource) ---
|
|
|
+ var n string
|
|
|
+ var p string
|
|
|
+ if ctx.IsStringTable() {
|
|
|
+ q := buff.ReadInt() // read string index
|
|
|
+ p = ctx.Table[q]
|
|
|
+ } else {
|
|
|
+ p = buff.ReadString() // read string
|
|
|
+ }
|
|
|
+ o := p
|
|
|
+ n = o
|
|
|
+
|
|
|
+ vv := Resource(n)
|
|
|
+ // --- [end][read][alias](Resource) ---
|
|
|
+
|
|
|
+ // --- [begin][read][struct](ResourceQuantity) ---
|
|
|
+ r := &ResourceQuantity{}
|
|
|
+ buff.ReadInt() // [compatibility, unused]
|
|
|
+ errB := r.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ zz := *r
|
|
|
+ // --- [end][read][struct](ResourceQuantity) ---
|
|
|
+
|
|
|
+ l[vv] = zz
|
|
|
+ }
|
|
|
+ k = l
|
|
|
+ // --- [end][read][map](map[Resource]ResourceQuantity) ---
|
|
|
+
|
|
|
+ }
|
|
|
+ target.Limits = ResourceQuantities(k)
|
|
|
+ // --- [end][read][alias](ResourceQuantities) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+// Window
|
|
|
+//--------------------------------------------------------------------------
|
|
|
+
|
|
|
+// MarshalBinary serializes the internal properties of this Window instance
|
|
|
+// into a byte array
|
|
|
+func (target *Window) MarshalBinary() (data []byte, err error) {
|
|
|
+ ctx := &EncodingContext{
|
|
|
+ Buffer: util.NewBuffer(),
|
|
|
+ Table: nil,
|
|
|
+ }
|
|
|
+
|
|
|
+ e := target.MarshalBinaryWithContext(ctx)
|
|
|
+ if e != nil {
|
|
|
+ return nil, e
|
|
|
+ }
|
|
|
+
|
|
|
+ encBytes := ctx.Buffer.Bytes()
|
|
|
+ return encBytes, nil
|
|
|
+}
|
|
|
+
|
|
|
+// MarshalBinaryWithContext serializes the internal properties of this Window instance
|
|
|
+// into a byte array leveraging a predefined context.
|
|
|
+func (target *Window) MarshalBinaryWithContext(ctx *EncodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ buff.WriteUInt8(DefaultCodecVersion) // version
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ a, errA := target.Start.MarshalBinary()
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(a))
|
|
|
+ buff.WriteBytes(a)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ // --- [begin][write][reference](time.Time) ---
|
|
|
+ b, errB := target.End.MarshalBinary()
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ buff.WriteInt(len(b))
|
|
|
+ buff.WriteBytes(b)
|
|
|
+ // --- [end][write][reference](time.Time) ---
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinary uses the data passed byte array to set all the internal properties of
|
|
|
+// the Window type
|
|
|
+func (target *Window) UnmarshalBinary(data []byte) error {
|
|
|
+ var table []string
|
|
|
+ buff := util.NewBufferFromBytes(data)
|
|
|
+
|
|
|
+ // string table header validation
|
|
|
+ if isBinaryTag(data, BinaryTagStringTable) {
|
|
|
+ buff.ReadBytes(len(BinaryTagStringTable)) // strip tag length
|
|
|
+ tl := buff.ReadInt() // table length
|
|
|
+ if tl > 0 {
|
|
|
+ table = make([]string, tl, tl)
|
|
|
+ for i := 0; i < tl; i++ {
|
|
|
+ table[i] = buff.ReadString()
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ ctx := &DecodingContext{
|
|
|
+ Buffer: buff,
|
|
|
+ Table: table,
|
|
|
+ }
|
|
|
+
|
|
|
+ err := target.UnmarshalBinaryWithContext(ctx)
|
|
|
+ if err != nil {
|
|
|
+ return err
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
|
|
+
|
|
|
+// UnmarshalBinaryWithContext uses the context containing a string table and binary buffer to set all the internal properties of
|
|
|
+// the Window type
|
|
|
+func (target *Window) UnmarshalBinaryWithContext(ctx *DecodingContext) (err error) {
|
|
|
+ // panics are recovered and propagated as errors
|
|
|
+ defer func() {
|
|
|
+ if r := recover(); r != nil {
|
|
|
+ if e, ok := r.(error); ok {
|
|
|
+ err = e
|
|
|
+ } else if s, ok := r.(string); ok {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %s", s)
|
|
|
+ } else {
|
|
|
+ err = fmt.Errorf("Unexpected panic: %+v", r)
|
|
|
+ }
|
|
|
+ }
|
|
|
+ }()
|
|
|
+
|
|
|
+ buff := ctx.Buffer
|
|
|
+ version := buff.ReadUInt8()
|
|
|
+
|
|
|
+ if version > DefaultCodecVersion {
|
|
|
+ return fmt.Errorf("Invalid Version Unmarshaling Window. Expected %d or less, got %d", DefaultCodecVersion, version)
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ a := &time.Time{}
|
|
|
+ b := buff.ReadInt() // byte array length
|
|
|
+ c := buff.ReadBytes(b) // byte array
|
|
|
+ errA := a.UnmarshalBinary(c)
|
|
|
+ if errA != nil {
|
|
|
+ return errA
|
|
|
+ }
|
|
|
+ target.Start = *a
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ // field version check
|
|
|
+ if uint8(1) <= version {
|
|
|
+ // --- [begin][read][reference](time.Time) ---
|
|
|
+ d := &time.Time{}
|
|
|
+ e := buff.ReadInt() // byte array length
|
|
|
+ f := buff.ReadBytes(e) // byte array
|
|
|
+ errB := d.UnmarshalBinary(f)
|
|
|
+ if errB != nil {
|
|
|
+ return errB
|
|
|
+ }
|
|
|
+ target.End = *d
|
|
|
+ // --- [end][read][reference](time.Time) ---
|
|
|
+
|
|
|
+ } else {
|
|
|
+ }
|
|
|
+
|
|
|
+ return nil
|
|
|
+}
|
Niko Kovacevic