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

package rust

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

// begin of rust.go
func init() {
 LibraryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(LibraryInfo) })
 CompilerInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(CompilerInfo) })
 ProtobufDecoratorInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProtobufDecoratorInfo) })
 SourceProviderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(SourceProviderInfo) })
 ProcMacroInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ProcMacroInfo) })
 RustInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RustInfo) })
 RustFlagExporterInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RustFlagExporterInfo) })
 RustDepInSameApexCheckerGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RustDepInSameApexChecker) })
 RustImplementationDepInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(RustImplementationDepInfo) })
}

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

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

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

func (r LibraryInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.LibraryInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.bool")
 if r.Rlib {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Dylib {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

 return err
}

var LibraryInfoGobRegId int16

func (r LibraryInfo) GetTypeId() int16 {
 return LibraryInfoGobRegId
}

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

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

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

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

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

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

 if err = r.CargoOutDir.Encode(ctx, buf); err != nil {
  return err
 }

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

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

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

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

 if err = r.CheckTarget.Encode(ctx, buf); err != nil {
  return err
 }
 return err
}

func (r CompilerInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.CompilerInfo")
 hasher.WriteInt(11)
 hasher.WriteString(":rust.StdLinkage")
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(int(r.StdLinkageForDevice)))
 hasher.WriteString(":rust.StdLinkage")
 hasher.WriteString(":.int")
 hasher.WriteUint64(uint64(int(r.StdLinkageForNonDevice)))
 hasher.WriteString(":.bool")
 if r.NoStdlibs {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.CrateName)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Edition)
 if err := r.CargoOutDir.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Features))
 for val1 := 0; val1 < len(r.Features); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Features[val1])
 }
 hasher.WriteString(":rust.android.Path")
 val2 := r.CrateRootPath == nil
 if val2 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.CrateRootPath); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val3 := r.CrateRootPath == nil
    if val3 {
     hasher.WriteByte(0)
    } else {
     val4 := func(hasher *proptools.Hasher) error { return r.CrateRootPath.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
      return err
     }
    }
   }
  } else {
   r.CrateRootPath.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.*LibraryInfo")
 val5 := r.LibraryInfo == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  val6 := func(hasher *proptools.Hasher) error {
   if err := (*r.LibraryInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.LibraryInfo)), val6); err != nil {
   return err
  }
 }
 hasher.WriteString(":rust.android.Path")
 val7 := r.BuildTarget == nil
 if val7 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.BuildTarget); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val8 := r.BuildTarget == nil
    if val8 {
     hasher.WriteByte(0)
    } else {
     val9 := func(hasher *proptools.Hasher) error { return r.BuildTarget.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
      return err
     }
    }
   }
  } else {
   r.BuildTarget.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 if err := r.CheckTarget.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

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

 var val2 int
 err = gobtools.DecodeInt(buf, &val2)
 if err != nil {
  return err
 }
 r.StdLinkageForDevice = StdLinkage(val2)

 var val5 int
 err = gobtools.DecodeInt(buf, &val5)
 if err != nil {
  return err
 }
 r.StdLinkageForNonDevice = StdLinkage(val5)

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

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

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

 if err = r.CargoOutDir.Decode(ctx, buf); err != nil {
  return err
 }

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

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

 var val18 bool
 if err = gobtools.DecodeBool(buf, &val18); err != nil {
  return err
 }
 if !val18 {
  var val17 LibraryInfo
  if err = val17.Decode(ctx, buf); err != nil {
   return err
  }
  r.LibraryInfo = &val17
 }

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

 if err = r.CheckTarget.Decode(ctx, buf); err != nil {
  return err
 }

 return err
}

var CompilerInfoGobRegId int16

func (r CompilerInfo) GetTypeId() int16 {
 return CompilerInfoGobRegId
}

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

func (r ProtobufDecoratorInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.ProtobufDecoratorInfo")
 hasher.WriteInt(0)
 return nil
}

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

 return err
}

var ProtobufDecoratorInfoGobRegId int16

func (r ProtobufDecoratorInfo) GetTypeId() int16 {
 return ProtobufDecoratorInfoGobRegId
}

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

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

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

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

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

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

 var val8 bool
 if err = gobtools.DecodeBool(buf, &val8); err != nil {
  return err
 }
 if !val8 {
  var val7 ProtobufDecoratorInfo
  if err = val7.Decode(ctx, buf); err != nil {
   return err
  }
  r.ProtobufDecoratorInfo = &val7
 }

 return err
}

var SourceProviderInfoGobRegId int16

