Returns the <code>expiration-cache</code> element
@return the node defined for the element <code>expiration-cache</code>
13211
public Integer getExpirationCache()
   {
      if (childNode.getTextValueForPatternName("expiration-cache") != null && !childNode.getTextValueForPatternName("expiration-cache").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("expiration-cache"));
      }
      return null;
   }
198540
public long expire(long time) {
    for (int logSize = (Long.SIZE - 1) - numberOfLeadingZeros(last); logSize >= 0; logSize--) {
      boolean live = false;
      for (int i = min_l(logSize); i < max_l(logSize); i++) {
        long end = boxes[i];
        if (end != MIN_VALUE) {
          if ((time - end) >= window) {
            total -= 1L << logSize;
            boxes[i] = MIN_VALUE;
          } else {
            live = true;
          }
        }
      }
      if (live) {
        last = 1L << logSize;
        return count();
      }
    }
    last = 0;
    return 0;
  }
1266002
public <T extends Memory> T getNodeMemory(MemoryFactory<T> node) {
        return nodeMemories.getNodeMemory( node, this );
    }
1217067
protected final Segment getSegment( NodeCache cache,
                                        CachedNode parent ) {
        if (parent != null) {
            ChildReference ref = parent.getChildReferences(cache).getChild(key);
            if (ref == null) {
                // This node doesn't exist in the parent
                throw new NodeNotFoundInParentException(key, parent.getKey());
            }
            return ref.getSegment();
        }
        // This is the root node ...
        return workspace(cache).childReferenceForRoot().getSegment();
    }
455063
@SuppressWarnings("ShortCircuitBoolean")
  boolean hasExpired(Node<K, V> node, long now) {
    return (expiresAfterAccess() && (now - node.getAccessTime() >= expiresAfterAccessNanos()))
        | (expiresAfterWrite() && (now - node.getWriteTime() >= expiresAfterWriteNanos()))
        | (expiresVariable() && (now - node.getVariableTime() >= 0));
  }
1067082
public java.util.List<CacheNodeTypeSpecificValue> getCacheNodeTypeSpecificValues() {
        if (cacheNodeTypeSpecificValues == null) {
            cacheNodeTypeSpecificValues = new com.amazonaws.internal.SdkInternalList<CacheNodeTypeSpecificValue>();
        }
        return cacheNodeTypeSpecificValues;
    }
652636
protected final CachedNode node() throws ItemNotFoundException, InvalidItemStateException {
        CachedNode node = sessionCache().getNode(key);
        if (node == null) {
            if (sessionCache().isDestroyed(key)) {
                throw new InvalidItemStateException("The node with key " + key + " has been removed in this session.");
            }
            throw new ItemNotFoundException("The node with key " + key + " no longer exists.");
        }
        return node;
    }
514142
@Nonnull
  public ExpressionTreeElement getRoot() {
    if (last.isEmptySlot()) {
      return this.last;
    } else {
      ExpressionTreeElement element = last;
      while (!Thread.currentThread().isInterrupted()) {
        final ExpressionTreeElement next = element.getParent();
        if (next == null) {
          return element;
        } else {
          element = next;
        }
      }
    }
    return ExpressionTreeElement.EMPTY_SLOT;
  }
594966
public INode getLastCompleteNodeByOffset(INode node, int offsetPosition, int completionOffset) {
		return internalGetLastCompleteNodeByOffset(node.getRootNode(), offsetPosition);
	}
596171
public T get() {
    long expiration = whenItExpires;
    long now = System.nanoTime();

    // if uninitialized or expired update value
    if (expiration == 0 || now >= expiration) {
      synchronized (this) {
        // ensure a different thread didn't update it
        if (whenItExpires == expiration) {
          whenItExpires = now + durationNanos;
          try {
            value = getter.call();
          } catch (Exception e) {
            // shouldn't happen
            throw Throwables.propagate(e);
          }
        }
      }
    }
    return value;
  }
