Java Code Examples for java.util.LinkedList#toArray()

public static Variable[] getVariablesFilteredInclusive(DataBean dataBean, String startsWith, boolean removeStart) {
	String exprHeader = "/column/";

	LinkedList<Variable> vars = new LinkedList<Variable>();
	try (Table columns = dataBean.queryFeatures("/column/*").asTable()) {

		for (String columnName : columns.getColumnNames()) {
			if (columnName.startsWith(startsWith)) {
				String chipName;

				if (removeStart) {
					chipName = columnName.substring(startsWith.length());
				} else {
					chipName = columnName;
				}

				String expression = exprHeader + columnName;
				vars.add(new Variable(chipName, expression));
			}
		}

	} catch (MicroarrayException e) {
		application.reportException(new MicroarrayException("no chips to visualise"));
	}
	return vars.toArray(new Variable[0]);
}
 

public static ZipEntry[] listEntries(File zip, String classification) throws IOException
{
    if ( !zip.exists() ) {
        return new ZipEntry[0];
    }
    LinkedList<ZipEntry> result = new LinkedList<>();
    ZipFile originalZip = new ZipFile(zip);
    Enumeration<? extends ZipEntry> entries = originalZip.entries();
    while (entries.hasMoreElements()) {
        ZipEntry e = entries.nextElement();
        if ( e.isDirectory() ) {
            continue;
        }
        if ( classification==null ){
            result.add(e);
            continue;
        }
        String entryName = e.getName();
        if ( entryName.indexOf(classification)>0 ) {
            result.add(e);
        }
    }
    originalZip.close();
    return result.toArray(new ZipEntry[result.size()]);
}
 

/**
 * Normalize flat files, Git treats folder as normal file
 * so it's necessary explicitly list direct descendants to
 * get classical flat behaviour.
 * <strong>Does not return up-to-date files</strong>
 *
 * <p> E.g. revert on package node means:
 * <ul>
 *   <li>revert package folder properties AND
 *   <li>revert all modified (including deleted) files in the folder
 * </ul>
 *
 * @return files with given status and direct descendants with given status.
 */

public static File[] flatten(File[] files, Set<Status> statuses) {
    LinkedList<File> ret = new LinkedList<File>();

    FileStatusCache cache = Git.getInstance().getFileStatusCache();
    for (int i = 0; i<files.length; i++) {
        File dir = files[i];
        FileInformation info = cache.getStatus(dir);
        if (info.containsStatus(statuses)) {
            ret.add(dir);
        }
        File[] entries = cache.listFiles(dir);  // comparing to dir.listFiles() lists already deleted too
        for (int e = 0; e<entries.length; e++) {
            File entry = entries[e];
            info = cache.getStatus(entry);
            if (info.containsStatus(statuses)) {
                ret.add(entry);
            }
        }
    }

    return ret.toArray(new File[ret.size()]);
}
 

@SuppressWarnings("unchecked")
@Override
public void restoreFromBundle( Bundle bundle ) {
	pos = bundle.getInt( POS );
	seen = bundle.getBoolean( SEEN );
	type = Type.valueOf( bundle.getString( TYPE ) );
	items = new LinkedList( bundle.getCollection( ITEMS ) );
	items.removeAll(Collections.singleton(null));
	
	//remove any document pages that either don't exist anymore or that the player already has
	for (Item item : items.toArray(new Item[0])){
		if (item instanceof DocumentPage
				&& ( !((DocumentPage) item).document().pages().contains(((DocumentPage) item).page())
				||    ((DocumentPage) item).document().hasPage(((DocumentPage) item).page()))){
			items.remove(item);
		}
	}
	
	haunted = bundle.getBoolean( HAUNTED );
	
}
 

