// Properties returns properties for the first rune in s.
436115
func (f Form) Properties(s []byte) Properties {
	if f == NFC || f == NFD {
		return compInfo(nfcData.lookup(s))
	}
	return compInfo(nfkcData.lookup(s))
}
231215
func (self Object) Keys() []string {
	var keys []string
	self.object.enumerate(false, func(name string) bool {
		keys = append(keys, name)
		return true
	})
	return keys
}
250610
func (f *Flags) Properties() *Properties {
	contentType := types.ContentType(f.ContentType)
	if contentType == "" {
		contentType = f.Type.DefaultContentType()
	}

	p := &Properties{
		LogStreamDescriptor: &logpb.LogStreamDescriptor{
			Name:          string(f.Name),
			ContentType:   string(contentType),
			StreamType:    logpb.StreamType(f.Type),
			Timestamp:     google.NewTimestamp(time.Time(f.Timestamp)),
			BinaryFileExt: f.BinaryFileExtension,
			Tags:          f.Tags,
		},
		Tee:      f.Tee,
		Timeout:  time.Duration(f.Timeout),
		Deadline: time.Duration(f.Deadline),
	}
	return p
}
346256
func (s *PerformanceMetrics) SetProperties(v map[string]*string) *PerformanceMetrics {
	s.Properties = v
	return s
}
173695
func (g *Group) Rune() *Statement {
	// notest
	s := Rune()
	g.items = append(g.items, s)
	return s
}
582091
func Runes(a, b []rune) []Change {
	return Diff(len(a), len(b), &runes{a, b})
}
365224
func (s *Products) GetPropertyValues(job Jobs, identifier string) (propertyMap map[string]string) {
	properties := job.Properties
	propertyMap = make(map[string]string)
	for _, property := range properties {

		if property.Identifier == identifier {
			for key, value := range property.Value.MapValue {
				propertyMap[key] = fmt.Sprintf("%v", value)
			}
		}
	}
	return
}
15354
func (state *UserState) Properties(username string) []string {
	props, err := state.users.Keys(username)
	if err != nil {
		return []string{}
	}
	return props
}
356271
func (ss stringSet) keys() []string {
	keys := make([]string, 0, len(ss))

	for key := range ss {
		keys = append(keys, key)
	}

	return keys
}
799900
func (dp *Datapoint) GetProperties() map[string]interface{} {
	m, ok := dp.Meta[tsProperty].(map[string]interface{})
	if !ok {
		return nil
	}
	return m
}
88990
func (k *ArrayKeyring) Keys() ([]string, error) {
	var keys = []string{}
	for key := range k.items {
		keys = append(keys, key)
	}
	return keys, nil
}
982601
func (s *DocumentationPart) SetProperties(v string) *DocumentationPart {
	s.Properties = &v
	return s
}
226535
func (p Properties) String(key string, def string) string {
	if v, found := p[key]; found {
		return v
	}
	return def
}
920091
func Runes(b0, b1 []rune) int {
	d := 0
	for i, x := range b0 {
		d += Rune(x, b1[i])
	}
	return d
}
847416
func (v *Validator) Fields() []string {
	fields := []string{}
	for _, vr := range v.results {
		fields = append(fields, vr.field)
	}
	return fields
}
324898
func (c *Client) Keys(pattern string) ([]string, error) {
	keys := []string{}
	v, err := c.execOnFirst(true, "KEYS", pattern)
	if err != nil {
		return keys, err
	}
	return iface2vstr(v), nil
}
607893
func GetProperties(t reflect.Type) *StructProperties {
	if t.Kind() != reflect.Struct {
		panic("proto: type must have kind struct")
	}

	// Most calls to GetProperties in a long-running program will be
	// retrieving details for types we have seen before.
	propertiesMu.RLock()
	sprop, ok := propertiesMap[t]
	propertiesMu.RUnlock()
	if ok {
		return sprop
	}

	propertiesMu.Lock()
	sprop = getPropertiesLocked(t)
	propertiesMu.Unlock()
	return sprop
}