A set of nodes that are stored as unavailable.

@return a set of unavailable nodes, never <code>null</code>.
559812
public Set<K> getUnavailableNodes() {
        final Set<K> result = new HashSet<K>();
        for ( final Map.Entry<K, ManagedItem<Boolean>> entry : _map.entrySet() ) {
            if ( !entry.getValue()._value.booleanValue() && !isExpired( entry.getValue() ) ) {
                result.add( entry.getKey() );
            }
        }
        return result;
    }
515079
public Set<String> getAllNodeIDs() {
		HashSet<String> ids = new HashSet<>(nodes.keySet());
		ids.add(nodeID);
		return ids;
	}
1066978
public Map<String, T> getNodes() {
        return Maps.transformValues(Collections.unmodifiableMap(_nodes), input -> (input != null) ? input.orElse(null) : null);
    }
640800
@VisibleForTesting
  Set<String> getToBeDroppedFromNode(
      LookupsState<LookupExtractorFactoryMapContainer> currLookupsStateOnNode,
      Map<String, LookupExtractorFactoryMapContainer> nodeTierLookupsToBe
  )
  {
    Set<String> toDrop = new HashSet<>();

    // {currently loading/loaded on the node} - {currently pending deletion on node} - {lookups node should actually have}
    toDrop.addAll(currLookupsStateOnNode.getCurrent().keySet());
    toDrop.addAll(currLookupsStateOnNode.getToLoad().keySet());
    toDrop = Sets.difference(toDrop, currLookupsStateOnNode.getToDrop());
    toDrop = Sets.difference(toDrop, nodeTierLookupsToBe.keySet());
    return toDrop;
  }
1292887
public Set<SortedSet<T>> allSets() {
        final List<UBNode<T>> allEndOfPathNodes = getAllEndOfPathNodes(this.rootNodes);
        final Set<SortedSet<T>> allSets = new LinkedHashSet<>();
        for (UBNode<T> endOfPathNode : allEndOfPathNodes) {
            allSets.add(endOfPathNode.set());
        }
        return allSets;
    }
32391
public NodeIterator nodeset() throws javax.xml.transform.TransformerException
  {
    return new org.apache.xml.dtm.ref.DTMNodeIterator(iter());
  }
818965
public Node getCurrentNode()
  {

    if (!m_cacheNodes)
      throw new RuntimeException(
        XSLMessages.createXPATHMessage(XPATHErrorResources.ER_NODESET_CANNOT_INDEX, null)); //"This NodeSet can not do indexing or counting functions!");

    int saved = m_next;
    Node n = (m_next < m_firstFree) ? elementAt(m_next) : null;
    m_next = saved; // HACK: I think this is a bit of a hack.  -sb
    return n;
  }
674785
public Set<Map.Entry<String, V>> entrySet()
    {
        Set<Map.Entry<String, V>> entrySet = new TreeSet<Map.Entry<String, V>>();
        StringBuilder sb = new StringBuilder();
        for (BaseNode node : child)
        {
            if (node == null) continue;
            node.walk(new StringBuilder(sb.toString()), entrySet);
        }
        return entrySet;
    }
811567
public NodeIterator nodeset() throws javax.xml.transform.TransformerException
  {
    return (m_origObj instanceof NodeIterator) 
                   ? (NodeIterator)m_origObj : super.nodeset();      
  }
60629
public java.util.List<String> getRestorableNodeTypes() {
        if (restorableNodeTypes == null) {
            restorableNodeTypes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return restorableNodeTypes;
    }
741051
public ArrayList<Pair<String, Integer>> nodes() {
        string_int_pair_vector v = ti.nodes();
        int size = (int) v.size();

        ArrayList<Pair<String, Integer>> l = new ArrayList<>(size);

        for (int i = 0; i < size; i++) {
            string_int_pair p = v.get(i);
            l.add(new Pair<>(p.getFirst(), p.getSecond()));
        }

        return l;
    }
649979
public List<ModelNode> getAllowedValues() {
        if (allowedValues == null) {
            return Collections.emptyList();
        }
        return Arrays.asList(this.allowedValues);
    }
38237
public Collection<String> getParticipantNodes() throws Exception
    {
        return LockInternals.getParticipantNodes(internals.getClient(), basePath, internals.getLockName(), internals.getDriver());
    }
895168
public List<String> getBlacklistedNodes() {
    List<String> ret = new ArrayList<String>();
    for (String nodeName : blacklistedNodes.keySet()) {
      ret.add(nodeName);
    }
    return ret;
  }
54717
public Collection<ConnectionFactory> getConnectionFactories()
   {
      if (connectionFactories == null)
         return Collections.emptyList();
      
      return Collections.unmodifiableCollection(connectionFactories);
   }
1213502
public java.util.List<UnsuccessfulItem> getUnsuccessful() {
        if (unsuccessful == null) {
            unsuccessful = new com.amazonaws.internal.SdkInternalList<UnsuccessfulItem>();
        }
        return unsuccessful;
    }
1247984
public Collection<Xml> getChildren()
    {
        final Collection<Xml> nodes = new ArrayList<>(1);
        final NodeList list = root.getChildNodes();
        for (int i = 0; i < list.getLength(); i++)
        {
            final Node node = list.item(i);
            if (node instanceof Element)
            {
                nodes.add(new Xml(document, (Element) node));
            }
        }
        return nodes;
    }