tff

package

v0.0.0-...-aa0246c Latest Latest Go to latest Published: Sep 30, 2019 License: Apache-2.0 Imports: 3 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/pquerna/ffjson

Links

Open Source Insights

Documentation ¶

Index ¶

Variables
type ATbool
type ATbyte
type ATduration
type ATfloat32
type ATfloat64
type ATint
type ATint16
type ATint32
type ATint64
type ATint8
type ATtime
type ATuint
type ATuint16
type ATuint32
type ATuint64
type ATuint8
type ATuintptr
type AXbool
type AXbyte
type AXduration
type AXfloat32
type AXfloat64
type AXint
type AXint16
type AXint32
type AXint64
type AXint8
type AXtime
type AXuint
type AXuint16
type AXuint32
type AXuint64
type AXuint8
type AXuintptr
type BugA
type BugB
type BugC
type BugD
type BugX
type BugY
type BugZ
type ByteSliceDoubleRenamed
type ByteSliceNormal
type ByteSliceRenamed
type C
- func (C) MarshalJSON() ([]byte, error)
type CText
- func (CText) MarshalText() ([]byte, error)
type FFFoo
type FFRecord
type FfFuzz
type FfFuzzOmitEmpty
type FfFuzzString
type Foo
type FuzzOmitEmpty
type FuzzString
type GiveError
- func (r GiveError) MarshalJSON() ([]byte, error)
- func (r *GiveError) UnmarshalJSON([]byte) error
type IntType
type MyStruct
type NoDecoder
type NoEncoder
type NoExported
type OmitAll
type OmitFirst
type OmitLast
type Optionals
type ReAReTypedAp
type RePReTypedA
type ReReTypedA
type ReReTypedAa
type ReReTypedAap
type ReReTypedAp
type ReReTypedS
type ReReTypedSp
type ReReTypedXa
type ReReTypedXb
type ReReTypedXc
type ReReTypedXd
type ReSReTypedS
type ReTypedA
type ReTypedAa
type ReTypedAap
type ReTypedAp
type ReTypedB
type ReTypedBa
type ReTypedBap
type ReTypedBp
type ReTypedC
type ReTypedCa
type ReTypedCap
type ReTypedCp
type ReTypedD
type ReTypedDa
type ReTypedDap
type ReTypedDp
type ReTypedE
type ReTypedEa
type ReTypedEap
type ReTypedEp
type ReTypedF
type ReTypedFa
type ReTypedFap
type ReTypedFp
type ReTypedG
type ReTypedGa
type ReTypedGap
type ReTypedGp
type ReTypedH
type ReTypedHa
type ReTypedHap
type ReTypedHp
type ReTypedI
type ReTypedIP
type ReTypedIa
type ReTypedIap
type ReTypedJ
type ReTypedJa
type ReTypedJap
type ReTypedJp
type ReTypedM
type ReTypedMa
type ReTypedMap
type ReTypedMp
type ReTypedN
type ReTypedNa
type ReTypedNap
type ReTypedNp
type ReTypedO
type ReTypedOa
type ReTypedOap
type ReTypedOp
type ReTypedP
type ReTypedPa
type ReTypedPap
type ReTypedPp
type ReTypedQ
type ReTypedQa
type ReTypedQap
type ReTypedQp
type ReTypedR
type ReTypedRa
type ReTypedRap
type ReTypedRp
type ReTypedS
type ReTypedSp
type ReTypedXa
type ReTypedXb
type ReTypedXc
type ReTypedXd
type Record
type Ref
- func (*Ref) MarshalJSON() ([]byte, error)
- func (r *Ref) UnmarshalJSON([]byte) error
type RefText
- func (*RefText) MarshalText() ([]byte, error)
- func (r *RefText) UnmarshalText([]byte) error
type STbool
type STbyte
type STduration
type STfloat32
type STfloat64
type STint
type STint16
type STint32
type STint64
type STint8
type STtime
type STuint
type STuint16
type STuint32
type STuint64
type STuint8
type STuintptr
type SXbool
type SXbyte
type SXduration
type SXfloat32
type SXfloat64
type SXint
type SXint16
type SXint32
type SXint64
type SXint8
type SXtime
type SXuint
type SXuint16
type SXuint32
type SXuint64
type SXuint8
type SXuintptr
type StringTag
type TDominantField
type TEmbeddedStructures
type TI18nName
type TInlineStructs
type TMapPtrStruct
type TMapStringAString
type TMapStringMapString
type TMapStringPtr
type TMapStringString
type TReTyped
type TRenameTypes
type TSAAtring
type TSAString
type TTestMaps
type Tarray
type TarrayPtr
type Tbool
type TboolTagged
type Tbyte
type Tduration
type Tfloat32
type Tfloat64
type Tint
type Tint16
type Tint32
type Tint64
type Tint8
type TintTagged
type Tmystring
type TmystringPtr
type Tobj
type Tslice
type TslicePtr
type TslicePtrStruct
type TsortName
type Tstring
type TstringTagged
type TstringTaggedPtr
type TtimePtr
type Tuint
type Tuint16
type Tuint32
type Tuint64
type Tuint8
type Tuintptr
type Val
- func (Val) MarshalJSON() ([]byte, error)
type ValText
- func (ValText) MarshalText() ([]byte, error)
type XDominantField
type XEmbeddedStructures
type XI18nName
type XInlineStructs
type XMapPtrStruct
type XMapStringAString
type XMapStringMapString
type XMapStringPtr
type XMapStringString
type XReTyped
type XRenameTypes
type XSAAtring
type XSAString
type XTestMaps
type Xarray
type XarrayPtr
type Xbool
type XboolTagged
type Xbyte
type Xduration
type Xfloat32
type Xfloat64
type Xint
type Xint16
type Xint32
type Xint64
type Xint8
type XintTagged
type Xmystring
type XmystringPtr
type Xobj
type Xslice
type XslicePtr
type XslicePtrStruct
type XsortName
type Xstring
type XstringTagged
type XstringTaggedPtr
type XtimePtr
type Xuint
type Xuint16
type Xuint32
type Xuint64
type Xuint8
type Xuintptr

