org.dd4t.caching.CacheElement.setExpired java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 SimpleDateFormat s =String pattern;new SimpleDateFormat(pattern)
String template;Locale locale;new SimpleDateFormat(template, locale)
new SimpleDateFormat()
Smart code suggestions by Codota
}

private void setNotExpired(Element dependentElement) {
  if (dependentElement == null) {
    return;
  }
  CacheElement cacheElement = (CacheElement) dependentElement.getObjectValue();
  if (cacheElement.isExpired()) {
    cacheElement.setExpired(false);
    updateTTL(dependentElement);
  }
}

private static boolean validInCache(final CacheElement<String> cacheElement) {
  if (cacheElement.isExpired()) {
    //noinspection SynchronizationOnLocalVariableOrMethodParameter
    synchronized (cacheElement) {
      if (cacheElement.isExpired()) {
        cacheElement.setExpired(false);
        return false;
      }
    }
  }
  return true;
}

public void setExpired(Element element, int adjustTTL) {
  if (!isEnabled()) {
    return;
  }
  if (element == null) {
    return;
  }
  if (element.getObjectValue() instanceof CacheElement) {
    CacheElement cacheElement = (CacheElement) element.getObjectValue();
    if (!cacheElement.isExpired()) {
      cacheElement.setExpired(true);
      expireElement(element, adjustTTL);
    }
  } else {
    expireElement(element, adjustTTL);
  }
}

/**
 * Store given item in the cache with a simple time-to-live property.
 *
 * @param key          String representing the key to store the payload under
 * @param cacheElement CacheElement a wrapper around the actual value to store in
 *                     cache
 */
