tff

package
v0.0.0-...-a16f62e Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 13, 2016 License: Apache-2.0 Imports: 3 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var ErrGiveError = errors.New("GiveError error")

Functions

This section is empty.

Types

type ATbool 

type ATbool struct {
	X [3]bool
}

ffjson: skip

type ATbyte 

type ATbyte struct {
	X [3]byte
}

ffjson: skip

type ATduration 

type ATduration struct {
	X [3]time.Duration
}

Arrays ffjson: skip

type ATfloat32 

type ATfloat32 struct {
	X [3]float32
}

ffjson: skip

type ATfloat64 

type ATfloat64 struct {
	X [3]float64
}

ffjson: skip

type ATint 

type ATint struct {
	X [3]int
}

ffjson: skip

type ATint16 

type ATint16 struct {
	X [3]int16
}

ffjson: skip

type ATint32 

type ATint32 struct {
	X [3]int32
}

ffjson: skip

type ATint64 

type ATint64 struct {
	X [3]int64
}

ffjson: skip

type ATint8 

type ATint8 struct {
	X [3]int8
}

ffjson: skip

type ATtime 

type ATtime struct {
	X [3]time.Time
}

ffjson: skip

type ATuint 

type ATuint struct {
	X [3]uint
}

ffjson: skip

type ATuint16 

type ATuint16 struct {
	X [3]uint16
}

ffjson: skip

type ATuint32 

type ATuint32 struct {
	X [3]uint32
}

ffjson: skip

type ATuint64 

type ATuint64 struct {
	X [3]uint64
}

ffjson: skip

type ATuint8 

type ATuint8 struct {
	X [3]uint8
}

ffjson: skip

type ATuintptr 

type ATuintptr struct {
	X [3]uintptr
}

ffjson: skip

type AXbool 

type AXbool struct {
	X [3]bool
}

type AXbyte 

type AXbyte struct {
	X [3]byte
}

type AXduration 

type AXduration struct {
	X [3]time.Duration
}

type AXfloat32 

type AXfloat32 struct {
	X [3]float32
}

type AXfloat64 

type AXfloat64 struct {
	X [3]float64
}

type AXint 

type AXint struct {
	X [3]int
}

type AXint16 

type AXint16 struct {
	X [3]int16
}

type AXint32 

type AXint32 struct {
	X [3]int32
}

type AXint64 

type AXint64 struct {
	X [3]int64
}

type AXint8 

type AXint8 struct {
	X [3]int8
}

type AXtime 

type AXtime struct {
	X [3]time.Time
}

type AXuint 

type AXuint struct {
	X [3]uint
}

type AXuint16 

type AXuint16 struct {
	X [3]uint16
}

type AXuint32 

type AXuint32 struct {
	X [3]uint32
}

type AXuint64 

type AXuint64 struct {
	X [3]uint64
}

type AXuint8 

type AXuint8 struct {
	X [3]uint8
}

type AXuintptr 

type AXuintptr struct {
	X [3]uintptr
}

type BugA 

type BugA struct {
	S string
}

type BugB 

type BugB struct {
	BugA
	S string
}

type BugC 

type BugC struct {
	S string
}

type BugD 

type BugD struct {
	XXX string `json:"S"`
}

type BugX 

type BugX struct {
	A int
	BugA
	BugB
}

Legal Go: We never use the repeated embedded field (S).

type BugY 

type BugY struct {
	BugA
	BugD
}

BugD's tagged S field should dominate BugA's.

type BugZ 

type BugZ struct {
	BugA
	BugC
	BugY // Contains a tagged S field through BugD; should not dominate.
}

There are no tags here, so S should not appear.

type ByteSliceDoubleRenamed 

type ByteSliceDoubleRenamed struct {
	X renamedRenamedByteSlice
}

type ByteSliceNormal 

type ByteSliceNormal struct {
	X []byte
}

type ByteSliceRenamed 

type ByteSliceRenamed struct {
	X renamedByteSlice
}

type C 

type C int

C implements Marshaler and returns unescaped JSON.

func (C) MarshalJSON 

func (C) MarshalJSON() ([]byte, error)

type CText 

type CText int

CText implements Marshaler and returns unescaped text.

func (CText) MarshalText 

func (CText) MarshalText() ([]byte, error)

type FFFoo 

type FFFoo struct {
	Blah int
}

type FFRecord 

type FFRecord struct {
	Timestamp int64 `json:"id,omitempty"`
	OriginId  uint32
	Bar       FFFoo
	Method    string `json:"meth"`
	ReqId     string
	ServerIp  string
	RemoteIp  string
	BytesSent uint64
}

type FfFuzz 

type FfFuzz struct {
	A uint8
	B uint16
	C uint32
	D uint64

	E int8
	F int16
	G int32
	H int64

	I float32
	J float64

	M byte
	N rune

	O int
	P uint
	Q string
	R bool
	S time.Time

	Ap *uint8
	Bp *uint16
	Cp *uint32
	Dp *uint64

	Ep *int8
	Fp *int16
	Gp *int32
	Hp *int64

	Ip *float32
	Jp *float64

	Mp *byte
	Np *rune

	Op *int
	Pp *uint
	Qp *string
	Rp *bool
	Sp *time.Time

	Aa []uint8
	Ba []uint16
	Ca []uint32
	Da []uint64

	Ea []int8
	Fa []int16
	Ga []int32
	Ha []int64

	Ia []float32
	Ja []float64

	Ma []byte
	Na []rune

	Oa []int
	Pa []uint
	Qa []string
	Ra []bool

	Aap []*uint8
	Bap []*uint16
	Cap []*uint32
	Dap []*uint64

	Eap []*int8
	Fap []*int16
	Gap []*int32
	Hap []*int64

	Iap []*float32
	Jap []*float64

	Map []*byte
	Nap []*rune

	Oap []*int
	Pap []*uint
	Qap []*string
	Rap []*bool
}

