// +build !notfastpath

// Copyright (c) 2012-2015 Ugorji Nwoke. All rights reserved.
// Use of this source code is governed by a MIT license found in the LICENSE file.

// ************************************************************
// DO NOT EDIT. 
// THIS FILE IS AUTO-GENERATED from fast-path.go.tmpl
// ************************************************************

package codec

// Fast path functions try to create a fast path encode or decode implementation
// for common maps and slices.
//
// We define the functions and register then in this single file
// so as not to pollute the encode.go and decode.go, and create a dependency in there.
// This file can be omitted without causing a build failure.
//
// The advantage of fast paths is:
//    - Many calls bypass reflection altogether
// 
// Currently support
//    - slice of all builtin types,
//    - map of all builtin types to string or interface value
//    - symmetrical maps of all builtin types (e.g. str-str, uint8-uint8)
// This should provide adequate "typical" implementations.
// 
// Note that fast track decode functions must handle values for which an address cannot be obtained.
// For example: 
//   m2 := map[string]int{}
//   p2 := []interface{}{m2}
//   // decoding into p2 will bomb if fast track functions do not treat like unaddressable.
// 

import (
	"reflect"
	"sort"
)

const fastpathEnabled = true

const fastpathCheckNilFalse = false // for reflect
const fastpathCheckNilTrue = true // for type switch

type fastpathT struct {}

var fastpathTV fastpathT

type fastpathE struct {
	rtid uintptr
	rt reflect.Type 
	encfn func(*encFnInfo, reflect.Value)
	decfn func(*decFnInfo, reflect.Value)
}

type fastpathA [{{ .FastpathLen }}]fastpathE

func (x *fastpathA) index(rtid uintptr) int {
	// use binary search to grab the index (adapted from sort/search.go)
	h, i, j := 0, 0, {{ .FastpathLen }} // len(x)
	for i < j {
		h = i + (j-i)/2
		if x[h].rtid < rtid {
			i = h + 1
		} else {
			j = h
		}
	}
	if i < {{ .FastpathLen }} && x[i].rtid == rtid {
		return i
	}
	return -1
}

type fastpathAslice []fastpathE

func (x fastpathAslice) Len() int { return len(x) }
func (x fastpathAslice) Less(i, j int) bool { return x[i].rtid < x[j].rtid }
func (x fastpathAslice) Swap(i, j int) { x[i], x[j] = x[j], x[i] }

var fastpathAV fastpathA

// due to possible initialization loop error, make fastpath in an init()
func init() {
	i := 0
	fn := func(v interface{}, fe func(*encFnInfo, reflect.Value), fd func(*decFnInfo, reflect.Value)) (f fastpathE) {
		xrt := reflect.TypeOf(v)
		xptr := reflect.ValueOf(xrt).Pointer()
		fastpathAV[i] = fastpathE{xptr, xrt, fe, fd}
		i++
		return
	}
	
	{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
	fn([]{{ .Elem }}(nil), (*encFnInfo).{{ .MethodNamePfx "fastpathEnc" false }}R, (*decFnInfo).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
	
	{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
	fn(map[{{ .MapKey }}]{{ .Elem }}(nil), (*encFnInfo).{{ .MethodNamePfx "fastpathEnc" false }}R, (*decFnInfo).{{ .MethodNamePfx "fastpathDec" false }}R){{end}}{{end}}{{end}}
	
	sort.Sort(fastpathAslice(fastpathAV[:]))
}

// -- encode

// -- -- fast path type switch
func fastpathEncodeTypeSwitch(iv interface{}, e *Encoder) bool {
	switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
	case []{{ .Elem }}:{{else}}
	case map[{{ .MapKey }}]{{ .Elem }}:{{end}}
		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e){{if not .MapKey }}
	case *[]{{ .Elem }}:{{else}}
	case *map[{{ .MapKey }}]{{ .Elem }}:{{end}}
		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
{{end}}{{end}}
	default:
        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
		return false
	}
	return true
}

func fastpathEncodeTypeSwitchSlice(iv interface{}, e *Encoder) bool {
	switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
	case []{{ .Elem }}:
		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e)
	case *[]{{ .Elem }}:
		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
{{end}}{{end}}{{end}}
	default:
        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
		return false
	}
	return true
}

func fastpathEncodeTypeSwitchMap(iv interface{}, e *Encoder) bool {
	switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
	case map[{{ .MapKey }}]{{ .Elem }}:
		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(v, fastpathCheckNilTrue, e)
	case *map[{{ .MapKey }}]{{ .Elem }}:
		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(*v, fastpathCheckNilTrue, e)
{{end}}{{end}}{{end}}
	default:
        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
		return false
	}
	return true
}