@Override
protected Portal[] getPortals() {
	Random rr = new Random(32324524);
	int n = getNumberOfPortalsExcludingAnchor();
	LinkedList<Portal> pp = new LinkedList<>();
	double p1X = 200;
	double p1Y = -400;
	double p2X = -500;
	double p2Y = 200;
	double p3X = 600;
	double p3Y = 300;
	pp.add(new Portal(p1X,p1Y, Faction.ENL.getColor()));
	pp.add(new Portal(p2X,p2Y, Color.GRAY));
	pp.add(new Portal(p3X,p3Y, Color.GRAY));
	for (int i=3; i<=n; i++) {
		double theta = Math.PI/2*(i-2)/(n-1)+rr.nextGaussian()*0.02*Math.PI/2/n;
		double r = rr.nextDouble()*0.7+0.2;
		double a= r*Math.cos(theta);
		double b= r*Math.sin(theta);
		double x = p1X + (p2X-p1X)*a + (p3X-p1X)*b;
		double y = p1Y + (p2Y-p1Y)*a + (p3Y-p1Y)*b;
		pp.add(new Portal(x, y, Color.GRAY));
	}
	return pp.toArray(new Portal[0]);
}
 

/**
* @generated
*/
protected ISchedulingRule getSynchronizeRule(Object element) {
	ResourceSetInfo info = getResourceSetInfo(element);
	if (info != null) {
		LinkedList<ISchedulingRule> rules = new LinkedList<ISchedulingRule>();
		for (Iterator<Resource> it = info.getLoadedResourcesIterator(); it.hasNext();) {
			Resource nextResource = it.next();
			IFile file = WorkspaceSynchronizer.getFile(nextResource);
			if (file != null) {
				rules.add(ResourcesPlugin.getWorkspace().getRuleFactory().refreshRule(file));
			}
		}
		return new MultiRule((ISchedulingRule[]) rules.toArray(new ISchedulingRule[rules.size()]));
	}
	return null;
}
 

/**
 * Retrieves an array of spell chain elements ordered by their occurrence in the chain,
 * which implement at least one override.
 *
 * @param spellRing the head element of the spell chain.
 * @return the array containing all elements having an override.
 */
private static SpellRing[] getSequenceFromSpellChain(SpellRing spellRing) {
	SpellRing cur = spellRing;
	LinkedList<SpellRing> instances = new LinkedList<>();
	while (cur != null) {
		ModuleInstance module = cur.getModule();
		if (module == null) continue;

		if (module.getFactory().hasOverrides()) {
			instances.add(cur);
		}
		cur = cur.getChildRing();
	}

	return instances.toArray(new SpellRing[instances.size()]);
}
 

/**
 * Validates objects using Hibernate Validator.
 * @param content an object to be validated
 * @return a list of error messages or empty if object is valid
 */
public static String[] validateObject(ParaObject content) {
	if (content == null) {
		return new String[]{"Object cannot be null."};
	}
	LinkedList<String> list = new LinkedList<>();
	try {
		for (ConstraintViolation<ParaObject> constraintViolation : getValidator().validate(content)) {
			String prop = "'".concat(constraintViolation.getPropertyPath().toString()).concat("'");
			list.add(prop.concat(" ").concat(constraintViolation.getMessage()));
		}
	} catch (Exception e) {
		logger.error(null, e);
	}
	return list.toArray(new String[]{});
}
 

public DataBean[] getSelectedDatasAsArray() {
    LinkedList<DataBean> beans = new LinkedList<DataBean>();
	for (DataBean bean : getSelectedDataBeans()) {
		beans.add(bean);
	}
	return beans.toArray(new DataBean[0]);    	
}
 

public static Element[] getChildrenByName(Element e, String name) {
	NodeList nl = e.getChildNodes();
	int max = nl.getLength();
	LinkedList list = new LinkedList();
	for (int i = 0; i < max; i++) {
		Node n = nl.item(i);
		if (n.getNodeType() == Node.ELEMENT_NODE
				&& n.getNodeName().equals(name)) {
			list.add(n);
		}
	}
	return (Element[]) list.toArray(new Element[list.size()]);
}
 

/**
 * toArray(null) throws NullPointerException
 */