Constants ¶

This section is empty.

Variables ¶

View Source

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

ErrGiveError generates error

Functions ¶

This section is empty.

Types ¶

type ATbool ¶

type ATbool struct {
	X [3]bool
}

ATbool struct ffjson: skip

type ATbyte ¶

type ATbyte struct {
	X [3]byte
}

ATbyte struct ffjson: skip

type ATduration ¶

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

ATduration struct Arrays ffjson: skip

type ATfloat32 ¶

type ATfloat32 struct {
	X [3]float32
}

ATfloat32 struct ffjson: skip

type ATfloat64 ¶

type ATfloat64 struct {
	X [3]float64
}

ATfloat64 struct ffjson: skip

type ATint ¶

type ATint struct {
	X [3]int
}

ATint struct ffjson: skip

type ATint16 ¶

type ATint16 struct {
	X [3]int16
}

ATint16 struct ffjson: skip

type ATint32 ¶

type ATint32 struct {
	X [3]int32
}

ATint32 struct ffjson: skip

type ATint64 ¶

type ATint64 struct {
	X [3]int64
}

ATint64 struct ffjson: skip

type ATint8 ¶

type ATint8 struct {
	X [3]int8
}

ATint8 struct ffjson: skip

type ATtime ¶

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

ATtime struct ffjson: skip

type ATuint ¶

type ATuint struct {
	X [3]uint
}

ATuint struct ffjson: skip

type ATuint16 ¶

type ATuint16 struct {
	X [3]uint16
}

ATuint16 struct ffjson: skip

type ATuint32 ¶

type ATuint32 struct {
	X [3]uint32
}

ATuint32 struct ffjson: skip

type ATuint64 ¶

