Returns the current marker, then increments the marker by what's specified
322865
def get_marker(self, increment=1):
        

        i = self.markers_index

        self.markers_index += increment
        if self.markers_index >= len(self.markers):
            self.markers_index = self.markers_index-len(self.markers)
            if self.markers_index >= len(self.markers): self.markers_index=0 # to be safe

        return self.markers[i]
1241867
function colorChanged(elem) {
		var color = elem.getAttribute('stroke');

		$.each(mtypes, function(i, pos) {
			var marker = getLinked(elem, 'marker-'+pos);
			if (!marker) {return;}
			if (!marker.attributes.se_type) {return;} // not created by this extension
			var ch = marker.lastElementChild;
			if (!ch) {return;}
			var curfill = ch.getAttribute('fill');
			var curstroke = ch.getAttribute('stroke');
			if (curfill && curfill != 'none') {ch.setAttribute('fill', color);}
			if (curstroke && curstroke != 'none') {ch.setAttribute('stroke', color);}
		});
	}
1267673
def getCurrentItem(self): # TODO: rename? getCurrentItemAndIndex? getCurrentTuple? getCurrent?
        
        currentIndex = self.getRowCurrentIndex()
        currentItem = self.model().getItem(currentIndex)
        return currentItem, currentIndex
1186389
def markers():
    ''' 
    '''
    print("Available markers: \n\n - " + "\n - ".join(list(MarkerType)))
    print()
    print("Shortcuts: \n\n" + "\n".join(" %r: %s" % item for item in _MARKER_SHORTCUTS.items()))
1274193
def touch(self):
        
        marker_key = self.marker_key()
        self.redis_client.hset(marker_key, 'update_id', self.update_id)
        self.redis_client.hset(marker_key, 'date', datetime.datetime.now())

        if self.expire is not None:
            self.redis_client.expire(marker_key, self.expire)
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());
            }
        }
    }
1328761
def increment(self, delta=1):
        
        check_call(_LIB.MXProfileAdjustCounter(self.handle, int(delta)))
441323
function updateMarkWhenResizing() {
    const helper = getHelper();

    ml.getAll().forEach(marker => {
      helper.updateMarkerWithExtraInfo(marker);
    });

    editor.eventManager.emit('markerUpdated', ml.getAll());
  }
713460
def increment(self, delta=1, text=None):
        """"""
        return self.update(value=min(self.max, self.value + delta), text=text)
1266683
public int incrementAndGet(T obj) {
        int prev, next;
        do {
            prev = get(obj);
            next = prev + 1;
        } while (!compareAndSet(obj, prev, next));
        return next;
    }
1089218
function (options) {
		var ret,
			series = this.series,
			pointArrayMap = series.pointArrayMap || ['y'],
			valueCount = pointArrayMap.length,
			firstItemType,
			i = 0,
			j = 0;

		if (typeof options === 'number' || options === null) {
			ret = { y: options };

		} else if (isArray(options)) {
			ret = {};
			// with leading x value
			if (options.length > valueCount) {
				firstItemType = typeof options[0];
				if (firstItemType === 'string') {
					ret.name = options[0];
				} else if (firstItemType === 'number') {
					ret.x = options[0];
				}
				i++;
			}
			while (j < valueCount) {
				ret[pointArrayMap[j++]] = options[i++];
			}			
		} else if (typeof options === 'object') {
			ret = options;

			// This is the fastest way to detect if there are individual point dataLabels that need 
			// to be considered in drawDataLabels. These can only occur in object configs.
			if (options.dataLabels) {
				series._hasPointLabels = true;
			}

			// Same approach as above for markers
			if (options.marker) {
				series._hasPointMarkers = true;
			}
		}
		return ret;
	}
330890
private static final int marker(int marker) {
        for (int i = 0; i < VALID_MARKERS.length; i++) {
            if (marker == VALID_MARKERS[i]) {
                return VALID_MARKER;
            }
        }
        for (int i = 0; i < NOPARAM_MARKERS.length; i++) {
            if (marker == NOPARAM_MARKERS[i]) {
                return NOPARAM_MARKER;
            }
        }
        for (int i = 0; i < UNSUPPORTED_MARKERS.length; i++) {
            if (marker == UNSUPPORTED_MARKERS[i]) {
                return UNSUPPORTED_MARKER;
            }
        }
        return NOT_A_MARKER;
    }
