// Code generated by go run gob_gen.go; DO NOT EDIT.

package blueprint

import (
	"bytes"
	"github.com/google/blueprint/gobtools"
)

func init() {
	BuildActionCacheKeyGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BuildActionCacheKey) })
	CachedProviderGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CachedProvider) })
	ProviderCachedDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProviderCachedData) })
	ProviderHashGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProviderHash) })
	ModuleActionCachedDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleActionCachedData) })
	SingletonActionCachedDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SingletonActionCachedData) })
	OrderOnlyStringsCacheGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(OrderOnlyStringsCache) })
}

func (r BuildActionCacheKey) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeString(buf, r.Id); err != nil {
		return err
	}
	return err
}

func (r *BuildActionCacheKey) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeString(buf, &r.Id)
	if err != nil {
		return err
	}

	return err
}

var BuildActionCacheKeyGobRegId int16

func (r BuildActionCacheKey) GetTypeId() int16 {
	return BuildActionCacheKeyGobRegId
}

func (r CachedProvider) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	val1 := r.Id == nil
	if err = gobtools.EncodeSimple(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = (*r.Id).Encode(ctx, buf); err != nil {
			return err
		}
	}

	val2 := r.Value == nil
	if err = gobtools.EncodeSimple(buf, val2); err != nil {
		return err
	}
	if !val2 {
		if err = gobtools.EncodeInterface(ctx, buf, (*r.Value)); err != nil {
			return err
		}
	}
	return err
}

func (r *CachedProvider) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val2 bool
	if err = gobtools.DecodeSimple(buf, &val2); err != nil {
		return err
	}
	if !val2 {
		var val1 providerKey
		if err = val1.Decode(ctx, buf); err != nil {
			return err
		}
		r.Id = &val1
	}

	var val5 bool
	if err = gobtools.DecodeSimple(buf, &val5); err != nil {
		return err
	}
	if !val5 {
		var val4 any
		if val7, err := gobtools.DecodeInterface(ctx, buf); err != nil {
			return err
		} else if val7 == nil {
			val4 = nil
		} else {
			val4 = val7
		}
		r.Value = &val4
	}

	return err
}

var CachedProviderGobRegId int16

func (r CachedProvider) GetTypeId() int16 {
	return CachedProviderGobRegId
}

func (r ProviderCachedData) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.Providers == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.Providers))); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.Providers); val1++ {
			if err = r.Providers[val1].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *ProviderCachedData) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val2 int32
	err = gobtools.DecodeSimple[int32](buf, &val2)
	if err != nil {
		return err
	}
	if val2 != -1 {
		r.Providers = make([]CachedProvider, val2)
		for val3 := 0; val3 < int(val2); val3++ {
			if err = r.Providers[val3].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var ProviderCachedDataGobRegId int16

func (r ProviderCachedData) GetTypeId() int16 {
	return ProviderCachedDataGobRegId
}

func (r ProviderHash) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	val1 := r.Id == nil
	if err = gobtools.EncodeSimple(buf, val1); err != nil {
		return err
	}
	if !val1 {
		if err = (*r.Id).Encode(ctx, buf); err != nil {
			return err
		}
	}

	if err = gobtools.EncodeSimple(buf, r.Hash); err != nil {
		return err
	}
	return err
}

func (r *ProviderHash) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val2 bool
	if err = gobtools.DecodeSimple(buf, &val2); err != nil {
		return err
	}
	if !val2 {
		var val1 providerKey
		if err = val1.Decode(ctx, buf); err != nil {
			return err
		}
		r.Id = &val1
	}

	err = gobtools.DecodeSimple[uint64](buf, &r.Hash)
	if err != nil {
		return err
	}

	return err
}

var ProviderHashGobRegId int16

func (r ProviderHash) GetTypeId() int16 {
	return ProviderHashGobRegId
}