type ATuint64 struct {
	X [3]uint64
}

ATuint64 struct ffjson: skip

type ATuint8 ¶

type ATuint8 struct {
	X [3]uint8
}

ATuint8 struct ffjson: skip

type ATuintptr ¶

type ATuintptr struct {
	X [3]uintptr
}

ATuintptr struct ffjson: skip

type AXbool ¶

type AXbool struct {
	X [3]bool
}

AXbool struct

type AXbyte ¶

type AXbyte struct {
	X [3]byte
}

AXbyte struct

type AXduration ¶

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

AXduration struct

type AXfloat32 ¶

type AXfloat32 struct {
	X [3]float32
}

AXfloat32 struct

type AXfloat64 ¶

type AXfloat64 struct {
	X [3]float64
}

AXfloat64 struct

type AXint ¶

type AXint struct {
	X [3]int
}

AXint struct

type AXint16 ¶

type AXint16 struct {
	X [3]int16
}

AXint16 struct

type AXint32 ¶

type AXint32 struct {
	X [3]int32
}

AXint32 struct

type AXint64 ¶

type AXint64 struct {
	X [3]int64
}

AXint64 struct

type AXint8 ¶

type AXint8 struct {
	X [3]int8
}

AXint8 struct

type AXtime ¶

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

AXtime struct

type AXuint ¶

type AXuint struct {
	X [3]uint
}

AXuint struct

type AXuint16 ¶

type AXuint16 struct {
	X [3]uint16
}

AXuint16 struct

type AXuint32 ¶

type AXuint32 struct {
	X [3]uint32
}

AXuint32 struct

type AXuint64 ¶

type AXuint64 struct {
	X [3]uint64
}

AXuint64 struct

type AXuint8 ¶

type AXuint8 struct {
	X [3]uint8
}

AXuint8 struct

type AXuintptr ¶

type AXuintptr struct {
	X [3]uintptr
}

AXuintptr struct

type BugA ¶

type BugA struct {
	S string
}

BugA struct

type BugB ¶

type BugB struct {
	BugA
	S string
}

BugB struct

type BugC ¶

type BugC struct {
	S string
}

BugC struct

type BugD ¶

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

BugD struct

type BugX ¶

type BugX struct {
	A int
	BugA
	BugB
}

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

type BugY ¶

type BugY struct {
	BugA
	BugD
}

BugY struct 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.
}

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

type ByteSliceDoubleRenamed ¶

type ByteSliceDoubleRenamed struct {
	X renamedRenamedByteSlice
}

ByteSliceDoubleRenamed struct

type ByteSliceNormal ¶

type ByteSliceNormal struct {
	X []byte
}

ByteSliceNormal struct

type ByteSliceRenamed ¶

type ByteSliceRenamed struct {
	X renamedByteSlice
}

ByteSliceRenamed stuct

type C ¶

type C int

C implements Marshaler and returns unescaped JSON.

func (C) MarshalJSON ¶

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

MarshalJSON func

type CText ¶

type CText int

CText implements Marshaler and returns unescaped text.

func (CText) MarshalText ¶

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

MarshalText func

type FFFoo ¶

type FFFoo struct {
	Blah int
}

FFFoo struc... just blah

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
}

FFRecord struct

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
}

FfFuzz struct

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"`
}

FfFuzzOmitEmpty struct

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"`
}

FfFuzzString struct

type Foo ¶

type Foo struct {
	Blah int
}

Foo struct

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"`
}

FuzzOmitEmpty struct 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"`
}

FuzzString struct ffjson: skip

type GiveError ¶

type GiveError struct{}

GiveError always returns an ErrGiveError on Marshal/Unmarshal.

func (GiveError) MarshalJSON ¶

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

MarshalJSON func

func (*GiveError) UnmarshalJSON ¶

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

UnmarshalJSON func

type IntType ¶

type IntType int

IntType type

type MyStruct ¶

type MyStruct struct {
	IntType
}