// -- -- fast path functions
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }} 

func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) {
	if f.ti.mbs {
		fastpathTV.{{ .MethodNamePfx "EncAsMap" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
	} else {
		fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv.Interface().([]{{ .Elem }}), fastpathCheckNilFalse, f.e)
	}
}
func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
	ee := e.e
	cr := e.cr
	if checkNil && v == nil {
		ee.EncodeNil()
		return
	}
	ee.EncodeArrayStart(len(v))
	for _, v2 := range v {
		if cr != nil { cr.sendContainerState(containerArrayElem) }
		{{ encmd .Elem "v2"}}
	}
	if cr != nil { cr.sendContainerState(containerArrayEnd) }{{/* ee.EncodeEnd() */}}
}

func (_ fastpathT) {{ .MethodNamePfx "EncAsMap" false }}V(v []{{ .Elem }}, checkNil bool, e *Encoder) {
	ee := e.e
	cr := e.cr
	if checkNil && v == nil {
		ee.EncodeNil()
		return
	}
	if len(v)%2 == 1 {
		e.errorf("mapBySlice requires even slice length, but got %v", len(v))
		return
	}
	ee.EncodeMapStart(len(v) / 2)
	for j, v2 := range v {
		if cr != nil {
			if j%2 == 0 {
				cr.sendContainerState(containerMapKey)
			} else {
				cr.sendContainerState(containerMapValue)
			}
		}
		{{ encmd .Elem "v2"}}
	}
	if cr != nil { cr.sendContainerState(containerMapEnd) }
}

{{end}}{{end}}{{end}}

{{range .Values}}{{if not .Primitive}}{{if .MapKey }}

func (f *encFnInfo) {{ .MethodNamePfx "fastpathEnc" false }}R(rv reflect.Value) {
	fastpathTV.{{ .MethodNamePfx "Enc" false }}V(rv.Interface().(map[{{ .MapKey }}]{{ .Elem }}), fastpathCheckNilFalse, f.e)
}
func (_ fastpathT) {{ .MethodNamePfx "Enc" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, e *Encoder) {
	ee := e.e
	cr := e.cr
	if checkNil && v == nil {
		ee.EncodeNil()
		return
	}
	ee.EncodeMapStart(len(v))
	{{if eq .MapKey "string"}}asSymbols := e.h.AsSymbols&AsSymbolMapStringKeysFlag != 0
	{{end}}if e.h.Canonical {
		{{if eq .MapKey "interface{}"}}{{/* out of band 
		*/}}var mksv []byte = make([]byte, 0, len(v)*16) // temporary byte slice for the encoding
		e2 := NewEncoderBytes(&mksv, e.hh)
		v2 := make([]bytesI, len(v))
		var i, l int
		var vp *bytesI {{/* put loop variables outside. seems currently needed for better perf */}}
		for k2, _ := range v {
			l = len(mksv)
			e2.MustEncode(k2)
			vp = &v2[i]
			vp.v = mksv[l:]
			vp.i = k2 
			i++
		}
		sort.Sort(bytesISlice(v2))
		for j := range v2 {
			if cr != nil { cr.sendContainerState(containerMapKey) }
			e.asis(v2[j].v)
			if cr != nil { cr.sendContainerState(containerMapValue) }
			e.encode(v[v2[j].i])
		} {{else}}{{ $x := sorttype .MapKey true}}v2 := make([]{{ $x }}, len(v))
		var i int 
		for k, _ := range v {
			v2[i] = {{ $x }}(k)
			i++
		}
		sort.Sort({{ sorttype .MapKey false}}(v2))
		for _, k2 := range v2 {
			if cr != nil { cr.sendContainerState(containerMapKey) }
			{{if eq .MapKey "string"}}if asSymbols {
				ee.EncodeSymbol(k2)
			} else {
				ee.EncodeString(c_UTF8, k2)
			}{{else}}{{ $y := printf "%s(k2)" .MapKey }}{{ encmd .MapKey $y }}{{end}}
			if cr != nil { cr.sendContainerState(containerMapValue) }
			{{ $y := printf "v[%s(k2)]" .MapKey }}{{ encmd .Elem $y }}
		} {{end}}
	} else {
		for k2, v2 := range v {
			if cr != nil { cr.sendContainerState(containerMapKey) }
			{{if eq .MapKey "string"}}if asSymbols {
				ee.EncodeSymbol(k2)
			} else {
				ee.EncodeString(c_UTF8, k2)
			}{{else}}{{ encmd .MapKey "k2"}}{{end}}
			if cr != nil { cr.sendContainerState(containerMapValue) }
			{{ encmd .Elem "v2"}}
		}
	}
	if cr != nil { cr.sendContainerState(containerMapEnd) }{{/* ee.EncodeEnd() */}}
}

{{end}}{{end}}{{end}}

// -- decode

// -- -- fast path type switch
func fastpathDecodeTypeSwitch(iv interface{}, d *Decoder) bool {
	switch v := iv.(type) {
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
	case []{{ .Elem }}:{{else}}
	case map[{{ .MapKey }}]{{ .Elem }}:{{end}}
		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, d){{if not .MapKey }}
	case *[]{{ .Elem }}:{{else}}
	case *map[{{ .MapKey }}]{{ .Elem }}:{{end}}
		v2, changed2 := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*v, fastpathCheckNilFalse, true, d)
		if changed2 {
			*v = v2 
		}
{{end}}{{end}}
	default:
        _ = v // TODO: workaround https://github.com/golang/go/issues/12927 (remove after go 1.6 release)
		return false
	}
	return true
}

