Quelle  blueprint_enc.go   Sprache: unbekannt

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

package blueprint

import (
 "bytes"
 "fmt"
 "github.com/google/blueprint/gobtools"
 "github.com/google/blueprint/proptools"
 "reflect"
 "unsafe"
)

// begin of context.go
func init() {
 globResultCacheGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(globResultCache) })
 stringHashGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(stringHash) })
 VariationGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(Variation) })
}

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

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

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

 for val2 := 0; val2 < len(r.Result); val2++ {
  if err = gobtools.EncodeUint64(buf, r.Result[val2]); err != nil {
   return err
  }
 }
 return err
}

func (r globResultCache) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.globResultCache")
 hasher.WriteInt(3)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Pattern)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Excludes))
 for val1 := 0; val1 < len(r.Excludes); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Excludes[val1])
 }
 hasher.WriteString(":blueprint.proptools.Hash")
 hasher.WriteString(":.[1]uint64")
 hasher.WriteInt(len(r.Result))
 for val2 := 0; val2 < len(r.Result); val2++ {
  hasher.WriteString(":.uint64")
  hasher.WriteUint64(uint64(r.Result[val2]))
 }
 return nil
}

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

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

 var val3 int
 err = gobtools.DecodeInt(buf, &val3)
 if err != nil {
  return err
 }
 if val3 != -1 {
  r.Excludes = make([]string, val3)
  for val4 := 0; val4 < int(val3); val4++ {
   err = gobtools.DecodeString(buf, &r.Excludes[val4])
   if err != nil {
    return err
   }
  }
 }

 for val8 := 0; val8 < len(r.Result); val8++ {
  err = gobtools.DecodeUint64(buf, &r.Result[val8])
  if err != nil {
   return err
  }
 }

 return err
}

var globResultCacheGobRegId int16

func (r globResultCache) GetTypeId() int16 {
 return globResultCacheGobRegId
}

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

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

func (r stringHash) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.stringHash")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.string)
 return nil
}

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

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

 return err
}

var stringHashGobRegId int16

func (r stringHash) GetTypeId() int16 {
 return stringHashGobRegId
}

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

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

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

func (r Variation) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.Variation")
 hasher.WriteInt(2)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Mutator)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Variation)
 return nil
}

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

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

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

 return err
}

var VariationGobRegId int16

func (r Variation) GetTypeId() int16 {
 return VariationGobRegId
}

// end of context.go

// begin of incremental.go
func init() {
 DataCacheKeyGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DataCacheKey) })
 CachedProviderGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CachedProvider) })
 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 DataCacheKey) 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 DataCacheKey) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.DataCacheKey")
 hasher.WriteInt(1)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Id)
 return nil
}

func (r *DataCacheKey) 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 DataCacheKeyGobRegId int16

func (r DataCacheKey) GetTypeId() int16 {
 return DataCacheKeyGobRegId
}

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

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

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

func (r CachedProvider) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.CachedProvider")
 hasher.WriteInt(2)
 hasher.WriteString(":.*providerKey")
 val1 := r.Id == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   if err := (*r.Id).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Id)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":.any")
 val3 := r.Value == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Value); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val4 := r.Value == nil
    if val4 {
     hasher.WriteByte(0)
    } else {
     val5 := func(hasher *proptools.Hasher) error { return r.Value.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val5); err != nil {
      return err
     }
    }
   }
  } else {
   r.Value.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 return nil
}

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

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

 if val5, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val5 == nil {
  r.Value = nil
 } else {
  r.Value = val5
 }

 return err
}

var CachedProviderGobRegId int16

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

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

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

 for val2 := 0; val2 < len(r.Hash); val2++ {
  if err = gobtools.EncodeUint64(buf, r.Hash[val2]); err != nil {
   return err
  }
 }
 return err
}