MyStruct struc

type NoDecoder ¶

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

NoDecoder struct ffjson: nodecoder

type NoEncoder ¶

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

NoEncoder struct ffjson: noencoder

type NoExported ¶

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

NoExported struct

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"`
}

OmitAll struct

type OmitFirst ¶

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

OmitFirst struct

type OmitLast ¶

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

OmitLast struct

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"`
}

Optionals tests from golang test suite

type ReAReTypedAp ¶

type ReAReTypedAp [4]ReTypedAp

ReAReTypedAp type

type RePReTypedA ¶

type RePReTypedA *ReTypedA

RePReTypedA type

type ReReTypedA ¶

type ReReTypedA ReTypedA

ReReTypedA type

type ReReTypedAa ¶

type ReReTypedAa ReTypedAa

ReReTypedAa type

type ReReTypedAap ¶

type ReReTypedAap ReTypedAap

ReReTypedAap type

type ReReTypedAp ¶

type ReReTypedAp ReTypedAp

ReReTypedAp type

type ReReTypedS ¶

type ReReTypedS ReTypedS

ReReTypedS type

type ReReTypedSp ¶

type ReReTypedSp ReTypedSp

ReReTypedSp type

type ReReTypedXa ¶

type ReReTypedXa ReTypedXa

ReReTypedXa type

type ReReTypedXb ¶

type ReReTypedXb ReTypedXb

ReReTypedXb type

type ReReTypedXc ¶

type ReReTypedXc ReTypedXc

ReReTypedXc type

type ReReTypedXd ¶

type ReReTypedXd ReTypedXd

ReReTypedXd type

type ReSReTypedS ¶

type ReSReTypedS []ReTypedS

ReSReTypedS type

type ReTypedA ¶

type ReTypedA uint8

ReTypedA type

type ReTypedAa ¶

type ReTypedAa []uint8

ReTypedAa type

type ReTypedAap ¶

type ReTypedAap []*uint8

ReTypedAap type

type ReTypedAp ¶

type ReTypedAp *uint8

ReTypedAp type

type ReTypedB ¶

type ReTypedB uint16

ReTypedB type

type ReTypedBa ¶

type ReTypedBa []uint16

ReTypedBa type

type ReTypedBap ¶

type ReTypedBap []*uint16

ReTypedBap type

type ReTypedBp ¶

type ReTypedBp *uint16

ReTypedBp type

type ReTypedC ¶

type ReTypedC uint32

ReTypedC type

type ReTypedCa ¶

type ReTypedCa []uint32

ReTypedCa type

type ReTypedCap ¶

type ReTypedCap []*uint32

ReTypedCap type

type ReTypedCp ¶

type ReTypedCp *uint32

ReTypedCp type

type ReTypedD ¶

type ReTypedD uint64

ReTypedD type

type ReTypedDa ¶

type ReTypedDa []uint64

ReTypedDa type

type ReTypedDap ¶

type ReTypedDap []*uint64

ReTypedDap type

type ReTypedDp ¶

type ReTypedDp *uint64

ReTypedDp type

type ReTypedE ¶

type ReTypedE int8

ReTypedE type

type ReTypedEa ¶

type ReTypedEa []int8

ReTypedEa type

type ReTypedEap ¶

type ReTypedEap []*int8

ReTypedEap type

type ReTypedEp ¶

type ReTypedEp *int8

ReTypedEp type

type ReTypedF ¶

type ReTypedF int16

ReTypedF type

type ReTypedFa ¶

type ReTypedFa []int16

ReTypedFa type

type ReTypedFap ¶

type ReTypedFap []*int16

ReTypedFap type

type ReTypedFp ¶

type ReTypedFp *int16

ReTypedFp type

type ReTypedG ¶

type ReTypedG int32

ReTypedG type

type ReTypedGa ¶

type ReTypedGa []int32

ReTypedGa type

type ReTypedGap ¶

type ReTypedGap []*int32

ReTypedGap type

