// Shows the properties of an object.
// Returns the identifier and the definition of the dimension.
// If the member delta is set to true in the request object, only the delta is retrieved.
961171
func (obj *GenericDimension) GetProperties(ctx context.Context) (*GenericDimensionProperties, error) {
	result := &struct {
		Prop *GenericDimensionProperties	`json:"qProp"`
	} {}
	err := obj.rpc(ctx, "GetProperties", result)
	return result.Prop, err 
}
335028
func (f *ItemFlagger) GetDimensions() map[string]string {
	f.mu.RLock()
	ret := f.dimensions
	f.mu.RUnlock()
	return ret
}
90580
func (f *File) ajustSingleRowDimensions(r *xlsxRow, num int) {
	r.R = num
	for i, col := range r.C {
		colName, _, _ := SplitCellName(col.R)
		r.C[i].R, _ = JoinCellName(colName, num)
	}
}
460739
func (h *Client) DimensionIndex(dimensionIndex string) *Client {
	h.dimensionIndex = dimensionIndex
	h.dimensionIndexSet = true
	return h
}
773390
func (obj *GenericObject) GetFullPropertyTreeRaw(ctx context.Context) (json.RawMessage, error) {
	result := &struct {
		PropEntry json.RawMessage	`json:"qPropEntry"`
	} {}
	err := obj.rpc(ctx, "GetFullPropertyTree", result)
	return result.PropEntry, err 
}
993200
func (o *Object) DefineDataProperty(name string, value Value, writable, configurable, enumerable Flag) error {
	return tryFunc(func() {
		o.self.defineOwnProperty(newStringValue(name), propertyDescr{
			Value:        value,
			Writable:     writable,
			Configurable: configurable,
			Enumerable:   enumerable,
		}, true)
	})
}
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 
}
391444
func (arc *ConfigFactory) GetConfigurationsByDimensionInfo(dimensionInfo string) map[string]interface{} {
	if arc.initSuccess == false {
		return nil
	}

	config, err := arc.configMgr.GetConfigurationsByDimensionInfo(dimensionInfo)
	if err != nil {
		openlogging.GetLogger().Errorf("Failed to get the configuration by dimension info: %s", err)
	}

	return config
}
349505
func (obj *Variable) GetNxProperties(ctx context.Context) (*NxVariableProperties, error) {
	result := &struct {
		Properties *NxVariableProperties	`json:"qProperties"`
	} {}
	err := obj.rpc(ctx, "GetNxProperties", result)
	return result.Properties, err 
}
729940
func (c *BotsListCall) Dimensions(dimensions ...string) *BotsListCall {
	c.urlParams_.SetMulti("dimensions", append([]string{}, dimensions...))
	return c
}
25517
func (r Account_Regional_Registry_Detail_Property) GetPropertyType() (resp datatypes.Account_Regional_Registry_Detail_Property_Type, err error) {
	err = r.Session.DoRequest("SoftLayer_Account_Regional_Registry_Detail_Property", "getPropertyType", nil, &r.Options, &resp)
	return
}
1197826
func (p *Properties) Property(name string, prop Prop) {
	p.propNames = append(p.propNames, name)
	p.props[name] = prop
}
494431
func getBodyPropertiesDescription(body *raml.Bodies) (map[string]interface{}, string) {
	tipStr := body.ApplicationJSON.TypeString()
	if tipStr == "" || strings.ToLower(tipStr) == "object" {
		return body.ApplicationJSON.Properties, ""
	}

	var js raml.JSONSchema

	if err := json.Unmarshal([]byte(body.ApplicationJSON.TypeString()), &js); err != nil {
		return nil, ""
	}
	return js.RAMLProperties(), js.Description

}
1083610
func (b *SampleJSONBuilder) Properties() []*SamplePropertyInfo {
	return []*SamplePropertyInfo{
		b.A1,
		b.A2,
		b.As1,
		b.As2,
		b.As3,
		b.As4,
	}
}
419833
func (c *edgeCollection) Properties(ctx context.Context) (CollectionProperties, error) {
	result, err := c.rawCollection().Properties(ctx)
	if err != nil {
		return CollectionProperties{}, WithStack(err)
	}
	return result, nil
}
1247529
func serializeProperties(props []datastore.Property, exists bool) ([]byte, error) {
	// NOTE: We use a separate exists bool to support nil-props for existing structs
	if !exists {
		return []byte{0, 0, 0, 0}, nil
	}

	buf := getBuffer()
	defer freeBuffer(buf)

	// Serialize the entity header
	header := serializeEntityHeader(len(props), entityExists)
	headerBytes := make([]byte, 4)
	binary.LittleEndian.PutUint32(headerBytes, header)
	buf.Write(headerBytes)

	// Serialize the properties
	for i := range props {
		if err := serializeProperty(buf, &props[i]); err != nil {
			return nil, err
		}
	}

	output := make([]byte, buf.Len())
	copy(output, buf.Bytes())
	return output, nil
}
1070260
func GetProperties(required bool) (*Properties, error) {
	filename := flag.String("props", "", "properties filename")
	flag.Parse()
	if *filename == "" {
		if required {
			return nil, NO_PROPS_FILE
		} else {
			return &Properties{make(map[string]string)}, nil
		}
	}
	return readPropertiesFile(*filename)
}