// UpdateDelay updates i2c signal delay amount; tune if neccessary to fit your requirements
500657
func (c *digisparkI2cConnection) UpdateDelay(duration uint) error {
	if !c.adaptor.i2c {
		return errors.New("Digispark i2c not initialized")
	}
	return c.adaptor.littleWire.i2cUpdateDelay(duration)
}
592690
func (c *Client) UpdateDomain(p *UpdateDomainParameter) (*Domain, error) {
	obj, err := c.Request("updateDomain", convertParamToMap(p))
	if err != nil {
		return nil, err
	}
	return obj.(*Domain), err
}
827452
func (mh *MinHeap) UpdateEl(el *Element, priority int) {
	heap.Remove(mh, el.index)
	el.Priority = priority
	heap.Push(mh, el)
}
195959
func (client *CMSClient) UpdateAlarm(args *UpdateAlarmArgs) error {
	response := &UpdateAlarmResponse{}
	err := client.Invoke("UpdateAlarm", args, response)

	return err
}
676522
func (api *Client) UpdateBridge(id string, changedData *BridgeData) error {
	_, _, err := api.makeRequest(http.MethodPost, fmt.Sprintf("%s/%s", api.concatUserPath(bridgesPath), id), nil, changedData)
	return err
}
1055838
func (_m *DBClient) UpdateDeviceReport(dr models.DeviceReport) error {
	ret := _m.Called(dr)

	var r0 error
	if rf, ok := ret.Get(0).(func(models.DeviceReport) error); ok {
		r0 = rf(dr)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
608124
func (client *Client) UpdateLIFF(liffID string, view View) *UpdateLIFFCall {
	return &UpdateLIFFCall{
		c:      client,
		liffID: liffID,
		view:   view,
	}
}
1276281
func (c *FakeCSIDrivers) Update(cSIDriver *v1beta1.CSIDriver) (result *v1beta1.CSIDriver, err error) {
	obj, err := c.Fake.
		Invokes(testing.NewRootUpdateAction(csidriversResource, cSIDriver), &v1beta1.CSIDriver{})
	if obj == nil {
		return nil, err
	}
	return obj.(*v1beta1.CSIDriver), err
}
1178688
func updateServiceLastReported(ds models.DeviceService, lr int64, w http.ResponseWriter) error {
	ds.LastReported = lr
	if err := dbClient.UpdateDeviceService(ds); err != nil {
		http.Error(w, err.Error(), http.StatusServiceUnavailable)
		return err
	}

	return nil
}
530791
func (sc *DocumentsWriterStallControl) updateStalled(stalled bool) {
	sc.Lock()
	defer sc.Unlock()
	sc.stalled = stalled
	if stalled {
		sc.wasStalled = true
	}
	sc.Signal()
}
283155
func (s *sequenceDecs) updateAlt(br *bitReader) {
	// Update all 3 states at once. Approx 20% faster.
	a, b, c := s.litLengths.state.state, s.matchLengths.state.state, s.offsets.state.state

	nBits := a.nbBits + b.nbBits + c.nbBits
	if nBits == 0 {
		s.litLengths.state.state = s.litLengths.state.dt[a.newState]
		s.matchLengths.state.state = s.matchLengths.state.dt[b.newState]
		s.offsets.state.state = s.offsets.state.dt[c.newState]
		return
	}
	bits := br.getBitsFast(nBits)
	lowBits := uint16(bits >> ((c.nbBits + b.nbBits) & 31))
	s.litLengths.state.state = s.litLengths.state.dt[a.newState+lowBits]

	lowBits = uint16(bits >> (c.nbBits & 31))
	lowBits &= bitMask[b.nbBits&15]
	s.matchLengths.state.state = s.matchLengths.state.dt[b.newState+lowBits]

	lowBits = uint16(bits) & bitMask[c.nbBits&15]
	s.offsets.state.state = s.offsets.state.dt[c.newState+lowBits]
}
283202
func (l *channelLink) updateChannelFee(feePerKw lnwallet.SatPerKWeight) error {

	log.Infof("ChannelPoint(%v): updating commit fee to %v sat/kw", l,
		feePerKw)

	// We skip sending the UpdateFee message if the channel is not
	// currently eligible to forward messages.
	if !l.EligibleToForward() {
		log.Debugf("ChannelPoint(%v): skipping fee update for "+
			"inactive channel", l.ChanID())
		return nil
	}

	// First, we'll update the local fee on our commitment.
	if err := l.channel.UpdateFee(feePerKw); err != nil {
		return err
	}

	// We'll then attempt to send a new UpdateFee message, and also lock it
	// in immediately by triggering a commitment update.
	msg := lnwire.NewUpdateFee(l.ChanID(), uint32(feePerKw))
	if err := l.cfg.Peer.SendMessage(false, msg); err != nil {
		return err
	}
	return l.updateCommitTx()
}
1293278
func (_m *DBClient) UpdateDeviceService(ds models.DeviceService) error {
	ret := _m.Called(ds)

	var r0 error
	if rf, ok := ret.Get(0).(func(models.DeviceService) error); ok {
		r0 = rf(ds)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}
258885
func (n *NetworkServerAPI) UpdateDevice(ctx context.Context, req *ns.UpdateDeviceRequest) (*empty.Empty, error) {
	if req.Device == nil {
		return nil, grpc.Errorf(codes.InvalidArgument, "device must not be nil")
	}

	var devEUI lorawan.EUI64
	var dpID, spID, rpID uuid.UUID

	copy(devEUI[:], req.Device.DevEui)
	copy(dpID[:], req.Device.DeviceProfileId)
	copy(rpID[:], req.Device.RoutingProfileId)
	copy(spID[:], req.Device.ServiceProfileId)

	d, err := storage.GetDevice(storage.DB(), devEUI)
	if err != nil {
		return nil, errToRPCError(err)
	}

	d.DeviceProfileID = dpID
	d.ServiceProfileID = spID
	d.RoutingProfileID = rpID
	d.SkipFCntCheck = req.Device.SkipFCntCheck
	d.ReferenceAltitude = req.Device.ReferenceAltitude

	if err := storage.UpdateDevice(storage.DB(), &d); err != nil {
		return nil, errToRPCError(err)
	}

	return &empty.Empty{}, nil
}
320397
func (pq *PriorityQueue) Update(priority uint8, id uint64, newValue []byte) (*PriorityItem, error) {
	pq.Lock()
	defer pq.Unlock()

	// Check if queue is closed.
	if !pq.isOpen {
		return nil, ErrDBClosed
	}

	// Check if item exists in queue.
	if id <= pq.levels[priority].head || id > pq.levels[priority].tail {
		return nil, ErrOutOfBounds
	}

	// Create new PriorityItem.
	item := &PriorityItem{
		ID:       id,
		Priority: priority,
		Key:      pq.generateKey(priority, id),
		Value:    newValue,
	}

	// Update this item in the queue.
	if err := pq.db.Put(item.Key, item.Value, nil); err != nil {
		return nil, err
	}

	return item, nil
}
480902
func UpdateDeleteRange(ctx sessionctx.Context, dr DelRangeTask, newStartKey, oldStartKey kv.Key) error {
	newStartKeyHex := hex.EncodeToString(newStartKey)
	oldStartKeyHex := hex.EncodeToString(oldStartKey)
	sql := fmt.Sprintf(updateDeleteRangeSQL, newStartKeyHex, dr.JobID, dr.ElementID, oldStartKeyHex)
	_, err := ctx.(sqlexec.SQLExecutor).Execute(context.TODO(), sql)
	return errors.Trace(err)
}
521642
func (mg *MailgunImpl) UpdateDomainConnection(ctx context.Context, domain string, settings DomainConnection) error {
	r := newHTTPRequest(generatePublicApiUrl(mg, domainsEndpoint) + "/" + domain + "/connection")
	r.setClient(mg.Client())
	r.setBasicAuth(basicAuthUser, mg.APIKey())

	payload := newUrlEncodedPayload()
	payload.addValue("require_tls", boolToString(settings.RequireTLS))
	payload.addValue("skip_verification", boolToString(settings.SkipVerification))
	_, err := makePutRequest(ctx, r, payload)
	return err
}