func (r ProviderHash) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.ProviderHash")
 hasher.WriteInt(2)
 hasher.WriteString(":.*providerKey")
 val1 := r.Id == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   if err := (*r.Id).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Id)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":blueprint.proptools.Hash")
 hasher.WriteString(":.[1]uint64")
 hasher.WriteInt(len(r.Hash))
 for val3 := 0; val3 < len(r.Hash); val3++ {
  hasher.WriteString(":.uint64")
  hasher.WriteUint64(uint64(r.Hash[val3]))
 }
 return nil
}

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

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

 for val6 := 0; val6 < len(r.Hash); val6++ {
  err = gobtools.DecodeUint64(buf, &r.Hash[val6])
  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

 for val1 := 0; val1 < len(r.InputHash); val1++ {
  if err = gobtools.EncodeUint64(buf, r.InputHash[val1]); err != nil {
   return err
  }
 }

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

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

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

func (r ModuleActionCachedData) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.ModuleActionCachedData")
 hasher.WriteInt(4)
 hasher.WriteString(":blueprint.proptools.Hash")
 hasher.WriteString(":.[1]uint64")
 hasher.WriteInt(len(r.InputHash))
 for val1 := 0; val1 < len(r.InputHash); val1++ {
  hasher.WriteString(":.uint64")
  hasher.WriteUint64(uint64(r.InputHash[val1]))
 }
 hasher.WriteString(":.[]ProviderHash")
 hasher.WriteInt(len(r.ProviderHashes))
 for val2 := 0; val2 < len(r.ProviderHashes); val2++ {
  if err := r.ProviderHashes[val2].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.OrderOnlyStrings))
 for val3 := 0; val3 < len(r.OrderOnlyStrings); val3++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.OrderOnlyStrings[val3])
 }
 hasher.WriteString(":.[]globResultCache")
 hasher.WriteInt(len(r.GlobCache))
 for val4 := 0; val4 < len(r.GlobCache); val4++ {
  if err := r.GlobCache[val4].CustomHash(hasher); err != nil {
   return err
  }
 }
 return nil
}

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

 for val3 := 0; val3 < len(r.InputHash); val3++ {
  err = gobtools.DecodeUint64(buf, &r.InputHash[val3])
  if err != nil {
   return err
  }
 }

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

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

 var val14 int
 err = gobtools.DecodeInt(buf, &val14)
 if err != nil {
  return err
 }
 if val14 != -1 {
  r.GlobCache = make([]globResultCache, val14)
  for val15 := 0; val15 < int(val14); val15++ {
   if err = r.GlobCache[val15].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.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, 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.DependencyProviderHashes == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.DependencyProviderHashes)); err != nil {
   return err
  }
  for val2, val3 := range r.DependencyProviderHashes {
   if err = gobtools.EncodeInt(buf, val2); err != nil {
    return err
   }
   for val4 := 0; val4 < len(val3); val4++ {
    if err = gobtools.EncodeUint64(buf, val3[val4]); err != nil {
     return err
    }
   }
  }
 }

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

