// NodeSet sets a control value on a node.
556243
func (c *Client) NodeSet(id int32, ctls map[string]float32) error {
	msg := osc.Message{
		Address: nodeSetAddress,
		Arguments: osc.Arguments{
			osc.Int(id),
		},
	}
	for k, v := range ctls {
		msg.Arguments = append(msg.Arguments, osc.String(k))
		msg.Arguments = append(msg.Arguments, osc.Float(v))
	}
	return c.oscConn.Send(msg)
}
601962
func (s *ListNodesOutput) SetNodes(v []*NodeSummary) *ListNodesOutput {
	s.Nodes = v
	return s
}
248043
func (tree *MutableTree) Set(key, value []byte) bool {
	orphaned, updated := tree.set(key, value)
	tree.addOrphans(orphaned)
	return updated
}
708173
func (aa *AtomicArray) Set(idx int, node interface{}) error {
	// do not lock if not needed
	if idx < 0 || idx >= aa.length {
		return fmt.Errorf("index %d is larger than array size (%d)", idx, aa.length)
	}

	aa.mutex.Lock()
	aa.items[idx] = node
	aa.mutex.Unlock()
	return nil
}
1142338
func powerSet(set *Set) *Set {
	// Create the output set
	pSet := New()

	// If set is empty, return the nil set
	if set.Size() == 0 {
		pSet.Add(New())
		return pSet
	}

	// Get the head element of the set, and remove it
	head := set.Enumerate()[0]
	set.Remove(head)

	// Get the "tail" power set, and add it to the set
	tpSet := powerSet(set)
	for _, tp := range tpSet.Enumerate() {
		pSet.Add(tp)
	}

	// Iterate the "tail" power set and get the "head" power set,
	// and add it to the set
	for _, tp := range tpSet.Enumerate() {
		hSet := tp.(*Set).Clone()
		hSet.Add(head)
		pSet.Add(hSet)
	}

	return pSet
}
830503
func (db *RedisDB) setSet(k string, set setKey) {
	db.keys[k] = "set"
	db.setKeys[k] = set
	db.keyVersion[k]++
}
888095
func (s *CreateHostedZoneOutput) SetDelegationSet(v *DelegationSet) *CreateHostedZoneOutput {
	s.DelegationSet = v
	return s
}
976265
func (a allocSet) nameSet() map[string]struct{} {
	names := make(map[string]struct{}, len(a))
	for _, alloc := range a {
		names[alloc.Name] = struct{}{}
	}
	return names
}
1005936
func (c *Context) Set(name, value string) error {
	c.setFlags = nil
	return c.flagSet.Set(name, value)
}
641962
func (s *GetObjectTaggingOutput) SetTagSet(v []*Tag) *GetObjectTaggingOutput {
	s.TagSet = v
	return s
}
905899
func (s *GetReusableDelegationSetOutput) SetDelegationSet(v *DelegationSet) *GetReusableDelegationSetOutput {
	s.DelegationSet = v
	return s
}
263275
func (b *BadgeNumber) Set(number uint) {
	b.Number = number
	b.IsSet = true
}
1374659
func (m *MemDB) Set(key, value []byte, o *db.WriteOptions) error {
	m.mutex.Lock()
	defer m.mutex.Unlock()
	// Find the node, and its predecessors at all heights.
	var prev [maxHeight]int
	n, exactMatch := m.findNode(key, &prev)
	if exactMatch {
		m.nodeData[n+fVal] = m.save(value)
		return nil
	}
	// Choose the new node's height, branching with 25% probability.
	h := 1
	for h < maxHeight && rand.Intn(4) == 0 {
		h++
	}
	// Raise the skiplist's height to the node's height, if necessary.
	if m.height < h {
		for i := m.height; i < h; i++ {
			prev[i] = headNode
		}
		m.height = h
	}
	// Insert the new node.
	var x [fNxt + maxHeight]int
	n1 := len(m.nodeData)
	x[fKey] = m.save(key)
	x[fVal] = m.save(value)
	for i := 0; i < h; i++ {
		j := prev[i] + fNxt + i
		x[fNxt+i] = m.nodeData[j]
		m.nodeData[j] = n1
	}
	m.nodeData = append(m.nodeData, x[:fNxt+h]...)
	return nil
}
599713
func (t *Tab) handleSetChildNodes(parentNodeId int, nodes []*gcdapi.DOMNode) {
	for _, node := range nodes {
		t.addNodes(node)
	}
	parent, ok := t.GetElementByNodeId(parentNodeId)
	if ok {
		if err := parent.WaitForReady(); err == nil {
			parent.addChildren(nodes)
		}
	}
	t.lastNodeChangeTimeVal.Store(time.Now())

}
679360
func (p *Pointer) Set(document interface{}, value interface{}) (interface{}, error) {
	return document, p.set(document, value, swag.DefaultJSONNameProvider)
}
1171259
func (d *partialArray) set(key string, val *lazyNode) error {
	idx, err := strconv.Atoi(key)
	if err != nil {
		return err
	}
	(*d)[idx] = val
	return nil
}
559261
func (p JSPointer) Set(item interface{}, value interface{}) error {
	var ctx matchCtx

	ctx.set = true
	ctx.raw = p.raw
	ctx.tokens = &p.tokens
	ctx.setvalue = value
	ctx.apply(item)
	return ctx.err
}