Quelle  fuzz_enc.go   Sprache: unbekannt

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

package fuzz

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

// begin of fuzz_common.go
func init() {
 FuzzConfigInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FuzzConfigInfo) })
 FuzzPackagedModuleInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(FuzzPackagedModuleInfo) })
}

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

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

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

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

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

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

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

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

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

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

func (r FuzzConfigInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":fuzz.FuzzConfigInfo")
 hasher.WriteInt(9)
 hasher.WriteString(":fuzz.Vector")
 hasher.WriteString(":.string")
 hasher.WriteString(string(r.Vector))
 hasher.WriteString(":fuzz.ServicePrivilege")
 hasher.WriteString(":.string")
 hasher.WriteString(string(r.ServicePrivilege))
 hasher.WriteString(":fuzz.UserData")
 hasher.WriteString(":.string")
 hasher.WriteString(string(r.Users))
 hasher.WriteString(":fuzz.FuzzedCodeUsage")
 hasher.WriteString(":.string")
 hasher.WriteString(string(r.FuzzedCodeUsage))
 hasher.WriteString(":fuzz.AutomaticallyRouteTo")
 hasher.WriteString(":.string")
 hasher.WriteString(string(r.AutomaticallyRouteTo))
 hasher.WriteString(":fuzz.UsePlatformLibs")
 hasher.WriteString(":.string")
 hasher.WriteString(string(r.UsePlatformLibs))
 hasher.WriteString(":.bool")
 if r.FuzzOnHaikuDevice {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.FuzzOnHaikuHost {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":.bool")
 if r.UseForPresubmit {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 return nil
}

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

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

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

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

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

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

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

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

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

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

 return err
}

var FuzzConfigInfoGobRegId int16

func (r FuzzConfigInfo) GetTypeId() int16 {
 return FuzzConfigInfoGobRegId
}

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

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

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

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

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

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

func (r FuzzPackagedModuleInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":fuzz.FuzzPackagedModuleInfo")
 hasher.WriteInt(5)
 hasher.WriteString(":.*FuzzConfigInfo")
 val1 := r.FuzzConfig == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  val2 := func(hasher *proptools.Hasher) error {
   if err := (*r.FuzzConfig).CustomHash(hasher); err != nil {
    return err
   }
   return nil
  }
  if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.FuzzConfig)), val2); err != nil {
   return err
  }
 }
 hasher.WriteString(":fuzz.android.Path")
 val3 := r.Dictionary == nil
 if val3 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Dictionary); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val4 := r.Dictionary == nil
    if val4 {
     hasher.WriteByte(0)
    } else {
     val5 := func(hasher *proptools.Hasher) error { return r.Dictionary.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val5); err != nil {
      return err
     }
    }
   }
  } else {
   r.Dictionary.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":fuzz.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.Corpus))
 for val6 := 0; val6 < len(r.Corpus); val6++ {
  hasher.WriteString("android/soong/android:android.Path")
  val7 := r.Corpus[val6] == nil
  if val7 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.Corpus[val6]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val8 := r.Corpus[val6] == nil
     if val8 {
      hasher.WriteByte(0)
     } else {
      val9 := func(hasher *proptools.Hasher) error { return r.Corpus[val6].(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val9); err != nil {
       return err
      }
     }
    }
   } else {
    r.Corpus[val6].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":fuzz.android.Path")
 val10 := r.Config == nil
 if val10 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Config); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val11 := r.Config == nil
    if val11 {
     hasher.WriteByte(0)
    } else {
     val12 := func(hasher *proptools.Hasher) error { return r.Config.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val12); err != nil {
      return err
     }
    }
   }
  } else {
   r.Config.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":fuzz.android.Paths")
 hasher.WriteString(":.[]Path")
 hasher.WriteInt(len(r.Data))
 for val13 := 0; val13 < len(r.Data); val13++ {
  hasher.WriteString("android/soong/android:android.Path")
  val14 := r.Data[val13] == nil
  if val14 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.Data[val13]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val15 := r.Data[val13] == nil
     if val15 {
      hasher.WriteByte(0)
     } else {
      val16 := func(hasher *proptools.Hasher) error { return r.Data[val13].(proptools.CustomHash).CustomHash(hasher) }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val16); err != nil {
       return err
      }
     }
    }
   } else {
    r.Data[val13].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 return nil
}

func (r *FuzzPackagedModuleInfo) 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 FuzzConfigInfo
  if err = val1.Decode(ctx, buf); err != nil {
   return err
  }
  r.FuzzConfig = &val1
 }

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

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

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

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

 return err
}

var FuzzPackagedModuleInfoGobRegId int16

func (r FuzzPackagedModuleInfo) GetTypeId() int16 {
 return FuzzPackagedModuleInfoGobRegId
}

// end of fuzz_common.go