func (r SingletonActionCachedData) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.SingletonActionCachedData")
 hasher.WriteInt(3)
 hasher.WriteString(":.[]ProviderHash")
 hasher.WriteInt(len(r.ProviderHashes))
 for val1 := 0; val1 < len(r.ProviderHashes); val1++ {
  if err := r.ProviderHashes[val1].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":.map[int]proptools.Hash")
 hasher.WriteInt(len(r.DependencyProviderHashes))
 val2 := make([]int, 0, len(r.DependencyProviderHashes))
 for val4 := range r.DependencyProviderHashes {
  val2 = append(val2, val4)
 }
 proptools.SortOrdered(val2)
 for _, val3 := range val2 {
  hasher.WriteString(":.int")
  hasher.WriteUint64(uint64(val3))
  hasher.WriteString(":blueprint.proptools.Hash")
  hasher.WriteString(":.[1]uint64")
  hasher.WriteInt(len(r.DependencyProviderHashes[val3]))
  for val5 := 0; val5 < len(r.DependencyProviderHashes[val3]); val5++ {
   hasher.WriteString(":.uint64")
   hasher.WriteUint64(uint64(r.DependencyProviderHashes[val3][val5]))
  }
 }
 hasher.WriteString(":.[]globResultCache")
 hasher.WriteInt(len(r.GlobCache))
 for val6 := 0; val6 < len(r.GlobCache); val6++ {
  if err := r.GlobCache[val6].CustomHash(hasher); err != nil {
   return err
  }
 }
 return nil
}

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

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

 var val5 int
 err = gobtools.DecodeInt(buf, &val5)
 if err != nil {
  return err
 }
 if val5 != -1 {
  r.DependencyProviderHashes = make(map[int]proptools.Hash, val5)
  for val6 := 0; val6 < int(val5); val6++ {
   var val7 int
   var val8 proptools.Hash
   err = gobtools.DecodeInt(buf, &val7)
   if err != nil {
    return err
   }
   for val12 := 0; val12 < len(val8); val12++ {
    err = gobtools.DecodeUint64(buf, &val8[val12])
    if err != nil {
     return err
    }
   }
   r.DependencyProviderHashes[val7] = val8
  }
 }

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

 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.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r)); err != nil {
   return err
  }
  for val1, val2 := range r {
   if err = gobtools.EncodeString(buf, val1); err != nil {
    return err
   }
   if val2 == nil {
    if err = gobtools.EncodeInt(buf, -1); err != nil {
     return err
    }
   } else {
    if err = gobtools.EncodeInt(buf, len(val2)); err != nil {
     return err
    }
    for val3 := 0; val3 < len(val2); val3++ {
     if err = gobtools.EncodeString(buf, val2[val3]); err != nil {
      return err
     }
    }
   }
  }
 }
 return err
}

func (r OrderOnlyStringsCache) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":.map[string][]string")
 hasher.WriteInt(len(r))
 val1 := make([]string, 0, len(r))
 for val3 := range r {
  val1 = append(val1, val3)
 }
 proptools.SortOrdered(val1)
 for _, val2 := range val1 {
  hasher.WriteString(":.string")
  hasher.WriteString(val2)
  hasher.WriteString(":.[]string")
  hasher.WriteInt(len(r[val2]))
  for val4 := 0; val4 < len(r[val2]); val4++ {
   hasher.WriteString(":.string")
   hasher.WriteString(r[val2][val4])
  }
 }
 return nil
}

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

 var val1 int
 err = gobtools.DecodeInt(buf, &val1)
 if err != nil {
  return err
 }
 if val1 != -1 {
  (*r) = make(map[string][]string, val1)
  for val2 := 0; val2 < int(val1); val2++ {
   var val3 string
   var val4 []string
   err = gobtools.DecodeString(buf, &val3)
   if err != nil {
    return err
   }
   var val7 int
   err = gobtools.DecodeInt(buf, &val7)
   if err != nil {
    return err
   }
   if val7 != -1 {
    val4 = make([]string, val7)
    for val8 := 0; val8 < int(val7); val8++ {
     err = gobtools.DecodeString(buf, &val4[val8])
     if err != nil {
      return err
     }
    }
   }
   (*r)[val3] = val4
  }
 }

 return err
}

var OrderOnlyStringsCacheGobRegId int16

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

// end of incremental.go

// begin of incremental_module.go
func init() {
 ModuleBuildActionCacheInputGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ModuleBuildActionCacheInput) })
 hashListGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(hashList) })
 stringListGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(stringList) })
}

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

 for val1 := 0; val1 < len(r.PropertiesHash); val1++ {
  if err = gobtools.EncodeUint64(buf, r.PropertiesHash[val1]); err != nil {
   return err
  }
 }

 if r.DepProviderHashes == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.DepProviderHashes)); err != nil {
   return err
  }
  for val2 := 0; val2 < len(r.DepProviderHashes); val2++ {
   for val3 := 0; val3 < len(r.DepProviderHashes[val2]); val3++ {
    if err = gobtools.EncodeUint64(buf, r.DepProviderHashes[val2][val3]); err != nil {
     return err
    }
   }
  }
 }
 return err
}