func (r ModuleActionCachedData) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if err = gobtools.EncodeSimple(buf, r.InputHash); err != nil {
		return err
	}

	if r.ProviderHashes == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.ProviderHashes))); err != nil {
			return err
		}
		for val1 := 0; val1 < len(r.ProviderHashes); val1++ {
			if err = r.ProviderHashes[val1].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}

	if r.OrderOnlyStrings == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.OrderOnlyStrings))); err != nil {
			return err
		}
		for val2 := 0; val2 < len(r.OrderOnlyStrings); val2++ {
			if err = gobtools.EncodeString(buf, r.OrderOnlyStrings[val2]); err != nil {
				return err
			}
		}
	}

	if r.GlobCache == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.GlobCache))); err != nil {
			return err
		}
		for val3 := 0; val3 < len(r.GlobCache); val3++ {
			if err = r.GlobCache[val3].Encode(ctx, buf); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *ModuleActionCachedData) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	err = gobtools.DecodeSimple[uint64](buf, &r.InputHash)
	if err != nil {
		return err
	}

	var val3 int32
	err = gobtools.DecodeSimple[int32](buf, &val3)
	if err != nil {
		return err
	}
	if val3 != -1 {
		r.ProviderHashes = make([]ProviderHash, val3)
		for val4 := 0; val4 < int(val3); val4++ {
			if err = r.ProviderHashes[val4].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	var val7 int32
	err = gobtools.DecodeSimple[int32](buf, &val7)
	if err != nil {
		return err
	}
	if val7 != -1 {
		r.OrderOnlyStrings = make([]string, val7)
		for val8 := 0; val8 < int(val7); val8++ {
			err = gobtools.DecodeString(buf, &r.OrderOnlyStrings[val8])
			if err != nil {
				return err
			}
		}
	}

	var val11 int32
	err = gobtools.DecodeSimple[int32](buf, &val11)
	if err != nil {
		return err
	}
	if val11 != -1 {
		r.GlobCache = make([]globResultCache, val11)
		for val12 := 0; val12 < int(val11); val12++ {
			if err = r.GlobCache[val12].Decode(ctx, buf); err != nil {
				return err
			}
		}
	}

	return err
}

var ModuleActionCachedDataGobRegId int16

func (r ModuleActionCachedData) GetTypeId() int16 {
	return ModuleActionCachedDataGobRegId
}

func (r SingletonActionCachedData) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r.ProviderHashes == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r.ProviderHashes))); err != nil {
			return err
		}
		for k, v := range r.ProviderHashes {
			if err = gobtools.EncodeSimple(buf, int64(k)); err != nil {
				return err
			}
			if err = gobtools.EncodeSimple(buf, v); err != nil {
				return err
			}
		}
	}
	return err
}

func (r *SingletonActionCachedData) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val1 int32
	err = gobtools.DecodeSimple[int32](buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		r.ProviderHashes = make(map[int]uint64, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var k int
			var v uint64
			var val3 int64
			err = gobtools.DecodeSimple[int64](buf, &val3)
			if err != nil {
				return err
			}
			k = int(val3)
			err = gobtools.DecodeSimple[uint64](buf, &v)
			if err != nil {
				return err
			}
			r.ProviderHashes[k] = v
		}
	}

	return err
}

var SingletonActionCachedDataGobRegId int16

func (r SingletonActionCachedData) GetTypeId() int16 {
	return SingletonActionCachedDataGobRegId
}

func (r OrderOnlyStringsCache) Encode(ctx gobtools.EncContext, buf *bytes.Buffer) error {
	var err error

	if r == nil {
		if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
			return err
		}
	} else {
		if err = gobtools.EncodeSimple(buf, int32(len(r))); err != nil {
			return err
		}
		for k, v := range r {
			if err = gobtools.EncodeString(buf, k); err != nil {
				return err
			}
			if v == nil {
				if err = gobtools.EncodeSimple(buf, int32(-1)); err != nil {
					return err
				}
			} else {
				if err = gobtools.EncodeSimple(buf, int32(len(v))); err != nil {
					return err
				}
				for val1 := 0; val1 < len(v); val1++ {
					if err = gobtools.EncodeString(buf, v[val1]); err != nil {
						return err
					}
				}
			}
		}
	}
	return err
}

func (r *OrderOnlyStringsCache) Decode(ctx gobtools.EncContext, buf *bytes.Reader) error {
	var err error

	var val1 int32
	err = gobtools.DecodeSimple[int32](buf, &val1)
	if err != nil {
		return err
	}
	if val1 != -1 {
		(*r) = make(map[string][]string, val1)
		for val2 := 0; val2 < int(val1); val2++ {
			var k string
			var v []string
			err = gobtools.DecodeString(buf, &k)
			if err != nil {
				return err
			}
			var val5 int32
			err = gobtools.DecodeSimple[int32](buf, &val5)
			if err != nil {
				return err
			}
			if val5 != -1 {
				v = make([]string, val5)
				for val6 := 0; val6 < int(val5); val6++ {
					err = gobtools.DecodeString(buf, &v[val6])
					if err != nil {
						return err
					}
				}
			}
			(*r)[k] = v
		}
	}

	return err
}

var OrderOnlyStringsCacheGobRegId int16

func (r OrderOnlyStringsCache) GetTypeId() int16 {
	return OrderOnlyStringsCacheGobRegId
}