type FfFuzzOmitEmpty 

type FfFuzzOmitEmpty struct {
	A uint8  `json:",omitempty"`
	B uint16 `json:",omitempty"`
	C uint32 `json:",omitempty"`
	D uint64 `json:",omitempty"`

	E int8  `json:",omitempty"`
	F int16 `json:",omitempty"`
	G int32 `json:",omitempty"`
	H int64 `json:",omitempty"`

	I float32 `json:",omitempty"`
	J float64 `json:",omitempty"`

	M byte `json:",omitempty"`
	N rune `json:",omitempty"`

	O int       `json:",omitempty"`
	P uint      `json:",omitempty"`
	Q string    `json:",omitempty"`
	R bool      `json:",omitempty"`
	S time.Time `json:",omitempty"`

	Ap *uint8  `json:",omitempty"`
	Bp *uint16 `json:",omitempty"`
	Cp *uint32 `json:",omitempty"`
	Dp *uint64 `json:",omitempty"`

	Ep *int8  `json:",omitempty"`
	Fp *int16 `json:",omitempty"`
	Gp *int32 `json:",omitempty"`
	Hp *int64 `json:",omitempty"`

	Ip *float32 `json:",omitempty"`
	Jp *float64 `json:",omitempty"`

	Mp *byte `json:",omitempty"`
	Np *rune `json:",omitempty"`

	Op *int       `json:",omitempty"`
	Pp *uint      `json:",omitempty"`
	Qp *string    `json:",omitempty"`
	Rp *bool      `json:",omitempty"`
	Sp *time.Time `json:",omitempty"`

	Aa []uint8  `json:",omitempty"`
	Ba []uint16 `json:",omitempty"`
	Ca []uint32 `json:",omitempty"`
	Da []uint64 `json:",omitempty"`

	Ea []int8  `json:",omitempty"`
	Fa []int16 `json:",omitempty"`
	Ga []int32 `json:",omitempty"`
	Ha []int64 `json:",omitempty"`

	Ia []float32 `json:",omitempty"`
	Ja []float64 `json:",omitempty"`

	Ma []byte `json:",omitempty"`
	Na []rune `json:",omitempty"`

	Oa []int    `json:",omitempty"`
	Pa []uint   `json:",omitempty"`
	Qa []string `json:",omitempty"`
	Ra []bool   `json:",omitempty"`

	Aap []*uint8  `json:",omitempty"`
	Bap []*uint16 `json:",omitempty"`
	Cap []*uint32 `json:",omitempty"`
	Dap []*uint64 `json:",omitempty"`

	Eap []*int8  `json:",omitempty"`
	Fap []*int16 `json:",omitempty"`
	Gap []*int32 `json:",omitempty"`
	Hap []*int64 `json:",omitempty"`

	Iap []*float32 `json:",omitempty"`
	Jap []*float64 `json:",omitempty"`

	Map []*byte `json:",omitempty"`
	Nap []*rune `json:",omitempty"`

	Oap []*int    `json:",omitempty"`
	Pap []*uint   `json:",omitempty"`
	Qap []*string `json:",omitempty"`
	Rap []*bool   `json:",omitempty"`
}

type FfFuzzString 

type FfFuzzString struct {
	A uint8  `json:",string"`
	B uint16 `json:",string"`
	C uint32 `json:",string"`
	D uint64 `json:",string"`

	E int8  `json:",string"`
	F int16 `json:",string"`
	G int32 `json:",string"`
	H int64 `json:",string"`

	I float32 `json:",string"`
	J float64 `json:",string"`

	M byte `json:",string"`
	N rune `json:",string"`

	O int  `json:",string"`
	P uint `json:",string"`

	Q string `json:",string"`

	R bool `json:",string"`

	Ap *uint8  `json:",string"`
	Bp *uint16 `json:",string"`
	Cp *uint32 `json:",string"`
	Dp *uint64 `json:",string"`

	Ep *int8  `json:",string"`
	Fp *int16 `json:",string"`
	Gp *int32 `json:",string"`
	Hp *int64 `json:",string"`

	Ip *float32 `json:",string"`
	Jp *float64 `json:",string"`

	Mp *byte `json:",string"`
	Np *rune `json:",string"`

	Op *int    `json:",string"`
	Pp *uint   `json:",string"`
	Qp *string `json:",string"`
	Rp *bool   `json:",string"`
}

type Foo 

type Foo struct {
	Blah int
}

type FuzzOmitEmpty 

