1// Copyright 2018 The Go Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style
3// license that can be found in the LICENSE file.
4
5package impl
6
7import (
8	"fmt"
9	"reflect"
10
11	pref "google.golang.org/protobuf/reflect/protoreflect"
12)
13
14type mapConverter struct {
15	goType           reflect.Type // map[K]V
16	keyConv, valConv Converter
17}
18
19func newMapConverter(t reflect.Type, fd pref.FieldDescriptor) *mapConverter {
20	if t.Kind() != reflect.Map {
21		panic(fmt.Sprintf("invalid Go type %v for field %v", t, fd.FullName()))
22	}
23	return &mapConverter{
24		goType:  t,
25		keyConv: newSingularConverter(t.Key(), fd.MapKey()),
26		valConv: newSingularConverter(t.Elem(), fd.MapValue()),
27	}
28}
29
30func (c *mapConverter) PBValueOf(v reflect.Value) pref.Value {
31	if v.Type() != c.goType {
32		panic(fmt.Sprintf("invalid type: got %v, want %v", v.Type(), c.goType))
33	}
34	return pref.ValueOfMap(&mapReflect{v, c.keyConv, c.valConv})
35}
36
37func (c *mapConverter) GoValueOf(v pref.Value) reflect.Value {
38	return v.Map().(*mapReflect).v
39}
40
41func (c *mapConverter) IsValidPB(v pref.Value) bool {
42	mapv, ok := v.Interface().(*mapReflect)
43	if !ok {
44		return false
45	}
46	return mapv.v.Type() == c.goType
47}
48
49func (c *mapConverter) IsValidGo(v reflect.Value) bool {
50	return v.IsValid() && v.Type() == c.goType
51}
52
53func (c *mapConverter) New() pref.Value {
54	return c.PBValueOf(reflect.MakeMap(c.goType))
55}
56
57func (c *mapConverter) Zero() pref.Value {
58	return c.PBValueOf(reflect.Zero(c.goType))
59}
60
61type mapReflect struct {
62	v       reflect.Value // map[K]V
63	keyConv Converter
64	valConv Converter
65}
66
67func (ms *mapReflect) Len() int {
68	return ms.v.Len()
69}
70func (ms *mapReflect) Has(k pref.MapKey) bool {
71	rk := ms.keyConv.GoValueOf(k.Value())
72	rv := ms.v.MapIndex(rk)
73	return rv.IsValid()
74}
75func (ms *mapReflect) Get(k pref.MapKey) pref.Value {
76	rk := ms.keyConv.GoValueOf(k.Value())
77	rv := ms.v.MapIndex(rk)
78	if !rv.IsValid() {
79		return pref.Value{}
80	}
81	return ms.valConv.PBValueOf(rv)
82}
83func (ms *mapReflect) Set(k pref.MapKey, v pref.Value) {
84	rk := ms.keyConv.GoValueOf(k.Value())
85	rv := ms.valConv.GoValueOf(v)
86	ms.v.SetMapIndex(rk, rv)
87}
88func (ms *mapReflect) Clear(k pref.MapKey) {
89	rk := ms.keyConv.GoValueOf(k.Value())
90	ms.v.SetMapIndex(rk, reflect.Value{})
91}
92func (ms *mapReflect) Mutable(k pref.MapKey) pref.Value {
93	if _, ok := ms.valConv.(*messageConverter); !ok {
94		panic("invalid Mutable on map with non-message value type")
95	}
96	v := ms.Get(k)
97	if !v.IsValid() {
98		v = ms.NewValue()
99		ms.Set(k, v)
100	}
101	return v
102}
103func (ms *mapReflect) Range(f func(pref.MapKey, pref.Value) bool) {
104	iter := mapRange(ms.v)
105	for iter.Next() {
106		k := ms.keyConv.PBValueOf(iter.Key()).MapKey()
107		v := ms.valConv.PBValueOf(iter.Value())
108		if !f(k, v) {
109			return
110		}
111	}
112}
113func (ms *mapReflect) NewValue() pref.Value {
114	return ms.valConv.New()
115}
116func (ms *mapReflect) IsValid() bool {
117	return !ms.v.IsNil()
118}
119func (ms *mapReflect) protoUnwrap() interface{} {
120	return ms.v.Interface()
121}
122