Java Code Examples for java.util.Collections.enumeration()

protected void cleanChildren() {
	if (childrenSteps != null) {
		//Enumeration e = childrenSteps.elements();
		Enumeration<String> e = Collections.enumeration(childrenSteps.keySet());
		while (e.hasMoreElements()) {
			String timeID = (String)e.nextElement();
			if (timeID != null) {
				Long stepPriority = null;
				Step step = sequence.getCopy(timeID);
				if (step != null) {
					stepPriority = new Long(step.priority);
					step.cleanCopy();
				}
				sequence.removeCopy(timeID, stepPriority);
			}
		}
		childrenSteps.clear();
	}
}
 

/**
 * Gets the current contents of this byte stream as a Input Stream. The
 * returned stream is backed by buffers of <code>this</code> stream,
 * avoiding memory allocation and copy, thus saving space and time.<br>
 * 
 * @return the current contents of this output stream.
 * @see java.io.ByteArrayOutputStream#toByteArray()
 * @see #reset()
 * @since 2.0
 */
private InputStream toBufferedInputStream() {
    int remaining = count;
    if (remaining == 0) {
        return new ClosedInputStream();
    }
    List<ByteArrayInputStream> list = new ArrayList<ByteArrayInputStream>(buffers.size());
    for (byte[] buf : buffers) {
        int c = Math.min(buf.length, remaining);
        list.add(new ByteArrayInputStream(buf, 0, c));
        remaining -= c;
        if (remaining == 0) {
            break;
        }
    }
    return new SequenceInputStream(Collections.enumeration(list));
}
 

/**
 * Return an enumeration of prefixes declared in this context.
 *
 * @return An enumeration of prefixes (possibly empty).
 * @see org.xml.sax.helpers.NamespaceSupport#getDeclaredPrefixes
 */
Enumeration getDeclaredPrefixes ()
{
    if (declarations == null) {
        return EMPTY_ENUMERATION;
    } else {
        return Collections.enumeration(declarations);
    }
}
 

public InputStream getInputStream() throws IOException
{
  List<InputStream> inputSteamList = new ArrayList<InputStream>(_uploadedFileChunkList.size());
  for (UploadedFile uploadedFileChunk : _uploadedFileChunkList)
    inputSteamList.add(uploadedFileChunk.getInputStream());
  
  return new SequenceInputStream(Collections.enumeration(inputSteamList));
}
 

private static SequenceInputStream maakLogischBestand(final List<Path> paths) {
    final List<InputStream> inputStreamList = Lists.newArrayList();
    for (Path path : paths) {
        try {
            final FileInputStream fileInputStream = new FileInputStream(path.toFile());
            inputStreamList.add(fileInputStream);
        } catch (FileNotFoundException e) {
            inputStreamList.forEach(IOUtils::closeQuietly);
            throw new IllegalStateException(e);

        }
    }
    return new SequenceInputStream(Collections.enumeration(inputStreamList));
}
 

@Override
public Enumeration enabled(GrammarEnvironment ctx) {
    // check if is supported environment..
    if (getGrammar(ctx) != null) {
        Enumeration en = ctx.getDocumentChildren();
        while (en.hasMoreElements()) {
            Node next = (Node)en.nextElement();
            if (next.getNodeType() == Node.ELEMENT_NODE) {
                return Collections.enumeration(Collections.singletonList(next));
            }
        }
    }
    return null;
}
 

@SuppressWarnings("unchecked")
@Override
public Enumeration<String> getAttributeNames() {
	Set<String> names = new HashSet<String>();
	names.addAll(attributes.keySet());

	return new MultiEnumeration<String>(
			new Enumeration[] { super.getAttributeNames(), Collections.enumeration(names) });
}
 

@Override
public Enumeration<String> getKeys() {
    return Collections.enumeration(keySet());
}
 

private static Enumeration<String> buildHeaderAccept() {
	return Collections.enumeration(Arrays.asList("application/json"));
}
 

@Override
public Enumeration<String> getKeys() {
    return Collections.enumeration(keySet());
}
 

public Enumeration<String> getAttributeNames() {
    return Collections.enumeration(keys());
}
 

public void run() {
	Display display = Display.getDefault();
	Cursor waitCursor = new Cursor(display, SWT.CURSOR_WAIT);		
	
	Shell shell = getParentShell();
	shell.setCursor(waitCursor);
	
       try {
       	treeNodesToUpdate = new ArrayList<TreeParent>();
       	
   		ProjectExplorerView explorerView = getProjectExplorerView();
   		if (explorerView != null) {
   			TreeObject[] treeObjects = explorerView.getSelectedTreeObjects();
   			String[] selectedPaths = new String[treeObjects.length];
   			if (treeObjects != null) {
   				// Increase priority
   				TreeObject treeObject = null;
   				for (int i = 0 ; i < treeObjects.length ; i++) {
   					treeObject = treeObjects[i];
   					selectedPaths[i] = treeObject.getPath();
  						increasePriority(treeObject);
   				}
   				
   				// Updating the tree and the properties panel
   				Enumeration<TreeParent> enumeration = Collections.enumeration(treeNodesToUpdate);
   				TreeParent parentTreeObject = null;
   				while (enumeration.hasMoreElements()) {
   					parentTreeObject = enumeration.nextElement();
   					explorerView.reloadTreeObject(parentTreeObject);
   				}
   				
   				// Restore selection
   	    		TreeObjectEvent treeObjectEvent;
   	        	for (int i=0; i<selectedPaths.length; i++) {
   	        		String previousPath = selectedPaths[i];
   	        		treeObject = explorerView.findTreeObjectByPath(parentTreeObject, previousPath);
   	        		if (treeObject != null) {
   	        			treeObjects[i] = treeObject;
   		                treeObjectEvent = new TreeObjectEvent(treeObject);
   		                explorerView.fireTreeObjectPropertyChanged(treeObjectEvent);
   	        		}
   	        	}
   				explorerView.setSelectedTreeObjects(treeObjects);
   			}
   		}
       }
       catch (Throwable e) {
       	ConvertigoPlugin.logException(e, "Unable to increase priority!");
       }
       finally {
		shell.setCursor(null);
		waitCursor.dispose();
       }
}
 

@Override
public Enumeration<String> getInitParameterNames() {
    return Collections.enumeration(initParameters.keySet());
}
 

/**
 * @return all build components that are an instance of the given class
 * @deprecated Use {@link #getComponentsOf(Class<T>)} instead.
 */
@Deprecated
public <T> Enumeration<T> getComponents(Class<T> target) {
  return Collections.enumeration(getComponentsOf(target));
}
 

/**
 * @return an Enumeration of all {@link Board}s on the map
 * @deprecated Use {@link #getBoards()} instead.
 */
@Deprecated
public Enumeration<Board> getAllBoards() {
  return Collections.enumeration(boards);
}
 

protected Enumeration<? extends DataLoader> loaders() {
    return Collections.enumeration(result.allInstances());
}
 

@Override
public Enumeration<?> getAttributeNames() {
    return Collections.enumeration(getAllKeys());
}
 

@Override
public Enumeration<Locale> getLocales() {
	return Collections.enumeration(Arrays.asList(getLocale()));
}
 

/** {@inheritDoc} */
@Override
public Enumeration<String> engineAliases() {
    return Collections.enumeration(this.aliases);
}
 

/**
 * <p>
 * Enumerates the attribute names.
 * </p>
 * 
 * @return An instance of {@link Enumeration}.
 */
public Enumeration<String> attributeNames() {
    // Create a new list, so that the references are copied
    return Collections.enumeration(new LinkedList<String>(values.keySet()));
}