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

package aconfig

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

// begin of aconfig_value_set.go
func init() {
 valueSetProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(valueSetProviderData) })
}

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

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

func (r valueSetProviderData) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":aconfig.valueSetProviderData")
 hasher.WriteInt(1)
 hasher.WriteString(":.map[string]android.Paths")
 hasher.WriteInt(len(r.AvailablePackages))
 val1 := make([]string, 0, len(r.AvailablePackages))
 for val3 := range r.AvailablePackages {
  val1 = append(val1, val3)
 }
 proptools.SortOrdered(val1)
 for _, val2 := range val1 {
  hasher.WriteString(":.string")
  hasher.WriteString(val2)
  hasher.WriteString(":aconfig.android.Paths")
  hasher.WriteString(":.[]Path")
  hasher.WriteInt(len(r.AvailablePackages[val2]))
  for val4 := 0; val4 < len(r.AvailablePackages[val2]); val4++ {
   hasher.WriteString("android/soong/android:android.Path")
   val5 := r.AvailablePackages[val2][val4] == nil
   if val5 {
    hasher.WriteByte(0)
   } else {
    if v := reflect.ValueOf(r.AvailablePackages[val2][val4]); v.Kind() == reflect.Ptr {
     if v.IsNil() {
      panic(fmt.Errorf("nil pointer is not supported in interface"))
     } else {
      val6 := r.AvailablePackages[val2][val4] == nil
      if val6 {
       hasher.WriteByte(0)
      } else {
       val7 := func(hasher *proptools.Hasher) error {
        return r.AvailablePackages[val2][val4].(proptools.CustomHash).CustomHash(hasher)
       }
       if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
        return err
       }
      }
     }
    } else {
     r.AvailablePackages[val2][val4].(proptools.CustomHash).CustomHash(hasher)
    }
   }
  }
 }
 return nil
}

func (r *valueSetProviderData) 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.AvailablePackages = make(map[string]android.Paths, val1)
  for val2 := 0; val2 < int(val1); val2++ {
   var val3 string
   var val4 android.Paths
   err = gobtools.DecodeString(buf, &val3)
   if err != nil {
    return err
   }
   var val8 int
   err = gobtools.DecodeInt(buf, &val8)
   if err != nil {
    return err
   }
   if val8 != -1 {
    val4 = make([]android.Path, val8)
    for val9 := 0; val9 < int(val8); val9++ {
     if val11, err := gobtools.DecodeInterface(ctx, buf); err != nil {
      return err
     } else if val11 == nil {
      val4[val9] = nil
     } else {
      val4[val9] = val11.(android.Path)
     }
    }
   }
   r.AvailablePackages[val3] = val4
  }
 }

 return err
}

var valueSetProviderDataGobRegId int16

func (r valueSetProviderData) GetTypeId() int16 {
 return valueSetProviderDataGobRegId
}

// end of aconfig_value_set.go

// begin of aconfig_values.go
func init() {
 valuesProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(valuesProviderData) })
}

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

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

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

