tff

package

v0.0.0-...-184f786 Latest Latest Go to latest Published: Aug 4, 2015 License: Apache-2.0 Imports: 3 Imported by: 0

Details

Valid go.mod file
Redistributable license
Tagged version
Stable version
Learn more about best practices

Repository

github.com/guojun1992/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 ReTypedIa
type ReTypedIap
type ReTypedIp
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 StringTag
type TDominantField
type TEmbeddedStructures
type TI18nName
type TInlineStructs
type TMapStringString
type TReTyped
type TRenameTypes
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 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 XMapStringString
type XReTyped
type XRenameTypes
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 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")

Functions ¶

This section is empty.

Types ¶

type ATbool ¶

type ATbool struct {
	X []bool
}

ffjson: skip

type ATbyte ¶

type ATbyte struct {
	X []byte
}

ffjson: skip

type ATduration ¶

type ATduration struct {
	X []time.Duration
}

Arrays ffjson: skip

type ATfloat32 ¶

type ATfloat32 struct {
	X []float32
}

ffjson: skip

type ATfloat64 ¶

type ATfloat64 struct {
	X []float64
}

ffjson: skip

type ATint ¶

type ATint struct {
	X []int
}

ffjson: skip

type ATint16 ¶

type ATint16 struct {
	X []int16
}

ffjson: skip

type ATint32 ¶

type ATint32 struct {
	X []int32
}

ffjson: skip

type ATint64 ¶

type ATint64 struct {
	X []int64
}

ffjson: skip

type ATint8 ¶

type ATint8 struct {
	X []int8
}

ffjson: skip

type ATtime ¶

type ATtime struct {
	X []time.Time
}

ffjson: skip

type ATuint ¶

type ATuint struct {
	X []uint
}

ffjson: skip

type ATuint16 ¶

type ATuint16 struct {
	X []uint16
}

ffjson: skip

type ATuint32 ¶

type ATuint32 struct {
	X []uint32
}

ffjson: skip

type ATuint64 ¶

type ATuint64 struct {
	X []uint64
}

ffjson: skip

type ATuint8 ¶

type ATuint8 struct {
	X []uint8
}

ffjson: skip

type ATuintptr ¶

type ATuintptr struct {
	X []uintptr
}

ffjson: skip

type AXbool ¶

type AXbool struct {
	X []bool
}

type AXbyte ¶

type AXbyte struct {
	X []byte
}

type AXduration ¶

type AXduration struct {
	X []time.Duration
}

type AXfloat32 ¶

type AXfloat32 struct {
	X []float32
}

type AXfloat64 ¶

type AXfloat64 struct {
	X []float64
}

type AXint ¶

type AXint struct {
	X []int
}

type AXint16 ¶

type AXint16 struct {
	X []int16
}

type AXint32 ¶

type AXint32 struct {
	X []int32
}

type AXint64 ¶

type AXint64 struct {
	X []int64
}

type AXint8 ¶

type AXint8 struct {
	X []int8
}

type AXtime ¶

type AXtime struct {
	X []time.Time
}

type AXuint ¶

type AXuint struct {
	X []uint
}

type AXuint16 ¶

type AXuint16 struct {
	X []uint16
}

type AXuint32 ¶

type AXuint32 struct {
	X []uint32
}

type AXuint64 ¶

type AXuint64 struct {
	X []uint64
}

type AXuint8 ¶

type AXuint8 struct {
	X []uint8
}

type AXuintptr ¶

type AXuintptr struct {
	X []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 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 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 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 []int
}

ffjson: skip

type TarrayPtr ¶

type TarrayPtr struct {
	X []*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 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 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 XTestMaps ¶

type XTestMaps struct {
	TTestMaps
}

type Xarray ¶

type Xarray struct {
	X []int
}

type XarrayPtr ¶

type XarrayPtr struct {
	X []*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 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
types
ff

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