// -- -- fast path functions
{{range .Values}}{{if not .Primitive}}{{if not .MapKey }}
{{/*
Slices can change if they 
- did not come from an array
- are addressable (from a ptr)
- are settable (e.g. contained in an interface{})
*/}}
func (f *decFnInfo) {{ .MethodNamePfx "fastpathDec" false }}R(rv reflect.Value) { 
	array := f.seq == seqTypeArray
	if !array && rv.CanAddr() { {{/* // CanSet => CanAddr + Exported */}}
		vp := rv.Addr().Interface().(*[]{{ .Elem }})
		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, fastpathCheckNilFalse, !array, f.d)
		if changed {
			*vp = v
		}
	} else {
		v := rv.Interface().([]{{ .Elem }})
		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
	}
}

func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *[]{{ .Elem }}, checkNil bool, d *Decoder) {
	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, checkNil, true, d)
	if changed {
		*vp = v 
	}
}
func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v []{{ .Elem }}, checkNil bool, canChange bool, d *Decoder) (_ []{{ .Elem }}, changed bool) {
	dd := d.d
	{{/* // if dd.isContainerType(valueTypeNil) { dd.TryDecodeAsNil() */}}
	if checkNil && dd.TryDecodeAsNil() {
		if v != nil {
			changed = true 
		}
		return nil, changed 
	}

	slh, containerLenS := d.decSliceHelperStart()
	if containerLenS == 0 {
		if canChange {
			if v == nil {
				v = []{{ .Elem }}{}
			} else if len(v) != 0 {
				v = v[:0]
			}
			changed = true
		}
		slh.End()
		return v, changed
	}
	
	if containerLenS > 0 {
		x2read := containerLenS
		var xtrunc bool 
		if containerLenS > cap(v) {
			if canChange { {{/*
				// fast-path is for "basic" immutable types, so no need to copy them over
				// s := make([]{{ .Elem }}, decInferLen(containerLenS, d.h.MaxInitLen))
				// copy(s, v[:cap(v)])
				// v = s */}}
				var xlen int 
                xlen, xtrunc = decInferLen(containerLenS, d.h.MaxInitLen, {{ .Size }})
				if xtrunc {
					if xlen <= cap(v) {
						v = v[:xlen]
					} else {
						v = make([]{{ .Elem }}, xlen)
					}
				} else {
					v = make([]{{ .Elem }}, xlen)
				}
				changed = true
			} else {
				d.arrayCannotExpand(len(v), containerLenS)
			}
			x2read = len(v)
		} else if containerLenS != len(v) {
			if canChange {
				v = v[:containerLenS]
				changed = true
			}
		} {{/* // all checks done. cannot go past len. */}}
		j := 0
		for ; j < x2read; j++ {
			slh.ElemContainerState(j)
			{{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }}
		}
		if xtrunc { {{/* // means canChange=true, changed=true already. */}}
			for ; j < containerLenS; j++ {
				v = append(v, {{ zerocmd .Elem }})
				slh.ElemContainerState(j)
				{{ if eq .Elem "interface{}" }}d.decode(&v[j]){{ else }}v[j] = {{ decmd .Elem }}{{ end }}
			}
		} else if !canChange {
			for ; j < containerLenS; j++ {
				slh.ElemContainerState(j)
				d.swallow()
			}
		}
	} else {
		breakFound := dd.CheckBreak() {{/* check break first, so we can initialize v with a capacity of 4 if necessary */}}
		if breakFound {
			if canChange {
				if v == nil {
					v = []{{ .Elem }}{}
				} else if len(v) != 0 {
					v = v[:0]
				}
				changed = true
			}
			slh.End()
			return v, changed
		}
		if cap(v) == 0 {
			v = make([]{{ .Elem }}, 1, 4)
			changed = true
		}
		j := 0	
		for ; !breakFound; j++ {
			if j >= len(v) { 
				if canChange {
					v = append(v, {{ zerocmd .Elem }})
					changed = true
				} else {
					d.arrayCannotExpand(len(v), j+1)
				}
			}
			slh.ElemContainerState(j)
			if j < len(v) { {{/* // all checks done. cannot go past len. */}}
				{{ if eq .Elem "interface{}" }}d.decode(&v[j])
				{{ else }}v[j] = {{ decmd .Elem }}{{ end }}
			} else {
				d.swallow()
			}
			breakFound = dd.CheckBreak()
		}
		if canChange && j < len(v) {
			v = v[:j]
			changed = true
		}
	}
	slh.End() 
	return v, changed 
}