type FuzzOmitEmpty struct {
	A uint8  `json:",omitempty"`
	B uint16 `json:",omitempty"`
	C uint32 `json:",omitempty"`
	D uint64 `json:",omitempty"`

	E int8  `json:",omitempty"`
	F int16 `json:",omitempty"`
	G int32 `json:",omitempty"`
	H int64 `json:",omitempty"`

	I float32 `json:",omitempty"`
	J float64 `json:",omitempty"`

	M byte `json:",omitempty"`
	N rune `json:",omitempty"`

	O int       `json:",omitempty"`
	P uint      `json:",omitempty"`
	Q string    `json:",omitempty"`
	R bool      `json:",omitempty"`
	S time.Time `json:",omitempty"`

	Ap *uint8  `json:",omitempty"`
	Bp *uint16 `json:",omitempty"`
	Cp *uint32 `json:",omitempty"`
	Dp *uint64 `json:",omitempty"`

	Ep *int8  `json:",omitempty"`
	Fp *int16 `json:",omitempty"`
	Gp *int32 `json:",omitempty"`
	Hp *int64 `json:",omitempty"`

	Ip *float32 `json:",omitempty"`
	Jp *float64 `json:",omitempty"`

	Mp *byte `json:",omitempty"`
	Np *rune `json:",omitempty"`

	Op *int       `json:",omitempty"`
	Pp *uint      `json:",omitempty"`
	Qp *string    `json:",omitempty"`
	Rp *bool      `json:",omitempty"`
	Sp *time.Time `json:",omitempty"`

	Aa []uint8  `json:",omitempty"`
	Ba []uint16 `json:",omitempty"`
	Ca []uint32 `json:",omitempty"`
	Da []uint64 `json:",omitempty"`

	Ea []int8  `json:",omitempty"`
	Fa []int16 `json:",omitempty"`
	Ga []int32 `json:",omitempty"`
	Ha []int64 `json:",omitempty"`

	Ia []float32 `json:",omitempty"`
	Ja []float64 `json:",omitempty"`

	Ma []byte `json:",omitempty"`
	Na []rune `json:",omitempty"`

	Oa []int    `json:",omitempty"`
	Pa []uint   `json:",omitempty"`
	Qa []string `json:",omitempty"`
	Ra []bool   `json:",omitempty"`

	Aap []*uint8  `json:",omitempty"`
	Bap []*uint16 `json:",omitempty"`
	Cap []*uint32 `json:",omitempty"`
	Dap []*uint64 `json:",omitempty"`

	Eap []*int8  `json:",omitempty"`
	Fap []*int16 `json:",omitempty"`
	Gap []*int32 `json:",omitempty"`
	Hap []*int64 `json:",omitempty"`

	Iap []*float32 `json:",omitempty"`
	Jap []*float64 `json:",omitempty"`

	Map []*byte `json:",omitempty"`
	Nap []*rune `json:",omitempty"`

	Oap []*int    `json:",omitempty"`
	Pap []*uint   `json:",omitempty"`
	Qap []*string `json:",omitempty"`
	Rap []*bool   `json:",omitempty"`
}

ffjson: skip

type FuzzString 

type FuzzString struct {
	A uint8  `json:",string"`
	B uint16 `json:",string"`
	C uint32 `json:",string"`
	D uint64 `json:",string"`

	E int8  `json:",string"`
	F int16 `json:",string"`
	G int32 `json:",string"`
	H int64 `json:",string"`

	I float32 `json:",string"`
	J float64 `json:",string"`

	M byte `json:",string"`
	N rune `json:",string"`

	O int  `json:",string"`
	P uint `json:",string"`

	Q string `json:",string"`

	R bool `json:",string"`

	Ap *uint8  `json:",string"`
	Bp *uint16 `json:",string"`
	Cp *uint32 `json:",string"`
	Dp *uint64 `json:",string"`

	Ep *int8  `json:",string"`
	Fp *int16 `json:",string"`
	Gp *int32 `json:",string"`
	Hp *int64 `json:",string"`

	Ip *float32 `json:",string"`
	Jp *float64 `json:",string"`

	Mp *byte `json:",string"`
	Np *rune `json:",string"`

	Op *int    `json:",string"`
	Pp *uint   `json:",string"`
	Qp *string `json:",string"`
	Rp *bool   `json:",string"`
}

ffjson: skip

type GiveError 

type GiveError struct{}

GiveError always returns an ErrGiveError on Marshal/Unmarshal.

func (GiveError) MarshalJSON 

func (r GiveError) MarshalJSON() ([]byte, error)

func (*GiveError) UnmarshalJSON 

func (r *GiveError) UnmarshalJSON([]byte) error

type IntType 

type IntType int

type MyStruct 

type MyStruct struct {
	IntType
}

type NoDecoder 

type NoDecoder struct {
	C string
	B int `json:"A"`
}

ffjson: nodecoder

type NoEncoder 

type NoEncoder struct {
	C string
	B int `json:"A"`
}

ffjson: noencoder

type NoExported 

type NoExported struct {
	// contains filtered or unexported fields
}

type OmitAll 

type OmitAll struct {
	Ostr    string                 `json:",omitempty"`
	Oint    int                    `json:",omitempty"`
	Obool   bool                   `json:",omitempty"`
	Odouble float64                `json:",omitempty"`
	Ointer  interface{}            `json:",omitempty"`
	Omap    map[string]interface{} `json:",omitempty"`
	OstrP   *string                `json:",omitempty"`
	OintP   *int                   `json:",omitempty"`
	// TODO: Re-enable when issue #55 is fixed.
	OboolP  *bool                   `json:",omitempty"`
	OmapP   *map[string]interface{} `json:",omitempty"`
	Astr    []string                `json:",omitempty"`
	Aint    []int                   `json:",omitempty"`
	Abool   []bool                  `json:",omitempty"`
	Adouble []float64               `json:",omitempty"`
}