public void testToArray_NullArg() {
    LinkedList l = new LinkedList();
    l.add(new Object());
    try {
        l.toArray(null);
        shouldThrow();
    } catch (NullPointerException success) {}
}
 

public static synchronized String[] getNames() {
    if (names == null) {
        LinkedList<String> list = new LinkedList<String>();
        InputStream str
            = PlatformClasses.class
                .getResourceAsStream("/com/sun/tools/hat/resources/platform_names.txt");
        if (str != null) {
            try {
                BufferedReader rdr
                    = new BufferedReader(new InputStreamReader(str));
                for (;;) {
                    String s = rdr.readLine();
                    if (s == null) {
                        break;
                    } else if (s.length() > 0) {
                        list.add(s);
                    }
                }
                rdr.close();
                str.close();
            } catch (IOException ex) {
                ex.printStackTrace();
                // Shouldn't happen, and if it does, continuing
                // is the right thing to do anyway.
            }
        }
        names = list.toArray(new String[list.size()]);
    }
    return names;
}
 

/**
 * Pads two strings before comparing them.
 * @param s1 an array of words (an automatically tokenized sentence) 
 * @param s2 an array of words (a manually tokenized sentence)
 * @return
 */
private static String[][] padStrings(String[] s1, String[] s2) {
	String[][] result = new String[2][];
	
	LinkedList<String> l1 = new LinkedList<String>(Arrays.asList(s1));
	LinkedList<String> l2 = new LinkedList<String>(Arrays.asList(s2));
	int i1 = 0;
	int i2 = 0;
	while (i1 < l1.size() && i2 < l2.size()) {
		String e1 = l1.get(i1);
		String[] a1 = e1.split("_");
		
		String e2 = l2.get(i2);
		String[] a2 = e2.split("_");
		
		if (a1.length >= a2.length) {
			for (int j = 0; j < a1.length - a2.length; j++) {
				l1.add(i1+1, PADDING_STRING_1);
			}
		} else {
			for (int j = 0; j < a2.length - a1.length; j++) {
				l2.add(i2+1, PADDING_STRING_2);
			}
		}
		i1++;
		i2++;
	}
	
	if (l1.size() != l2.size()) {
		System.err.println("Error: After padding, two lists must be equal in size!");
		System.err.println(l1);
		System.err.println(l2);
	}
	result[0] = l1.toArray(new String[l1.size()]); 
	result[1] = l2.toArray(new String[l2.size()]);	
		
	return result;
}
 

static ColorStateList inflateColorStateList(Context context, XmlPullParser parser, AttributeSet attrs) throws IOException, XmlPullParserException {
    final int innerDepth = parser.getDepth() + 1;
    int depth;
    int type;

    LinkedList<int[]> stateList = new LinkedList<>();
    LinkedList<Integer> colorList = new LinkedList<>();

    while ((type = parser.next()) != XmlPullParser.END_DOCUMENT && ((depth = parser.getDepth()) >= innerDepth || type != XmlPullParser.END_TAG)) {
        if (type != XmlPullParser.START_TAG || depth > innerDepth || !parser.getName().equals("item")) {
            continue;
        }

        TypedArray a1 = context.obtainStyledAttributes(attrs, new int[]{android.R.attr.color});
        final int value = a1.getResourceId(0, Color.MAGENTA);
        final int baseColor = value == Color.MAGENTA ? Color.MAGENTA : ThemeUtils.replaceColorById(context, value);
        a1.recycle();
        TypedArray a2 = context.obtainStyledAttributes(attrs, new int[]{android.R.attr.alpha});
        final float alphaMod = a2.getFloat(0, 1.0f);
        a2.recycle();
        colorList.add(alphaMod != 1.0f ? ColorUtils.setAlphaComponent(baseColor, Math.round(Color.alpha(baseColor) * alphaMod)) : baseColor);

        stateList.add(extractStateSet(attrs));
    }

    if (stateList.size() > 0 && stateList.size() == colorList.size()) {
        int[] colors = new int[colorList.size()];
        for (int i = 0; i < colorList.size(); i++) {
            colors[i] = colorList.get(i);
        }
        return new ColorStateList(stateList.toArray(new int[stateList.size()][]), colors);
    }
    return null;
}
 

