12063 lines
245 KiB
Go
12063 lines
245 KiB
Go
// DO NOT EDIT!
|
|
// Code generated by ffjson <https://github.com/pquerna/ffjson>
|
|
// source: config.go
|
|
// DO NOT EDIT!
|
|
|
|
package specs
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
fflib "github.com/pquerna/ffjson/fflib/v1"
|
|
"os"
|
|
)
|
|
|
|
func (mj *Arg) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Arg) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"index":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Index), 10, false)
|
|
buf.WriteString(`,"value":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Value), 10, false)
|
|
buf.WriteString(`,"valueTwo":`)
|
|
fflib.FormatBits2(buf, uint64(mj.ValueTwo), 10, false)
|
|
buf.WriteString(`,"op":`)
|
|
fflib.WriteJsonString(buf, string(mj.Op))
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Argbase = iota
|
|
ffj_t_Argno_such_key
|
|
|
|
ffj_t_Arg_Index
|
|
|
|
ffj_t_Arg_Value
|
|
|
|
ffj_t_Arg_ValueTwo
|
|
|
|
ffj_t_Arg_Op
|
|
)
|
|
|
|
var ffj_key_Arg_Index = []byte("index")
|
|
|
|
var ffj_key_Arg_Value = []byte("value")
|
|
|
|
var ffj_key_Arg_ValueTwo = []byte("valueTwo")
|
|
|
|
var ffj_key_Arg_Op = []byte("op")
|
|
|
|
func (uj *Arg) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Arg) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Argbase
|
|
_ = 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 = ffj_t_Argno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'i':
|
|
|
|
if bytes.Equal(ffj_key_Arg_Index, kn) {
|
|
currentKey = ffj_t_Arg_Index
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'o':
|
|
|
|
if bytes.Equal(ffj_key_Arg_Op, kn) {
|
|
currentKey = ffj_t_Arg_Op
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'v':
|
|
|
|
if bytes.Equal(ffj_key_Arg_Value, kn) {
|
|
currentKey = ffj_t_Arg_Value
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Arg_ValueTwo, kn) {
|
|
currentKey = ffj_t_Arg_ValueTwo
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Arg_Op, kn) {
|
|
currentKey = ffj_t_Arg_Op
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Arg_ValueTwo, kn) {
|
|
currentKey = ffj_t_Arg_ValueTwo
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Arg_Value, kn) {
|
|
currentKey = ffj_t_Arg_Value
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Arg_Index, kn) {
|
|
currentKey = ffj_t_Arg_Index
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Argno_such_key
|
|
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 ffj_t_Arg_Index:
|
|
goto handle_Index
|
|
|
|
case ffj_t_Arg_Value:
|
|
goto handle_Value
|
|
|
|
case ffj_t_Arg_ValueTwo:
|
|
goto handle_ValueTwo
|
|
|
|
case ffj_t_Arg_Op:
|
|
goto handle_Op
|
|
|
|
case ffj_t_Argno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Index:
|
|
|
|
/* handler: uj.Index type=uint kind=uint quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.Index = uint(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Value:
|
|
|
|
/* handler: uj.Value type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.Value = uint64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_ValueTwo:
|
|
|
|
/* handler: uj.ValueTwo type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.ValueTwo = uint64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Op:
|
|
|
|
/* handler: uj.Op type=specs.Operator 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 Operator", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
uj.Op = Operator(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *BlockIO) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *BlockIO) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.Weight != nil {
|
|
if true {
|
|
buf.WriteString(`"blkioWeight":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Weight), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.LeafWeight != nil {
|
|
if true {
|
|
buf.WriteString(`"blkioLeafWeight":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.LeafWeight), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if len(mj.WeightDevice) != 0 {
|
|
buf.WriteString(`"blkioWeightDevice":`)
|
|
if mj.WeightDevice != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.WeightDevice {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.ThrottleReadBpsDevice) != 0 {
|
|
buf.WriteString(`"blkioThrottleReadBpsDevice":`)
|
|
if mj.ThrottleReadBpsDevice != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.ThrottleReadBpsDevice {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.ThrottleWriteBpsDevice) != 0 {
|
|
buf.WriteString(`"blkioThrottleWriteBpsDevice":`)
|
|
if mj.ThrottleWriteBpsDevice != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.ThrottleWriteBpsDevice {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.ThrottleReadIOPSDevice) != 0 {
|
|
buf.WriteString(`"blkioThrottleReadIOPSDevice":`)
|
|
if mj.ThrottleReadIOPSDevice != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.ThrottleReadIOPSDevice {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.ThrottleWriteIOPSDevice) != 0 {
|
|
buf.WriteString(`"blkioThrottleWriteIOPSDevice":`)
|
|
if mj.ThrottleWriteIOPSDevice != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.ThrottleWriteIOPSDevice {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_BlockIObase = iota
|
|
ffj_t_BlockIOno_such_key
|
|
|
|
ffj_t_BlockIO_Weight
|
|
|
|
ffj_t_BlockIO_LeafWeight
|
|
|
|
ffj_t_BlockIO_WeightDevice
|
|
|
|
ffj_t_BlockIO_ThrottleReadBpsDevice
|
|
|
|
ffj_t_BlockIO_ThrottleWriteBpsDevice
|
|
|
|
ffj_t_BlockIO_ThrottleReadIOPSDevice
|
|
|
|
ffj_t_BlockIO_ThrottleWriteIOPSDevice
|
|
)
|
|
|
|
var ffj_key_BlockIO_Weight = []byte("blkioWeight")
|
|
|
|
var ffj_key_BlockIO_LeafWeight = []byte("blkioLeafWeight")
|
|
|
|
var ffj_key_BlockIO_WeightDevice = []byte("blkioWeightDevice")
|
|
|
|
var ffj_key_BlockIO_ThrottleReadBpsDevice = []byte("blkioThrottleReadBpsDevice")
|
|
|
|
var ffj_key_BlockIO_ThrottleWriteBpsDevice = []byte("blkioThrottleWriteBpsDevice")
|
|
|
|
var ffj_key_BlockIO_ThrottleReadIOPSDevice = []byte("blkioThrottleReadIOPSDevice")
|
|
|
|
var ffj_key_BlockIO_ThrottleWriteIOPSDevice = []byte("blkioThrottleWriteIOPSDevice")
|
|
|
|
func (uj *BlockIO) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *BlockIO) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_BlockIObase
|
|
_ = 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 = ffj_t_BlockIOno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'b':
|
|
|
|
if bytes.Equal(ffj_key_BlockIO_Weight, kn) {
|
|
currentKey = ffj_t_BlockIO_Weight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_BlockIO_LeafWeight, kn) {
|
|
currentKey = ffj_t_BlockIO_LeafWeight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_BlockIO_WeightDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_WeightDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_BlockIO_ThrottleReadBpsDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleReadBpsDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_BlockIO_ThrottleWriteBpsDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleWriteBpsDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_BlockIO_ThrottleReadIOPSDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleReadIOPSDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_BlockIO_ThrottleWriteIOPSDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleWriteIOPSDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_BlockIO_ThrottleWriteIOPSDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleWriteIOPSDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_BlockIO_ThrottleReadIOPSDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleReadIOPSDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_BlockIO_ThrottleWriteBpsDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleWriteBpsDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_BlockIO_ThrottleReadBpsDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_ThrottleReadBpsDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_BlockIO_WeightDevice, kn) {
|
|
currentKey = ffj_t_BlockIO_WeightDevice
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_BlockIO_LeafWeight, kn) {
|
|
currentKey = ffj_t_BlockIO_LeafWeight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_BlockIO_Weight, kn) {
|
|
currentKey = ffj_t_BlockIO_Weight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_BlockIOno_such_key
|
|
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 ffj_t_BlockIO_Weight:
|
|
goto handle_Weight
|
|
|
|
case ffj_t_BlockIO_LeafWeight:
|
|
goto handle_LeafWeight
|
|
|
|
case ffj_t_BlockIO_WeightDevice:
|
|
goto handle_WeightDevice
|
|
|
|
case ffj_t_BlockIO_ThrottleReadBpsDevice:
|
|
goto handle_ThrottleReadBpsDevice
|
|
|
|
case ffj_t_BlockIO_ThrottleWriteBpsDevice:
|
|
goto handle_ThrottleWriteBpsDevice
|
|
|
|
case ffj_t_BlockIO_ThrottleReadIOPSDevice:
|
|
goto handle_ThrottleReadIOPSDevice
|
|
|
|
case ffj_t_BlockIO_ThrottleWriteIOPSDevice:
|
|
goto handle_ThrottleWriteIOPSDevice
|
|
|
|
case ffj_t_BlockIOno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Weight:
|
|
|
|
/* handler: uj.Weight type=uint16 kind=uint16 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint16", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Weight = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 16)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint16(tval)
|
|
uj.Weight = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_LeafWeight:
|
|
|
|
/* handler: uj.LeafWeight type=uint16 kind=uint16 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint16", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.LeafWeight = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 16)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint16(tval)
|
|
uj.LeafWeight = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_WeightDevice:
|
|
|
|
/* handler: uj.WeightDevice type=[]specs.WeightDevice 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 {
|
|
uj.WeightDevice = nil
|
|
} else {
|
|
|
|
uj.WeightDevice = make([]WeightDevice, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__WeightDevice WeightDevice
|
|
|
|
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: tmp_uj__WeightDevice type=specs.WeightDevice kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__WeightDevice.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.WeightDevice = append(uj.WeightDevice, tmp_uj__WeightDevice)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_ThrottleReadBpsDevice:
|
|
|
|
/* handler: uj.ThrottleReadBpsDevice type=[]specs.ThrottleDevice 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 {
|
|
uj.ThrottleReadBpsDevice = nil
|
|
} else {
|
|
|
|
uj.ThrottleReadBpsDevice = make([]ThrottleDevice, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__ThrottleReadBpsDevice ThrottleDevice
|
|
|
|
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: tmp_uj__ThrottleReadBpsDevice type=specs.ThrottleDevice kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__ThrottleReadBpsDevice.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.ThrottleReadBpsDevice = append(uj.ThrottleReadBpsDevice, tmp_uj__ThrottleReadBpsDevice)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_ThrottleWriteBpsDevice:
|
|
|
|
/* handler: uj.ThrottleWriteBpsDevice type=[]specs.ThrottleDevice 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 {
|
|
uj.ThrottleWriteBpsDevice = nil
|
|
} else {
|
|
|
|
uj.ThrottleWriteBpsDevice = make([]ThrottleDevice, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__ThrottleWriteBpsDevice ThrottleDevice
|
|
|
|
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: tmp_uj__ThrottleWriteBpsDevice type=specs.ThrottleDevice kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__ThrottleWriteBpsDevice.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.ThrottleWriteBpsDevice = append(uj.ThrottleWriteBpsDevice, tmp_uj__ThrottleWriteBpsDevice)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_ThrottleReadIOPSDevice:
|
|
|
|
/* handler: uj.ThrottleReadIOPSDevice type=[]specs.ThrottleDevice 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 {
|
|
uj.ThrottleReadIOPSDevice = nil
|
|
} else {
|
|
|
|
uj.ThrottleReadIOPSDevice = make([]ThrottleDevice, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__ThrottleReadIOPSDevice ThrottleDevice
|
|
|
|
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: tmp_uj__ThrottleReadIOPSDevice type=specs.ThrottleDevice kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__ThrottleReadIOPSDevice.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.ThrottleReadIOPSDevice = append(uj.ThrottleReadIOPSDevice, tmp_uj__ThrottleReadIOPSDevice)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_ThrottleWriteIOPSDevice:
|
|
|
|
/* handler: uj.ThrottleWriteIOPSDevice type=[]specs.ThrottleDevice 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 {
|
|
uj.ThrottleWriteIOPSDevice = nil
|
|
} else {
|
|
|
|
uj.ThrottleWriteIOPSDevice = make([]ThrottleDevice, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__ThrottleWriteIOPSDevice ThrottleDevice
|
|
|
|
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: tmp_uj__ThrottleWriteIOPSDevice type=specs.ThrottleDevice kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__ThrottleWriteIOPSDevice.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.ThrottleWriteIOPSDevice = append(uj.ThrottleWriteIOPSDevice, tmp_uj__ThrottleWriteIOPSDevice)
|
|
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
|
|
}
|
|
|
|
func (mj *CPU) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *CPU) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.Shares != nil {
|
|
if true {
|
|
buf.WriteString(`"shares":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Shares), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Quota != nil {
|
|
if true {
|
|
buf.WriteString(`"quota":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Quota), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Period != nil {
|
|
if true {
|
|
buf.WriteString(`"period":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Period), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.RealtimeRuntime != nil {
|
|
if true {
|
|
buf.WriteString(`"realtimeRuntime":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.RealtimeRuntime), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.RealtimePeriod != nil {
|
|
if true {
|
|
buf.WriteString(`"realtimePeriod":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.RealtimePeriod), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Cpus != nil {
|
|
if true {
|
|
buf.WriteString(`"cpus":`)
|
|
fflib.WriteJsonString(buf, string(*mj.Cpus))
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Mems != nil {
|
|
if true {
|
|
buf.WriteString(`"mems":`)
|
|
fflib.WriteJsonString(buf, string(*mj.Mems))
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_CPUbase = iota
|
|
ffj_t_CPUno_such_key
|
|
|
|
ffj_t_CPU_Shares
|
|
|
|
ffj_t_CPU_Quota
|
|
|
|
ffj_t_CPU_Period
|
|
|
|
ffj_t_CPU_RealtimeRuntime
|
|
|
|
ffj_t_CPU_RealtimePeriod
|
|
|
|
ffj_t_CPU_Cpus
|
|
|
|
ffj_t_CPU_Mems
|
|
)
|
|
|
|
var ffj_key_CPU_Shares = []byte("shares")
|
|
|
|
var ffj_key_CPU_Quota = []byte("quota")
|
|
|
|
var ffj_key_CPU_Period = []byte("period")
|
|
|
|
var ffj_key_CPU_RealtimeRuntime = []byte("realtimeRuntime")
|
|
|
|
var ffj_key_CPU_RealtimePeriod = []byte("realtimePeriod")
|
|
|
|
var ffj_key_CPU_Cpus = []byte("cpus")
|
|
|
|
var ffj_key_CPU_Mems = []byte("mems")
|
|
|
|
func (uj *CPU) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *CPU) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_CPUbase
|
|
_ = 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 = ffj_t_CPUno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffj_key_CPU_Cpus, kn) {
|
|
currentKey = ffj_t_CPU_Cpus
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'm':
|
|
|
|
if bytes.Equal(ffj_key_CPU_Mems, kn) {
|
|
currentKey = ffj_t_CPU_Mems
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_CPU_Period, kn) {
|
|
currentKey = ffj_t_CPU_Period
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'q':
|
|
|
|
if bytes.Equal(ffj_key_CPU_Quota, kn) {
|
|
currentKey = ffj_t_CPU_Quota
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'r':
|
|
|
|
if bytes.Equal(ffj_key_CPU_RealtimeRuntime, kn) {
|
|
currentKey = ffj_t_CPU_RealtimeRuntime
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_CPU_RealtimePeriod, kn) {
|
|
currentKey = ffj_t_CPU_RealtimePeriod
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_CPU_Shares, kn) {
|
|
currentKey = ffj_t_CPU_Shares
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_CPU_Mems, kn) {
|
|
currentKey = ffj_t_CPU_Mems
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_CPU_Cpus, kn) {
|
|
currentKey = ffj_t_CPU_Cpus
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_CPU_RealtimePeriod, kn) {
|
|
currentKey = ffj_t_CPU_RealtimePeriod
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_CPU_RealtimeRuntime, kn) {
|
|
currentKey = ffj_t_CPU_RealtimeRuntime
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_CPU_Period, kn) {
|
|
currentKey = ffj_t_CPU_Period
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_CPU_Quota, kn) {
|
|
currentKey = ffj_t_CPU_Quota
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_CPU_Shares, kn) {
|
|
currentKey = ffj_t_CPU_Shares
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_CPUno_such_key
|
|
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 ffj_t_CPU_Shares:
|
|
goto handle_Shares
|
|
|
|
case ffj_t_CPU_Quota:
|
|
goto handle_Quota
|
|
|
|
case ffj_t_CPU_Period:
|
|
goto handle_Period
|
|
|
|
case ffj_t_CPU_RealtimeRuntime:
|
|
goto handle_RealtimeRuntime
|
|
|
|
case ffj_t_CPU_RealtimePeriod:
|
|
goto handle_RealtimePeriod
|
|
|
|
case ffj_t_CPU_Cpus:
|
|
goto handle_Cpus
|
|
|
|
case ffj_t_CPU_Mems:
|
|
goto handle_Mems
|
|
|
|
case ffj_t_CPUno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Shares:
|
|
|
|
/* handler: uj.Shares type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Shares = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Shares = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Quota:
|
|
|
|
/* handler: uj.Quota type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Quota = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Quota = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Period:
|
|
|
|
/* handler: uj.Period type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Period = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Period = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_RealtimeRuntime:
|
|
|
|
/* handler: uj.RealtimeRuntime type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.RealtimeRuntime = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.RealtimeRuntime = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_RealtimePeriod:
|
|
|
|
/* handler: uj.RealtimePeriod type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.RealtimePeriod = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.RealtimePeriod = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Cpus:
|
|
|
|
/* handler: uj.Cpus 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 {
|
|
|
|
uj.Cpus = nil
|
|
|
|
} else {
|
|
|
|
var tval string
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tval = string(string(outBuf))
|
|
uj.Cpus = &tval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Mems:
|
|
|
|
/* handler: uj.Mems 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 {
|
|
|
|
uj.Mems = nil
|
|
|
|
} else {
|
|
|
|
var tval string
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tval = string(string(outBuf))
|
|
uj.Mems = &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
|
|
}
|
|
|
|
func (mj *Device) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Device) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "path":`)
|
|
fflib.WriteJsonString(buf, string(mj.Path))
|
|
buf.WriteString(`,"type":`)
|
|
fflib.WriteJsonString(buf, string(mj.Type))
|
|
buf.WriteString(`,"major":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Major), 10, mj.Major < 0)
|
|
buf.WriteString(`,"minor":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Minor), 10, mj.Minor < 0)
|
|
buf.WriteByte(',')
|
|
if mj.FileMode != nil {
|
|
if true {
|
|
buf.WriteString(`"fileMode":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.FileMode), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.UID != nil {
|
|
if true {
|
|
buf.WriteString(`"uid":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.UID), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.GID != nil {
|
|
if true {
|
|
buf.WriteString(`"gid":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.GID), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Devicebase = iota
|
|
ffj_t_Deviceno_such_key
|
|
|
|
ffj_t_Device_Path
|
|
|
|
ffj_t_Device_Type
|
|
|
|
ffj_t_Device_Major
|
|
|
|
ffj_t_Device_Minor
|
|
|
|
ffj_t_Device_FileMode
|
|
|
|
ffj_t_Device_UID
|
|
|
|
ffj_t_Device_GID
|
|
)
|
|
|
|
var ffj_key_Device_Path = []byte("path")
|
|
|
|
var ffj_key_Device_Type = []byte("type")
|
|
|
|
var ffj_key_Device_Major = []byte("major")
|
|
|
|
var ffj_key_Device_Minor = []byte("minor")
|
|
|
|
var ffj_key_Device_FileMode = []byte("fileMode")
|
|
|
|
var ffj_key_Device_UID = []byte("uid")
|
|
|
|
var ffj_key_Device_GID = []byte("gid")
|
|
|
|
func (uj *Device) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Device) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Devicebase
|
|
_ = 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 = ffj_t_Deviceno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'f':
|
|
|
|
if bytes.Equal(ffj_key_Device_FileMode, kn) {
|
|
currentKey = ffj_t_Device_FileMode
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'g':
|
|
|
|
if bytes.Equal(ffj_key_Device_GID, kn) {
|
|
currentKey = ffj_t_Device_GID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'm':
|
|
|
|
if bytes.Equal(ffj_key_Device_Major, kn) {
|
|
currentKey = ffj_t_Device_Major
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Device_Minor, kn) {
|
|
currentKey = ffj_t_Device_Minor
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Device_Path, kn) {
|
|
currentKey = ffj_t_Device_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 't':
|
|
|
|
if bytes.Equal(ffj_key_Device_Type, kn) {
|
|
currentKey = ffj_t_Device_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'u':
|
|
|
|
if bytes.Equal(ffj_key_Device_UID, kn) {
|
|
currentKey = ffj_t_Device_UID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Device_GID, kn) {
|
|
currentKey = ffj_t_Device_GID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Device_UID, kn) {
|
|
currentKey = ffj_t_Device_UID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Device_FileMode, kn) {
|
|
currentKey = ffj_t_Device_FileMode
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Device_Minor, kn) {
|
|
currentKey = ffj_t_Device_Minor
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Device_Major, kn) {
|
|
currentKey = ffj_t_Device_Major
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Device_Type, kn) {
|
|
currentKey = ffj_t_Device_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Device_Path, kn) {
|
|
currentKey = ffj_t_Device_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Deviceno_such_key
|
|
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 ffj_t_Device_Path:
|
|
goto handle_Path
|
|
|
|
case ffj_t_Device_Type:
|
|
goto handle_Type
|
|
|
|
case ffj_t_Device_Major:
|
|
goto handle_Major
|
|
|
|
case ffj_t_Device_Minor:
|
|
goto handle_Minor
|
|
|
|
case ffj_t_Device_FileMode:
|
|
goto handle_FileMode
|
|
|
|
case ffj_t_Device_UID:
|
|
goto handle_UID
|
|
|
|
case ffj_t_Device_GID:
|
|
goto handle_GID
|
|
|
|
case ffj_t_Deviceno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Path:
|
|
|
|
/* handler: uj.Path 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()
|
|
|
|
uj.Path = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Type:
|
|
|
|
/* handler: uj.Type 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()
|
|
|
|
uj.Type = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Major:
|
|
|
|
/* handler: uj.Major 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)
|
|
}
|
|
|
|
uj.Major = int64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Minor:
|
|
|
|
/* handler: uj.Minor 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)
|
|
}
|
|
|
|
uj.Minor = int64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_FileMode:
|
|
|
|
/* handler: uj.FileMode type=os.FileMode kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for FileMode", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.FileMode = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := os.FileMode(tval)
|
|
uj.FileMode = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_UID:
|
|
|
|
/* handler: uj.UID type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.UID = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint32(tval)
|
|
uj.UID = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_GID:
|
|
|
|
/* handler: uj.GID type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.GID = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint32(tval)
|
|
uj.GID = &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
|
|
}
|
|
|
|
func (mj *DeviceCgroup) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *DeviceCgroup) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
if mj.Allow {
|
|
buf.WriteString(`{ "allow":true`)
|
|
} else {
|
|
buf.WriteString(`{ "allow":false`)
|
|
}
|
|
buf.WriteByte(',')
|
|
if mj.Type != nil {
|
|
if true {
|
|
buf.WriteString(`"type":`)
|
|
fflib.WriteJsonString(buf, string(*mj.Type))
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Major != nil {
|
|
if true {
|
|
buf.WriteString(`"major":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Major), 10, *mj.Major < 0)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Minor != nil {
|
|
if true {
|
|
buf.WriteString(`"minor":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Minor), 10, *mj.Minor < 0)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Access != nil {
|
|
if true {
|
|
buf.WriteString(`"access":`)
|
|
fflib.WriteJsonString(buf, string(*mj.Access))
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_DeviceCgroupbase = iota
|
|
ffj_t_DeviceCgroupno_such_key
|
|
|
|
ffj_t_DeviceCgroup_Allow
|
|
|
|
ffj_t_DeviceCgroup_Type
|
|
|
|
ffj_t_DeviceCgroup_Major
|
|
|
|
ffj_t_DeviceCgroup_Minor
|
|
|
|
ffj_t_DeviceCgroup_Access
|
|
)
|
|
|
|
var ffj_key_DeviceCgroup_Allow = []byte("allow")
|
|
|
|
var ffj_key_DeviceCgroup_Type = []byte("type")
|
|
|
|
var ffj_key_DeviceCgroup_Major = []byte("major")
|
|
|
|
var ffj_key_DeviceCgroup_Minor = []byte("minor")
|
|
|
|
var ffj_key_DeviceCgroup_Access = []byte("access")
|
|
|
|
func (uj *DeviceCgroup) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *DeviceCgroup) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_DeviceCgroupbase
|
|
_ = 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 = ffj_t_DeviceCgroupno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_DeviceCgroup_Allow, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Allow
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_DeviceCgroup_Access, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Access
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'm':
|
|
|
|
if bytes.Equal(ffj_key_DeviceCgroup_Major, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Major
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_DeviceCgroup_Minor, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Minor
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 't':
|
|
|
|
if bytes.Equal(ffj_key_DeviceCgroup_Type, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_DeviceCgroup_Access, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Access
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_DeviceCgroup_Minor, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Minor
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_DeviceCgroup_Major, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Major
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_DeviceCgroup_Type, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_DeviceCgroup_Allow, kn) {
|
|
currentKey = ffj_t_DeviceCgroup_Allow
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_DeviceCgroupno_such_key
|
|
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 ffj_t_DeviceCgroup_Allow:
|
|
goto handle_Allow
|
|
|
|
case ffj_t_DeviceCgroup_Type:
|
|
goto handle_Type
|
|
|
|
case ffj_t_DeviceCgroup_Major:
|
|
goto handle_Major
|
|
|
|
case ffj_t_DeviceCgroup_Minor:
|
|
goto handle_Minor
|
|
|
|
case ffj_t_DeviceCgroup_Access:
|
|
goto handle_Access
|
|
|
|
case ffj_t_DeviceCgroupno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Allow:
|
|
|
|
/* handler: uj.Allow type=bool kind=bool quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_bool && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
tmpb := fs.Output.Bytes()
|
|
|
|
if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 {
|
|
|
|
uj.Allow = true
|
|
|
|
} else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 {
|
|
|
|
uj.Allow = false
|
|
|
|
} else {
|
|
err = errors.New("unexpected bytes for true/false value")
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Type:
|
|
|
|
/* handler: uj.Type 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 {
|
|
|
|
uj.Type = nil
|
|
|
|
} else {
|
|
|
|
var tval string
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tval = string(string(outBuf))
|
|
uj.Type = &tval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Major:
|
|
|
|
/* handler: uj.Major 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 {
|
|
|
|
uj.Major = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := int64(tval)
|
|
uj.Major = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Minor:
|
|
|
|
/* handler: uj.Minor 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 {
|
|
|
|
uj.Minor = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := int64(tval)
|
|
uj.Minor = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Access:
|
|
|
|
/* handler: uj.Access 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 {
|
|
|
|
uj.Access = nil
|
|
|
|
} else {
|
|
|
|
var tval string
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tval = string(string(outBuf))
|
|
uj.Access = &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
|
|
}
|
|
|
|
func (mj *Hook) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Hook) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "path":`)
|
|
fflib.WriteJsonString(buf, string(mj.Path))
|
|
buf.WriteByte(',')
|
|
if len(mj.Args) != 0 {
|
|
buf.WriteString(`"args":`)
|
|
if mj.Args != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Args {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.Env) != 0 {
|
|
buf.WriteString(`"env":`)
|
|
if mj.Env != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Env {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Hookbase = iota
|
|
ffj_t_Hookno_such_key
|
|
|
|
ffj_t_Hook_Path
|
|
|
|
ffj_t_Hook_Args
|
|
|
|
ffj_t_Hook_Env
|
|
)
|
|
|
|
var ffj_key_Hook_Path = []byte("path")
|
|
|
|
var ffj_key_Hook_Args = []byte("args")
|
|
|
|
var ffj_key_Hook_Env = []byte("env")
|
|
|
|
func (uj *Hook) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Hook) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Hookbase
|
|
_ = 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 = ffj_t_Hookno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_Hook_Args, kn) {
|
|
currentKey = ffj_t_Hook_Args
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'e':
|
|
|
|
if bytes.Equal(ffj_key_Hook_Env, kn) {
|
|
currentKey = ffj_t_Hook_Env
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Hook_Path, kn) {
|
|
currentKey = ffj_t_Hook_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Hook_Env, kn) {
|
|
currentKey = ffj_t_Hook_Env
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Hook_Args, kn) {
|
|
currentKey = ffj_t_Hook_Args
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Hook_Path, kn) {
|
|
currentKey = ffj_t_Hook_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Hookno_such_key
|
|
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 ffj_t_Hook_Path:
|
|
goto handle_Path
|
|
|
|
case ffj_t_Hook_Args:
|
|
goto handle_Args
|
|
|
|
case ffj_t_Hook_Env:
|
|
goto handle_Env
|
|
|
|
case ffj_t_Hookno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Path:
|
|
|
|
/* handler: uj.Path 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()
|
|
|
|
uj.Path = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Args:
|
|
|
|
/* handler: uj.Args 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 {
|
|
uj.Args = nil
|
|
} else {
|
|
|
|
uj.Args = make([]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Args 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: tmp_uj__Args 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()
|
|
|
|
tmp_uj__Args = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Args = append(uj.Args, tmp_uj__Args)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Env:
|
|
|
|
/* handler: uj.Env 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 {
|
|
uj.Env = nil
|
|
} else {
|
|
|
|
uj.Env = make([]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Env 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: tmp_uj__Env 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()
|
|
|
|
tmp_uj__Env = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Env = append(uj.Env, tmp_uj__Env)
|
|
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
|
|
}
|
|
|
|
func (mj *Hooks) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Hooks) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if len(mj.Prestart) != 0 {
|
|
buf.WriteString(`"prestart":`)
|
|
if mj.Prestart != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Prestart {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.Poststart) != 0 {
|
|
buf.WriteString(`"poststart":`)
|
|
if mj.Poststart != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Poststart {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.Poststop) != 0 {
|
|
buf.WriteString(`"poststop":`)
|
|
if mj.Poststop != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Poststop {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Hooksbase = iota
|
|
ffj_t_Hooksno_such_key
|
|
|
|
ffj_t_Hooks_Prestart
|
|
|
|
ffj_t_Hooks_Poststart
|
|
|
|
ffj_t_Hooks_Poststop
|
|
)
|
|
|
|
var ffj_key_Hooks_Prestart = []byte("prestart")
|
|
|
|
var ffj_key_Hooks_Poststart = []byte("poststart")
|
|
|
|
var ffj_key_Hooks_Poststop = []byte("poststop")
|
|
|
|
func (uj *Hooks) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Hooks) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Hooksbase
|
|
_ = 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 = ffj_t_Hooksno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Hooks_Prestart, kn) {
|
|
currentKey = ffj_t_Hooks_Prestart
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Hooks_Poststart, kn) {
|
|
currentKey = ffj_t_Hooks_Poststart
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Hooks_Poststop, kn) {
|
|
currentKey = ffj_t_Hooks_Poststop
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Hooks_Poststop, kn) {
|
|
currentKey = ffj_t_Hooks_Poststop
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Hooks_Poststart, kn) {
|
|
currentKey = ffj_t_Hooks_Poststart
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Hooks_Prestart, kn) {
|
|
currentKey = ffj_t_Hooks_Prestart
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Hooksno_such_key
|
|
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 ffj_t_Hooks_Prestart:
|
|
goto handle_Prestart
|
|
|
|
case ffj_t_Hooks_Poststart:
|
|
goto handle_Poststart
|
|
|
|
case ffj_t_Hooks_Poststop:
|
|
goto handle_Poststop
|
|
|
|
case ffj_t_Hooksno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Prestart:
|
|
|
|
/* handler: uj.Prestart type=[]specs.Hook 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 {
|
|
uj.Prestart = nil
|
|
} else {
|
|
|
|
uj.Prestart = make([]Hook, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Prestart Hook
|
|
|
|
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: tmp_uj__Prestart type=specs.Hook kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Prestart.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Prestart = append(uj.Prestart, tmp_uj__Prestart)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Poststart:
|
|
|
|
/* handler: uj.Poststart type=[]specs.Hook 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 {
|
|
uj.Poststart = nil
|
|
} else {
|
|
|
|
uj.Poststart = make([]Hook, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Poststart Hook
|
|
|
|
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: tmp_uj__Poststart type=specs.Hook kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Poststart.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Poststart = append(uj.Poststart, tmp_uj__Poststart)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Poststop:
|
|
|
|
/* handler: uj.Poststop type=[]specs.Hook 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 {
|
|
uj.Poststop = nil
|
|
} else {
|
|
|
|
uj.Poststop = make([]Hook, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Poststop Hook
|
|
|
|
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: tmp_uj__Poststop type=specs.Hook kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Poststop.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Poststop = append(uj.Poststop, tmp_uj__Poststop)
|
|
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
|
|
}
|
|
|
|
func (mj *HugepageLimit) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *HugepageLimit) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.Pagesize != nil {
|
|
if true {
|
|
buf.WriteString(`"pageSize":`)
|
|
fflib.WriteJsonString(buf, string(*mj.Pagesize))
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Limit != nil {
|
|
if true {
|
|
buf.WriteString(`"limit":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Limit), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_HugepageLimitbase = iota
|
|
ffj_t_HugepageLimitno_such_key
|
|
|
|
ffj_t_HugepageLimit_Pagesize
|
|
|
|
ffj_t_HugepageLimit_Limit
|
|
)
|
|
|
|
var ffj_key_HugepageLimit_Pagesize = []byte("pageSize")
|
|
|
|
var ffj_key_HugepageLimit_Limit = []byte("limit")
|
|
|
|
func (uj *HugepageLimit) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *HugepageLimit) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_HugepageLimitbase
|
|
_ = 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 = ffj_t_HugepageLimitno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'l':
|
|
|
|
if bytes.Equal(ffj_key_HugepageLimit_Limit, kn) {
|
|
currentKey = ffj_t_HugepageLimit_Limit
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_HugepageLimit_Pagesize, kn) {
|
|
currentKey = ffj_t_HugepageLimit_Pagesize
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_HugepageLimit_Limit, kn) {
|
|
currentKey = ffj_t_HugepageLimit_Limit
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_HugepageLimit_Pagesize, kn) {
|
|
currentKey = ffj_t_HugepageLimit_Pagesize
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_HugepageLimitno_such_key
|
|
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 ffj_t_HugepageLimit_Pagesize:
|
|
goto handle_Pagesize
|
|
|
|
case ffj_t_HugepageLimit_Limit:
|
|
goto handle_Limit
|
|
|
|
case ffj_t_HugepageLimitno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Pagesize:
|
|
|
|
/* handler: uj.Pagesize 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 {
|
|
|
|
uj.Pagesize = nil
|
|
|
|
} else {
|
|
|
|
var tval string
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tval = string(string(outBuf))
|
|
uj.Pagesize = &tval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Limit:
|
|
|
|
/* handler: uj.Limit type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Limit = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Limit = &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
|
|
}
|
|
|
|
func (mj *IDMapping) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *IDMapping) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"hostID":`)
|
|
fflib.FormatBits2(buf, uint64(mj.HostID), 10, false)
|
|
buf.WriteString(`,"containerID":`)
|
|
fflib.FormatBits2(buf, uint64(mj.ContainerID), 10, false)
|
|
buf.WriteString(`,"size":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Size), 10, false)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_IDMappingbase = iota
|
|
ffj_t_IDMappingno_such_key
|
|
|
|
ffj_t_IDMapping_HostID
|
|
|
|
ffj_t_IDMapping_ContainerID
|
|
|
|
ffj_t_IDMapping_Size
|
|
)
|
|
|
|
var ffj_key_IDMapping_HostID = []byte("hostID")
|
|
|
|
var ffj_key_IDMapping_ContainerID = []byte("containerID")
|
|
|
|
var ffj_key_IDMapping_Size = []byte("size")
|
|
|
|
func (uj *IDMapping) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *IDMapping) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_IDMappingbase
|
|
_ = 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 = ffj_t_IDMappingno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffj_key_IDMapping_ContainerID, kn) {
|
|
currentKey = ffj_t_IDMapping_ContainerID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'h':
|
|
|
|
if bytes.Equal(ffj_key_IDMapping_HostID, kn) {
|
|
currentKey = ffj_t_IDMapping_HostID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_IDMapping_Size, kn) {
|
|
currentKey = ffj_t_IDMapping_Size
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_IDMapping_Size, kn) {
|
|
currentKey = ffj_t_IDMapping_Size
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_IDMapping_ContainerID, kn) {
|
|
currentKey = ffj_t_IDMapping_ContainerID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_IDMapping_HostID, kn) {
|
|
currentKey = ffj_t_IDMapping_HostID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_IDMappingno_such_key
|
|
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 ffj_t_IDMapping_HostID:
|
|
goto handle_HostID
|
|
|
|
case ffj_t_IDMapping_ContainerID:
|
|
goto handle_ContainerID
|
|
|
|
case ffj_t_IDMapping_Size:
|
|
goto handle_Size
|
|
|
|
case ffj_t_IDMappingno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_HostID:
|
|
|
|
/* handler: uj.HostID type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.HostID = uint32(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_ContainerID:
|
|
|
|
/* handler: uj.ContainerID type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.ContainerID = uint32(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Size:
|
|
|
|
/* handler: uj.Size type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.Size = uint32(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
|
|
}
|
|
|
|
func (mj *InterfacePriority) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *InterfacePriority) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"name":`)
|
|
fflib.WriteJsonString(buf, string(mj.Name))
|
|
buf.WriteString(`,"priority":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Priority), 10, false)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_InterfacePrioritybase = iota
|
|
ffj_t_InterfacePriorityno_such_key
|
|
|
|
ffj_t_InterfacePriority_Name
|
|
|
|
ffj_t_InterfacePriority_Priority
|
|
)
|
|
|
|
var ffj_key_InterfacePriority_Name = []byte("name")
|
|
|
|
var ffj_key_InterfacePriority_Priority = []byte("priority")
|
|
|
|
func (uj *InterfacePriority) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *InterfacePriority) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_InterfacePrioritybase
|
|
_ = 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 = ffj_t_InterfacePriorityno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'n':
|
|
|
|
if bytes.Equal(ffj_key_InterfacePriority_Name, kn) {
|
|
currentKey = ffj_t_InterfacePriority_Name
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_InterfacePriority_Priority, kn) {
|
|
currentKey = ffj_t_InterfacePriority_Priority
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_InterfacePriority_Priority, kn) {
|
|
currentKey = ffj_t_InterfacePriority_Priority
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_InterfacePriority_Name, kn) {
|
|
currentKey = ffj_t_InterfacePriority_Name
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_InterfacePriorityno_such_key
|
|
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 ffj_t_InterfacePriority_Name:
|
|
goto handle_Name
|
|
|
|
case ffj_t_InterfacePriority_Priority:
|
|
goto handle_Priority
|
|
|
|
case ffj_t_InterfacePriorityno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Name:
|
|
|
|
/* handler: uj.Name 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()
|
|
|
|
uj.Name = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Priority:
|
|
|
|
/* handler: uj.Priority type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.Priority = uint32(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
|
|
}
|
|
|
|
func (mj *Linux) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Linux) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if len(mj.UIDMappings) != 0 {
|
|
buf.WriteString(`"uidMappings":`)
|
|
if mj.UIDMappings != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.UIDMappings {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.GIDMappings) != 0 {
|
|
buf.WriteString(`"gidMappings":`)
|
|
if mj.GIDMappings != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.GIDMappings {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.Sysctl) != 0 {
|
|
if mj.Sysctl == nil {
|
|
buf.WriteString(`"sysctl":null`)
|
|
} else {
|
|
buf.WriteString(`"sysctl":{ `)
|
|
for key, value := range mj.Sysctl {
|
|
fflib.WriteJsonString(buf, key)
|
|
buf.WriteString(`:`)
|
|
fflib.WriteJsonString(buf, string(value))
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if mj.Resources != nil {
|
|
if true {
|
|
buf.WriteString(`"resources":`)
|
|
|
|
{
|
|
|
|
err = mj.Resources.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.CgroupsPath != nil {
|
|
if true {
|
|
buf.WriteString(`"cgroupsPath":`)
|
|
fflib.WriteJsonString(buf, string(*mj.CgroupsPath))
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.WriteString(`"namespaces":`)
|
|
if mj.Namespaces != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Namespaces {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteString(`,"devices":`)
|
|
if mj.Devices != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Devices {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
if mj.Seccomp != nil {
|
|
if true {
|
|
buf.WriteString(`"seccomp":`)
|
|
|
|
{
|
|
|
|
err = mj.Seccomp.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if len(mj.RootfsPropagation) != 0 {
|
|
buf.WriteString(`"rootfsPropagation":`)
|
|
fflib.WriteJsonString(buf, string(mj.RootfsPropagation))
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Linuxbase = iota
|
|
ffj_t_Linuxno_such_key
|
|
|
|
ffj_t_Linux_UIDMappings
|
|
|
|
ffj_t_Linux_GIDMappings
|
|
|
|
ffj_t_Linux_Sysctl
|
|
|
|
ffj_t_Linux_Resources
|
|
|
|
ffj_t_Linux_CgroupsPath
|
|
|
|
ffj_t_Linux_Namespaces
|
|
|
|
ffj_t_Linux_Devices
|
|
|
|
ffj_t_Linux_Seccomp
|
|
|
|
ffj_t_Linux_RootfsPropagation
|
|
)
|
|
|
|
var ffj_key_Linux_UIDMappings = []byte("uidMappings")
|
|
|
|
var ffj_key_Linux_GIDMappings = []byte("gidMappings")
|
|
|
|
var ffj_key_Linux_Sysctl = []byte("sysctl")
|
|
|
|
var ffj_key_Linux_Resources = []byte("resources")
|
|
|
|
var ffj_key_Linux_CgroupsPath = []byte("cgroupsPath")
|
|
|
|
var ffj_key_Linux_Namespaces = []byte("namespaces")
|
|
|
|
var ffj_key_Linux_Devices = []byte("devices")
|
|
|
|
var ffj_key_Linux_Seccomp = []byte("seccomp")
|
|
|
|
var ffj_key_Linux_RootfsPropagation = []byte("rootfsPropagation")
|
|
|
|
func (uj *Linux) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Linux) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Linuxbase
|
|
_ = 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 = ffj_t_Linuxno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffj_key_Linux_CgroupsPath, kn) {
|
|
currentKey = ffj_t_Linux_CgroupsPath
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'd':
|
|
|
|
if bytes.Equal(ffj_key_Linux_Devices, kn) {
|
|
currentKey = ffj_t_Linux_Devices
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'g':
|
|
|
|
if bytes.Equal(ffj_key_Linux_GIDMappings, kn) {
|
|
currentKey = ffj_t_Linux_GIDMappings
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'n':
|
|
|
|
if bytes.Equal(ffj_key_Linux_Namespaces, kn) {
|
|
currentKey = ffj_t_Linux_Namespaces
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'r':
|
|
|
|
if bytes.Equal(ffj_key_Linux_Resources, kn) {
|
|
currentKey = ffj_t_Linux_Resources
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Linux_RootfsPropagation, kn) {
|
|
currentKey = ffj_t_Linux_RootfsPropagation
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_Linux_Sysctl, kn) {
|
|
currentKey = ffj_t_Linux_Sysctl
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Linux_Seccomp, kn) {
|
|
currentKey = ffj_t_Linux_Seccomp
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'u':
|
|
|
|
if bytes.Equal(ffj_key_Linux_UIDMappings, kn) {
|
|
currentKey = ffj_t_Linux_UIDMappings
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_RootfsPropagation, kn) {
|
|
currentKey = ffj_t_Linux_RootfsPropagation
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_Seccomp, kn) {
|
|
currentKey = ffj_t_Linux_Seccomp
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_Devices, kn) {
|
|
currentKey = ffj_t_Linux_Devices
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_Namespaces, kn) {
|
|
currentKey = ffj_t_Linux_Namespaces
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_CgroupsPath, kn) {
|
|
currentKey = ffj_t_Linux_CgroupsPath
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_Resources, kn) {
|
|
currentKey = ffj_t_Linux_Resources
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_Sysctl, kn) {
|
|
currentKey = ffj_t_Linux_Sysctl
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_GIDMappings, kn) {
|
|
currentKey = ffj_t_Linux_GIDMappings
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Linux_UIDMappings, kn) {
|
|
currentKey = ffj_t_Linux_UIDMappings
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Linuxno_such_key
|
|
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 ffj_t_Linux_UIDMappings:
|
|
goto handle_UIDMappings
|
|
|
|
case ffj_t_Linux_GIDMappings:
|
|
goto handle_GIDMappings
|
|
|
|
case ffj_t_Linux_Sysctl:
|
|
goto handle_Sysctl
|
|
|
|
case ffj_t_Linux_Resources:
|
|
goto handle_Resources
|
|
|
|
case ffj_t_Linux_CgroupsPath:
|
|
goto handle_CgroupsPath
|
|
|
|
case ffj_t_Linux_Namespaces:
|
|
goto handle_Namespaces
|
|
|
|
case ffj_t_Linux_Devices:
|
|
goto handle_Devices
|
|
|
|
case ffj_t_Linux_Seccomp:
|
|
goto handle_Seccomp
|
|
|
|
case ffj_t_Linux_RootfsPropagation:
|
|
goto handle_RootfsPropagation
|
|
|
|
case ffj_t_Linuxno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_UIDMappings:
|
|
|
|
/* handler: uj.UIDMappings type=[]specs.IDMapping 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 {
|
|
uj.UIDMappings = nil
|
|
} else {
|
|
|
|
uj.UIDMappings = make([]IDMapping, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__UIDMappings IDMapping
|
|
|
|
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: tmp_uj__UIDMappings type=specs.IDMapping kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__UIDMappings.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.UIDMappings = append(uj.UIDMappings, tmp_uj__UIDMappings)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_GIDMappings:
|
|
|
|
/* handler: uj.GIDMappings type=[]specs.IDMapping 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 {
|
|
uj.GIDMappings = nil
|
|
} else {
|
|
|
|
uj.GIDMappings = make([]IDMapping, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__GIDMappings IDMapping
|
|
|
|
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: tmp_uj__GIDMappings type=specs.IDMapping kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__GIDMappings.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.GIDMappings = append(uj.GIDMappings, tmp_uj__GIDMappings)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Sysctl:
|
|
|
|
/* handler: uj.Sysctl type=map[string]string 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 {
|
|
uj.Sysctl = nil
|
|
} else {
|
|
|
|
uj.Sysctl = make(map[string]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var k string
|
|
|
|
var tmp_uj__Sysctl string
|
|
|
|
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: tmp_uj__Sysctl 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()
|
|
|
|
tmp_uj__Sysctl = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Sysctl[k] = tmp_uj__Sysctl
|
|
|
|
wantVal = false
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Resources:
|
|
|
|
/* handler: uj.Resources type=specs.Resources kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Resources = nil
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
if uj.Resources == nil {
|
|
uj.Resources = new(Resources)
|
|
}
|
|
|
|
err = uj.Resources.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_CgroupsPath:
|
|
|
|
/* handler: uj.CgroupsPath 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 {
|
|
|
|
uj.CgroupsPath = nil
|
|
|
|
} else {
|
|
|
|
var tval string
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tval = string(string(outBuf))
|
|
uj.CgroupsPath = &tval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Namespaces:
|
|
|
|
/* handler: uj.Namespaces type=[]specs.Namespace 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 {
|
|
uj.Namespaces = nil
|
|
} else {
|
|
|
|
uj.Namespaces = make([]Namespace, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Namespaces Namespace
|
|
|
|
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: tmp_uj__Namespaces type=specs.Namespace kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Namespaces.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Namespaces = append(uj.Namespaces, tmp_uj__Namespaces)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Devices:
|
|
|
|
/* handler: uj.Devices type=[]specs.Device 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 {
|
|
uj.Devices = nil
|
|
} else {
|
|
|
|
uj.Devices = make([]Device, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Devices Device
|
|
|
|
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: tmp_uj__Devices type=specs.Device kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Devices.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Devices = append(uj.Devices, tmp_uj__Devices)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Seccomp:
|
|
|
|
/* handler: uj.Seccomp type=specs.Seccomp kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Seccomp = nil
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
if uj.Seccomp == nil {
|
|
uj.Seccomp = new(Seccomp)
|
|
}
|
|
|
|
err = uj.Seccomp.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_RootfsPropagation:
|
|
|
|
/* handler: uj.RootfsPropagation 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()
|
|
|
|
uj.RootfsPropagation = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *Memory) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Memory) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.Limit != nil {
|
|
if true {
|
|
buf.WriteString(`"limit":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Limit), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Reservation != nil {
|
|
if true {
|
|
buf.WriteString(`"reservation":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Reservation), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Swap != nil {
|
|
if true {
|
|
buf.WriteString(`"swap":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Swap), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Kernel != nil {
|
|
if true {
|
|
buf.WriteString(`"kernel":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Kernel), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.KernelTCP != nil {
|
|
buf.WriteString(`"kernelTCP":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.KernelTCP), 10, false)
|
|
} else {
|
|
buf.WriteString(`"kernelTCP":null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
if mj.Swappiness != nil {
|
|
if true {
|
|
buf.WriteString(`"swappiness":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Swappiness), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Memorybase = iota
|
|
ffj_t_Memoryno_such_key
|
|
|
|
ffj_t_Memory_Limit
|
|
|
|
ffj_t_Memory_Reservation
|
|
|
|
ffj_t_Memory_Swap
|
|
|
|
ffj_t_Memory_Kernel
|
|
|
|
ffj_t_Memory_KernelTCP
|
|
|
|
ffj_t_Memory_Swappiness
|
|
)
|
|
|
|
var ffj_key_Memory_Limit = []byte("limit")
|
|
|
|
var ffj_key_Memory_Reservation = []byte("reservation")
|
|
|
|
var ffj_key_Memory_Swap = []byte("swap")
|
|
|
|
var ffj_key_Memory_Kernel = []byte("kernel")
|
|
|
|
var ffj_key_Memory_KernelTCP = []byte("kernelTCP")
|
|
|
|
var ffj_key_Memory_Swappiness = []byte("swappiness")
|
|
|
|
func (uj *Memory) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Memory) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Memorybase
|
|
_ = 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 = ffj_t_Memoryno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'k':
|
|
|
|
if bytes.Equal(ffj_key_Memory_Kernel, kn) {
|
|
currentKey = ffj_t_Memory_Kernel
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Memory_KernelTCP, kn) {
|
|
currentKey = ffj_t_Memory_KernelTCP
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'l':
|
|
|
|
if bytes.Equal(ffj_key_Memory_Limit, kn) {
|
|
currentKey = ffj_t_Memory_Limit
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'r':
|
|
|
|
if bytes.Equal(ffj_key_Memory_Reservation, kn) {
|
|
currentKey = ffj_t_Memory_Reservation
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_Memory_Swap, kn) {
|
|
currentKey = ffj_t_Memory_Swap
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Memory_Swappiness, kn) {
|
|
currentKey = ffj_t_Memory_Swappiness
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Memory_Swappiness, kn) {
|
|
currentKey = ffj_t_Memory_Swappiness
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Memory_KernelTCP, kn) {
|
|
currentKey = ffj_t_Memory_KernelTCP
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Memory_Kernel, kn) {
|
|
currentKey = ffj_t_Memory_Kernel
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Memory_Swap, kn) {
|
|
currentKey = ffj_t_Memory_Swap
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Memory_Reservation, kn) {
|
|
currentKey = ffj_t_Memory_Reservation
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Memory_Limit, kn) {
|
|
currentKey = ffj_t_Memory_Limit
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Memoryno_such_key
|
|
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 ffj_t_Memory_Limit:
|
|
goto handle_Limit
|
|
|
|
case ffj_t_Memory_Reservation:
|
|
goto handle_Reservation
|
|
|
|
case ffj_t_Memory_Swap:
|
|
goto handle_Swap
|
|
|
|
case ffj_t_Memory_Kernel:
|
|
goto handle_Kernel
|
|
|
|
case ffj_t_Memory_KernelTCP:
|
|
goto handle_KernelTCP
|
|
|
|
case ffj_t_Memory_Swappiness:
|
|
goto handle_Swappiness
|
|
|
|
case ffj_t_Memoryno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Limit:
|
|
|
|
/* handler: uj.Limit type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Limit = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Limit = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Reservation:
|
|
|
|
/* handler: uj.Reservation type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Reservation = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Reservation = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Swap:
|
|
|
|
/* handler: uj.Swap type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Swap = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Swap = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Kernel:
|
|
|
|
/* handler: uj.Kernel type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Kernel = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Kernel = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_KernelTCP:
|
|
|
|
/* handler: uj.KernelTCP type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.KernelTCP = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.KernelTCP = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Swappiness:
|
|
|
|
/* handler: uj.Swappiness type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Swappiness = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Swappiness = &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
|
|
}
|
|
|
|
func (mj *Mount) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Mount) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "destination":`)
|
|
fflib.WriteJsonString(buf, string(mj.Destination))
|
|
buf.WriteString(`,"type":`)
|
|
fflib.WriteJsonString(buf, string(mj.Type))
|
|
buf.WriteString(`,"source":`)
|
|
fflib.WriteJsonString(buf, string(mj.Source))
|
|
buf.WriteByte(',')
|
|
if len(mj.Options) != 0 {
|
|
buf.WriteString(`"options":`)
|
|
if mj.Options != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Options {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Mountbase = iota
|
|
ffj_t_Mountno_such_key
|
|
|
|
ffj_t_Mount_Destination
|
|
|
|
ffj_t_Mount_Type
|
|
|
|
ffj_t_Mount_Source
|
|
|
|
ffj_t_Mount_Options
|
|
)
|
|
|
|
var ffj_key_Mount_Destination = []byte("destination")
|
|
|
|
var ffj_key_Mount_Type = []byte("type")
|
|
|
|
var ffj_key_Mount_Source = []byte("source")
|
|
|
|
var ffj_key_Mount_Options = []byte("options")
|
|
|
|
func (uj *Mount) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Mount) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Mountbase
|
|
_ = 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 = ffj_t_Mountno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'd':
|
|
|
|
if bytes.Equal(ffj_key_Mount_Destination, kn) {
|
|
currentKey = ffj_t_Mount_Destination
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'o':
|
|
|
|
if bytes.Equal(ffj_key_Mount_Options, kn) {
|
|
currentKey = ffj_t_Mount_Options
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_Mount_Source, kn) {
|
|
currentKey = ffj_t_Mount_Source
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 't':
|
|
|
|
if bytes.Equal(ffj_key_Mount_Type, kn) {
|
|
currentKey = ffj_t_Mount_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Mount_Options, kn) {
|
|
currentKey = ffj_t_Mount_Options
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Mount_Source, kn) {
|
|
currentKey = ffj_t_Mount_Source
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Mount_Type, kn) {
|
|
currentKey = ffj_t_Mount_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Mount_Destination, kn) {
|
|
currentKey = ffj_t_Mount_Destination
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Mountno_such_key
|
|
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 ffj_t_Mount_Destination:
|
|
goto handle_Destination
|
|
|
|
case ffj_t_Mount_Type:
|
|
goto handle_Type
|
|
|
|
case ffj_t_Mount_Source:
|
|
goto handle_Source
|
|
|
|
case ffj_t_Mount_Options:
|
|
goto handle_Options
|
|
|
|
case ffj_t_Mountno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Destination:
|
|
|
|
/* handler: uj.Destination 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()
|
|
|
|
uj.Destination = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Type:
|
|
|
|
/* handler: uj.Type 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()
|
|
|
|
uj.Type = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Source:
|
|
|
|
/* handler: uj.Source 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()
|
|
|
|
uj.Source = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Options:
|
|
|
|
/* handler: uj.Options 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 {
|
|
uj.Options = nil
|
|
} else {
|
|
|
|
uj.Options = make([]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Options 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: tmp_uj__Options 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()
|
|
|
|
tmp_uj__Options = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Options = append(uj.Options, tmp_uj__Options)
|
|
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
|
|
}
|
|
|
|
func (mj *Namespace) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Namespace) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "type":`)
|
|
fflib.WriteJsonString(buf, string(mj.Type))
|
|
buf.WriteByte(',')
|
|
if len(mj.Path) != 0 {
|
|
buf.WriteString(`"path":`)
|
|
fflib.WriteJsonString(buf, string(mj.Path))
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Namespacebase = iota
|
|
ffj_t_Namespaceno_such_key
|
|
|
|
ffj_t_Namespace_Type
|
|
|
|
ffj_t_Namespace_Path
|
|
)
|
|
|
|
var ffj_key_Namespace_Type = []byte("type")
|
|
|
|
var ffj_key_Namespace_Path = []byte("path")
|
|
|
|
func (uj *Namespace) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Namespace) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Namespacebase
|
|
_ = 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 = ffj_t_Namespaceno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Namespace_Path, kn) {
|
|
currentKey = ffj_t_Namespace_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 't':
|
|
|
|
if bytes.Equal(ffj_key_Namespace_Type, kn) {
|
|
currentKey = ffj_t_Namespace_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Namespace_Path, kn) {
|
|
currentKey = ffj_t_Namespace_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Namespace_Type, kn) {
|
|
currentKey = ffj_t_Namespace_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Namespaceno_such_key
|
|
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 ffj_t_Namespace_Type:
|
|
goto handle_Type
|
|
|
|
case ffj_t_Namespace_Path:
|
|
goto handle_Path
|
|
|
|
case ffj_t_Namespaceno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Type:
|
|
|
|
/* handler: uj.Type type=specs.NamespaceType 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 NamespaceType", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
uj.Type = NamespaceType(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Path:
|
|
|
|
/* handler: uj.Path 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()
|
|
|
|
uj.Path = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *Network) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Network) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
if mj.ClassID != nil {
|
|
buf.WriteString(`{ "classID":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.ClassID), 10, false)
|
|
} else {
|
|
buf.WriteString(`{ "classID":null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
if len(mj.Priorities) != 0 {
|
|
buf.WriteString(`"priorities":`)
|
|
if mj.Priorities != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Priorities {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Networkbase = iota
|
|
ffj_t_Networkno_such_key
|
|
|
|
ffj_t_Network_ClassID
|
|
|
|
ffj_t_Network_Priorities
|
|
)
|
|
|
|
var ffj_key_Network_ClassID = []byte("classID")
|
|
|
|
var ffj_key_Network_Priorities = []byte("priorities")
|
|
|
|
func (uj *Network) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Network) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Networkbase
|
|
_ = 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 = ffj_t_Networkno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffj_key_Network_ClassID, kn) {
|
|
currentKey = ffj_t_Network_ClassID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Network_Priorities, kn) {
|
|
currentKey = ffj_t_Network_Priorities
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Network_Priorities, kn) {
|
|
currentKey = ffj_t_Network_Priorities
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Network_ClassID, kn) {
|
|
currentKey = ffj_t_Network_ClassID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Networkno_such_key
|
|
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 ffj_t_Network_ClassID:
|
|
goto handle_ClassID
|
|
|
|
case ffj_t_Network_Priorities:
|
|
goto handle_Priorities
|
|
|
|
case ffj_t_Networkno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_ClassID:
|
|
|
|
/* handler: uj.ClassID type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.ClassID = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint32(tval)
|
|
uj.ClassID = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Priorities:
|
|
|
|
/* handler: uj.Priorities type=[]specs.InterfacePriority 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 {
|
|
uj.Priorities = nil
|
|
} else {
|
|
|
|
uj.Priorities = make([]InterfacePriority, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Priorities InterfacePriority
|
|
|
|
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: tmp_uj__Priorities type=specs.InterfacePriority kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Priorities.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Priorities = append(uj.Priorities, tmp_uj__Priorities)
|
|
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
|
|
}
|
|
|
|
func (mj *Pids) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Pids) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.Limit != nil {
|
|
if true {
|
|
buf.WriteString(`"limit":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Limit), 10, *mj.Limit < 0)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Pidsbase = iota
|
|
ffj_t_Pidsno_such_key
|
|
|
|
ffj_t_Pids_Limit
|
|
)
|
|
|
|
var ffj_key_Pids_Limit = []byte("limit")
|
|
|
|
func (uj *Pids) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Pids) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Pidsbase
|
|
_ = 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 = ffj_t_Pidsno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'l':
|
|
|
|
if bytes.Equal(ffj_key_Pids_Limit, kn) {
|
|
currentKey = ffj_t_Pids_Limit
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Pids_Limit, kn) {
|
|
currentKey = ffj_t_Pids_Limit
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Pidsno_such_key
|
|
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 ffj_t_Pids_Limit:
|
|
goto handle_Limit
|
|
|
|
case ffj_t_Pidsno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Limit:
|
|
|
|
/* handler: uj.Limit 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 {
|
|
|
|
uj.Limit = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := int64(tval)
|
|
uj.Limit = &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
|
|
}
|
|
|
|
func (mj *Platform) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Platform) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"os":`)
|
|
fflib.WriteJsonString(buf, string(mj.OS))
|
|
buf.WriteString(`,"arch":`)
|
|
fflib.WriteJsonString(buf, string(mj.Arch))
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Platformbase = iota
|
|
ffj_t_Platformno_such_key
|
|
|
|
ffj_t_Platform_OS
|
|
|
|
ffj_t_Platform_Arch
|
|
)
|
|
|
|
var ffj_key_Platform_OS = []byte("os")
|
|
|
|
var ffj_key_Platform_Arch = []byte("arch")
|
|
|
|
func (uj *Platform) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Platform) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Platformbase
|
|
_ = 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 = ffj_t_Platformno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_Platform_Arch, kn) {
|
|
currentKey = ffj_t_Platform_Arch
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'o':
|
|
|
|
if bytes.Equal(ffj_key_Platform_OS, kn) {
|
|
currentKey = ffj_t_Platform_OS
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Platform_Arch, kn) {
|
|
currentKey = ffj_t_Platform_Arch
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Platform_OS, kn) {
|
|
currentKey = ffj_t_Platform_OS
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Platformno_such_key
|
|
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 ffj_t_Platform_OS:
|
|
goto handle_OS
|
|
|
|
case ffj_t_Platform_Arch:
|
|
goto handle_Arch
|
|
|
|
case ffj_t_Platformno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_OS:
|
|
|
|
/* handler: uj.OS 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()
|
|
|
|
uj.OS = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Arch:
|
|
|
|
/* handler: uj.Arch 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()
|
|
|
|
uj.Arch = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *Process) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Process) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
if mj.Terminal {
|
|
buf.WriteString(`{ "terminal":true`)
|
|
} else {
|
|
buf.WriteString(`{ "terminal":false`)
|
|
}
|
|
buf.WriteString(`,"user":`)
|
|
|
|
{
|
|
|
|
err = mj.User.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteString(`,"args":`)
|
|
if mj.Args != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Args {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
if len(mj.Env) != 0 {
|
|
buf.WriteString(`"env":`)
|
|
if mj.Env != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Env {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.WriteString(`"cwd":`)
|
|
fflib.WriteJsonString(buf, string(mj.Cwd))
|
|
buf.WriteByte(',')
|
|
if len(mj.Capabilities) != 0 {
|
|
buf.WriteString(`"capabilities":`)
|
|
if mj.Capabilities != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Capabilities {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.Rlimits) != 0 {
|
|
buf.WriteString(`"rlimits":`)
|
|
if mj.Rlimits != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Rlimits {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if mj.NoNewPrivileges != false {
|
|
if mj.NoNewPrivileges {
|
|
buf.WriteString(`"noNewPrivileges":true`)
|
|
} else {
|
|
buf.WriteString(`"noNewPrivileges":false`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.ApparmorProfile) != 0 {
|
|
buf.WriteString(`"apparmorProfile":`)
|
|
fflib.WriteJsonString(buf, string(mj.ApparmorProfile))
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.SelinuxLabel) != 0 {
|
|
buf.WriteString(`"selinuxLabel":`)
|
|
fflib.WriteJsonString(buf, string(mj.SelinuxLabel))
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Processbase = iota
|
|
ffj_t_Processno_such_key
|
|
|
|
ffj_t_Process_Terminal
|
|
|
|
ffj_t_Process_User
|
|
|
|
ffj_t_Process_Args
|
|
|
|
ffj_t_Process_Env
|
|
|
|
ffj_t_Process_Cwd
|
|
|
|
ffj_t_Process_Capabilities
|
|
|
|
ffj_t_Process_Rlimits
|
|
|
|
ffj_t_Process_NoNewPrivileges
|
|
|
|
ffj_t_Process_ApparmorProfile
|
|
|
|
ffj_t_Process_SelinuxLabel
|
|
)
|
|
|
|
var ffj_key_Process_Terminal = []byte("terminal")
|
|
|
|
var ffj_key_Process_User = []byte("user")
|
|
|
|
var ffj_key_Process_Args = []byte("args")
|
|
|
|
var ffj_key_Process_Env = []byte("env")
|
|
|
|
var ffj_key_Process_Cwd = []byte("cwd")
|
|
|
|
var ffj_key_Process_Capabilities = []byte("capabilities")
|
|
|
|
var ffj_key_Process_Rlimits = []byte("rlimits")
|
|
|
|
var ffj_key_Process_NoNewPrivileges = []byte("noNewPrivileges")
|
|
|
|
var ffj_key_Process_ApparmorProfile = []byte("apparmorProfile")
|
|
|
|
var ffj_key_Process_SelinuxLabel = []byte("selinuxLabel")
|
|
|
|
func (uj *Process) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Process) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Processbase
|
|
_ = 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 = ffj_t_Processno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_Process_Args, kn) {
|
|
currentKey = ffj_t_Process_Args
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Process_ApparmorProfile, kn) {
|
|
currentKey = ffj_t_Process_ApparmorProfile
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffj_key_Process_Cwd, kn) {
|
|
currentKey = ffj_t_Process_Cwd
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Process_Capabilities, kn) {
|
|
currentKey = ffj_t_Process_Capabilities
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'e':
|
|
|
|
if bytes.Equal(ffj_key_Process_Env, kn) {
|
|
currentKey = ffj_t_Process_Env
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'n':
|
|
|
|
if bytes.Equal(ffj_key_Process_NoNewPrivileges, kn) {
|
|
currentKey = ffj_t_Process_NoNewPrivileges
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'r':
|
|
|
|
if bytes.Equal(ffj_key_Process_Rlimits, kn) {
|
|
currentKey = ffj_t_Process_Rlimits
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_Process_SelinuxLabel, kn) {
|
|
currentKey = ffj_t_Process_SelinuxLabel
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 't':
|
|
|
|
if bytes.Equal(ffj_key_Process_Terminal, kn) {
|
|
currentKey = ffj_t_Process_Terminal
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'u':
|
|
|
|
if bytes.Equal(ffj_key_Process_User, kn) {
|
|
currentKey = ffj_t_Process_User
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Process_SelinuxLabel, kn) {
|
|
currentKey = ffj_t_Process_SelinuxLabel
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Process_ApparmorProfile, kn) {
|
|
currentKey = ffj_t_Process_ApparmorProfile
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Process_NoNewPrivileges, kn) {
|
|
currentKey = ffj_t_Process_NoNewPrivileges
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Process_Rlimits, kn) {
|
|
currentKey = ffj_t_Process_Rlimits
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Process_Capabilities, kn) {
|
|
currentKey = ffj_t_Process_Capabilities
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Process_Cwd, kn) {
|
|
currentKey = ffj_t_Process_Cwd
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Process_Env, kn) {
|
|
currentKey = ffj_t_Process_Env
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Process_Args, kn) {
|
|
currentKey = ffj_t_Process_Args
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Process_User, kn) {
|
|
currentKey = ffj_t_Process_User
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Process_Terminal, kn) {
|
|
currentKey = ffj_t_Process_Terminal
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Processno_such_key
|
|
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 ffj_t_Process_Terminal:
|
|
goto handle_Terminal
|
|
|
|
case ffj_t_Process_User:
|
|
goto handle_User
|
|
|
|
case ffj_t_Process_Args:
|
|
goto handle_Args
|
|
|
|
case ffj_t_Process_Env:
|
|
goto handle_Env
|
|
|
|
case ffj_t_Process_Cwd:
|
|
goto handle_Cwd
|
|
|
|
case ffj_t_Process_Capabilities:
|
|
goto handle_Capabilities
|
|
|
|
case ffj_t_Process_Rlimits:
|
|
goto handle_Rlimits
|
|
|
|
case ffj_t_Process_NoNewPrivileges:
|
|
goto handle_NoNewPrivileges
|
|
|
|
case ffj_t_Process_ApparmorProfile:
|
|
goto handle_ApparmorProfile
|
|
|
|
case ffj_t_Process_SelinuxLabel:
|
|
goto handle_SelinuxLabel
|
|
|
|
case ffj_t_Processno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Terminal:
|
|
|
|
/* handler: uj.Terminal type=bool kind=bool quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_bool && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
tmpb := fs.Output.Bytes()
|
|
|
|
if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 {
|
|
|
|
uj.Terminal = true
|
|
|
|
} else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 {
|
|
|
|
uj.Terminal = false
|
|
|
|
} else {
|
|
err = errors.New("unexpected bytes for true/false value")
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_User:
|
|
|
|
/* handler: uj.User type=specs.User kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = uj.User.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Args:
|
|
|
|
/* handler: uj.Args 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 {
|
|
uj.Args = nil
|
|
} else {
|
|
|
|
uj.Args = make([]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Args 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: tmp_uj__Args 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()
|
|
|
|
tmp_uj__Args = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Args = append(uj.Args, tmp_uj__Args)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Env:
|
|
|
|
/* handler: uj.Env 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 {
|
|
uj.Env = nil
|
|
} else {
|
|
|
|
uj.Env = make([]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Env 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: tmp_uj__Env 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()
|
|
|
|
tmp_uj__Env = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Env = append(uj.Env, tmp_uj__Env)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Cwd:
|
|
|
|
/* handler: uj.Cwd 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()
|
|
|
|
uj.Cwd = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Capabilities:
|
|
|
|
/* handler: uj.Capabilities 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 {
|
|
uj.Capabilities = nil
|
|
} else {
|
|
|
|
uj.Capabilities = make([]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Capabilities 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: tmp_uj__Capabilities 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()
|
|
|
|
tmp_uj__Capabilities = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Capabilities = append(uj.Capabilities, tmp_uj__Capabilities)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Rlimits:
|
|
|
|
/* handler: uj.Rlimits type=[]specs.Rlimit 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 {
|
|
uj.Rlimits = nil
|
|
} else {
|
|
|
|
uj.Rlimits = make([]Rlimit, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Rlimits Rlimit
|
|
|
|
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: tmp_uj__Rlimits type=specs.Rlimit kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Rlimits.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Rlimits = append(uj.Rlimits, tmp_uj__Rlimits)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_NoNewPrivileges:
|
|
|
|
/* handler: uj.NoNewPrivileges type=bool kind=bool quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_bool && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
tmpb := fs.Output.Bytes()
|
|
|
|
if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 {
|
|
|
|
uj.NoNewPrivileges = true
|
|
|
|
} else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 {
|
|
|
|
uj.NoNewPrivileges = false
|
|
|
|
} else {
|
|
err = errors.New("unexpected bytes for true/false value")
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_ApparmorProfile:
|
|
|
|
/* handler: uj.ApparmorProfile 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()
|
|
|
|
uj.ApparmorProfile = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_SelinuxLabel:
|
|
|
|
/* handler: uj.SelinuxLabel 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()
|
|
|
|
uj.SelinuxLabel = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *Resources) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Resources) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "devices":`)
|
|
if mj.Devices != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Devices {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
if mj.DisableOOMKiller != nil {
|
|
if true {
|
|
if *mj.DisableOOMKiller {
|
|
buf.WriteString(`"disableOOMKiller":true`)
|
|
} else {
|
|
buf.WriteString(`"disableOOMKiller":false`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.OOMScoreAdj != nil {
|
|
if true {
|
|
buf.WriteString(`"oomScoreAdj":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.OOMScoreAdj), 10, *mj.OOMScoreAdj < 0)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Memory != nil {
|
|
if true {
|
|
buf.WriteString(`"memory":`)
|
|
|
|
{
|
|
|
|
err = mj.Memory.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.CPU != nil {
|
|
if true {
|
|
buf.WriteString(`"cpu":`)
|
|
|
|
{
|
|
|
|
err = mj.CPU.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.Pids != nil {
|
|
if true {
|
|
buf.WriteString(`"pids":`)
|
|
|
|
{
|
|
|
|
err = mj.Pids.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.BlockIO != nil {
|
|
if true {
|
|
buf.WriteString(`"blockIO":`)
|
|
|
|
{
|
|
|
|
err = mj.BlockIO.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if len(mj.HugepageLimits) != 0 {
|
|
buf.WriteString(`"hugepageLimits":`)
|
|
if mj.HugepageLimits != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.HugepageLimits {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
if mj.Network != nil {
|
|
if true {
|
|
buf.WriteString(`"network":`)
|
|
|
|
{
|
|
|
|
err = mj.Network.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Resourcesbase = iota
|
|
ffj_t_Resourcesno_such_key
|
|
|
|
ffj_t_Resources_Devices
|
|
|
|
ffj_t_Resources_DisableOOMKiller
|
|
|
|
ffj_t_Resources_OOMScoreAdj
|
|
|
|
ffj_t_Resources_Memory
|
|
|
|
ffj_t_Resources_CPU
|
|
|
|
ffj_t_Resources_Pids
|
|
|
|
ffj_t_Resources_BlockIO
|
|
|
|
ffj_t_Resources_HugepageLimits
|
|
|
|
ffj_t_Resources_Network
|
|
)
|
|
|
|
var ffj_key_Resources_Devices = []byte("devices")
|
|
|
|
var ffj_key_Resources_DisableOOMKiller = []byte("disableOOMKiller")
|
|
|
|
var ffj_key_Resources_OOMScoreAdj = []byte("oomScoreAdj")
|
|
|
|
var ffj_key_Resources_Memory = []byte("memory")
|
|
|
|
var ffj_key_Resources_CPU = []byte("cpu")
|
|
|
|
var ffj_key_Resources_Pids = []byte("pids")
|
|
|
|
var ffj_key_Resources_BlockIO = []byte("blockIO")
|
|
|
|
var ffj_key_Resources_HugepageLimits = []byte("hugepageLimits")
|
|
|
|
var ffj_key_Resources_Network = []byte("network")
|
|
|
|
func (uj *Resources) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Resources) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Resourcesbase
|
|
_ = 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 = ffj_t_Resourcesno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'b':
|
|
|
|
if bytes.Equal(ffj_key_Resources_BlockIO, kn) {
|
|
currentKey = ffj_t_Resources_BlockIO
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'c':
|
|
|
|
if bytes.Equal(ffj_key_Resources_CPU, kn) {
|
|
currentKey = ffj_t_Resources_CPU
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'd':
|
|
|
|
if bytes.Equal(ffj_key_Resources_Devices, kn) {
|
|
currentKey = ffj_t_Resources_Devices
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Resources_DisableOOMKiller, kn) {
|
|
currentKey = ffj_t_Resources_DisableOOMKiller
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'h':
|
|
|
|
if bytes.Equal(ffj_key_Resources_HugepageLimits, kn) {
|
|
currentKey = ffj_t_Resources_HugepageLimits
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'm':
|
|
|
|
if bytes.Equal(ffj_key_Resources_Memory, kn) {
|
|
currentKey = ffj_t_Resources_Memory
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'n':
|
|
|
|
if bytes.Equal(ffj_key_Resources_Network, kn) {
|
|
currentKey = ffj_t_Resources_Network
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'o':
|
|
|
|
if bytes.Equal(ffj_key_Resources_OOMScoreAdj, kn) {
|
|
currentKey = ffj_t_Resources_OOMScoreAdj
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Resources_Pids, kn) {
|
|
currentKey = ffj_t_Resources_Pids
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Resources_Network, kn) {
|
|
currentKey = ffj_t_Resources_Network
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Resources_HugepageLimits, kn) {
|
|
currentKey = ffj_t_Resources_HugepageLimits
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Resources_BlockIO, kn) {
|
|
currentKey = ffj_t_Resources_BlockIO
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Resources_Pids, kn) {
|
|
currentKey = ffj_t_Resources_Pids
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Resources_CPU, kn) {
|
|
currentKey = ffj_t_Resources_CPU
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Resources_Memory, kn) {
|
|
currentKey = ffj_t_Resources_Memory
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Resources_OOMScoreAdj, kn) {
|
|
currentKey = ffj_t_Resources_OOMScoreAdj
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Resources_DisableOOMKiller, kn) {
|
|
currentKey = ffj_t_Resources_DisableOOMKiller
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Resources_Devices, kn) {
|
|
currentKey = ffj_t_Resources_Devices
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Resourcesno_such_key
|
|
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 ffj_t_Resources_Devices:
|
|
goto handle_Devices
|
|
|
|
case ffj_t_Resources_DisableOOMKiller:
|
|
goto handle_DisableOOMKiller
|
|
|
|
case ffj_t_Resources_OOMScoreAdj:
|
|
goto handle_OOMScoreAdj
|
|
|
|
case ffj_t_Resources_Memory:
|
|
goto handle_Memory
|
|
|
|
case ffj_t_Resources_CPU:
|
|
goto handle_CPU
|
|
|
|
case ffj_t_Resources_Pids:
|
|
goto handle_Pids
|
|
|
|
case ffj_t_Resources_BlockIO:
|
|
goto handle_BlockIO
|
|
|
|
case ffj_t_Resources_HugepageLimits:
|
|
goto handle_HugepageLimits
|
|
|
|
case ffj_t_Resources_Network:
|
|
goto handle_Network
|
|
|
|
case ffj_t_Resourcesno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Devices:
|
|
|
|
/* handler: uj.Devices type=[]specs.DeviceCgroup 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 {
|
|
uj.Devices = nil
|
|
} else {
|
|
|
|
uj.Devices = make([]DeviceCgroup, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Devices DeviceCgroup
|
|
|
|
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: tmp_uj__Devices type=specs.DeviceCgroup kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Devices.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Devices = append(uj.Devices, tmp_uj__Devices)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_DisableOOMKiller:
|
|
|
|
/* handler: uj.DisableOOMKiller type=bool kind=bool quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_bool && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.DisableOOMKiller = nil
|
|
|
|
} else {
|
|
tmpb := fs.Output.Bytes()
|
|
|
|
var tval bool
|
|
|
|
if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 {
|
|
|
|
tval = true
|
|
|
|
} else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 {
|
|
|
|
tval = false
|
|
|
|
} else {
|
|
err = errors.New("unexpected bytes for true/false value")
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.DisableOOMKiller = &tval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_OOMScoreAdj:
|
|
|
|
/* handler: uj.OOMScoreAdj 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 {
|
|
|
|
uj.OOMScoreAdj = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseInt(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := int(tval)
|
|
uj.OOMScoreAdj = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Memory:
|
|
|
|
/* handler: uj.Memory type=specs.Memory kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Memory = nil
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
if uj.Memory == nil {
|
|
uj.Memory = new(Memory)
|
|
}
|
|
|
|
err = uj.Memory.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_CPU:
|
|
|
|
/* handler: uj.CPU type=specs.CPU kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.CPU = nil
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
if uj.CPU == nil {
|
|
uj.CPU = new(CPU)
|
|
}
|
|
|
|
err = uj.CPU.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Pids:
|
|
|
|
/* handler: uj.Pids type=specs.Pids kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Pids = nil
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
if uj.Pids == nil {
|
|
uj.Pids = new(Pids)
|
|
}
|
|
|
|
err = uj.Pids.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_BlockIO:
|
|
|
|
/* handler: uj.BlockIO type=specs.BlockIO kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.BlockIO = nil
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
if uj.BlockIO == nil {
|
|
uj.BlockIO = new(BlockIO)
|
|
}
|
|
|
|
err = uj.BlockIO.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_HugepageLimits:
|
|
|
|
/* handler: uj.HugepageLimits type=[]specs.HugepageLimit 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 {
|
|
uj.HugepageLimits = nil
|
|
} else {
|
|
|
|
uj.HugepageLimits = make([]HugepageLimit, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__HugepageLimits HugepageLimit
|
|
|
|
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: tmp_uj__HugepageLimits type=specs.HugepageLimit kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__HugepageLimits.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.HugepageLimits = append(uj.HugepageLimits, tmp_uj__HugepageLimits)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Network:
|
|
|
|
/* handler: uj.Network type=specs.Network kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Network = nil
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
if uj.Network == nil {
|
|
uj.Network = new(Network)
|
|
}
|
|
|
|
err = uj.Network.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *Rlimit) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Rlimit) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"type":`)
|
|
fflib.WriteJsonString(buf, string(mj.Type))
|
|
buf.WriteString(`,"hard":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Hard), 10, false)
|
|
buf.WriteString(`,"soft":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Soft), 10, false)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Rlimitbase = iota
|
|
ffj_t_Rlimitno_such_key
|
|
|
|
ffj_t_Rlimit_Type
|
|
|
|
ffj_t_Rlimit_Hard
|
|
|
|
ffj_t_Rlimit_Soft
|
|
)
|
|
|
|
var ffj_key_Rlimit_Type = []byte("type")
|
|
|
|
var ffj_key_Rlimit_Hard = []byte("hard")
|
|
|
|
var ffj_key_Rlimit_Soft = []byte("soft")
|
|
|
|
func (uj *Rlimit) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Rlimit) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Rlimitbase
|
|
_ = 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 = ffj_t_Rlimitno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'h':
|
|
|
|
if bytes.Equal(ffj_key_Rlimit_Hard, kn) {
|
|
currentKey = ffj_t_Rlimit_Hard
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_Rlimit_Soft, kn) {
|
|
currentKey = ffj_t_Rlimit_Soft
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 't':
|
|
|
|
if bytes.Equal(ffj_key_Rlimit_Type, kn) {
|
|
currentKey = ffj_t_Rlimit_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Rlimit_Soft, kn) {
|
|
currentKey = ffj_t_Rlimit_Soft
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Rlimit_Hard, kn) {
|
|
currentKey = ffj_t_Rlimit_Hard
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Rlimit_Type, kn) {
|
|
currentKey = ffj_t_Rlimit_Type
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Rlimitno_such_key
|
|
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 ffj_t_Rlimit_Type:
|
|
goto handle_Type
|
|
|
|
case ffj_t_Rlimit_Hard:
|
|
goto handle_Hard
|
|
|
|
case ffj_t_Rlimit_Soft:
|
|
goto handle_Soft
|
|
|
|
case ffj_t_Rlimitno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Type:
|
|
|
|
/* handler: uj.Type 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()
|
|
|
|
uj.Type = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Hard:
|
|
|
|
/* handler: uj.Hard type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.Hard = uint64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Soft:
|
|
|
|
/* handler: uj.Soft type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.Soft = uint64(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
|
|
}
|
|
|
|
func (mj *Root) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Root) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"path":`)
|
|
fflib.WriteJsonString(buf, string(mj.Path))
|
|
if mj.Readonly {
|
|
buf.WriteString(`,"readonly":true`)
|
|
} else {
|
|
buf.WriteString(`,"readonly":false`)
|
|
}
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Rootbase = iota
|
|
ffj_t_Rootno_such_key
|
|
|
|
ffj_t_Root_Path
|
|
|
|
ffj_t_Root_Readonly
|
|
)
|
|
|
|
var ffj_key_Root_Path = []byte("path")
|
|
|
|
var ffj_key_Root_Readonly = []byte("readonly")
|
|
|
|
func (uj *Root) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Root) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Rootbase
|
|
_ = 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 = ffj_t_Rootno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Root_Path, kn) {
|
|
currentKey = ffj_t_Root_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'r':
|
|
|
|
if bytes.Equal(ffj_key_Root_Readonly, kn) {
|
|
currentKey = ffj_t_Root_Readonly
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Root_Readonly, kn) {
|
|
currentKey = ffj_t_Root_Readonly
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Root_Path, kn) {
|
|
currentKey = ffj_t_Root_Path
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Rootno_such_key
|
|
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 ffj_t_Root_Path:
|
|
goto handle_Path
|
|
|
|
case ffj_t_Root_Readonly:
|
|
goto handle_Readonly
|
|
|
|
case ffj_t_Rootno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Path:
|
|
|
|
/* handler: uj.Path 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()
|
|
|
|
uj.Path = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Readonly:
|
|
|
|
/* handler: uj.Readonly type=bool kind=bool quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_bool && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for bool", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
tmpb := fs.Output.Bytes()
|
|
|
|
if bytes.Compare([]byte{'t', 'r', 'u', 'e'}, tmpb) == 0 {
|
|
|
|
uj.Readonly = true
|
|
|
|
} else if bytes.Compare([]byte{'f', 'a', 'l', 's', 'e'}, tmpb) == 0 {
|
|
|
|
uj.Readonly = false
|
|
|
|
} else {
|
|
err = errors.New("unexpected bytes for true/false value")
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *Seccomp) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Seccomp) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "defaultAction":`)
|
|
fflib.WriteJsonString(buf, string(mj.DefaultAction))
|
|
buf.WriteString(`,"architectures":`)
|
|
if mj.Architectures != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Architectures {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.WriteJsonString(buf, string(v))
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
if len(mj.Syscalls) != 0 {
|
|
buf.WriteString(`"syscalls":`)
|
|
if mj.Syscalls != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Syscalls {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Seccompbase = iota
|
|
ffj_t_Seccompno_such_key
|
|
|
|
ffj_t_Seccomp_DefaultAction
|
|
|
|
ffj_t_Seccomp_Architectures
|
|
|
|
ffj_t_Seccomp_Syscalls
|
|
)
|
|
|
|
var ffj_key_Seccomp_DefaultAction = []byte("defaultAction")
|
|
|
|
var ffj_key_Seccomp_Architectures = []byte("architectures")
|
|
|
|
var ffj_key_Seccomp_Syscalls = []byte("syscalls")
|
|
|
|
func (uj *Seccomp) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Seccomp) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Seccompbase
|
|
_ = 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 = ffj_t_Seccompno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_Seccomp_Architectures, kn) {
|
|
currentKey = ffj_t_Seccomp_Architectures
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'd':
|
|
|
|
if bytes.Equal(ffj_key_Seccomp_DefaultAction, kn) {
|
|
currentKey = ffj_t_Seccomp_DefaultAction
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 's':
|
|
|
|
if bytes.Equal(ffj_key_Seccomp_Syscalls, kn) {
|
|
currentKey = ffj_t_Seccomp_Syscalls
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Seccomp_Syscalls, kn) {
|
|
currentKey = ffj_t_Seccomp_Syscalls
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Seccomp_Architectures, kn) {
|
|
currentKey = ffj_t_Seccomp_Architectures
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Seccomp_DefaultAction, kn) {
|
|
currentKey = ffj_t_Seccomp_DefaultAction
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Seccompno_such_key
|
|
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 ffj_t_Seccomp_DefaultAction:
|
|
goto handle_DefaultAction
|
|
|
|
case ffj_t_Seccomp_Architectures:
|
|
goto handle_Architectures
|
|
|
|
case ffj_t_Seccomp_Syscalls:
|
|
goto handle_Syscalls
|
|
|
|
case ffj_t_Seccompno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_DefaultAction:
|
|
|
|
/* handler: uj.DefaultAction type=specs.Action 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 Action", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
uj.DefaultAction = Action(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Architectures:
|
|
|
|
/* handler: uj.Architectures type=[]specs.Arch 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 {
|
|
uj.Architectures = nil
|
|
} else {
|
|
|
|
uj.Architectures = make([]Arch, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Architectures Arch
|
|
|
|
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: tmp_uj__Architectures type=specs.Arch 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 Arch", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
tmp_uj__Architectures = Arch(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Architectures = append(uj.Architectures, tmp_uj__Architectures)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Syscalls:
|
|
|
|
/* handler: uj.Syscalls type=[]specs.Syscall 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 {
|
|
uj.Syscalls = nil
|
|
} else {
|
|
|
|
uj.Syscalls = make([]Syscall, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Syscalls Syscall
|
|
|
|
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: tmp_uj__Syscalls type=specs.Syscall kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Syscalls.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Syscalls = append(uj.Syscalls, tmp_uj__Syscalls)
|
|
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
|
|
}
|
|
|
|
func (mj *Spec) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Spec) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"ociVersion":`)
|
|
fflib.WriteJsonString(buf, string(mj.Version))
|
|
buf.WriteString(`,"platform":`)
|
|
|
|
{
|
|
|
|
err = mj.Platform.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteString(`,"process":`)
|
|
|
|
{
|
|
|
|
err = mj.Process.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteString(`,"root":`)
|
|
|
|
{
|
|
|
|
err = mj.Root.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
if len(mj.Hostname) != 0 {
|
|
buf.WriteString(`"hostname":`)
|
|
fflib.WriteJsonString(buf, string(mj.Hostname))
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.WriteString(`"mounts":`)
|
|
if mj.Mounts != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Mounts {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteString(`,"hooks":`)
|
|
|
|
{
|
|
|
|
err = mj.Hooks.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte(',')
|
|
if len(mj.Annotations) != 0 {
|
|
if mj.Annotations == nil {
|
|
buf.WriteString(`"annotations":null`)
|
|
} else {
|
|
buf.WriteString(`"annotations":{ `)
|
|
for key, value := range mj.Annotations {
|
|
fflib.WriteJsonString(buf, key)
|
|
buf.WriteString(`:`)
|
|
fflib.WriteJsonString(buf, string(value))
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.WriteString(`"linux":`)
|
|
|
|
{
|
|
|
|
err = mj.Linux.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Specbase = iota
|
|
ffj_t_Specno_such_key
|
|
|
|
ffj_t_Spec_Version
|
|
|
|
ffj_t_Spec_Platform
|
|
|
|
ffj_t_Spec_Process
|
|
|
|
ffj_t_Spec_Root
|
|
|
|
ffj_t_Spec_Hostname
|
|
|
|
ffj_t_Spec_Mounts
|
|
|
|
ffj_t_Spec_Hooks
|
|
|
|
ffj_t_Spec_Annotations
|
|
|
|
ffj_t_Spec_Linux
|
|
)
|
|
|
|
var ffj_key_Spec_Version = []byte("ociVersion")
|
|
|
|
var ffj_key_Spec_Platform = []byte("platform")
|
|
|
|
var ffj_key_Spec_Process = []byte("process")
|
|
|
|
var ffj_key_Spec_Root = []byte("root")
|
|
|
|
var ffj_key_Spec_Hostname = []byte("hostname")
|
|
|
|
var ffj_key_Spec_Mounts = []byte("mounts")
|
|
|
|
var ffj_key_Spec_Hooks = []byte("hooks")
|
|
|
|
var ffj_key_Spec_Annotations = []byte("annotations")
|
|
|
|
var ffj_key_Spec_Linux = []byte("linux")
|
|
|
|
func (uj *Spec) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Spec) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Specbase
|
|
_ = 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 = ffj_t_Specno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_Spec_Annotations, kn) {
|
|
currentKey = ffj_t_Spec_Annotations
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'h':
|
|
|
|
if bytes.Equal(ffj_key_Spec_Hostname, kn) {
|
|
currentKey = ffj_t_Spec_Hostname
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Spec_Hooks, kn) {
|
|
currentKey = ffj_t_Spec_Hooks
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'l':
|
|
|
|
if bytes.Equal(ffj_key_Spec_Linux, kn) {
|
|
currentKey = ffj_t_Spec_Linux
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'm':
|
|
|
|
if bytes.Equal(ffj_key_Spec_Mounts, kn) {
|
|
currentKey = ffj_t_Spec_Mounts
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'o':
|
|
|
|
if bytes.Equal(ffj_key_Spec_Version, kn) {
|
|
currentKey = ffj_t_Spec_Version
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'p':
|
|
|
|
if bytes.Equal(ffj_key_Spec_Platform, kn) {
|
|
currentKey = ffj_t_Spec_Platform
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Spec_Process, kn) {
|
|
currentKey = ffj_t_Spec_Process
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'r':
|
|
|
|
if bytes.Equal(ffj_key_Spec_Root, kn) {
|
|
currentKey = ffj_t_Spec_Root
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Spec_Linux, kn) {
|
|
currentKey = ffj_t_Spec_Linux
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Spec_Annotations, kn) {
|
|
currentKey = ffj_t_Spec_Annotations
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Spec_Hooks, kn) {
|
|
currentKey = ffj_t_Spec_Hooks
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Spec_Mounts, kn) {
|
|
currentKey = ffj_t_Spec_Mounts
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Spec_Hostname, kn) {
|
|
currentKey = ffj_t_Spec_Hostname
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Spec_Root, kn) {
|
|
currentKey = ffj_t_Spec_Root
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Spec_Process, kn) {
|
|
currentKey = ffj_t_Spec_Process
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Spec_Platform, kn) {
|
|
currentKey = ffj_t_Spec_Platform
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Spec_Version, kn) {
|
|
currentKey = ffj_t_Spec_Version
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Specno_such_key
|
|
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 ffj_t_Spec_Version:
|
|
goto handle_Version
|
|
|
|
case ffj_t_Spec_Platform:
|
|
goto handle_Platform
|
|
|
|
case ffj_t_Spec_Process:
|
|
goto handle_Process
|
|
|
|
case ffj_t_Spec_Root:
|
|
goto handle_Root
|
|
|
|
case ffj_t_Spec_Hostname:
|
|
goto handle_Hostname
|
|
|
|
case ffj_t_Spec_Mounts:
|
|
goto handle_Mounts
|
|
|
|
case ffj_t_Spec_Hooks:
|
|
goto handle_Hooks
|
|
|
|
case ffj_t_Spec_Annotations:
|
|
goto handle_Annotations
|
|
|
|
case ffj_t_Spec_Linux:
|
|
goto handle_Linux
|
|
|
|
case ffj_t_Specno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Version:
|
|
|
|
/* handler: uj.Version 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()
|
|
|
|
uj.Version = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Platform:
|
|
|
|
/* handler: uj.Platform type=specs.Platform kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = uj.Platform.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Process:
|
|
|
|
/* handler: uj.Process type=specs.Process kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = uj.Process.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Root:
|
|
|
|
/* handler: uj.Root type=specs.Root kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = uj.Root.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Hostname:
|
|
|
|
/* handler: uj.Hostname 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()
|
|
|
|
uj.Hostname = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Mounts:
|
|
|
|
/* handler: uj.Mounts type=[]specs.Mount 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 {
|
|
uj.Mounts = nil
|
|
} else {
|
|
|
|
uj.Mounts = make([]Mount, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Mounts Mount
|
|
|
|
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: tmp_uj__Mounts type=specs.Mount kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Mounts.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Mounts = append(uj.Mounts, tmp_uj__Mounts)
|
|
wantVal = false
|
|
}
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Hooks:
|
|
|
|
/* handler: uj.Hooks type=specs.Hooks kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = uj.Hooks.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Annotations:
|
|
|
|
/* handler: uj.Annotations type=map[string]string 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 {
|
|
uj.Annotations = nil
|
|
} else {
|
|
|
|
uj.Annotations = make(map[string]string, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var k string
|
|
|
|
var tmp_uj__Annotations string
|
|
|
|
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: tmp_uj__Annotations 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()
|
|
|
|
tmp_uj__Annotations = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
uj.Annotations[k] = tmp_uj__Annotations
|
|
|
|
wantVal = false
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Linux:
|
|
|
|
/* handler: uj.Linux type=specs.Linux kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = uj.Linux.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
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
|
|
}
|
|
|
|
func (mj *Syscall) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *Syscall) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ "name":`)
|
|
fflib.WriteJsonString(buf, string(mj.Name))
|
|
buf.WriteString(`,"action":`)
|
|
fflib.WriteJsonString(buf, string(mj.Action))
|
|
buf.WriteByte(',')
|
|
if len(mj.Args) != 0 {
|
|
buf.WriteString(`"args":`)
|
|
if mj.Args != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.Args {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
|
|
{
|
|
|
|
err = v.MarshalJSONBuf(buf)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
}
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Syscallbase = iota
|
|
ffj_t_Syscallno_such_key
|
|
|
|
ffj_t_Syscall_Name
|
|
|
|
ffj_t_Syscall_Action
|
|
|
|
ffj_t_Syscall_Args
|
|
)
|
|
|
|
var ffj_key_Syscall_Name = []byte("name")
|
|
|
|
var ffj_key_Syscall_Action = []byte("action")
|
|
|
|
var ffj_key_Syscall_Args = []byte("args")
|
|
|
|
func (uj *Syscall) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *Syscall) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Syscallbase
|
|
_ = 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 = ffj_t_Syscallno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_Syscall_Action, kn) {
|
|
currentKey = ffj_t_Syscall_Action
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_Syscall_Args, kn) {
|
|
currentKey = ffj_t_Syscall_Args
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'n':
|
|
|
|
if bytes.Equal(ffj_key_Syscall_Name, kn) {
|
|
currentKey = ffj_t_Syscall_Name
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_Syscall_Args, kn) {
|
|
currentKey = ffj_t_Syscall_Args
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Syscall_Action, kn) {
|
|
currentKey = ffj_t_Syscall_Action
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_Syscall_Name, kn) {
|
|
currentKey = ffj_t_Syscall_Name
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Syscallno_such_key
|
|
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 ffj_t_Syscall_Name:
|
|
goto handle_Name
|
|
|
|
case ffj_t_Syscall_Action:
|
|
goto handle_Action
|
|
|
|
case ffj_t_Syscall_Args:
|
|
goto handle_Args
|
|
|
|
case ffj_t_Syscallno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Name:
|
|
|
|
/* handler: uj.Name 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()
|
|
|
|
uj.Name = string(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Action:
|
|
|
|
/* handler: uj.Action type=specs.Action 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 Action", tok))
|
|
}
|
|
}
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
outBuf := fs.Output.Bytes()
|
|
|
|
uj.Action = Action(string(outBuf))
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Args:
|
|
|
|
/* handler: uj.Args type=[]specs.Arg 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 {
|
|
uj.Args = nil
|
|
} else {
|
|
|
|
uj.Args = make([]Arg, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__Args Arg
|
|
|
|
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: tmp_uj__Args type=specs.Arg kind=struct quoted=false*/
|
|
|
|
{
|
|
if tok == fflib.FFTok_null {
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
|
|
err = tmp_uj__Args.UnmarshalJSONFFLexer(fs, fflib.FFParse_want_key)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
}
|
|
|
|
uj.Args = append(uj.Args, tmp_uj__Args)
|
|
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
|
|
}
|
|
|
|
func (mj *ThrottleDevice) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *ThrottleDevice) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.Rate != nil {
|
|
if true {
|
|
buf.WriteString(`"rate":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Rate), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_ThrottleDevicebase = iota
|
|
ffj_t_ThrottleDeviceno_such_key
|
|
|
|
ffj_t_ThrottleDevice_Rate
|
|
)
|
|
|
|
var ffj_key_ThrottleDevice_Rate = []byte("rate")
|
|
|
|
func (uj *ThrottleDevice) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *ThrottleDevice) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_ThrottleDevicebase
|
|
_ = 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 = ffj_t_ThrottleDeviceno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'r':
|
|
|
|
if bytes.Equal(ffj_key_ThrottleDevice_Rate, kn) {
|
|
currentKey = ffj_t_ThrottleDevice_Rate
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_ThrottleDevice_Rate, kn) {
|
|
currentKey = ffj_t_ThrottleDevice_Rate
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_ThrottleDeviceno_such_key
|
|
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 ffj_t_ThrottleDevice_Rate:
|
|
goto handle_Rate
|
|
|
|
case ffj_t_ThrottleDeviceno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Rate:
|
|
|
|
/* handler: uj.Rate type=uint64 kind=uint64 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint64", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Rate = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 64)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint64(tval)
|
|
uj.Rate = &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
|
|
}
|
|
|
|
func (mj *User) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *User) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.UID != 0 {
|
|
buf.WriteString(`"uid":`)
|
|
fflib.FormatBits2(buf, uint64(mj.UID), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
if mj.GID != 0 {
|
|
buf.WriteString(`"gid":`)
|
|
fflib.FormatBits2(buf, uint64(mj.GID), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
if len(mj.AdditionalGids) != 0 {
|
|
buf.WriteString(`"additionalGids":`)
|
|
if mj.AdditionalGids != nil {
|
|
buf.WriteString(`[`)
|
|
for i, v := range mj.AdditionalGids {
|
|
if i != 0 {
|
|
buf.WriteString(`,`)
|
|
}
|
|
fflib.FormatBits2(buf, uint64(v), 10, false)
|
|
}
|
|
buf.WriteString(`]`)
|
|
} else {
|
|
buf.WriteString(`null`)
|
|
}
|
|
buf.WriteByte(',')
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_Userbase = iota
|
|
ffj_t_Userno_such_key
|
|
|
|
ffj_t_User_UID
|
|
|
|
ffj_t_User_GID
|
|
|
|
ffj_t_User_AdditionalGids
|
|
)
|
|
|
|
var ffj_key_User_UID = []byte("uid")
|
|
|
|
var ffj_key_User_GID = []byte("gid")
|
|
|
|
var ffj_key_User_AdditionalGids = []byte("additionalGids")
|
|
|
|
func (uj *User) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *User) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_Userbase
|
|
_ = 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 = ffj_t_Userno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'a':
|
|
|
|
if bytes.Equal(ffj_key_User_AdditionalGids, kn) {
|
|
currentKey = ffj_t_User_AdditionalGids
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'g':
|
|
|
|
if bytes.Equal(ffj_key_User_GID, kn) {
|
|
currentKey = ffj_t_User_GID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'u':
|
|
|
|
if bytes.Equal(ffj_key_User_UID, kn) {
|
|
currentKey = ffj_t_User_UID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.EqualFoldRight(ffj_key_User_AdditionalGids, kn) {
|
|
currentKey = ffj_t_User_AdditionalGids
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_User_GID, kn) {
|
|
currentKey = ffj_t_User_GID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_User_UID, kn) {
|
|
currentKey = ffj_t_User_UID
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_Userno_such_key
|
|
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 ffj_t_User_UID:
|
|
goto handle_UID
|
|
|
|
case ffj_t_User_GID:
|
|
goto handle_GID
|
|
|
|
case ffj_t_User_AdditionalGids:
|
|
goto handle_AdditionalGids
|
|
|
|
case ffj_t_Userno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_UID:
|
|
|
|
/* handler: uj.UID type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.UID = uint32(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_GID:
|
|
|
|
/* handler: uj.GID type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
uj.GID = uint32(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_AdditionalGids:
|
|
|
|
/* handler: uj.AdditionalGids type=[]uint32 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 {
|
|
uj.AdditionalGids = nil
|
|
} else {
|
|
|
|
uj.AdditionalGids = make([]uint32, 0)
|
|
|
|
wantVal := true
|
|
|
|
for {
|
|
|
|
var tmp_uj__AdditionalGids uint32
|
|
|
|
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: tmp_uj__AdditionalGids type=uint32 kind=uint32 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint32", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 32)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
tmp_uj__AdditionalGids = uint32(tval)
|
|
|
|
}
|
|
}
|
|
|
|
uj.AdditionalGids = append(uj.AdditionalGids, tmp_uj__AdditionalGids)
|
|
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
|
|
}
|
|
|
|
func (mj *WeightDevice) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *WeightDevice) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{ `)
|
|
if mj.Weight != nil {
|
|
if true {
|
|
buf.WriteString(`"weight":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.Weight), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
if mj.LeafWeight != nil {
|
|
if true {
|
|
buf.WriteString(`"leafWeight":`)
|
|
fflib.FormatBits2(buf, uint64(*mj.LeafWeight), 10, false)
|
|
buf.WriteByte(',')
|
|
}
|
|
}
|
|
buf.Rewind(1)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_WeightDevicebase = iota
|
|
ffj_t_WeightDeviceno_such_key
|
|
|
|
ffj_t_WeightDevice_Weight
|
|
|
|
ffj_t_WeightDevice_LeafWeight
|
|
)
|
|
|
|
var ffj_key_WeightDevice_Weight = []byte("weight")
|
|
|
|
var ffj_key_WeightDevice_LeafWeight = []byte("leafWeight")
|
|
|
|
func (uj *WeightDevice) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *WeightDevice) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_WeightDevicebase
|
|
_ = 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 = ffj_t_WeightDeviceno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'l':
|
|
|
|
if bytes.Equal(ffj_key_WeightDevice_LeafWeight, kn) {
|
|
currentKey = ffj_t_WeightDevice_LeafWeight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
case 'w':
|
|
|
|
if bytes.Equal(ffj_key_WeightDevice_Weight, kn) {
|
|
currentKey = ffj_t_WeightDevice_Weight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_WeightDevice_LeafWeight, kn) {
|
|
currentKey = ffj_t_WeightDevice_LeafWeight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_WeightDevice_Weight, kn) {
|
|
currentKey = ffj_t_WeightDevice_Weight
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_WeightDeviceno_such_key
|
|
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 ffj_t_WeightDevice_Weight:
|
|
goto handle_Weight
|
|
|
|
case ffj_t_WeightDevice_LeafWeight:
|
|
goto handle_LeafWeight
|
|
|
|
case ffj_t_WeightDeviceno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Weight:
|
|
|
|
/* handler: uj.Weight type=uint16 kind=uint16 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint16", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.Weight = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 16)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint16(tval)
|
|
uj.Weight = &ttypval
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_LeafWeight:
|
|
|
|
/* handler: uj.LeafWeight type=uint16 kind=uint16 quoted=false*/
|
|
|
|
{
|
|
if tok != fflib.FFTok_integer && tok != fflib.FFTok_null {
|
|
return fs.WrapErr(fmt.Errorf("cannot unmarshal %s into Go value for uint16", tok))
|
|
}
|
|
}
|
|
|
|
{
|
|
|
|
if tok == fflib.FFTok_null {
|
|
|
|
uj.LeafWeight = nil
|
|
|
|
} else {
|
|
|
|
tval, err := fflib.ParseUint(fs.Output.Bytes(), 10, 16)
|
|
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
|
|
ttypval := uint16(tval)
|
|
uj.LeafWeight = &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
|
|
}
|
|
|
|
func (mj *blockIODevice) MarshalJSON() ([]byte, error) {
|
|
var buf fflib.Buffer
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return buf.Bytes(), nil
|
|
}
|
|
err := mj.MarshalJSONBuf(&buf)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return buf.Bytes(), nil
|
|
}
|
|
func (mj *blockIODevice) MarshalJSONBuf(buf fflib.EncodingBuffer) error {
|
|
if mj == nil {
|
|
buf.WriteString("null")
|
|
return nil
|
|
}
|
|
var err error
|
|
var obj []byte
|
|
_ = obj
|
|
_ = err
|
|
buf.WriteString(`{"major":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Major), 10, mj.Major < 0)
|
|
buf.WriteString(`,"minor":`)
|
|
fflib.FormatBits2(buf, uint64(mj.Minor), 10, mj.Minor < 0)
|
|
buf.WriteByte('}')
|
|
return nil
|
|
}
|
|
|
|
const (
|
|
ffj_t_blockIODevicebase = iota
|
|
ffj_t_blockIODeviceno_such_key
|
|
|
|
ffj_t_blockIODevice_Major
|
|
|
|
ffj_t_blockIODevice_Minor
|
|
)
|
|
|
|
var ffj_key_blockIODevice_Major = []byte("major")
|
|
|
|
var ffj_key_blockIODevice_Minor = []byte("minor")
|
|
|
|
func (uj *blockIODevice) UnmarshalJSON(input []byte) error {
|
|
fs := fflib.NewFFLexer(input)
|
|
return uj.UnmarshalJSONFFLexer(fs, fflib.FFParse_map_start)
|
|
}
|
|
|
|
func (uj *blockIODevice) UnmarshalJSONFFLexer(fs *fflib.FFLexer, state fflib.FFParseState) error {
|
|
var err error = nil
|
|
currentKey := ffj_t_blockIODevicebase
|
|
_ = 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 = ffj_t_blockIODeviceno_such_key
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
} else {
|
|
switch kn[0] {
|
|
|
|
case 'm':
|
|
|
|
if bytes.Equal(ffj_key_blockIODevice_Major, kn) {
|
|
currentKey = ffj_t_blockIODevice_Major
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
|
|
} else if bytes.Equal(ffj_key_blockIODevice_Minor, kn) {
|
|
currentKey = ffj_t_blockIODevice_Minor
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_blockIODevice_Minor, kn) {
|
|
currentKey = ffj_t_blockIODevice_Minor
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
if fflib.SimpleLetterEqualFold(ffj_key_blockIODevice_Major, kn) {
|
|
currentKey = ffj_t_blockIODevice_Major
|
|
state = fflib.FFParse_want_colon
|
|
goto mainparse
|
|
}
|
|
|
|
currentKey = ffj_t_blockIODeviceno_such_key
|
|
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 ffj_t_blockIODevice_Major:
|
|
goto handle_Major
|
|
|
|
case ffj_t_blockIODevice_Minor:
|
|
goto handle_Minor
|
|
|
|
case ffj_t_blockIODeviceno_such_key:
|
|
err = fs.SkipField(tok)
|
|
if err != nil {
|
|
return fs.WrapErr(err)
|
|
}
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
}
|
|
} else {
|
|
goto wantedvalue
|
|
}
|
|
}
|
|
}
|
|
|
|
handle_Major:
|
|
|
|
/* handler: uj.Major 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)
|
|
}
|
|
|
|
uj.Major = int64(tval)
|
|
|
|
}
|
|
}
|
|
|
|
state = fflib.FFParse_after_value
|
|
goto mainparse
|
|
|
|
handle_Minor:
|
|
|
|
/* handler: uj.Minor 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)
|
|
}
|
|
|
|
uj.Minor = int64(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
|
|
}
|