func (cdc *Codec) decodeReflectBinaryInterface(bz []byte, iinfo *TypeInfo, rv reflect.Value, fopts FieldOptions, bare bool) (n int, err error) {
	if !rv.CanAddr() {
		panic("rv not addressable")
	}
	if printLog {
		fmt.Println("(d) decodeReflectBinaryInterface")
		defer func() {
			fmt.Printf("(d) -> err: %v\n", err)
		}()
	}
	if !rv.IsNil() {
		// JAE: Heed this note, this is very tricky.
		// I've forgotten the reason a second time,
		// but I'm pretty sure that reason exists.
		err = errors.New("Decoding to a non-nil interface is not supported yet")
		return
	}

	if !bare {
		// Read byte-length prefixed byteslice.
		var buf, _n = []byte(nil), int(0)
		buf, _n, err = DecodeByteSlice(bz)
		if slide(&bz, nil, _n) && err != nil {
			return
		}
		// This is a trick for debuggability -- we slide on &n more later.
		n += UvarintSize(uint64(len(buf)))
		bz = buf
	}

	// Consume disambiguation / prefix bytes.
	disamb, hasDisamb, prefix, hasPrefix, _n, err := DecodeDisambPrefixBytes(bz)
	if slide(&bz, &n, _n) && err != nil {
		return
	}

	// Get concrete type info from disfix/prefix.
	var cinfo *TypeInfo
	if hasDisamb {
		cinfo, err = cdc.getTypeInfoFromDisfix_rlock(toDisfix(disamb, prefix))
	} else if hasPrefix {
		cinfo, err = cdc.getTypeInfoFromPrefix_rlock(iinfo, prefix)
	} else {
		err = errors.New("Expected disambiguation or prefix bytes.")
	}
	if err != nil {
		return
	}

	// Construct the concrete type.
	var crv, irvSet = constructConcreteType(cinfo)

	// Decode into the concrete type.
	_n, err = cdc.decodeReflectBinary(bz, cinfo, crv, fopts, true)
	if slide(&bz, &n, _n) && err != nil {
		rv.Set(irvSet) // Helps with debugging
		return
	}

	// Earlier, we set bz to the byteslice read from buf.
	// Ensure that all of bz was consumed.
	if len(bz) > 0 {
		err = errors.New("bytes left over after reading interface contents")
		return
	}

	// We need to set here, for when !PointerPreferred and the type
	// is say, an array of bytes (e.g. [32]byte), then we must call
	// rv.Set() *after* the value was acquired.
	// NOTE: rv.Set() should succeed because it was validated
	// already during Register[Interface/Concrete].
	rv.Set(irvSet)
	return
}
func (cdc *Codec) decodeReflectBinaryInterface(bz []byte, iinfo *TypeInfo, rv reflect.Value, fopts FieldOptions, bare bool) (n int, err error) {
	if !rv.CanAddr() {
		panic("rv not addressable")
	}
	if printLog {
		fmt.Println("(d) decodeReflectBinaryInterface")
		defer func() {
			fmt.Printf("(d) -> err: %v\n", err)
		}()
	}
	if !rv.IsNil() {
		
		
		
		err = errors.New("Decoding to a non-nil interface is not supported yet")
		return
	}

	if !bare {
		
		var buf, _n = []byte(nil), int(0)
		buf, _n, err = DecodeByteSlice(bz)
		if slide(&bz, nil, _n) && err != nil {
			return
		}
		
		n += UvarintSize(uint64(len(buf)))
		bz = buf
	}

	
	disamb, hasDisamb, prefix, hasPrefix, _n, err := DecodeDisambPrefixBytes(bz)
	if slide(&bz, &n, _n) && err != nil {
		return
	}

	
	var cinfo *TypeInfo
	if hasDisamb {
		cinfo, err = cdc.getTypeInfoFromDisfix_rlock(toDisfix(disamb, prefix))
	} else if hasPrefix {
		cinfo, err = cdc.getTypeInfoFromPrefix_rlock(iinfo, prefix)
	} else {
		err = errors.New("Expected disambiguation or prefix bytes.")
	}
	if err != nil {
		return
	}

	
	var crv, irvSet = constructConcreteType(cinfo)

	
	_n, err = cdc.decodeReflectBinary(bz, cinfo, crv, fopts, true)
	if slide(&bz, &n, _n) && err != nil {
		rv.Set(irvSet) 
		return
	}

	
	
	if len(bz) > 0 {
		err = errors.New("bytes left over after reading interface contents")
		return
	}

	
	
	
	
	
	rv.Set(irvSet)
	return
}
func ( cdc * Codec ) decodeReflectBinaryInterface ( bz [ ] byte , iinfo * TypeInfo , rv reflect . Value , fopts FieldOptions , bare bool ) ( n int , err error ) { if ! rv . CanAddr ( ) { panic ( " " ) } if printLog { fmt . Println ( " " ) defer func ( ) { fmt . Printf ( " \n " , err ) } ( ) } if ! rv . IsNil ( ) { // JAE: Heed this note, this is very tricky. // I've forgotten the reason a second time, // but I'm pretty sure that reason exists. err = errors . New ( " " ) return } if ! bare { // Read byte-length prefixed byteslice. var buf , _n = [ ] byte ( nil ) , int ( 0 ) buf , _n , err = DecodeByteSlice ( bz ) if slide ( & bz , nil , _n ) && err != nil { return } // This is a trick for debuggability -- we slide on &n more later. n += UvarintSize ( uint64 ( len ( buf ) ) ) bz = buf } // Consume disambiguation / prefix bytes. disamb , hasDisamb , prefix , hasPrefix , _n , err := DecodeDisambPrefixBytes ( bz ) if slide ( & bz , & n , _n ) && err != nil { return } // Get concrete type info from disfix/prefix. var cinfo * TypeInfo if hasDisamb { cinfo , err = cdc . getTypeInfoFromDisfix_rlock ( toDisfix ( disamb , prefix ) ) } else if hasPrefix { cinfo , err = cdc . getTypeInfoFromPrefix_rlock ( iinfo , prefix ) } else { err = errors . New ( " " ) } if err != nil { return } // Construct the concrete type. var crv , irvSet = constructConcreteType ( cinfo ) // Decode into the concrete type. _n , err = cdc . decodeReflectBinary ( bz , cinfo , crv , fopts , true ) if slide ( & bz , & n , _n ) && err != nil { rv . Set ( irvSet ) // Helps with debugging return } // Earlier, we set bz to the byteslice read from buf. // Ensure that all of bz was consumed. if len ( bz ) > 0 { err = errors . New ( " " ) return } // We need to set here, for when !PointerPreferred and the type // is say, an array of bytes (e.g. [32]byte), then we must call // rv.Set() *after* the value was acquired. // NOTE: rv.Set() should succeed because it was validated // already during Register[Interface/Concrete]. rv . Set ( irvSet ) return }
// CONTRACT: rv.CanAddr() is true.
CONTRACT : rv . CanAddr () is true .