type OmitFirst 

type OmitFirst struct {
	Ostr string `json:",omitempty"`
	Str  string
}

type OmitLast 

type OmitLast struct {
	Xstr string `json:",omitempty"`
	Str  string
}

type Optionals 

type Optionals struct {
	Sr string `json:"sr"`
	So string `json:"so,omitempty"`
	Sw string `json:"-"`

	Ir int `json:"omitempty"` // actually named omitempty, not an option
	Io int `json:"io,omitempty"`

	Slr []string `json:"slr,random"`
	Slo []string `json:"slo,omitempty"`

	Mr map[string]interface{} `json:"mr"`
	Mo map[string]interface{} `json:",omitempty"`

	Fr float64 `json:"fr"`
	Fo float64 `json:"fo,omitempty"`

	Br bool `json:"br"`
	Bo bool `json:"bo,omitempty"`

	Ur uint `json:"ur"`
	Uo uint `json:"uo,omitempty"`

	Str struct{} `json:"str"`
	Sto struct{} `json:"sto,omitempty"`
}

Tests from golang test suite

type ReAReTypedAp 

type ReAReTypedAp [4]ReTypedAp

type RePReTypedA 

type RePReTypedA *ReTypedA

type ReReTypedA 

type ReReTypedA ReTypedA

type ReReTypedAa 

type ReReTypedAa ReTypedAa

type ReReTypedAap 

type ReReTypedAap ReTypedAap

type ReReTypedAp 

type ReReTypedAp ReTypedAp

type ReReTypedS 

type ReReTypedS ReTypedS

type ReReTypedSp 

type ReReTypedSp ReTypedSp

type ReReTypedXa 

type ReReTypedXa ReTypedXa

type ReReTypedXb 

type ReReTypedXb ReTypedXb

type ReReTypedXc 

type ReReTypedXc ReTypedXc

type ReReTypedXd 

type ReReTypedXd ReTypedXd

type ReSReTypedS 

type ReSReTypedS []ReTypedS

type ReTypedA 

type ReTypedA uint8

type ReTypedAa 

type ReTypedAa []uint8

type ReTypedAap 

type ReTypedAap []*uint8

type ReTypedAp 

type ReTypedAp *uint8

type ReTypedB 

type ReTypedB uint16

type ReTypedBa 

type ReTypedBa []uint16

type ReTypedBap 

type ReTypedBap []*uint16

type ReTypedBp 

type ReTypedBp *uint16

type ReTypedC 

type ReTypedC uint32

type ReTypedCa 

type ReTypedCa []uint32

type ReTypedCap 

type ReTypedCap []*uint32

type ReTypedCp 

type ReTypedCp *uint32

type ReTypedD 

type ReTypedD uint64

type ReTypedDa 

type ReTypedDa []uint64

type ReTypedDap 

type ReTypedDap []*uint64

type ReTypedDp 

type ReTypedDp *uint64

type ReTypedE 

type ReTypedE int8

type ReTypedEa 

type ReTypedEa []int8

type ReTypedEap 

type ReTypedEap []*int8

type ReTypedEp 

type ReTypedEp *int8

type ReTypedF 

type ReTypedF int16

type ReTypedFa 

type ReTypedFa []int16

type ReTypedFap 

type ReTypedFap []*int16

type ReTypedFp 

type ReTypedFp *int16

type ReTypedG 

type ReTypedG int32

type ReTypedGa 

type ReTypedGa []int32

type ReTypedGap 

type ReTypedGap []*int32

type ReTypedGp 

type ReTypedGp *int32

type ReTypedH 

type ReTypedH int64

type ReTypedHa 

type ReTypedHa []int64

type ReTypedHap 

type ReTypedHap []*int64

type ReTypedHp 

type ReTypedHp *int64

type ReTypedI 

type ReTypedI float32

type ReTypedIa 

type ReTypedIa []float32

type ReTypedIap 

type ReTypedIap []*float32

type ReTypedIp 

type ReTypedIp *float32

type ReTypedJ 

type ReTypedJ float64

type ReTypedJa 

type ReTypedJa []float64

type ReTypedJap 

type ReTypedJap []*float64

type ReTypedJp 

type ReTypedJp *float64

type ReTypedM 

type ReTypedM byte

type ReTypedMa 

type ReTypedMa []byte

type ReTypedMap 

type ReTypedMap []*byte

type ReTypedMp 

type ReTypedMp *byte

type ReTypedN 

type ReTypedN rune

type ReTypedNa 

type ReTypedNa []rune

type ReTypedNap 

type ReTypedNap []*rune

type ReTypedNp 

type ReTypedNp *rune

type ReTypedO 

type ReTypedO int

type ReTypedOa 

type ReTypedOa []int

type ReTypedOap 

type ReTypedOap []*int

type ReTypedOp 

type ReTypedOp *int

type ReTypedP 

type ReTypedP uint

type ReTypedPa 

type ReTypedPa []uint

type ReTypedPap 

type ReTypedPap []*uint

type ReTypedPp 

type ReTypedPp *uint

type ReTypedQ 

type ReTypedQ string

type ReTypedQa 

type ReTypedQa []string

type ReTypedQap 

type ReTypedQap []*string

type ReTypedQp 

type ReTypedQp *string

type ReTypedR 

type ReTypedR bool

type ReTypedRa 