685772
function incrementRemainingMarkdownListNumbers(cm, pos) {
  var startLine = pos.line, lookAhead = 0, skipCount = 0;
  var startItem = listRE.exec(cm.getLine(startLine)), startIndent = startItem[1];

  do {
    lookAhead += 1;
    var nextLineNumber = startLine + lookAhead;
    var nextLine = cm.getLine(nextLineNumber), nextItem = listRE.exec(nextLine);

    if (nextItem) {
      var nextIndent = nextItem[1];
      var newNumber = (parseInt(startItem[3], 10) + lookAhead - skipCount);
      var nextNumber = (parseInt(nextItem[3], 10)), itemNumber = nextNumber;

      if (startIndent === nextIndent && !isNaN(nextNumber)) {
        if (newNumber === nextNumber) itemNumber = nextNumber + 1;
        if (newNumber > nextNumber) itemNumber = newNumber + 1;
        cm.replaceRange(
          nextLine.replace(listRE, nextIndent + itemNumber + nextItem[4] + nextItem[5]),
        {
          line: nextLineNumber, ch: 0
        }, {
          line: nextLineNumber, ch: nextLine.length
        });
      } else {
        if (startIndent.length > nextIndent.length) return;
        // This doesn't run if the next line immediatley indents, as it is
        // not clear of the users intention (new indented item or same level)
        if ((startIndent.length < nextIndent.length) && (lookAhead === 1)) return;
        skipCount += 1;
      }
    }
  } while (nextItem);
}
205235
def _left_motion(self, event):
        """"""
        iid = self.current_iid
        if iid is None:
            return
        marker = self._markers[iid]
        if marker["move"] is False:
            return
        delta = marker["finish"] - marker["start"]
        # Limit x to 0
        x = max(self._timeline.canvasx(event.x), 0)
        # Check if the timeline needs to be extended
        limit = self.get_time_position(self._finish - delta)
        if self._extend is False:
            x = min(x, limit)
        elif x > limit:  # self._extend is True
            self.configure(finish=(self.get_position_time(x) + (marker["finish"] - marker["start"])) * 1.1)
        # Get the new start value
        start = self.get_position_time(x)
        finish = start + (marker["finish"] - marker["start"])
        rectangle_id, text_id = marker["rectangle_id"], marker["text_id"]
        if rectangle_id not in self._timeline.find_all():
            return
        x1, y1, x2, y2 = self._timeline.coords(rectangle_id)
        # Overlap protection
        allow_overlap = marker["allow_overlap"]
        allow_overlap = self._marker_allow_overlap if allow_overlap == "default" else allow_overlap
        if allow_overlap is False:
            for marker_dict in self.markers.values():
                if marker_dict["allow_overlap"] is True:
                    continue
                if marker["iid"] != marker_dict["iid"] and marker["category"] == marker_dict["category"]:
                    if marker_dict["start"] < start < marker_dict["finish"]:
                        start = marker_dict["finish"] if start < marker_dict["finish"] else marker_dict["start"]
                        finish = start + (marker["finish"] - marker["start"])
                        x = self.get_time_position(start)
                        break
                    if marker_dict["start"] < finish < marker_dict["finish"]:
                        finish = marker_dict["finish"] if finish > marker_dict["finish"] else marker_dict["start"]
                        start = finish - (marker_dict["finish"] - marker_dict["start"])
                        x = self.get_time_position(start)
                        break
        # Vertical movement
        if marker["change_category"] is True or \
                (marker["change_category"] == "default" and self._marker_change_category):
            y = max(self._timeline.canvasy(event.y), 0)
            category = min(self._rows.keys(), key=lambda category: abs(self._rows[category][0] - y))
            marker["category"] = category
            y1, y2 = self._rows[category]
        # Snapping to ticks
        if marker["snap_to_ticks"] is True or (marker["snap_to_ticks"] == "default" and self._marker_snap_to_ticks):
            # Start is prioritized over finish
            for tick in self._ticks:
                tick = self.get_time_position(tick)
                # Start
                if abs(x - tick) < self._snap_margin:
                    x = tick
                    break
                # Finish
                x_finish = x + delta
                if abs(x_finish - tick) < self._snap_margin:
                    delta = self.get_time_position(marker["finish"] - marker["start"])
                    x = tick - delta
                    break
        rectangle_coords = (x, y1, x2 + (x - x1), y2)
        self._timeline.coords(rectangle_id, *rectangle_coords)
        if text_id is not None:
            text_x, text_y = TimeLine.calculate_text_coords(rectangle_coords)
            self._timeline.coords(text_id, text_x, text_y)
        if self._after_id is not None:
            self.after_cancel(self._after_id)
        args = (iid, (marker["start"], marker["finish"]), (start, finish))
        self._after_id = self.after(10, self._after_handler(iid, "move_callback", args))
        marker["start"] = start
        marker["finish"] = finish
997306
function _moveMarker(treeData, markerName, oldPath, newPath) {
        var objectPath;

        if (newPath) {
            objectPath = _filePathToObjectPath(treeData, newPath);
        }

        var newTreeData = treeData;

        if (oldPath && oldPath !== newPath) {
            var lastObjectPath = _filePathToObjectPath(treeData, oldPath);
            if (lastObjectPath) {
                newTreeData = newTreeData.updateIn(lastObjectPath, function (entry) {
                    return entry.delete(markerName);
                });
            }
        }

        if (newPath && objectPath && objectPath.length !== 0) {
            newTreeData = newTreeData.updateIn(objectPath, function (entry) {
                return entry.set(markerName, true);
            });
        }

        return newTreeData;
    }
861844
private int incrementAndGetModulo(int modulo) {
        for (;;) {
            int current = nextIndex.get();
            int next = (current + 1) % modulo;
            if (nextIndex.compareAndSet(current, next) && current < modulo)
                return current;
        }
    }
747953
public BigInteger incrementAndGet() {
        for (;;) {
        	BigInteger current = get();
        	BigInteger next = current.add(BigInteger.ONE);
            if (compareAndSet(current, next))
                return next;
        }
    }