/*
(non-Javadoc)

@see net.rubyeye.xmemcached.MemcachedClient#decr(java.lang.String, int)
438432
public final long decr(String key, final long delta)
      throws TimeoutException, InterruptedException, MemcachedException {
    key = this.preProcessKey(key);
    return this.sendIncrOrDecrCommand(key, delta, 0, CommandType.DECR, false, this.opTimeout, 0);
  }
734698
String getNamespacedKey(CacheNamespace cacheNamespace, String key) {
        String namespaceIndicator = getNamespaceIndicator(cacheNamespace);

        if (cacheNamespace.isNamespaceExpirationRequired() == false) {
            return namespaceIndicator + ":" + key;
        }

        String namespaceIndicatorKey = namespaceIndicator + NAMESPACE_NAME_SQUENCE_SEPARATOR;
        long namespaceSquence = memcachedClient.incr(namespaceIndicatorKey, 0L, System.currentTimeMillis(),
                DEFAULT_NAMESPACE_SEQUENCE_EXPIRY_SECONDS);

        return namespaceIndicatorKey + namespaceSquence + ":" + key;
    }
1201277
@Override
	public byte[] decrypt(byte[] data, KeyType keyType) throws CryptoException {
		if (KeyType.PrivateKey != keyType) {
			throw new IllegalArgumentException("Decrypt is only support by private key");
		}
		ckeckKey(keyType);

		lock.lock();
		final SM2Engine engine = getEngine();
		try {
			engine.init(false, getCipherParameters(keyType));
			return engine.processBlock(data, 0, data.length);
		} finally {
			lock.unlock();
		}
	}
48103
public String decrypt(String encrytedText) {
        Objects.requireNonNull(encrytedText, Required.ENCRYPTED_TEXT.toString());
        return decrypt(encrytedText, getSizedSecret(this.config.getApplicationSecret()));
    }
1267441
public function decrement($key, $offset = 1)
    {
        return $this->memcached ? $this->memcached->decrement($key, $offset) : false;
    }
733455
def decr(self, stat, count=1, rate=1):
        """"""
        self.incr(stat, -count, rate)
790416
private function decryptRecipientKey(Object\JWEInterface &$jwe, Object\JWKSetInterface $jwk_set, $i)
    {
        $recipient = $jwe->getRecipient($i);
        $complete_headers = array_merge($jwe->getSharedProtectedHeaders(), $jwe->getSharedHeaders(), $recipient->getHeaders());
        $this->checkCompleteHeader($complete_headers);

        $key_encryption_algorithm = $this->getKeyEncryptionAlgorithm($complete_headers);
        $content_encryption_algorithm = $this->getContentEncryptionAlgorithm($complete_headers);

        foreach ($jwk_set as $jwk) {
            try {
                $this->checkKeyUsage($jwk, 'decryption');
                if ('dir' !== $key_encryption_algorithm->getAlgorithmName()) {
                    $this->checkKeyAlgorithm($jwk, $key_encryption_algorithm->getAlgorithmName());
                } else {
                    $this->checkKeyAlgorithm($jwk, $content_encryption_algorithm->getAlgorithmName());
                }
                $cek = $this->decryptCEK($key_encryption_algorithm, $content_encryption_algorithm, $jwk, $recipient, $complete_headers);
                if (null !== $cek) {
                    if (true === $this->decryptPayload($jwe, $cek, $content_encryption_algorithm, $complete_headers)) {
                        return $i;
                    }
                }
            } catch (\Exception $e) {
                //We do nothing, we continue with other keys
                continue;
            }
        }
    }
436792
def decr(self, member, by=1):
        
        return self._client.zincrby(
            self.key_prefix, self._dumps(member), by * -1)
7729
public static function dec($key, $dec = 1) {
		return self::set ( $key, self::get ( $key, 0 ) - $dec );
	}
1242838
def decr(self, field, by=1):
        
        return self._client.hincrby(self.key_prefix, field, by * -1)
533452
protected String decrypt(String encryptedStr) throws Exception {
        String[] split = encryptedStr.split(":");
        checkTrue(split.length == 3, "Wrong format of the encrypted variable (" + encryptedStr + ")");
        byte[] salt = Base64.getDecoder().decode(split[0].getBytes(UTF8_CHARSET));
        checkTrue(salt.length == saltLengthBytes, "Salt length doesn't match.");
        int iterations = Integer.parseInt(split[1]);
        byte[] encryptedVal = Base64.getDecoder().decode(split[2].getBytes(UTF8_CHARSET));
        return new String(transform(Cipher.DECRYPT_MODE, encryptedVal, salt, iterations), UTF8_CHARSET);
    }
193963
@VisibleForTesting
	BigInteger memcacheSafeGet(final String memcacheKey)
	{
		Preconditions.checkNotNull(memcacheKey);

		BigInteger cachedCounterCount;
		try
		{
			cachedCounterCount = (BigInteger) memcacheService.get(memcacheKey);
		}
		catch (MemcacheServiceException mse)
		{
			// Do nothing. This merely indicates that memcache was unreachable, which is fine. If it's
			// unreachable, there's likely nothing in the cache anyway, but in any case there's nothing we can do here.
			cachedCounterCount = null;
		}
		return cachedCounterCount;
	}
995668
public static void setDnsCache(long expireMillis, String host, String... ips) {
        try {
            InetAddressCacheUtil.setInetAddressCache(host, ips, System.currentTimeMillis() + expireMillis);
        } catch (Exception e) {
            final String message = String.format("Fail to setDnsCache for host %s ip %s expireMillis %s, cause: %s",
                    host, Arrays.toString(ips), expireMillis, e.toString());
            throw new DnsCacheManipulatorException(message, e);
        }
    }
772298
def decrement(self, key, value=1):
        
        return self._memcache.decr(self._prefix + key, value)
53861
def decr(self, key, delta=1):
        
        return uwsgi.cache_dec(key, delta, self.timeout, self.name)
967709
public function decrement($key, $offset = 1)
    {
        $key = $this->_key($key);

        return $this->_Memcached->decrement($key, $offset);
    }
1357621
@SuppressWarnings("unchecked")
  public final <T> T get(final String key, final long timeout, final Transcoder<T> transcoder)
      throws TimeoutException, InterruptedException, MemcachedException {
    return (T) this.get0(key, timeout, CommandType.GET_ONE, transcoder);
  }