Java Outline类代码示例

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
@Override
protected Outline parseOutline(final Element e, final boolean validate, final Locale locale) throws FeedException {
    Outline retValue;

    retValue = super.parseOutline(e, validate, locale);

    if (e.getAttributeValue("created") != null) {
        retValue.setCreated(DateParser.parseRFC822(e.getAttributeValue("created"), locale));
    }

    final List<Attribute> atts = retValue.getAttributes();

    for (int i = 0; i < atts.size(); i++) {
        final Attribute a = atts.get(i);

        if (a.getName().equals("created")) {
            retValue.getAttributes().remove(a);

            break;
        }
    }

    return retValue;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
protected Element generateOutline(final Outline outline) {
    final Element e = new Element("outline");
    addNotNullAttribute(e, "text", outline.getText());
    addNotNullAttribute(e, "type", outline.getType());
    addNotNullAttribute(e, "title", outline.getTitle());

    if (outline.isBreakpoint()) {
        addNotNullAttribute(e, "isBreakpoint", "true");
    }

    if (outline.isComment()) {
        addNotNullAttribute(e, "isComment", "true");
    }

    final List<Attribute> atts = Collections.synchronizedList(outline.getAttributes());

    for (int i = 0; i < atts.size(); i++) {
        final Attribute att = atts.get(i);
        addNotNullAttribute(e, att.getName(), att.getValue());
    }

    super.generateItemModules(outline.getModules(), e);
    e.addContent(generateOutlines(outline.getChildren()));

    return e;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
private NodeList categoryOf(final String... categories) {

        try {

            final Outline outline = new Outline("outline1", null);
            outline.setCategories(Arrays.asList(categories));

            final Opml opml = new Opml();
            opml.setFeedType("opml_2.0");
            opml.setTitle("title");
            opml.setOutlines(Arrays.asList(outline));

            final WireFeedOutput output = new WireFeedOutput();
            final String xml = output.outputString(opml);

            final Document document = XMLUnit.buildControlDocument(xml);
            return XMLUnit.newXpathEngine().getMatchingNodes("/opml/body/outline/@category", document);

        } catch (final Exception e) {
            throw new RuntimeException(e);
        }

    }
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
private Outline buildCategoryOutline(FeedCategory cat, List<FeedCategory> categories, List<FeedSubscription> subscriptions) {
	Outline outline = new Outline();
	outline.setText(cat.getName());
	outline.setTitle(cat.getName());

	for (FeedCategory child : categories.stream().filter(c -> c.getParent() != null && c.getParent().getId().equals(cat.getId()))
			.collect(Collectors.toList())) {
		outline.getChildren().add(buildCategoryOutline(child, categories, subscriptions));
	}

	for (FeedSubscription sub : subscriptions.stream()
			.filter(s -> s.getCategory() != null && s.getCategory().getId().equals(cat.getId())).collect(Collectors.toList())) {
		outline.getChildren().add(buildSubscriptionOutline(sub));
	}
	return outline;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
@Test
public void generates_OPML_correctly() {
	when(feedCategoryDAO.findAll(user)).thenReturn(categories);
	when(feedSubscriptionDAO.findAll(user)).thenReturn(subscriptions);

	Opml opml = new OPMLExporter(feedCategoryDAO, feedSubscriptionDAO).export(user);

	List<Outline> rootOutlines = opml.getOutlines();
	assertEquals(2, rootOutlines.size());
	assertTrue(containsCategory(rootOutlines, "cat1"));
	assertTrue(containsFeed(rootOutlines, "rootFeed", "rootFeed.com"));

	Outline cat1Outline = getCategoryOutline(rootOutlines, "cat1");
	List<Outline> cat1Children = cat1Outline.getChildren();
	assertEquals(2, cat1Children.size());
	assertTrue(containsCategory(cat1Children, "cat2"));
	assertTrue(containsFeed(cat1Children, "cat1Feed", "cat1Feed.com"));

	Outline cat2Outline = getCategoryOutline(cat1Children, "cat2");
	List<Outline> cat2Children = cat2Outline.getChildren();
	assertEquals(1, cat2Children.size());
	assertTrue(containsFeed(cat2Children, "cat2Feed", "cat2Feed.com"));
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
protected void createEntries(final Stack<Integer> context, final List<SyndEntry> allEntries, final List<Outline> outlines) {
    final List<Outline> so = Collections.synchronizedList(outlines);

    for (int i = 0; i < so.size(); i++) {
        createEntry(context, allEntries, so.get(i));
    }
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
protected List<Element> generateOutlines(final List<Outline> outlines) {
    final ArrayList<Element> elements = new ArrayList<Element>();
    for (int i = 0; outlines != null && i < outlines.size(); i++) {
        elements.add(generateOutline(outlines.get(i)));
    }
    return elements;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
protected List<Outline> parseOutlines(final List<Element> elements, final boolean validate, final Locale locale) throws FeedException {
    final ArrayList<Outline> results = new ArrayList<Outline>();
    for (int i = 0; i < elements.size(); i++) {
        results.add(parseOutline(elements.get(i), validate, locale));
    }
    return results;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
public void importOpml(User user, String xml) {
	xml = xml.substring(xml.indexOf('<'));
	WireFeedInput input = new WireFeedInput();
	try {
		Opml feed = (Opml) input.build(new StringReader(xml));
		List<Outline> outlines = feed.getOutlines();
		for (int i = 0; i < outlines.size(); i++) {
			handleOutline(user, outlines.get(i), null, i);
		}
	} catch (Exception e) {
		log.error(e.getMessage(), e);
	}

}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
private Outline buildSubscriptionOutline(FeedSubscription sub) {
	Outline outline = new Outline();
	outline.setText(sub.getTitle());
	outline.setTitle(sub.getTitle());
	outline.setType("rss");
	outline.getAttributes().add(new Attribute("xmlUrl", sub.getFeed().getUrl()));
	if (sub.getFeed().getLink() != null) {
		outline.getAttributes().add(new Attribute("htmlUrl", sub.getFeed().getLink()));
	}
	return outline;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
private boolean containsCategory(List<Outline> outlines, String category) {
	for (Outline o : outlines)
		if (!"rss".equals(o.getType()))
			if (category.equals(o.getTitle()))
				return true;

	return false;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
private boolean containsFeed(List<Outline> outlines, String title, String url) {
	for (Outline o : outlines)
		if ("rss".equals(o.getType()))
			if (title.equals(o.getTitle()) && o.getAttributeValue("xmlUrl").equals(url))
				return true;

	return false;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
private Outline getCategoryOutline(List<Outline> outlines, String title) {
	for (Outline o : outlines)
		if (o.getTitle().equals(title))
			return o;

	return null;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
public OutlineHolder(final Outline outline, final String parent) {
    this.outline = outline;
    this.parent = parent;
}
 

import com.rometools.opml.feed.opml.Outline; //导入依赖的package包/类
@Override
protected Element generateOutline(final Outline outline) {

    final Element outlineElement = super.generateOutline(outline);

    if (outline.getCreated() != null) {
        outlineElement.setAttribute("created", DateParser.formatRFC822(outline.getCreated(), Locale.US));
    }

    final List<String> categories = outline.getCategories();
    final String categoryValue = generateCategoryValue(categories);
    addNotNullAttribute(outlineElement, "category", categoryValue);

    return outlineElement;

}