protobuf-go/internal/impl/legacy_extension.go

// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package impl

import (
	"reflect"
	"sync"
	"unsafe"

	protoV1 "github.com/golang/protobuf/proto"
	pref "github.com/golang/protobuf/v2/reflect/protoreflect"
)

// TODO: The logic below this is a hack since v1 currently exposes no
// exported functionality for interacting with these data structures.
// Eventually make changes to v1 such that v2 can access the necessary
// fields without relying on unsafe.

var (
	extTypeA = reflect.TypeOf(map[int32]protoV1.Extension(nil))
	extTypeB = reflect.TypeOf(protoV1.XXX_InternalExtensions{})
)

type legacyExtensionIface interface {
	Len() int
	Get(pref.FieldNumber) legacyExtensionEntry
	Set(pref.FieldNumber, legacyExtensionEntry)
	Range(f func(pref.FieldNumber, legacyExtensionEntry) bool)
}

func makeLegacyExtensionMapFunc(t reflect.Type) func(*messageDataType) legacyExtensionIface {
	fx1, _ := t.FieldByName("XXX_extensions")
	fx2, _ := t.FieldByName("XXX_InternalExtensions")
	switch {
	case fx1.Type == extTypeA:
		return func(p *messageDataType) legacyExtensionIface {
			rv := p.p.asType(t).Elem()
			return (*legacyExtensionMap)(unsafe.Pointer(rv.UnsafeAddr() + fx1.Offset))
		}
	case fx2.Type == extTypeB:
		return func(p *messageDataType) legacyExtensionIface {
			rv := p.p.asType(t).Elem()
			return (*legacyExtensionSyncMap)(unsafe.Pointer(rv.UnsafeAddr() + fx2.Offset))
		}
	default:
		return nil
	}
}

// legacyExtensionSyncMap is identical to protoV1.XXX_InternalExtensions.
// It implements legacyExtensionIface.
type legacyExtensionSyncMap struct {
	p *struct {
		mu sync.Mutex
		m  legacyExtensionMap
	}
}

func (m legacyExtensionSyncMap) Len() int {
	if m.p == nil {
		return 0
	}
	m.p.mu.Lock()
	defer m.p.mu.Unlock()
	return m.p.m.Len()
}
func (m legacyExtensionSyncMap) Get(n pref.FieldNumber) legacyExtensionEntry {
	if m.p == nil {
		return legacyExtensionEntry{}
	}
	m.p.mu.Lock()
	defer m.p.mu.Unlock()
	return m.p.m.Get(n)
}
func (m *legacyExtensionSyncMap) Set(n pref.FieldNumber, x legacyExtensionEntry) {
	if m.p == nil {
		m.p = new(struct {
			mu sync.Mutex
			m  legacyExtensionMap
		})
	}
	m.p.mu.Lock()
	defer m.p.mu.Unlock()
	m.p.m.Set(n, x)
}
func (m legacyExtensionSyncMap) Range(f func(pref.FieldNumber, legacyExtensionEntry) bool) {
	if m.p == nil {
		return
	}
	m.p.mu.Lock()
	defer m.p.mu.Unlock()
	m.p.m.Range(f)
}

// legacyExtensionMap is identical to map[int32]protoV1.Extension.
// It implements legacyExtensionIface.
type legacyExtensionMap map[pref.FieldNumber]legacyExtensionEntry

func (m legacyExtensionMap) Len() int {
	return len(m)
}
func (m legacyExtensionMap) Get(n pref.FieldNumber) legacyExtensionEntry {
	return m[n]
}
func (m *legacyExtensionMap) Set(n pref.FieldNumber, x legacyExtensionEntry) {
	if *m == nil {
		*m = make(map[pref.FieldNumber]legacyExtensionEntry)
	}
	(*m)[n] = x
}
func (m legacyExtensionMap) Range(f func(pref.FieldNumber, legacyExtensionEntry) bool) {
	for n, x := range m {
		if !f(n, x) {
			return
		}
	}
}

// legacyExtensionEntry is identical to protoV1.Extension.
type legacyExtensionEntry struct {
	desc *protoV1.ExtensionDesc
	val  interface{}
	raw  []byte
}