type ReTypedRa []bool

type ReTypedRap 

type ReTypedRap []*bool

type ReTypedRp 

type ReTypedRp *bool

type ReTypedS 

type ReTypedS time.Time

type ReTypedSp 

type ReTypedSp *time.Time

type ReTypedXa 

type ReTypedXa NoDecoder

type ReTypedXb 

type ReTypedXb NoEncoder

type ReTypedXc 

type ReTypedXc *NoDecoder

type ReTypedXd 

type ReTypedXd *NoEncoder

type Record 

type Record struct {
	Timestamp int64 `json:"id,omitempty"`
	OriginId  uint32
	Bar       Foo
	Method    string `json:"meth"`
	ReqId     string
	ServerIp  string
	RemoteIp  string
	BytesSent uint64
}

type Ref 

type Ref int

Ref has Marshaler and Unmarshaler methods with pointer receiver.

func (*Ref) MarshalJSON 

func (*Ref) MarshalJSON() ([]byte, error)

func (*Ref) UnmarshalJSON 

func (r *Ref) UnmarshalJSON([]byte) error

type RefText 

type RefText int

RefText has Marshaler and Unmarshaler methods with pointer receiver.

func (*RefText) MarshalText 

func (*RefText) MarshalText() ([]byte, error)

func (*RefText) UnmarshalText 

func (r *RefText) UnmarshalText([]byte) error

type STbool 

type STbool struct {
	X []bool
}

ffjson: skip

type STbyte 

type STbyte struct {
	X []byte
}

ffjson: skip

type STduration 

type STduration struct {
	X []time.Duration
}

Slices ffjson: skip

type STfloat32 

type STfloat32 struct {
	X []float32
}

ffjson: skip

type STfloat64 

type STfloat64 struct {
	X []float64
}

ffjson: skip

type STint 

type STint struct {
	X []int
}

ffjson: skip

type STint16 

type STint16 struct {
	X []int16
}

ffjson: skip

type STint32 

type STint32 struct {
	X []int32
}

ffjson: skip

type STint64 

type STint64 struct {
	X []int64
}

ffjson: skip

type STint8 

type STint8 struct {
	X []int8
}

ffjson: skip

type STtime 

type STtime struct {
	X []time.Time
}

ffjson: skip

type STuint 

type STuint struct {
	X []uint
}

ffjson: skip

type STuint16 

type STuint16 struct {
	X []uint16
}

ffjson: skip

type STuint32 

type STuint32 struct {
	X []uint32
}

ffjson: skip

type STuint64 

type STuint64 struct {
	X []uint64
}

ffjson: skip

type STuint8 

type STuint8 struct {
	X []uint8
}

ffjson: skip

type STuintptr 

type STuintptr struct {
	X []uintptr
}

ffjson: skip

type SXbool 

type SXbool struct {
	X []bool
}

type SXbyte 

type SXbyte struct {
	X []byte
}

type SXduration 

type SXduration struct {
	X []time.Duration
}

type SXfloat32 

type SXfloat32 struct {
	X []float32
}

type SXfloat64 

type SXfloat64 struct {
	X []float64
}

type SXint 

type SXint struct {
	X []int
}

type SXint16 

type SXint16 struct {
	X []int16
}

type SXint32 

type SXint32 struct {
	X []int32
}

type SXint64 

type SXint64 struct {
	X []int64
}

type SXint8 

type SXint8 struct {
	X []int8
}

type SXtime 

type SXtime struct {
	X []time.Time
}

type SXuint 

type SXuint struct {
	X []uint
}

type SXuint16 

type SXuint16 struct {
	X []uint16
}

type SXuint32 

type SXuint32 struct {
	X []uint32
}

type SXuint64 

type SXuint64 struct {
	X []uint64
}

type SXuint8 

type SXuint8 struct {
	X []uint8
}

type SXuintptr 

type SXuintptr struct {
	X []uintptr
}

type StringTag 

type StringTag struct {
	BoolStr bool    `json:",string"`
	IntStr  int64   `json:",string"`
	FltStr  float64 `json:",string"`
	StrStr  string  `json:",string"`
}

type TDominantField 

type TDominantField struct {
	X     *int `json:"Name,omitempty"`
	Y     *int `json:"Name,omitempty"`
	Other string
	Name  *int             `json",omitempty"`
	A     *struct{ X int } `json:"Name,omitempty"`
}

ffjson: skip

type TEmbeddedStructures 

type TEmbeddedStructures struct {
	X []interface{}
	Y struct {
		X int
	}
	Z []struct {
		X int
	}
	U map[string]struct {
		X int
	}
	V []map[string]struct {
		X int
	}
	W [5]map[string]struct {
		X int
	}
	Q [][]string
}

ffjson: skip

type TI18nName 

type TI18nName struct {
	Ændret   int64
	Aוההקלדה uint32
	Позната  string
}

ffjson: skip

type TInlineStructs 

