1 package middleware 2 3 // MetadataReader provides an interface for reading metadata from the 4 // underlying metadata container. 5 type MetadataReader interface { 6 Get(key interface{}) interface{} 7 } 8 9 // Metadata provides storing and reading metadata values. Keys may be any 10 // comparable value type. Get and set will panic if key is not a comparable 11 // value type. 12 // 13 // Metadata uses lazy initialization, and Set method must be called as an 14 // addressable value, or pointer. Not doing so may cause key/value pair to not 15 // be set. 16 type Metadata struct { 17 values map[interface{}]interface{} 18 } 19 20 // Get attempts to retrieve the value the key points to. Returns nil if the 21 // key was not found. 22 // 23 // Panics if key type is not comparable. 24 func (m Metadata) Get(key interface{}) interface{} { 25 return m.values[key] 26 } 27 28 // Clone creates a shallow copy of Metadata entries, returning a new Metadata 29 // value with the original entries copied into it. 30 func (m Metadata) Clone() Metadata { 31 vs := make(map[interface{}]interface{}, len(m.values)) 32 for k, v := range m.values { 33 vs[k] = v 34 } 35 36 return Metadata{ 37 values: vs, 38 } 39 } 40 41 // Set stores the value pointed to by the key. If a value already exists at 42 // that key it will be replaced with the new value. 43 // 44 // Set method must be called as an addressable value, or pointer. If Set is not 45 // called as an addressable value or pointer, the key value pair being set may 46 // be lost. 47 // 48 // Panics if the key type is not comparable. 49 func (m *Metadata) Set(key, value interface{}) { 50 if m.values == nil { 51 m.values = map[interface{}]interface{}{} 52 } 53 m.values[key] = value 54 } 55 56 // Has returns whether the key exists in the metadata. 57 // 58 // Panics if the key type is not comparable. 59 func (m Metadata) Has(key interface{}) bool { 60 if m.values == nil { 61 return false 62 } 63 _, ok := m.values[key] 64 return ok 65 } 66