Quelle  testsuites_enc.go   Sprache: unbekannt

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

package testsuites

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

// begin of test_suites.go
func init() {
 testSuiteConfigGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testSuiteConfig) })
 compatibilitySuitePackageInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(compatibilitySuitePackageInfo) })
}

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

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

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

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

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

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

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

func (r testSuiteConfig) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testsuites.testSuiteConfig")
 hasher.WriteInt(6)
 hasher.WriteString(":.string")
 hasher.WriteString(r.name)
 hasher.WriteString(":.bool")
 if r.buildHostSharedLibsZip {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.includeHostSharedLibsInMainZip {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.includeCommonHostSharedLibsSymlinksInMainZip {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":testsuites.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.hostJavaToolFiles))
 for val1 := 0; val1 < len(r.hostJavaToolFiles); val1++ {
  hasher.WriteString("android/soong/android:android.Path")
  val2 := r.hostJavaToolFiles[val1] == nil
  if val2 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.hostJavaToolFiles[val1]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val3 := r.hostJavaToolFiles[val1] == nil
     if val3 {
      hasher.WriteByte(0)
     } else {
      val4 := func(hasher *proptools.Hasher) error {
       return r.hostJavaToolFiles[val1].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val4); err != nil {
       return err
      }
     }
    }
   } else {
    r.hostJavaToolFiles[val1].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":testsuites.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.Art_data_zips))
 for val5 := 0; val5 < len(r.Art_data_zips); val5++ {
  hasher.WriteString("android/soong/android:android.Path")
  val6 := r.Art_data_zips[val5] == nil
  if val6 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.Art_data_zips[val5]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val7 := r.Art_data_zips[val5] == nil
     if val7 {
      hasher.WriteByte(0)
     } else {
      val8 := func(hasher *proptools.Hasher) error {
       return r.Art_data_zips[val5].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val8); err != nil {
       return err
      }
     }
    }
   } else {
    r.Art_data_zips[val5].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 return nil
}

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

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

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

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

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

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

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

 return err
}

var testSuiteConfigGobRegId int16

func (r testSuiteConfig) GetTypeId() int16 {
 return testSuiteConfigGobRegId
}

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

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

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

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

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

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

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

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

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

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

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

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

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

func (r compatibilitySuitePackageInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":testsuites.compatibilitySuitePackageInfo")
 hasher.WriteInt(12)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Name)
 hasher.WriteString(":testsuites.android.Path")
 val1 := r.Readme == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Readme); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.Readme == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.Readme.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.Readme.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":testsuites.android.Path")
 val4 := r.DynamicConfig == nil
 if val4 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.DynamicConfig); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val5 := r.DynamicConfig == nil
    if val5 {
     hasher.WriteByte(0)
    } else {
     val6 := func(hasher *proptools.Hasher) error { return r.DynamicConfig.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
      return err
     }
    }
   }
  } else {
   r.DynamicConfig.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":testsuites.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.ToolFiles))
 for val7 := 0; val7 < len(r.ToolFiles); val7++ {
  hasher.WriteString("android/soong/android:android.Path")
  val8 := r.ToolFiles[val7] == nil
  if val8 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.ToolFiles[val7]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val9 := r.ToolFiles[val7] == nil
     if val9 {
      hasher.WriteByte(0)
     } else {
      val10 := func(hasher *proptools.Hasher) error {
       return r.ToolFiles[val7].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val10); err != nil {
       return err
      }
     }
    }
   } else {
    r.ToolFiles[val7].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":testsuites.android.NoticeModuleInfos")
 hasher.WriteString(":.[]NoticeModuleInfo")
 hasher.WriteInt(len(r.ToolNoticeInfo))
 for val11 := 0; val11 < len(r.ToolNoticeInfo); val11++ {
  if err := r.ToolNoticeInfo[val11].CustomHash(hasher); err != nil {
   return err
  }
 }
 hasher.WriteString(":testsuites.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.HostSharedLibs))
 for val12 := 0; val12 < len(r.HostSharedLibs); val12++ {
  hasher.WriteString("android/soong/android:android.Path")
  val13 := r.HostSharedLibs[val12] == nil
  if val13 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.HostSharedLibs[val12]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val14 := r.HostSharedLibs[val12] == nil
     if val14 {
      hasher.WriteByte(0)
     } else {
      val15 := func(hasher *proptools.Hasher) error {
       return r.HostSharedLibs[val12].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val15); err != nil {
       return err
      }
     }
    }
   } else {
    r.HostSharedLibs[val12].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.bool")
 if r.BuildTestList {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.BuildMetadata {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.BuildSharedReport {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.NoDist {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.TestSuiteSubdir)
 hasher.WriteString(":testsuites.android.Path")
 val16 := r.Aliases == nil
 if val16 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Aliases); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val17 := r.Aliases == nil
    if val17 {
     hasher.WriteByte(0)
    } else {
     val18 := func(hasher *proptools.Hasher) error { return r.Aliases.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val18); err != nil {
      return err
     }
    }
   }
  } else {
   r.Aliases.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 return nil
}

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

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

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

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

 var val8 int
 err = gobtools.DecodeInt(buf, &val8)
 if err != nil {
  return err
 }
 if val8 != -1 {
  r.ToolFiles = 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 {
    r.ToolFiles[val9] = nil
   } else {
    r.ToolFiles[val9] = val11.(android.Path)
   }
  }
 }

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

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

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

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

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

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

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

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

 return err
}

var compatibilitySuitePackageInfoGobRegId int16

func (r compatibilitySuitePackageInfo) GetTypeId() int16 {
 return compatibilitySuitePackageInfoGobRegId
}

// end of test_suites.go