Atomically adds `delta` to the current value.

        :param delta: The delta to add.
779848
def add_and_get(self, delta):
        '''
        
        '''
        with self._reference.get_lock():
            self._reference.value += delta
            return self._reference.value
110030
def _add_timedelta(self, delta):
        
        if isinstance(delta, pendulum.Duration):
            return self.add(
                years=delta.years,
                months=delta.months,
                weeks=delta.weeks,
                days=delta.remaining_days,
            )

        return self.add(days=delta.days)
1338409
def advance_time_delta(timedelta):
    """"""
    assert(utcnow.override_time is not None)
    try:
        for dt in utcnow.override_time:
            dt += timedelta
    except TypeError:
        utcnow.override_time += timedelta
713460
def increment(self, delta=1, text=None):
        """"""
        return self.update(value=min(self.max, self.value + delta), text=text)
1160878
def increment(self, counter_name, delta=1):
    
    self._shard_state.counters_map.increment(counter_name, delta)
1101323
public void plusDays(long delta)
    {
        if (delta != 0)
        {
            long result = getDay() + delta;
            if (result >= 1 && result <= 28)
            {
                setDay((int) result);
            }
            else
            {
                ZonedDateTime zonedDateTime = ZonedDateTime.from(this);
                ZonedDateTime plusDays = zonedDateTime.plusDays(delta);
                set(plusDays);
            }
        }
    }
330494
function Delta(modelID) {
  if (false === (this instanceof Delta)) throw new Error('new operator required');
  if (false === (modelID instanceof Attribute.ModelID)) throw new Error('Attribute.ModelID required in constructor');
  this.dateCreated = new Date();
  this.modelID = modelID;
  this.attributeValues = {};
}
803802
def _add_timedelta(self, delta):
        
        if isinstance(delta, pendulum.Period):
            return self.add(
                years=delta.years,
                months=delta.months,
                weeks=delta.weeks,
                days=delta.remaining_days,
                hours=delta.hours,
                minutes=delta.minutes,
                seconds=delta.remaining_seconds,
                microseconds=delta.microseconds,
            )
        elif isinstance(delta, pendulum.Duration):
            return self.add(
                years=delta.years, months=delta.months, seconds=delta.total_seconds()
            )

        return self.add(seconds=delta.total_seconds())
646831
public final double addAndGet(double delta) 
    {
        while(true) 
        {
            double orig = get();
            double newVal = orig + delta;
            if (compareAndSet(orig, newVal))
                return newVal;
        }
    }
243317
public BigInteger addAndGet(BigInteger delta) {
        for (;;) {
        	BigInteger current = valueHolder.get();
        	BigInteger next = current.add(delta);
            if (valueHolder.compareAndSet(current, next))
                return next;
        }
    }
959638
def addl(self, value, start=0.0, end=float('inf')):
        
        self.add(Label(value, start=start, end=end))
1199724
def patch(self, delta):
        ""
        return self.api.post('path/sync/patch', self.path, delta=delta)
1115470
def incr(self, key, delta=1):
        
        value = self.get(key)
        if value is None:
            raise ValueError("Key '%s' not found" % key)
        new_value = value + delta
        self.set(key, new_value)
        return new_value
1232932
def __run_delta_py(self, delta):
        """"""

        self.__run_py_file(delta.get_file(), delta.get_name())
        self.__update_upgrades_table(delta)
1127724
def _create_delta(self):
        
        states = self._read_transitions()
        total_states = len(states)
        self._add_sink_state(states)
        nulltrans = self._read_null_transitions()

        def delta(current_state, character):
            """
            Sub function describing the transitions
            Args:
                current_state (str): The current state
                character (str): The input character
            Returns:
                str: The next state
            """
            if character != '':
                newstate = states[current_state][ord(character)]
                if newstate > 0:
                    return newstate
                else:
                    return total_states
            else:
                return nulltrans[current_state]

        return total_states + 1, delta
609664
def update_from_delta(self, delta, *args):
        """"""
        for (node, extant) in delta.get('nodes', {}).items():
            if extant:
                if node in delta.get('node_val', {}) \
                        and 'location' in delta['node_val'][node]\
                        and node not in self.pawn:
                    self.add_pawn(node)
                elif node not in self.spot:
                    self.add_spot(node)
                    spot = self.spot[node]
                    if '_x' not in spot.place or '_y' not in spot.place:
                        self.spots_unposd.append(spot)
            else:
                if node in self.pawn:
                    self.rm_pawn(node)
                if node in self.spot:
                    self.rm_spot(node)
        for (node, stats) in delta.get('node_val', {}).items():
            if node in self.spot:
                spot = self.spot[node]
                x = stats.get('_x')
                y = stats.get('_y')
                if x is not None:
                    spot.x = x * self.width
                if y is not None:
                    spot.y = y * self.height
                if '_image_paths' in stats:
                    spot.paths = stats['_image_paths'] or spot.default_image_paths
            elif node in self.pawn:
                pawn = self.pawn[node]
                if 'location' in stats:
                    pawn.loc_name = stats['location']
                if '_image_paths' in stats:
                    pawn.paths = stats['_image_paths'] or pawn.default_image_paths
            else:
                Logger.warning(
                    "Board: diff tried to change stats of node {} "
                    "but I don't have a widget for it".format(node)
                )
        for (orig, dests) in delta.get('edges', {}).items():
            for (dest, extant) in dests.items():
                if extant and (orig not in self.arrow or dest not in self.arrow[orig]):
                    self.add_arrow(orig, dest)
                elif not extant and orig in self.arrow and dest in self.arrow[orig]:
                    self.rm_arrow(orig, dest)
1039665
def update(self, deltat=1.0):
        ''''''
        DNFZ.update(self, deltat)
        self.lifetime -= deltat
        if self.lifetime <= 0:
            self.randpos()
            self.lifetime = random.uniform(300,600)