{{end}}{{end}}{{end}}


{{range .Values}}{{if not .Primitive}}{{if .MapKey }}
{{/*
Maps can change if they are
- addressable (from a ptr)
- settable (e.g. contained in an interface{})
*/}}
func (f *decFnInfo) {{ .MethodNamePfx "fastpathDec" false }}R(rv reflect.Value) { 
	if rv.CanAddr() {
		vp := rv.Addr().Interface().(*map[{{ .MapKey }}]{{ .Elem }})
		v, changed := fastpathTV.{{ .MethodNamePfx "Dec" false }}V(*vp, fastpathCheckNilFalse, true, f.d)
		if changed {
			*vp = v
		}
	} else {
		v := rv.Interface().(map[{{ .MapKey }}]{{ .Elem }})
		fastpathTV.{{ .MethodNamePfx "Dec" false }}V(v, fastpathCheckNilFalse, false, f.d)
	}
}
func (f fastpathT) {{ .MethodNamePfx "Dec" false }}X(vp *map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, d *Decoder) {
	v, changed := f.{{ .MethodNamePfx "Dec" false }}V(*vp, checkNil, true, d)
	if changed {
		*vp = v 
	}
}
func (_ fastpathT) {{ .MethodNamePfx "Dec" false }}V(v map[{{ .MapKey }}]{{ .Elem }}, checkNil bool, canChange bool, 
	d *Decoder) (_ map[{{ .MapKey }}]{{ .Elem }}, changed bool) {
	dd := d.d
	cr := d.cr
	{{/* // if dd.isContainerType(valueTypeNil) {dd.TryDecodeAsNil() */}}
	if checkNil && dd.TryDecodeAsNil() {
		if v != nil {
			changed = true
		} 
		return nil, changed
	}

	containerLen := dd.ReadMapStart()
	if canChange && v == nil {
		xlen, _ := decInferLen(containerLen, d.h.MaxInitLen, {{ .Size }})
		v = make(map[{{ .MapKey }}]{{ .Elem }}, xlen)
		changed = true
	}
	{{ if eq .Elem "interface{}" }}mapGet := !d.h.MapValueReset && !d.h.InterfaceReset{{end}}
	var mk {{ .MapKey }}
	var mv {{ .Elem }}
	if containerLen > 0 {
		for j := 0; j < containerLen; j++ {
			if cr != nil { cr.sendContainerState(containerMapKey) }
			{{ if eq .MapKey "interface{}" }}mk = nil 
			d.decode(&mk)
			if bv, bok := mk.([]byte); bok {
				mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
			}{{ else }}mk = {{ decmd .MapKey }}{{ end }}
			if cr != nil { cr.sendContainerState(containerMapValue) }
			{{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil }
			d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }}
			if v != nil {
				v[mk] = mv
			}
		}
	} else if containerLen < 0 {
		for j := 0; !dd.CheckBreak(); j++ {
			if cr != nil { cr.sendContainerState(containerMapKey) }
			{{ if eq .MapKey "interface{}" }}mk = nil 
			d.decode(&mk)
			if bv, bok := mk.([]byte); bok {
				mk = d.string(bv) {{/* // maps cannot have []byte as key. switch to string. */}}
			}{{ else }}mk = {{ decmd .MapKey }}{{ end }}
			if cr != nil { cr.sendContainerState(containerMapValue) }
			{{ if eq .Elem "interface{}" }}if mapGet { mv = v[mk] } else { mv = nil }
			d.decode(&mv){{ else }}mv = {{ decmd .Elem }}{{ end }}
			if v != nil {
				v[mk] = mv
			}
		}
	}
	if cr != nil { cr.sendContainerState(containerMapEnd) }
	return v, changed
}

{{end}}{{end}}{{end}}