type TInlineStructs struct {
	B struct {
		A uint8
		B uint16
		C uint32
		D uint64

		E int8
		F int16
		G int32
		H int64

		I float32
		J float64

		M byte
		N rune

		O int
		P uint
		Q string
		R bool
		S time.Time

		Ap *uint8
		Bp *uint16
		Cp *uint32
		Dp *uint64

		Ep *int8
		Fp *int16
		Gp *int32
		Hp *int64

		Ip *float32
		Jp *float64

		Mp *byte
		Np *rune

		Op *int
		Pp *uint
		Qp *string
		Rp *bool
		Sp *time.Time

		Aa []uint8
		Ba []uint16
		Ca []uint32
		Da []uint64

		Ea []int8
		Fa []int16
		Ga []int32
		Ha []int64

		Ia []float32
		Ja []float64

		Ma []byte
		Na []rune

		Oa []int
		Pa []uint
		Qa []string
		Ra []bool

		Aap []*uint8
		Bap []*uint16
		Cap []*uint32
		Dap []*uint64

		Eap []*int8
		Fap []*int16
		Gap []*int32
		Hap []*int64

		Iap []*float32
		Jap []*float64

		Map []*byte
		Nap []*rune

		Oap []*int
		Pap []*uint
		Qap []*string
		Rap []*bool
	}
	PtStr *struct {
		X int
	}
	InceptionStr struct {
		Y []struct {
			X *int
		}
	}
}

ffjson: skip

type TMapStringAString 

type TMapStringAString struct {
	X map[string][3]string
}

ffjson: skip

type TMapStringMapString 

type TMapStringMapString struct {
	X map[string]map[string]string
}

Nested ffjson: skip

type TMapStringString 

type TMapStringString struct {
	X map[string]string
}

ffjson: skip

type TReTyped 

type TReTyped struct {
	A ReTypedA
	B ReTypedB
	C ReTypedC
	D ReTypedD

	E ReTypedE
	F ReTypedF
	G ReTypedG
	H ReTypedH

	I ReTypedI
	J ReTypedJ

	M ReTypedM
	N ReTypedN

	O ReTypedO
	P ReTypedP
	Q ReTypedQ
	R ReTypedR
	S ReTypedS

	Ap ReTypedAp
	Bp ReTypedBp
	Cp ReTypedCp
	Dp ReTypedDp

	Ep ReTypedEp
	Fp ReTypedFp
	Gp ReTypedGp
	Hp ReTypedHp

	Ip ReTypedIp
	Jp ReTypedJp

	Mp ReTypedMp
	Np ReTypedNp

	Op ReTypedOp
	Pp ReTypedPp
	Qp ReTypedQp
	Rp ReTypedRp

	// Bug in encoding/json: Bug in encoding/json: json: cannot unmarshal string into Go value of type tff.ReTypedAa
	//Aa ReTypedAa
	Ba ReTypedBa
	Ca ReTypedCa
	Da ReTypedDa

	Ea ReTypedEa
	Fa ReTypedFa
	Ga ReTypedGa
	Ha ReTypedHa

	Ia ReTypedIa
	Ja ReTypedJa

	// Bug in encoding/json: json: cannot unmarshal string into Go value of type tff.ReTypedMa
	// Ma ReTypedMa
	Na ReTypedNa

	Oa ReTypedOa
	Pa ReTypedPa
	Qa ReTypedQa
	Ra ReTypedRa

	Aap ReTypedAap
	Bap ReTypedBap
	Cap ReTypedCap
	Dap ReTypedDap

	Eap ReTypedEap
	Fap ReTypedFap
	Gap ReTypedGap
	Hap ReTypedHap

	Iap ReTypedIap
	Jap ReTypedJap

	Map ReTypedMap
	Nap ReTypedNap

	Oap ReTypedOap
	Pap ReTypedPap
	Qap ReTypedQap
	Rap ReTypedRap

	Xa ReTypedXa
	Xb ReTypedXb

	Rra  ReReTypedA
	Rrs  ReReTypedS
	Rrap ReReTypedAp

	// Bug in encoding/json: json: json: cannot unmarshal string into Go value of type tff.ReReTypedAa
	// Rraa  ReReTypedAa
	Rraap ReReTypedAap
	Rrxa  ReReTypedXa
	Rrxb  ReReTypedXb

	Rpra RePReTypedA
	Rsrs ReSReTypedS
}

ffjson: ignore

type TRenameTypes 

type TRenameTypes struct {
	X struct {
		X int
	} `json:"X-renamed"`
	Y NoEncoder  `json:"Y-renamed"`
	Z string     `json:"Z-renamed"`
	U *NoDecoder `json:"U-renamed"`
}

ffjson: skip Side-effect of this test is also to verify that Encoder/Decoder skipping works.

type TSAAtring 

type TSAAtring struct {
	X [2][3]string
}

ffjson: skip

type TSAString 

type TSAString struct {
	X [][3]string
}

ffjson: skip

type TTestMaps 

type TTestMaps struct {
	Aa map[string]uint8
	Ba map[string]uint16
	Ca map[string]uint32
	Da map[string]uint64

	Ea map[string]int8
	Fa map[string]int16
	Ga map[string]int32
	Ha map[string]int64

	Ia map[string]float32
	Ja map[string]float64

	Ma map[string]byte
	Na map[string]rune

	Oa map[string]int
	Pa map[string]uint
	Qa map[string]string
	Ra map[string]bool

	AaP map[string]*uint8
	BaP map[string]*uint16
	CaP map[string]*uint32
	DaP map[string]*uint64

	EaP map[string]*int8
	FaP map[string]*int16
	GaP map[string]*int32
	HaP map[string]*int64

	IaP map[string]*float32
	JaP map[string]*float64

	MaP map[string]*byte
	NaP map[string]*rune

	OaP map[string]*int
	PaP map[string]*uint
	QaP map[string]*string
	RaP map[string]*bool
}

