proj_name
stringclasses 131
values | relative_path
stringlengths 30
228
| class_name
stringlengths 1
68
| func_name
stringlengths 1
48
| masked_class
stringlengths 78
9.82k
| func_body
stringlengths 46
9.61k
| len_input
int64 29
2.01k
| len_output
int64 14
1.94k
| total
int64 55
2.05k
| relevant_context
stringlengths 0
38.4k
|
|---|---|---|---|---|---|---|---|---|---|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/formatter/NodeFormatterSubContext.java
|
NodeFormatterSubContext
|
flushTo
|
class NodeFormatterSubContext implements NodeFormatterContext {
final protected MarkdownWriter markdown;
Node renderingNode;
List<NodeFormattingHandler<?>> rendererList = null;
int rendererIndex = -1;
public NodeFormatterSubContext(@NotNull MarkdownWriter markdown) {
this.markdown = markdown;
this.renderingNode = null;
}
public @Nullable Node getRenderingNode() {
return renderingNode;
}
public void setRenderingNode(@Nullable Node renderingNode) {
this.renderingNode = renderingNode;
}
@Override
public @NotNull MarkdownWriter getMarkdown() {
return markdown;
}
public void flushTo(@NotNull Appendable out, int maxTrailingBlankLines) {
flushTo(out, getFormatterOptions().maxBlankLines, maxTrailingBlankLines);
}
public void flushTo(@NotNull Appendable out, int maxBlankLines, int maxTrailingBlankLines) {<FILL_FUNCTION_BODY>}
}
|
markdown.line();
try {
markdown.appendTo(out, maxBlankLines, maxTrailingBlankLines);
} catch (IOException e) {
e.printStackTrace();
}
| 274
| 58
| 332
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/formatter/internal/CoreNodeFormatter.java
|
Factory
|
getNodeFormattingHandlers
|
class Factory implements NodeFormatterFactory {
@NotNull
@Override
public NodeFormatter create(@NotNull DataHolder options) {
return new CoreNodeFormatter(options);
}
}
final FormatterOptions formatterOptions;
final private ListOptions listOptions;
final private String myHtmlBlockPrefix;
final private String myHtmlInlinePrefix;
final private String myTranslationAutolinkPrefix;
private int blankLines;
MutableDataHolder myTranslationStore;
private Map<String, String> attributeUniquificationIdMap;
public CoreNodeFormatter(DataHolder options) {
super(options, null, Formatter.UNIQUIFICATION_MAP);
formatterOptions = new FormatterOptions(options);
this.listOptions = ListOptions.get(options);
blankLines = 0;
myHtmlBlockPrefix = "<" + formatterOptions.translationHtmlBlockPrefix;
myHtmlInlinePrefix = formatterOptions.translationHtmlInlinePrefix;
myTranslationAutolinkPrefix = formatterOptions.translationAutolinkPrefix;
}
@Override
public char getBlockQuoteLikePrefixChar() {
return '>';
}
@Nullable
@Override
public Set<NodeFormattingHandler<?>> getNodeFormattingHandlers() {<FILL_FUNCTION_BODY>
|
return new HashSet<>(Arrays.asList(
// Generic unknown node formatter
new NodeFormattingHandler<>(Node.class, CoreNodeFormatter.this::render),
// specific nodes
new NodeFormattingHandler<>(AutoLink.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(BlankLine.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(BlockQuote.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Code.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Document.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Emphasis.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(FencedCodeBlock.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HardLineBreak.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Heading.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HtmlBlock.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HtmlCommentBlock.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HtmlInnerBlock.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HtmlInnerBlockComment.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HtmlEntity.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HtmlInline.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(HtmlInlineComment.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Image.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(ImageRef.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(IndentedCodeBlock.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Link.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(LinkRef.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(BulletList.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(OrderedList.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(BulletListItem.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(OrderedListItem.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(MailLink.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Paragraph.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Reference.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(SoftLineBreak.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(StrongEmphasis.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(Text.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(TextBase.class, CoreNodeFormatter.this::render),
new NodeFormattingHandler<>(ThematicBreak.class, CoreNodeFormatter.this::render)
));
| 333
| 839
| 1,172
|
<methods>public void <init>(com.vladsch.flexmark.util.data.DataHolder, DataKey<Map<java.lang.String,java.lang.String>>, DataKey<Map<java.lang.String,java.lang.String>>) ,public @Nullable Set<FormattingPhase> getFormattingPhases() ,public Comparator<com.vladsch.flexmark.ast.Reference> getReferenceComparator() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacement getReferencePlacement() ,public abstract com.vladsch.flexmark.util.format.options.ElementPlacementSort getReferenceSort() ,public abstract com.vladsch.flexmark.ast.util.ReferenceRepository getRepository(com.vladsch.flexmark.util.data.DataHolder) ,public java.lang.String modifyTransformedReference(java.lang.String, com.vladsch.flexmark.formatter.NodeFormatterContext) ,public void renderDocument(@NotNull NodeFormatterContext, @NotNull MarkdownWriter, @NotNull Document, @NotNull FormattingPhase) <variables>public static final HashSet<com.vladsch.flexmark.formatter.FormattingPhase> FORMATTING_PHASES,protected final non-sealed com.vladsch.flexmark.ast.Reference lastReference,protected final non-sealed Comparator<com.vladsch.flexmark.ast.Reference> myComparator,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceMapKey,private final non-sealed DataKey<Map<java.lang.String,java.lang.String>> myReferenceUniqificationMapKey,protected boolean recheckUndefinedReferences,protected final non-sealed List<com.vladsch.flexmark.ast.Reference> referenceList,protected final non-sealed com.vladsch.flexmark.ast.util.ReferenceRepository referenceRepository,private Map<java.lang.String,java.lang.String> referenceTranslationMap,protected Map<java.lang.String,java.lang.String> referenceUniqificationMap,protected boolean repositoryNodesDone,protected final non-sealed HashSet<com.vladsch.flexmark.util.ast.Node> unusedReferences
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/formatter/internal/FormatControlProcessor.java
|
FormatControlProcessor
|
isFormattingRegion
|
class FormatControlProcessor {
final public static String OPEN_COMMENT = "<!--";
final public static String CLOSE_COMMENT = "-->";
final private String formatterOnTag;
final private String formatterOffTag;
final private boolean formatterTagsEnabled;
private boolean myFormatterOff = false;
private boolean justTurnedOffFormatting = false;
private boolean justTurnedOnFormatting = false;
private boolean formatterTagsAcceptRegexp;
private volatile Pattern formatterOffPattern;
private volatile Pattern formatterOnPattern;
public FormatControlProcessor(@NotNull Document document, @Nullable DataHolder options) {
FormatterOptions formatterOptions = new FormatterOptions(options);
this.formatterOnTag = formatterOptions.formatterOnTag;
this.formatterOffTag = formatterOptions.formatterOffTag;
this.formatterTagsEnabled = formatterOptions.formatterTagsEnabled;
this.formatterTagsAcceptRegexp = formatterOptions.formatterTagsAcceptRegexp;
}
public boolean isFormattingOff() {
return myFormatterOff;
}
@Nullable
public Pattern getFormatterOffPattern() {
if (this.formatterOffPattern == null && formatterTagsEnabled && formatterTagsAcceptRegexp) {
this.formatterOffPattern = this.getPatternOrDisableRegexp(formatterOffTag);
}
return this.formatterOffPattern;
}
@Nullable
public Pattern getFormatterOnPattern() {
if (this.formatterOffPattern == null && formatterTagsEnabled && formatterTagsAcceptRegexp) {
this.formatterOnPattern = this.getPatternOrDisableRegexp(formatterOnTag);
}
return this.formatterOnPattern;
}
@Nullable
private Pattern getPatternOrDisableRegexp(@NotNull String markerText) {
try {
return Pattern.compile(markerText);
} catch (PatternSyntaxException var3) {
formatterTagsAcceptRegexp = false;
return null;
}
}
public boolean isFormattingRegion() {
return !myFormatterOff;
}
public String getFormatterOnTag() {
return formatterOnTag;
}
public String getFormatterOffTag() {
return formatterOffTag;
}
public boolean getFormatterTagsEnabled() {
return formatterTagsEnabled;
}
public boolean getFormatterRegExEnabled() {
return formatterTagsAcceptRegexp;
}
public boolean isJustTurnedOffFormatting() {
return justTurnedOffFormatting;
}
public boolean isJustTurnedOnFormatting() {
return justTurnedOnFormatting;
}
@Nullable
private Boolean isFormatterOffTag(@Nullable CharSequence commentText) {
if (commentText == null) return null;
String text = commentText.toString().trim();
text = text.substring(OPEN_COMMENT.length(), text.length() - CLOSE_COMMENT.length()).trim();
if (formatterTagsAcceptRegexp && formatterOffPattern != null && formatterOnPattern != null) {
if (formatterOnPattern.matcher(text).matches()) {
return false;
} else if (formatterOffPattern.matcher(text).matches()) {
return true;
}
} else if (formatterTagsEnabled) {
if (text.equals(formatterOnTag)) {
return false;
} else if (text.equals(formatterOffTag)) {
return true;
}
}
return null;
}
public void initializeFrom(@NotNull Node element) {
myFormatterOff = !isFormattingRegion(element.getStartOffset(), element, true);
}
public void processFormatControl(@NotNull Node node) {
justTurnedOffFormatting = false;
justTurnedOnFormatting = false;
if ((node instanceof HtmlCommentBlock || node instanceof HtmlInnerBlockComment) && formatterTagsEnabled) {
// could be formatter control
boolean formatterOff = myFormatterOff;
Boolean isFormatterOff = isFormatterOffTag(node.getChars());
if (isFormatterOff == null) return;
myFormatterOff = isFormatterOff;
if (!formatterOff && myFormatterOff) justTurnedOffFormatting = true;
if (formatterOff && !myFormatterOff) justTurnedOnFormatting = true;
}
}
private boolean isFormattingRegion(int offset, @NotNull Node node, boolean checkParent) {<FILL_FUNCTION_BODY>}
public boolean isFormattingRegion(@NotNull Node node) {
// find the first HTML comment with a formatter directive
if (!formatterTagsEnabled || node.getStartOffset() == 0) return true;
return isFormattingRegion(node.getStartOffset(), node, true);
}
}
|
while (node != null) {
if (node.getStartOffset() <= offset) {
if (node instanceof Block && !(node instanceof Paragraph) && node.hasChildren()) {
Node lastChild = node.getLastChild();
return lastChild != null && isFormattingRegion(offset, lastChild, false);
} else if (node instanceof HtmlCommentBlock || node instanceof HtmlInnerBlockComment) {
Boolean formatterOff = isFormatterOffTag(node.getChars());
if (formatterOff != null) return !formatterOff;
}
}
if (node.getPrevious() == null && checkParent) {
node = node.getParent();
if (node instanceof Document) break;
if (node != null) node = node.getPrevious();
} else {
node = node.getPrevious();
}
}
return true;
| 1,256
| 223
| 1,479
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/formatter/internal/MergeContextImpl.java
|
MergeContextImpl
|
updateDocumentMap
|
class MergeContextImpl implements MergeContext {
private Document[] myDocuments;
private TranslationHandler[] myTranslationHandlers;
final private HashMap<TranslationContext, Document> myTranslationHandlerDocumentMap;
public MergeContextImpl(Document[] documents, TranslationHandler[] translationHandlers) {
assert documents.length == translationHandlers.length;
myDocuments = documents;
myTranslationHandlers = translationHandlers;
myTranslationHandlerDocumentMap = new HashMap<>();
updateDocumentMap();
for (TranslationHandler handler : myTranslationHandlers) {
handler.setMergeContext(this);
}
}
private void updateDocumentMap() {<FILL_FUNCTION_BODY>}
public Document[] getDocuments() {
return myDocuments;
}
public void setDocuments(Document[] documents) {
assert documents.length == myTranslationHandlers.length;
myDocuments = documents;
updateDocumentMap();
}
public TranslationHandler[] getTranslationHandlers() {
return myTranslationHandlers;
}
@NotNull
@Override
public Document getDocument(@NotNull TranslationContext context) {
return myTranslationHandlerDocumentMap.get(context);
}
@Override
public void forEachPrecedingDocument(@Nullable Document document, @NotNull MergeContextConsumer consumer) {
int iMax = myDocuments.length;
for (int i = 0; i < iMax; i++) {
if (myDocuments[i] == document) break;
consumer.accept(myTranslationHandlers[i], myDocuments[i], i);
}
}
}
|
int iMax = myDocuments.length;
for (int i = 0; i < iMax; i++) {
myTranslationHandlerDocumentMap.put(myTranslationHandlers[i], myDocuments[i]);
}
| 414
| 59
| 473
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/formatter/internal/MergeLinkResolver.java
|
MergeLinkResolver
|
resolveLink
|
class MergeLinkResolver implements LinkResolver {
final private String docRelativeURL;
final private String docRootURL;
final private String[] relativeParts;
public MergeLinkResolver(LinkResolverBasicContext context) {
// can use context for custom settings
String docRelativeURL = Formatter.DOC_RELATIVE_URL.get(context.getOptions());
String docRootURL = Formatter.DOC_ROOT_URL.get(context.getOptions());
this.docRelativeURL = docRelativeURL;
this.docRootURL = docRootURL;
docRelativeURL = Utils.removePrefix(docRelativeURL, '/');
relativeParts = docRelativeURL.split("/");
}
@NotNull
@Override
public ResolvedLink resolveLink(@NotNull Node node, @NotNull LinkResolverBasicContext context, @NotNull ResolvedLink link) {<FILL_FUNCTION_BODY>}
public static class Factory implements LinkResolverFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@Override
public boolean affectsGlobalScope() {
return false;
}
@NotNull
@Override
public LinkResolver apply(@NotNull LinkResolverBasicContext context) {
return new MergeLinkResolver(context);
}
}
}
|
if (node instanceof Image || node instanceof Link || node instanceof Reference) {
String url = link.getUrl();
if (docRelativeURL.isEmpty() && docRootURL.isEmpty()) {
// resolve url, return one of LinkStatus other than LinkStatus.UNKNOWN
return link.withStatus(LinkStatus.VALID)
.withUrl(url);
}
if (url.startsWith("http://") || url.startsWith("https://") || url.startsWith("ftp://") || url.startsWith("sftp://")) {
// resolve url, return one of LinkStatus other than LinkStatus.UNKNOWN
return link.withStatus(LinkStatus.VALID)
.withUrl(url);
} else if (url.startsWith("file:/")) {
// assume it is good
return link.withStatus(LinkStatus.VALID)
.withUrl(url);
} else if (url.startsWith("/")) {
if (docRootURL != null && !docRootURL.isEmpty()) {
// this one is root url, prefix with merged root url, without the trailing /
url = (!docRootURL.startsWith("/") ? "/" : "") + docRootURL + url;
return link.withStatus(LinkStatus.VALID)
.withUrl(url);
}
} else if (!url.matches("^(?:[a-z]+:|#|\\?)")) {
// relative, we will process it as a relative path to the docRelativeURL
String pageRef = url;
String suffix = "";
int pos = url.indexOf('#');
if (pos == 0) {
return link.withStatus(LinkStatus.VALID);
} else {
if (pos > 0) {
// remove anchor
suffix = url.substring(pos);
pageRef = url.substring(0, pos);
} else if (url.contains("?")) {
// remove query
pos = url.indexOf("?");
suffix = url.substring(pos);
pageRef = url.substring(0, pos);
}
String[] pathParts = pageRef.split("/");
int docParts = relativeParts.length;
int iMax = pathParts.length;
StringBuilder resolved = new StringBuilder();
String sep = "";
for (int i = 0; i < iMax; i++) {
String part = pathParts[i];
if (part.equals(".")) {
// skp
} else if (part.equals("..")) {
// remove one doc part
if (docParts == 0) return link;
docParts--;
} else {
resolved.append(sep);
resolved.append(part);
sep = "/";
}
}
// prefix with remaining docParts
sep = docRelativeURL.startsWith("/") ? "/" : "";
StringBuilder resolvedPath = new StringBuilder();
iMax = docParts;
for (int i = 0; i < iMax; i++) {
resolvedPath.append(sep);
resolvedPath.append(relativeParts[i]);
sep = "/";
}
resolvedPath.append('/').append(resolved).append(suffix);
String resolvedUri = resolvedPath.toString();
return link.withStatus(LinkStatus.VALID)
.withUrl(resolvedUri);
}
}
}
return link;
| 376
| 863
| 1,239
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/DelegatingNodeRendererFactoryWrapper.java
|
DelegatingNodeRendererFactoryWrapper
|
getBeforeDependents
|
class DelegatingNodeRendererFactoryWrapper implements Function<DataHolder, NodeRenderer>, Dependent, DelegatingNodeRendererFactory {
final private NodeRendererFactory nodeRendererFactory;
private List<DelegatingNodeRendererFactoryWrapper> nodeRenderers;
private Set<Class<?>> myDelegates = null;
public DelegatingNodeRendererFactoryWrapper(List<DelegatingNodeRendererFactoryWrapper> nodeRenderers, NodeRendererFactory nodeRendererFactory) {
this.nodeRendererFactory = nodeRendererFactory;
this.nodeRenderers = nodeRenderers;
}
@Override
public @NotNull NodeRenderer apply(@NotNull DataHolder options) {
return nodeRendererFactory.apply(options);
}
public @NotNull NodeRendererFactory getFactory() {
return nodeRendererFactory;
}
@Override
public @Nullable Set<Class<?>> getDelegates() {
return nodeRendererFactory instanceof DelegatingNodeRendererFactory ? ((DelegatingNodeRendererFactory) nodeRendererFactory).getDelegates() : null;
}
@Override
final public @Nullable Set<Class<?>> getAfterDependents() {
return null;
}
@Override
public @Nullable Set<Class<?>> getBeforeDependents() {<FILL_FUNCTION_BODY>}
@Override
final public boolean affectsGlobalScope() {
return false;
}
}
|
if (myDelegates == null && nodeRenderers != null) {
Set<Class<?>> delegates = getDelegates();
if (delegates != null) {
myDelegates = new HashSet<>();
for (DelegatingNodeRendererFactoryWrapper factory : nodeRenderers) {
if (delegates.contains(factory.getFactory().getClass())) {
myDelegates.add(factory.getFactory().getClass());
}
}
}
// release reference
nodeRenderers = null;
}
return myDelegates;
| 344
| 153
| 497
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/EmbeddedAttributeProvider.java
|
EmbeddedAttributeProvider
|
setAttributes
|
class EmbeddedAttributeProvider implements AttributeProvider {
final public static IndependentAttributeProviderFactory Factory = new IndependentAttributeProviderFactory() {
@NotNull
@Override
public AttributeProvider apply(@NotNull LinkResolverContext context) {
return new EmbeddedAttributeProvider();
}
};
EmbeddedAttributeProvider() {
}
@Override
public void setAttributes(@NotNull Node node, @NotNull AttributablePart part, @NotNull MutableAttributes attributes) {<FILL_FUNCTION_BODY>}
// so we can attach attributes to any node in the AST and have a generic attribute provider serve them up
public static class EmbeddedNodeAttributes extends Node {
final @NotNull Attributes attributes;
public EmbeddedNodeAttributes(@NotNull Node parent, @NotNull Attributes attributes) {
super(parent.getChars().subSequence(0, 0));
this.attributes = attributes;
}
@NotNull
@Override
public BasedSequence[] getSegments() {
return Node.EMPTY_SEGMENTS;
}
@Override
public void astString(@NotNull StringBuilder out, boolean withExtra) {
out.append(EmbeddedNodeAttributes.class.getSimpleName());
out.append("[").append(getStartOffset()).append(", ").append(getEndOffset()).append("]");
out.append(", attributes: ").append(attributes.toString());
if (withExtra) getAstExtra(out);
}
@Override
public void astExtraChars(@NotNull StringBuilder out) {
}
}
}
|
if (part == AttributablePart.NODE) {
Node firstChild = node.getChildOfType(EmbeddedNodeAttributes.class);
if (firstChild instanceof EmbeddedNodeAttributes) {
attributes.addValues(((EmbeddedNodeAttributes) firstChild).attributes);
}
}
| 393
| 79
| 472
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/HtmlWriter.java
|
HtmlWriter
|
tag
|
class HtmlWriter extends HtmlAppendableBase<HtmlWriter> {
private @Nullable NodeRendererContext context;
private @Nullable AttributablePart useAttributes;
public HtmlWriter(int indentSize, int formatOptions) {
super(indentSize, formatOptions);
}
public HtmlWriter(HtmlWriter other, boolean inheritIndent) {
super(other, inheritIndent);
context = other.context;
}
public HtmlWriter(int indentSize, int formatOptions, boolean suppressOpenTagLine, boolean suppressCloseTagLine) {
this(null, indentSize, formatOptions, suppressOpenTagLine, suppressCloseTagLine);
}
public HtmlWriter(@Nullable Appendable appendable, int indentSize, int formatOptions, boolean suppressOpenTagLine, boolean suppressCloseTagLine) {
super(appendable, indentSize, formatOptions);
setSuppressOpenTagLine(suppressOpenTagLine);
setSuppressCloseTagLine(suppressCloseTagLine);
}
void setContext(@NotNull NodeRendererContext context) {
this.context = context;
}
public @NotNull NodeRendererContext getContext() {
assert context != null;
return context;
}
public @NotNull HtmlWriter srcPos() {
return context == null ? this : srcPos(context.getCurrentNode().getChars());
}
public @NotNull HtmlWriter srcPosWithEOL() {
return context == null ? this : srcPosWithEOL(context.getCurrentNode().getChars());
}
public @NotNull HtmlWriter srcPosWithTrailingEOL() {
return context == null ? this : srcPosWithTrailingEOL(context.getCurrentNode().getChars());
}
public @NotNull HtmlWriter srcPos(@NotNull BasedSequence sourceText) {
if (sourceText.isNotNull()) {
BasedSequence trimmed = sourceText.trimEOL();
return srcPos(trimmed.getStartOffset(), trimmed.getEndOffset());
}
return this;
}
@SuppressWarnings("WeakerAccess")
public @NotNull HtmlWriter srcPosWithEOL(@NotNull BasedSequence sourceText) {
if (sourceText.isNotNull()) {
return srcPos(sourceText.getStartOffset(), sourceText.getEndOffset());
}
return this;
}
@SuppressWarnings("WeakerAccess")
public @NotNull HtmlWriter srcPosWithTrailingEOL(@NotNull BasedSequence sourceText) {
if (sourceText.isNotNull()) {
int endOffset = sourceText.getEndOffset();
BasedSequence base = sourceText.getBaseSequence();
while (endOffset < base.length()) {
char c = base.charAt(endOffset);
if (c != ' ' && c != '\t') break;
endOffset++;
}
if (endOffset < base.length() && base.charAt(endOffset) == '\r') {
endOffset++;
}
if (endOffset < base.length() && base.charAt(endOffset) == '\n') {
endOffset++;
}
return srcPos(sourceText.getStartOffset(), endOffset);
}
return this;
}
public @NotNull HtmlWriter srcPos(int startOffset, int endOffset) {
if (startOffset <= endOffset && context != null && !context.getHtmlOptions().sourcePositionAttribute.isEmpty()) {
super.attr(context.getHtmlOptions().sourcePositionAttribute, startOffset + "-" + endOffset);
}
return this;
}
@NotNull
public HtmlWriter withAttr() {
return withAttr(AttributablePart.NODE);
}
public @NotNull HtmlWriter withAttr(@NotNull AttributablePart part) {
super.withAttr();
useAttributes = part;
return this;
}
public @NotNull HtmlWriter withAttr(@NotNull LinkStatus status) {
attr(Attribute.LINK_STATUS_ATTR, status.getName());
return withAttr(AttributablePart.LINK);
}
public @NotNull HtmlWriter withAttr(@NotNull ResolvedLink resolvedLink) {
return withAttr(resolvedLink.getStatus());
}
@NotNull
@Override
public HtmlWriter tag(@NotNull CharSequence tagName, boolean voidElement) {<FILL_FUNCTION_BODY>}
}
|
if (useAttributes != null) {
String attributeValue;
final Attributes attributes;
if (context != null) {
attributes = context.extendRenderingNodeAttributes(useAttributes, getAttributes());
String sourcePositionAttribute = context.getHtmlOptions().sourcePositionAttribute;
attributeValue = attributes.getValue(sourcePositionAttribute);
} else {
attributeValue = "";
attributes = new Attributes();
}
if (!attributeValue.isEmpty()) {
// add to tag ranges
int pos = attributeValue.indexOf('-');
int startOffset = -1;
int endOffset = -1;
if (pos != -1) {
try {
startOffset = Integer.parseInt(attributeValue.substring(0, pos));
} catch (Throwable ignored) {
}
try {
endOffset = Integer.parseInt(attributeValue.substring(pos + 1));
} catch (Throwable ignored) {
}
}
if (startOffset >= 0 && startOffset < endOffset) {
ArrayList<TagRange> tagRanges = HtmlRenderer.TAG_RANGES.get(context.getDocument());
tagRanges.add(new TagRange(tagName, startOffset, endOffset));
}
}
setAttributes(attributes);
useAttributes = null;
}
super.tag(tagName, voidElement);
return this;
| 1,097
| 357
| 1,454
|
<methods>public void <init>(com.vladsch.flexmark.util.sequence.LineAppendable, boolean) ,public void <init>(int, int) ,public void <init>(@Nullable Appendable, int, int) ,public @NotNull HtmlWriter addIndentOnFirstEOL(@NotNull Runnable) ,public @NotNull HtmlWriter addPrefix(@NotNull CharSequence) ,public @NotNull HtmlWriter addPrefix(@NotNull CharSequence, boolean) ,public @NotNull HtmlWriter append(char) ,public @NotNull HtmlWriter append(@NotNull CharSequence) ,public @NotNull HtmlWriter append(@NotNull CharSequence, int, int) ,public @NotNull HtmlWriter append(@NotNull LineAppendable, int, int, boolean) ,public @NotNull HtmlWriter append(char, int) ,public T appendTo(@NotNull T, boolean, int, int, int, int) throws java.io.IOException,public @NotNull HtmlWriter attr(@NotNull CharSequence, @NotNull CharSequence) ,public transient @NotNull HtmlWriter attr(@NotNull Attribute []) ,public @NotNull HtmlWriter attr(@NotNull Attributes) ,public @NotNull HtmlWriter blankLine() ,public @NotNull HtmlWriter blankLine(int) ,public @NotNull HtmlWriter blankLineIf(boolean) ,public @NotNull HtmlWriter changeOptions(int, int) ,public @NotNull HtmlWriter closePre() ,public @NotNull HtmlWriter closePreFormatted() ,public @NotNull HtmlWriter closeTag(@NotNull CharSequence) ,public int column() ,public boolean endsWithEOL() ,public int getAfterEolPrefixDelta() ,public com.vladsch.flexmark.util.html.Attributes getAttributes() ,public @NotNull BasedSequence getBeforeEolPrefix() ,public @NotNull ISequenceBuilder<?,?> getBuilder() ,public @NotNull HtmlAppendable getEmptyAppendable() ,public @NotNull BasedSequence getIndentPrefix() ,public @NotNull BasedSequence getLine(int) ,public int getLineCount() ,public int getLineCountWithPending() ,public @NotNull LineInfo getLineInfo(int) ,public @NotNull Iterable<BasedSequence> getLines(int, int, int, boolean) ,public @NotNull Iterable<LineInfo> getLinesInfo(int, int, int) ,public @NotNull Stack<String> getOpenTags() ,public @NotNull List<String> getOpenTagsAfterLast(@NotNull CharSequence) ,public @NotNull BitFieldSet<LineAppendable.Options> getOptionSet() ,public int getOptions() ,public int getPendingEOL() ,public int getPendingSpace() ,public @NotNull BasedSequence getPrefix() ,public int getTrailingBlankLines(int) ,public boolean inPre() ,public @NotNull HtmlWriter indent() ,public void insertLine(int, @NotNull CharSequence, @NotNull CharSequence) ,public boolean isPendingSpace() ,public boolean isPreFormatted() ,public boolean isSuppressCloseTagLine() ,public boolean isSuppressOpenTagLine() ,public @NotNull Iterator<LineInfo> iterator() ,public @NotNull HtmlWriter line() ,public @NotNull HtmlWriter lineIf(boolean) ,public @NotNull HtmlWriter lineOnFirstText(boolean) ,public @NotNull HtmlWriter lineWithTrailingSpaces(int) ,public int offset() ,public int offsetWithPending() ,public @NotNull HtmlWriter openPre() ,public @NotNull HtmlWriter openPreFormatted(boolean) ,public @NotNull HtmlWriter popOptions() ,public @NotNull HtmlWriter popPrefix() ,public @NotNull HtmlWriter popPrefix(boolean) ,public @NotNull HtmlWriter pushOptions() ,public @NotNull HtmlWriter pushPrefix() ,public @NotNull HtmlWriter raw(@NotNull CharSequence) ,public @NotNull HtmlWriter raw(@NotNull CharSequence, int) ,public @NotNull HtmlWriter rawIndentedPre(@NotNull CharSequence) ,public @NotNull HtmlWriter rawPre(@NotNull CharSequence) ,public @NotNull HtmlWriter removeExtraBlankLines(int, int, int, int) ,public @NotNull HtmlWriter removeIndentOnFirstEOL(@NotNull Runnable) ,public @NotNull HtmlWriter removeLines(int, int) ,public @NotNull HtmlWriter setAttributes(@NotNull Attributes) ,public @NotNull HtmlWriter setIndentPrefix(@Nullable CharSequence) ,public void setLine(int, @NotNull CharSequence, @NotNull CharSequence) ,public @NotNull HtmlWriter setOptions(int) ,public @NotNull HtmlWriter setPrefix(@NotNull CharSequence) ,public @NotNull HtmlWriter setPrefix(@Nullable CharSequence, boolean) ,public void setPrefixLength(int, int) ,public @NotNull HtmlWriter setSuppressCloseTagLine(boolean) ,public void setSuppressOpenTagLine(boolean) ,public @NotNull HtmlWriter tag(@NotNull CharSequence) ,public @NotNull HtmlWriter tag(@NotNull CharSequence, @NotNull Runnable) ,public @NotNull HtmlWriter tag(@NotNull CharSequence, boolean) ,public @NotNull HtmlWriter tag(@NotNull CharSequence, boolean, boolean, @NotNull Runnable) ,public @NotNull HtmlWriter tagIndent(@NotNull CharSequence, @NotNull Runnable) ,public @NotNull HtmlWriter tagLine(@NotNull CharSequence) ,public @NotNull HtmlWriter tagLine(@NotNull CharSequence, boolean) ,public @NotNull HtmlWriter tagLine(@NotNull CharSequence, @NotNull Runnable) ,public @NotNull HtmlWriter tagLineIndent(@NotNull CharSequence, @NotNull Runnable) ,public @NotNull HtmlWriter tagVoid(@NotNull CharSequence) ,public @NotNull HtmlWriter tagVoidLine(@NotNull CharSequence) ,public @NotNull HtmlWriter text(@NotNull CharSequence) ,public @NotNull CharSequence toSequence(int, int, boolean) ,public @NotNull String toString() ,public @NotNull String toString(int, int, boolean) ,public @NotNull HtmlWriter unIndent() ,public @NotNull HtmlWriter unIndentNoEol() ,public @NotNull HtmlWriter withAttr() ,public @NotNull HtmlWriter withCondIndent() ,public @NotNull HtmlWriter withCondLineOnChildText() <variables>private final non-sealed com.vladsch.flexmark.util.sequence.LineAppendable appendable,private @Nullable MutableAttributes currentAttributes,private boolean indentOnFirstEol,private boolean lineOnChildText,private final @NotNull Stack<String> openTags,private boolean suppressCloseTagLine,private boolean suppressOpenTagLine,private boolean withAttributes
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/NodeRendererSubContext.java
|
NodeRendererSubContext
|
flushTo
|
class NodeRendererSubContext implements NodeRendererContext {
final HtmlWriter htmlWriter;
Node renderingNode;
NodeRenderingHandlerWrapper renderingHandlerWrapper;
int doNotRenderLinksNesting;
public NodeRendererSubContext(@NotNull HtmlWriter htmlWriter) {
this.htmlWriter = htmlWriter;
this.renderingNode = null;
this.doNotRenderLinksNesting = 0;
}
public @NotNull HtmlWriter getHtmlWriter() {
return htmlWriter;
}
public void flushTo(@NotNull Appendable out, int maxTrailingBlankLines) {
flushTo(out, getHtmlOptions().maxBlankLines, maxTrailingBlankLines);
}
public void flushTo(@NotNull Appendable out, int maxBlankLines, int maxTrailingBlankLines) {<FILL_FUNCTION_BODY>}
protected int getDoNotRenderLinksNesting() {
return doNotRenderLinksNesting;
}
public boolean isDoNotRenderLinks() {
return doNotRenderLinksNesting != 0;
}
public void doNotRenderLinks(boolean doNotRenderLinks) {
if (doNotRenderLinks) doNotRenderLinks();
else doRenderLinks();
}
public void doNotRenderLinks() {
this.doNotRenderLinksNesting++;
}
public void doRenderLinks() {
if (this.doNotRenderLinksNesting == 0) throw new IllegalStateException("Not in do not render links context");
this.doNotRenderLinksNesting--;
}
}
|
htmlWriter.line();
try {
htmlWriter.appendTo(out, maxBlankLines, maxTrailingBlankLines);
} catch (IOException e) {
e.printStackTrace();
}
| 420
| 58
| 478
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/renderer/FileUriContentResolver.java
|
FileUriContentResolver
|
resolveContent
|
class FileUriContentResolver implements UriContentResolver {
public FileUriContentResolver(LinkResolverBasicContext context) {
}
@Override
public @NotNull ResolvedContent resolveContent(@NotNull Node node, @NotNull LinkResolverBasicContext context, @NotNull ResolvedContent content) {<FILL_FUNCTION_BODY>}
public static class Factory implements UriContentResolverFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
// ensure that default file uri resolver is the last one in the list
return Collections.singleton(LastDependent.class);
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@Override
public boolean affectsGlobalScope() {
return false;
}
@NotNull
@Override
public UriContentResolver apply(@NotNull LinkResolverBasicContext context) {
return new FileUriContentResolver(context);
}
}
}
|
ResolvedLink resolvedLink = content.getResolvedLink();
if (resolvedLink.getStatus() == LinkStatus.VALID) {
// have the file
String url = resolvedLink.getUrl();
if (url.startsWith("file:/")) {
// handle Windows and OSX/Unix URI
String substring = url.startsWith("file://") ? url.substring("file://".length()) : File.separatorChar == '\\' ? url.substring("file:/".length()) : url.substring("file:".length());
File includedFile = new File(substring);
if (includedFile.isFile() && includedFile.exists()) {
// need to read and parse the file
try {
return content.withContent(FileUtil.getFileContentBytesWithExceptions(includedFile)).withStatus(LinkStatus.VALID);
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
return content;
| 252
| 248
| 500
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/renderer/LinkStatus.java
|
LinkStatus
|
equals
|
class LinkStatus {
final public static LinkStatus UNKNOWN = new LinkStatus("UNKNOWN");
final public static LinkStatus VALID = new LinkStatus("VALID");
final public static LinkStatus INVALID = new LinkStatus("INVALID");
final public static LinkStatus UNCHECKED = new LinkStatus("UNCHECKED");
final public static LinkStatus NOT_FOUND = new LinkStatus("NOT_FOUND");
final private String myName;
public LinkStatus(@NotNull String name) {
this.myName = name;
}
public @NotNull String getName() {
return myName;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return myName.hashCode();
}
public boolean isStatus(CharSequence status) {
return myName.equals(status instanceof String ? (String) status : String.valueOf(status));
}
}
|
if (this == o) return true;
if (!(o instanceof LinkStatus)) return false;
LinkStatus status = (LinkStatus) o;
return myName.equals(status.myName);
| 246
| 54
| 300
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/renderer/ResolvedContent.java
|
ResolvedContent
|
equals
|
class ResolvedContent {
final private @NotNull ResolvedLink resolvedLink;
final private @NotNull LinkStatus status;
final private @Nullable byte[] content;
public ResolvedContent(@NotNull ResolvedLink resolvedLink, @NotNull LinkStatus status, @Nullable byte[] content) {
this.resolvedLink = resolvedLink;
this.status = status;
this.content = content;
}
// @formatter:off
public ResolvedContent withStatus(@NotNull LinkStatus status) { return status == this.status ? this : new ResolvedContent(resolvedLink, status, content); }
public ResolvedContent withContent(@Nullable byte[] content) { return Arrays.equals(this.content, content) ? this : new ResolvedContent(resolvedLink, status, content); }
// @formatter:on
public @NotNull ResolvedLink getResolvedLink() {
return resolvedLink;
}
public @NotNull LinkStatus getStatus() {
return status;
}
public @Nullable byte[] getContent() {
return content;
}
@Override
public boolean equals(Object o) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
int result = resolvedLink.hashCode();
result = 31 * result + status.hashCode();
result = 31 * result + Arrays.hashCode(content);
return result;
}
}
|
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
ResolvedContent content1 = (ResolvedContent) o;
if (!resolvedLink.equals(content1.resolvedLink)) return false;
if (!status.equals(content1.status)) return false;
return Arrays.equals(content, content1.content);
| 360
| 102
| 462
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/html/renderer/ResolvedLink.java
|
ResolvedLink
|
getAnchorRef
|
class ResolvedLink {
final private @NotNull LinkType myLinkType;
final private @NotNull String myUrl;
final private @NotNull LinkStatus myStatus;
private @Nullable MutableAttributes myAttributes;
public ResolvedLink(@NotNull LinkType linkType, @NotNull CharSequence url) {
this(linkType, url, null, LinkStatus.UNKNOWN);
}
public ResolvedLink(@NotNull LinkType linkType, @NotNull CharSequence url, @Nullable Attributes attributes) {
this(linkType, url, attributes, LinkStatus.UNKNOWN);
}
@Nullable
public Attributes getAttributes() {
return myAttributes == null ? null : myAttributes.toImmutable();
}
public @NotNull Attributes getNonNullAttributes() {
if (myAttributes == null) {
myAttributes = new MutableAttributes();
}
return myAttributes.toImmutable();
}
public @NotNull MutableAttributes getMutableAttributes() {
if (myAttributes == null) {
myAttributes = new MutableAttributes();
}
return myAttributes;
}
public ResolvedLink(@NotNull LinkType linkType, CharSequence url, @Nullable Attributes attributes, @NotNull LinkStatus status) {
myLinkType = linkType;
myUrl = String.valueOf(url);
myStatus = status;
if (attributes != null) {
getMutableAttributes().addValues(attributes);
}
}
// @formatter:off
public ResolvedLink withLinkType(@NotNull LinkType linkType) { return linkType == this.myLinkType ? this : new ResolvedLink(linkType, myUrl, myAttributes, myStatus); }
public ResolvedLink withStatus(@NotNull LinkStatus status) { return status == this.myStatus ? this : new ResolvedLink(myLinkType, myUrl, myAttributes, status); }
// @formatter:on
@NotNull
public LinkType getLinkType() {
return myLinkType;
}
@NotNull
public LinkStatus getStatus() {
return myStatus;
}
public @NotNull ResolvedLink withUrl(@NotNull CharSequence url) {
String useUrl = String.valueOf(url);
return this.myUrl.equals(useUrl) ? this : new ResolvedLink(myLinkType, useUrl, myAttributes, myStatus);
}
@NotNull
public String getUrl() {
return myUrl;
}
public @NotNull String getPageRef() {
// parse out the anchor marker and ref
int pos = myUrl.indexOf('#');
if (pos < 0) {
return myUrl;
} else {
return myUrl.substring(0, pos);
}
}
public @Nullable String getAnchorRef() {<FILL_FUNCTION_BODY>}
public @NotNull ResolvedLink withTitle(@Nullable CharSequence title) {
String haveTitle = myAttributes == null ? null : myAttributes.getValue(Attribute.TITLE_ATTR);
if (title == haveTitle || haveTitle != null && title != null && haveTitle.contentEquals(title)) return this;
MutableAttributes attributes = new MutableAttributes(myAttributes);
if (title == null) {
attributes.remove(Attribute.TITLE_ATTR);
if (attributes.isEmpty()) attributes = null;
} else {
attributes.replaceValue(Attribute.TITLE_ATTR, title);
}
return new ResolvedLink(myLinkType, myUrl, attributes, myStatus);
}
public @Nullable String getTitle() {
return myAttributes == null ? null : myAttributes.getValue(Attribute.TITLE_ATTR);
}
public @NotNull ResolvedLink withTarget(@Nullable CharSequence target) {
String haveTarget = myAttributes == null ? null : myAttributes.getValue(Attribute.TARGET_ATTR);
if (target == haveTarget || haveTarget != null && target != null && haveTarget.contentEquals(target)) return this;
MutableAttributes attributes = new MutableAttributes(myAttributes);
if (target == null) {
attributes.remove(Attribute.TARGET_ATTR);
if (attributes.isEmpty()) attributes = null;
} else {
attributes.replaceValue(Attribute.TARGET_ATTR, target);
}
return new ResolvedLink(myLinkType, myUrl, attributes, myStatus);
}
public String getTarget() {
return myAttributes == null ? null : myAttributes.getValue(Attribute.TARGET_ATTR);
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (!(o instanceof ResolvedLink)) return false;
ResolvedLink link = (ResolvedLink) o;
if (!myLinkType.equals(link.myLinkType)) return false;
if (!myUrl.equals(link.myUrl)) return false;
return myStatus.equals(link.myStatus);
}
@Override
public int hashCode() {
int result = myLinkType.hashCode();
result = 31 * result + myUrl.hashCode();
result = 31 * result + myStatus.hashCode();
return result;
}
}
|
// parse out the anchor marker and ref
int pos = myUrl.indexOf('#');
if (pos < 0) {
return null;
} else {
return myUrl.substring(pos + 1);
}
| 1,313
| 59
| 1,372
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/LightInlineParserImpl.java
|
LightInlineParserImpl
|
moveNodes
|
class LightInlineParserImpl implements LightInlineParser {
final protected InlineParserOptions options;
final protected Parsing myParsing;
protected Node block;
protected BasedSequence input;
protected int index;
protected ArrayList<BasedSequence> currentText;
protected Document document;
public LightInlineParserImpl(DataHolder dataOptions) {
this.options = new InlineParserOptions(dataOptions);
this.myParsing = new Parsing(dataOptions);
}
@NotNull
@Override
public ArrayList<BasedSequence> getCurrentText() {
if (currentText == null) {
currentText = new ArrayList<>();
}
return currentText;
}
@NotNull
@Override
public BasedSequence getInput() {
return input;
}
@Override
public void setInput(BasedSequence input) {
this.input = input;
}
@Override
public int getIndex() {
return index;
}
@Override
public void setIndex(int index) {
this.index = index;
}
@NotNull
@Override
public Document getDocument() {
return document;
}
@Override
public void setDocument(@NotNull Document document) {
this.document = document;
}
@NotNull
@Override
public InlineParserOptions getOptions() {
return options;
}
@NotNull
@Override
public Parsing getParsing() {
return myParsing;
}
@NotNull
@Override
public Node getBlock() {
return block;
}
@Override
public void setBlock(@NotNull Node block) {
this.block = block;
}
@Override
public void moveNodes(@NotNull Node fromNode, @NotNull Node toNode) {<FILL_FUNCTION_BODY>}
@Override
public void appendText(@NotNull BasedSequence text) {
getCurrentText().add(text);
}
@Override
public void appendText(@NotNull BasedSequence text, int beginIndex, int endIndex) {
getCurrentText().add(text.subSequence(beginIndex, endIndex));
}
@Override
public void appendNode(@NotNull Node node) {
flushTextNode();
block.appendChild(node);
}
// In some cases, we don't want the text to be appended to an existing node, we need it separate
@NotNull
@Override
public Text appendSeparateText(@NotNull BasedSequence text) {
Text node = new Text(text);
appendNode(node);
return node;
}
@Override
public boolean flushTextNode() {
if (currentText != null) {
block.appendChild(new Text(SegmentedSequence.create(input, currentText)));
currentText = null;
return true;
}
return false;
}
/**
* If RE matches at current index in the input, advance index and return the match; otherwise return null.
*
* @param re pattern to match
* @return sequence matched or null
*/
@Override
public BasedSequence match(Pattern re) {
if (index >= input.length()) {
return null;
}
Matcher matcher = re.matcher(input);
matcher.region(index, input.length());
boolean m = matcher.find();
if (m) {
index = matcher.end();
MatchResult result = matcher.toMatchResult();
return input.subSequence(result.start(), result.end());
} else {
return null;
}
}
/**
* If RE matches at current index in the input, advance index and return the match; otherwise return null.
*
* @param re pattern to match
* @return sequence matched or null
*/
@Override
public BasedSequence[] matchWithGroups(Pattern re) {
if (index >= input.length()) {
return null;
}
Matcher matcher = re.matcher(input);
matcher.region(index, input.length());
boolean m = matcher.find();
if (m) {
index = matcher.end();
MatchResult result = matcher.toMatchResult();
int iMax = matcher.groupCount() + 1;
BasedSequence[] results = new BasedSequence[iMax];
results[0] = input.subSequence(result.start(), result.end());
for (int i = 1; i < iMax; i++) {
if (matcher.group(i) != null) {
results[i] = input.subSequence(result.start(i), result.end(i));
} else {
results[i] = null;
}
}
return results;
} else {
return null;
}
}
/**
* If RE matches at current index in the input, advance index and return the match; otherwise return null.
*
* @param re pattern to match
* @return matched matcher or null
*/
@Override
public Matcher matcher(Pattern re) {
if (index >= input.length()) {
return null;
}
Matcher matcher = re.matcher(input);
matcher.region(index, input.length());
boolean m = matcher.find();
if (m) {
index = matcher.end();
return matcher;
} else {
return null;
}
}
/**
* @return the char at the current input index, or {@code '\0'} in case there are no more characters.
*/
@Override
public char peek() {
if (index < input.length()) {
return input.charAt(index);
} else {
return SequenceUtils.NUL;
}
}
@Override
public char peek(int ahead) {
if (index + ahead < input.length()) {
return input.charAt(index + ahead);
} else {
return SequenceUtils.NUL;
}
}
/**
* Parse zero or more space characters, including at most one newline and zero or more spaces.
*
* @return true
*/
@Override
public boolean spnl() {
match(myParsing.SPNL);
return true;
}
/**
* Parse zero or more non-indent spaces
*
* @return true
*/
@Override
public boolean nonIndentSp() {
match(myParsing.SPNI);
return true;
}
/**
* Parse zero or more spaces
*
* @return true
*/
@Override
public boolean sp() {
match(myParsing.SP);
return true;
}
/**
* Parse zero or more space characters, including at one newline.
*
* @return true
*/
@Override
public boolean spnlUrl() {
return match(myParsing.SPNL_URL) != null;
}
/**
* Parse to end of line, including EOL
*
* @return characters parsed or null if no end of line
*/
@Nullable
@Override
public BasedSequence toEOL() {
return match(myParsing.REST_OF_LINE);
}
}
|
if (fromNode != toNode) {
Node next = fromNode.getNext();
while (next != null) {
Node nextNode = next.getNext();
next.unlink();
fromNode.appendChild(next);
if (next == toNode) break;
next = nextNode;
}
}
fromNode.setCharsFromContent();
| 1,873
| 100
| 1,973
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/block/AbstractBlockParser.java
|
AbstractBlockParser
|
removeBlankLines
|
class AbstractBlockParser implements BlockParser {
private MutableDataSet mutableData = null;
private boolean isClosed = false;
@Override
public boolean isClosed() {
return isClosed;
}
@Override
public boolean isContainer() {
return false;
}
@Override
public boolean isInterruptible() {
return false;
}
@Override
public boolean isRawText() {
return false;
}
@Override
public boolean canContain(ParserState state, BlockParser blockParser, Block block) {
return false;
}
@Override
public boolean isParagraphParser() {
return false;
}
/**
* should be overridden in BlockQuote, FencedCode and ListItem
*
* @param lastMatchedBlockParser the last matched block parser instance
* @return true if the blank line should be propagated to parent
*/
@Override
public boolean isPropagatingLastBlankLine(BlockParser lastMatchedBlockParser) {
return true;
}
@Override
public BlockContent getBlockContent() {
return null;
}
@Override
public void addLine(ParserState state, BasedSequence line) {
}
@Override
public void parseInlines(InlineParser inlineParser) {
}
@Override
public boolean breakOutOnDoubleBlankLine() {
return false;
}
@Override
final public void finalizeClosedBlock() {
mutableData = null;
isClosed = true;
}
@Override
public boolean canInterruptBy(BlockParserFactory blockParserFactory) {
return true;
}
@Override
public MutableDataHolder getDataHolder() {
if (mutableData == null) {
mutableData = new MutableDataSet();
}
return mutableData;
}
public void removeBlankLines() {<FILL_FUNCTION_BODY>}
}
|
// need to remove blank lines, these were used to extend block quote chars to include blank lines
Node child = getBlock().getFirstChild();
while (child != null) {
Node next = child.getNext();
if (child instanceof BlankLine) {
child.unlink();
}
child = next;
}
| 514
| 88
| 602
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/block/NodePostProcessorFactory.java
|
NodePostProcessorFactory
|
addNodes
|
class NodePostProcessorFactory implements PostProcessorFactory {
final private HashMap<Class<?>, Set<Class<?>>> NODE_MAP = new HashMap<>();
// added to force constructor
public NodePostProcessorFactory(boolean ignored) {
}
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return null;
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return null;
}
@Override
final public boolean affectsGlobalScope() {
return false;
}
protected final void addNodeWithExclusions(Class<? extends Node> nodeType, Class<?>... excludeDescendantsOf) {
if (excludeDescendantsOf.length > 0) {
NODE_MAP.put(nodeType, new HashSet<>(Arrays.asList(excludeDescendantsOf)));
} else {
addNodes(nodeType);
}
}
protected final void addNodes(Class<?>... nodeTypes) {<FILL_FUNCTION_BODY>}
@Override
final public Map<Class<?>, Set<Class<?>>> getNodeTypes() {
return NODE_MAP;
}
@NotNull
@Override
abstract public NodePostProcessor apply(@NotNull Document document);
}
|
for (Class<?> nodeType : nodeTypes) {
//noinspection unchecked
NODE_MAP.put(nodeType, Collections.EMPTY_SET);
}
| 339
| 50
| 389
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/BlockQuoteParser.java
|
BlockFactory
|
tryStart
|
class BlockFactory extends AbstractBlockParserFactory {
final private boolean allowLeadingSpace;
final private boolean interruptsParagraph;
final private boolean interruptsItemParagraph;
final private boolean withLeadSpacesInterruptsItemParagraph;
BlockFactory(DataHolder options) {
super(options);
allowLeadingSpace = Parser.BLOCK_QUOTE_ALLOW_LEADING_SPACE.get(options);
interruptsParagraph = Parser.BLOCK_QUOTE_INTERRUPTS_PARAGRAPH.get(options);
interruptsItemParagraph = Parser.BLOCK_QUOTE_INTERRUPTS_ITEM_PARAGRAPH.get(options);
withLeadSpacesInterruptsItemParagraph = Parser.BLOCK_QUOTE_WITH_LEAD_SPACES_INTERRUPTS_ITEM_PARAGRAPH.get(options);
}
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {<FILL_FUNCTION_BODY>}
}
|
int nextNonSpace = state.getNextNonSpaceIndex();
BlockParser matched = matchedBlockParser.getBlockParser();
boolean inParagraph = matched.isParagraphParser();
boolean inParagraphListItem = inParagraph && matched.getBlock().getParent() instanceof ListItem && matched.getBlock() == matched.getBlock().getParent().getFirstChild();
if (isMarker(state, nextNonSpace, inParagraph, inParagraphListItem, allowLeadingSpace, interruptsParagraph, interruptsItemParagraph, withLeadSpacesInterruptsItemParagraph)) {
int newColumn = state.getColumn() + state.getIndent() + 1;
// optional following space or tab
if (Parsing.isSpaceOrTab(state.getLine(), nextNonSpace + 1)) {
newColumn++;
}
return BlockStart.of(new BlockQuoteParser(state.getProperties(), state.getLine().subSequence(nextNonSpace, nextNonSpace + 1))).atColumn(newColumn);
} else {
return BlockStart.none();
}
| 267
| 266
| 533
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/FencedCodeBlockParser.java
|
FencedCodeBlockParser
|
closeBlock
|
class FencedCodeBlockParser extends AbstractBlockParser {
final private static Pattern OPENING_FENCE = Pattern.compile("^`{3,}(?!.*`)|^~{3,}(?!.*~)");
final private static Pattern CLOSING_FENCE = Pattern.compile("^(?:`{3,}|~{3,})(?=[ \t]*$)");
final private FencedCodeBlock block = new FencedCodeBlock();
private BlockContent content = new BlockContent();
final private char fenceChar;
final private int fenceLength;
final private int fenceIndent;
final private int fenceMarkerIndent;
final private boolean matchingCloser;
final private boolean codeContentBlock;
public FencedCodeBlockParser(DataHolder options, char fenceChar, int fenceLength, int fenceIndent, int fenceMarkerIndent) {
this.fenceChar = fenceChar;
this.fenceLength = fenceLength;
this.fenceIndent = fenceIndent;
this.fenceMarkerIndent = fenceIndent + fenceMarkerIndent;
this.matchingCloser = Parser.MATCH_CLOSING_FENCE_CHARACTERS.get(options);
this.codeContentBlock = Parser.FENCED_CODE_CONTENT_BLOCK.get(options);
}
@Override
public Block getBlock() {
return block;
}
public int getFenceIndent() {
return fenceIndent;
}
public int getFenceMarkerIndent() {
return fenceMarkerIndent;
}
@Override
public BlockContinue tryContinue(ParserState state) {
int nextNonSpace = state.getNextNonSpaceIndex();
int newIndex = state.getIndex();
BasedSequence line = state.getLine();
Matcher matcher;
boolean matches = (state.getIndent() <= 3 &&
nextNonSpace < line.length() &&
(!matchingCloser || line.charAt(nextNonSpace) == fenceChar));
if (matches) {
BasedSequence trySequence = line.subSequence(nextNonSpace, line.length());
matcher = CLOSING_FENCE.matcher(trySequence);
if (matcher.find()) {
int foundFenceLength = matcher.group(0).length();
if (foundFenceLength >= fenceLength) {
// closing fence - we're at end of line, so we can finalize now
block.setClosingMarker(trySequence.subSequence(0, foundFenceLength));
return BlockContinue.finished();
}
}
}
// skip optional spaces of fence indent
int i = fenceIndent;
while (i > 0 && newIndex < line.length() && line.charAt(newIndex) == ' ') {
newIndex++;
i--;
}
return BlockContinue.atIndex(newIndex);
}
@Override
public void addLine(ParserState state, BasedSequence line) {
content.add(line, state.getIndent());
}
@Override
public boolean isPropagatingLastBlankLine(BlockParser lastMatchedBlockParser) {
return false;
}
@Override
public void closeBlock(ParserState state) {<FILL_FUNCTION_BODY>}
public static class Factory implements CustomBlockParserFactory {
@Nullable
@Override
public Set<Class<?>> getAfterDependents() {
return new HashSet<>(Arrays.asList(
BlockQuoteParser.Factory.class,
HeadingParser.Factory.class
//FencedCodeBlockParser.Factory.class,
//HtmlBlockParser.Factory.class,
//ThematicBreakParser.Factory.class,
//ListBlockParser.Factory.class,
//IndentedCodeBlockParser.Factory.class
));
}
@Nullable
@Override
public Set<Class<?>> getBeforeDependents() {
return new HashSet<>(Arrays.asList(
//BlockQuoteParser.Factory.class,
//HeadingParser.Factory.class,
//FencedCodeBlockParser.Factory.class,
HtmlBlockParser.Factory.class,
ThematicBreakParser.Factory.class,
ListBlockParser.Factory.class,
IndentedCodeBlockParser.Factory.class
));
}
@Override
public boolean affectsGlobalScope() {
return false;
}
@NotNull
@Override
public BlockParserFactory apply(@NotNull DataHolder options) {
return new BlockFactory(options);
}
}
private static class BlockFactory extends AbstractBlockParserFactory {
private BlockFactory(DataHolder options) {
super(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {
int nextNonSpace = state.getNextNonSpaceIndex();
BasedSequence line = state.getLine();
Matcher matcher;
if (state.getIndent() < 4) {
BasedSequence trySequence = line.subSequence(nextNonSpace, line.length());
if ((matcher = OPENING_FENCE.matcher(trySequence)).find()) {
int fenceLength = matcher.group(0).length();
char fenceChar = matcher.group(0).charAt(0);
FencedCodeBlockParser blockParser = new FencedCodeBlockParser(state.getProperties(), fenceChar, fenceLength, state.getIndent(), nextNonSpace);
blockParser.block.setOpeningMarker(trySequence.subSequence(0, fenceLength));
return BlockStart.of(blockParser).atIndex(nextNonSpace + fenceLength);
}
}
return BlockStart.none();
}
}
}
|
// first line, if not blank, has the info string
List<BasedSequence> lines = content.getLines();
if (lines.size() > 0) {
BasedSequence info = lines.get(0);
if (!info.isBlank()) {
block.setInfo(info.trim());
}
BasedSequence chars = content.getSpanningChars();
BasedSequence spanningChars = chars.baseSubSequence(chars.getStartOffset(), lines.get(0).getEndOffset());
if (lines.size() > 1) {
// have more lines
List<BasedSequence> segments = lines.subList(1, lines.size());
block.setContent(spanningChars, segments);
if (codeContentBlock) {
CodeBlock codeBlock = new CodeBlock();
codeBlock.setContent(segments);
codeBlock.setCharsFromContent();
block.appendChild(codeBlock);
} else {
Text codeBlock = new Text(SegmentedSequence.create(chars, segments));
block.appendChild(codeBlock);
}
} else {
block.setContent(spanningChars, BasedSequence.EMPTY_LIST);
}
} else {
block.setContent(content);
}
block.setCharsFromContent();
content = null;
| 1,442
| 336
| 1,778
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/HeadingParser.java
|
BlockFactory
|
tryStart
|
class BlockFactory extends AbstractBlockParserFactory {
final private HeadingOptions options;
final private HeadingParsing myParsing;
BlockFactory(DataHolder options) {
super(options);
this.options = new HeadingOptions(options);
this.myParsing = new HeadingParsing(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {<FILL_FUNCTION_BODY>}
}
|
if (state.getIndent() >= 4 || options.noLeadSpace && state.getIndent() >= 1) {
return BlockStart.none();
}
if (state.getActiveBlockParser() instanceof FencedCodeBlockParser) {
return BlockStart.none();
}
if (!options.canInterruptItemParagraph) {
BlockParser matched = matchedBlockParser.getBlockParser();
boolean inParagraph = matched.isParagraphParser();
boolean inParagraphListItem = inParagraph && matched.getBlock().getParent() instanceof ListItem && matched.getBlock() == matched.getBlock().getParent().getFirstChild();
if (inParagraphListItem) {
return BlockStart.none();
}
}
BasedSequence line = state.getLine();
int nextNonSpace = state.getNextNonSpaceIndex();
BasedSequence paragraph = matchedBlockParser.getParagraphContent();
Matcher matcher;
BasedSequence trySequence = line.subSequence(nextNonSpace, line.length());
matcher = myParsing.ATX_HEADING.matcher(trySequence);
if (matcher.find()) {
// ATX heading
int newOffset = nextNonSpace + matcher.group(0).length();
int openingStart = matcher.start();
int openingEnd = matcher.end();
BasedSequence openingMarker = trySequence.subSequence(openingStart, openingEnd).trim();
int level = openingMarker.length(); // number of #s
BlockContent content = new BlockContent();
content.add(state.getLineWithEOL().subSequence(newOffset), state.getIndent());
BasedSequence headerText = trySequence.subSequence(openingEnd);
BasedSequence closingMarker = null;
matcher = myParsing.ATX_TRAILING.matcher(headerText);
if (matcher.find()) {
// removeIndex trailing ###s:
int closingStart = matcher.start();
int closingEnd = matcher.end();
closingMarker = headerText.subSequence(closingStart, closingEnd).trim();
headerText = headerText.subSequence(0, closingStart);
}
HeadingParser headingParser = new HeadingParser(level);
headingParser.block.setOpeningMarker(openingMarker);
headingParser.block.setText(headerText.trim());
headingParser.block.setClosingMarker(closingMarker);
headingParser.block.setCharsFromContent();
return BlockStart.of(headingParser)
.atIndex(line.length());
} else {
if ((matcher = myParsing.SETEXT_HEADING.matcher(trySequence)).find()) {
if (paragraph != null) {
// setext heading line
int level = matcher.group(0).charAt(0) == '=' ? 1 : 2;
BlockContent content = new BlockContent();
content.addAll(matchedBlockParser.getParagraphLines(), matchedBlockParser.getParagraphEolLengths());
BasedSequence headingText = content.getContents().trim();
BasedSequence closingMarker = line.trim();
HeadingParser headingParser = new HeadingParser(level);
headingParser.block.setText(headingText);
headingParser.block.setClosingMarker(closingMarker);
headingParser.block.setCharsFromContent();
return BlockStart.of(headingParser)
.atIndex(line.length())
.replaceActiveBlockParser();
} else {
return BlockStart.none();
}
} else {
return BlockStart.none();
}
}
| 125
| 903
| 1,028
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/HtmlBlockParser.java
|
BlockFactory
|
tryStart
|
class BlockFactory extends AbstractBlockParserFactory {
private Patterns myPatterns = null;
final private boolean myHtmlCommentBlocksInterruptParagraph;
final private boolean myHtmlBlockDeepParser;
final private boolean myHtmlBlockDeepParseNonBlock;
final private boolean myHtmlBlockDeepParseFirstOpenTagOnOneLine;
final private boolean myHtmlBlockCommentOnlyFullLine;
final private boolean myHtmlBlockStartOnlyOnBlockTags;
private BlockFactory(DataHolder options) {
super(options);
myHtmlCommentBlocksInterruptParagraph = Parser.HTML_COMMENT_BLOCKS_INTERRUPT_PARAGRAPH.get(options);
this.myHtmlBlockDeepParser = Parser.HTML_BLOCK_DEEP_PARSER.get(options);
this.myHtmlBlockDeepParseNonBlock = Parser.HTML_BLOCK_DEEP_PARSE_NON_BLOCK.get(options);
this.myHtmlBlockDeepParseFirstOpenTagOnOneLine = Parser.HTML_BLOCK_DEEP_PARSE_FIRST_OPEN_TAG_ON_ONE_LINE.get(options);
this.myHtmlBlockCommentOnlyFullLine = Parser.HTML_BLOCK_COMMENT_ONLY_FULL_LINE.get(options);
this.myHtmlBlockStartOnlyOnBlockTags = Parser.HTML_BLOCK_START_ONLY_ON_BLOCK_TAGS.get(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {<FILL_FUNCTION_BODY>}
}
|
int nextNonSpace = state.getNextNonSpaceIndex();
BasedSequence line = state.getLine();
if (state.getIndent() < 4 && line.charAt(nextNonSpace) == '<' && !(matchedBlockParser.getBlockParser() instanceof HtmlBlockParser)) {
if (myHtmlBlockDeepParser) {
HtmlDeepParser deepParser = new HtmlDeepParser(Parser.HTML_BLOCK_TAGS.get(state.getProperties()));
deepParser.parseHtmlChunk(line.subSequence(nextNonSpace, line.length()), myHtmlBlockStartOnlyOnBlockTags, myHtmlBlockDeepParseNonBlock, myHtmlBlockDeepParseFirstOpenTagOnOneLine);
if (deepParser.hadHtml()) {
// have our html block start
if ((deepParser.getHtmlMatch() == OPEN_TAG || (!myHtmlCommentBlocksInterruptParagraph && deepParser.getHtmlMatch() == COMMENT))
&& (!deepParser.isFirstBlockTag() && matchedBlockParser.getBlockParser().getBlock() instanceof Paragraph)) {
} else {
// not paragraph or can interrupt paragraph
return BlockStart.of(new HtmlBlockParser(state.getProperties(), null, deepParser.getHtmlMatch() == COMMENT, deepParser)).atIndex(state.getIndex());
}
}
} else {
for (int blockType = 1; blockType <= 7; blockType++) {
// Type 7 cannot interrupt a paragraph or may not start a block altogether
if (blockType == 7 && (myHtmlBlockStartOnlyOnBlockTags || matchedBlockParser.getBlockParser().getBlock() instanceof Paragraph)) {
continue;
}
if (myPatterns == null) {
myPatterns = new Patterns(state.getParsing(), state.getProperties());
}
Pattern opener = myPatterns.BLOCK_PATTERNS[blockType][0];
Pattern closer = myPatterns.BLOCK_PATTERNS[blockType][1];
Matcher matcher = opener.matcher(line.subSequence(nextNonSpace, line.length()));
boolean matches = matcher.find();
// TEST: non-interrupting of paragraphs by HTML comments
if (matches && (myHtmlCommentBlocksInterruptParagraph || blockType != myPatterns.COMMENT_PATTERN_INDEX || !(matchedBlockParser.getBlockParser() instanceof ParagraphParser))) {
// Issue #158, HTML Comment followed by text
if (blockType == myPatterns.COMMENT_PATTERN_INDEX && myHtmlBlockCommentOnlyFullLine) {
Matcher endMatcher = myPatterns.BLOCK_PATTERNS[myPatterns.COMMENT_PATTERN_INDEX][1].matcher(line.subSequence(matcher.end(), line.length()));
if (endMatcher.find()) {
// see if nothing follows
BasedSequence trailing = line.subSequence(endMatcher.end(), line.length()).trim();
if (!trailing.equals("-->")) {
return BlockStart.none();
}
}
}
return BlockStart.of(new HtmlBlockParser(state.getProperties(), closer, blockType == myPatterns.COMMENT_PATTERN_INDEX, null)).atIndex(state.getIndex());
}
}
}
}
return BlockStart.none();
| 396
| 835
| 1,231
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/IndentedCodeBlockParser.java
|
BlockFactory
|
tryStart
|
class BlockFactory extends AbstractBlockParserFactory {
private BlockFactory(DataHolder options) {
super(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {<FILL_FUNCTION_BODY>}
}
|
// An indented code block cannot interrupt a paragraph.
if (state.getIndent() >= state.getParsing().CODE_BLOCK_INDENT && !state.isBlank() && !(state.getActiveBlockParser().getBlock() instanceof Paragraph)) {
return BlockStart.of(new IndentedCodeBlockParser(state.getProperties())).atColumn(state.getColumn() + state.getParsing().CODE_BLOCK_INDENT);
} else {
return BlockStart.none();
}
| 71
| 128
| 199
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/ParagraphParser.java
|
ParagraphParser
|
addLine
|
class ParagraphParser extends AbstractBlockParser {
final private Paragraph block = new Paragraph();
private BlockContent content = new BlockContent();
public BlockContent getBlockContent() {
return content;
}
@Override
public Paragraph getBlock() {
return block;
}
@Override
public BlockContinue tryContinue(ParserState state) {
if (!state.isBlank()) {
// NOTE: here we can continue with any indent, unless the parent is a list item and the indent is >= code indent
return BlockContinue.atIndex(state.getIndex());
} else {
boolean blankLine = state.isBlankLine();
block.setTrailingBlankLine(blankLine);
return BlockContinue.none();
}
}
@Override
public void addLine(ParserState state, BasedSequence line) {<FILL_FUNCTION_BODY>}
@Override
public boolean isParagraphParser() {
return true;
}
@Override
public boolean isInterruptible() {
return true;
}
@Override
public void closeBlock(ParserState state) {
block.setContent(content);
content = null;
}
@Override
public void parseInlines(InlineParser inlineParser) {
inlineParser.parse(getBlock().getContentChars(), getBlock());
}
public static class Factory implements BlockParserFactory {
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {
return null;
}
}
}
|
int indent = state.getIndent();
if (indent > 0) {
content.add(PrefixedSubSequence.repeatOf(' ', indent, line), indent);
} else {
content.add(line, indent);
}
| 404
| 66
| 470
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/ThematicBreakParser.java
|
BlockFactory
|
tryStart
|
class BlockFactory extends AbstractBlockParserFactory {
final private ThematicBreakOptions options;
BlockFactory(DataHolder options) {
super(options);
this.options = new ThematicBreakOptions(options);
}
@Override
public BlockStart tryStart(ParserState state, MatchedBlockParser matchedBlockParser) {<FILL_FUNCTION_BODY>}
}
|
if (state.getIndent() >= 4 || matchedBlockParser.getBlockParser().isParagraphParser() && !options.relaxedStart) {
return BlockStart.none();
}
BasedSequence line = state.getLine();
final BasedSequence input = line.subSequence(state.getNextNonSpaceIndex(), line.length());
if (PATTERN.matcher(input).matches()) {
return BlockStart.of(new ThematicBreakParser(line.subSequence(state.getIndex()))).atIndex(line.length());
} else {
return BlockStart.none();
}
| 95
| 150
| 245
|
<methods>public non-sealed void <init>() ,public void addLine(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.util.sequence.BasedSequence) ,public boolean breakOutOnDoubleBlankLine() ,public boolean canContain(com.vladsch.flexmark.parser.block.ParserState, com.vladsch.flexmark.parser.block.BlockParser, com.vladsch.flexmark.util.ast.Block) ,public boolean canInterruptBy(com.vladsch.flexmark.parser.block.BlockParserFactory) ,public final void finalizeClosedBlock() ,public com.vladsch.flexmark.util.ast.BlockContent getBlockContent() ,public com.vladsch.flexmark.util.data.MutableDataHolder getDataHolder() ,public boolean isClosed() ,public boolean isContainer() ,public boolean isInterruptible() ,public boolean isParagraphParser() ,public boolean isPropagatingLastBlankLine(com.vladsch.flexmark.parser.block.BlockParser) ,public boolean isRawText() ,public void parseInlines(com.vladsch.flexmark.parser.InlineParser) ,public void removeBlankLines() <variables>private boolean isClosed,private com.vladsch.flexmark.util.data.MutableDataSet mutableData
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/delimiter/Bracket.java
|
Bracket
|
isStraddling
|
class Bracket {
final private Text node;
final private int index;
final private boolean image;
/**
* Previous bracket.
*/
final private Bracket previous;
/**
* Previous delimiter (emphasis, etc) before this bracket.
*/
final private Delimiter previousDelimiter;
/**
* Whether this bracket is allowed to form a link/image (also known as "active").
*/
private boolean allowed = true;
/**
* Whether there is an unescaped bracket (opening or closing) anywhere after this opening bracket.
* determined by next != null
*/
private boolean bracketAfter = false;
public boolean isAllowed() {
return allowed;
}
public void setAllowed(boolean allowed) {
this.allowed = allowed;
}
public boolean isBracketAfter() {
return bracketAfter;
}
public void setBracketAfter(boolean bracketAfter) {
this.bracketAfter = bracketAfter;
}
public Bracket getPrevious() {
return previous;
}
public boolean isImage() {
return image;
}
public Delimiter getPreviousDelimiter() {
return previousDelimiter;
}
public int getStartIndex() {
return index;
}
public int getEndIndex() {
return image ? index + 2 : index + 1;
}
public Text getNode() {
return node;
}
public static Bracket link(BasedSequence input, Text node, int index, Bracket previous, Delimiter previousDelimiter) {
return new Bracket(input, node, index, previous, previousDelimiter, false);
}
public static Bracket image(BasedSequence input, Text node, int index, Bracket previous, Delimiter previousDelimiter) {
return new Bracket(input, node, index, previous, previousDelimiter, true);
}
private Bracket(BasedSequence input, Text node, int index, Bracket previous, Delimiter previousDelimiter, boolean image) {
this.node = node;
this.index = index;
this.image = image;
this.previous = previous;
this.previousDelimiter = previousDelimiter;
}
public boolean isStraddling(BasedSequence nodeChars) {<FILL_FUNCTION_BODY>}
}
|
// first see if we have any closers in our span
int startOffset = nodeChars.getStartOffset();
int endOffset = nodeChars.getEndOffset();
Delimiter inner = previousDelimiter == null ? null : previousDelimiter.getNext();
while (inner != null) {
int innerOffset = inner.getEndIndex();
if (innerOffset >= endOffset) break;
if (innerOffset >= startOffset) {
// inside our region, if unmatched then we are straddling the region
if (!inner.isMatched()) return true;
}
inner = inner.getNext();
}
return false;
| 617
| 166
| 783
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/delimiter/Delimiter.java
|
Delimiter
|
convertDelimitersToText
|
class Delimiter implements DelimiterRun {
final private Text node;
final private BasedSequence input;
final private char delimiterChar;
private int index;
/**
* Can open emphasis, see spec.
*/
final private boolean canOpen;
/**
* Can close emphasis, see spec.
*/
final private boolean canClose;
/**
* Skip this delimiter when looking for a link/image opener because it was already matched.
*/
private boolean matched = false;
private Delimiter previous;
private Delimiter next;
private int numDelims = 1;
@Override
public Delimiter getPrevious() {
return previous;
}
@Override
public Delimiter getNext() {
return next;
}
public void setMatched(boolean matched) {
this.matched = matched;
}
public void setPrevious(Delimiter previous) {
this.previous = previous;
}
public void setNext(Delimiter next) {
this.next = next;
}
public void setNumDelims(int numDelims) {
this.numDelims = numDelims;
}
@Override
public char getDelimiterChar() {
return delimiterChar;
}
public boolean isMatched() {
return matched;
}
public int getNumDelims() {
return numDelims;
}
@Override
public Text getNode() {
return node;
}
public BasedSequence getInput() {
return input;
}
public int getStartIndex() {
return index;
}
public int getEndIndex() {
return index + numDelims;
}
public int getIndex() {
return index;
}
public void setIndex(int index) {
this.index = index;
}
public BasedSequence getTailChars(int delimiterUse) {
return input.subSequence(getEndIndex() - delimiterUse, getEndIndex());
}
public BasedSequence getLeadChars(int delimiterUse) {
return input.subSequence(getStartIndex(), getStartIndex() + delimiterUse);
}
public Delimiter(BasedSequence input, Text node, char delimiterChar, boolean canOpen, boolean canClose, Delimiter previous, int index) {
this.input = input;
this.node = node;
this.delimiterChar = delimiterChar;
this.canOpen = canOpen;
this.canClose = canClose;
this.previous = previous;
this.index = index;
}
public Text getPreviousNonDelimiterTextNode() {
Node previousNode = node.getPrevious();
if (previousNode instanceof Text && (this.previous == null || this.previous.node != previousNode)) {
return (Text) previousNode;
} else {
return null;
}
}
public Text getNextNonDelimiterTextNode() {
Node nextNode = node.getNext();
if (nextNode instanceof Text && (this.next == null || this.next.node != nextNode)) {
return (Text) nextNode;
} else {
return null;
}
}
public void moveNodesBetweenDelimitersTo(DelimitedNode delimitedNode, Delimiter closer) {
Node tmp = getNode().getNext();
while (tmp != null && tmp != closer.getNode()) {
Node next = tmp.getNext();
((Node) delimitedNode).appendChild(tmp);
tmp = next;
}
delimitedNode.setText(input.subSequence(getEndIndex(), closer.getStartIndex()));
getNode().insertAfter((Node) delimitedNode);
}
public void convertDelimitersToText(int delimitersUsed, Delimiter closer) {<FILL_FUNCTION_BODY>}
@Override
public boolean canOpen() {
return canOpen;
}
@Override
public boolean canClose() {
return canClose;
}
@Override
public int length() {
return numDelims;
}
}
|
Text openerText = new Text();
openerText.setChars(getTailChars(delimitersUsed));
Text closerText = new Text();
closerText.setChars(closer.getLeadChars(delimitersUsed));
getNode().insertAfter(openerText);
closer.getNode().insertBefore(closerText);
| 1,085
| 92
| 1,177
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/core/delimiter/EmphasisDelimiterProcessor.java
|
EmphasisDelimiterProcessor
|
getDelimiterUse
|
class EmphasisDelimiterProcessor implements DelimiterProcessor {
final private char delimiterChar;
final private int multipleUse;
protected EmphasisDelimiterProcessor(char delimiterChar, boolean strongWrapsEmphasis) {
this.delimiterChar = delimiterChar;
this.multipleUse = strongWrapsEmphasis ? 1 : 2;
}
@Override
public char getOpeningCharacter() {
return delimiterChar;
}
@Override
public char getClosingCharacter() {
return delimiterChar;
}
@Override
public int getMinLength() {
return 1;
}
@Override
public boolean canBeOpener(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return leftFlanking;
}
@Override
public boolean canBeCloser(String before, String after, boolean leftFlanking, boolean rightFlanking, boolean beforeIsPunctuation, boolean afterIsPunctuation, boolean beforeIsWhitespace, boolean afterIsWhiteSpace) {
return rightFlanking;
}
@Override
public boolean skipNonOpenerCloser() {
return false;
}
@Override
public Node unmatchedDelimiterNode(InlineParser inlineParser, DelimiterRun delimiter) {
return null;
}
@Override
public int getDelimiterUse(DelimiterRun opener, DelimiterRun closer) {<FILL_FUNCTION_BODY>}
@Override
public void process(Delimiter opener, Delimiter closer, int delimitersUsed) {
DelimitedNode emphasis = delimitersUsed == 1
? new Emphasis(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed))
: new StrongEmphasis(opener.getTailChars(delimitersUsed), BasedSequence.NULL, closer.getLeadChars(delimitersUsed));
opener.moveNodesBetweenDelimitersTo(emphasis, closer);
}
}
|
// "multiple of 3" rule for internal delimiter runs
if ((opener.canClose() || closer.canOpen()) && (opener.length() + closer.length()) % 3 == 0) {
return 0;
}
// calculate actual number of delimiters used from this closer
if (opener.length() < 3 || closer.length() < 3) {
return Utils.min(closer.length(), opener.length());
} else {
// default to latest spec
return closer.length() % 2 == 0 ? 2 : multipleUse;
}
| 570
| 151
| 721
|
<no_super_class>
|
vsch_flexmark-java
|
flexmark-java/flexmark/src/main/java/com/vladsch/flexmark/parser/internal/PostProcessorManager.java
|
PostProcessorManager
|
prioritizePostProcessors
|
class PostProcessorManager {
// @SuppressWarnings("MismatchedQueryAndUpdateOfCollection")
// final private static HashMap<DataKey<Boolean>, PostProcessorFactory> CORE_POST_PROCESSORS = new HashMap<>();
// static {
// //CORE_POST_PROCESSORS.put(Parser.REFERENCE_PARAGRAPH_PRE_PROCESSOR, new ReferencePreProcessorFactory());
// }
final private List<PostProcessorDependencyStage> postProcessorDependencies;
final private OrderedSet<Node> allPostProcessNodes = new OrderedSet<>();
public PostProcessorManager(List<PostProcessorDependencyStage> postProcessorDependencies) {
this.postProcessorDependencies = postProcessorDependencies;
}
public static List<PostProcessorDependencyStage> calculatePostProcessors(DataHolder options, List<PostProcessorFactory> postProcessorFactories) {
// By having the custom factories come first, extensions are able to change behavior of core syntax.
// List<PostProcessorFactory> list = new ArrayList<>(postProcessorFactories);
//
// // add core block preprocessors
// for (DataKey<Boolean> processorDataKey : CORE_POST_PROCESSORS.keySet()) {
// if (processorDataKey.get(options)) {
// PostProcessorFactory preProcessorFactory = CORE_POST_PROCESSORS.get(processorDataKey);
// list.add(preProcessorFactory);
// }
// }
List<List<PostProcessorFactory>> resolveDependencies = DependencyResolver.resolveDependencies(postProcessorFactories, PostProcessorManager::prioritizePostProcessors, null);
ArrayList<PostProcessorDependencyStage> dependencyStages = new ArrayList<>(resolveDependencies.size());
for (List<PostProcessorFactory> dependencies : resolveDependencies) {
dependencyStages.add(new PostProcessorDependencyStage(dependencies));
}
return dependencyStages;
}
public static Document processDocument(Document document, List<PostProcessorDependencyStage> processorDependencies) {
if (!processorDependencies.isEmpty()) {
PostProcessorManager manager = new PostProcessorManager(processorDependencies);
document = manager.postProcess(document);
}
return document;
}
public Document postProcess(Document document) {
// first initialize node tracker if
ClassifyingNodeTracker classifyingNodeTracker;
classifyingNodeTracker = null;
for (PostProcessorDependencyStage stage : postProcessorDependencies) {
// idiosyncrasy of post processors the last dependency can be global, in which case it processes the whole document and no ancestry info is
// provided
//new ClassifyingNodeTracker()
boolean hadGlobal = false;
for (PostProcessorFactory dependent : stage.dependents) {
if (dependent.affectsGlobalScope()) {
document = dependent.apply(document).processDocument(document);
hadGlobal = true;
// assume it no longer reflects reality;
classifyingNodeTracker = null;
} else {
assert !hadGlobal;
if (classifyingNodeTracker == null) {
// build the node type information by traversing the document tree
classifyingNodeTracker = new NodeClassifierVisitor(stage.myNodeMap).classify(document);
}
Map<Class<?>, Set<Class<?>>> dependentNodeTypes = dependent.getNodeTypes();
PostProcessor postProcessor = dependent.apply(document);
BitSet exclusionSet = new BitSet();
if (dependentNodeTypes != null) {
for (Set<Class<?>> excluded : dependentNodeTypes.values()) {
BitSet mapped = classifyingNodeTracker.getExclusionSet().indexBitSet(excluded);
exclusionSet.or(mapped);
}
ReversibleIterable<Node> nodes = classifyingNodeTracker.getCategoryItems(Node.class, dependentNodeTypes.keySet());
for (Node node : nodes) {
if (node.getParent() == null) continue; // was already removed
// now we need to get the bitset for the excluded ancestors of the node, then intersect it with the actual ancestors of this factory
int index;
BitSet nodeAncestors;
BitSet nodeExclusions;
Set<Class<?>> excluded = dependentNodeTypes.get(node.getClass());
if (excluded != null) {
index = classifyingNodeTracker.getItems().indexOf(node);
if (index != -1) {
nodeAncestors = classifyingNodeTracker.getNodeAncestryMap().get(index);
if (nodeAncestors != null) {
nodeExclusions = classifyingNodeTracker.getExclusionSet().indexBitSet(excluded);
nodeExclusions.and(nodeAncestors);
if (!nodeExclusions.isEmpty()) {
// has excluded ancestor
continue;
}
}
}
}
postProcessor.process(classifyingNodeTracker, node);
}
}
}
}
}
return document;
}
static DependentItemMap<PostProcessorFactory> prioritizePostProcessors(DependentItemMap<PostProcessorFactory> dependentMap) {<FILL_FUNCTION_BODY>}
public static class PostProcessorDependencyStage {
final Map<Class<? extends Node>, Set<Class<?>>> myNodeMap;
final List<PostProcessorFactory> dependents;
public PostProcessorDependencyStage(List<PostProcessorFactory> dependents) {
// compute mappings
HashMap<Class<? extends Node>, Set<Class<?>>> nodeMap = new HashMap<>();
for (PostProcessorFactory dependent : dependents) {
Map<Class<?>, Set<Class<?>>> types = dependent.getNodeTypes();
if ((types == null || types.isEmpty()) && !dependent.affectsGlobalScope()) {
throw new IllegalStateException("PostProcessorFactory " + dependent + " is not document post processor and has empty node map, does nothing, should not be registered.");
}
if (types != null) {
for (Map.Entry<Class<?>, Set<Class<?>>> entry : types.entrySet()) {
if (Node.class.isAssignableFrom(entry.getKey())) {
Set<Class<?>> classes = nodeMap.get(entry.getKey());
Set<Class<?>> value = entry.getValue();
if (classes == null) {
// copy so it is not modified by additional dependencies injecting other exclusions by mistake
classes = new HashSet<>(value);
//noinspection unchecked
nodeMap.put((Class<? extends Node>) entry.getKey(), classes);
} else {
try {
classes.addAll(value);
} catch (UnsupportedOperationException e) {
classes = new HashSet<>(classes);
classes.addAll(value);
}
}
}
}
}
}
this.dependents = dependents;
this.myNodeMap = nodeMap;
}
}
}
|
// put globals last
List<DependentItemMap.Entry<Class<?>, DependentItem<PostProcessorFactory>>> prioritized = dependentMap.entries();
prioritized.sort((e1, e2) -> {
int g1 = e1.getValue().isGlobalScope ? 1 : 0;
int g2 = e2.getValue().isGlobalScope ? 1 : 0;
return g1 - g2;
});
BitSet dependentMapSet = dependentMap.keySet().keyDifferenceBitSet(prioritized);
if (dependentMapSet.isEmpty()) {
return dependentMap;
}
DependentItemMap<PostProcessorFactory> prioritizedMap = new DependentItemMap<>(prioritized.size());
prioritizedMap.addAll(prioritized);
return prioritizedMap;
| 1,750
| 213
| 1,963
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/AbstractDownloader.java
|
AbstractDownloader
|
toByteInputStream
|
class AbstractDownloader implements Downloader {
private static Log log = LogFactory.getLog(AbstractDownloader.class);
private static final Pattern charsetPattern = Pattern.compile("(?i)\\bcharset=\\s*\"?([^\\s;\"]*)");
private String getCharsetFromContentType(String contentType) {
if (contentType == null)
return null;
Matcher m = charsetPattern.matcher(contentType);
if (m.find()) {
return m.group(1).trim().toUpperCase();
}
return null;
}
protected String getCharset(String requestCharset, String contentType) {
//先取contentType的字符集
String charset = getCharsetFromContentType(contentType);
if(charset == null) {
//再取request指定的字符集
charset = requestCharset;
}
if(charset == null) {
//默认采用utf-8
charset = "UTF-8";
}
return charset;
}
/**
* 将原始的inputStream转换为ByteArrayInputStream使raw可以重复使用
*
* @param in 原始的inputStream
* @return 可以重复使用的ByteArrayInputStream
* @throws IOException
*/
protected ByteArrayInputStream toByteInputStream(InputStream in) throws IOException {<FILL_FUNCTION_BODY>}
}
|
ByteArrayInputStream bis = null;
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try {
byte[] b = new byte[1024];
for (int c = 0; (c = in.read(b)) != -1;) {
bos.write(b, 0, c);
}
b = null;
bis = new ByteArrayInputStream(bos.toByteArray());
} catch(EOFException eof){
bis = new ByteArrayInputStream(bos.toByteArray());
log.warn("inputstream " + in.getClass().getName() + " eof!");
}
// 读取 org.apache.http.client.entity.LazyDecompressingInputStream 流时会抛出超时异常
catch(ConnectTimeoutException | SocketTimeoutException e) {
throw e;
} catch (IOException e) {
log.warn("inputstream " + in.getClass().getName() + " don't to byte inputstream!");
return null;
} finally {
try {
in.close();
bos.close();
} catch (IOException e) {
bos = null;
in = null;
}
}
return bis;
| 363
| 325
| 688
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/DownloaderContext.java
|
DownloaderContext
|
defaultDownload
|
class DownloaderContext {
public static HttpResponse download(HttpRequest request) throws DownloadException {
SpiderBeanContext context = SpiderThreadLocal.get().getSpiderBeanContext();
return context.getDownloader().download(request, context.getTimeout());
}
public static HttpResponse defaultDownload(HttpRequest request) throws DownloadException {<FILL_FUNCTION_BODY>}
}
|
SpiderBeanContext context = SpiderThreadLocal.get().getSpiderBeanContext();
Downloader downloader = SpiderThreadLocal.get().getEngine().getSpiderBeanFactory().getDownloaderFactory().defaultDownloader();
return downloader.download(request, context.getTimeout());
| 100
| 73
| 173
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/DownloaderFactory.java
|
DownloaderFactory
|
getDownloader
|
class DownloaderFactory {
public static final String DEFAULT_DOWNLOADER = "httpClientDownloader";
private Map<String, Downloader> downloaders;
public DownloaderFactory(Reflections reflections) {
this.downloaders = new HashMap<String, Downloader>();
Set<Class<?>> classes = reflections.getTypesAnnotatedWith(com.geccocrawler.gecco.annotation.Downloader.class);
for(Class<?> downloaderClass : classes) {
com.geccocrawler.gecco.annotation.Downloader downloader = (com.geccocrawler.gecco.annotation.Downloader)downloaderClass.getAnnotation(com.geccocrawler.gecco.annotation.Downloader.class);
try {
Object o = createDownloader(downloaderClass);
if(o instanceof Downloader) {
Downloader downloaderInstance = (Downloader)o;
String name = downloader.value();
downloaders.put(name, downloaderInstance);
}
} catch(Exception ex) {
ex.printStackTrace();
}
}
}
public Downloader getDownloader(String name) {<FILL_FUNCTION_BODY>}
public Downloader defaultDownloader() {
return downloaders.get(DEFAULT_DOWNLOADER);
}
protected abstract Object createDownloader(Class<?> downloaderClass) throws Exception;
public void closeAll() {
for(Downloader downloader : downloaders.values()) {
downloader.shutdown();
}
}
}
|
Downloader downloader = downloaders.get(name);
if(downloader == null) {
return defaultDownloader();
}
return downloader;
| 404
| 44
| 448
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/MonitorDownloaderFactory.java
|
MonitorDownloaderFactory
|
createDownloader
|
class MonitorDownloaderFactory extends DownloaderFactory {
public MonitorDownloaderFactory(Reflections reflections) {
super(reflections);
}
@Override
protected Object createDownloader(Class<?> downloaderClass) throws Exception {<FILL_FUNCTION_BODY>}
}
|
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(downloaderClass);
enhancer.setCallback(new DownloadMointorIntercetor());
Object o = enhancer.create();
return o;
| 84
| 74
| 158
|
<methods>public void <init>(org.reflections.Reflections) ,public void closeAll() ,public com.geccocrawler.gecco.downloader.Downloader defaultDownloader() ,public com.geccocrawler.gecco.downloader.Downloader getDownloader(java.lang.String) <variables>public static final java.lang.String DEFAULT_DOWNLOADER,private Map<java.lang.String,com.geccocrawler.gecco.downloader.Downloader> downloaders
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/UserAgent.java
|
UserAgent
|
getUserAgent
|
class UserAgent {
private static final String DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/45.0.2454.85 Safari/537.36";
private static final String DEFAULT_MOBILE_USER_AGENT = "Mozilla/5.0 (iPhone; CPU iPhone OS 6_0 like Mac OS X) AppleWebKit/536.26 (KHTML, like Gecko) Version/6.0 Mobile/10A403 Safari/8536.25";
private static List<String> userAgents = null;
static {
try {
URL url = Resources.getResource("userAgents");
File file = new File(url.getPath());
userAgents = Files.readLines(file, Charsets.UTF_8);
} catch(Exception ex) {}
}
private static List<String> mobileUserAgents = null;
static {
try {
URL url = Resources.getResource("mobileUserAgents");
File file = new File(url.getPath());
mobileUserAgents = Files.readLines(file, Charsets.UTF_8);
} catch(Exception ex) {}
}
public static String getUserAgent(boolean isMobile) {<FILL_FUNCTION_BODY>}
}
|
if(isMobile) {
if(mobileUserAgents == null || mobileUserAgents.size() == 0) {
return DEFAULT_MOBILE_USER_AGENT;
}
Collections.shuffle(mobileUserAgents);
return mobileUserAgents.get(0);
} else {
if(userAgents == null || userAgents.size() == 0) {
return DEFAULT_USER_AGENT;
}
Collections.shuffle(userAgents);
return userAgents.get(0);
}
| 371
| 139
| 510
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/proxy/FileProxys.java
|
FileProxys
|
getProxy
|
class FileProxys implements Proxys {
private static Log log = LogFactory.getLog(FileProxys.class);
private ConcurrentLinkedQueue<Proxy> proxyQueue;
private Map<String, Proxy> proxys = null;
public FileProxys() {
try {
proxys = new ConcurrentHashMap<String, Proxy>();
proxyQueue = new ConcurrentLinkedQueue<Proxy>();
URL url = Resources.getResource("proxys");
File file = new File(url.getPath());
List<String> lines = Files.readLines(file, Charsets.UTF_8);
if(lines.size() > 0) {
for(String line : lines) {
line = line.trim();
if(line.startsWith("#")) {
continue;
}
String[] hostPort = line.split(":");
if(hostPort.length == 2) {
String host = hostPort[0];
int port = NumberUtils.toInt(hostPort[1], 80);
addProxy(host, port);
}
}
}
} catch(Exception ex) {
log.info("proxys not load");
}
}
@Override
public boolean addProxy(String host, int port) {
return addProxy(host, port, null);
}
@Override
public boolean addProxy(String host, int port, String src) {
Proxy proxy = new Proxy(host, port);
if(StringUtils.isNotEmpty(src)) {
proxy.setSrc(src);
}
if(proxys.containsKey(proxy.toHostString())) {
return false;
} else {
proxys.put(host+":"+port, proxy);
proxyQueue.offer(proxy);
if(log.isDebugEnabled()) {
log.debug("add proxy : " + host + ":" + port);
}
return true;
}
}
@Override
public void failure(String host, int port) {
Proxy proxy = proxys.get(host+":"+port);
if(proxy != null) {
long failure = proxy.getFailureCount().incrementAndGet();
long success = proxy.getSuccessCount().get();
reProxy(proxy, success, failure);
}
}
@Override
public void success(String host, int ip) {
Proxy proxy = proxys.get(host+":"+ip);
if(proxy != null) {
long success = proxy.getSuccessCount().incrementAndGet();
long failure = proxy.getFailureCount().get();
reProxy(proxy, success, failure);
}
}
private void reProxy(Proxy proxy, long success, long failure) {
long sum = failure + success;
if(sum < 20) {
proxyQueue.offer(proxy);
} else {
if((success / (float)sum) >= 0.5f) {
proxyQueue.offer(proxy);
}
}
}
@Override
public HttpHost getProxy() {<FILL_FUNCTION_BODY>}
}
|
if(proxys == null || proxys.size() == 0) {
return null;
}
Proxy proxy = proxyQueue.poll();
if(log.isDebugEnabled()) {
log.debug("use proxy : " + proxy);
}
if(proxy == null) {
return null;
}
return proxy.getHttpHost();
| 904
| 109
| 1,013
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/proxy/Proxy.java
|
Proxy
|
toString
|
class Proxy {
private HttpHost httpHost;
private AtomicLong successCount;
private AtomicLong failureCount;
private String src;//来源
public Proxy(String host, int port) {
this.httpHost = new HttpHost(host, port);
this.src = "custom";
this.successCount = new AtomicLong(0);
this.failureCount = new AtomicLong(0);
}
public HttpHost getHttpHost() {
return httpHost;
}
public void setHttpHost(HttpHost httpHost) {
this.httpHost = httpHost;
}
public AtomicLong getSuccessCount() {
return successCount;
}
public void setSuccessCount(AtomicLong successCount) {
this.successCount = successCount;
}
public AtomicLong getFailureCount() {
return failureCount;
}
public void setFailureCount(AtomicLong failureCount) {
this.failureCount = failureCount;
}
public String getIP() {
return this.getHttpHost().getHostName();
}
public int getPort() {
return this.getHttpHost().getPort();
}
public String toHostString() {
return httpHost.toHostString();
}
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "Proxy [httpHost=" + httpHost + ", successCount=" + successCount
+ ", failureCount=" + failureCount + "]";
| 382
| 40
| 422
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/downloader/proxy/ProxysContext.java
|
ProxysContext
|
isEnableProxy
|
class ProxysContext {
public static Proxys get() {
Spider spider = SpiderThreadLocal.get();
if(spider == null) {
return null;
}
return spider.getEngine().getProxysLoader();
}
public static boolean isEnableProxy() {<FILL_FUNCTION_BODY>}
}
|
Spider spider = SpiderThreadLocal.get();
if(spider == null) {
return false;
}
return spider.getEngine().isProxy();
| 106
| 54
| 160
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/dynamic/FieldType.java
|
FieldType
|
type
|
class FieldType {
public static CtClass intType = CtClass.intType;
public static CtClass longType = CtClass.longType;
//public static CtClass booleanType = CtClass.booleanType;
public static CtClass doubleType = CtClass.doubleType;
public static CtClass floatType = CtClass.floatType;
public static CtClass shortType = CtClass.shortType;
public static CtClass voidType = CtClass.voidType;
public static CtClass stringType;
static {
try {
stringType = ClassPool.getDefault().get("java.lang.String");
} catch (NotFoundException e) {
e.printStackTrace();
}
}
public static CtClass requestType;
static {
try {
requestType = ClassPool.getDefault().get("com.geccocrawler.gecco.request.HttpRequest");
} catch (NotFoundException e) {
e.printStackTrace();
}
}
public static CtClass type(Class<?> clazz) {<FILL_FUNCTION_BODY>}
public static CtClass listType(String className) {
try {
return ClassPool.getDefault().get(className+"[]");
} catch (NotFoundException e) {
e.printStackTrace();
return voidType;
}
}
}
|
try {
return ClassPool.getDefault().get(clazz.getName());
} catch (NotFoundException e) {
e.printStackTrace();
return voidType;
}
| 369
| 52
| 421
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/dynamic/GeccoClassLoader.java
|
GeccoClassLoader
|
findClass
|
class GeccoClassLoader extends ClassLoader {
private static final Log LOG = LogFactory.getLog(GeccoClassLoader.class);
private Map<String, Class<?>> classes;
private static GeccoClassLoader instance;
/**
* 创建一个新的GeccoClassLoader
* @return GeccoClassLoader
*/
public static synchronized GeccoClassLoader create() {
if(instance != null) {
instance.classes.clear();
}
ClassLoader parent = Thread.currentThread().getContextClassLoader();
if(parent != null) {
instance = new GeccoClassLoader(parent);
} else {
instance = new GeccoClassLoader();
}
return instance;
}
public static synchronized GeccoClassLoader get() {
if(instance == null) {
instance = create();
}
return instance;
}
public GeccoClassLoader() {
classes = new HashMap<String, Class<?>>();
}
public GeccoClassLoader(ClassLoader parent) {
super(parent);
classes = new HashMap<String, Class<?>>();
}
@Override
protected Class<?> findClass(String name) throws ClassNotFoundException {<FILL_FUNCTION_BODY>}
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
LOG.debug("load from GeccoClassLoader : " + name);
return super.loadClass(name);
}
public void addClass(String key, Class<?> clazz) {
classes.put(key, clazz);
}
public Map<String, Class<?>> getClasses() {
return classes;
}
}
|
Class<?> clazz = classes.get(name);
if(clazz == null) {
throw new ClassNotFoundException(name);
}
LOG.debug("find from GeccoClassLoader : " + name);
return clazz;
| 446
| 68
| 514
|
<methods>public void clearAssertionStatus() ,public final java.lang.Package getDefinedPackage(java.lang.String) ,public final java.lang.Package[] getDefinedPackages() ,public java.lang.String getName() ,public final java.lang.ClassLoader getParent() ,public static java.lang.ClassLoader getPlatformClassLoader() ,public java.net.URL getResource(java.lang.String) ,public java.io.InputStream getResourceAsStream(java.lang.String) ,public Enumeration<java.net.URL> getResources(java.lang.String) throws java.io.IOException,public static java.lang.ClassLoader getSystemClassLoader() ,public static java.net.URL getSystemResource(java.lang.String) ,public static java.io.InputStream getSystemResourceAsStream(java.lang.String) ,public static Enumeration<java.net.URL> getSystemResources(java.lang.String) throws java.io.IOException,public final java.lang.Module getUnnamedModule() ,public final boolean isRegisteredAsParallelCapable() ,public Class<?> loadClass(java.lang.String) throws java.lang.ClassNotFoundException,public Stream<java.net.URL> resources(java.lang.String) ,public void setClassAssertionStatus(java.lang.String, boolean) ,public void setDefaultAssertionStatus(boolean) ,public void setPackageAssertionStatus(java.lang.String, boolean) <variables>static final boolean $assertionsDisabled,final java.lang.Object assertionLock,Map<java.lang.String,java.lang.Boolean> classAssertionStatus,private volatile ConcurrentHashMap<?,?> classLoaderValueMap,private final ArrayList<Class<?>> classes,private boolean defaultAssertionStatus,private final java.security.ProtectionDomain defaultDomain,private final jdk.internal.loader.NativeLibraries libraries,private final java.lang.String name,private final java.lang.String nameAndId,private static final java.security.cert.Certificate[] nocerts,private final ConcurrentHashMap<java.lang.String,java.security.cert.Certificate[]> package2certs,private Map<java.lang.String,java.lang.Boolean> packageAssertionStatus,private final ConcurrentHashMap<java.lang.String,java.lang.NamedPackage> packages,private final ConcurrentHashMap<java.lang.String,java.lang.Object> parallelLockMap,private final java.lang.ClassLoader parent,private static volatile java.lang.ClassLoader scl,private final java.lang.Module unnamedModule
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/dynamic/JavassistDynamicField.java
|
JavassistDynamicField
|
attr
|
class JavassistDynamicField implements DynamicField {
private static Log log = LogFactory.getLog(JavassistDynamicField.class);
private DynamicBean dynamicBean;
private CtField cfield;
private ConstPool cpool;
private AnnotationsAttribute attr;
public JavassistDynamicField(DynamicBean dynamicBean, CtClass clazz, ConstPool cpool, String fieldName) {
try {
this.dynamicBean = dynamicBean;
this.cpool = cpool;
this.cfield = clazz.getField(fieldName);
attr = new AnnotationsAttribute(cpool, AnnotationsAttribute.visibleTag);
} catch (NotFoundException e) {
log.error(fieldName + " not found");
}
}
public DynamicBean build() {
FieldInfo finfo = cfield.getFieldInfo();
finfo.addAttribute(attr);
return dynamicBean;
}
@Deprecated
@Override
public DynamicField htmlField(String cssPath) {
return csspath(cssPath);
}
@Override
public DynamicField csspath(String cssPath) {
Annotation annot = new Annotation(HtmlField.class.getName(), cpool);
annot.addMemberValue("cssPath", new StringMemberValue(cssPath, cpool));
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField text(boolean own) {
Annotation annot = new Annotation(Text.class.getName(), cpool);
annot.addMemberValue("own", new BooleanMemberValue(own, cpool));
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField text() {
return text(true);
}
@Override
public DynamicField html(boolean outer) {
Annotation annot = new Annotation(Html.class.getName(), cpool);
annot.addMemberValue("outer", new BooleanMemberValue(outer, cpool));
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField href(boolean click, String... value) {
Annotation annot = new Annotation(Href.class.getName(), cpool);
annot.addMemberValue("click", new BooleanMemberValue(click, cpool));
ArrayMemberValue arrayMemberValue = new ArrayMemberValue(cpool);
MemberValue[] memberValues = new StringMemberValue[value.length];
for(int i = 0; i < value.length; i++) {
memberValues[i] = new StringMemberValue(value[i], cpool);
}
arrayMemberValue.setValue(memberValues);
annot.addMemberValue("value", arrayMemberValue);
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField href(String... value) {
return href(false, value);
}
@Override
public DynamicField image(String download, String... value) {
Annotation annot = new Annotation(Image.class.getName(), cpool);
annot.addMemberValue("download", new StringMemberValue(download, cpool));
ArrayMemberValue arrayMemberValue = new ArrayMemberValue(cpool);
MemberValue[] memberValues = new StringMemberValue[value.length];
for(int i = 0; i < value.length; i++) {
memberValues[i] = new StringMemberValue(value[i], cpool);
}
arrayMemberValue.setValue(memberValues);
annot.addMemberValue("value", arrayMemberValue);
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField image() {
return image("");
}
@Override
public DynamicField attr(String value) {<FILL_FUNCTION_BODY>}
@Override
public DynamicField ajax(String url) {
Annotation annot = new Annotation(Ajax.class.getName(), cpool);
annot.addMemberValue("url", new StringMemberValue(url, cpool));
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField request() {
Annotation annot = new Annotation(Request.class.getName(), cpool);
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField requestParameter(String param) {
Annotation annot = new Annotation(RequestParameter.class.getName(), cpool);
annot.addMemberValue("value", new StringMemberValue(param, cpool));
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField requestParameter() {
return requestParameter("");
}
@Override
public DynamicField jsvar(String var, String jsonpath) {
Annotation annot = new Annotation(JSVar.class.getName(), cpool);
annot.addMemberValue("var", new StringMemberValue(var, cpool));
annot.addMemberValue("jsonpath", new StringMemberValue(jsonpath, cpool));
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField jsvar(String var) {
return jsvar(var, "");
}
@Override
public DynamicField jsonpath(String value) {
Annotation annot = new Annotation(JSONPath.class.getName(), cpool);
annot.addMemberValue("value", new StringMemberValue(value, cpool));
attr.addAnnotation(annot);
return this;
}
@Override
public DynamicField renderName(String value) {
Annotation renderName = new Annotation(FieldRenderName.class.getName(), cpool);
renderName.addMemberValue("value", new StringMemberValue(value, cpool));
attr.addAnnotation(renderName);
return this;
}
@Override
public DynamicField customAnnotation(Annotation annotation) {
attr.addAnnotation(annotation);
return this;
}
@Override
public ConstPool getConstPool(){
return this.cpool;
}
}
|
Annotation annot = new Annotation(Attr.class.getName(), cpool);
annot.addMemberValue("value", new StringMemberValue(value, cpool));
attr.addAnnotation(annot);
return this;
| 1,508
| 57
| 1,565
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/monitor/DownloadMointorIntercetor.java
|
DownloadMointorIntercetor
|
intercept
|
class DownloadMointorIntercetor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
if(method.getName().equals("download")) {
HttpRequest request = (HttpRequest)args[0];
try {
Object o = proxy.invokeSuper(obj, args);
DownloadMonitor.incrSuccess(request.getUrl());
return o;
} catch(DownloadServerException ex) {
DownloadMonitor.incrServerError(request.getUrl());
throw ex;
} catch(DownloadException ex) {
DownloadMonitor.incrException(request.getUrl());
throw ex;
}
} else {
return proxy.invokeSuper(obj, args);
}
| 59
| 160
| 219
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/monitor/DownloadMonitor.java
|
DownloadMonitor
|
getStatistics
|
class DownloadMonitor {
private static Log log = LogFactory.getLog(DownloadMonitor.class);
private static Map<String, DownloadStatistics> statistics = new ConcurrentHashMap<String, DownloadStatistics>();
//不公平重入锁,用来控制host的创建
private static Lock lock = new ReentrantLock();
public static Set<String> getHosts() {
return statistics.keySet();
}
public static Map<String, DownloadStatistics> getStatistics() {
return statistics;
}
/**
* 双重检查机制锁
*
* @param host host
* @return DownloadStatistics
*/
public static DownloadStatistics getStatistics(String host) {<FILL_FUNCTION_BODY>}
private static String getHost(String url) {
try {
URL requestUrl = new URL(url);
String host = requestUrl.getHost();
return host;
} catch (MalformedURLException e) {
log.error(e);
return url;
}
}
public static void incrSuccess(String url) {
getStatistics(getHost(url)).incrSuccess();
}
public static void incrServerError(String url) {
getStatistics(getHost(url)).incrServerError();
}
public static void incrException(String url) {
getStatistics(getHost(url)).incrException();
}
}
|
DownloadStatistics downloadStatistics = statistics.get(host);
if(downloadStatistics != null) {
return downloadStatistics;
}
lock.lock();
try{
downloadStatistics = statistics.get(host);
if(downloadStatistics == null) {
downloadStatistics = new DownloadStatistics();
statistics.put(host, downloadStatistics);
}
} finally {
lock.unlock();
}
return downloadStatistics;
| 366
| 128
| 494
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/monitor/DownloadStatistics.java
|
DownloadStatistics
|
toString
|
class DownloadStatistics implements Serializable {
private static final long serialVersionUID = 5441547994721879109L;
/**
* 成功下载次数
*/
private AtomicLong success;
/**
* 下载异常次数
*/
private AtomicLong exception;
/**
* 服务器错误次数
*/
private AtomicLong serverError;
public DownloadStatistics() {
success = new AtomicLong(0);
exception = new AtomicLong(0);
serverError = new AtomicLong(0);
}
public long getSuccess() {
return success.get();
}
public long incrSuccess() {
return this.success.incrementAndGet();
}
public long getException() {
return exception.get();
}
public long incrException() {
return this.exception.incrementAndGet();
}
public long getServerError() {
return serverError.get();
}
public long incrServerError() {
return this.serverError.incrementAndGet();
}
@Override
public String toString() {<FILL_FUNCTION_BODY>}
}
|
return "[success=" + success + ", exception=" + exception + ", serverError=" + serverError + "]";
| 308
| 32
| 340
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/monitor/GeccoJmx.java
|
GeccoJmx
|
export
|
class GeccoJmx {
private static MBeanExporter exporter = new MBeanExporter(ManagementFactory.getPlatformMBeanServer());
public static void export(String classpath) {<FILL_FUNCTION_BODY>}
public static void unexport() {
exporter.unexportAllAndReportMissing();
}
}
|
Reflections reflections = new Reflections("com.geccocrawler.gecco.monitor");
Set<Class<?>> mbeanClasses = reflections.getTypesAnnotatedWith(MBean.class);
for(Class<?> mbeanClass : mbeanClasses) {
MBean mbean = (MBean)mbeanClass.getAnnotation(MBean.class);
String name = mbean.value();
try {
exporter.export(classpath+":name="+name, mbeanClass.newInstance());
} catch (Exception e) {
e.printStackTrace();
}
}
| 88
| 168
| 256
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/monitor/RenderMointorIntercetor.java
|
RenderMointorIntercetor
|
intercept
|
class RenderMointorIntercetor implements MethodInterceptor {
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {<FILL_FUNCTION_BODY>}
}
|
if(method.getName().equals("inject")) {
try {
Object o = proxy.invokeSuper(obj, args);
return o;
} catch(RenderException ex) {
RenderMonitor.incrException(ex.getSpiderBeanClass().getName());
throw ex;
}
} else {
return proxy.invokeSuper(obj, args);
}
| 60
| 101
| 161
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/monitor/RenderMonitor.java
|
RenderMonitor
|
getGecco
|
class RenderMonitor {
private static Map<String, AtomicLong> statistics = new ConcurrentHashMap<String, AtomicLong>();
private static Lock lock = new ReentrantLock();
public static void incrException(String geccoName) {
getGecco(geccoName).incrementAndGet();
}
public static AtomicLong getGecco(String geccoName) {<FILL_FUNCTION_BODY>}
public static Map<String, AtomicLong> getStatistics() {
return statistics;
}
}
|
AtomicLong al = statistics.get(geccoName);
if(al != null) {
return al;
}
lock.lock();
try {
al = statistics.get(geccoName);
if(al == null) {
al = new AtomicLong(0);
statistics.put(geccoName, al);
}
} finally {
lock.unlock();
}
return al;
| 144
| 123
| 267
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/request/AbstractHttpRequest.java
|
AbstractHttpRequest
|
equals
|
class AbstractHttpRequest implements HttpRequest, Comparable<HttpRequest>, Serializable {
private static final long serialVersionUID = -7284636094595149962L;
private String url;
private boolean forceUseCharset = false;
private String charset;
private Map<String, String> parameters;
private Map<String, String> cookies;
private Map<String, String> headers;
private long priority;
public AbstractHttpRequest() {
this.parameters = new HashMap<String, String>(1);
this.headers = new HashMap<String, String>(1);
this.cookies = new HashMap<String, String>(1);
}
public AbstractHttpRequest(String url) {
this();
this.setUrl(url);
}
@Override
public void clearHeader() {
Iterator<Map.Entry<String, String>> it = this.headers.entrySet().iterator();
while(it.hasNext()){
it.next();
it.remove();
}
}
@Override
public void clearCookie() {
Iterator<Map.Entry<String, String>> it = this.cookies.entrySet().iterator();
while(it.hasNext()){
it.next();
it.remove();
}
}
@Override
public void addCookie(String name, String value) {
cookies.put(name, value);
}
@Override
public String getCookie(String name) {
return cookies.get(name);
}
@Override
public void addParameter(String name, String value) {
parameters.put(name, value);
}
@Override
public void setParameters(Map<String, String> parameters) {
this.parameters.putAll(parameters);
}
@Override
public String getParameter(String name) {
return parameters.get(name);
}
@Override
public HttpRequest subRequest(String url) {
try {
HttpRequest request = (HttpRequest)clone();
request.setUrl(url);
request.refer(this.getUrl());
return request;
} catch(Exception ex) {
ex.printStackTrace();
}
return null;
}
@Override
public void addHeader(String name, String value) {
headers.put(name, value);
}
@Override
public String getUrl() {
return url;
}
@Override
public Map<String, String> getHeaders() {
/*StringBuffer sb = new StringBuffer();
for(Map.Entry<String, String> entry : cookies.entrySet()) {
sb.append(entry.getKey()).append("=").append(entry.getValue()).append(";");
}
headers.put("Cookie", sb.toString());*/
return headers;
}
@Override
public void refer(String refer) {
this.addHeader("Referer", refer);
}
@Override
public Map<String, String> getParameters() {
return parameters;
}
@Override
public void setForceUseCharset(boolean forceUseCharset) {
this.forceUseCharset = forceUseCharset;
}
@Override
public boolean isForceUseCharset() {
return forceUseCharset;
}
@Override
public String getCharset() {
return charset;
}
@Override
public void setCharset(String charset) {
this.charset = charset;
}
public void setCookies(Map<String, String> cookies) {
this.cookies = cookies;
}
public void setHeaders(Map<String, String> headers) {
this.headers = headers;
}
@Override
public long getPriority() {
return priority;
}
@Override
public void setPriority(long prio) {
this.priority = prio;
}
@Override
public Map<String, String> getCookies() {
return cookies;
}
@Override
public void setUrl(String url) {
this.url = StringUtils.substringBefore(url, "#");
}
/**
* 数字小，优先级高
*/
@Override
public int compareTo(HttpRequest o) {
return this.priority > o.getPriority() ? 1 : this.priority < o.getPriority() ? -1 : 0;
}
@Override
protected Object clone() throws CloneNotSupportedException {
//通过json的序列号和反序列化实现对象的深度clone
String text = JSON.toJSONString(this); //序列化
HttpRequest request = JSON.parseObject(text, this.getClass()); //反序列化
return request;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((url == null) ? 0 : url.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
}
|
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
AbstractHttpRequest other = (AbstractHttpRequest) obj;
String otherJson = JSON.toJSONString(other);
String thisJson = JSON.toJSONString(this);
return otherJson.equals(thisJson);
| 1,277
| 102
| 1,379
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/request/StartRequestList.java
|
StartRequestList
|
toRequest
|
class StartRequestList {
private String url;
private String charset;
private Map<String, String> cookies;
private Map<String, String> headers;
private Map<String, String> posts;
public StartRequestList() {
cookies = new HashMap<String, String>();
headers = new HashMap<String, String>();
posts = new HashMap<String, String>();
}
public HttpRequest toRequest() {<FILL_FUNCTION_BODY>}
public void addHeader(String name, String value) {
headers.put(name, value);
}
public void addCookie(String name, String value) {
cookies.put(name, value);
}
public void addPost(String name, String value) {
posts.put(name, value);
}
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getCharset() {
return charset;
}
public void setCharset(String charset) {
this.charset = charset;
}
public Map<String, String> getCookies() {
return cookies;
}
public void setCookies(Map<String, String> cookies) {
this.cookies = cookies;
}
public Map<String, String> getHeaders() {
return headers;
}
public void setHeaders(Map<String, String> headers) {
this.headers = headers;
}
public Map<String, String> getPosts() {
return posts;
}
public void setPosts(Map<String, String> posts) {
this.posts = posts;
}
}
|
if(posts != null && posts.size() > 0) {
HttpPostRequest post = new HttpPostRequest(this.getUrl());
post.setCharset(charset);
post.setFields(posts);
post.setCookies(cookies);
post.setHeaders(headers);
return post;
} else {
HttpGetRequest get = new HttpGetRequest(this.getUrl());
get.setCharset(charset);
get.setCookies(cookies);
get.setHeaders(headers);
return get;
}
| 433
| 152
| 585
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/response/HttpResponse.java
|
HttpResponse
|
getContent
|
class HttpResponse {
private ByteArrayInputStream raw;
private String content;
private String contentType;
private String charset;
private int status;
public static HttpResponse createSimple(String content) {
HttpResponse response = new HttpResponse();
response.setContent(content);
return response;
}
public ByteArrayInputStream getRaw() {
return raw;
}
public void setRaw(ByteArrayInputStream raw) {
this.raw = raw;
}
public String getContent() {
return content;
}
public String getContent(String charset) {<FILL_FUNCTION_BODY>}
public void setContent(String content) {
this.content = content;
}
public String getContentType() {
return contentType;
}
public void setContentType(String contentType) {
this.contentType = contentType;
}
public int getStatus() {
return status;
}
public void setStatus(int status) {
this.status = status;
}
public String getCharset() {
return charset;
}
public void setCharset(String charset) {
this.charset = charset;
}
public void close() {
if(raw != null) {
try{
raw.close();
} catch(Exception ex) {
raw = null;
}
}
}
}
|
if(charset == null) {
return content;
}
try {
return CharStreams.toString(new InputStreamReader(raw, charset));
} catch (Exception e) {
e.printStackTrace();
return content;
}
| 352
| 70
| 422
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/scheduler/FIFOScheduler.java
|
FIFOScheduler
|
out
|
class FIFOScheduler implements Scheduler {
private static Log log = LogFactory.getLog(FIFOScheduler.class);
private LinkedBlockingQueue<HttpRequest> starQueue;
private ConcurrentLinkedQueue<HttpRequest> queue;
private ReentrantLock outLock;
public FIFOScheduler() {
starQueue = new LinkedBlockingQueue<HttpRequest>();
queue = new ConcurrentLinkedQueue<HttpRequest>();
outLock = new ReentrantLock();
}
/*@Override
public void start(List<HttpRequest> requests) {
try {
for(HttpRequest request : requests) {
if(StringUtils.isNotEmpty(request.getUrl())) {
starQueue.put(request);
if(log.isDebugEnabled()) {
log.debug("<===[start]"+request.getUrl());
}
}
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}*/
/**
* 入队列，超过边界会阻塞等待
*/
@Override
public void into(HttpRequest request) {
if(request == null) {
return;
}
if(queue.offer(request)) {
if(log.isDebugEnabled()) {
log.debug("<==="+request.getUrl());
}
} else {
log.error(request.getUrl());
}
}
/**
* 出队列，队列为空会阻塞等待
*/
@Override
public HttpRequest out() {<FILL_FUNCTION_BODY>}
}
|
outLock.lock();
try {
HttpRequest request = queue.poll();
if(request == null) {
request = starQueue.take();
if(log.isDebugEnabled()) {
log.debug("[start]===>"+request.getUrl());
}
starQueue.put(request);
if(log.isDebugEnabled()) {
log.debug("<===[start]"+request.getUrl());
}
return request;
} else {
if(log.isDebugEnabled()) {
log.debug("===>"+request.getUrl());
}
return request;
}
} catch (InterruptedException e) {
e.printStackTrace();
return null;
} finally {
outLock.unlock();
}
| 418
| 211
| 629
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/scheduler/SpiderScheduler.java
|
SpiderScheduler
|
out
|
class SpiderScheduler implements Scheduler {
private static Log log = LogFactory.getLog(SpiderScheduler.class);
private ConcurrentLinkedQueue<HttpRequest> queue;
public SpiderScheduler() {
queue = new ConcurrentLinkedQueue<HttpRequest>();
}
@Override
public HttpRequest out() {<FILL_FUNCTION_BODY>}
@Override
public void into(HttpRequest request) {
queue.offer(request);
if(log.isDebugEnabled()) {
log.debug("INTO:"+request.getUrl()+"(Referer:"+request.getHeaders().get("Referer")+")");
}
}
}
|
HttpRequest request = queue.poll();
if(request != null) {
if(log.isDebugEnabled()) {
log.debug("OUT:"+request.getUrl()+"(Referer:"+request.getHeaders().get("Referer")+")");
}
}
return request;
| 175
| 81
| 256
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/scheduler/StartScheduler.java
|
StartScheduler
|
out
|
class StartScheduler implements Scheduler {
private LinkedBlockingQueue<HttpRequest> startQueue;
public StartScheduler() {
startQueue = new LinkedBlockingQueue<HttpRequest>();
}
@Override
public HttpRequest out() {<FILL_FUNCTION_BODY>}
@Override
public void into(HttpRequest request) {
try {
startQueue.put(request);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
|
try {
return startQueue.take();
} catch (InterruptedException e) {
e.printStackTrace();
return null;
}
| 132
| 44
| 176
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/scheduler/UniqueSpiderScheduler.java
|
UniqueSpiderScheduler
|
into
|
class UniqueSpiderScheduler implements Scheduler {
private static Log log = LogFactory.getLog(UniqueSpiderScheduler.class);
private NavigableSet<SortHttpRequest> set;
public UniqueSpiderScheduler() {
set = new ConcurrentSkipListSet<SortHttpRequest>(new Comparator<SortHttpRequest>() {
@Override
public int compare(SortHttpRequest o1, SortHttpRequest o2) {
if(o1.getHttpRequest().hashCode() == o2.getHttpRequest().hashCode()) {
if(o1.getHttpRequest().equals(o2.getHttpRequest())) {
return 0;
}
}
return (o1.getPriority() - o2.getPriority()) > 0 ? 1 : -1 ;
}
});
}
@Override
public HttpRequest out() {
SortHttpRequest sortHttpRequest = set.pollFirst();
if(sortHttpRequest == null) {
return null;
}
long priority = sortHttpRequest.getPriority();
HttpRequest request = sortHttpRequest.getHttpRequest();
if(request != null && log.isDebugEnabled()) {
log.debug("OUT("+priority+"):"+request.getUrl()+"(Referer:"+request.getHeaders().get("Referer")+")");
}
return request;
}
@Override
public void into(HttpRequest request) {<FILL_FUNCTION_BODY>}
private class SortHttpRequest {
private long priority;
private HttpRequest httpRequest;
public SortHttpRequest(long priority, HttpRequest httpRequest) {
super();
this.priority = priority;
this.httpRequest = httpRequest;
}
public long getPriority() {
return priority;
}
public HttpRequest getHttpRequest() {
return httpRequest;
}
}
}
|
long priority = System.nanoTime();
boolean success = set.add(new SortHttpRequest(priority, request));
if(success && log.isDebugEnabled()) {
log.debug("INTO("+priority+"):"+request.getUrl()+"(Referer:"+request.getHeaders().get("Referer")+")");
}
if(!success && log.isDebugEnabled()) {
log.error("not unique request : " + request.getUrl());
}
| 492
| 127
| 619
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/Spider.java
|
Spider
|
pipelines
|
class Spider implements Runnable {
private static Log log = LogFactory.getLog(Spider.class);
private CountDownLatch pauseCountDown;
private volatile boolean stop;
private volatile boolean pause;
private GeccoEngine engine;
private Scheduler spiderScheduler;
/**
* 当前待渲染的bean
*/
public Class<? extends SpiderBean> currSpiderBeanClass;
public Spider(GeccoEngine engine) {
this.engine = engine;
this.spiderScheduler = new UniqueSpiderScheduler();
this.pause = false;
this.stop = false;
}
public void run() {
//将spider放入线程本地变量，之后需要使用
SpiderThreadLocal.set(this);
while(true) {
//停止
if(stop) {
//告知engine线程执行结束
engine.notifyComplete();
break;
}
//暂停抓取
if(pause) {
try {
this.pauseCountDown.await();
} catch (InterruptedException e) {
log.error("can't pause : ", e);
}
}
//获取待抓取的url
boolean start = false;
HttpRequest request = spiderScheduler.out();
if(request == null) {
//startScheduler
request = engine.getScheduler().out();
if(request == null) {
//告知engine线程执行结束
engine.notifyComplete();
break;
}
start = true;
}
if(log.isDebugEnabled()) {
log.debug("match url : " + request.getUrl());
}
//匹配SpiderBean
currSpiderBeanClass = engine.getSpiderBeanFactory().matchSpider(request);
//download
HttpResponse response = null;
try {
if(currSpiderBeanClass == null) {//如果无法匹配但是是302跳转，需要放入抓取队列继续抓取
response = defaultDownload(request);
if(response.getStatus() == 302 || response.getStatus() == 301){
spiderScheduler.into(request.subRequest(response.getContent()));
} else {
log.error("cant't match url : " + request.getUrl());
}
} else {
//获取SpiderBean的上下文：downloader,beforeDownloader,afterDownloader,render,pipelines
SpiderBeanContext context = getSpiderBeanContext();
response = download(context, request);
if(response.getStatus() == 200) {
//render
Render render = context.getRender();
SpiderBean spiderBean = null;
spiderBean = render.inject(currSpiderBeanClass, request, response);
//pipelines
pipelines(spiderBean, context);
} else if(response.getStatus() == 302 || response.getStatus() == 301){
spiderScheduler.into(request.subRequest(response.getContent()));
}
}
} catch(Exception ex) {
if(engine.isDebug()) {
log.error(request.getUrl() + " ERROR : ", ex);
}
log.error(request.getUrl() + " ERROR : " + ex.getClass().getName() + ex.getMessage());
// 如果使用代理无效，重新加入队列换其他代理再次抓取
if(ex instanceof DownloadTimeoutException) {
//开启代理，并且获取代理不为null
if(engine.isProxy() && engine.getProxysLoader().getProxy() != null) {
log.debug(request.getUrl()+" ERROR : connect time out, again insert to scheduler!");
spiderScheduler.into(request);
}
}
} finally {
if(response != null) {
response.close();
}
}
//抓取间隔
interval();
//开始地址放入队尾重新抓取
if(start && engine.isLoop()) {
//如果是一个开始抓取请求，再返回开始队列中
engine.getScheduler().into(request);
}
}
}
/**
* 暂停，当前正在抓取的请求会继续抓取完成，之后会等到restart的调用才继续抓取
*/
public void pause() {
this.pauseCountDown = new CountDownLatch(1);
this.pause = true;
}
/**
* 重新开始
*/
public void restart() {
this.pauseCountDown.countDown();
this.pause = false;
}
/**
* 停止抓取
*/
public void stop() {
this.stop = true;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private void pipelines(SpiderBean spiderBean, SpiderBeanContext context) {<FILL_FUNCTION_BODY>}
private void interval() {
int interval = engine.getInterval();
if(interval > 0) {
try {
Thread.sleep(randomInterval(interval));
} catch (InterruptedException e) {}
}
}
/**
* 默认下载
*
* @param request
* @return
*/
private HttpResponse defaultDownload(HttpRequest request) throws DownloadException {
HttpResponse response = download(null, request);
return response;
}
private HttpResponse download(SpiderBeanContext context, HttpRequest request) throws DownloadException {
Downloader currDownloader = null;
BeforeDownload before = null;
AfterDownload after = null;
int timeout = 1000;
if(context != null) {
currDownloader = context.getDownloader();
before = context.getBeforeDownload();
after = context.getAfterDownload();
timeout = context.getTimeout();
} else {
currDownloader = engine.getSpiderBeanFactory().getDownloaderFactory().defaultDownloader();
}
if(before != null) {
before.process(request);
}
HttpResponse response = currDownloader.download(request, timeout);
if(after != null) {
after.process(request, response);
}
return response;
}
/**
* 间隔时间在左右1s的范围内随机
*
* @param interval
* @return
*/
private int randomInterval(int interval) {
int min = interval - 1000;
if(min < 1) {
min = 1;
}
int max = interval + 1000;
return (int)Math.rint(Math.random()*(max-min)+min);
}
public GeccoEngine getEngine() {
return engine;
}
public Scheduler getSpiderScheduler() {
return spiderScheduler;
}
public void setSpiderScheduler(Scheduler spiderScheduler) {
this.spiderScheduler = spiderScheduler;
}
public SpiderBeanContext getSpiderBeanContext() {
return engine.getSpiderBeanFactory().getContext(currSpiderBeanClass);
}
}
|
if(spiderBean == null) {
return ;
}
List<Pipeline> pipelines = context.getPipelines();
if(pipelines != null) {
for(Pipeline pipeline : pipelines) {
pipeline.process(spiderBean);
}
}
| 1,874
| 80
| 1,954
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/conversion/BigDecimalTypeHandle.java
|
BigDecimalTypeHandle
|
getValue
|
class BigDecimalTypeHandle implements TypeHandle<BigDecimal>{
@Override
public BigDecimal getValue(Object src) throws Exception{<FILL_FUNCTION_BODY>}
}
|
if (null == src){
return null;
}
return new BigDecimal(src.toString());
| 52
| 32
| 84
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/conversion/Conversion.java
|
Conversion
|
getValue
|
class Conversion {
@SuppressWarnings({ "rawtypes" })
private static final Map<Class<?>, TypeHandle> TYPE_HANDLERS = new HashMap<Class<?>, TypeHandle>();
static {
// int, float, long, double, java.util.Date, boolean, String
TYPE_HANDLERS.put(Integer.class, new IntegerTypeHandle());
TYPE_HANDLERS.put(int.class, new IntegerTypeHandle());
TYPE_HANDLERS.put(Long.class, new LongTypeHandle());
TYPE_HANDLERS.put(long.class, new LongTypeHandle());
TYPE_HANDLERS.put(Float.class, new FloatTypeHandle());
TYPE_HANDLERS.put(float.class, new FloatTypeHandle());
TYPE_HANDLERS.put(Double.class, new DoubleTypeHandle());
TYPE_HANDLERS.put(double.class, new DoubleTypeHandle());
TYPE_HANDLERS.put(Boolean.class, new BooleanTypeHandle());
TYPE_HANDLERS.put(boolean.class, new BooleanTypeHandle());
TYPE_HANDLERS.put(Date.class, new DateTypeHandle());
TYPE_HANDLERS.put(BigDecimal.class, new BigDecimalTypeHandle());
}
@SuppressWarnings({ "rawtypes" })
public static void register(Class<?> type, TypeHandle typeHandle) {
TYPE_HANDLERS.put(type, typeHandle);
}
public static void unregister(Class<?> type) {
TYPE_HANDLERS.remove(type);
}
@SuppressWarnings({ "rawtypes" })
public static Object getValue(Class<?> type, Object value) throws Exception {<FILL_FUNCTION_BODY>}
public static Object getDateValue(Object value, String format) throws Exception {
DateTypeHandle th = (DateTypeHandle) TYPE_HANDLERS.get(Date.class);
return th.getValue(value, format);
}
}
|
TypeHandle th = TYPE_HANDLERS.get(type);
if (th != null && value != null) {
return th.getValue(value);
}
return value;
| 523
| 53
| 576
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/AbstractRender.java
|
AbstractRender
|
requests
|
class AbstractRender implements Render {
private static Log log = LogFactory.getLog(AbstractRender.class);
/**
* request请求的注入
*/
private RequestFieldRender requestFieldRender;
/**
* request参数的注入
*/
private RequestParameterFieldRender requestParameterFieldRender;
/**
* 自定义注入
*/
private CustomFieldRenderFactory customFieldRenderFactory;
public AbstractRender() {
this.requestFieldRender = new RequestFieldRender();
this.requestParameterFieldRender = new RequestParameterFieldRender();
}
@Override
@SuppressWarnings({ "unchecked" })
public SpiderBean inject(Class<? extends SpiderBean> clazz, HttpRequest request, HttpResponse response) {
try {
SpiderBean bean = clazz.newInstance();
BeanMap beanMap = BeanMap.create(bean);
requestFieldRender.render(request, response, beanMap, bean);
requestParameterFieldRender.render(request, response, beanMap, bean);
fieldRender(request, response, beanMap, bean);
Set<Field> customFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(FieldRenderName.class));
for (Field customField : customFields) {
FieldRenderName fieldRender = customField.getAnnotation(FieldRenderName.class);
String name = fieldRender.value();
CustomFieldRender customFieldRender = customFieldRenderFactory.getCustomFieldRender(name);
if (customFieldRender != null) {
customFieldRender.render(request, response, beanMap, bean, customField);
}
}
requests(request, bean);
return bean;
} catch(Exception ex) {
//throw new RenderException(ex.getMessage(), clazz);
log.error("instance SpiderBean error", ex);
return null;
}
}
public abstract void fieldRender(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean);
/**
* 需要继续抓取的请求
*/
@Override
@SuppressWarnings({ "unchecked" })
public void requests(HttpRequest request, SpiderBean bean) {<FILL_FUNCTION_BODY>}
public void setCustomFieldRenderFactory(CustomFieldRenderFactory customFieldRenderFactory) {
this.customFieldRenderFactory = customFieldRenderFactory;
}
}
|
BeanMap beanMap = BeanMap.create(bean);
Set<Field> hrefFields = ReflectionUtils.getAllFields(bean.getClass(),
ReflectionUtils.withAnnotation(Href.class));
for (Field hrefField : hrefFields) {
Href href = hrefField.getAnnotation(Href.class);
if (href.click()) {
Object o = beanMap.get(hrefField.getName());
if (o == null) {
continue;
}
boolean isList = ReflectUtils.haveSuperType(o.getClass(), List.class);// 是List类型
if (isList) {
List<String> list = (List<String>) o;
for (String url : list) {
if (StringUtils.isNotEmpty(url)) {
DeriveSchedulerContext.into(request.subRequest(url));
}
}
} else {
String url = (String) o;
if (StringUtils.isNotEmpty(url)) {
DeriveSchedulerContext.into(request.subRequest(url));
}
}
}
}
| 600
| 290
| 890
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/FieldRenderException.java
|
FieldRenderException
|
log
|
class FieldRenderException extends Exception {
private static Log log = LogFactory.getLog(FieldRenderException.class);
private static final long serialVersionUID = 5698150653455275921L;
private Field field;
public FieldRenderException(Field field, String message) {
super(message);
this.field = field;
}
public FieldRenderException(Field field, String message, Throwable cause) {
super(message, cause);
this.field = field;
}
public Field getField() {
return field;
}
public void setField(Field field) {
this.field = field;
}
public static void log(Field field, String message, Throwable cause) {<FILL_FUNCTION_BODY>}
public static void log(Field field, String message) {
log(field, message, null);
}
}
|
boolean debug = SpiderThreadLocal.get().getEngine().isDebug();
log.error(field.getName() + " render error : " + message);
if(debug && cause != null) {
log.error(message, cause);
}
| 230
| 68
| 298
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.Throwable) <variables>static final long serialVersionUID
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/MonitorRenderFactory.java
|
MonitorRenderFactory
|
createHtmlRender
|
class MonitorRenderFactory extends RenderFactory {
public MonitorRenderFactory(Reflections reflections) {
super(reflections);
}
@Override
public HtmlRender createHtmlRender() {<FILL_FUNCTION_BODY>}
@Override
public JsonRender createJsonRender() {
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(JsonRender.class);
enhancer.setCallback(new RenderMointorIntercetor());
return (JsonRender)enhancer.create();
}
}
|
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(HtmlRender.class);
enhancer.setCallback(new RenderMointorIntercetor());
return (HtmlRender)enhancer.create();
| 146
| 67
| 213
|
<methods>public void <init>(org.reflections.Reflections) ,public abstract com.geccocrawler.gecco.spider.render.html.HtmlRender createHtmlRender() ,public abstract com.geccocrawler.gecco.spider.render.json.JsonRender createJsonRender() ,public com.geccocrawler.gecco.spider.render.Render getRender(com.geccocrawler.gecco.spider.render.RenderType) <variables>private Map<com.geccocrawler.gecco.spider.render.RenderType,com.geccocrawler.gecco.spider.render.Render> renders
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/RenderException.java
|
RenderException
|
log
|
class RenderException extends Exception {
private static Log log = LogFactory.getLog(RenderException.class);
private static final long serialVersionUID = 5034687491589622988L;
private Class<? extends SpiderBean> spiderBeanClass;
public RenderException(String message, Class<? extends SpiderBean> spiderBeanClass) {
super(message);
this.spiderBeanClass = spiderBeanClass;
}
public RenderException(String message, Class<? extends SpiderBean> spiderBeanClass, FieldRenderException cause) {
super(message, cause);
this.spiderBeanClass = spiderBeanClass;
}
public Class<? extends SpiderBean> getSpiderBeanClass() {
return spiderBeanClass;
}
public void setSpiderBeanClass(Class<? extends SpiderBean> spiderBeanClass) {
this.spiderBeanClass = spiderBeanClass;
}
public static void log(String message, Class<? extends SpiderBean> spiderBeanClass, Throwable cause) {<FILL_FUNCTION_BODY>}
public static void log(String message, Class<? extends SpiderBean> spiderBeanClass) {
log(message, spiderBeanClass, null);
}
}
|
boolean debug = SpiderThreadLocal.get().getEngine().isDebug();
log.error(spiderBeanClass.getName() + " render error : " + message);
if(debug && cause != null) {
log.error(message, cause);
}
| 329
| 71
| 400
|
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.Throwable) <variables>static final long serialVersionUID
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/RequestFieldRender.java
|
RequestFieldRender
|
render
|
class RequestFieldRender implements FieldRender {
@Override
@SuppressWarnings({"unchecked" })
public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {<FILL_FUNCTION_BODY>}
}
|
Set<Field> requestFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(Request.class));
for(Field field : requestFields) {
beanMap.put(field.getName(), request);
}
| 67
| 65
| 132
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/RequestParameterFieldRender.java
|
RequestParameterFieldRender
|
render
|
class RequestParameterFieldRender implements FieldRender {
@Override
@SuppressWarnings({ "unchecked" })
public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {<FILL_FUNCTION_BODY>}
}
|
Map<String, Object> fieldMap = new HashMap<String, Object>();
Set<Field> requestParameterFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(RequestParameter.class));
for(Field field : requestParameterFields) {
RequestParameter requestParameter = field.getAnnotation(RequestParameter.class);
String key = requestParameter.value();
if(StringUtils.isEmpty(key)) {
key = field.getName();
}
String src = request.getParameter(key);
if(request instanceof HttpPostRequest && StringUtils.isEmpty(src)) {
HttpPostRequest postRequest = (HttpPostRequest)request;
src = postRequest.getField(key);
}
try {
Object value = Conversion.getValue(field.getType(), src);
fieldMap.put(field.getName(), value);
} catch(Exception ex) {
//throw new FieldRenderException(field, src, ex);
FieldRenderException.log(field, src, ex);
}
}
beanMap.putAll(fieldMap);
| 68
| 280
| 348
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/html/AjaxFieldRender.java
|
AjaxFieldRender
|
render
|
class AjaxFieldRender implements FieldRender {
@Override
@SuppressWarnings("unchecked")
public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {<FILL_FUNCTION_BODY>}
@SuppressWarnings({ "rawtypes", "unchecked" })
private Object injectAjaxField(HttpRequest request, BeanMap beanMap, Field field) {
Class clazz = field.getType();
// ajax的属性类型必须是spiderBean
Ajax ajax = field.getAnnotation(Ajax.class);
String url = ajax.url();
url = UrlMatcher.replaceParams(url, request.getParameters());
url = UrlMatcher.replaceFields(url, beanMap);
HttpRequest subRequest = request.subRequest(url);
HttpResponse subReponse = null;
try {
subReponse = DownloaderContext.download(subRequest);
RenderType type = RenderType.HTML;
if (ReflectUtils.haveSuperType(clazz, JsonBean.class)) {
type = RenderType.JSON;
}
Render render = RenderContext.getRender(type);
return render.inject(clazz, subRequest, subReponse);
} catch (DownloadException ex) {
//throw new FieldRenderException(field, ex.getMessage(), ex);
FieldRenderException.log(field, ex.getMessage(), ex);
return null;
} finally {
if(subReponse != null) {
subReponse.close();
}
}
}
}
|
Map<String, Object> fieldMap = new HashMap<String, Object>();
Set<Field> ajaxFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(Ajax.class));
for (Field ajaxField : ajaxFields) {
Object value = injectAjaxField(request, beanMap, ajaxField);
if(value != null) {
fieldMap.put(ajaxField.getName(), value);
}
}
beanMap.putAll(fieldMap);
| 412
| 137
| 549
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/html/HtmlFieldRender.java
|
HtmlFieldRender
|
injectHtmlField
|
class HtmlFieldRender implements FieldRender {
@Override
public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {
Map<String, Object> fieldMap = new HashMap<String, Object>();
Set<Field> htmlFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(HtmlField.class));
for (Field htmlField : htmlFields) {
Object value = injectHtmlField(request, response, htmlField, bean.getClass());
if(value != null) {
fieldMap.put(htmlField.getName(), value);
}
}
beanMap.putAll(fieldMap);
}
private Object injectHtmlField(HttpRequest request, HttpResponse response, Field field, Class<? extends SpiderBean> clazz) {<FILL_FUNCTION_BODY>}
}
|
HtmlField htmlField = field.getAnnotation(HtmlField.class);
String content = response.getContent();
HtmlParser parser = new HtmlParser(request.getUrl(), content);
// parser.setLogClass(clazz);
String cssPath = htmlField.cssPath();
Class<?> type = field.getType();// 属性的类
boolean isArray = type.isArray();// 是否是数组类型
boolean isList = ReflectUtils.haveSuperType(type, List.class);// 是List类型
if (isList) {
Type genericType = field.getGenericType();// 获得包含泛型的类型
Class genericClass = ReflectUtils.getGenericClass(genericType, 0);// 泛型类
if (ReflectUtils.haveSuperType(genericClass, SpiderBean.class)) {
// List<spiderBean>
return parser.$beanList(cssPath, request, genericClass);
} else {
// List<Object>
try {
return parser.$basicList(cssPath, field);
} catch (Exception ex) {
//throw new FieldRenderException(field, content, ex);
FieldRenderException.log(field, content, ex);
}
}
} else if (isArray) {
Class genericClass = type.getComponentType();
if (ReflectUtils.haveSuperType(genericClass, SpiderBean.class)) {
List<SpiderBean> list = parser.$beanList(cssPath, request, genericClass);
SpiderBean[] a = (SpiderBean[]) Array.newInstance(genericClass, list.size());
return list.toArray(a);
} else {
// List<Object>
try {
return parser.$basicList(cssPath, field).toArray();
} catch (Exception ex) {
//throw new FieldRenderException(field, content, ex);
FieldRenderException.log(field, content, ex);
}
}
} else {
if (ReflectUtils.haveSuperType(type, SpiderBean.class)) {
// SpiderBean
return parser.$bean(cssPath, request, (Class<? extends SpiderBean>) type);
} else {
// Object
try {
return parser.$basic(cssPath, field);
} catch (Exception ex) {
//throw new FieldRenderException(field, content, ex);
FieldRenderException.log(field, content, ex);
}
}
}
return null;
| 221
| 639
| 860
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/html/HtmlRender.java
|
HtmlRender
|
fieldRender
|
class HtmlRender extends AbstractRender {
private HtmlFieldRender htmlFieldRender;
private AjaxFieldRender ajaxFieldRender;
private JSVarFieldRender jsVarFieldRender;
private ImageFieldRender imageFieldRender;
public HtmlRender() {
super();
this.htmlFieldRender = new HtmlFieldRender();
this.ajaxFieldRender = new AjaxFieldRender();
this.jsVarFieldRender = new JSVarFieldRender();
this.imageFieldRender = new ImageFieldRender();
}
@Override
public void fieldRender(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {<FILL_FUNCTION_BODY>}
}
|
htmlFieldRender.render(request, response, beanMap, bean);
ajaxFieldRender.render(request, response, beanMap, bean);
jsVarFieldRender.render(request, response, beanMap, bean);
imageFieldRender.render(request, response, beanMap, bean);
| 175
| 76
| 251
|
<methods>public void <init>() ,public abstract void fieldRender(com.geccocrawler.gecco.request.HttpRequest, com.geccocrawler.gecco.response.HttpResponse, net.sf.cglib.beans.BeanMap, com.geccocrawler.gecco.spider.SpiderBean) ,public com.geccocrawler.gecco.spider.SpiderBean inject(Class<? extends com.geccocrawler.gecco.spider.SpiderBean>, com.geccocrawler.gecco.request.HttpRequest, com.geccocrawler.gecco.response.HttpResponse) ,public void requests(com.geccocrawler.gecco.request.HttpRequest, com.geccocrawler.gecco.spider.SpiderBean) ,public void setCustomFieldRenderFactory(com.geccocrawler.gecco.spider.render.CustomFieldRenderFactory) <variables>private com.geccocrawler.gecco.spider.render.CustomFieldRenderFactory customFieldRenderFactory,private static org.apache.commons.logging.Log log,private com.geccocrawler.gecco.spider.render.RequestFieldRender requestFieldRender,private com.geccocrawler.gecco.spider.render.RequestParameterFieldRender requestParameterFieldRender
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/html/ImageFieldRender.java
|
ImageFieldRender
|
downloadImage
|
class ImageFieldRender implements FieldRender {
@Override
@SuppressWarnings("unchecked")
public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {
Map<String, Object> fieldMap = new HashMap<String, Object>();
Set<Field> imageFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(Image.class));
for (Field imageField : imageFields) {
Object value = injectImageField(request, beanMap, bean, imageField);
if(value != null) {
fieldMap.put(imageField.getName(), value);
}
}
beanMap.putAll(fieldMap);
}
@SuppressWarnings("unchecked")
private Object injectImageField(HttpRequest request, BeanMap beanMap, SpiderBean bean, Field field) {
Object value = beanMap.get(field.getName());
if(value == null) {
return null;
}
if(value instanceof Collection) {
Collection<Object> collection = (Collection<Object>)value;
for(Object item : collection) {
String imgUrl = downloadImage(request, field, item.toString());
item = imgUrl;
}
return collection;
} else {
return downloadImage(request, field, value.toString());
}
}
private String downloadImage(HttpRequest request, Field field, String imgUrl) {<FILL_FUNCTION_BODY>}
}
|
if(StringUtils.isEmpty(imgUrl)) {
return imgUrl;
}
Image image = field.getAnnotation(Image.class);
String parentPath = image.download();
if(StringUtils.isEmpty(parentPath)) {
return imgUrl;
}
HttpResponse subReponse = null;
try {
String before = StringUtils.substringBefore(imgUrl, "?");
String last = StringUtils.substringAfter(imgUrl, "?");
String fileName = StringUtils.substringAfterLast(before, "/");
if(StringUtils.isNotEmpty(last)) {
last = URLEncoder.encode(last, "UTF-8");
imgUrl = before + "?" + last;
}
HttpRequest subRequest = request.subRequest(imgUrl);
subReponse = DownloaderContext.defaultDownload(subRequest);
return DownloadImage.download(parentPath, fileName, subReponse.getRaw());
} catch (Exception ex) {
//throw new FieldRenderException(field, ex.getMessage(), ex);
FieldRenderException.log(field, "download image error : " + imgUrl, ex);
return imgUrl;
} finally {
if(subReponse != null) {
subReponse.close();
}
}
| 378
| 338
| 716
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/html/JSVarFieldRender.java
|
JSVarFieldRender
|
injectJsVarField
|
class JSVarFieldRender implements FieldRender {
private static Log log = LogFactory.getLog(JSVarFieldRender.class);
@Override
@SuppressWarnings({ "unchecked" })
public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {
Context cx = Context.enter();
ScriptableObject scope = cx.initSafeStandardObjects();
String windowScript = "var window = {};var document = {};";
cx.evaluateString(scope, windowScript, "window", 1, null);
HtmlParser parser = new HtmlParser(request.getUrl(), response.getContent());
for (Element ele : parser.$("script")) {
String sc = ele.html();
if (StringUtils.isNotEmpty(sc)) {
try {
cx.evaluateString(scope, sc, "", 1, null);
} catch (Exception ex) {
// ex.printStackTrace();
}
}
}
Map<String, Object> fieldMap = new HashMap<String, Object>();
Set<Field> jsVarFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(JSVar.class));
for (Field jsVarField : jsVarFields) {
Object value = injectJsVarField(request, beanMap, jsVarField, cx, scope);
if(value != null) {
fieldMap.put(jsVarField.getName(), value);
}
}
beanMap.putAll(fieldMap);
Context.exit();
}
@SuppressWarnings({ "rawtypes" })
private Object injectJsVarField(HttpRequest request, BeanMap beanMap, Field field, Context cx, ScriptableObject scope) {<FILL_FUNCTION_BODY>}
public static void main(String[] args) {
Object json = JSON.parse("{ads:[{id:1},{id:2}],test:'test111'}");
Object src = com.alibaba.fastjson.JSONPath.eval(json, "$.ads");
if (src instanceof String) {
src = JSON.parse(src.toString());
}
System.out.println(src);
Object src2 = com.alibaba.fastjson.JSONPath.eval(json, "$.test");
if (src2 instanceof String) {
src2 = JSON.parse(src2.toString());
}
System.out.println(src2);
}
}
|
Class clazz = field.getType();
JSVar jsVar = field.getAnnotation(JSVar.class);
String var = jsVar.var();
Object jsObj = scope.get(var, scope);
if (jsObj instanceof NativeObject || jsObj instanceof NativeArray) {
String jsonPath = jsVar.jsonpath();
// 将javascript变量格式化为json对象
Object jsonObj = NativeJSON.stringify(cx, scope, jsObj, null, null);
// 使用fastjson将json字符串格式化为JSONObject
Object json = JSON.parse(jsonObj.toString());
// 解析jsonpath
Object src = com.alibaba.fastjson.JSONPath.eval(json, jsonPath);
// 如果解析出来的是字符串，尝试转换为json对象
try {
if (src instanceof String) {
src = JSON.parse(src.toString());
}
} catch (Exception ex) {
}
// 将json对象转换为javabean属性
try {
Object value = Conversion.getValue(clazz, src);
return value;
} catch (Exception e) {
log.error("field [" + field.getName() + "] conversion error, value=" + src);
}
} else if (jsObj instanceof Boolean || jsObj instanceof Number || jsObj instanceof String) {
try {
Object value = Conversion.getValue(clazz, jsObj);
return value;
} catch (Exception e) {
log.error("field [" + field.getName() + "] conversion error, value=" + jsObj);
}
}
return null;
| 634
| 428
| 1,062
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/spider/render/json/JsonFieldRender.java
|
JsonFieldRender
|
injectJsonField
|
class JsonFieldRender implements FieldRender {
@Override
@SuppressWarnings({ "unchecked" })
public void render(HttpRequest request, HttpResponse response, BeanMap beanMap, SpiderBean bean) {
Map<String, Object> fieldMap = new HashMap<String, Object>();
Set<Field> jsonPathFields = ReflectionUtils.getAllFields(bean.getClass(), ReflectionUtils.withAnnotation(JSONPath.class));
String jsonStr = response.getContent();
jsonStr = jsonp2Json(jsonStr);
if (jsonStr == null) {
return;
}
try {
Object json = JSON.parse(jsonStr);
for (Field field : jsonPathFields) {
Object value = injectJsonField(request, field, json);
if(value != null) {
fieldMap.put(field.getName(), value);
}
}
} catch(JSONException ex) {
//throw new RenderException(ex.getMessage(), bean.getClass());
RenderException.log("json parse error : " + request.getUrl(), bean.getClass(), ex);
}
beanMap.putAll(fieldMap);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private Object injectJsonField(HttpRequest request, Field field, Object json) {<FILL_FUNCTION_BODY>}
@SuppressWarnings({ "rawtypes" })
private List<SpiderBean> spiderBeanListRender(Object src, Class genericClass, HttpRequest request) {
List<SpiderBean> list = new ArrayList<SpiderBean>();
Iterable ja = (Iterable) src;
for (Object jo : ja) {
if(jo != null) {
SpiderBean subBean = this.spiderBeanRender(jo, genericClass, request);
list.add(subBean);
}
}
return list;
}
@SuppressWarnings({ "rawtypes", "unchecked" })
private SpiderBean spiderBeanRender(Object src, Class genericClass, HttpRequest request) {
HttpResponse subResponse = HttpResponse.createSimple(src.toString());
Render render = null;
if(ReflectUtils.haveSuperType(genericClass, JsonBean.class)) {
render = RenderContext.getRender(RenderType.JSON);
} else {
render = RenderContext.getRender(RenderType.HTML);
}
SpiderBean subBean = render.inject(genericClass, request, subResponse);
return subBean;
}
private Object objectRender(Object src, Field field, String jsonPath, Object json) {
if (src == null) {
//throw new FieldRenderException(field, jsonPath + " not found in : " + json);
FieldRenderException.log(field, jsonPath + " not found in : " + json);
}
try {
return Conversion.getValue(field.getType(), src);
} catch (Exception ex) {
//throw new FieldRenderException(field, "Conversion error : " + src, ex);
FieldRenderException.log(field, "Conversion error : " + src, ex);
}
return null;
}
private String jsonp2Json(String jsonp) {
if (jsonp == null) {
return null;
}
jsonp = StringUtils.trim(jsonp);
if(jsonp.startsWith("try")||StringUtils.endsWith(jsonp, ")")){
if(jsonp.indexOf("catch")!=-1){
jsonp = jsonp.substring(0,jsonp.indexOf("catch"));
}
int fromIndex = jsonp.indexOf('(');
int toIndex = jsonp.lastIndexOf(')');
if(fromIndex!=-1&&toIndex!=-1){
jsonp = jsonp.substring(fromIndex+1,toIndex).trim();
return jsonp;
}
}
if (StringUtils.endsWith(jsonp, ";")) {
jsonp = StringUtils.substringBeforeLast(jsonp, ";");
jsonp = StringUtils.trim(jsonp);
}
/*if (StringUtils.endsWith(jsonp, ")")) {
String jsonStr = StringUtils.substring(jsonp, "(", ")");
jsonStr = StringUtils.trim(jsonStr);
return jsonStr;
}*/
return jsonp;
}
}
|
JSONPath JSONPath = field.getAnnotation(JSONPath.class);
String jsonPath = JSONPath.value();
Class<?> type = field.getType();// 类属性的类
Object src = com.alibaba.fastjson.JSONPath.eval(json, jsonPath);
boolean isArray = type.isArray();
boolean isList = ReflectUtils.haveSuperType(type, List.class);// 是List类型
if (isList) {
Type genericType = field.getGenericType();// 获得包含泛型的类型
Class genericClass = ReflectUtils.getGenericClass(genericType, 0);// 泛型类
if (ReflectUtils.haveSuperType(genericClass, SpiderBean.class)) {
// List<spiderBean>
return spiderBeanListRender(src, genericClass, request);
} else {
// List<Object>
return objectRender(src, field, jsonPath, json);
}
} else if (isArray) {
Class genericClass = type.getComponentType();
if (ReflectUtils.haveSuperType(genericClass, SpiderBean.class)) {
// SpiderBean[]
List<SpiderBean> list = spiderBeanListRender(src, genericClass, request);
SpiderBean[] a = (SpiderBean[]) Array.newInstance(genericClass, list.size());
return list.toArray(a);
} else {
// Object[]
return ((List<Object>) objectRender(src, field, jsonPath, json)).toArray();
}
} else {
if (ReflectUtils.haveSuperType(type, SpiderBean.class)) {
if(src == null) {
return null;
}
// spiderBean
return spiderBeanRender(src, type, request);
} else {
// Object
return objectRender(src, field, jsonPath, json);
}
}
| 1,124
| 489
| 1,613
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/utils/DownloadImage.java
|
DownloadImage
|
download
|
class DownloadImage {
private static Log log = LogFactory.getLog(DownloadImage.class);
/**
* 下载图片到指定目录
*
* @param parentPath 指定目录
* @param imgUrl 图片地址
* @return 下载文件地址
*/
public static String download(String parentPath, String imgUrl) {<FILL_FUNCTION_BODY>}
public static String download(String parentPath, String fileName, InputStream in) {
Closer closer = Closer.create();
try {
File imageDir = new File(parentPath);
if(!imageDir.exists()) {
imageDir.mkdirs();
}
File imageFile = new File(imageDir, fileName);
Files.write(ByteStreams.toByteArray(in), imageFile);
return imageFile.getAbsolutePath();
} catch(Exception ex) {
ex.printStackTrace();
return null;
} finally {
try {
closer.close();
} catch (IOException e) {
closer = null;
}
}
}
public static void main(String[] args) {
System.out.println(DownloadImage.download("d:\\", "http://git.oschina.net/uploads/78/666978_xtuhcy.jpg?1459474621"));
}
}
|
if(Strings.isNullOrEmpty(imgUrl) || Strings.isNullOrEmpty(parentPath)) {
return null;
}
if(imgUrl.length() > 500) {
return null;
}
Closer closer = Closer.create();
try {
File imageDir = new File(parentPath);
if(!imageDir.exists()) {
imageDir.mkdirs();
}
String fileName = StringUtils.substringBefore(imgUrl, "?");
fileName = StringUtils.substringAfterLast(fileName, "/");
File imageFile = new File(imageDir, fileName);
InputStream in = closer.register(new URL(imgUrl).openStream());
Files.write(ByteStreams.toByteArray(in), imageFile);
return imageFile.getAbsolutePath();
} catch(Exception ex) {
ex.printStackTrace();
log.error("image download error :"+imgUrl);
return null;
} finally {
try {
closer.close();
} catch (IOException e) {
closer = null;
}
}
| 371
| 301
| 672
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/utils/ReflectUtils.java
|
ReflectUtils
|
getGenericClass
|
class ReflectUtils {
/**
* 获得类的所有基类和接口
*
* @param clazz 类
* @return 所有基类的集合
*/
public static Set<Class<?>> getAllSuperType(Class clazz) {
return ReflectionUtils.getAllSuperTypes(clazz);
}
/**
* 是否继承某个基类
*
* @param childClazz
* 子类
* @param superClazz
* 基类
* @return 是否继承某个基类
*/
public static boolean haveSuperType(Class childClazz, Class superClazz) {
for (Class<?> clazz : getAllSuperType(childClazz)) {
if (clazz.equals(superClazz)) {
return true;
}
}
return false;
}
/**
* 是否继承某个基类
*
* @param bean 需要判断的对象bean
* @param superClazz 基类
* @return 是否继承某个基类
*/
public static boolean haveSuperType(Object bean, Class superClazz) {
return haveSuperType(bean.getClass(), superClazz);
}
public static Class getGenericClass(Type type, int i) {
if (type instanceof ParameterizedType) { // 处理泛型类型
return getGenericClass((ParameterizedType) type, i);
} else if (type instanceof TypeVariable) { // 处理泛型擦拭对象
return getGenericClass(((TypeVariable) type).getBounds()[0], 0);
} else {// class本身也是type，强制转型
return (Class) type;
}
}
private static Class getGenericClass(ParameterizedType parameterizedType, int i) {<FILL_FUNCTION_BODY>}
}
|
Object genericClass = parameterizedType.getActualTypeArguments()[i];
if (genericClass instanceof ParameterizedType) { // 处理多级泛型
return (Class) ((ParameterizedType) genericClass).getRawType();
} else if (genericClass instanceof GenericArrayType) { // 处理数组泛型
return (Class) ((GenericArrayType) genericClass).getGenericComponentType();
} else if (genericClass instanceof TypeVariable) { // 处理泛型擦拭对象
return getGenericClass(((TypeVariable) genericClass).getBounds()[0], 0);
} else {
return (Class) genericClass;
}
| 466
| 163
| 629
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/utils/UrlMatcher.java
|
UrlMatcher
|
match
|
class UrlMatcher {
private static Log log = LogFactory.getLog(UrlMatcher.class);
public static String replaceParams(String regex, String name, String value) {
Map<String, String> map = new HashMap<String, String>(1);
map.put(name, value);
return replaceParams(regex, map);
}
public static String replaceParams(String srcUrl, Map<String, String> params) {
return replaceRegexs(srcUrl, "\\{(.*?)\\}", params);
}
public static String replaceFields(String regex, String name, String value) {
Map<String, String> map = new HashMap<String, String>(1);
map.put(name, value);
return replaceFields(regex, map);
}
public static String replaceFields(String srcUrl, Map<String, String> params) {
return replaceRegexs(srcUrl, "\\[(.*?)\\]", params);
}
public static String replaceRegexs(String srcUrl, String regex, Map<String, String> params) {
if(params == null) {
return srcUrl;
}
StringBuffer sb = new StringBuffer();
Pattern pattern = Pattern.compile(regex);
Matcher matcher = pattern.matcher(srcUrl);
while(matcher.find()) {
String name = matcher.group(1);
String value = params.get(name);
if(StringUtils.isNotEmpty(value)) {
matcher.appendReplacement(sb, value);
}
}
matcher.appendTail(sb);
return sb.toString();
}
public static Map<String, String> match(String url, String regex) {<FILL_FUNCTION_BODY>}
public static void main(String[] args) {
//http://temai.tuniu.com/{catalog}/{srcId}
//http://temai.tuniu.com/weihuo/{catalog}/s4-p{currPage}/
//http://temai.tuniu.com/weihuo/tours/s4-p1/
//http://temai.tuniu.com/tours/212055673
//String regex = "http://temai.tuniu.com/weihuo/{catalog}/s4-p{currPage}/";
//String url = "http://temai.tuniu.com/weihuo/tours/s4-p1/";
//String regex = "http://temai.tuniu.com/{catalog}/{srcId}";
//String url = "http://temai.tuniu.com/tours/212055673";
//System.out.println(match(url, regex));
String url = "http://www.ly.com/HotelInfo-597101.html#id_nameAndSliderInfo&is=1&searchId=undefined&ab=0";
String regex = "http://www.ly.com/HotelInfo-{code}.html#{hash}";
String url1 = "http://xxx.com/index.html";
String url2 = "http://xxx.com/123456.html";
String regex2 = "http://xxx.com/{code:[0-9]+}.html";
String regex3 = "http://xxx.com/{code}.html";
System.out.println(match(url2, regex2));
System.out.println(match(url2, regex3));
}
}
|
String regexSrc = StringUtils.replace(regex, "?", "\\?");
//regexSrc = StringUtils.replace(regexSrc, "/", "\\/");
String regex1 = "\\{(.*?)\\}";
StringBuffer sb = new StringBuffer();
Pattern pattern = Pattern.compile(regex1);
Matcher matcher = pattern.matcher(regexSrc);
List<String> names = new ArrayList<String>();
/*while(matcher.find()) {
matcher.appendReplacement(sb, "([^/]*)");
//matcher.appendReplacement(sb, "(.*)");
String name = matcher.group(1);
names.add(name);
}*/
//每一个匹配都是键值对key:value或者只有key
while(matcher.find()) {
String name = matcher.group(1);
String[] splits = name.split("\\s*:\\s*");//使用:分割,只能分成两个组
names.add(splits[0]);
//如果有自定义的正则表达式规则，使用自定义的正则表达式规则。类似Jersey的@Path语法
String regex2 = "([^/]*)";
if(splits.length > 1) {
regex2 = "("+splits[1]+")";
}
matcher.appendReplacement(sb, regex2);
}
if(names.size() > 0) {
matcher.appendTail(sb);
String regex2 = sb.toString();
if(log.isDebugEnabled()) {
log.debug(regex2);
}
regex2 = "^"+regex2;
Pattern pattern2 = Pattern.compile(regex2);
Matcher matcher2 = pattern2.matcher(url);
if(matcher2.matches()) {
Map<String, String> params = new HashMap<String, String>(names.size());
for(int i = 1; i <= matcher2.groupCount(); i++) {
String value = matcher2.group(i);
//boolean x = matcher2.requireEnd();
try {
value = URLDecoder.decode(value, "UTF-8");
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
}
params.put(names.get(i-1), value);
}
return params;
}
} else {
//如果没有变量，返回空map
if(url.equals(regex)) {
return new HashMap<String, String>(0);
}
}
//适配失败返回null
return null;
| 909
| 690
| 1,599
|
<no_super_class>
|
xtuhcy_gecco
|
gecco/src/main/java/com/geccocrawler/gecco/utils/UrlUtils.java
|
UrlUtils
|
relative2Absolute
|
class UrlUtils {
/**
* 相对地址转绝对地址
*
* @param absolutePath 当前绝对地址
* @param relativePath 相对地址
* @return 绝对地址
*/
public static String relative2Absolute(String absolutePath, String relativePath) {<FILL_FUNCTION_BODY>}
}
|
if(relativePath == null) {
return null;
}
//relativePath = relativePath.toLowerCase();
if(relativePath.startsWith("http")) {
return relativePath;
}
try {
// 以下方法对相对路径进行转换
URL absoluteUrl = new URL(absolutePath);
URL parseUrl = new URL(absoluteUrl, relativePath);
return parseUrl.toString();
} catch(Exception ex) {
return relativePath;
}
| 87
| 132
| 219
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/AppearanceControllerImpl.java
|
AppearanceControllerImpl
|
transform
|
class AppearanceControllerImpl implements AppearanceController, Controller<AppearanceModelImpl> {
public AppearanceControllerImpl() {
}
@Override
public AppearanceModelImpl newModel(Workspace workspace) {
return new AppearanceModelImpl(workspace);
}
@Override
public void transform(Function function) {<FILL_FUNCTION_BODY>}
@Override
public Class<AppearanceModelImpl> getModelClass() {
return AppearanceModelImpl.class;
}
@Override
public AppearanceModelImpl getModel() {
return Controller.super.getModel();
}
@Override
public AppearanceModelImpl getModel(Workspace workspace) {
return Controller.super.getModel(workspace);
}
@Override
public Transformer getTransformer(TransformerUI ui) {
Class<? extends Transformer> transformerClass = ui.getTransformerClass();
Transformer transformer = Lookup.getDefault().lookup(transformerClass);
return transformer;
}
@Override
public void setUseRankingLocalScale(boolean useLocalScale) {
AppearanceModelImpl model = getModel();
if (model != null) {
model.setRankingLocalScale(useLocalScale);
}
}
@Override
public void setUsePartitionLocalScale(boolean useLocalScale) {
AppearanceModelImpl model = getModel();
if (model != null) {
model.setPartitionLocalScale(useLocalScale);
}
}
@Override
public void setTransformNullValues(boolean transformNullValues) {
AppearanceModelImpl model = getModel();
if (model != null) {
model.setTransformNullValues(transformNullValues);
}
}
}
|
if (!function.isValid()) {
return;
}
GraphModel graphModel = function.getGraph().getModel();
Graph graph = graphModel.getGraphVisible();
ElementIterable<? extends Element> iterable;
if (function.getElementClass().equals(Node.class)) {
iterable = graph.getNodes();
} else {
iterable = graph.getEdges();
}
try {
function.transformAll(iterable);
} catch (Exception e) {
iterable.doBreak();
if (e instanceof RuntimeException) {
throw (RuntimeException) e;
} else {
throw new RuntimeException(e);
}
}
| 450
| 175
| 625
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/AttributePartitionImpl.java
|
AttributePartitionImpl
|
hashCode
|
class AttributePartitionImpl extends PartitionImpl {
protected final WeakReference<Column> column;
public AttributePartitionImpl(Column column) {
super();
this.column = new WeakReference<>(column);
}
@Override
public Object getValue(Element element, Graph graph) {
return element.getAttribute(column.get(), graph.getView());
}
private Index<Element> getIndex(Graph graph) {
return graph.getModel().getElementIndex(column.get().getTable(), graph.getView());
}
@Override
public Collection getValues(Graph graph) {
return getIndex(graph).values(column.get());
}
@Override
public int getElementCount(Graph graph) {
return getIndex(graph).countElements(column.get());
}
@Override
public int count(Object value, Graph graph) {
return getIndex(graph).count(column.get(), value);
}
@Override
public float percentage(Object value, Graph graph) {
Index<Element> index = getIndex(graph);
int count = index.count(column.get(), value);
return 100f * ((float) count / index.countElements(column.get()));
}
@Override
public int size(Graph graph) {
return getIndex(graph).countValues(column.get());
}
@Override
public Column getColumn() {
return column.get();
}
@Override
public Class getValueType() {
return getColumn().getTypeClass();
}
@Override
public boolean isValid(Graph graph) {
Column col = column.get();
if (col != null && col.getIndex() != -1) {
return true;
}
return false;
}
@Override
public int getVersion(Graph graph) {
if (isValid(graph)) {
return getIndex(graph).getColumnIndex(column.get()).getVersion();
}
return 0;
}
@Override
public int hashCode() {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final AttributePartitionImpl other = (AttributePartitionImpl) obj;
return this.column == other.column || (this.column != null && this.column.equals(other.column));
}
}
|
int hash = 3;
hash = 23 * hash + (this.column != null ? this.column.hashCode() : 0);
return hash;
| 646
| 43
| 689
|
<methods>public java.awt.Color getColor(java.lang.Object) ,public Collection#RAW getSortedValues(Graph) ,public abstract Class#RAW getValueType() ,public abstract int getVersion(Graph) ,public abstract boolean isValid(Graph) ,public void setColor(java.lang.Object, java.awt.Color) ,public void setColors(Graph, java.awt.Color[]) <variables>protected final non-sealed Map<java.lang.Object,java.awt.Color> colorMap
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/AttributeRankingImpl.java
|
AttributeRankingImpl
|
hashCode
|
class AttributeRankingImpl extends RankingImpl {
protected final WeakReference<Column> column;
public AttributeRankingImpl(Column column) {
super();
this.column = new WeakReference<>(column);
}
@Override
public Number getMinValue(Graph graph) {
return getIndex(graph).getMinValue(column.get());
}
@Override
public Number getMaxValue(Graph graph) {
return getIndex(graph).getMaxValue(column.get());
}
private Index<Element> getIndex(Graph graph) {
return graph.getModel().getElementIndex(column.get().getTable(), graph.getView());
}
@Override
public Number getValue(Element element, Graph graph) {
return (Number) element.getAttribute(column.get(), graph.getView());
}
@Override
public boolean isValid(Graph graph) {
Column col = column.get();
if (col != null && col.getIndex() != -1) {
return col.isNumber() && !col.isArray();
}
return false;
}
@Override
public int hashCode() {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final AttributeRankingImpl other = (AttributeRankingImpl) obj;
return Objects.equals(this.column, other.column);
}
@Override
public Column getColumn() {
return column.get();
}
}
|
int hash = 3;
hash = 67 * hash + (this.column != null ? this.column.hashCode() : 0);
return hash;
| 432
| 43
| 475
|
<methods>public non-sealed void <init>() ,public Column getColumn() ,public org.gephi.appearance.api.Interpolator getInterpolator() ,public float getNormalizedValue(Element, Graph) ,public abstract boolean isValid(Graph) ,public float normalize(java.lang.Number, org.gephi.appearance.api.Interpolator, java.lang.Number, java.lang.Number) ,public void setInterpolator(org.gephi.appearance.api.Interpolator) <variables>public static org.gephi.appearance.api.Interpolator DEFAULT_INTERPOLATOR,protected org.gephi.appearance.api.Interpolator interpolator
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/EdgeTypePartitionImpl.java
|
EdgeTypePartitionImpl
|
percentage
|
class EdgeTypePartitionImpl extends PartitionImpl {
private final Class valueType;
private final Column column;
public EdgeTypePartitionImpl(Column column, Class valueType) {
super();
this.valueType = valueType;
this.column = column;
}
@Override
public Collection getValues(Graph graph) {
int[] types = graph.getModel().getEdgeTypes();
return Arrays.stream(types).filter(t -> graph.getEdgeCount(t) > 0)
.mapToObj(t -> graph.getModel().getEdgeTypeLabel(t)).collect(
Collectors.toList());
}
@Override
public Object getValue(Element element, Graph gr) {
return ((Edge) element).getTypeLabel();
}
@Override
public int getElementCount(Graph graph) {
return graph.getEdgeCount();
}
@Override
public int count(Object value, Graph graph) {
return getIndex(graph).count(column, value);
}
@Override
public float percentage(Object value, Graph graph) {<FILL_FUNCTION_BODY>}
@Override
public int size(Graph graph) {
return getIndex(graph).countValues(column);
}
private Index<Edge> getIndex(Graph graph) {
return graph.getModel().getEdgeIndex(graph.getView());
}
@Override
public Column getColumn() {
return column;
}
@Override
public Class getValueType() {
return valueType;
}
@Override
public boolean isValid(Graph graph) {
return graph.getModel().isMultiGraph();
}
@Override
public int getVersion(Graph graph) {
if (isValid(graph)) {
return getIndex(graph).getColumnIndex(column).getVersion();
}
return 0;
}
}
|
Index<Edge> index = getIndex(graph);
int count = index.count(column, value);
return 100f * ((float) count / index.countElements(column));
| 487
| 50
| 537
|
<methods>public java.awt.Color getColor(java.lang.Object) ,public Collection#RAW getSortedValues(Graph) ,public abstract Class#RAW getValueType() ,public abstract int getVersion(Graph) ,public abstract boolean isValid(Graph) ,public void setColor(java.lang.Object, java.awt.Color) ,public void setColors(Graph, java.awt.Color[]) <variables>protected final non-sealed Map<java.lang.Object,java.awt.Color> colorMap
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/FunctionImpl.java
|
FunctionImpl
|
isValid
|
class FunctionImpl implements Function {
protected final AppearanceModelImpl model;
protected final Class<? extends Element> elementClass;
protected final String name;
protected final Column column;
protected final Transformer transformer;
protected final TransformerUI transformerUI;
protected final PartitionImpl partition;
protected final RankingImpl ranking;
protected final AtomicInteger version;
// Version
protected WeakReference<Graph> lastGraph;
protected boolean lastTransformNullValues;
protected FunctionImpl(AppearanceModelImpl model, String name, Class<? extends Element> elementClass, Column column,
Transformer transformer, TransformerUI transformerUI, PartitionImpl partition,
RankingImpl ranking) {
if (name == null) {
throw new NullPointerException("The name can't be null");
}
this.model = model;
this.name = name;
this.elementClass = elementClass;
this.column = column;
try {
this.transformer = transformer.getClass().newInstance();
} catch (Exception ex) {
throw new RuntimeException(ex);
}
this.transformerUI = transformerUI;
this.partition = partition;
this.ranking = ranking;
this.version =
new AtomicInteger(partition != null ? partition.getVersion(model.getPartitionGraph()) : Integer.MIN_VALUE);
this.lastGraph = partition != null ? new WeakReference<>(model.getPartitionGraph()) : null;
this.lastTransformNullValues = model.isTransformNullValues();
}
@Override
public void transform(Element element) {
Graph graph = getGraph();
if (isSimple()) {
((SimpleTransformer) transformer).transform(element);
} else if (isRanking()) {
transformRanking(element, graph, ranking.getMinValue(graph), ranking.getMaxValue(graph));
} else if (isPartition()) {
transformPartition(element, graph);
}
}
@Override
public void transformAll(Iterable<? extends Element> elementIterable) {
Graph graph = getGraph();
if (!graph.getView().isDestroyed()) {
if (isSimple()) {
elementIterable.forEach(((SimpleTransformer) transformer)::transform);
} else if (isRanking()) {
final Number minValue = ranking.getMinValue(graph);
final Number maxValue = ranking.getMaxValue(graph);
elementIterable.forEach(e -> transformRanking(e, graph, minValue, maxValue));
} else if (isPartition()) {
elementIterable.forEach(e -> transformPartition(e, graph));
}
}
}
private void transformPartition(Element element, Graph graph) {
Object val = partition.getValue(element, graph);
if (val != null || model.isTransformNullValues()) {
((PartitionTransformer) transformer).transform(element, partition, val);
}
}
private void transformRanking(Element element, Graph graph, Number minValue, Number maxValue) {
// Always use visible graph to get the value (see #2629)
Number val = ranking.getValue(element, graph.getModel().getGraphVisible());
if (val != null) {
float normalizedValue = ranking.normalize(val, ranking.getInterpolator(), minValue, maxValue);
((RankingTransformer) transformer).transform(element, ranking, val, normalizedValue);
} else if (model.isTransformNullValues()) {
((RankingTransformer) transformer).transform(element, ranking, null, 0f);
}
}
public boolean hasChanged() {
if (isPartition()) {
Graph graph = model.getPartitionGraph();
// Check if view has changed
boolean viewChanged = false;
synchronized (this) {
if (lastGraph == null) {
lastGraph = new WeakReference<>(graph);
} else {
Graph lg = lastGraph.get();
lastGraph = null;
if (lg == null || lg != graph) {
viewChanged = true;
lastGraph = new WeakReference<>(graph);
}
}
// Check if transformNullValues was changed
if (lastTransformNullValues != model.isTransformNullValues()) {
viewChanged = true;
}
lastTransformNullValues = model.isTransformNullValues();
}
int newVersion = partition.getVersion(graph);
return version.getAndSet(newVersion) != newVersion || viewChanged;
}
return false;
}
@Override
public boolean isValid() {<FILL_FUNCTION_BODY>}
@Override
public Graph getGraph() {
if (isRanking()) {
return model.getRankingGraph();
} else if (isPartition()) {
return model.getPartitionGraph();
}
return model.getGraphModel().getGraph();
}
@Override
public Transformer getTransformer() {
return transformer;
}
@Override
public TransformerUI getUI() {
return transformerUI;
}
@Override
public boolean isSimple() {
return ranking == null && partition == null;
}
@Override
public boolean isAttribute() {
return column != null;
}
@Override
public boolean isPartition() {
return partition != null;
}
@Override
public boolean isRanking() {
return ranking != null;
}
@Override
public Class<? extends Element> getElementClass() {
return elementClass;
}
@Override
public AppearanceModelImpl getModel() {
return model;
}
@Override
public String toString() {
return name;
}
@Override
public String getId() {
return name;
}
@Override
public int hashCode() {
int hash = 5;
hash = 97 * hash + (this.name != null ? this.name.hashCode() : 0);
return hash;
}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final FunctionImpl other = (FunctionImpl) obj;
return Objects.equals(this.name, other.name);
}
}
|
Graph graph = getGraph();
if (graph.getView().isDestroyed()) {
return false;
}
if (isRanking()) {
return ranking.isValid(graph);
} else if (isPartition()) {
return partition.isValid(graph);
}
return true;
| 1,641
| 82
| 1,723
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/PartitionImpl.java
|
PartitionImpl
|
setColor
|
class PartitionImpl implements Partition {
protected final Map<Object, Color> colorMap;
protected PartitionImpl() {
this.colorMap = new HashMap<>();
}
@Override
public Color getColor(Object value) {
return colorMap.getOrDefault(value, Partition.DEFAULT_COLOR);
}
@Override
public void setColor(Object value, Color color) {<FILL_FUNCTION_BODY>}
@Override
public void setColors(Graph graph, Color[] colors) {
Collection sortedValues = getSortedValues(graph);
Iterator itr = sortedValues.iterator();
for (int i = 0; i < colors.length && itr.hasNext(); i++) {
setColor(itr.next(), colors[i]);
}
}
@Override
public Collection getSortedValues(Graph graph) {
List values = new ArrayList(getValues(graph));
values.sort((o1, o2) -> {
int c1 = count(o1, graph);
int c2 = count(o2, graph);
return Integer.compare(c2, c1);
});
return values;
}
public abstract boolean isValid(Graph graph);
public abstract Class getValueType();
public abstract int getVersion(Graph graph);
}
|
if (color.equals(Partition.DEFAULT_COLOR)) {
colorMap.remove(value);
} else {
colorMap.put(value, color);
}
| 339
| 46
| 385
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/RankingImpl.java
|
RankingImpl
|
normalize
|
class RankingImpl implements Ranking {
public static Interpolator DEFAULT_INTERPOLATOR = Interpolator.LINEAR;
protected Interpolator interpolator = DEFAULT_INTERPOLATOR;
public Interpolator getInterpolator() {
return interpolator;
}
public void setInterpolator(Interpolator interpolator) {
this.interpolator = interpolator;
}
@Override
public float getNormalizedValue(Element element, Graph graph) {
return normalize(getValue(element, graph), interpolator, getMinValue(graph), getMaxValue(graph));
}
@Override
public float normalize(Number value, Interpolator interpolator, Number minValue, Number maxValue) {<FILL_FUNCTION_BODY>}
public abstract boolean isValid(Graph graph);
@Override
public Column getColumn() {
return null;
}
}
|
if (minValue.equals(maxValue)) {
return 1f;
}
float normalizedValue =
(float) (value.doubleValue() - minValue.doubleValue()) /
(float) (maxValue.doubleValue() - minValue.doubleValue());
return interpolator.interpolate(normalizedValue);
| 229
| 84
| 313
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearanceAPI/src/main/java/org/gephi/appearance/TimesetRankingImpl.java
|
TimesetRankingImpl
|
getValue
|
class TimesetRankingImpl extends AttributeRankingImpl {
public TimesetRankingImpl(Column column) {
super(column);
}
@Override
public Number getValue(Element element, Graph graph) {<FILL_FUNCTION_BODY>}
@Override
public Number getMinValue(Graph graph) {
return getIndex(graph).getMinTimestamp();
}
@Override
public Number getMaxValue(Graph graph) {
return getIndex(graph).getMaxTimestamp();
}
private TimeIndex<? extends Element> getIndex(Graph graph) {
if (this.column.get().getTable().isNodeTable()) {
return graph.getModel().getNodeTimeIndex(graph.getView());
} else {
return graph.getModel().getEdgeTimeIndex(graph.getView());
}
}
@Override
public boolean isValid(Graph graph) {
if (column.get() != null) {
TimeIndex timeIndex = getIndex(graph);
return timeIndex.getMinTimestamp() != Double.NEGATIVE_INFINITY &&
timeIndex.getMaxTimestamp() != Double.POSITIVE_INFINITY;
}
return false;
}
}
|
TimeSet timeSet = (TimeSet) element.getAttribute(column.get(), graph.getView());
if (timeSet != null) {
// TODO Make this configurable via Estimator
return timeSet.getMinDouble();
}
return null;
| 318
| 69
| 387
|
<methods>public void <init>(Column) ,public boolean equals(java.lang.Object) ,public Column getColumn() ,public java.lang.Number getMaxValue(Graph) ,public java.lang.Number getMinValue(Graph) ,public java.lang.Number getValue(Element, Graph) ,public int hashCode() ,public boolean isValid(Graph) <variables>protected final non-sealed WeakReference<Column> column
|
gephi_gephi
|
gephi/modules/AppearancePlugin/src/main/java/org/gephi/appearance/plugin/PartitionLabelColorTransformer.java
|
PartitionLabelColorTransformer
|
transform
|
class PartitionLabelColorTransformer implements PartitionTransformer<Element> {
@Override
public void transform(Element element, Partition partition, Object value) {<FILL_FUNCTION_BODY>}
@Override
public boolean isNode() {
return true;
}
@Override
public boolean isEdge() {
return true;
}
public PaletteManager getPaletteManager() {
return PaletteManager.getInstance();
}
}
|
Color color = partition.getColor(value);
if (color == null) {
color = Partition.DEFAULT_COLOR;
}
element.getTextProperties().setColor(color);
| 120
| 50
| 170
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePlugin/src/main/java/org/gephi/appearance/plugin/RankingElementColorTransformer.java
|
LinearGradient
|
hashCode
|
class LinearGradient implements Serializable, Cloneable {
private Color[] colors;
private float[] positions;
public LinearGradient(Color[] colors, float[] positions) {
if (colors == null || positions == null) {
throw new NullPointerException();
}
if (colors.length != positions.length) {
throw new IllegalArgumentException();
}
this.colors = colors;
this.positions = positions;
}
public Color getValue(float pos) {
for (int a = 0; a < positions.length - 1; a++) {
if (positions[a] == pos) {
return colors[a];
}
if (positions[a] < pos && pos < positions[a + 1]) {
float v = (pos - positions[a]) / (positions[a + 1] - positions[a]);
return tween(colors[a], colors[a + 1], v);
}
}
if (pos <= positions[0]) {
return colors[0];
}
if (pos >= positions[positions.length - 1]) {
return colors[colors.length - 1];
}
return null;
}
private Color tween(Color c1, Color c2, float p) {
return new Color(
(int) (c1.getRed() * (1 - p) + c2.getRed() * (p)),
(int) (c1.getGreen() * (1 - p) + c2.getGreen() * (p)),
(int) (c1.getBlue() * (1 - p) + c2.getBlue() * (p)),
(int) (c1.getAlpha() * (1 - p) + c2.getAlpha() * (p)));
}
public Color[] getColors() {
return colors;
}
public void setColors(Color[] colors) {
this.colors = colors;
}
public int[] getColorsAsRgba() {
return Arrays.stream(colors).mapToInt(c -> (c.getAlpha() << 24) | c.getRGB()).toArray();
}
public void setColorsAsRgba(int[] colors) {
this.colors = Arrays.stream(colors).mapToObj(rgba -> new Color(rgba, true)).toArray(Color[]::new);
}
public float[] getPositions() {
return positions;
}
public void setPositions(float[] positions) {
this.positions = positions;
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final LinearGradient other = (LinearGradient) obj;
if (!Arrays.deepEquals(this.colors, other.colors)) {
return false;
}
return Arrays.equals(this.positions, other.positions);
}
@Override
public int hashCode() {<FILL_FUNCTION_BODY>}
@Override
protected Object clone() throws CloneNotSupportedException {
LinearGradient cl = new LinearGradient(colors, positions);
return cl;
}
}
|
int hash = 3;
hash = 17 * hash + Arrays.deepHashCode(this.colors);
hash = 17 * hash + Arrays.hashCode(this.positions);
return hash;
| 850
| 55
| 905
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePlugin/src/main/java/org/gephi/appearance/plugin/RankingLabelSizeTransformer.java
|
RankingLabelSizeTransformer
|
transform
|
class RankingLabelSizeTransformer extends RankingSizeTransformer<Element> {
@Override
public void transform(Element element, Ranking ranking, Number value, float normalisedValue) {<FILL_FUNCTION_BODY>}
@Override
public boolean isNode() {
return true;
}
@Override
public boolean isEdge() {
return true;
}
}
|
float size = normalisedValue * (maxSize - minSize) + minSize;
element.getTextProperties().setSize(size);
| 101
| 35
| 136
|
<methods>public non-sealed void <init>() ,public float getMaxSize() ,public float getMinSize() ,public void setMaxSize(float) ,public void setMinSize(float) <variables>protected float maxSize,protected float minSize
|
gephi_gephi
|
gephi/modules/AppearancePlugin/src/main/java/org/gephi/appearance/plugin/RankingNodeSizeTransformer.java
|
RankingNodeSizeTransformer
|
transform
|
class RankingNodeSizeTransformer extends RankingSizeTransformer<Node> {
@Override
public void transform(Node node, Ranking ranking, Number value, float normalisedValue) {<FILL_FUNCTION_BODY>}
@Override
public boolean isNode() {
return true;
}
@Override
public boolean isEdge() {
return false;
}
}
|
float size = normalisedValue * (maxSize - minSize) + minSize;
node.setSize(size);
| 101
| 32
| 133
|
<methods>public non-sealed void <init>() ,public float getMaxSize() ,public float getMinSize() ,public void setMaxSize(float) ,public void setMinSize(float) <variables>protected float maxSize,protected float minSize
|
gephi_gephi
|
gephi/modules/AppearancePlugin/src/main/java/org/gephi/appearance/plugin/palette/Palette.java
|
Palette
|
hashCode
|
class Palette {
private final String name;
private final Color[] colors;
public Palette(Color[] colors) {
this(null, colors);
}
public Palette(String name, Color[] colors) {
this.colors = colors;
this.name = name;
}
public Color[] getColors() {
return colors;
}
public String getName() {
return name;
}
public int size() {
return colors.length;
}
@Override
public int hashCode() {<FILL_FUNCTION_BODY>}
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (obj == null) {
return false;
}
if (getClass() != obj.getClass()) {
return false;
}
final Palette other = (Palette) obj;
if ((this.name == null) ? (other.name != null) : !this.name.equals(other.name)) {
return false;
}
return Arrays.deepEquals(this.colors, other.colors);
}
}
|
int hash = 7;
hash = 29 * hash + (this.name != null ? this.name.hashCode() : 0);
hash = 29 * hash + Arrays.deepHashCode(this.colors);
return hash;
| 308
| 64
| 372
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePlugin/src/main/java/org/gephi/appearance/plugin/palette/Preset.java
|
Preset
|
toArray
|
class Preset {
private final String name;
private final boolean dark;
private final int hMin;
private final int hMax;
private final float cMin;
private final float cMax;
private final float lMin;
private final float lMax;
public Preset(String name, boolean dark, int hMin, int hMax, float cMin, float cMax, float lMin, float lMax) {
this.name = name;
this.dark = dark;
this.hMin = hMin;
this.hMax = hMax;
this.cMin = cMin;
this.cMax = cMax;
this.lMin = lMin;
this.lMax = lMax;
}
public String getName() {
return name;
}
public boolean isDark() {
return dark;
}
public int gethMin() {
return hMin;
}
public int gethMax() {
return hMax;
}
public float getcMin() {
return cMin;
}
public float getcMax() {
return cMax;
}
public float getlMin() {
return lMin;
}
public float getlMax() {
return lMax;
}
public float[] toArray() {<FILL_FUNCTION_BODY>}
@Override
public String toString() {
return name;
}
}
|
return new float[] {hMin, hMax, cMin, cMax, lMin, lMax};
| 379
| 28
| 407
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/PartitionColorTransformerPanel.java
|
PalettePopupButton
|
createPopup
|
class PalettePopupButton extends JXHyperlink {
private final PaletteManager paletteManager;
public PalettePopupButton() {
setText(NbBundle
.getMessage(PartitionColorTransformerPanel.class, "PartitionColorTransformerPanel.paletteButton"));
setFocusPainted(false);
setFocusable(false);
paletteManager = PaletteManager.getInstance();
addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
int size = function.getPartition().size(function.getGraph());
JPopupMenu menu = createPopup(size);
menu.show(PalettePopupButton.this, 0, getHeight());
}
});
}
private JPopupMenu createPopup(final int colorsCount) {<FILL_FUNCTION_BODY>}
}
|
JPopupMenu menu = new JPopupMenu();
menu.add(new JXTitledSeparator(
NbBundle.getMessage(PartitionColorTransformerPanel.class, "PalettePopup.recent")));
Collection<Palette> recentPalettes = paletteManager.getRecentPalettes();
if (recentPalettes.isEmpty()) {
menu.add(
"<html><i>" + NbBundle.getMessage(PartitionColorTransformerPanel.class, "PalettePopup.norecent") +
"</i></html>");
} else {
for (Palette pl : recentPalettes) {
if (pl.size() >= colorsCount) {
menu.add(new PaletteMenuItem(pl, Math.min(PALETTE_DISPLAY_LIMIT, colorsCount)));
}
}
}
menu.add(new JXTitledSeparator(
NbBundle.getMessage(PartitionColorTransformerPanel.class, "PalettePopup.standard")));
JMenu lightPalette =
new JMenu(NbBundle.getMessage(PartitionColorTransformerPanel.class, "PalettePopup.palette"));
for (Palette pl : paletteManager.getDefaultPalette(colorsCount)) {
lightPalette.add(new PaletteMenuItem(pl, Math.min(PALETTE_DISPLAY_LIMIT, colorsCount)));
}
menu.add(lightPalette);
JMenuItem allGrey =
new JMenuItem(NbBundle.getMessage(PartitionColorTransformerPanel.class, "PalettePopup.allgrey"));
allGrey.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
applyColor(Color.LIGHT_GRAY);
}
});
menu.add(allGrey);
JMenuItem allWhite =
new JMenuItem(NbBundle.getMessage(PartitionColorTransformerPanel.class, "PalettePopup.allwhite"));
allWhite.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
applyColor(Color.WHITE);
}
});
menu.add(allWhite);
JMenuItem generate =
new JMenuItem(NbBundle.getMessage(PartitionColorTransformerPanel.class, "PalettePopup.generate"));
generate.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
PaletteGeneratorPanel pgn = new PaletteGeneratorPanel();
pgn.setup(colorsCount);
NotifyDescriptor nd = new NotifyDescriptor(pgn,
NbBundle.getMessage(PartitionColorTransformerPanel.class,
"PartitionColorTransformerPanel.generatePalettePanel.title"),
NotifyDescriptor.OK_CANCEL_OPTION,
NotifyDescriptor.DEFAULT_OPTION, null, null);
if (DialogDisplayer.getDefault().notify(nd) == NotifyDescriptor.OK_OPTION) {
Palette pl = pgn.getSelectedPalette();
if (pl != null) {
applyPalette(pl);
}
}
}
});
menu.add(generate);
return menu;
| 220
| 814
| 1,034
|
<methods>public void <init>() ,public void <init>(java.awt.LayoutManager) ,public void <init>(boolean) ,public void <init>(java.awt.LayoutManager, boolean) ,public javax.accessibility.AccessibleContext getAccessibleContext() ,public javax.swing.plaf.PanelUI getUI() ,public java.lang.String getUIClassID() ,public void setUI(javax.swing.plaf.PanelUI) ,public void updateUI() <variables>private static final java.lang.String uiClassID
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/PartitionElementColorTransformerUI.java
|
PartitionElementColorTransformerUI
|
getPanel
|
class PartitionElementColorTransformerUI implements TransformerUI {
private PartitionColorTransformerPanel panel;
@Override
public TransformerCategory getCategory() {
return DefaultCategory.COLOR;
}
@Override
public String getDisplayName() {
return NbBundle.getMessage(PartitionElementColorTransformerUI.class, "Attribute.partition.name");
}
@Override
public Icon getIcon() {
return null;
}
@Override
public String getDescription() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
if (panel == null) {
panel = new PartitionColorTransformerPanel();
}
return new AbstractButton[] {panel.getPaletteButton()};
}
@Override
public Class<? extends PartitionTransformer> getTransformerClass() {
return PartitionElementColorTransformer.class;
}
}
|
if (panel == null) {
panel = new PartitionColorTransformerPanel();
}
panel.setup((PartitionFunction) function);
return panel;
| 269
| 43
| 312
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/PartitionLabelColorTransformerUI.java
|
PartitionLabelColorTransformerUI
|
getControlButton
|
class PartitionLabelColorTransformerUI implements TransformerUI {
private PartitionColorTransformerPanel panel;
@Override
public TransformerCategory getCategory() {
return DefaultCategory.LABEL_COLOR;
}
@Override
public String getDisplayName() {
return NbBundle.getMessage(PartitionLabelColorTransformerUI.class, "Attribute.partition.name");
}
@Override
public Icon getIcon() {
return null;
}
@Override
public String getDescription() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {
if (panel == null) {
panel = new PartitionColorTransformerPanel();
}
panel.setup((PartitionFunction) function);
return panel;
}
@Override
public synchronized AbstractButton[] getControlButton() {<FILL_FUNCTION_BODY>}
@Override
public Class<? extends PartitionTransformer> getTransformerClass() {
return PartitionLabelColorTransformer.class;
}
}
|
if (panel == null) {
panel = new PartitionColorTransformerPanel();
}
return new AbstractButton[] {panel.getPaletteButton()};
| 273
| 43
| 316
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/RankingElementColorTransformerUI.java
|
RankingElementColorTransformerUI
|
getPanel
|
class RankingElementColorTransformerUI implements TransformerUI {
private RankingColorTransformerPanel panel;
@Override
public TransformerCategory getCategory() {
return DefaultCategory.COLOR;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public String getDisplayName() {
return NbBundle.getMessage(RankingElementColorTransformerUI.class, "Attribute.ranking.name");
}
@Override
public String getDescription() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends RankingTransformer> getTransformerClass() {
return RankingElementColorTransformer.class;
}
}
|
if (panel == null) {
panel = new RankingColorTransformerPanel();
}
panel.setup((RankingFunction) function);
return panel;
| 237
| 45
| 282
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/RankingElementSizeTransformerUI.java
|
RankingElementSizeTransformerUI
|
getPanel
|
class RankingElementSizeTransformerUI implements TransformerUI {
private RankingSizeTransformerPanel panel;
@Override
public TransformerCategory getCategory() {
return DefaultCategory.SIZE;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public String getDisplayName() {
return NbBundle.getMessage(RankingElementSizeTransformerUI.class, "Attribute.ranking.name");
}
@Override
public String getDescription() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends RankingTransformer> getTransformerClass() {
return RankingNodeSizeTransformer.class;
}
}
|
if (panel == null) {
panel = new RankingSizeTransformerPanel();
}
panel.setup((RankingFunction) function);
return panel;
| 237
| 45
| 282
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/RankingLabelColorTransformerUI.java
|
RankingLabelColorTransformerUI
|
getPanel
|
class RankingLabelColorTransformerUI implements TransformerUI {
private RankingColorTransformerPanel panel;
@Override
public TransformerCategory getCategory() {
return DefaultCategory.LABEL_COLOR;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public String getDisplayName() {
return NbBundle.getMessage(RankingLabelColorTransformerUI.class, "Attribute.ranking.name");
}
@Override
public String getDescription() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends RankingTransformer> getTransformerClass() {
return RankingLabelColorTransformer.class;
}
}
|
if (panel == null) {
panel = new RankingColorTransformerPanel();
}
panel.setup((RankingFunction) function);
return panel;
| 241
| 45
| 286
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/RankingLabelSizeTransformerUI.java
|
RankingLabelSizeTransformerUI
|
getPanel
|
class RankingLabelSizeTransformerUI implements TransformerUI {
private RankingSizeTransformerPanel panel;
@Override
public TransformerCategory getCategory() {
return DefaultCategory.LABEL_SIZE;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public String getDisplayName() {
return NbBundle.getMessage(RankingLabelSizeTransformerUI.class, "Attribute.ranking.name");
}
@Override
public String getDescription() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends RankingTransformer> getTransformerClass() {
return RankingLabelSizeTransformer.class;
}
}
|
if (panel == null) {
panel = new RankingSizeTransformerPanel();
}
panel.setup((RankingFunction) function);
return panel;
| 241
| 45
| 286
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/RankingSizeTransformerPanel.java
|
RankingSizeTransformerPanel
|
initComponents
|
class RankingSizeTransformerPanel extends javax.swing.JPanel {
// Variables declaration - do not modify//GEN-BEGIN:variables
private RankingSizeTransformer sizeTransformer;
private javax.swing.JSpinner maxSize;
private javax.swing.JSpinner minSize;
// End of variables declaration//GEN-END:variables
public RankingSizeTransformerPanel() {
initComponents();
}
public void setup(RankingFunction function) {
sizeTransformer = function.getTransformer();
minSize.setValue(sizeTransformer.getMinSize());
maxSize.setValue(sizeTransformer.getMaxSize());
minSize.addChangeListener(e -> {
sizeTransformer.setMinSize((Float) minSize.getValue());
});
maxSize.addChangeListener(e -> {
sizeTransformer.setMaxSize((Float) maxSize.getValue());
});
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {<FILL_FUNCTION_BODY>}// </editor-fold>//GEN-END:initComponents
}
|
javax.swing.JLabel labelMinSize = new javax.swing.JLabel();
minSize = new javax.swing.JSpinner();
// Variables declaration - do not modify//GEN-BEGIN:variables
javax.swing.JLabel labelMaxSize = new javax.swing.JLabel();
maxSize = new javax.swing.JSpinner();
setPreferredSize(new java.awt.Dimension(225, 114));
labelMinSize.setText(org.openide.util.NbBundle
.getMessage(RankingSizeTransformerPanel.class, "RankingSizeTransformerPanel.labelMinSize.text")); // NOI18N
minSize.setModel(new javax.swing.SpinnerNumberModel(1.0f, 0.01f, null, 0.5f));
labelMaxSize.setText(org.openide.util.NbBundle
.getMessage(RankingSizeTransformerPanel.class, "RankingSizeTransformerPanel.labelMaxSize.text")); // NOI18N
maxSize.setModel(new javax.swing.SpinnerNumberModel(4.0f, 0.5f, null, 0.5f));
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
this.setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(labelMinSize)
.addGap(8, 8, 8)
.addComponent(minSize, javax.swing.GroupLayout.PREFERRED_SIZE, 60,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addGap(18, 18, 18)
.addComponent(labelMaxSize)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(maxSize, javax.swing.GroupLayout.PREFERRED_SIZE, 60,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(minSize, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(maxSize, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addComponent(labelMaxSize)
.addComponent(labelMinSize))
.addContainerGap(80, Short.MAX_VALUE))
);
| 366
| 801
| 1,167
|
<methods>public void <init>() ,public void <init>(java.awt.LayoutManager) ,public void <init>(boolean) ,public void <init>(java.awt.LayoutManager, boolean) ,public javax.accessibility.AccessibleContext getAccessibleContext() ,public javax.swing.plaf.PanelUI getUI() ,public java.lang.String getUIClassID() ,public void setUI(javax.swing.plaf.PanelUI) ,public void updateUI() <variables>private static final java.lang.String uiClassID
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/RecentPalettes.java
|
RecentPalettes
|
store
|
class RecentPalettes {
public static final String COLORS = "PaletteColors";
public static final String POSITIONS = "PalettePositions";
protected static String DEFAULT_NODE_NAME = "prefs";
private final LinkedList<LinearGradient> gradients;
private final int maxSize;
protected String nodeName = null;
public RecentPalettes() {
nodeName = "recentrankingpalettes";
maxSize = 14;
gradients = new LinkedList<>();
retrieve();
}
public void add(LinearGradient gradient) {
//Remove the old
gradients.remove(gradient);
// add to the top
gradients.push(new LinearGradient(gradient.getColors(), gradient.getPositions()));
while (gradients.size() > maxSize) {
gradients.removeLast();
}
store();
}
public LinearGradient[] getPalettes() {
return gradients.toArray(new LinearGradient[0]);
}
private void store() {<FILL_FUNCTION_BODY>}
private void retrieve() {
gradients.clear();
Preferences prefs = getPreferences();
for (int i = 0; i < maxSize; i++) {
byte[] cols = prefs.getByteArray(COLORS + i, null);
byte[] poss = prefs.getByteArray(POSITIONS + i, null);
if (cols != null && poss != null) {
try {
Color[] colors = deserializeColors(cols);
float[] posisitons = deserializePositions(poss);
LinearGradient linearGradient = new LinearGradient(colors, posisitons);
gradients.addLast(linearGradient);
} catch (Exception e) {
Exceptions.printStackTrace(e);
}
} else {
break;
}
}
}
/**
* Return the backing store Preferences
*
* @return Preferences
*/
protected final Preferences getPreferences() {
String name = DEFAULT_NODE_NAME;
if (nodeName != null) {
name = nodeName;
}
Preferences prefs = NbPreferences.forModule(this.getClass()).node("options").node(name);
return prefs;
}
private byte[] serializePositions(float[] positions) throws Exception {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try (ObjectOutputStream out = new ObjectOutputStream(bos)) {
out.writeObject(positions);
}
return bos.toByteArray();
}
private float[] deserializePositions(byte[] positions) throws Exception {
ByteArrayInputStream bis = new ByteArrayInputStream(positions);
float[] array;
try (ObjectInputStream in = new ObjectInputStream(bis)) {
array = (float[]) in.readObject();
}
return array;
}
private byte[] serializeColors(Color[] colors) throws Exception {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try (ObjectOutputStream out = new ObjectOutputStream(bos)) {
out.writeObject(colors);
}
return bos.toByteArray();
}
private Color[] deserializeColors(byte[] colors) throws Exception {
ByteArrayInputStream bis = new ByteArrayInputStream(colors);
Color[] array;
try (ObjectInputStream in = new ObjectInputStream(bis)) {
array = (Color[]) in.readObject();
}
return array;
}
}
|
Preferences prefs = getPreferences();
// clear the backing store
try {
prefs.clear();
} catch (BackingStoreException ex) {
}
int i = 0;
for (LinearGradient gradient : gradients) {
try {
prefs.putByteArray(COLORS + i, serializeColors(gradient.getColors()));
prefs.putByteArray(POSITIONS + i, serializePositions(gradient.getPositions()));
} catch (Exception e) {
Exceptions.printStackTrace(e);
}
i++;
}
| 905
| 154
| 1,059
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/UniqueColorTransformerPanel.java
|
UniqueColorTransformerPanel
|
initComponents
|
class UniqueColorTransformerPanel extends javax.swing.JPanel {
private AbstractUniqueColorTransformer transformer;
// Variables declaration - do not modify//GEN-BEGIN:variables
private net.java.dev.colorchooser.ColorChooser colorChooser;
private javax.swing.JLabel colorLabel;
// End of variables declaration//GEN-END:variables
public UniqueColorTransformerPanel() {
initComponents();
colorChooser.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
if (evt.getPropertyName().equals(ColorChooser.PROP_COLOR)) {
if (!transformer.getColor().equals(colorChooser.getColor())) {
transformer.setColor(colorChooser.getColor());
colorLabel.setText(getHex(colorChooser.getColor()));
}
}
}
});
}
public void setup(SimpleFunction function) {
transformer = function.getTransformer();
colorChooser.setColor(transformer.getColor());
colorLabel.setText(getHex(transformer.getColor()));
}
private String getHex(Color color) {
return "#" + String.format("%06x", color.getRGB() & 0x00FFFFFF);
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {<FILL_FUNCTION_BODY>}// </editor-fold>//GEN-END:initComponents
}
|
colorChooser = new net.java.dev.colorchooser.ColorChooser();
colorLabel = new javax.swing.JLabel();
colorChooser.setMinimumSize(new java.awt.Dimension(14, 14));
colorChooser.setPreferredSize(new java.awt.Dimension(14, 14));
colorChooser.setToolTipText(org.openide.util.NbBundle.getMessage(UniqueColorTransformerPanel.class,
"UniqueColorTransformerPanel.colorChooser.toolTipText")); // NOI18N
javax.swing.GroupLayout colorChooserLayout = new javax.swing.GroupLayout(colorChooser);
colorChooser.setLayout(colorChooserLayout);
colorChooserLayout.setHorizontalGroup(
colorChooserLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 12, Short.MAX_VALUE)
);
colorChooserLayout.setVerticalGroup(
colorChooserLayout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGap(0, 12, Short.MAX_VALUE)
);
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
this.setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(colorChooser, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(colorLabel, javax.swing.GroupLayout.PREFERRED_SIZE, 380,
javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap())
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addComponent(colorLabel)
.addComponent(colorChooser, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
.addGap(278, 278, 278))
);
| 476
| 710
| 1,186
|
<methods>public void <init>() ,public void <init>(java.awt.LayoutManager) ,public void <init>(boolean) ,public void <init>(java.awt.LayoutManager, boolean) ,public javax.accessibility.AccessibleContext getAccessibleContext() ,public javax.swing.plaf.PanelUI getUI() ,public java.lang.String getUIClassID() ,public void setUI(javax.swing.plaf.PanelUI) ,public void updateUI() <variables>private static final java.lang.String uiClassID
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/UniqueElementColorTransformerUI.java
|
UniqueElementColorTransformerUI
|
getPanel
|
class UniqueElementColorTransformerUI implements TransformerUI {
private UniqueColorTransformerPanel panel;
@Override
public String getDisplayName() {
return NbBundle.getMessage(UniqueElementColorTransformerUI.class, "Unique.name");
}
@Override
public TransformerCategory getCategory() {
return DefaultCategory.COLOR;
}
@Override
public String getDescription() {
return null;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends SimpleTransformer> getTransformerClass() {
return UniqueElementColorTransformer.class;
}
}
|
if (panel == null) {
panel = new UniqueColorTransformerPanel();
}
panel.setup((SimpleFunction) function);
return panel;
| 233
| 43
| 276
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/UniqueLabelColorTransformerUI.java
|
UniqueLabelColorTransformerUI
|
getPanel
|
class UniqueLabelColorTransformerUI implements TransformerUI {
private UniqueColorTransformerPanel panel;
@Override
public String getDisplayName() {
return NbBundle.getMessage(UniqueLabelColorTransformerUI.class, "Unique.name");
}
@Override
public TransformerCategory getCategory() {
return DefaultCategory.LABEL_COLOR;
}
@Override
public String getDescription() {
return null;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends SimpleTransformer> getTransformerClass() {
return UniqueLabelColorTransformer.class;
}
}
|
if (panel == null) {
panel = new UniqueColorTransformerPanel();
}
panel.setup((SimpleFunction) function);
return panel;
| 237
| 43
| 280
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/UniqueLabelSizeTransformerUI.java
|
UniqueLabelSizeTransformerUI
|
getPanel
|
class UniqueLabelSizeTransformerUI implements TransformerUI {
private UniqueSizeTransformerPanel panel;
@Override
public String getDisplayName() {
return NbBundle.getMessage(UniqueLabelSizeTransformerUI.class, "Unique.name");
}
@Override
public TransformerCategory getCategory() {
return DefaultCategory.LABEL_SIZE;
}
@Override
public String getDescription() {
return null;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends SimpleTransformer> getTransformerClass() {
return UniqueLabelSizeTransformer.class;
}
}
|
if (panel == null) {
panel = new UniqueSizeTransformerPanel();
}
panel.setup((SimpleFunction) function);
return panel;
| 237
| 43
| 280
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/UniqueNodeSizeTransformerUI.java
|
UniqueNodeSizeTransformerUI
|
getPanel
|
class UniqueNodeSizeTransformerUI implements TransformerUI {
private UniqueSizeTransformerPanel panel;
@Override
public String getDisplayName() {
return NbBundle.getMessage(UniqueNodeSizeTransformerUI.class, "Unique.name");
}
@Override
public TransformerCategory getCategory() {
return DefaultCategory.SIZE;
}
@Override
public String getDescription() {
return null;
}
@Override
public Icon getIcon() {
return null;
}
@Override
public synchronized JPanel getPanel(Function function) {<FILL_FUNCTION_BODY>}
@Override
public synchronized AbstractButton[] getControlButton() {
return null;
}
@Override
public Class<? extends SimpleTransformer> getTransformerClass() {
return UniqueNodeSizeTransformer.class;
}
}
|
if (panel == null) {
panel = new UniqueSizeTransformerPanel();
}
panel.setup((SimpleFunction) function);
return panel;
| 233
| 43
| 276
|
<no_super_class>
|
gephi_gephi
|
gephi/modules/AppearancePluginUI/src/main/java/org/gephi/ui/appearance/plugin/UniqueSizeTransformerPanel.java
|
UniqueSizeTransformerPanel
|
initComponents
|
class UniqueSizeTransformerPanel extends javax.swing.JPanel {
private AbstractUniqueSizeTransformer transformer;
// Variables declaration - do not modify//GEN-BEGIN:variables
private javax.swing.JLabel jLabel1;
private javax.swing.JSpinner sizeSpinner;
// End of variables declaration//GEN-END:variables
public UniqueSizeTransformerPanel() {
initComponents();
sizeSpinner.addChangeListener(new ChangeListener() {
@Override
public void stateChanged(ChangeEvent e) {
transformer.setSize((Float) sizeSpinner.getValue());
}
});
}
public void setup(SimpleFunction function) {
transformer = function.getTransformer();
sizeSpinner.setValue(transformer.getSize());
}
/**
* This method is called from within the constructor to initialize the form.
* WARNING: Do NOT modify this code. The content of this method is always
* regenerated by the Form Editor.
*/
@SuppressWarnings("unchecked")
// <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
private void initComponents() {<FILL_FUNCTION_BODY>}// </editor-fold>//GEN-END:initComponents
}
|
jLabel1 = new javax.swing.JLabel();
sizeSpinner = new javax.swing.JSpinner();
jLabel1.setText(org.openide.util.NbBundle
.getMessage(UniqueSizeTransformerPanel.class, "UniqueSizeTransformerPanel.jLabel1.text")); // NOI18N
sizeSpinner.setModel(
new javax.swing.SpinnerNumberModel(1.0f, 0.01f, null, 0.5f));
javax.swing.GroupLayout layout = new javax.swing.GroupLayout(this);
this.setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addComponent(jLabel1)
.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
.addComponent(sizeSpinner, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
.addContainerGap(294, Short.MAX_VALUE))
);
layout.setVerticalGroup(
layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
.addGroup(layout.createSequentialGroup()
.addContainerGap()
.addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
.addComponent(jLabel1)
.addComponent(sizeSpinner, javax.swing.GroupLayout.PREFERRED_SIZE,
javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE))
.addContainerGap(266, Short.MAX_VALUE))
);
| 331
| 484
| 815
|
<methods>public void <init>() ,public void <init>(java.awt.LayoutManager) ,public void <init>(boolean) ,public void <init>(java.awt.LayoutManager, boolean) ,public javax.accessibility.AccessibleContext getAccessibleContext() ,public javax.swing.plaf.PanelUI getUI() ,public java.lang.String getUIClassID() ,public void setUI(javax.swing.plaf.PanelUI) ,public void updateUI() <variables>private static final java.lang.String uiClassID
|
gephi_gephi
|
gephi/modules/DBDrivers/src/main/java/org/gephi/io/database/drivers/MySQLDriver.java
|
MySQLDriver
|
equals
|
class MySQLDriver implements SQLDriver {
public MySQLDriver() {
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException ex) {
Logger.getLogger(MySQLDriver.class.getName()).log(Level.SEVERE, null, ex);
}
}
@Override
public Connection getConnection(String connectionUrl, String username, String passwd) throws SQLException {
return DriverManager.getConnection(connectionUrl, username, passwd);
}
@Override
public String getPrefix() {
return "mysql";
}
@Override
public String toString() {
return "MySQL";
}
@Override
public boolean equals(Object obj) {<FILL_FUNCTION_BODY>}
@Override
public int hashCode() {
return getPrefix().hashCode();
}
}
|
if (obj instanceof MySQLDriver) {
return ((MySQLDriver) obj).getPrefix().equals(getPrefix());
} else {
return false;
}
| 227
| 44
| 271
|
<no_super_class>
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.