public static Blade createBladeFromExpression(Expression expr) {
    final LinkedList<String> list = new LinkedList<String>();
    DFGTraversalVisitor visitor = new DFGTraversalVisitor() {
        @Override
        public void visit(BaseVector node) {
            list.add(node.toString());
            super.visit(node);
        }
    };
    expr.accept(visitor);
    return new Blade(list.toArray(new String[0]));
}
 

private static TransferMode[] getFXDndAction(int wkDndAction) {
	LinkedList<TransferMode> tms = new LinkedList<TransferMode>();
	if ((wkDndAction & WK_DND_ACTION_COPY) != 0)
		tms.add(TransferMode.COPY);
	if ((wkDndAction & WK_DND_ACTION_MOVE) != 0)
		tms.add(TransferMode.MOVE);
	if ((wkDndAction & WK_DND_ACTION_LINK) != 0)
		tms.add(TransferMode.LINK);
	return tms.toArray(new TransferMode[0]);
}
 

public static synchronized String[] getNames() {
    if (names == null) {
        LinkedList<String> list = new LinkedList<String>();
        InputStream str
            = PlatformClasses.class
                .getResourceAsStream("/com/sun/tools/hat/resources/platform_names.txt");
        if (str != null) {
            try {
                BufferedReader rdr
                    = new BufferedReader(new InputStreamReader(str));
                for (;;) {
                    String s = rdr.readLine();
                    if (s == null) {
                        break;
                    } else if (s.length() > 0) {
                        list.add(s);
                    }
                }
                rdr.close();
                str.close();
            } catch (IOException ex) {
                ex.printStackTrace();
                // Shouldn't happen, and if it does, continuing
                // is the right thing to do anyway.
            }
        }
        names = list.toArray(new String[list.size()]);
    }
    return names;
}
 

private void serializeNode(Node node, @Nullable Node parent, LinkedList<String> commentPath, boolean mappingScalar) throws IOException
{
    if (node.getNodeId() == NodeId.anchor)
    {
        node = ((AnchorNode) node).getRealNode();
    }
    String tAlias = this.anchors.get(node);
    if (this.serializedNodes.contains(node))
    {
        this.emitter.emit(new AliasEvent(tAlias, null, null));
    }
    else
    {
        this.serializedNodes.add(node);
        switch (node.getNodeId())
        {
            case scalar:
                ScalarNode scalarNode = (ScalarNode) node;
                Tag detectedTag = this.resolver.resolve(NodeId.scalar, scalarNode.getValue(), true);
                Tag defaultTag = this.resolver.resolve(NodeId.scalar, scalarNode.getValue(), false);
                String[] pathNodes = commentPath.toArray(new String[commentPath.size()]);
                String comment;
                if (this.checkCommentsSet(pathNodes))
                {
                    comment = this.comments.getComment(pathNodes);
                }
                else
                {
                    comment = null;
                }
                ImplicitTuple tuple = new ImplicitTupleExtension(node.getTag().equals(detectedTag), node.getTag().equals(defaultTag), comment);
                ScalarEvent event = new ScalarEvent(tAlias, node.getTag().getValue(), tuple, scalarNode.getValue(), null, null, scalarNode.getStyle());
                this.emitter.emit(event);
                break;
            case sequence:
                SequenceNode seqNode = (SequenceNode) node;
                boolean implicitS = node.getTag().equals(this.resolver.resolve(NodeId.sequence, null, true));
                this.emitter.emit(new SequenceStartEvent(tAlias, node.getTag().getValue(), implicitS, null, null, seqNode.getFlowStyle()));
                List<Node> list = seqNode.getValue();
                for (Node item : list)
                {
                    this.serializeNode(item, node, commentPath, false);
                }
                this.emitter.emit(new SequenceEndEvent(null, null));
                break;
            default:// instance of MappingNode
                Tag implicitTag = this.resolver.resolve(NodeId.mapping, null, true);
                boolean implicitM = node.getTag().equals(implicitTag);
                this.emitter.emit(new MappingStartEvent(tAlias, node.getTag().getValue(), implicitM, null, null, ((CollectionNode) node).getFlowStyle()));
                MappingNode mnode = (MappingNode) node;
                List<NodeTuple> map = mnode.getValue();
                for (NodeTuple row : map)
                {
                    Node key = row.getKeyNode();
                    Node value = row.getValueNode();
                    if (key instanceof ScalarNode)
                    {
                        commentPath.add(((ScalarNode) key).getValue());
                    }
                    this.serializeNode(key, mnode, commentPath, true);
                    this.serializeNode(value, mnode, commentPath, false);
                    if (key instanceof ScalarNode)
                    {
                        commentPath.removeLast();
                    }
                }
                this.emitter.emit(new MappingEndEvent(null, null));
        }
    }
}
 

