Quelle  art_enc.go   Sprache: unbekannt

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

package art

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

// begin of art.go
func init() {
 testInstallInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(testInstallInfo) })
}

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

 if r.Testcases == nil {
  if err = gobtools.EncodeInt(buf, -1); err != nil {
   return err
  }
 } else {
  if err = gobtools.EncodeInt(buf, len(r.Testcases)); err != nil {
   return err
  }
  for val1, val2 := range r.Testcases {
   if err = gobtools.EncodeString(buf, val1); err != nil {
    return err
   }
   if err = gobtools.EncodeInterface(ctx, buf, val2); err != nil {
    return err
   }
  }
 }

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

func (r testInstallInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":art.testInstallInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.map[string]android.Path")
 hasher.WriteInt(len(r.Testcases))
 val1 := make([]string, 0, len(r.Testcases))
 for val3 := range r.Testcases {
  val1 = append(val1, val3)
 }
 proptools.SortOrdered(val1)
 for _, val2 := range val1 {
  hasher.WriteString(":.string")
  hasher.WriteString(val2)
  hasher.WriteString(":art.android.Path")
  val4 := r.Testcases[val2] == nil
  if val4 {
   hasher.WriteByte(0)
  } else {
   if v := reflect.ValueOf(r.Testcases[val2]); v.Kind() == reflect.Ptr {
    if v.IsNil() {
     panic(fmt.Errorf("nil pointer is not supported in interface"))
    } else {
     val5 := r.Testcases[val2] == nil
     if val5 {
      hasher.WriteByte(0)
     } else {
      val6 := func(hasher *proptools.Hasher) error {
       return r.Testcases[val2].(proptools.CustomHash).CustomHash(hasher)
      }
      if err := proptools.HashReference(hasher, uintptr(v.Pointer()), val6); err != nil {
       return err
      }
     }
    }
   } else {
    r.Testcases[val2].(proptools.CustomHash).CustomHash(hasher)
   }
  }
 }
 hasher.WriteString(":.map[string][]string")
 hasher.WriteInt(len(r.TestMap))
 val7 := make([]string, 0, len(r.TestMap))
 for val9 := range r.TestMap {
  val7 = append(val7, val9)
 }
 proptools.SortOrdered(val7)
 for _, val8 := range val7 {
  hasher.WriteString(":.string")
  hasher.WriteString(val8)
  hasher.WriteString(":.[]string")
  hasher.WriteInt(len(r.TestMap[val8]))
  for val10 := 0; val10 < len(r.TestMap[val8]); val10++ {
   hasher.WriteString(":.string")
   hasher.WriteString(r.TestMap[val8][val10])
  }
 }
 return nil
}

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

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

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

 return err
}

var testInstallInfoGobRegId int16

func (r testInstallInfo) GetTypeId() int16 {
 return testInstallInfoGobRegId
}

// end of art.go