@Override
public <T> void storeInItemCache(String key, CacheElement<T> cacheElement) {
  if (!isEnabled()) {
    return;
  }
  if (!cacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  // detect undeclared nulls, complain, and set to null
  if (!cacheElement.isNull() && cacheElement.getPayload() == null) {
    Exception exToLogToHaveStacktraceWhoCausedIt = new Exception();
    LOG.error("Detected undeclared null payload on element with key " + key + " at insert time!",
        exToLogToHaveStacktraceWhoCausedIt);
    cacheElement.setNull(true);
  }
  cacheElement.setExpired(false);
  storeElement(key, cacheElement);
}

  cacheElement.setPayload(publicationMeta);
  cacheProvider.storeInItemCache(key, cacheElement);
  cacheElement.setExpired(false);
  LOG.debug("Stored Publication Meta with key: {} in cache", key);
} else {

  cacheElement.setExpired(false);
  LOG.debug("Stored Publication Id with key: {} in cache", key);
} else {

  cacheElement.setPayload(publicationMeta);
  cacheProvider.storeInItemCache(key, cacheElement);
  cacheElement.setExpired(false);
  LOG.debug("Stored Publication Meta with key: {} in cache", key);
} else {

  cacheElement.setPayload(result);
  cacheProvider.storeInItemCache(key, cacheElement);
  cacheElement.setExpired(false);
  LOG.debug("Publication Id for URL: {}, is {}", url, result);
} else {

  cacheElement.setExpired(false);
  LOG.debug("Stored Publication Id with key: {} in cache", key);
} else {

  cacheElement.setPayload(result);
  cacheProvider.storeInItemCache(key, cacheElement);
  cacheElement.setExpired(false);
  LOG.debug("Stored Publication Id with key: {} in cache", key);
} else {

  cacheElement.setPayload(null);
  cacheProvider.storeInItemCache(cacheKey, cacheElement);
  cacheElement.setExpired(true);
  throw new ItemNotFoundException("XML Page with url: " + url + " not found.");
cacheElement.setExpired(false);

    cacheElement.setPayload(null);
    cacheProvider.storeInItemCache(cacheKey, cacheElement);
    cacheElement.setExpired(true);
    throw new ItemNotFoundException("Unable to find page by id " + tcmId);
  cacheElement.setExpired(false);
} else {
  LOG.debug("Return a page with uri: {} from cache", tcmId);

@Override
public <T> void storeInItemCache(String key, CacheElement<T> cacheElement, List<CacheDependency> dependencies) {
  if (!isEnabled()) {
    return;
  }
  if (!cacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  // detect undeclared nulls, complain, and set to null
  if (!cacheElement.isNull() && cacheElement.getPayload() == null) {
    Exception exToLogToHaveStacktraceWhoCausedIt = new Exception();
    LOG.error("Detected undeclared null payload on element with key " + key + " at insert time!",
        exToLogToHaveStacktraceWhoCausedIt);
    cacheElement.setNull(true);
  }
  cacheElement.setExpired(false);
  Element element = cache.get(key);
  if (element == null) {
    element = new Element(key, cacheElement);
  }
  cache.put(element);
  element.setTimeToLive(cacheDependencyTTL);
  for (CacheDependency dep : dependencies) {
    String dependentKey = getKey(dep.getPublicationId(), dep.getItemId());
    cacheElement.setDependentKey(dependentKey);
    addDependency(key, dependentKey);
    updateTTL(dependencyCache.get(dependentKey));
  }
}

@Override
public <T> void storeInItemCache(final String key, final CacheElement<T> cacheElement, final
List<CacheDependency> dependencies) {
  if (!isEnabled()) {
    return;
  }
  if (!cacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  // detect undeclared nulls, complain, and set to null
  if (!cacheElement.isNull() && cacheElement.getPayload() == null) {
    Exception exToLogToHaveStacktraceWhoCausedIt = new Exception();
    LOG.error("Detected undeclared null payload on element with key " + key + " at insert time!",
        exToLogToHaveStacktraceWhoCausedIt);
    cacheElement.setNull(true);
    cacheElement.setExpired(true);
  }
  cacheElement.setExpired(false);
  if (cache.containsKey(key)) {
    cache.replace(key, cacheElement);
  } else {
    cache.put(key, cacheElement);
  }
  for (CacheDependency dep : dependencies) {
    String dependentKey = getKey(dep.getPublicationId(), dep.getItemId());
    cacheElement.setDependentKey(dependentKey);
    addDependency(key, dependentKey);
  }
}

  cacheProvider.storeInItemCache(key, cacheElement, tcmuri.getPublicationId(), tcmuri.getItemId
      ());
  cacheElement.setExpired(false);
} else {
  result = 0;
  cacheElement.setPayload(result);
  cacheProvider.storeInItemCache(key, cacheElement);
  cacheElement.setExpired(false);

@Override
public void addDependency(final String cacheKey, final String dependencyKey) {
  if (!isEnabled()) {
    return;
  }
  if (!dependencyCacheExists()) {
    LOG.error("Cache configuration is invalid! NOT Caching. Check EH Cache configuration.");
    return;
  }
  LOG.debug("Add dependency from key: {} to key: {}", dependencyKey, cacheKey);
  if (dependencyCache.containsKey(dependencyKey)) {
    CacheElement<ConcurrentSkipListSet<String>> dependencyElement = dependencyCache.get(dependencyKey);
    if (dependencyElement != null && dependencyElement.getPayload() != null) {
      ConcurrentSkipListSet<String> cacheSet = dependencyElement.getPayload();
      if (!cacheSet.contains(cacheKey)) {
        LOG.info("Adding cachekey: {} to dependent key: {}", cacheKey, dependencyKey);
        cacheSet.add(cacheKey);
      }
      dependencyElement.setExpired(false);
      dependencyCache.replace(dependencyKey, dependencyElement);
    } else {
      addNewDependencyCacheElement(cacheKey, dependencyKey);
    }
  } else {
    addNewDependencyCacheElement(cacheKey, dependencyKey);
  }
  LOG.info("Added or replaced cache element with dependency key: {} and dependent key: {}", dependencyKey,
      cacheKey);
}

  cacheElement.setPayload(null);
  cacheProvider.storeInItemCache(cacheKey, cacheElement);
  cacheElement.setExpired(true);
  throw new ItemNotFoundException("Page with url: " + url + " not found.");
cacheProvider.storeInItemCache(cacheKey, cacheElement, resultItem.getPublicationId(), resultItem
    .getItemId());
cacheElement.setExpired(false);

  cacheProvider.storeInItemCache(tcmUri, cacheElement, binaryURI.getPublicationId(), binaryURI
      .getItemId());
  cacheElement.setExpired(false);
  LOG.debug("Added binary with uri: {} to cache", tcmUri);
} catch (ParseException e) {
  cacheElement.setPayload(null);
  cacheProvider.storeInItemCache(tcmUri, cacheElement);
  cacheElement.setExpired(true);
  throw new ItemNotFoundException(e);

  cacheProvider.storeInItemCache(key, cacheElement, tcmUri.getPublicationId(), tcmUri.getItemId
      ());
  cacheElement.setExpired(false);
  LOG.debug("Added binary with url: {} to cache", url);
} catch (ParseException e) {

  cacheProvider.storeInItemCache(key, cacheElement, tcmuri.getPublicationId(), tcmuri
      .getItemId());
  cacheElement.setExpired(false);
} else {
  result = 0;
  cacheElement.setPayload(result);
  cacheProvider.storeInItemCache(key, cacheElement);
  cacheElement.setExpired(false);

Popular methods of CacheElement

Popular in Java

Reading from database using SQL prepared statement
getSystemService (Context)
setRequestProperty (URLConnection)
Sets the general request property. If a property with the key already exists, overwrite its value wi
notifyDataSetChanged (ArrayAdapter)
Container (java.awt)
A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
BufferedImage (java.awt.image)
The BufferedImage subclass describes an java.awt.Image with an accessible buffer of image data. All
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
TreeMap (java.util)
A Red-Black tree based NavigableMap implementation. The map is sorted according to the Comparable of
Collectors (java.util.stream)
Cipher (javax.crypto)
This class provides access to implementations of cryptographic ciphers for encryption and decryption

How to use setExpiredmethodin org.dd4t.caching.CacheElement

Best Java code snippets using org.dd4t.caching.CacheElement.setExpired (Showing top 20 results out of 315)

How to use
setExpired
method
in
org.dd4t.caching.CacheElement