// Properties fetches extended information about the view.
197179
func (v *viewArangoSearch) Properties(ctx context.Context) (ArangoSearchViewProperties, error) {
	req, err := v.conn.NewRequest("GET", path.Join(v.relPath(), "properties"))
	if err != nil {
		return ArangoSearchViewProperties{}, WithStack(err)
	}
	applyContextSettings(ctx, req)
	resp, err := v.conn.Do(ctx, req)
	if err != nil {
		return ArangoSearchViewProperties{}, WithStack(err)
	}
	if err := resp.CheckStatus(200); err != nil {
		return ArangoSearchViewProperties{}, WithStack(err)
	}
	var data ArangoSearchViewProperties
	if err := resp.ParseBody("", &data); err != nil {
		return ArangoSearchViewProperties{}, WithStack(err)
	}
	return data, nil
}
531084
func (n *nessusImpl) ServerProperties() (*ServerProperties, error) {
	if n.verbose {
		log.Println("Server properties...")
	}

	resp, err := n.doRequest("GET", "/server/properties", nil, []int{http.StatusOK})
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()
	reply := &ServerProperties{}
	if err = json.NewDecoder(resp.Body).Decode(&reply); err != nil {
		return nil, err
	}
	return reply, nil
}
888829
func (p *testSuiteDataParser) ExtractProperties(line string) (map[string]string, bool) {
	// `os::cmd` suites cannot expose properties
	return map[string]string{}, false
}
16449
func ChildProperties(Properties map[string]interface{}) []raml.Property {
	props := make([]raml.Property, 0)

	for propName, propInterface := range Properties {
		props = append(props, raml.ToProperty(propName, propInterface))
	}

	return props
}
368392
func AppendProperties(propertiesFile string, properties ...*Property) error {
	file, err := os.OpenFile(propertiesFile, os.O_RDWR|os.O_APPEND, NewFilePermissions)
	if err != nil {
		return err
	}
	for _, property := range properties {
		file.WriteString(fmt.Sprintf("\n%s\n", property.String()))
	}
	return file.Close()
}
1131895
func (b *SampleJSONBuilder) Properties() []*SamplePropertyInfo {
	return []*SamplePropertyInfo{
		b.A,
		b.B,
		b.C,
		b.D,
		b.F,
		b.G,
	}
}
436115
func (f Form) Properties(s []byte) Properties {
	if f == NFC || f == NFD {
		return compInfo(nfcData.lookup(s))
	}
	return compInfo(nfkcData.lookup(s))
}
1093305
func (b *PersonJSONBuilder) Properties() []*PersonPropertyInfo {
	return []*PersonPropertyInfo{
		b.Name,
		b.Age,
		b.Password,
	}
}
1276580
func (f *Field) views() []*view {
	f.mu.RLock()
	defer f.mu.RUnlock()

	other := make([]*view, 0, len(f.viewMap))
	for _, view := range f.viewMap {
		other = append(other, view)
	}
	return other
}
1064335
func (o *Object) GetProperty(p string) (Variant, error) {
	idx := strings.LastIndex(p, ".")
	if idx == -1 || idx+1 == len(p) {
		return Variant{}, errors.New("dbus: invalid property " + p)
	}

	iface := p[:idx]
	prop := p[idx+1:]

	result := Variant{}
	err := o.Call("org.freedesktop.DBus.Properties.Get", 0, iface, prop).Store(&result)

	if err != nil {
		return Variant{}, err
	}

	return result, nil
}
531145
func (p *propertySet) populateProperties(allocs []*structs.Allocation, nodes map[string]*structs.Node,
	properties map[string]uint64) {

	for _, alloc := range allocs {
		nProperty, ok := getProperty(nodes[alloc.NodeID], p.targetAttribute)
		if !ok {
			continue
		}

		properties[nProperty]++
	}
}
1189105
func analyticsProperties(s interface{}) map[string]interface{} {
	m := make(map[string]interface{})

	v := reflect.ValueOf(s).Elem()
	t := v.Type()

	if v.Kind() != reflect.Struct {
		return m
	}

	for i := 0; i < v.NumField(); i++ {
		field := v.Field(i)

		switch field.Kind() {
		case reflect.Ptr:
			if field.IsNil() || !field.CanInterface() {
				continue
			}

			mm := analyticsProperties(field.Interface())
			for k, v := range mm {
				m[k] = v
			}
		case reflect.Struct:
			mm := analyticsProperties(field.Addr().Interface())
			for k, v := range mm {
				m[k] = v
			}
		default:
			tag := t.Field(i).Tag.Get("analytics")
			if tag != "" {
				m[tag] = field.Interface()
			}
		}
	}

	return m
}
15354
func (state *UserState) Properties(username string) []string {
	props, err := state.users.Keys(username)
	if err != nil {
		return []string{}
	}
	return props
}
793135
func (ps *PropertiesService) Get(ctx context.Context, name string, pr *PropertyRequest) (*Properties, *APIResponse, error) {
	ps.log.WithField("endpoint", "PropertiesServices.Get").Info("Calling endpoint")
	return ps.commonPropertiesAction(ctx, fmt.Sprintf("/properties/%s/%d/%s/%d/%s/%s",
		pr.Pipeline, pr.PipelineCounter,
		pr.Stage, pr.StageCounter,
		pr.Job, name,
	), true)
}
967607
func NewPropertiesSearchResult(Matches []*PropertiesSearchMatch) *PropertiesSearchResult {
	s := new(PropertiesSearchResult)
	s.Matches = Matches
	return s
}
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
}
1280402
func GetProperties(contract *Contract, group *Group) (*Properties, error) {
	properties := NewProperties()
	if err := properties.GetProperties(contract, group); err != nil {
		return nil, err
	}

	return properties, nil
}