ffjson: skip

type Tarray 

type Tarray struct {
	X [3]int
}

ffjson: skip

type TarrayPtr 

type TarrayPtr struct {
	X [3]*int
}

ffjson: skip

type Tbool 

type Tbool struct {
	X bool
}

ffjson: skip

type TboolTagged 

type TboolTagged struct {
	X int `json:",string"`
}

ffjson: skip

type Tbyte 

type Tbyte struct {
	X byte
}

ffjson: skip

type Tduration 

type Tduration struct {
	X time.Duration
}

ffjson: skip

type Tfloat32 

type Tfloat32 struct {
	X float32
}

ffjson: skip

type Tfloat64 

type Tfloat64 struct {
	X float64
}

ffjson: skip

type Tint 

type Tint struct {
	X int
}

ffjson: skip

type Tint16 

type Tint16 struct {
	X int16
}

ffjson: skip

type Tint32 

type Tint32 struct {
	X int32
}

ffjson: skip

type Tint64 

type Tint64 struct {
	X int64
}

ffjson: skip

type Tint8 

type Tint8 struct {
	X int8
}

ffjson: skip

type TintTagged 

type TintTagged struct {
	X int `json:",string"`
}

ffjson: skip

type Tmystring 

type Tmystring struct {
	X mystring
}

ffjson: skip

type TmystringPtr 

type TmystringPtr struct {
	X *mystring
}

ffjson: skip

type Tobj 

type Tobj struct {
	X Tint
}

ffjson: skip

type Tslice 

type Tslice struct {
	X []int
}

ffjson: skip

type TslicePtr 

type TslicePtr struct {
	X []*int
}

ffjson: skip

type TsortName 

type TsortName struct {
	C string
	B int `json:"A"`
}

ffjson: skip

type Tstring 

type Tstring struct {
	X string
}

ffjson: skip

type TstringTagged 

type TstringTagged struct {
	X string `json:",string"`
}

ffjson: skip

type TstringTaggedPtr 

type TstringTaggedPtr struct {
	X *string `json:",string"`
}

ffjson: skip

type TtimePtr 

type TtimePtr struct {
	X *time.Time
}

ffjson: skip

type Tuint 

type Tuint struct {
	X uint
}

ffjson: skip

type Tuint16 

type Tuint16 struct {
	X uint16
}

ffjson: skip

type Tuint32 

type Tuint32 struct {
	X uint32
}

ffjson: skip

type Tuint64 

type Tuint64 struct {
	X uint64
}

ffjson: skip

type Tuint8 

type Tuint8 struct {
	X uint8
}

ffjson: skip

type Tuintptr 

type Tuintptr struct {
	X uintptr
}

ffjson: skip

type Val 

type Val int

Val has Marshaler methods with value receiver.

func (Val) MarshalJSON 

func (Val) MarshalJSON() ([]byte, error)

type ValText 

type ValText int

ValText has Marshaler methods with value receiver.

func (ValText) MarshalText 

func (ValText) MarshalText() ([]byte, error)

type XDominantField 

type XDominantField struct {
	X     *int `json:"Name,omitempty"`
	Y     *int `json:"Name,omitempty"`
	Other string
	Name  *int             `json",omitempty"`
	A     *struct{ X int } `json:"Name,omitempty"`
}

type XEmbeddedStructures 

type XEmbeddedStructures struct {
	X []interface{}
	Y struct {
		X int
	}
	Z []struct {
		X int
	}
	U map[string]struct {
		X int
	}
	V []map[string]struct {
		X int
	}
	W [5]map[string]struct {
		X int
	}
	Q [][]string
}

type XI18nName 

type XI18nName struct {
	Ændret   int64
	Aוההקלדה uint32
	Позната  string
}

type XInlineStructs 

type XInlineStructs struct {
	B struct {
		A uint8
		B uint16
		C uint32
		D uint64

		E int8
		F int16
		G int32
		H int64

		I float32
		J float64

		M byte
		N rune

		O int
		P uint
		Q string
		R bool
		S time.Time

		Ap *uint8
		Bp *uint16
		Cp *uint32
		Dp *uint64

		Ep *int8
		Fp *int16
		Gp *int32
		Hp *int64

		Ip *float32
		Jp *float64

		Mp *byte
		Np *rune

		Op *int
		Pp *uint
		Qp *string
		Rp *bool
		Sp *time.Time

		Aa []uint8
		Ba []uint16
		Ca []uint32
		Da []uint64

		Ea []int8
		Fa []int16
		Ga []int32
		Ha []int64

		Ia []float32
		Ja []float64

		Ma []byte
		Na []rune

		Oa []int
		Pa []uint
		Qa []string
		Ra []bool

		Aap []*uint8
		Bap []*uint16
		Cap []*uint32
		Dap []*uint64

		Eap []*int8
		Fap []*int16
		Gap []*int32
		Hap []*int64

		Iap []*float32
		Jap []*float64

		Map []*byte
		Nap []*rune

		Oap []*int
		Pap []*uint
		Qap []*string
		Rap []*bool
	}
	PtStr *struct {
		X int
	}
	InceptionStr struct {
		Y []struct {
			X *int
		}
	}
}

type XMapStringAString 

type XMapStringAString struct {
	X map[string][3]string
}

type XMapStringMapString 

type XMapStringMapString struct {
	X map[string]map[string]string
}

