Quelle  dexpreopt_enc.go   Sprache: unbekannt

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

package dexpreopt

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

// begin of class_loader_context.go
func init() {
 ClassLoaderContextGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(ClassLoaderContext) })
}

func (r ClassLoaderContext) 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.Optional); err != nil {
  return err
 }

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

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

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

func (r ClassLoaderContext) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":dexpreopt.ClassLoaderContext")
 hasher.WriteInt(5)
 hasher.WriteString(":.string")
 hasher.WriteString(r.Name)
 hasher.WriteString(":.bool")
 if r.Optional {
  hasher.WriteByte(1)
 } else {
  hasher.WriteByte(0)
 }
 hasher.WriteString(":dexpreopt.android.Path")
 val1 := r.Host == nil
 if val1 {
  hasher.WriteByte(0)
 } else {
  if v := reflect.ValueOf(r.Host); v.Kind() == reflect.Ptr {
   if v.IsNil() {
    panic(fmt.Errorf("nil pointer is not supported in interface"))
   } else {
    val2 := r.Host == nil
    if val2 {
     hasher.WriteByte(0)
    } else {
     val3 := func(hasher *proptools.Hasher) error { return r.Host.(proptools.CustomHash).CustomHash(hasher) }
     if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val3); err != nil {
      return err
     }
    }
   }
  } else {
   r.Host.(proptools.CustomHash).CustomHash(hasher)
  }
 }
 hasher.WriteString(":.string")
 hasher.WriteString(r.Device)
 hasher.WriteString(":.[]*ClassLoaderContext")
 hasher.WriteInt(len(r.Subcontexts))
 for val4 := 0; val4 < len(r.Subcontexts); val4++ {
  hasher.WriteString(":.*ClassLoaderContext")
  val5 := r.Subcontexts[val4] == nil
  if val5 {
   hasher.WriteByte(0)
  } else {
   val6 := func(hasher *proptools.Hasher) error {
    if err := (*r.Subcontexts[val4]).CustomHash(hasher); err != nil {
     return err
    }
    return nil
   }
   if err := proptools.HashReference(hasher, uintptr(unsafe.Pointer(r.Subcontexts[val4])), val6); err != nil {
    return err
   }
  }
 }
 return nil
}

func (r *ClassLoaderContext) 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.Optional)
 if err != nil {
  return err
 }

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

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

 var val7 int
 err = gobtools.DecodeInt(buf, &val7)
 if err != nil {
  return err
 }
 if val7 != -1 {
  r.Subcontexts = make([]*ClassLoaderContext, val7)
  for val8 := 0; val8 < int(val7); val8++ {
   var val10 bool
   if err = gobtools.DecodeBool(buf, &val10); err != nil {
    return err
   }
   if !val10 {
    var val9 ClassLoaderContext
    if err = val9.Decode(ctx, buf); err != nil {
     return err
    }
    r.Subcontexts[val8] = &val9
   }
  }
 }

 return err
}

var ClassLoaderContextGobRegId int16

func (r ClassLoaderContext) GetTypeId() int16 {
 return ClassLoaderContextGobRegId
}

// end of class_loader_context.go