type ReTypedGp ¶

type ReTypedGp *int32

ReTypedGp type

type ReTypedH ¶

type ReTypedH int64

ReTypedH type

type ReTypedHa ¶

type ReTypedHa []int64

ReTypedHa type

type ReTypedHap ¶

type ReTypedHap []*int64

ReTypedHap type

type ReTypedHp ¶

type ReTypedHp *int64

ReTypedHp type

type ReTypedI ¶

type ReTypedI float32

ReTypedI type

type ReTypedIP ¶

type ReTypedIP *float32

ReTypedIP type

type ReTypedIa ¶

type ReTypedIa []float32

ReTypedIa type

type ReTypedIap ¶

type ReTypedIap []*float32

ReTypedIap type

type ReTypedJ ¶

type ReTypedJ float64

ReTypedJ type

type ReTypedJa ¶

type ReTypedJa []float64

ReTypedJa type

type ReTypedJap ¶

type ReTypedJap []*float64

ReTypedJap type

type ReTypedJp ¶

type ReTypedJp *float64

ReTypedJp type

type ReTypedM ¶

type ReTypedM byte

ReTypedM type

type ReTypedMa ¶

type ReTypedMa []byte

ReTypedMa type

type ReTypedMap ¶

type ReTypedMap []*byte

ReTypedMap type

type ReTypedMp ¶

type ReTypedMp *byte

ReTypedMp type

type ReTypedN ¶

type ReTypedN rune

ReTypedN type

type ReTypedNa ¶

type ReTypedNa []rune

ReTypedNa type

type ReTypedNap ¶

type ReTypedNap []*rune

ReTypedNap type

type ReTypedNp ¶

type ReTypedNp *rune

ReTypedNp type

type ReTypedO ¶

type ReTypedO int

ReTypedO type

type ReTypedOa ¶

type ReTypedOa []int

ReTypedOa type

type ReTypedOap ¶

type ReTypedOap []*int

ReTypedOap type

type ReTypedOp ¶

type ReTypedOp *int

ReTypedOp type

type ReTypedP ¶

type ReTypedP uint

ReTypedP type

type ReTypedPa ¶

type ReTypedPa []uint

ReTypedPa type

type ReTypedPap ¶

type ReTypedPap []*uint

ReTypedPap type

type ReTypedPp ¶

type ReTypedPp *uint

ReTypedPp type

type ReTypedQ ¶

type ReTypedQ string

ReTypedQ type

type ReTypedQa ¶

type ReTypedQa []string

ReTypedQa type

type ReTypedQap ¶

type ReTypedQap []*string

ReTypedQap type

type ReTypedQp ¶

type ReTypedQp *string

ReTypedQp type

type ReTypedR ¶

type ReTypedR bool

ReTypedR type

type ReTypedRa ¶

type ReTypedRa []bool

ReTypedRa type

type ReTypedRap ¶

type ReTypedRap []*bool

ReTypedRap type

type ReTypedRp ¶

type ReTypedRp *bool

ReTypedRp type

type ReTypedS ¶

type ReTypedS time.Time

ReTypedS type

type ReTypedSp ¶

type ReTypedSp *time.Time

ReTypedSp type

type ReTypedXa ¶

type ReTypedXa NoDecoder

ReTypedXa type

type ReTypedXb ¶

type ReTypedXb NoEncoder

ReTypedXb type

type ReTypedXc ¶

type ReTypedXc *NoDecoder

ReTypedXc type

type ReTypedXd ¶

type ReTypedXd *NoEncoder

ReTypedXd type

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
}

Record struct

type Ref ¶

type Ref int

Ref has Marshaler and Unmarshaler methods with pointer receiver.

func (*Ref) MarshalJSON ¶

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

MarshalJSON func

func (*Ref) UnmarshalJSON ¶

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

UnmarshalJSON func

type RefText ¶

type RefText int

RefText has Marshaler and Unmarshaler methods with pointer receiver.

