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

package tradefed

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

// begin of providers.go
func init() {
 BaseTestProviderDataGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BaseTestProviderData) })
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r BaseTestProviderData) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":tradefed.BaseTestProviderData")
 hasher.WriteInt(13)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.TestcaseRelDataFiles))
 for val1 := 0; val1 < len(r.TestcaseRelDataFiles); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.TestcaseRelDataFiles[val1])
 }
 hasher.WriteString(":tradefed.android.Path")
 val2 := r.OutputFile == nil
 if val2 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.OutputFile); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val3 := r.OutputFile == nil
    if val3 {
     hasher.WriteByte(0)
    } else {
     val4 := func(hasher *proptools.Hasher) error { return r.OutputFile.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
      return err
     }
    }
   }
  } else {
   r.OutputFile.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":tradefed.android.Path")
 val5 := r.TestConfig == nil
 if val5 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.TestConfig); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val6 := r.TestConfig == nil
    if val6 {
     hasher.WriteByte(0)
    } else {
     val7 := func(hasher *proptools.Hasher) error { return r.TestConfig.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val7); err != nil {
      return err
     }
    }
   }
  } else {
   r.TestConfig.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.HostRequiredModuleNames))
 for val8 := 0; val8 < len(r.HostRequiredModuleNames); val8++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.HostRequiredModuleNames[val8])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.RequiredModuleNames))
 for val9 := 0; val9 < len(r.RequiredModuleNames); val9++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.RequiredModuleNames[val9])
 }
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.TestSuites))
 for val10 := 0; val10 < len(r.TestSuites); val10++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.TestSuites[val10])
 }
 hasher.WriteString(":.bool")
 if r.IsHost {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.LocalSdkVersion)
 hasher.WriteString(":.string")
 hasher.WriteString(r.LocalCertificate)
 hasher.WriteString(":.bool")
 if r.IsUnitTest {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.MkInclude)
 hasher.WriteString(":.string")
 hasher.WriteString(r.MkAppClass)
 if err := r.InstallDir.CustomHash(hasher); err != nil {
  return err
 }
 return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

 return err
}

var BaseTestProviderDataGobRegId int16

func (r BaseTestProviderData) GetTypeId() int16 {
 return BaseTestProviderDataGobRegId
}

// end of providers.go