Atomically increments a node's value.
326527
async def add(self, full, valu):
        '''
        
        '''
        node = await self.open(full)

        oldv = node.valu
        newv = oldv + valu

        node.valu = await self.storNodeValu(full, node.valu + valu)

        await node.fire('hive:set', path=full, valu=valu, oldv=oldv)

        return newv
555983
final public void increment(long time, long value) {
        if (!enabled)
            return;

        lastSampleTime = time;
        if (!sync) {
            count += value;
        } else {
            synchronized (this) {
                count += value;
            }
        }
    }
620147
public void update(final float value) {
    if (Float.isNaN(value)) { return; }
    if (isEmpty()) {
      minValue_ = value;
      maxValue_ = value;
    } else {
      if (value < minValue_) { minValue_ = value; }
      if (value > maxValue_) { maxValue_ = value; }
    }
    if (levels_[0] == 0) {
      compressWhileUpdating();
    }
    n_++;
    isLevelZeroSorted_ = false;
    final int nextPos = levels_[0] - 1;
    assert levels_[0] >= 0;
    levels_[0] = nextPos;
    items_[nextPos] = value;
  }
1062329
def strictly_increasing(values):
    """"""
    return all(x < y for x, y in zip(values, values[1:]))
1077982
def increment(self, member, amount=1):
        """"""
        return self.client.zincrby(self.name, member, amount)
615002
public void update(int node) {
        final int prev = prev(node);
        final int next = next(node);
        if ((prev == NIL || compare(prev) > 0) && (next == NIL || compare(next) < 0)) {
            // Update can be done in-place
            copy(node);
            for (int n = node; n != NIL; n = parent(n)) {
                fixAggregates(n);
            }
        } else {
            // TODO: it should be possible to find the new node position without
            // starting from scratch
            remove(node);
            add();
        }
    }
1468
def _increment(self, what, host):
        '''  '''

        self.processed[host] = 1
        prev = (getattr(self, what)).get(host, 0)
        getattr(self, what)[host] = prev+1
406158
def increment(self, name, value):
        
        counter = self.get(name, CounterType.Increment)
        counter.count = counter.count + value if counter.count != None else value
        self._update()
1192661
public void incrementAll(CounterMap<F, S> other) {
        for (Map.Entry<F, Counter<S>> entry : other.maps.entrySet()) {
            F key = entry.getKey();
            Counter<S> innerCounter = entry.getValue();
            for (Map.Entry<S, AtomicDouble> innerEntry : innerCounter.entrySet()) {
                S value = innerEntry.getKey();
                incrementCount(key, value, innerEntry.getValue().get());
            }
        }
    }
460704
def increment(handler, increment, item_id, counter_name):
    """"""
    data = {'operation': 'increment_counter',
            'id': item_id,
            'counter_name': counter_name,
            'increment': increment}
    handler.invoke(data)
851796
def on_assign(self, node):    # ('targets', 'value')
        """"""
        val = self.run(node.value)
        for tnode in node.targets:
            self.node_assign(tnode, val)
        return
805196
def increment(self, key, value=1):
        
        raw = self._get_payload(key)

        integer = int(raw['data']) + value

        self.put(key, integer, int(raw['time']))

        return integer
1368221
private void increment( TldFernFeature f , boolean positive ) {
		if( positive ) {
			f.incrementP();
			if( f.numP > maxP )
				maxP = f.numP;
		} else {
			f.incrementN();
			if( f.numN > maxN )
				maxN = f.numN;
		}
	}
594431
def put(self, key, value, element):
        """"""
        self.neoindex[key][value] = element.neoelement
372101
private void updateIncrementalSimonsIncrease(long inc, long now) {
		for (Simon simon : incrementalSimons.values()) {
			((CounterImpl) simon).increasePrivate(inc, now);
		}
	}
1132180
def update_node(self, node, diff=None):
        """"""
        return self.manager.update_node(node, diff=diff)
638752
def _increment(self, n=1):
        """"""
        if self._cur_position >= self.num_tokens-1:
            self._cur_positon = self.num_tokens - 1
            self._finished = True
        else:
            self._cur_position += n