func (r SourceProviderInfo) GetTypeId() int16 {
 return SourceProviderInfoGobRegId
}

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

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

func (r ProcMacroInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.ProcMacroInfo")
 hasher.WriteInt(1)
 hasher.WriteString(":rust.android.Path")
 val1 := r.Dylib == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Dylib); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.Dylib == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.Dylib.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.Dylib.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 return nil
}

func (r *ProcMacroInfo) 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.Dylib = nil
 } else {
  r.Dylib = val2.(android.Path)
 }

 return err
}

var ProcMacroInfoGobRegId int16

func (r ProcMacroInfo) GetTypeId() int16 {
 return ProcMacroInfoGobRegId
}

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

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

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

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

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

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

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

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

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

 if err = r.DocTimestampFile.Encode(ctx, buf); err != nil {
  return err
 }

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

func (r RustInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.RustInfo")
 hasher.WriteInt(10)
 hasher.WriteString(":.string")
 hasher.WriteString(r.AndroidMkSuffix)
 hasher.WriteString(":.string")
 hasher.WriteString(r.RustSubName)
 val2 := func(hasher *proptools.Hasher, val1 string) error {
  hasher.WriteString(":.string")
  hasher.WriteString(val1)
  return nil
 }
 if err := r.TransitiveAndroidMkSharedLibs.Hash(hasher, "string", val2); err != nil {
  return err
 }
 hasher.WriteString(":.*CompilerInfo")
 val3 := r.CompilerInfo == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  val4 := func(hasher *proptools.Hasher) error {
   if err := (*r.CompilerInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.CompilerInfo)), val4); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*cc.SnapshotInfo")
 val5 := r.SnapshotInfo == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  val6 := func(hasher *proptools.Hasher) error {
   if err := (*r.SnapshotInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SnapshotInfo)), val6); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*SourceProviderInfo")
 val7 := r.SourceProviderInfo == nil
 if val7 {
  hasher.WriteByte(0)
 } else {
  val8 := func(hasher *proptools.Hasher) error {
   if err := (*r.SourceProviderInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.SourceProviderInfo)), val8); err != nil {
   return err
  }
 }
 hasher.WriteString(":.*ProcMacroInfo")
 val9 := r.ProcMacroInfo == nil
 if val9 {
  hasher.WriteByte(0)
 } else {
  val10 := func(hasher *proptools.Hasher) error {
   if err := (*r.ProcMacroInfo).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.ProcMacroInfo)), val10); err != nil {
   return err
  }
 }
 hasher.WriteString(":rust.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.XrefRustFiles))
 for val11 := 0; val11 < len(r.XrefRustFiles); val11++ {
  hasher.WriteString("android/soong/android:android.Path")
  val12 := r.XrefRustFiles[val11] == nil
  if val12 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.XrefRustFiles[val11]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val13 := r.XrefRustFiles[val11] == nil
     if val13 {
      hasher.WriteByte(0)
     } else {
      val14 := func(hasher *proptools.Hasher) error {
       return r.XrefRustFiles[val11].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val14); err != nil {
       return err
      }
     }
    }
   } else {
    r.XrefRustFiles[val11].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 if err := r.DocTimestampFile.CustomHash(hasher); err != nil {
  return err
 }
 hasher.WriteString(":.bool")
 if r.CollectDoc {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

 if err = r.TransitiveAndroidMkSharedLibs.DecodeString(ctx, buf); err != nil {
  return err
 }

 var val5 bool
 if err = gobtools.DecodeBool(buf, &val5); err != nil {
  return err
 }
 if !val5 {
  var val4 CompilerInfo
  if err = val4.Decode(ctx, buf); err != nil {
   return err
  }
  r.CompilerInfo = &val4
 }

 var val8 bool
 if err = gobtools.DecodeBool(buf, &val8); err != nil {
  return err
 }
 if !val8 {
  var val7 cc.SnapshotInfo
  if err = val7.Decode(ctx, buf); err != nil {
   return err
  }
  r.SnapshotInfo = &val7
 }

 var val11 bool
 if err = gobtools.DecodeBool(buf, &val11); err != nil {
  return err
 }
 if !val11 {
  var val10 SourceProviderInfo
  if err = val10.Decode(ctx, buf); err != nil {
   return err
  }
  r.SourceProviderInfo = &val10
 }

 var val14 bool
 if err = gobtools.DecodeBool(buf, &val14); err != nil {
  return err
 }
 if !val14 {
  var val13 ProcMacroInfo
  if err = val13.Decode(ctx, buf); err != nil {
   return err
  }
  r.ProcMacroInfo = &val13
 }

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

 if err = r.DocTimestampFile.Decode(ctx, buf); err != nil {
  return err
 }

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

 return err
}

var RustInfoGobRegId int16

func (r RustInfo) GetTypeId() int16 {
 return RustInfoGobRegId
}

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

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

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

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

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

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

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

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

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

func (r RustFlagExporterInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.RustFlagExporterInfo")
 hasher.WriteInt(8)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Flags))
 for val1 := 0; val1 < len(r.Flags); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Flags[val1])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.LinkDirs))
 for val2 := 0; val2 < len(r.LinkDirs); val2++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.LinkDirs[val2])
 }
 hasher.WriteString(":.[]android.Path")
 hasher.WriteInt(len(r.LinkDirsDeps))
 for val3 := 0; val3 < len(r.LinkDirsDeps); val3++ {
  hasher.WriteString(":rust.android.Path")
  val4 := r.LinkDirsDeps[val3] == nil
  if val4 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.LinkDirsDeps[val3]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val5 := r.LinkDirsDeps[val3] == nil
     if val5 {
      hasher.WriteByte(0)
     } else {
      val6 := func(hasher *proptools.Hasher) error {
       return r.LinkDirsDeps[val3].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
       return err
      }
     }
    }
   } else {
    r.LinkDirsDeps[val3].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.RustLibObjects))
 for val7 := 0; val7 < len(r.RustLibObjects); val7++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.RustLibObjects[val7])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.StaticLibObjects))
 for val8 := 0; val8 < len(r.StaticLibObjects); val8++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.StaticLibObjects[val8])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.WholeStaticLibObjects))
 for val9 := 0; val9 < len(r.WholeStaticLibObjects); val9++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.WholeStaticLibObjects[val9])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.SharedLibPaths))
 for val10 := 0; val10 < len(r.SharedLibPaths); val10++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.SharedLibPaths[val10])
 }
 hasher.WriteString(":.[]cc.RustRlibDep")
 hasher.WriteInt(len(r.WholeRustRlibDeps))
 for val11 := 0; val11 < len(r.WholeRustRlibDeps); val11++ {
  if err := r.WholeRustRlibDeps[val11].CustomHash(hasher); err != nil {
   return err
  }
 }
 return nil
}

