Add local mode and nonlocal field tag

decoder.go

@@ -44,8 +44,15 @@ func WithDecodeMaxNested(nested uint) decoderOpts {
 // WithDecodeMaxElements sets the maximum number of elements allowed in a collection.
 // The default value is 1 << 20.
 func WithDecodeMaxElements(elements uint32) decoderOpts {
-	return func(e *Decoder) {
-		e.maxElements = elements
+	return func(d *Decoder) {
+		d.maxElements = elements
+	}
+}
+
+// WithDecodeLocal instructs the decoder to skip decoding of fields with the `nonlocal` tag.
+func WithDecodeLocal() decoderOpts {
+	return func(d *Decoder) {
+		d.local = true
 	}
 }
 
@@ -67,6 +74,7 @@ type Decoder struct {
 	scratch     [9]byte
 	maxNested   uint
 	maxElements uint32
+	local       bool
 }
 
 func (d *Decoder) enterNested() error {
@@ -85,6 +93,12 @@ func (d *Decoder) read(buf []byte) (int, error) {
 	return io.ReadFull(d.r, buf)
 }
 
+// Local returns true if the decoder is using local mode, that is, skipping fields with
+// the `nonlocal` tag.
+func (d *Decoder) Local() bool {
+	return d.local
+}
+
 func DecodeByte(d *Decoder) (byte, int, error) {
 	n, err := d.read(d.scratch[:1])
 	if err != nil {

encoder.go

@@ -52,6 +52,13 @@ func WithEncodeMaxElements(elements uint32) encoderOpts {
 	}
 }
 
+// WithEncodeLocal instructs the encoder to skip encoding of fields with the `nonlocal` tag.
+func WithEncodeLocal() encoderOpts {
+	return func(e *Encoder) {
+		e.local = true
+	}
+}
+
 // NewEncoder returns a new encoder that writes to w.
 // If w implements io.StringWriter, the returned encoder will be more efficient in encoding strings.
 func NewEncoder(w io.Writer, opts ...encoderOpts) *Encoder {
@@ -71,6 +78,7 @@ type Encoder struct {
 	scratch     [9]byte
 	maxNested   uint
 	maxElements uint32
+	local       bool
 }
 
 func (e *Encoder) enterNested() error {
@@ -85,6 +93,12 @@ func (e *Encoder) leaveNested() {
 	e.maxNested++
 }
 
+// Local returns true if the encoder is using local mode, that is, skipping fields with
+// the `nonlocal` tag.
+func (e *Encoder) Local() bool {
+	return e.local
+}
+
 func EncodeByteSlice(e *Encoder, value []byte) (int, error) {
 	return EncodeByteSliceWithLimit(e, value, e.maxElements)
 }

examples/nonlocal.go

@@ -0,0 +1,8 @@
+package examples
+
+//go:generate scalegen
+
+type StructWithNonLocalField struct {
+	Name   string `scale:"max=20"`
+	SomeID string `scale:"nonlocal,max=20"`
+}

examples/nonlocal_test.go

@@ -0,0 +1,43 @@
+package examples
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"github.com/spacemeshos/go-scale"
+)
+
+func TestNonLocal(t *testing.T) {
+	s := StructWithNonLocalField{
+		Name:   "foo",
+		SomeID: "bar",
+	}
+
+	buf := bytes.NewBuffer(nil)
+	encoder := scale.NewEncoder(buf)
+	n, err := s.EncodeScale(encoder)
+	require.NoError(t, err)
+	require.Equal(t, 8, n)
+
+	decoder := scale.NewDecoder(bytes.NewReader(buf.Bytes()))
+	var s1 StructWithNonLocalField
+	n, err = s1.DecodeScale(decoder)
+	require.NoError(t, err)
+	require.Equal(t, 8, n)
+	require.Equal(t, s, s1)
+
+	buf = bytes.NewBuffer(nil)
+	encoder = scale.NewEncoder(buf, scale.WithEncodeLocal())
+	n, err = s.EncodeScale(encoder)
+	require.NoError(t, err)
+	require.Equal(t, 4, n)
+
+	decoder = scale.NewDecoder(bytes.NewReader(buf.Bytes()), scale.WithDecodeLocal())
+	var s2 StructWithNonLocalField
+	n, err = s2.DecodeScale(decoder)
+	require.NoError(t, err)
+	require.Equal(t, 4, n)
+	require.Equal(t, StructWithNonLocalField{Name: "foo"}, s2)
+}

generate.go

@@ -31,8 +31,10 @@ type temp struct {
 	decode string
 }
 
+type action int
+
 const (
-	encode = iota
+	encode action = iota
 	decode
 )
 
@@ -119,7 +121,7 @@ var (
 	}
 )
 
-func getAction(tm temp, action int) string {
+func getAction(tm temp, action action) string {
 	switch action {
 	case encode:
 		return tm.encode
@@ -266,6 +268,7 @@ type scaleType struct {
 	Args           string
 	EncodeModifier string
 	DecodeModifier string
+	NonLocal       bool
 }
 
 func getDecodeModifier(parentType reflect.Type, field reflect.StructField) string {
@@ -277,6 +280,18 @@ func getDecodeModifier(parentType reflect.Type, field reflect.StructField) strin
 }
 
 func getScaleType(parentType reflect.Type, field reflect.StructField) (scaleType, error) {
+	st, err := getScaleTypeInner(parentType, field)
+	if err != nil {
+		return scaleType{}, err
+	}
+	st.NonLocal, err = nonLocal(field.Tag)
+	if err != nil {
+		return scaleType{}, fmt.Errorf("getting tags: %w", err)
+	}
+	return st, nil
+}
+
+func getScaleTypeInner(parentType reflect.Type, field reflect.StructField) (scaleType, error) {
 	decodeModifier := getDecodeModifier(parentType, field)
 	encodableType := reflect.TypeOf((*Encodable)(nil)).Elem()
 
@@ -374,7 +389,7 @@ func getTemplate(stype scaleType) temp {
 	}
 }
 
-func executeAction(action int, w io.Writer, tc *typeContext) error {
+func executeAction(action action, w io.Writer, tc *typeContext) error {
 	typ := tc.Type
 
 	tpl, err := template.New("").Parse(getAction(start, action))
@@ -396,6 +411,17 @@ func executeAction(action int, w io.Writer, tc *typeContext) error {
 			return fmt.Errorf("getting scale type for %s: %w", typ, err)
 		}
 
+		if scaleType.NonLocal {
+			switch action {
+			case encode:
+				w.Write([]byte("if !enc.Local() "))
+			case decode:
+				w.Write([]byte("if !dec.Local() "))
+			default:
+				panic("BUG: bad action")
+			}
+		}
+
 		tctx := &typeContext{
 			Name:           field.Name,
 			Type:           field.Type,