// GetPropertyCF returns the value of a database property.
516655
func (db *DB) GetPropertyCF(propName string, cf *ColumnFamilyHandle) string {
	cProp := C.CString(propName)
	defer C.free(unsafe.Pointer(cProp))
	cValue := C.rocksdb_property_value_cf(db.c, cf.c, cProp)
	defer C.free(unsafe.Pointer(cValue))
	return C.GoString(cValue)
}
749940
func (domain *Domain) propertyNameForReference(reference string) *string {
	parts := strings.Split(reference, "/")
	first := parts[0]
	last := parts[len(parts)-1]
	if first == "#" {
		return &last
	}
	return nil
}
377921
func getColumnTyp(al *alias, fi *fieldInfo) (col string) {
	T := al.DbBaser.DbTypes()
	fieldType := fi.fieldType
	fieldSize := fi.size

checkColumn:
	switch fieldType {
	case TypeBooleanField:
		col = T["bool"]
	case TypeCharField:
		col = fmt.Sprintf(T["string"], fieldSize)
	case TypeTextField:
		col = T["string-text"]
	case TypeDateField:
		col = T["time.Time-date"]
	case TypeDateTimeField:
		col = T["time.Time"]
	case TypeBitField:
		col = T["int8"]
	case TypeSmallIntegerField:
		col = T["int16"]
	case TypeIntegerField:
		col = T["int32"]
	case TypeBigIntegerField:
		if al.Driver == DRSqlite {
			fieldType = TypeIntegerField
			goto checkColumn
		}
		col = T["int64"]
	case TypePositiveBitField:
		col = T["uint8"]
	case TypePositiveSmallIntegerField:
		col = T["uint16"]
	case TypePositiveIntegerField:
		col = T["uint32"]
	case TypePositiveBigIntegerField:
		col = T["uint64"]
	case TypeFloatField:
		col = T["float64"]
	case TypeDecimalField:
		s := T["float64-decimal"]
		if strings.Index(s, "%d") == -1 {
			col = s
		} else {
			col = fmt.Sprintf(s, fi.digits, fi.decimals)
		}
	case RelForeignKey, RelOneToOne:
		fieldType = fi.relModelInfo.fields.pk.fieldType
		fieldSize = fi.relModelInfo.fields.pk.size
		goto checkColumn
	}

	return
}
318741
func (c *Conn) GetManagerProperty(prop string) (string, error) {
	variant, err := c.sysobj.GetProperty("org.freedesktop.systemd1.Manager." + prop)
	if err != nil {
		return "", err
	}
	return variant.String(), nil
}
468529
func (s *Products) GetPropertiesByJob(jobname string) (properties []Properties, err error) {
	var job Jobs
	job, err = s.GetJob(jobname)
	if err != nil {
		return
	}
	properties = job.Properties
	return
}
163710
func (c *DbClient) GetDataForKey(key string) (*decoder.FileDataEntry, bool) {
	c.Lock()
	defer c.Unlock()

	for _, file := range c.db {
		value, ok := file[key]
		if ok {
			return &decoder.FileDataEntry{
				Key:   key,
				Value: value.data,
			}, true
		}
	}
	return nil, false
}
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
}
115329
func getFieldRef(obj runtime.Object, from *corev1.EnvVarSource) (string, error) {
	return fieldpath.ExtractFieldPathAsString(obj, from.FieldRef.FieldPath)
}
1144978
func (api *PrivateDebugAPI) ChaindbProperty(property string) (string, error) {
	ldb, ok := api.b.ChainDb().(interface {
		LDB() *leveldb.DB
	})
	if !ok {
		return "", fmt.Errorf("chaindbProperty does not work for memory databases")
	}
	if property == "" {
		property = "leveldb.stats"
	} else if !strings.HasPrefix(property, "leveldb.") {
		property = "leveldb." + property
	}
	return ldb.LDB().GetProperty(property)
}
844608
func (l *SigChainLoader) GetKeyFamily() (err error) {
	l.ckf.kf = l.user.GetKeyFamily()
	return
}
747131
func (c *DbClient) GetDataForFile(path string) []*decoder.FileDataEntry {
	c.Lock()
	defer c.Unlock()

	var keyValues []*decoder.FileDataEntry
	if dbKeyValues, ok := c.db[path]; ok {
		for key, value := range dbKeyValues {
			keyValues = append(keyValues, &decoder.FileDataEntry{
				Key:   key,
				Value: value.data,
			})
		}
	}
	return keyValues
}
451543
func (obj *GenericBookmark) GetPropertiesRaw(ctx context.Context) (json.RawMessage, error) {
	result := &struct {
		Prop json.RawMessage	`json:"qProp"`
	} {}
	err := obj.rpc(ctx, "GetProperties", result)
	return result.Prop, err 
}
1120299
func (property *Property) GetProperty() error {
	req, err := client.NewRequest(
		Config,
		"GET",
		fmt.Sprintf(
			"/papi/v1/properties/%s",
			property.PropertyID,
		),
		nil,
	)
	if err != nil {
		return err
	}

	res, err := client.Do(Config, req)
	if err != nil {
		return err
	}

	if client.IsError(res) {
		return client.NewAPIError(res)
	}

	newProperties := NewProperties()
	if err := client.BodyJSON(res, newProperties); err != nil {
		return err
	}

	property.AccountID = newProperties.Properties.Items[0].AccountID
	property.Contract = newProperties.Properties.Items[0].Contract
	property.Group = newProperties.Properties.Items[0].Group
	property.ContractID = newProperties.Properties.Items[0].ContractID
	property.GroupID = newProperties.Properties.Items[0].GroupID
	property.PropertyID = newProperties.Properties.Items[0].PropertyID
	property.PropertyName = newProperties.Properties.Items[0].PropertyName
	property.LatestVersion = newProperties.Properties.Items[0].LatestVersion
	property.StagingVersion = newProperties.Properties.Items[0].StagingVersion
	property.ProductionVersion = newProperties.Properties.Items[0].ProductionVersion
	property.Note = newProperties.Properties.Items[0].Note
	property.ProductID = newProperties.Properties.Items[0].ProductID
	property.RuleFormat = newProperties.Properties.Items[0].RuleFormat
	property.CloneFrom = newProperties.Properties.Items[0].CloneFrom

	return nil
}
1324643
func (obj *GenericObject) GetFullPropertyTree(ctx context.Context) (*GenericObjectEntry, error) {
	result := &struct {
		PropEntry *GenericObjectEntry	`json:"qPropEntry"`
	} {}
	err := obj.rpc(ctx, "GetFullPropertyTree", result)
	return result.PropEntry, err 
}
135056
func (obj *GenericMeasure) GetProperties(ctx context.Context) (*GenericMeasureProperties, error) {
	result := &struct {
		Prop *GenericMeasureProperties	`json:"qProp"`
	} {}
	err := obj.rpc(ctx, "GetProperties", result)
	return result.Prop, err 
}
282063
func (obj *GenericBookmark) GetProperties(ctx context.Context) (*GenericBookmarkProperties, error) {
	result := &struct {
		Prop *GenericBookmarkProperties	`json:"qProp"`
	} {}
	err := obj.rpc(ctx, "GetProperties", result)
	return result.Prop, err 
}
502290
func readPropertiesFile(filePath string) (map[string]string, error) {
	props, err := properties.LoadFile(filePath, properties.UTF8)
	if err != nil {
		return nil, err
	}

	return props.Map(), nil
}