func (r *RustFlagExporterInfo) 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.Flags = make([]string, val2)
  for val3 := 0; val3 < int(val2); val3++ {
   err = gobtools.DecodeString(buf, &r.Flags[val3])
   if err != nil {
    return err
   }
  }
 }

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

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

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

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

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

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

 var val31 int
 err = gobtools.DecodeInt(buf, &val31)
 if err != nil {
  return err
 }
 if val31 != -1 {
  r.WholeRustRlibDeps = make([]cc.RustRlibDep, val31)
  for val32 := 0; val32 < int(val31); val32++ {
   if err = r.WholeRustRlibDeps[val32].Decode(ctx, buf); err != nil {
    return err
   }
  }
 }

 return err
}

var RustFlagExporterInfoGobRegId int16

func (r RustFlagExporterInfo) GetTypeId() int16 {
 return RustFlagExporterInfoGobRegId
}

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

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

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

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

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

func (r RustDepInSameApexChecker) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.RustDepInSameApexChecker")
 hasher.WriteInt(4)
 hasher.WriteString(":.bool")
 if r.Static {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.HasStubsVariants {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.ApexExclude {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.Host {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

 return err
}

var RustDepInSameApexCheckerGobRegId int16

func (r RustDepInSameApexChecker) GetTypeId() int16 {
 return RustDepInSameApexCheckerGobRegId
}

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

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

func (r RustImplementationDepInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":rust.RustImplementationDepInfo")
 hasher.WriteInt(1)
 val5 := func(hasher *proptools.Hasher, val1 android.Path) error {
  hasher.WriteString(":rust.android.Path")
  val2 := val1 == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(val1); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := val1 == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error { return val1.(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    val1.(proptools.CustomHash).CustomHash(hasher)
   }
  }
  return nil
 }
 if err := r.NonApexImplementationDeps.Hash(hasher, "android.Path", val5); err != nil {
  return err
 }
 return nil
}

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

 if err = r.NonApexImplementationDeps.DecodeInterface(ctx, buf); err != nil {
  return err
 }

 return err
}

var RustImplementationDepInfoGobRegId int16

func (r RustImplementationDepInfo) GetTypeId() int16 {
 return RustImplementationDepInfoGobRegId
}

// end of rust.go