Increment (and/or create) a counter inside the map.
@method incrementCounter
@param {String} key the key in the map for this counter.
@param {Number} increment the amount to increment (or decrement if negative)
@chainable
320466
function(key, increment) {
        this._removeRemove(this.counters.remove, key);
        var op = this._getOp(this.counters.increment, key);
        if (op) {
            op.increment += increment;
        } else {
            this.counters.increment.push({key: key, increment: increment});
        }
        return this;
    }
356736
public MapUpdate removeCounter(String key)
    {
        BinaryValue k = BinaryValue.create(key);
        removes.add(new MapOp.MapField(MapOp.FieldType.COUNTER, k));
        return this;
    }
67786
function _counter() {
    var counter = this.single.counter;
    var toUpdate = {};
    toUpdate[counter.column] = this.client.raw(this.formatter.wrap(counter.column) + ' ' + (counter.symbol || '+') + ' ' + counter.amount);
    this.single.update = toUpdate;
    return this.update();
  }
694255
def _increment_prop(self, prop, path=None, **kwargs):
        
        new_path = self.make_path(prop, path)
        if self.method == 'simple':
            counter = kwargs['current']
        else:
            counter = self.counts
        try:
            counter[new_path] += 1
        except KeyError:
            counter[new_path] = 1
        return counter
971667
function _counter(column, amount, symbol) {
    var amt = parseInt(amount, 10);
    if (isNaN(amt)) {
      amt = 1;
    }
    this._method = 'counter';
    this._single.counter = {
      column: column,
      amount: amt,
      symbol: symbol || '+'
    };
    return this;
  }
48711
public function increment($key, $value = 1)
    {
        $this->pushStandardKeys($this->tags->getNamespace(), $key);

        parent::increment($key, $value);
    }
796055
def increment(d, key, val=1):
    
    if key in d:
        d[key] += val
    else:
        d[key] = val
1138533
protected function addResult($key, $increment = 1)
    {
        if (!array_key_exists($key, $this->results)) {
            $this->results[$key] = 0;
        }
        $this->results[$key] += $increment;
        return $this;
    }
596710
void increment(double amount) {
    if (amount >= 0.0) {
      for (int i = 0; i < ServoPollers.NUM_POLLERS; ++i) {
        add(count.getCurrent(i), amount);
      }
    }
  }
246856
def increment(self):
        ''''''

        for i in xrange(len(self._counter) - 1, -1, -1):
            self._counter[i] += 1

            if self._counter[i] < 256: break

            # Carry the one
            self._counter[i] = 0

        # Overflow
        else:
            self._counter = [ 0 ] * len(self._counter)
543749
def increment(key, amount = 1, options = {})
      value = Utils.to_int(load(key, options)) + amount
      store(key, value.to_s, options)
      value
    end
86853
public function increment($key, $step)
    {
        $value = $this->getValueByKey($key, false);
        $this->alter($key, $value + $step);
    }
362974
private static int add1OrIncrement(String name, Map<String, Integer> map) {
        Integer old = map.get(name);
        int index = old == null ? 1 : old.intValue() + 1;
        map.put(name, Integer.valueOf(index));
        return index;
    }
120869
public void increment(T item, double amount) {
    counts.put(item, counts.get(item) + amount);
    totalCount += amount;
  }
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()
1311502
public void incrementCount(F first, S second, double inc) {
        Counter<S> counter = maps.get(first);
        if (counter == null) {
            counter = new Counter<S>();
            maps.put(first, counter);
        }

        counter.incrementCount(second, inc);
    }
1238725
public void add(Counter<? extends Pair<T>> counter) {
        for (Map.Entry<? extends Pair<T>,Integer> e : counter) {
            count(e.getKey(), e.getValue());
        }
    }