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

package bootstrap

import (
 "bytes"
 "github.com/google/blueprint/gobtools"
 "github.com/google/blueprint/proptools"
)

// begin of bootstrap.go
func init() {
 PackageInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PackageInfo) })
 BinaryInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(BinaryInfo) })
 DocsPackageInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(DocsPackageInfo) })
 PrimaryBuilderInfoGobRegId = gobtools.RegisterType(func() gobtools.CustomDec { return new(PrimaryBuilderInfo) })
}

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

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

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

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

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

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

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

func (r PackageInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":bootstrap.PackageInfo")
 hasher.WriteInt(6)
 hasher.WriteString(":.string")
 hasher.WriteString(r.PkgPath)
 hasher.WriteString(":.string")
 hasher.WriteString(r.PkgRoot)
 hasher.WriteString(":.string")
 hasher.WriteString(r.PackageTarget)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.TestTargets))
 for val1 := 0; val1 < len(r.TestTargets); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.TestTargets[val1])
 }
 val3 := func(hasher *proptools.Hasher, val2 string) error {
  hasher.WriteString(":.string")
  hasher.WriteString(val2)
  return nil
 }
 if err := r.TransitivePkgRoot.Hash(hasher, "string", val3); err != nil {
  return err
 }
 val5 := func(hasher *proptools.Hasher, val4 string) error {
  hasher.WriteString(":.string")
  hasher.WriteString(val4)
  return nil
 }
 if err := r.TransitivePackageTarget.Hash(hasher, "string", val5); err != nil {
  return err
 }
 return nil
}

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

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

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

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

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

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

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

 return err
}

var PackageInfoGobRegId int16

func (r PackageInfo) GetTypeId() int16 {
 return PackageInfoGobRegId
}

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

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

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

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

func (r BinaryInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":bootstrap.BinaryInfo")
 hasher.WriteInt(3)
 hasher.WriteString(":.string")
 hasher.WriteString(r.IntermediatePath)
 hasher.WriteString(":.string")
 hasher.WriteString(r.InstallPath)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.TestTargets))
 for val1 := 0; val1 < len(r.TestTargets); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.TestTargets[val1])
 }
 return nil
}

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

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

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

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

 return err
}

var BinaryInfoGobRegId int16

func (r BinaryInfo) GetTypeId() int16 {
 return BinaryInfoGobRegId
}

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

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

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

func (r DocsPackageInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":bootstrap.DocsPackageInfo")
 hasher.WriteInt(2)
 hasher.WriteString(":.string")
 hasher.WriteString(r.PkgPath)
 hasher.WriteString(":.[]string")
 hasher.WriteInt(len(r.Srcs))
 for val1 := 0; val1 < len(r.Srcs); val1++ {
  hasher.WriteString(":.string")
  hasher.WriteString(r.Srcs[val1])
 }
 return nil
}

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

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

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

 return err
}

var DocsPackageInfoGobRegId int16

func (r DocsPackageInfo) GetTypeId() int16 {
 return DocsPackageInfoGobRegId
}

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

func (r PrimaryBuilderInfo) CustomHash(hasher *proptools.Hasher) error {
 hasher.WriteString(":bootstrap.PrimaryBuilderInfo")
 hasher.WriteInt(0)
 return nil
}

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

 return err
}

var PrimaryBuilderInfoGobRegId int16

func (r PrimaryBuilderInfo) GetTypeId() int16 {
 return PrimaryBuilderInfoGobRegId
}

// end of bootstrap.go