reflect.Value.Len (method)

249 uses

	reflect (current package)
		deepequal.go#L89: 		for i := 0; i < v1.Len(); i++ {
		deepequal.go#L99: 		if v1.Len() != v2.Len() {
		deepequal.go#L105: 		for i := 0; i < v1.Len(); i++ {
		deepequal.go#L132: 		if v1.Len() != v2.Len() {
		swapper.go#L22: 	switch v.Len() {
		value.go#L1114: 		for i := 0; i < v.Len(); i++ {
		value.go#L1123: 		return v.Len() == 0
		value.go#L1146: func (v Value) Len() int {
		value.go#L2020: 	i0 := s.Len()
		value.go#L2062: 	s, i0, i1 := grow(s, t.Len())
		value.go#L2103: 		ds.Len = dst.Len()
		value.go#L2110: 		ss.Len = src.Len()

	crypto/x509
		verify.go#L532: 	*count += excludedValue.Len()
		verify.go#L537: 	for i := 0; i < excludedValue.Len(); i++ {
		verify.go#L551: 	*count += permittedValue.Len()
		verify.go#L557: 	for i := 0; i < permittedValue.Len(); i++ {

	encoding/asn1
		marshal.go#L507: 			if s.Len() > 0 {
		marshal.go#L543: 		switch l := v.Len(); l {
		marshal.go#L588: 	if v.Kind() == reflect.Slice && v.Len() == 0 && params.omitEmpty {

	encoding/binary
		binary.go#L409: 			return s * v.Len()
		binary.go#L543: 		l := v.Len()
		binary.go#L565: 		l := v.Len()
		binary.go#L612: 		l := v.Len()
		binary.go#L630: 		l := v.Len()

	encoding/gob
		dec_helpers.go#L57: 	return decBoolSlice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L80: 	return decComplex64Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L105: 	return decComplex128Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L130: 	return decFloat32Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L153: 	return decFloat64Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L176: 	return decIntSlice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L204: 	return decInt16Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L231: 	return decInt32Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L258: 	return decInt64Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L281: 	return decInt8Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L308: 	return decStringSlice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L345: 	return decUintSlice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L372: 	return decUint16Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L399: 	return decUint32Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L426: 	return decUint64Slice(state, v.Slice(0, v.Len()), length, ovfl)
		dec_helpers.go#L449: 	return decUintptrSlice(state, v.Slice(0, v.Len()), length, ovfl)
		enc_helpers.go#L56: 	return encBoolSlice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L82: 	return encComplex64Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L107: 	return encComplex128Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L132: 	return encFloat32Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L155: 	return encFloat64Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L178: 	return encIntSlice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L200: 	return encInt16Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L222: 	return encInt32Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L244: 	return encInt64Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L266: 	return encInt8Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L288: 	return encStringSlice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L311: 	return encUintSlice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L333: 	return encUint16Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L355: 	return encUint32Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L377: 	return encUint64Slice(state, v.Slice(0, v.Len()))
		enc_helpers.go#L399: 	return encUintptrSlice(state, v.Slice(0, v.Len()))
		encode.go#L437: 		for i := 0; i < val.Len(); i++ {
		encode.go#L444: 		return val.Len() == 0
		encode.go#L547: 				if !state.sendZero && slice.Len() == 0 {
		encode.go#L551: 				state.enc.encodeArray(state.b, slice, *elemOp, elemIndir, slice.Len(), helper)
		encode.go#L559: 				state.enc.encodeArray(state.b, array, *elemOp, elemIndir, array.Len(), helper)

	encoding/json
		decode.go#L547: 				newv := reflect.MakeSlice(v.Type(), v.Len(), newcap)
		decode.go#L551: 			if i >= v.Len() {
		decode.go#L556: 		if i < v.Len() {
		decode.go#L581: 	if i < v.Len() {
		decode.go#L585: 			for ; i < v.Len(); i++ {
		encode.go#L344: 		return v.Len() == 0
		encode.go#L881: 		}{v.Pointer(), v.Len()}
		encode.go#L910: 	n := v.Len()

	encoding/xml
		marshal.go#L457: 		for i, n := 0, val.Len(); i < n; i++ {
		marshal.go#L611: 		n := val.Len()
		marshal.go#L773: 			bytes = val.Slice(0, val.Len()).Bytes()
		marshal.go#L775: 			bytes = make([]byte, val.Len())
		marshal.go#L893: 			if vf.Len() == 0 {
		marshal.go#L1045: 		return v.Len() == 0
		read.go#L281: 		n := val.Len()
		read.go#L397: 		n := v.Len()

	fmt
		print.go#L831: 					bytes = f.Slice(0, f.Len()).Bytes()
		print.go#L836: 					bytes = make([]byte, f.Len())
		print.go#L852: 			for i := 0; i < f.Len(); i++ {
		print.go#L861: 			for i := 0; i < f.Len(); i++ {

	github.com/aws/aws-sdk-go/aws/awsutil
		copy.go#L82: 		s := reflect.MakeSlice(src.Type(), src.Len(), src.Cap())
		copy.go#L84: 		for i := 0; i < src.Len(); i++ {
		path_value.go#L116: 					for i := 0; i < value.Len(); i++ {
		path_value.go#L127: 				if i >= value.Len() { // check out of bounds
		path_value.go#L134: 					i = value.Len() + i
		path_value.go#L171: 	if v.Kind() == reflect.Map && v.Len() == 0 {
		path_value.go#L175: 		out := make([]interface{}, v.Len())
		path_value.go#L176: 		for i := 0; i < v.Len(); i++ {
		prettify.go#L66: 			fmt.Fprintf(buf, "<binary> len %d", v.Len())
		prettify.go#L71: 		if v.Len() > 3 {
		prettify.go#L75: 		for i := 0; i < v.Len(); i++ {
		prettify.go#L79: 			if i < v.Len()-1 {
		prettify.go#L93: 			if i < v.Len()-1 {
		string_value.go#L52: 		if v.Len() > 3 {
		string_value.go#L56: 		for i := 0; i < v.Len(); i++ {
		string_value.go#L60: 			if i < v.Len()-1 {
		string_value.go#L74: 			if i < v.Len()-1 {

	github.com/aws/aws-sdk-go/private/protocol/json/jsonutil
		build.go#L155: 	for i := 0; i < value.Len(); i++ {
		build.go#L158: 		if i < value.Len()-1 {

	github.com/aws/aws-sdk-go/private/protocol/query/queryutil
		queryutil.go#L119: 	if !value.IsNil() && value.Len() == 0 {
		queryutil.go#L137: 	for i := 0; i < value.Len(); i++ {
		queryutil.go#L153: 	if !value.IsNil() && value.Len() == 0 {

	github.com/aws/aws-sdk-go/private/protocol/xml/xmlutil
		build.go#L190: 		for i := 0; i < value.Len(); i++ {
		build.go#L201: 		for i := 0; i < value.Len(); i++ {
		build.go#L240: 	keys := make([]string, value.Len())
		unmarshal.go#L198: 		err := parse(r.Index(r.Len()-1), node, "")

	github.com/go-redis/redis/v8/internal/proto
		scan.go#L141: 			if v.Len() < v.Cap() {
		scan.go#L142: 				v.Set(v.Slice(0, v.Len()+1))
		scan.go#L143: 				elem := v.Index(v.Len() - 1)
		scan.go#L158: 		if v.Len() < v.Cap() {
		scan.go#L159: 			v.Set(v.Slice(0, v.Len()+1))
		scan.go#L160: 			return v.Index(v.Len() - 1)
		scan.go#L164: 		return v.Index(v.Len() - 1)

	github.com/google/go-cmp/cmp
		compare.go#L476: 	for ix := 0; ix < vx.Len(); ix++ {
		compare.go#L483: 	for iy := 0; iy < vy.Len(); iy++ {
		compare.go#L498: 	for ix < vx.Len() || iy < vy.Len() {
		report_reflect.go#L219: 		maxLen := v.Len()
		report_reflect.go#L225: 		for i := 0; i < v.Len(); i++ {
		report_reflect.go#L236: 			header := fmt.Sprintf("ptr:%v, len:%d, cap:%d", formatPointer(value.PointerOf(v), false), v.Len(), v.Cap())
		report_reflect.go#L252: 		maxLen := v.Len()
		report_slices.go#L29: 	case v.Type.Kind() == reflect.Slice && (v.ValueX.Len() == 0 || v.ValueY.Len() == 0):
		report_slices.go#L71: 	return v.ValueX.Len() >= minLength && v.ValueY.Len() >= minLength
		report_slices.go#L233: 				for i := 0; i < v.Len(); i++ {
		report_slices.go#L265: 				for i := 0; i < v.Len(); i++ {
		report_slices.go#L324: 	es := diff.Difference(vx.Len(), vy.Len(), func(ix int, iy int) diff.Result {
		report_slices.go#L329: 		n0 := v.Len()
		report_slices.go#L330: 		for v.Len() > 0 {
		report_slices.go#L332: 			if n > v.Len() {
		report_slices.go#L333: 				n = v.Len()
		report_slices.go#L336: 			v = v.Slice(n, v.Len())
		report_slices.go#L338: 		return n0 - v.Len()
		report_slices.go#L379: 			vx = vx.Slice(numEqual, vx.Len())
		report_slices.go#L380: 			vy = vy.Slice(numEqual, vy.Len())
		report_slices.go#L387: 		vx = vx.Slice(nx, vx.Len())
		report_slices.go#L389: 		vy = vy.Slice(ny, vy.Len())
		report_slices.go#L393: 		assert(vx.Len() == 0 && vy.Len() == 0)

	github.com/google/go-cmp/cmp/cmpopts
		equate.go#L31: 		(vx.Len() == 0 && vy.Len() == 0)
		sort.go#L47: 		(vx.Len() <= 1 && vy.Len() <= 1) {
		sort.go#L58: 	dst := reflect.MakeSlice(src.Type(), src.Len(), src.Len())
		sort.go#L59: 	for i := 0; i < src.Len(); i++ {
		sort.go#L68: 	for i := 1; i < v.Len(); i++ {
		sort.go#L118: 		(vx.Len() != 0 || vy.Len() != 0)
		sort.go#L126: 	dst := reflect.MakeSlice(reflect.SliceOf(outType), src.Len(), src.Len())
		sort.go#L138: 	for i := 1; i < v.Len(); i++ {

	github.com/google/go-cmp/cmp/internal/value
		sort.go#L61: 		for i := 0; i < x.Len(); i++ {
		zero.go#L33: 		for i := 0; i < v.Len(); i++ {

	github.com/imdario/mergo
		mergo.go#L39: 		return v.Len() == 0

	github.com/jackc/pgtype
		aclitem_array.go#L153: 		valueLen := value.Len()
		array.go#L367: 		length := value.Len()
		array_type.go#L69: 	dst.elements = make([]ValueTranscoder, sliceVal.Len())
		bool_array.go#L156: 		valueLen := value.Len()
		bpchar_array.go#L156: 		valueLen := value.Len()
		bytea_array.go#L137: 		valueLen := value.Len()
		cidr_array.go#L176: 		valueLen := value.Len()
		convert.go#L429: 			baseArrayType := reflect.PtrTo(reflect.ArrayOf(dstVal.Len(), baseElemType))
		date_array.go#L157: 		valueLen := value.Len()
		enum_array.go#L153: 		valueLen := value.Len()
		float4_array.go#L156: 		valueLen := value.Len()
		float8_array.go#L156: 		valueLen := value.Len()
		hstore_array.go#L137: 		valueLen := value.Len()
		inet_array.go#L176: 		valueLen := value.Len()
		int2_array.go#L422: 		valueLen := value.Len()
		int4_array.go#L422: 		valueLen := value.Len()
		int8_array.go#L422: 		valueLen := value.Len()
		jsonb_array.go#L156: 		valueLen := value.Len()
		macaddr_array.go#L157: 		valueLen := value.Len()
		numeric_array.go#L270: 		valueLen := value.Len()
		text_array.go#L156: 		valueLen := value.Len()
		timestamp_array.go#L157: 		valueLen := value.Len()
		timestamptz_array.go#L157: 		valueLen := value.Len()
		tsrange_array.go#L118: 		valueLen := value.Len()
		tstzrange_array.go#L118: 		valueLen := value.Len()
		uuid_array.go#L194: 		valueLen := value.Len()
		varchar_array.go#L156: 		valueLen := value.Len()

	github.com/jmespath/go-jmespath
		functions.go#L415: 		return float64(v.Len()), nil
		interpreter.go#L136: 				for i := 0; i < v.Len(); i++ {
		interpreter.go#L163: 				index += rv.Len()
		interpreter.go#L165: 			if index < rv.Len() && index >= 0 {
		interpreter.go#L345: 	for i := 0; i < v.Len(); i++ {
		interpreter.go#L352: 			for j := 0; j < elementV.Len(); j++ {
		interpreter.go#L374: 	for i := 0; i < v.Len(); i++ {
		interpreter.go#L385: 	for i := 0; i < v.Len(); i++ {
		interpreter.go#L407: 	for i := 0; i < v.Len(); i++ {
		util.go#L34: 		return rv.Len() == 0

	github.com/lann/builder
		reflect.go#L20: 	l := val.Len()

	github.com/lib/pq
		array.go#L413: 	if n := rv.Len(); n > 0 {
		array.go#L582: 			if n := rv.Len(); n > 0 {

	github.com/Masterminds/squirrel
		expr.go#L187: 				if valVal.Len() == 0 {
		expr.go#L193: 					for i := 0; i < valVal.Len(); i++ {
		expr.go#L196: 					expr = fmt.Sprintf("%s %s (%s)", key, inOpr, Placeholders(valVal.Len()))

	go.opentelemetry.io/otel/label
		set.go#L100: 	return l.equivalent.reflect().Len()
		set.go#L110: 	if idx >= 0 && idx < value.Len() {
		set.go#L125: 	vlen := rValue.Len()

	go/ast
		print.go#L154: 		p.printf("%s (len = %d) {", x.Type(), x.Len())
		print.go#L155: 		if x.Len() > 0 {
		print.go#L183: 		if x.Len() > 0 {
		print.go#L186: 			for i, n := 0, x.Len(); i < n; i++ {
		print.go#L200: 		p.printf("%s (len = %d) {", x.Type(), x.Len())
		print.go#L201: 		if x.Len() > 0 {
		print.go#L204: 			for i, n := 0, x.Len(); i < n; i++ {

	golang.org/x/crypto/ssh
		messages.go#L539: 					out = appendInt(out, field.Len())
		messages.go#L545: 				if n := field.Len(); n > 0 {

	google.golang.org/api/internal/gensupport
		json.go#L198: 		return v.Len() == 0

	google.golang.org/api/support/bundler
		bundler.go#L212: 		(b.BundleCountThreshold <= 0 || bu.items.Len() < b.BundleCountThreshold)
		bundler.go#L282: 		b.curBundle.items.Len() == b.BundleCountThreshold {

	google.golang.org/protobuf/internal/impl
		codec_map.go#L93: 	if mapv.Len() == 0 {
		codec_map.go#L268: 	if mapv.Len() == 0 {
		codec_map.go#L343: 	if srcm.Len() == 0 {
		codec_map.go#L358: 	if srcm.Len() == 0 {
		codec_map.go#L373: 	if srcm.Len() == 0 {
		convert.go#L353: 	if c.goType.Kind() == reflect.String && v.Len() == 0 {
		convert_list.go#L111: 	return ls.v.Elem().Len()
		convert_map.go#L68: 	return ms.v.Len()
		legacy_message.go#L213: 		for i := 0; i < vs.Len(); i++ {
		message_reflect_field.go#L130: 			return rv.Len() > 0
		message_reflect_field.go#L141: 			if rv.Len() == 0 {
		message_reflect_field.go#L183: 			return rv.Len() > 0
		message_reflect_field.go#L194: 			if rv.Elem().Len() == 0 {
		message_reflect_field.go#L258: 				return rv.Len() > 0
		message_reflect_field.go#L291: 			if isBytes && rv.Len() == 0 {

	gopkg.in/yaml.v2
		decode.go#L593: 		if l != out.Len() {
		decode.go#L594: 			failf("invalid array: want %d elements but got %d", out.Len(), l)
		encode.go#L230: 			if m.Len() > 0 {
		encode.go#L270: 	n := in.Len()
		yaml.go#L442: 		return v.Len() == 0
		yaml.go#L444: 		return v.Len() == 0

	internal/fmtsort
		sort.go#L59: 	n := mapValue.Len()
		sort.go#L164: 		for i := 0; i < aVal.Len(); i++ {

	text/template
		exec.go#L315: 		truth = val.Len() > 0
		exec.go#L356: 		if val.Len() == 0 {
		exec.go#L359: 		for i := 0; i < val.Len(); i++ {
		exec.go#L364: 		if val.Len() == 0 {
		funcs.go#L219: 			x, err := indexArg(index, item.Len())
		funcs.go#L264: 		cap = item.Len()
		funcs.go#L271: 	idx := [3]int{0, item.Len()}
		funcs.go#L303: 		return item.Len(), nil