safe_map.go raw

   1  package reflect2
   2  
   3  import (
   4  	"reflect"
   5  	"unsafe"
   6  )
   7  
   8  type safeMapType struct {
   9  	safeType
  10  }
  11  
  12  func (type2 *safeMapType) Key() Type {
  13  	return type2.safeType.cfg.Type2(type2.Type.Key())
  14  }
  15  
  16  func (type2 *safeMapType) MakeMap(cap int) interface{} {
  17  	ptr := reflect.New(type2.Type)
  18  	ptr.Elem().Set(reflect.MakeMap(type2.Type))
  19  	return ptr.Interface()
  20  }
  21  
  22  func (type2 *safeMapType) UnsafeMakeMap(cap int) unsafe.Pointer {
  23  	panic("does not support unsafe operation")
  24  }
  25  
  26  func (type2 *safeMapType) SetIndex(obj interface{}, key interface{}, elem interface{}) {
  27  	keyVal := reflect.ValueOf(key)
  28  	elemVal := reflect.ValueOf(elem)
  29  	val := reflect.ValueOf(obj)
  30  	val.Elem().SetMapIndex(keyVal.Elem(), elemVal.Elem())
  31  }
  32  
  33  func (type2 *safeMapType) UnsafeSetIndex(obj unsafe.Pointer, key unsafe.Pointer, elem unsafe.Pointer) {
  34  	panic("does not support unsafe operation")
  35  }
  36  
  37  func (type2 *safeMapType) TryGetIndex(obj interface{}, key interface{}) (interface{}, bool) {
  38  	keyVal := reflect.ValueOf(key)
  39  	if key == nil {
  40  		keyVal = reflect.New(type2.Type.Key()).Elem()
  41  	}
  42  	val := reflect.ValueOf(obj).MapIndex(keyVal)
  43  	if !val.IsValid() {
  44  		return nil, false
  45  	}
  46  	return val.Interface(), true
  47  }
  48  
  49  func (type2 *safeMapType) GetIndex(obj interface{}, key interface{}) interface{} {
  50  	val := reflect.ValueOf(obj).Elem()
  51  	keyVal := reflect.ValueOf(key).Elem()
  52  	elemVal := val.MapIndex(keyVal)
  53  	if !elemVal.IsValid() {
  54  		ptr := reflect.New(reflect.PtrTo(val.Type().Elem()))
  55  		return ptr.Elem().Interface()
  56  	}
  57  	ptr := reflect.New(elemVal.Type())
  58  	ptr.Elem().Set(elemVal)
  59  	return ptr.Interface()
  60  }
  61  
  62  func (type2 *safeMapType) UnsafeGetIndex(obj unsafe.Pointer, key unsafe.Pointer) unsafe.Pointer {
  63  	panic("does not support unsafe operation")
  64  }
  65  
  66  func (type2 *safeMapType) Iterate(obj interface{}) MapIterator {
  67  	m := reflect.ValueOf(obj).Elem()
  68  	return &safeMapIterator{
  69  		m:    m,
  70  		keys: m.MapKeys(),
  71  	}
  72  }
  73  
  74  func (type2 *safeMapType) UnsafeIterate(obj unsafe.Pointer) MapIterator {
  75  	panic("does not support unsafe operation")
  76  }
  77  
  78  type safeMapIterator struct {
  79  	i    int
  80  	m    reflect.Value
  81  	keys []reflect.Value
  82  }
  83  
  84  func (iter *safeMapIterator) HasNext() bool {
  85  	return iter.i != len(iter.keys)
  86  }
  87  
  88  func (iter *safeMapIterator) Next() (interface{}, interface{}) {
  89  	key := iter.keys[iter.i]
  90  	elem := iter.m.MapIndex(key)
  91  	iter.i += 1
  92  	keyPtr := reflect.New(key.Type())
  93  	keyPtr.Elem().Set(key)
  94  	elemPtr := reflect.New(elem.Type())
  95  	elemPtr.Elem().Set(elem)
  96  	return keyPtr.Interface(), elemPtr.Interface()
  97  }
  98  
  99  func (iter *safeMapIterator) UnsafeNext() (unsafe.Pointer, unsafe.Pointer) {
 100  	panic("does not support unsafe operation")
 101  }
 102