mirror of
https://github.com/containers/podman.git
synced 2025-12-03 03:39:44 +08:00
13f745092f
This vendor will improve the performance of using userns since it will save aside the image layer of the chown, so followup runnings of podman will use the new layer rather then chowning again. Signed-off-by: Daniel J Walsh <dwalsh@redhat.com> Closes: #881 Approved by: mheon
1933 lines
40 KiB
Go
1933 lines
40 KiB
Go
// Code generated by ffjson <https://github.com/pquerna/ffjson>. DO NOT EDIT.
|
|
// source: layers.go
|
|
|
|
package storage
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"github.com/containers/storage/pkg/archive"
|
|
"github.com/containers/storage/pkg/idtools"
|
|
"github.com/opencontainers/go-digest"
|
|
fflib "github.com/pquerna/ffjson/fflib/v1"
|
|
)
|
|
|
|
// MarshalJSON marshal bytes to json - template
|
|
func (j *DiffOptions) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := j.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// MarshalJSONBuf marshal buff to json - template
|
|
func (j *DiffOptions) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
if j.Compression != nil {
|
|
buf.WriteString(`{"Compression":`)
|
|
fflib.FormatBits2(buf, uint64(*j.Compression), 10, *j.Compression < 0)
|
|
} else {
|
|
buf.WriteString(`{"Compression":null`)
|
|
}
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffjtDiffOptionsbase = iota
|
|
ffjtDiffOptionsnosuchkey
|
|
|
|
ffjtDiffOptionsCompression
|
|
)
|
|
|
|
var ffjKeyDiffOptionsCompression = []byte("Compression")
|
|
|
|
// UnmarshalJSON umarshall json - template of ffjson
|
|
func (j *DiffOptions) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
|
|
func (j *DiffOptions) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error
|
|
currentKey := ffjtDiffOptionsbase
|
|
_ = currentKey
|
|
tok := fflib.FFTok_init
|
|
wantedTok := fflib.FFTok_init
|
|
|
|
mainparse:
|
|
for {
|
|
tok = fs.Scan()
|
|
// println(fmt.Sprintf("debug: tok: %v state: %v", tok, state))
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
|
|
switch state {
|
|
|
|
case fflib.FFParse_map_start:
|
|
if tok != fflib.FFTok_left_bracket {
|
|
wantedTok = fflib.FFTok_left_bracket
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_key
|
|
continue
|
|
|
|
case fflib.FFParse_after_value:
|
|
if tok == fflib.FFTok_comma {
|
|
state = fflib.FFParse_want_key
|
|
} else if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
} else {
|
|
wantedTok = fflib.FFTok_comma
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
case fflib.FFParse_want_key:
|
|
// json {} ended. goto exit. woo.
|
|
if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
}
|
|
if tok != fflib.FFTok_string {
|
|
wantedTok = fflib.FFTok_string
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
kn := fs.Output.Bytes()
|
|
if len(kn) <= 0 {
|
|
// "" case. hrm.
|
|
currentKey = ffjtDiffOptionsnosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'C':
|
|
|
|
if bytes.Equal(ffjKeyDiffOptionsCompression, kn) {
|
|
currentKey = ffjtDiffOptionsCompression
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyDiffOptionsCompression, kn) {
|
|
currentKey = ffjtDiffOptionsCompression
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffjtDiffOptionsnosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case fflib.FFParse_want_colon:
|
|
if tok != fflib.FFTok_colon {
|
|
wantedTok = fflib.FFTok_colon
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_value
|
|
continue
|
|
case fflib.FFParse_want_value:
|
|
|
|
if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
|
|
switch currentKey {
|
|
|
|
case ffjtDiffOptionsCompression:
|
|
goto handle_Compression
|
|
|
|
case ffjtDiffOptionsnosuchkey:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Compression:
|
|
|
|
/* handler: j.Compression type=archive.Compression kind=int quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Compression", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
j.Compression = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := archive.Compression(tval)
|
|
j.Compression = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
wantedvalue:
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
wrongtokenerror:
|
|
return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
|
|
tokerror:
|
|
if fs.BigError != nil {
|
|
return fs.WrapErr(fs.BigError)
|
|
}
|
|
err = fs.Error.ToError()
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
panic("ffjson-generated: unreachable, please report bug.")
|
|
done:
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON marshal bytes to json - template
|
|
func (j *Layer) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := j.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// MarshalJSONBuf marshal buff to json - template
|
|
func (j *Layer) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "id":`)
|
|
fflib.WriteJsonString(buf, string(j.ID))
|
|
buf.WriteByte(',')
|
|
if len(j.Names) != 0 {
|
|
buf.WriteString(`"names":`)
|
|
if j.Names != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range j.Names {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.Parent) != 0 {
|
|
buf.WriteString(`"parent":`)
|
|
fflib.WriteJsonString(buf, string(j.Parent))
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.Metadata) != 0 {
|
|
buf.WriteString(`"metadata":`)
|
|
fflib.WriteJsonString(buf, string(j.Metadata))
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.MountLabel) != 0 {
|
|
buf.WriteString(`"mountlabel":`)
|
|
fflib.WriteJsonString(buf, string(j.MountLabel))
|
|
buf.WriteByte(',')
|
|
}
|
|
if true {
|
|
buf.WriteString(`"created":`)
|
|
|
|
{
|
|
|
|
obj, err = j.Created.MarshalJSON()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
buf.Write(obj)
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.CompressedDigest) != 0 {
|
|
buf.WriteString(`"compressed-diff-digest":`)
|
|
fflib.WriteJsonString(buf, string(j.CompressedDigest))
|
|
buf.WriteByte(',')
|
|
}
|
|
if j.CompressedSize != 0 {
|
|
buf.WriteString(`"compressed-size":`)
|
|
fflib.FormatBits2(buf, uint64(j.CompressedSize), 10, j.CompressedSize < 0)
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.UncompressedDigest) != 0 {
|
|
buf.WriteString(`"diff-digest":`)
|
|
fflib.WriteJsonString(buf, string(j.UncompressedDigest))
|
|
buf.WriteByte(',')
|
|
}
|
|
if j.UncompressedSize != 0 {
|
|
buf.WriteString(`"diff-size":`)
|
|
fflib.FormatBits2(buf, uint64(j.UncompressedSize), 10, j.UncompressedSize < 0)
|
|
buf.WriteByte(',')
|
|
}
|
|
if j.CompressionType != 0 {
|
|
buf.WriteString(`"compression":`)
|
|
fflib.FormatBits2(buf, uint64(j.CompressionType), 10, j.CompressionType < 0)
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.Flags) != 0 {
|
|
buf.WriteString(`"flags":`)
|
|
/* Falling back. type=map[string]interface {} kind=map */
|
|
err = buf.Encode(j.Flags)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.UIDMap) != 0 {
|
|
buf.WriteString(`"uidmap":`)
|
|
if j.UIDMap != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range j.UIDMap {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
/* Struct fall back. type=idtools.IDMap kind=struct */
|
|
err = buf.Encode(&v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(j.GIDMap) != 0 {
|
|
buf.WriteString(`"gidmap":`)
|
|
if j.GIDMap != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range j.GIDMap {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
/* Struct fall back. type=idtools.IDMap kind=struct */
|
|
err = buf.Encode(&v)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffjtLayerbase = iota
|
|
ffjtLayernosuchkey
|
|
|
|
ffjtLayerID
|
|
|
|
ffjtLayerNames
|
|
|
|
ffjtLayerParent
|
|
|
|
ffjtLayerMetadata
|
|
|
|
ffjtLayerMountLabel
|
|
|
|
ffjtLayerCreated
|
|
|
|
ffjtLayerCompressedDigest
|
|
|
|
ffjtLayerCompressedSize
|
|
|
|
ffjtLayerUncompressedDigest
|
|
|
|
ffjtLayerUncompressedSize
|
|
|
|
ffjtLayerCompressionType
|
|
|
|
ffjtLayerFlags
|
|
|
|
ffjtLayerUIDMap
|
|
|
|
ffjtLayerGIDMap
|
|
)
|
|
|
|
var ffjKeyLayerID = []byte("id")
|
|
|
|
var ffjKeyLayerNames = []byte("names")
|
|
|
|
var ffjKeyLayerParent = []byte("parent")
|
|
|
|
var ffjKeyLayerMetadata = []byte("metadata")
|
|
|
|
var ffjKeyLayerMountLabel = []byte("mountlabel")
|
|
|
|
var ffjKeyLayerCreated = []byte("created")
|
|
|
|
var ffjKeyLayerCompressedDigest = []byte("compressed-diff-digest")
|
|
|
|
var ffjKeyLayerCompressedSize = []byte("compressed-size")
|
|
|
|
var ffjKeyLayerUncompressedDigest = []byte("diff-digest")
|
|
|
|
var ffjKeyLayerUncompressedSize = []byte("diff-size")
|
|
|
|
var ffjKeyLayerCompressionType = []byte("compression")
|
|
|
|
var ffjKeyLayerFlags = []byte("flags")
|
|
|
|
var ffjKeyLayerUIDMap = []byte("uidmap")
|
|
|
|
var ffjKeyLayerGIDMap = []byte("gidmap")
|
|
|
|
// UnmarshalJSON umarshall json - template of ffjson
|
|
func (j *Layer) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
|
|
func (j *Layer) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error
|
|
currentKey := ffjtLayerbase
|
|
_ = currentKey
|
|
tok := fflib.FFTok_init
|
|
wantedTok := fflib.FFTok_init
|
|
|
|
mainparse:
|
|
for {
|
|
tok = fs.Scan()
|
|
// println(fmt.Sprintf("debug: tok: %v state: %v", tok, state))
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
|
|
switch state {
|
|
|
|
case fflib.FFParse_map_start:
|
|
if tok != fflib.FFTok_left_bracket {
|
|
wantedTok = fflib.FFTok_left_bracket
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_key
|
|
continue
|
|
|
|
case fflib.FFParse_after_value:
|
|
if tok == fflib.FFTok_comma {
|
|
state = fflib.FFParse_want_key
|
|
} else if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
} else {
|
|
wantedTok = fflib.FFTok_comma
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
case fflib.FFParse_want_key:
|
|
// json {} ended. goto exit. woo.
|
|
if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
}
|
|
if tok != fflib.FFTok_string {
|
|
wantedTok = fflib.FFTok_string
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
kn := fs.Output.Bytes()
|
|
if len(kn) <= 0 {
|
|
// "" case. hrm.
|
|
currentKey = ffjtLayernosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffjKeyLayerCreated, kn) {
|
|
currentKey = ffjtLayerCreated
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffjKeyLayerCompressedDigest, kn) {
|
|
currentKey = ffjtLayerCompressedDigest
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffjKeyLayerCompressedSize, kn) {
|
|
currentKey = ffjtLayerCompressedSize
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffjKeyLayerCompressionType, kn) {
|
|
currentKey = ffjtLayerCompressionType
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'd':
|
|
|
|
if bytes.Equal(ffjKeyLayerUncompressedDigest, kn) {
|
|
currentKey = ffjtLayerUncompressedDigest
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffjKeyLayerUncompressedSize, kn) {
|
|
currentKey = ffjtLayerUncompressedSize
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'f':
|
|
|
|
if bytes.Equal(ffjKeyLayerFlags, kn) {
|
|
currentKey = ffjtLayerFlags
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'g':
|
|
|
|
if bytes.Equal(ffjKeyLayerGIDMap, kn) {
|
|
currentKey = ffjtLayerGIDMap
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'i':
|
|
|
|
if bytes.Equal(ffjKeyLayerID, kn) {
|
|
currentKey = ffjtLayerID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'm':
|
|
|
|
if bytes.Equal(ffjKeyLayerMetadata, kn) {
|
|
currentKey = ffjtLayerMetadata
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffjKeyLayerMountLabel, kn) {
|
|
currentKey = ffjtLayerMountLabel
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'n':
|
|
|
|
if bytes.Equal(ffjKeyLayerNames, kn) {
|
|
currentKey = ffjtLayerNames
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffjKeyLayerParent, kn) {
|
|
currentKey = ffjtLayerParent
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'u':
|
|
|
|
if bytes.Equal(ffjKeyLayerUIDMap, kn) {
|
|
currentKey = ffjtLayerUIDMap
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeyLayerGIDMap, kn) {
|
|
currentKey = ffjtLayerGIDMap
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeyLayerUIDMap, kn) {
|
|
currentKey = ffjtLayerUIDMap
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyLayerFlags, kn) {
|
|
currentKey = ffjtLayerFlags
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyLayerCompressionType, kn) {
|
|
currentKey = ffjtLayerCompressionType
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyLayerUncompressedSize, kn) {
|
|
currentKey = ffjtLayerUncompressedSize
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyLayerUncompressedDigest, kn) {
|
|
currentKey = ffjtLayerUncompressedDigest
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyLayerCompressedSize, kn) {
|
|
currentKey = ffjtLayerCompressedSize
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyLayerCompressedDigest, kn) {
|
|
currentKey = ffjtLayerCompressedDigest
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeyLayerCreated, kn) {
|
|
currentKey = ffjtLayerCreated
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeyLayerMountLabel, kn) {
|
|
currentKey = ffjtLayerMountLabel
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeyLayerMetadata, kn) {
|
|
currentKey = ffjtLayerMetadata
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeyLayerParent, kn) {
|
|
currentKey = ffjtLayerParent
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffjKeyLayerNames, kn) {
|
|
currentKey = ffjtLayerNames
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeyLayerID, kn) {
|
|
currentKey = ffjtLayerID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffjtLayernosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case fflib.FFParse_want_colon:
|
|
if tok != fflib.FFTok_colon {
|
|
wantedTok = fflib.FFTok_colon
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_value
|
|
continue
|
|
case fflib.FFParse_want_value:
|
|
|
|
if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
|
|
switch currentKey {
|
|
|
|
case ffjtLayerID:
|
|
goto handle_ID
|
|
|
|
case ffjtLayerNames:
|
|
goto handle_Names
|
|
|
|
case ffjtLayerParent:
|
|
goto handle_Parent
|
|
|
|
case ffjtLayerMetadata:
|
|
goto handle_Metadata
|
|
|
|
case ffjtLayerMountLabel:
|
|
goto handle_MountLabel
|
|
|
|
case ffjtLayerCreated:
|
|
goto handle_Created
|
|
|
|
case ffjtLayerCompressedDigest:
|
|
goto handle_CompressedDigest
|
|
|
|
case ffjtLayerCompressedSize:
|
|
goto handle_CompressedSize
|
|
|
|
case ffjtLayerUncompressedDigest:
|
|
goto handle_UncompressedDigest
|
|
|
|
case ffjtLayerUncompressedSize:
|
|
goto handle_UncompressedSize
|
|
|
|
case ffjtLayerCompressionType:
|
|
goto handle_CompressionType
|
|
|
|
case ffjtLayerFlags:
|
|
goto handle_Flags
|
|
|
|
case ffjtLayerUIDMap:
|
|
goto handle_UIDMap
|
|
|
|
case ffjtLayerGIDMap:
|
|
goto handle_GIDMap
|
|
|
|
case ffjtLayernosuchkey:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_ID:
|
|
|
|
/* handler: j.ID type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.ID = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Names:
|
|
|
|
/* handler: j.Names type=[]string kind=slice quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
j.Names = nil
|
|
} else {
|
|
|
|
j.Names = []string{}
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmpJNames string
|
|
|
|
tok = fs.Scan()
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
if tok == fflib.FFTok_right_brace {
|
|
break
|
|
}
|
|
|
|
if tok == fflib.FFTok_comma {
|
|
if wantVal == true {
|
|
// TODO(pquerna): this isn't an ideal error message, this handles
|
|
// things like [,,,] as an array value.
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
}
|
|
continue
|
|
} else {
|
|
wantVal = true
|
|
}
|
|
|
|
/* handler: tmpJNames type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tmpJNames = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
j.Names = append(j.Names, tmpJNames)
|
|
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Parent:
|
|
|
|
/* handler: j.Parent type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.Parent = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Metadata:
|
|
|
|
/* handler: j.Metadata type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.Metadata = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_MountLabel:
|
|
|
|
/* handler: j.MountLabel type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.MountLabel = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Created:
|
|
|
|
/* handler: j.Created type=time.Time kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tbuf, err := fs.CaptureField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
err = j.Created.UnmarshalJSON(tbuf)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_CompressedDigest:
|
|
|
|
/* handler: j.CompressedDigest type=digest.Digest kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Digest", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.CompressedDigest = digest.Digest(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_CompressedSize:
|
|
|
|
/* handler: j.CompressedSize type=int64 kind=int64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
j.CompressedSize = int64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_UncompressedDigest:
|
|
|
|
/* handler: j.UncompressedDigest type=digest.Digest kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Digest", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.UncompressedDigest = digest.Digest(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_UncompressedSize:
|
|
|
|
/* handler: j.UncompressedSize type=int64 kind=int64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
j.UncompressedSize = int64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_CompressionType:
|
|
|
|
/* handler: j.CompressionType type=archive.Compression kind=int quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for Compression", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
j.CompressionType = archive.Compression(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Flags:
|
|
|
|
/* handler: j.Flags type=map[string]interface {} kind=map quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_left_bracket && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
j.Flags = nil
|
|
} else {
|
|
|
|
j.Flags = make(map[string]interface{}, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var k string
|
|
|
|
var tmpJFlags interface{}
|
|
|
|
tok = fs.Scan()
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
if tok == fflib.FFTok_right_bracket {
|
|
break
|
|
}
|
|
|
|
if tok == fflib.FFTok_comma {
|
|
if wantVal == true {
|
|
// TODO(pquerna): this isn't an ideal error message, this handles
|
|
// things like [,,,] as an array value.
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
}
|
|
continue
|
|
} else {
|
|
wantVal = true
|
|
}
|
|
|
|
/* handler: k type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
k = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
// Expect ':' after key
|
|
tok = fs.Scan()
|
|
if tok != fflib.FFTok_colon {
|
|
return fs.WrapErr(fmt.Errorf("wanted colon token, but got token: %v", tok))
|
|
}
|
|
|
|
tok = fs.Scan()
|
|
/* handler: tmpJFlags type=interface {} kind=interface quoted=false*/
|
|
|
|
{
|
|
/* Falling back. type=interface {} kind=interface */
|
|
tbuf, err := fs.CaptureField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
err = json.Unmarshal(tbuf, &tmpJFlags)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
}
|
|
|
|
j.Flags[k] = tmpJFlags
|
|
|
|
wantVal = false
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_UIDMap:
|
|
|
|
/* handler: j.UIDMap type=[]idtools.IDMap kind=slice quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
j.UIDMap = nil
|
|
} else {
|
|
|
|
j.UIDMap = []idtools.IDMap{}
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmpJUIDMap idtools.IDMap
|
|
|
|
tok = fs.Scan()
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
if tok == fflib.FFTok_right_brace {
|
|
break
|
|
}
|
|
|
|
if tok == fflib.FFTok_comma {
|
|
if wantVal == true {
|
|
// TODO(pquerna): this isn't an ideal error message, this handles
|
|
// things like [,,,] as an array value.
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
}
|
|
continue
|
|
} else {
|
|
wantVal = true
|
|
}
|
|
|
|
/* handler: tmpJUIDMap type=idtools.IDMap kind=struct quoted=false*/
|
|
|
|
{
|
|
/* Falling back. type=idtools.IDMap kind=struct */
|
|
tbuf, err := fs.CaptureField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
err = json.Unmarshal(tbuf, &tmpJUIDMap)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
}
|
|
|
|
j.UIDMap = append(j.UIDMap, tmpJUIDMap)
|
|
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_GIDMap:
|
|
|
|
/* handler: j.GIDMap type=[]idtools.IDMap kind=slice quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_left_brace && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for ", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
j.GIDMap = nil
|
|
} else {
|
|
|
|
j.GIDMap = []idtools.IDMap{}
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmpJGIDMap idtools.IDMap
|
|
|
|
tok = fs.Scan()
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
if tok == fflib.FFTok_right_brace {
|
|
break
|
|
}
|
|
|
|
if tok == fflib.FFTok_comma {
|
|
if wantVal == true {
|
|
// TODO(pquerna): this isn't an ideal error message, this handles
|
|
// things like [,,,] as an array value.
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
}
|
|
continue
|
|
} else {
|
|
wantVal = true
|
|
}
|
|
|
|
/* handler: tmpJGIDMap type=idtools.IDMap kind=struct quoted=false*/
|
|
|
|
{
|
|
/* Falling back. type=idtools.IDMap kind=struct */
|
|
tbuf, err := fs.CaptureField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
err = json.Unmarshal(tbuf, &tmpJGIDMap)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
}
|
|
|
|
j.GIDMap = append(j.GIDMap, tmpJGIDMap)
|
|
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
wantedvalue:
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
wrongtokenerror:
|
|
return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
|
|
tokerror:
|
|
if fs.BigError != nil {
|
|
return fs.WrapErr(fs.BigError)
|
|
}
|
|
err = fs.Error.ToError()
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
panic("ffjson-generated: unreachable, please report bug.")
|
|
done:
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON marshal bytes to json - template
|
|
func (j *layerMountPoint) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := j.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// MarshalJSONBuf marshal buff to json - template
|
|
func (j *layerMountPoint) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"id":`)
|
|
fflib.WriteJsonString(buf, string(j.ID))
|
|
buf.WriteString(`,"path":`)
|
|
fflib.WriteJsonString(buf, string(j.MountPoint))
|
|
buf.WriteString(`,"count":`)
|
|
fflib.FormatBits2(buf, uint64(j.MountCount), 10, j.MountCount < 0)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffjtlayerMountPointbase = iota
|
|
ffjtlayerMountPointnosuchkey
|
|
|
|
ffjtlayerMountPointID
|
|
|
|
ffjtlayerMountPointMountPoint
|
|
|
|
ffjtlayerMountPointMountCount
|
|
)
|
|
|
|
var ffjKeylayerMountPointID = []byte("id")
|
|
|
|
var ffjKeylayerMountPointMountPoint = []byte("path")
|
|
|
|
var ffjKeylayerMountPointMountCount = []byte("count")
|
|
|
|
// UnmarshalJSON umarshall json - template of ffjson
|
|
func (j *layerMountPoint) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
|
|
func (j *layerMountPoint) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error
|
|
currentKey := ffjtlayerMountPointbase
|
|
_ = currentKey
|
|
tok := fflib.FFTok_init
|
|
wantedTok := fflib.FFTok_init
|
|
|
|
mainparse:
|
|
for {
|
|
tok = fs.Scan()
|
|
// println(fmt.Sprintf("debug: tok: %v state: %v", tok, state))
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
|
|
switch state {
|
|
|
|
case fflib.FFParse_map_start:
|
|
if tok != fflib.FFTok_left_bracket {
|
|
wantedTok = fflib.FFTok_left_bracket
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_key
|
|
continue
|
|
|
|
case fflib.FFParse_after_value:
|
|
if tok == fflib.FFTok_comma {
|
|
state = fflib.FFParse_want_key
|
|
} else if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
} else {
|
|
wantedTok = fflib.FFTok_comma
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
case fflib.FFParse_want_key:
|
|
// json {} ended. goto exit. woo.
|
|
if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
}
|
|
if tok != fflib.FFTok_string {
|
|
wantedTok = fflib.FFTok_string
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
kn := fs.Output.Bytes()
|
|
if len(kn) <= 0 {
|
|
// "" case. hrm.
|
|
currentKey = ffjtlayerMountPointnosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffjKeylayerMountPointMountCount, kn) {
|
|
currentKey = ffjtlayerMountPointMountCount
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'i':
|
|
|
|
if bytes.Equal(ffjKeylayerMountPointID, kn) {
|
|
currentKey = ffjtlayerMountPointID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffjKeylayerMountPointMountPoint, kn) {
|
|
currentKey = ffjtlayerMountPointMountPoint
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeylayerMountPointMountCount, kn) {
|
|
currentKey = ffjtlayerMountPointMountCount
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeylayerMountPointMountPoint, kn) {
|
|
currentKey = ffjtlayerMountPointMountPoint
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffjKeylayerMountPointID, kn) {
|
|
currentKey = ffjtlayerMountPointID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffjtlayerMountPointnosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case fflib.FFParse_want_colon:
|
|
if tok != fflib.FFTok_colon {
|
|
wantedTok = fflib.FFTok_colon
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_value
|
|
continue
|
|
case fflib.FFParse_want_value:
|
|
|
|
if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
|
|
switch currentKey {
|
|
|
|
case ffjtlayerMountPointID:
|
|
goto handle_ID
|
|
|
|
case ffjtlayerMountPointMountPoint:
|
|
goto handle_MountPoint
|
|
|
|
case ffjtlayerMountPointMountCount:
|
|
goto handle_MountCount
|
|
|
|
case ffjtlayerMountPointnosuchkey:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_ID:
|
|
|
|
/* handler: j.ID type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.ID = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_MountPoint:
|
|
|
|
/* handler: j.MountPoint type=string kind=string quoted=false*/
|
|
|
|
{
|
|
|
|
{
|
|
if tok != fflib.FFTok_string && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for string", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
j.MountPoint = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_MountCount:
|
|
|
|
/* handler: j.MountCount type=int kind=int quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for int", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
j.MountCount = int(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
wantedvalue:
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
wrongtokenerror:
|
|
return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
|
|
tokerror:
|
|
if fs.BigError != nil {
|
|
return fs.WrapErr(fs.BigError)
|
|
}
|
|
err = fs.Error.ToError()
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
panic("ffjson-generated: unreachable, please report bug.")
|
|
done:
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON marshal bytes to json - template
|
|
func (j *layerStore) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := j.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// MarshalJSONBuf marshal buff to json - template
|
|
func (j *layerStore) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{}`)
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffjtlayerStorebase = iota
|
|
ffjtlayerStorenosuchkey
|
|
)
|
|
|
|
// UnmarshalJSON umarshall json - template of ffjson
|
|
func (j *layerStore) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
|
|
func (j *layerStore) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error
|
|
currentKey := ffjtlayerStorebase
|
|
_ = currentKey
|
|
tok := fflib.FFTok_init
|
|
wantedTok := fflib.FFTok_init
|
|
|
|
mainparse:
|
|
for {
|
|
tok = fs.Scan()
|
|
// println(fmt.Sprintf("debug: tok: %v state: %v", tok, state))
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
|
|
switch state {
|
|
|
|
case fflib.FFParse_map_start:
|
|
if tok != fflib.FFTok_left_bracket {
|
|
wantedTok = fflib.FFTok_left_bracket
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_key
|
|
continue
|
|
|
|
case fflib.FFParse_after_value:
|
|
if tok == fflib.FFTok_comma {
|
|
state = fflib.FFParse_want_key
|
|
} else if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
} else {
|
|
wantedTok = fflib.FFTok_comma
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
case fflib.FFParse_want_key:
|
|
// json {} ended. goto exit. woo.
|
|
if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
}
|
|
if tok != fflib.FFTok_string {
|
|
wantedTok = fflib.FFTok_string
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
kn := fs.Output.Bytes()
|
|
if len(kn) <= 0 {
|
|
// "" case. hrm.
|
|
currentKey = ffjtlayerStorenosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
}
|
|
|
|
currentKey = ffjtlayerStorenosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case fflib.FFParse_want_colon:
|
|
if tok != fflib.FFTok_colon {
|
|
wantedTok = fflib.FFTok_colon
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_value
|
|
continue
|
|
case fflib.FFParse_want_value:
|
|
|
|
if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
|
|
switch currentKey {
|
|
|
|
case ffjtlayerStorenosuchkey:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
wantedvalue:
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
wrongtokenerror:
|
|
return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
|
|
tokerror:
|
|
if fs.BigError != nil {
|
|
return fs.WrapErr(fs.BigError)
|
|
}
|
|
err = fs.Error.ToError()
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
panic("ffjson-generated: unreachable, please report bug.")
|
|
done:
|
|
|
|
return nil
|
|
}
|
|
|
|
// MarshalJSON marshal bytes to json - template
|
|
func (j *simpleGetCloser) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := j.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
|
|
// MarshalJSONBuf marshal buff to json - template
|
|
func (j *simpleGetCloser) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if j == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{}`)
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffjtsimpleGetCloserbase = iota
|
|
ffjtsimpleGetClosernosuchkey
|
|
)
|
|
|
|
// UnmarshalJSON umarshall json - template of ffjson
|
|
func (j *simpleGetCloser) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return j.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
// UnmarshalJSONFFLexer fast json unmarshall - template ffjson
|
|
func (j *simpleGetCloser) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error
|
|
currentKey := ffjtsimpleGetCloserbase
|
|
_ = currentKey
|
|
tok := fflib.FFTok_init
|
|
wantedTok := fflib.FFTok_init
|
|
|
|
mainparse:
|
|
for {
|
|
tok = fs.Scan()
|
|
// println(fmt.Sprintf("debug: tok: %v state: %v", tok, state))
|
|
if tok == fflib.FFTok_error {
|
|
goto tokerror
|
|
}
|
|
|
|
switch state {
|
|
|
|
case fflib.FFParse_map_start:
|
|
if tok != fflib.FFTok_left_bracket {
|
|
wantedTok = fflib.FFTok_left_bracket
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_key
|
|
continue
|
|
|
|
case fflib.FFParse_after_value:
|
|
if tok == fflib.FFTok_comma {
|
|
state = fflib.FFParse_want_key
|
|
} else if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
} else {
|
|
wantedTok = fflib.FFTok_comma
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
case fflib.FFParse_want_key:
|
|
// json {} ended. goto exit. woo.
|
|
if tok == fflib.FFTok_right_bracket {
|
|
goto done
|
|
}
|
|
if tok != fflib.FFTok_string {
|
|
wantedTok = fflib.FFTok_string
|
|
goto wrongtokenerror
|
|
}
|
|
|
|
kn := fs.Output.Bytes()
|
|
if len(kn) <= 0 {
|
|
// "" case. hrm.
|
|
currentKey = ffjtsimpleGetClosernosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
}
|
|
|
|
currentKey = ffjtsimpleGetClosernosuchkey
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case fflib.FFParse_want_colon:
|
|
if tok != fflib.FFTok_colon {
|
|
wantedTok = fflib.FFTok_colon
|
|
goto wrongtokenerror
|
|
}
|
|
state = fflib.FFParse_want_value
|
|
continue
|
|
case fflib.FFParse_want_value:
|
|
|
|
if tok == fflib.FFTok_left_brace || tok == fflib.FFTok_left_bracket || tok == fflib.FFTok_integer || tok == fflib.FFTok_double || tok == fflib.FFTok_string || tok == fflib.FFTok_bool || tok == fflib.FFTok_null {
|
|
switch currentKey {
|
|
|
|
case ffjtsimpleGetClosernosuchkey:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
wantedvalue:
|
|
return fs.WrapErr(fmt.Errorf("wanted value token, but got token: %v", tok))
|
|
wrongtokenerror:
|
|
return fs.WrapErr(fmt.Errorf("ffjson: wanted token: %v, but got token: %v output=%s", wantedTok, tok, fs.Output.String()))
|
|
tokerror:
|
|
if fs.BigError != nil {
|
|
return fs.WrapErr(fs.BigError)
|
|
}
|
|
err = fs.Error.ToError()
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
panic("ffjson-generated: unreachable, please report bug.")
|
|
done:
|
|
|
|
return nil
|
|
}
|