/*
(non-Javadoc)

@see net.rubyeye.xmemcached.MemcachedClient#gets(java.util.Collection, long)
517321
@SuppressWarnings("unchecked")
  public final <T> Map<String, GetsResponse<T>> gets(final Collection<String> keyCollections,
      final long timeout) throws TimeoutException, InterruptedException, MemcachedException {
    return this.gets(keyCollections, timeout, this.transcoder);
  }
686777
public byte[] get(WmsRequest request) {
        synchronized (this) {
            log.info("cache size=" + cache.size());
            return cache.get(getKey(request));
        }
    }
531883
public static cacheobject[] get(nitro_service service) throws Exception{
		cacheobject obj = new cacheobject();
		cacheobject[] response = (cacheobject[])obj.get_resources(service);
		return response;
	}
1344992
public V get(String key) {
		try {
			BlockingQueue<V> queue = retrieveSharedQueue(key);
			V objToShare = queue.take();
			if (!queue.offer(objToShare)) {
				throw new RuntimeException("Error: Concurrent modification of the broker slot for key '" + key + "'.");
			}
			return objToShare;
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
	}
1038039
@SuppressWarnings("unchecked")
  public final <T> GetsResponse<T> gets(final String key, final Transcoder transcoder)
      throws TimeoutException, InterruptedException, MemcachedException {
    return this.gets(key, this.opTimeout, transcoder);
  }
1016046
@SuppressWarnings("unchecked")
  public final <T> GetsResponse<T> gets(final String key, final long timeout)
      throws TimeoutException, InterruptedException, MemcachedException {
    return this.gets(key, timeout, this.transcoder);
  }
161164
@Override
    public synchronized Object get(Object key) {
        ValueWrapper valueWrapper = (ValueWrapper) super.get(key);
        if (valueWrapper != null) {
            // Check if value has expired
            long creationTime = valueWrapper.getCreationTime();
            long cacheInterval = valueWrapper.getCacheInterval();
            long currentTime = System.currentTimeMillis();
            if (cacheInterval >= 0 && creationTime + cacheInterval < currentTime) {
                remove(key);
                return null;
            }
            return valueWrapper.getValue();
        } else return null;
    }
476627
public final <T> Map<String, T> get(final Collection<String> keyCollections, final long timeout,
      final Transcoder<T> transcoder)
      throws TimeoutException, InterruptedException, MemcachedException {
    return this.getMulti0(keyCollections, timeout, CommandType.GET_MANY, transcoder);
  }
1160561
public String get(final String key, final Function<String, String> mapper) {
        try {
            return cache.get(key, () -> mapper.apply(key));
        } catch (final ExecutionException ex) {
            LOGGER.warn("Error fetching {} from cache: {}", key, ex.getMessage());
            return null;
        }
    }
750302
function getKeys (memcached, cb) {
  var keyArray = []
  var keyLength = 0

  memcached.items().then(function (items) {
    items.forEach(function (item) {
      keyLength += item.data.number

      memcached.cachedump(item.slab_id, item.data.number).then(function (dataSet) {
        dataSet.forEach(function (data) {
          if (data.key) {
            memcached.get(data.key).then(function (val) {
              if (val) {
                keyArray.push(data.key)
              }

              keyLength -= 1

              if (keyLength === 0) {
                cb(null, keyArray)
              }
            })
          }
        })
      })
    })
  }).catch(function (err) {
    cb(err)
  })
}
1322010
@Override
    public T get() throws InterruptedException, ExecutionException {
        // when get returns without an exception the synchronisation is complete
        // and else the exception will be thrown
        if (isInitialized()) {
            synchronisationFuture.get();
        }
        return internalFuture.get();
    }
1128544
@SuppressWarnings("unchecked")
    protected <T> T getFromCache(String cacheName, String key, Class<T> clazz) {
        Object obj = getFromCache(cacheName, key);
        if (obj == null) {
            return null;
        }
        if (clazz.isAssignableFrom(obj.getClass())) {
            return (T) obj;
        }
        return null;
    }
800011
public Object get(long key)
	{
		if (tc.isEntryEnabled()) Tr.entry(tc, "get", new Object[]{new Long(key), this});
		
		int hash = getHashForExistingEntry(key);
		Object value = null;
         
        if (hash >= 0)
        {
            value = _values[hash];
        }
		
		if (tc.isEntryEnabled()) Tr.exit(tc, "get", value);				
		return value;
	}
1315415
public final <T> Map<String, GetsResponse<T>> gets(final Collection<String> keyCollections)
      throws TimeoutException, InterruptedException, MemcachedException {
    return this.gets(keyCollections, this.opTimeout);
  }
1175450
@Override
    @SuppressWarnings("unchecked")
    public V get(Object key) {
        final Element element = this.cache.get((Serializable) key);
        if (element == null) {
            return null;
        }

        return (V) element.getObjectValue();
    }
856539
private Map<String, T> internalGet(long to, TimeUnit unit,
      Collection<Operation> timedoutOps) throws InterruptedException,
      ExecutionException {
    if (!latch.await(to, unit)) {
      for (Operation op : ops) {
        if (op.getState() != OperationState.COMPLETE) {
          MemcachedConnection.opTimedOut(op);
          timedoutOps.add(op);
        } else {
          MemcachedConnection.opSucceeded(op);
        }
      }
    }
    for (Operation op : ops) {
      if (op.isCancelled()) {
        throw new ExecutionException(new CancellationException("Cancelled"));
      }
      if (op.hasErrored()) {
        throw new ExecutionException(op.getException());
      }
    }
    Map<String, T> m = new HashMap<String, T>();
    for (Map.Entry<String, Future<T>> me : rvMap.entrySet()) {
      m.put(me.getKey(), me.getValue().get());
    }
    return m;
  }
592250
@Override
	public Object get(final Object key) {
		final boolean useLocalPrefixes = !mixDefaultAndLocalPrefixes && hasLocalPrefixConfigurations();
		return get(key, useLocalPrefixes);
	}