func (r valuesProviderData) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":aconfig.valuesProviderData")
 hasher.WriteInt(2)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Package)
 hasher.WriteString(":aconfig.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.Values))
 for val1 := 0; val1 < len(r.Values); val1++ {
  hasher.WriteString("android/soong/android:android.Path")
  val2 := r.Values[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.Values[val1]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := r.Values[val1] == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error { return r.Values[val1].(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    r.Values[val1].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 return nil
}

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

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

 var val4 int
 err = gobtools.DecodeInt(buf, &val4)
 if err != nil {
  return err
 }
 if val4 != -1 {
  r.Values = make([]android.Path, val4)
  for val5 := 0; val5 < int(val4); val5++ {
   if val7, err := gobtools.DecodeInterface(ctx, buf); err != nil {
    return err
   } else if val7 == nil {
    r.Values[val5] = nil
   } else {
    r.Values[val5] = val7.(android.Path)
   }
  }
 }

 return err
}

var valuesProviderDataGobRegId int16

func (r valuesProviderData) GetTypeId() int16 {
 return valuesProviderDataGobRegId
}

// end of aconfig_values.go

// begin of all_aconfig_declarations.go
func init() {
 AllAconfigDeclarationsInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(AllAconfigDeclarationsInfo) })
}

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

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

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

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

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

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

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

func (r AllAconfigDeclarationsInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":aconfig.AllAconfigDeclarationsInfo")
 hasher.WriteInt(6)
 hasher.WriteString(":aconfig.android.Path")
 val1 := r.ParsedFlagsFile == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.ParsedFlagsFile); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.ParsedFlagsFile == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error {
      return r.ParsedFlagsFile.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.ParsedFlagsFile.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":aconfig.android.Path")
 val4 := r.TextProtoFlagsFile == nil
 if val4 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.TextProtoFlagsFile); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val5 := r.TextProtoFlagsFile == nil
    if val5 {
     hasher.WriteByte(0)
    } else {
     val6 := func(hasher *proptools.Hasher) error {
      return r.TextProtoFlagsFile.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
      return err
     }
    }
   }
  } else {
   r.TextProtoFlagsFile.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":aconfig.android.Path")
 val7 := r.StorageFlagVal == nil
 if val7 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.StorageFlagVal); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val8 := r.StorageFlagVal == nil
    if val8 {
     hasher.WriteByte(0)
    } else {
     val9 := func(hasher *proptools.Hasher) error {
      return r.StorageFlagVal.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
      return err
     }
    }
   }
  } else {
   r.StorageFlagVal.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":aconfig.android.Path")
 val10 := r.StorageFlagMap == nil
 if val10 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.StorageFlagMap); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val11 := r.StorageFlagMap == nil
    if val11 {
     hasher.WriteByte(0)
    } else {
     val12 := func(hasher *proptools.Hasher) error {
      return r.StorageFlagMap.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
      return err
     }
    }
   }
  } else {
   r.StorageFlagMap.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":aconfig.android.Path")
 val13 := r.StorageFlagInfo == nil
 if val13 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.StorageFlagInfo); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val14 := r.StorageFlagInfo == nil
    if val14 {
     hasher.WriteByte(0)
    } else {
     val15 := func(hasher *proptools.Hasher) error {
      return r.StorageFlagInfo.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val15); err != nil {
      return err
     }
    }
   }
  } else {
   r.StorageFlagInfo.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":aconfig.android.Path")
 val16 := r.StoragePackageMap == nil
 if val16 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.StoragePackageMap); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val17 := r.StoragePackageMap == nil
    if val17 {
     hasher.WriteByte(0)
    } else {
     val18 := func(hasher *proptools.Hasher) error {
      return r.StoragePackageMap.(proptools.CustomHash).CustomHash(hasher)
     }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val18); err != nil {
      return err
     }
    }
   }
  } else {
   r.StoragePackageMap.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 return nil
}

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

 if val2, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val2 == nil {
  r.ParsedFlagsFile = nil
 } else {
  r.ParsedFlagsFile = val2.(android.Path)
 }

 if val4, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val4 == nil {
  r.TextProtoFlagsFile = nil
 } else {
  r.TextProtoFlagsFile = val4.(android.Path)
 }

 if val6, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val6 == nil {
  r.StorageFlagVal = nil
 } else {
  r.StorageFlagVal = val6.(android.Path)
 }

 if val8, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val8 == nil {
  r.StorageFlagMap = nil
 } else {
  r.StorageFlagMap = val8.(android.Path)
 }

 if val10, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val10 == nil {
  r.StorageFlagInfo = nil
 } else {
  r.StorageFlagInfo = val10.(android.Path)
 }

 if val12, err := gobtools.DecodeInterface(ctx, buf); err != nil {
  return err
 } else if val12 == nil {
  r.StoragePackageMap = nil
 } else {
  r.StoragePackageMap = val12.(android.Path)
 }

 return err
}

var AllAconfigDeclarationsInfoGobRegId int16

func (r AllAconfigDeclarationsInfo) GetTypeId() int16 {
 return AllAconfigDeclarationsInfoGobRegId
}

// end of all_aconfig_declarations.go