func (r ModuleBuildActionCacheInput) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.ModuleBuildActionCacheInput")
 hasher.WriteInt(2)
 hasher.WriteString(":blueprint.proptools.Hash")
 hasher.WriteString(":.[1]uint64")
 hasher.WriteInt(len(r.PropertiesHash))
 for val1 := 0; val1 < len(r.PropertiesHash); val1++ {
  hasher.WriteString(":.uint64")
  hasher.WriteUint64(uint64(r.PropertiesHash[val1]))
 }
 hasher.WriteString(":.[]proptools.Hash")
 hasher.WriteInt(len(r.DepProviderHashes))
 for val2 := 0; val2 < len(r.DepProviderHashes); val2++ {
  hasher.WriteString(":blueprint.proptools.Hash")
  hasher.WriteString(":.[1]uint64")
  hasher.WriteInt(len(r.DepProviderHashes[val2]))
  for val3 := 0; val3 < len(r.DepProviderHashes[val2]); val3++ {
   hasher.WriteString(":.uint64")
   hasher.WriteUint64(uint64(r.DepProviderHashes[val2][val3]))
  }
 }
 return nil
}

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

 for val3 := 0; val3 < len(r.PropertiesHash); val3++ {
  err = gobtools.DecodeUint64(buf, &r.PropertiesHash[val3])
  if err != nil {
   return err
  }
 }

 var val6 int
 err = gobtools.DecodeInt(buf, &val6)
 if err != nil {
  return err
 }
 if val6 != -1 {
  r.DepProviderHashes = make([]proptools.Hash, val6)
  for val7 := 0; val7 < int(val6); val7++ {
   for val10 := 0; val10 < len(r.DepProviderHashes[val7]); val10++ {
    err = gobtools.DecodeUint64(buf, &r.DepProviderHashes[val7][val10])
    if err != nil {
     return err
    }
   }
  }
 }

 return err
}

var ModuleBuildActionCacheInputGobRegId int16

func (r ModuleBuildActionCacheInput) GetTypeId() int16 {
 return ModuleBuildActionCacheInputGobRegId
}

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

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

func (r hashList) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":.[]proptools.Hash")
 hasher.WriteInt(len(r))
 for val1 := 0; val1 < len(r); val1++ {
  hasher.WriteString(":blueprint.proptools.Hash")
  hasher.WriteString(":.[1]uint64")
  hasher.WriteInt(len(r[val1]))
  for val2 := 0; val2 < len(r[val1]); val2++ {
   hasher.WriteString(":.uint64")
   hasher.WriteUint64(uint64(r[val1][val2]))
  }
 }
 return nil
}

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

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  (*r) = make([]proptools.Hash, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   for val6 := 0; val6 < len((*r)[val3]); val6++ {
    err = gobtools.DecodeUint64(buf, &(*r)[val3][val6])
    if err != nil {
     return err
    }
   }
  }
 }

 return err
}

var hashListGobRegId int16

func (r hashList) GetTypeId() int16 {
 return hashListGobRegId
}

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

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

func (r stringList) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r))
 for val1 := 0; val1 < len(r); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r[val1])
 }
 return nil
}

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

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 if val2 != -1 {
  (*r) = make([]string, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   err = gobtools.DecodeString(buf, &(*r)[val3])
   if err != nil {
    return err
   }
  }
 }

 return err
}

var stringListGobRegId int16

func (r stringList) GetTypeId() int16 {
 return stringListGobRegId
}

// end of incremental_module.go

// begin of provider.go
func init() {
 providerKeyGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(providerKey) })
}

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

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

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

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

func (r providerKey) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":blueprint.providerKey")
 hasher.WriteInt(3)
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(r.id))
 hasher.WriteString(":.string")
 hasher.WriteString(r.typ)
 hasher.WriteString(":.string")
 hasher.WriteString(r.mutator)
 return nil
}

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

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

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

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

 return err
}

var providerKeyGobRegId int16

func (r providerKey) GetTypeId() int16 {
 return providerKeyGobRegId
}

// end of provider.go