func (*RefText) MarshalText ¶

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

MarshalText func

func (*RefText) UnmarshalText ¶

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

UnmarshalText func

type STbool ¶

type STbool struct {
	X []bool
}

STbool struct ffjson: skip

type STbyte ¶

type STbyte struct {
	X []byte
}

STbyte struct ffjson: skip

type STduration ¶

type STduration struct {
	X []time.Duration
}

STduration struct Slices ffjson: skip

type STfloat32 ¶

type STfloat32 struct {
	X []float32
}

STfloat32 struct ffjson: skip

type STfloat64 ¶

type STfloat64 struct {
	X []float64
}

STfloat64 struct ffjson: skip

type STint ¶

type STint struct {
	X []int
}

STint struct ffjson: skip

type STint16 ¶

type STint16 struct {
	X []int16
}

STint16 struct ffjson: skip

type STint32 ¶

type STint32 struct {
	X []int32
}

STint32 struct ffjson: skip

type STint64 ¶

type STint64 struct {
	X []int64
}

STint64 struct ffjson: skip

type STint8 ¶

type STint8 struct {
	X []int8
}

STint8 struct ffjson: skip

type STtime ¶

type STtime struct {
	X []time.Time
}

STtime struct ffjson: skip

type STuint ¶

type STuint struct {
	X []uint
}

STuint struct ffjson: skip

type STuint16 ¶

type STuint16 struct {
	X []uint16
}

STuint16 struct ffjson: skip

type STuint32 ¶

type STuint32 struct {
	X []uint32
}

STuint32 struct ffjson: skip

type STuint64 ¶

type STuint64 struct {
	X []uint64
}

STuint64 struct ffjson: skip

type STuint8 ¶

type STuint8 struct {
	X []uint8
}

STuint8 struct ffjson: skip

type STuintptr ¶

type STuintptr struct {
	X []uintptr
}

STuintptr struct ffjson: skip

type SXbool ¶

type SXbool struct {
	X []bool
}

SXbool struct

type SXbyte ¶

type SXbyte struct {
	X []byte
}

SXbyte struct

type SXduration ¶

type SXduration struct {
	X []time.Duration
}

SXduration struct

type SXfloat32 ¶

type SXfloat32 struct {
	X []float32
}

SXfloat32 struct

type SXfloat64 ¶

type SXfloat64 struct {
	X []float64
}

SXfloat64 struct

type SXint ¶

type SXint struct {
	X []int
}

SXint struct

type SXint16 ¶

type SXint16 struct {
	X []int16
}

SXint16 struct

type SXint32 ¶

type SXint32 struct {
	X []int32
}

SXint32 struct

type SXint64 ¶

type SXint64 struct {
	X []int64
}

SXint64 struct

type SXint8 ¶

type SXint8 struct {
	X []int8
}

SXint8 struct

type SXtime ¶

type SXtime struct {
	X []time.Time
}

SXtime struct

type SXuint ¶

type SXuint struct {
	X []uint
}

SXuint struct

type SXuint16 ¶

type SXuint16 struct {
	X []uint16
}

SXuint16 struct

type SXuint32 ¶

type SXuint32 struct {
	X []uint32
}

SXuint32 struct

type SXuint64 ¶

type SXuint64 struct {
	X []uint64
}

SXuint64 struct

type SXuint8 ¶

type SXuint8 struct {
	X []uint8
}

SXuint8 struct

type SXuintptr ¶

type SXuintptr struct {
	X []uintptr
}

SXuintptr struct

type StringTag ¶

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

StringTag struct

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"`
}

TDominantField struct 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
}

TEmbeddedStructures struct ffjson: skip

type TI18nName ¶

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

TI18nName struct 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
		}
	}
}

TInlineStructs struct ffjson: skip

type TMapPtrStruct ¶

type TMapPtrStruct struct {
	X map[string]*Xstring
}

TMapPtrStruct struct ffjson: skip

type TMapStringAString ¶

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

