type mapType … func (t *rtype) Key() Type { … } // MapOf returns the map type with the given key and element types. // For example, if k represents int and e represents string, // MapOf(k, e) represents map[int]string. // // If the key type is not a valid map key type (that is, if it does // not implement Go's == operator), MapOf panics. func MapOf(key, elem Type) Type { … } func groupAndSlotOf(ktyp, etyp Type) (Type, Type) { … } var stringType … // MapIndex returns the value associated with key in the map v. // It panics if v's Kind is not [Map]. // It returns the zero Value if key is not found in the map or if v represents a nil map. // As in Go, the key's value must be assignable to the map's key type. func (v Value) MapIndex(key Value) Value { … } // MapKeys returns a slice containing all the keys present in the map, // in unspecified order. // It panics if v's Kind is not [Map]. // It returns an empty slice if v represents a nil map. func (v Value) MapKeys() []Value { … } type MapIter … type hiter … // Key returns the key of iter's current map entry. func (iter *MapIter) Key() Value { … } // SetIterKey assigns to v the key of iter's current map entry. // It is equivalent to v.Set(iter.Key()), but it avoids allocating a new Value. // As in Go, the key must be assignable to v's type and // must not be derived from an unexported field. func (v Value) SetIterKey(iter *MapIter) { … } // Value returns the value of iter's current map entry. func (iter *MapIter) Value() Value { … } // SetIterValue assigns to v the value of iter's current map entry. // It is equivalent to v.Set(iter.Value()), but it avoids allocating a new Value. // As in Go, the value must be assignable to v's type and // must not be derived from an unexported field. func (v Value) SetIterValue(iter *MapIter) { … } // Next advances the map iterator and reports whether there is another // entry. It returns false when iter is exhausted; subsequent // calls to [MapIter.Key], [MapIter.Value], or [MapIter.Next] will panic. func (iter *MapIter) Next() bool { … } // Reset modifies iter to iterate over v. // It panics if v's Kind is not [Map] and v is not the zero Value. // Reset(Value{}) causes iter to not to refer to any map, // which may allow the previously iterated-over map to be garbage collected. func (iter *MapIter) Reset(v Value) { … } // MapRange returns a range iterator for a map. // It panics if v's Kind is not [Map]. // // Call [MapIter.Next] to advance the iterator, and [MapIter.Key]/[MapIter.Value] to access each entry. // [MapIter.Next] returns false when the iterator is exhausted. // MapRange follows the same iteration semantics as a range statement. // // Example: // // iter := reflect.ValueOf(m).MapRange() // for iter.Next() { // k := iter.Key() // v := iter.Value() // ... // } func (v Value) MapRange() *MapIter { … } // SetMapIndex sets the element associated with key in the map v to elem. // It panics if v's Kind is not [Map]. // If elem is the zero Value, SetMapIndex deletes the key from the map. // Otherwise if v holds a nil map, SetMapIndex will panic. // As in Go, key's elem must be assignable to the map's key type, // and elem's value must be assignable to the map's elem type. func (v Value) SetMapIndex(key, elem Value) { … } // Force slow panicking path not inlined, so it won't add to the // inlining budget of the caller. // TODO: undo when the inliner is no longer bottom-up only. // //go:noinline func (f flag) panicNotMap() { … }
Codebase Browser
go