488445
@SuppressWarnings("unchecked")
    public synchronized ValT get(Object elementKey) {
        KeyT key = (KeyT) elementKey;
        ValT value = cache.get(key);
        if (value != null) {
            // memory hit
            Log.d(name, "MEM cache hit for " + key.toString());
            return value;
        }

        // memory miss, try reading from disk
        File file = getFileForKey(key);
        if (file.exists()) {
        	// if file older than expirationInMinutes, remove it
        	long lastModified = file.lastModified();
        	Date now = new Date();
        	long ageInMinutes = ((now.getTime() - lastModified) / (1000*60));
        	
        	if (ageInMinutes >= expirationInMinutes) {
        		Log.d(name, "DISK cache expiration for file " + file.toString());
        		file.delete();
        		return null;
        	}
        	
        	// disk hit
            Log.d(name, "DISK cache hit for " + key.toString());
            try {
                value = readValueFromDisk(file);
            } catch (IOException e) {
                // treat decoding errors as a cache miss
                e.printStackTrace();
                return null;
            }
            if (value == null) {
                return null;
            }
            cache.put(key, value);
            return value;
        }

        // cache miss
        return null;
    }
266528
protected final Date getExpirationDate() {
        if (sessionTracker != null) {
            Session currentSession = sessionTracker.getOpenSession();
            return (currentSession != null) ? currentSession.getExpirationDate() : null;
        }
        return null;
    }
429456
@SuppressWarnings("unchecked")
	public int expurge() {
		// clear out ref queue.
		while (this.queue.poll() != null) {
			this.enquedElement = true;
		}

		int j;

		if (this.enquedElement) {
			// Clear the table
			Reference<? extends T> ref;
			j = 0;
			for (int i = 0; i < this.size; ++i) {
				ref = (Reference<T>) this.data[i];
				if ((ref == null) || (ref.isEnqueued()) || (ref.get() == null)) {
					if (ref != null) {
						ref.clear();
					}
					this.data[i] = null;
				} else {
					if (i != j) {
						this.data[j] = this.data[i];
						this.data[i] = null;
					}
					j++;
				}
			}
			this.enquedElement = false;
		} else {
			j = this.size;
		}

		// Allocation of array may have caused GC, which may have caused
		// additional entries to go stale.  Removing these entries from the
		// reference queue will make them eligible for reclamation.
		while (this.queue.poll() != null) {
			this.enquedElement = true;
		}

		final int oldSize = this.size;
		this.size = j;

		if (j < oldSize) {
			fireReferenceRelease(oldSize - j);
		}

		return this.size;
	}
624161
public Node root() {
        Node node = this;
        while (node.parentNode != null)
            node = node.parentNode;
        return node;
    }
825627
public OMVRBTreeEntry<K, V> getFirstInMemory() {
    OMVRBTreeEntry<K, V> node = this;
    OMVRBTreeEntry<K, V> prev = this;

    while (node != null) {
      prev = node;
      node = node.getPreviousInMemory();
    }

    return prev;
  }
1191684
public Node getDOM()
    {
        Object root = m_message.getRawData();
        try {
            String strSOAPPackage = (String)((TrxMessageHeader)this.getMessage().getMessageHeader()).get(SOAPMessageTransport.SOAP_PACKAGE);

            Node node = null;            
            DocumentBuilder db = Util.getDocumentBuilder();
            Document doc = db.newDocument();            
            
            Marshaller m = JaxbContexts.getJAXBContexts().getMarshaller(strSOAPPackage);
            if (m == null)
                return null;
            synchronized(m)
            {   // Since the marshaller is shared (may want to tweek this for multi-cpu implementations)
                m.marshal( root, doc );
            }
            node = doc.getDocumentElement();

            if (node != null)
                return node;
        } catch (JAXBException ex)   {
            ex.printStackTrace();
        } catch (java.lang.IllegalArgumentException ex)   {
            ex.printStackTrace();
        }
        return super.getDOM();
    }
1310602
public Date getExpirationDateTime() {
        if (getExpirationDate() == null) {
            return null;
        }

        Calendar cal = Calendar.getInstance();
        cal.setTime(getExpirationDate());
        cal.set(Calendar.HOUR, getExpirationHour());
        cal.set(Calendar.MINUTE, getExpirationMinute());
        cal.set(Calendar.SECOND, 0);
        cal.set(Calendar.MILLISECOND, 0);
        cal.set(Calendar.AM_PM, getExpirationAmPm());
        return cal.getTime();
    }