TMapStringAString struct ffjson: skip

type TMapStringMapString ¶

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

TMapStringMapString struct Nested ffjson: skip

type TMapStringPtr ¶

type TMapStringPtr struct {
	X map[string]*int
}

TMapStringPtr struct ffjson: skip

type TMapStringString ¶

type TMapStringString struct {
	X map[string]string
}

TMapStringString struct 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
}

TReTyped struct 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"`
}

TRenameTypes struct 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
}

TSAAtring struct ffjson: skip

type TSAString ¶

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

TSAString struct 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
}

TTestMaps struct ffjson: skip

type Tarray ¶

type Tarray struct {
	X [3]int
}

Tarray struct ffjson: skip

type TarrayPtr ¶

type TarrayPtr struct {
	X [3]*int
}

TarrayPtr struct ffjson: skip

type Tbool ¶

type Tbool struct {
	X bool
}

Tbool struct ffjson: skip

type TboolTagged ¶

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

TboolTagged struct ffjson: skip

type Tbyte ¶

type Tbyte struct {
	X byte
}

Tbyte struct ffjson: skip

type Tduration ¶

type Tduration struct {
	X time.Duration
}

Tduration struct ffjson: skip

type Tfloat32 ¶

type Tfloat32 struct {
	X float32
}

Tfloat32 struct ffjson: skip

type Tfloat64 ¶

type Tfloat64 struct {
	X float64
}

Tfloat64 struct ffjson: skip

type Tint ¶

type Tint struct {
	X int
}

Tint struct ffjson: skip

type Tint16 ¶

type Tint16 struct {
	X int16
}

Tint16 struct ffjson: skip

type Tint32 ¶

type Tint32 struct {
	X int32
}

Tint32 struct ffjson: skip

type Tint64 ¶

type Tint64 struct {
	X int64
}

Tint64 struct ffjson: skip

type Tint8 ¶

type Tint8 struct {
	X int8
}

Tint8 struct ffjson: skip

type TintTagged ¶

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

TintTagged struct ffjson: skip

type Tmystring ¶

type Tmystring struct {
	X mystring
}

Tmystring struct ffjson: skip

type TmystringPtr ¶

type TmystringPtr struct {
	X *mystring
}

TmystringPtr struct ffjson: skip

type Tobj ¶

type Tobj struct {
	X Tint
}

Tobj struct ffjson: skip

type Tslice ¶

type Tslice struct {
	X []int
}

Tslice struct ffjson: skip

type TslicePtr ¶

type TslicePtr struct {
	X []*int
}

TslicePtr struct ffjson: skip

type TslicePtrStruct ¶

type TslicePtrStruct struct {
	X []*Xstring
}

TslicePtrStruct struct ffjson: skip

type TsortName ¶

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

TsortName struct ffjson: skip

type Tstring ¶

type Tstring struct {
	X string
}

Tstring struct ffjson: skip

type TstringTagged ¶

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

TstringTagged struct ffjson: skip

type TstringTaggedPtr ¶

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

TstringTaggedPtr struct ffjson: skip

type TtimePtr ¶

type TtimePtr struct {
	X *time.Time
}

TtimePtr struct ffjson: skip

type Tuint ¶

type Tuint struct {
	X uint
}

Tuint struct ffjson: skip

type Tuint16 ¶

type Tuint16 struct {
	X uint16
}

Tuint16 struct ffjson: skip

type Tuint32 ¶

type Tuint32 struct {
	X uint32
}

Tuint32 struct ffjson: skip

type Tuint64 ¶

type Tuint64 struct {
	X uint64
}

Tuint64 struct ffjson: skip

type Tuint8 ¶

type Tuint8 struct {
	X uint8
}

Tuint8 struct ffjson: skip

type Tuintptr ¶

type Tuintptr struct {
	X uintptr
}

Tuintptr struct ffjson: skip

type Val ¶

type Val int

Val has Marshaler methods with value receiver.