private void validateColumnBlocks() {
    colAll = new ImmutableBitSet(0, nColumns);

    if (colBlocks == null) {
        colBlocks = new ImmutableBitSet[2];
        colBlocks[0] = primaryKey;
        colBlocks[1] = colAll.andNot(primaryKey);
    }

    colBlocksAll = new ImmutableBitSet(0, colBlocks.length);

    if (colPreferIndex == null)
        colPreferIndex = ImmutableBitSet.EMPTY;

    // column blocks must not overlap
    for (int i = 0; i < colBlocks.length; i++) {
        for (int j = i + 1; j < colBlocks.length; j++) {
            if (colBlocks[i].intersects(colBlocks[j]))
                throw new IllegalStateException();
        }
    }

    // column block must cover all columns
    ImmutableBitSet merge = ImmutableBitSet.EMPTY;
    for (int i = 0; i < colBlocks.length; i++) {
        merge = merge.or(colBlocks[i]);
    }
    if (!merge.equals(colAll))
        throw new IllegalStateException();

    // primary key must be the first column block
    if (!primaryKey.equals(colBlocks[0]))
        throw new IllegalStateException();

    // drop empty column block
    LinkedList<ImmutableBitSet> list = new LinkedList<ImmutableBitSet>(Arrays.asList(colBlocks));
    Iterator<ImmutableBitSet> it = list.iterator();
    while (it.hasNext()) {
        ImmutableBitSet cb = it.next();
        if (cb.isEmpty())
            it.remove();
    }
    colBlocks = list.toArray(new ImmutableBitSet[list.size()]);

    // for dynamic dimensions
    if (dynamicDims == null)
        dynamicDims = ImmutableBitSet.EMPTY;
}
 

private void decode(String format) {
    LinkedList<Object[]> list = new LinkedList<>();
    StringTokenizer tokenizer = new StringTokenizer(format, ";");
    while (tokenizer.hasMoreElements()) {
        String[] split = tokenizer.nextToken().split(":");
        String name = split[0];
        String type = split[1];
        Object[] object = new Object[]{name, type.charAt(0), null};
        switch (type.charAt(0)) {
            case 'i':
            case 'f':
                numberOfBytes += 4;
                break;
            case 'l':
                numberOfBytes += 8;
                break;
            case 'b':
                numberOfBytes += 1;
                break;
            case 'B':
                numberOfBytes += 6;
                break;
            case 'c':
                numberOfBytes += 2;
                break;
        }
        name2data.put(name, object);
        list.add(object);
    }
    data = list.toArray(new Object[list.size()][]);

    // access to standard items set here:
    bitScore = name2data.get("BitScore");
    expected = name2data.get("Expected");
    percentIdentity = name2data.get("Identity");
    taxonId = name2data.get("TaxonId");
    seedId = name2data.get("SeedId");
    cogId = name2data.get("CogId");
    keggId = name2data.get("KeggId");
    pfamId = name2data.get("PfamId");
    refSeqId = name2data.get("RefSeqID");
}