type XMapStringString 

type XMapStringString struct {
	X map[string]string
}

type XReTyped 

type XReTyped struct {
	A ReTypedA
	B ReTypedB
	C ReTypedC
	D ReTypedD

	E ReTypedE
	F ReTypedF
	G ReTypedG
	H ReTypedH

	I ReTypedI
	J ReTypedJ

	M ReTypedM
	N ReTypedN

	O ReTypedO
	P ReTypedP
	Q ReTypedQ
	R ReTypedR
	S ReTypedS

	Ap ReTypedAp
	Bp ReTypedBp
	Cp ReTypedCp
	Dp ReTypedDp

	Ep ReTypedEp
	Fp ReTypedFp
	Gp ReTypedGp
	Hp ReTypedHp

	Ip ReTypedIp
	Jp ReTypedJp

	Mp ReTypedMp
	Np ReTypedNp

	Op ReTypedOp
	Pp ReTypedPp
	Qp ReTypedQp
	Rp ReTypedRp

	// Bug in encoding/json: Bug in encoding/json: json: cannot unmarshal string into Go value of type tff.ReTypedAa
	// Aa ReTypedAa
	Ba ReTypedBa
	Ca ReTypedCa
	Da ReTypedDa

	Ea ReTypedEa
	Fa ReTypedFa
	Ga ReTypedGa
	Ha ReTypedHa

	Ia ReTypedIa
	Ja ReTypedJa

	// Bug in encoding/json: Bug in encoding/json: json: cannot unmarshal string into Go value of type tff.ReTypedMa
	//Ma ReTypedMa
	Na ReTypedNa

	Oa ReTypedOa
	Pa ReTypedPa
	Qa ReTypedQa
	Ra ReTypedRa

	Aap ReTypedAap
	Bap ReTypedBap
	Cap ReTypedCap
	Dap ReTypedDap

	Eap ReTypedEap
	Fap ReTypedFap
	Gap ReTypedGap
	Hap ReTypedHap

	Iap ReTypedIap
	Jap ReTypedJap

	Map ReTypedMap
	Nap ReTypedNap

	Oap ReTypedOap
	Pap ReTypedPap
	Qap ReTypedQap
	Rap ReTypedRap

	Xa ReTypedXa
	Xb ReTypedXb

	Rra  ReReTypedA
	Rrs  ReReTypedS
	Rrap ReReTypedAp

	// Bug in encoding/json: json: json: cannot unmarshal string into Go value of type tff.ReReTypedAa
	// Rraa  ReReTypedAa
	Rraap ReReTypedAap
	Rrxa  ReReTypedXa
	Rrxb  ReReTypedXb

	Rpra RePReTypedA
	Rsrs ReSReTypedS
}

type XRenameTypes 

type XRenameTypes struct {
	X struct {
		X int
	} `json:"X-renamed"`
	Y NoEncoder  `json:"Y-renamed"`
	Z string     `json:"Z-renamed"`
	U *NoDecoder `json:"U-renamed"`
}

type XSAAtring 

type XSAAtring struct {
	X [2][3]string
}

type XSAString 

type XSAString struct {
	X [][3]string
}

type XTestMaps 

type XTestMaps struct {
	TTestMaps
}

type Xarray 

type Xarray struct {
	X [3]int
}

type XarrayPtr 

type XarrayPtr struct {
	X [3]*int
}

type Xbool 

type Xbool struct {
	X bool
}

type XboolTagged 

type XboolTagged struct {
	X int `json:",string"`
}

type Xbyte 

type Xbyte struct {
	X byte
}

type Xduration 

type Xduration struct {
	X time.Duration
}

type Xfloat32 

type Xfloat32 struct {
	X float32
}

type Xfloat64 

type Xfloat64 struct {
	X float64
}

type Xint 

type Xint struct {
	X int
}

type Xint16 

type Xint16 struct {
	X int16
}

type Xint32 

type Xint32 struct {
	X int32
}

type Xint64 

type Xint64 struct {
	X int64
}

type Xint8 

type Xint8 struct {
	X int8
}

type XintTagged 

type XintTagged struct {
	X int `json:",string"`
}

type Xmystring 

type Xmystring struct {
	X mystring
}

type XmystringPtr 

type XmystringPtr struct {
	X *mystring
}

type Xobj 

type Xobj struct {
	X Xint
}

type Xslice 

type Xslice struct {
	X []int
}

type XslicePtr 

type XslicePtr struct {
	X []*int
}

type XsortName 

type XsortName struct {
	C string
	B int `json:"A"`
}

type Xstring 

type Xstring struct {
	X string
}

type XstringTagged 

type XstringTagged struct {
	X string `json:",string"`
}

type XstringTaggedPtr 

type XstringTaggedPtr struct {
	X *string `json:",string"`
}

type XtimePtr 

type XtimePtr struct {
	X *time.Time
}

type Xuint 

type Xuint struct {
	X uint
}

type Xuint16 

type Xuint16 struct {
	X uint16
}

type Xuint32 

type Xuint32 struct {
	X uint32
}

type Xuint64 

type Xuint64 struct {
	X uint64
}

type Xuint8 

type Xuint8 struct {
	X uint8
}

type Xuintptr 

type Xuintptr struct {
	X uintptr
}

Source Files

View all Source files

Directories

Path Synopsis
go.stripe
base
ff
goser
base
ff
number
ff
types
ff

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.