func (Val) MarshalJSON ¶

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

MarshalJSON var

type ValText ¶

type ValText int

ValText has Marshaler methods with value receiver.

func (ValText) MarshalText ¶

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

MarshalText val

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"`
}

XDominantField struct

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
}

XEmbeddedStructures struct

type XI18nName ¶

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

XI18nName struct

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
		}
	}
}

XInlineStructs struct

type XMapPtrStruct ¶

type XMapPtrStruct struct {
	X map[string]*Xstring
}

XMapPtrStruct struct

type XMapStringAString ¶

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

XMapStringAString struct

type XMapStringMapString ¶

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

XMapStringMapString struct

type XMapStringPtr ¶

type XMapStringPtr struct {
	X map[string]*int
}

XMapStringPtr struct

type XMapStringString ¶

type XMapStringString struct {
	X map[string]string
}

XMapStringString struct

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
}

XReTyped struct

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"`
}

XRenameTypes struct

type XSAAtring ¶

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

XSAAtring struct

type XSAString ¶

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

XSAString struct

type XTestMaps ¶

type XTestMaps struct {
	TTestMaps
}

XTestMaps struct

type Xarray ¶

type Xarray struct {
	X [3]int
}

Xarray struct

type XarrayPtr ¶

type XarrayPtr struct {
	X [3]*int
}

XarrayPtr struct

type Xbool ¶

type Xbool struct {
	X bool
}

Xbool struct

type XboolTagged ¶

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

XboolTagged struct

type Xbyte ¶

type Xbyte struct {
	X byte
}

Xbyte struct

type Xduration ¶

type Xduration struct {
	X time.Duration
}

Xduration struct

type Xfloat32 ¶

type Xfloat32 struct {
	X float32
}

Xfloat32 struct

type Xfloat64 ¶

type Xfloat64 struct {
	X float64
}

Xfloat64 struct

type Xint ¶

type Xint struct {
	X int
}

Xint struct

type Xint16 ¶

type Xint16 struct {
	X int16
}

Xint16 stuct

type Xint32 ¶

type Xint32 struct {
	X int32
}

Xint32 struct

type Xint64 ¶

type Xint64 struct {
	X int64
}

Xint64 struct

type Xint8 ¶

type Xint8 struct {
	X int8
}

Xint8 struct

type XintTagged ¶

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

XintTagged struct

type Xmystring ¶

type Xmystring struct {
	X mystring
}

Xmystring struct

type XmystringPtr ¶

type XmystringPtr struct {
	X *mystring
}

XmystringPtr struct

type Xobj ¶

type Xobj struct {
	X Xint
}

Xobj struct

type Xslice ¶

type Xslice struct {
	X []int
}

Xslice struct

type XslicePtr ¶

type XslicePtr struct {
	X []*int
}

XslicePtr struct

type XslicePtrStruct ¶

type XslicePtrStruct struct {
	X []*Xstring
}

XslicePtrStruct struct

type XsortName ¶

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

XsortName struct

type Xstring ¶

type Xstring struct {
	X string
}

Xstring struct

type XstringTagged ¶

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

XstringTagged struct

type XstringTaggedPtr ¶

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

XstringTaggedPtr struct

type XtimePtr ¶

type XtimePtr struct {
	X *time.Time
}

XtimePtr struct

type Xuint ¶

type Xuint struct {
	X uint
}

Xuint struct

type Xuint16 ¶

type Xuint16 struct {
	X uint16
}

Xuint16 struct

type Xuint32 ¶

type Xuint32 struct {
	X uint32
}

Xuint32 struct

type Xuint64 ¶

type Xuint64 struct {
	X uint64
}

Xuint64 struct

type Xuint8 ¶

type Xuint8 struct {
	X uint8
}

Xuint8 struct

type Xuintptr ¶

type Xuintptr struct {
	X uintptr
}

Xuintptr struct

Source Files ¶

View all Source files

Directories ¶

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

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL