// ChildProperties returns child properties of a property
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
}
618441
func (obj *GenericObject) SetProperties(ctx context.Context, prop *GenericObjectProperties) error {
	err := obj.rpc(ctx, "SetProperties", nil, prop)
	return err 
}
335717
func (sd StorageGroupDefinition) Children() []dslengine.Definition {
	var stores []dslengine.Definition
	for _, s := range sd.RelationalStores {
		stores = append(stores, s)
	}
	return stores
}
733320
func (r *GormWorkItemTypeRepository) AddChildTypes(ctx context.Context, parentTypeID uuid.UUID, childTypeIDs []uuid.UUID) error {
	defer goa.MeasureSince([]string{"goa", "db", "workitemtype", "add_child_types"}, time.Now())
	if len(childTypeIDs) <= 0 {
		return nil
	}
	// Create entries for each child in the type list
	for idx, ID := range childTypeIDs {
		childType := ChildType{
			ParentWorkItemTypeID: parentTypeID,
			ChildWorkItemTypeID:  ID,
			Position:             idx,
		}
		db := r.db.Create(&childType)
		if db.Error != nil {
			return errors.NewInternalError(ctx, db.Error)
		}
	}
	ClearGlobalWorkItemTypeCache()
	return nil

}
376004
func (pb ProjectionBuilder) buildChildNodes() ([]exprNode, error) {
	childNodes := make([]exprNode, 0, len(pb.names))
	for _, name := range pb.names {
		operand, err := name.BuildOperand()
		if err != nil {
			return []exprNode{}, err
		}
		childNodes = append(childNodes, operand.exprNode)
	}

	return childNodes, nil
}
1083610
func (b *SampleJSONBuilder) Properties() []*SamplePropertyInfo {
	return []*SamplePropertyInfo{
		b.A1,
		b.A2,
		b.As1,
		b.As2,
		b.As3,
		b.As4,
	}
}
657844
func (o *Object) ChildPathObject(path string) (*Object, error) {
	return o.ChildPathObjectOrFunc(path, o.h.NewObject)
}
530382
func (obj *GenericDimension) SetProperties(ctx context.Context, prop *GenericDimensionProperties) error {
	err := obj.rpc(ctx, "SetProperties", nil, prop)
	return err 
}
191919
func (o *ObjectConstraint) MaxProperties(n int) *ObjectConstraint {
	o.maxProperties = n
	return o
}
799900
func (dp *Datapoint) GetProperties() map[string]interface{} {
	m, ok := dp.Meta[tsProperty].(map[string]interface{})
	if !ok {
		return nil
	}
	return m
}
455914
func NewProperties(parameters *TestParameters) *Properties {
	if parameters == nil {
		parameters = DefaultTestParameters()
	}
	return &Properties{
		parameters: parameters,
		props:      make(map[string]Prop, 0),
		propNames:  make([]string, 0),
	}
}
638336
func (tn *TreeNode) ChildData() *ChildData {
	tn.RLock()
	defer tn.RUnlock()
	return tn.childData
}
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
}
982601
func (s *DocumentationPart) SetProperties(v string) *DocumentationPart {
	s.Properties = &v
	return s
}
777110
func (s *Namespace) SetProperties(v *NamespaceProperties) *Namespace {
	s.Properties = v
	return s
}
128242
func (fp *FieldPath) Child(name string, moreNames ...string) *FieldPath {
	r := NewFieldPath(name, moreNames...)
	r.Root().parent = fp
	return r
}
182869
func (b *SampleJSONBuilder) Properties() []*SamplePropertyInfo {
	return []*SamplePropertyInfo{
		b.B,
		b.C,
		b.D,
		b.E,
	}
}