Increments this version number by 1 in the last digit.<p>
492516
protected void increment() {

        if (m_number < 1999999999999L) {
            m_number += (long)Math.pow(1000.0, (4 - m_dots));
            setVersion(m_number);
        } else {
            throw new CmsRuntimeException(Messages.get().container(Messages.ERR_MODULE_VERSION_NUMBER_0));
        }
    }
381925
def _increment_numeric_suffix(s):
        """"""
        if re.match(r".*\d+$", s):
            return re.sub(r"\d+$", lambda n: str(int(n.group(0)) + 1), s)
        return s + "_2"
1186214
private void addVersionColumn() {

        AbstractCell<CmsHistoryResourceBean> cell = new CmsVersionCell();
        addColumn(CmsHistoryMessages.columnVersion(), 40, new IdentityColumn<CmsHistoryResourceBean>(cell));
    }
1041237
private void incrementModCounts() {
    if (externalMessageList != null) {
      externalMessageList.incrementModCount();
    }
    if (externalBuilderList != null) {
      externalBuilderList.incrementModCount();
    }
    if (externalMessageOrBuilderList != null) {
      externalMessageOrBuilderList.incrementModCount();
    }
  }
1468
def _increment(self, what, host):
        '''  '''

        self.processed[host] = 1
        prev = (getattr(self, what)).get(host, 0)
        getattr(self, what)[host] = prev+1
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;
        }
    }
966647
public void setVersion(String version) {

        m_number = 0L;
        if ((version == null) || (version.charAt(0) == '.') || (version.charAt(version.length() - 1) == '.')) {
            throw new CmsIllegalArgumentException(Messages.get().container(Messages.ERR_NOT_NUMBER_0));
        }
        String[] split = CmsStringUtil.splitAsArray(version, '.');
        m_dots = split.length;
        if (m_dots > 4) {
            throw new CmsIllegalArgumentException(
                Messages.get().container(Messages.ERR_INVALID_VERSION_LENGTH_1, version));
        }
        String[] numbers = new String[5];
        System.arraycopy(split, 0, numbers, 1, m_dots);
        numbers[0] = "1";
        for (int i = 1 + m_dots; i < 5; i++) {
            numbers[i] = "0";
        }
        for (int i = numbers.length - 1; i >= 0; i--) {
            try {
                int number = Integer.valueOf(numbers[numbers.length - i - 1]).intValue();

                if ((number > 999) || (number < 0)) {
                    throw new CmsIllegalArgumentException(
                        Messages.get().container(Messages.ERR_INVALID_VERSION_SUBNUMBER_1, new Integer(number)));
                }
                m_number = ((long)Math.pow(1000.0, i) * number) + m_number;
            } catch (NumberFormatException e) {
                // no valid version provided
                throw new CmsIllegalArgumentException(Messages.get().container(Messages.ERR_NOT_NUMBER_0));
            }
        }

        setVersion(m_number);
    }
913249
@SuppressWarnings("unchecked")
  public <T extends CMAResource> T setVersion(Integer version) {
    getSystem().setVersion(version);
    return (T) this;
  }
1154478
public void updateVersion()
    {
        try
        {
            MessageDigest versionDigest = MessageDigest.getInstance("MD5");

            for (Row row : SystemKeyspace.serializedSchema())
            {
                if (invalidSchemaRow(row) || ignoredSchemaRow(row))
                    continue;

                // we want to digest only live columns
                ColumnFamilyStore.removeDeletedColumnsOnly(row.cf, Integer.MAX_VALUE, SecondaryIndexManager.nullUpdater);
                row.cf.purgeTombstones(Integer.MAX_VALUE);
                row.cf.updateDigest(versionDigest);
            }

            version = UUID.nameUUIDFromBytes(versionDigest.digest());
            SystemKeyspace.updateSchemaVersion(version);
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
1323136
def increment(self, n=1):
        
        with self.count.get_lock():
            self.count.value += n
875196
public void setVersion(String value) {
        clear();
        
        if (value == null || value.length() == 0) {
            return;
        }
        
        String pcs[] = value.split("\\.", 4);
        int len = Math.min(pcs.length, 4);
        
        for (int i = 0; i < len; i++) {
            ver[i] = Long.parseLong(pcs[i]);
        }
    }
356277
public void incrementVersion(int node, long time) {
        if(node < 0 || node > Short.MAX_VALUE)
            throw new IllegalArgumentException(node
                                               + " is outside the acceptable range of node ids.");

        this.timestamp = time;

        Long version = versionMap.get((short) node);
        if(version == null) {
            version = 1L;
        } else {
            version = version + 1L;
        }

        versionMap.put((short) node, version);
        if(versionMap.size() >= MAX_NUMBER_OF_VERSIONS) {
            throw new IllegalStateException("Vector clock is full!");
        }

    }
747953
public BigInteger incrementAndGet() {
        for (;;) {
        	BigInteger current = get();
        	BigInteger next = current.add(BigInteger.ONE);
            if (compareAndSet(current, next))
                return next;
        }
    }
1339137
private void incrementVersion() throws FrameworkException {

		// increment version on each change
		final Long version = getProperty(SessionDataNode.version);
		if (version == null) {

			setProperty(SessionDataNode.version, 1L);

		} else {
			
			setProperty(SessionDataNode.version,  version + 1);
		}
	}
1080953
private boolean incrementViews() {

        if (System.currentTimeMillis() - settings.getLong(KEY_LAST_COUNT_UPDATE, 0L) < minimumInterval) {
            if (debug) LogD("Count not incremented due to minimum interval not reached");
            return false;
        }

        editor.putInt(KEY_COUNT, settings.getInt(KEY_COUNT, 0) + 1);
        editor.putLong(KEY_LAST_COUNT_UPDATE, System.currentTimeMillis());
        commitEditor();
        return true;
    }
858724
public void incrementEntry(int i, SufficientStatistics increment) {
    ensureStatisticInstantiated(i);
    statistics.get(i).increment(increment, 1.0);
  }
969621
private void setVersion(long number) {

        String result = "";
        for (int i = 0; i < 4; i++) {
            long mod = number % 1000L;
            number = number / 1000L;
            if (m_dots >= (4 - i)) {
                if (m_dots > (4 - i)) {
                    result = '.' + result;
                }
                result = "" + mod + result;
            }
        }

        m_version = result;
    }