Datasets:

---

CM

/

codexglue_code2text_java

like 4

[ "private", "boolean", "nodeAttribute", "(", "Node", "node", ",", "String", "attributeName", ",", "boolean", "defaultValue", ")", "{", "boolean", "value", "=", "defaultValue", ";", "if", "(", "node", ".", "hasAttributes", "(", ")", ")", "{", "Node", "attribute", "=", "node", ".", "getAttributes", "(", ")", ".", "getNamedItem", "(", "attributeName", ")", ";", "if", "(", "attribute", "!=", "null", ")", "{", "value", "=", "Boolean", ".", "valueOf", "(", "attribute", ".", "getNodeValue", "(", ")", ")", ";", "}", "}", "return", "value", ";", "}" ]

[ "Return", "node", "attribute", "value", "if", "exists", "or", "default", "attribute", "value" ]

[ "private", "boolean", "nodeHasAttribute", "(", "Node", "node", ",", "String", "attributeName", ")", "{", "return", "node", ".", "hasAttributes", "(", ")", "&&", "node", ".", "getAttributes", "(", ")", ".", "getNamedItem", "(", "attributeName", ")", "!=", "null", ";", "}" ]

[ "Check", "node", "attribute", "." ]

[ "public", "boolean", "parse", "(", "Context", "context", ")", "throws", "NestingException", "{", "boolean", "flag", "=", "true", ";", "Source", "source", "=", "context", ".", "getSource", "(", ")", ";", "int", "offset", "=", "source", ".", "getOffset", "(", ")", ";", "// Log start parsing", "if", "(", "log", ".", "isTraceEnabled", "(", ")", ")", "{", "log", ".", "trace", "(", "\"[{}] Begin {}\"", ",", "offset", ",", "this", ")", ";", "}", "int", "i", ";", "for", "(", "i", "=", "0", ";", "i", "<", "patternSize", "&&", "flag", ";", "i", "++", ")", "{", "ProcPatternElement", "current", "=", "elements", ".", "get", "(", "i", ")", ";", "ProcPatternElement", "next", ";", "if", "(", "i", "<", "patternSize", "-", "1", ")", "{", "next", "=", "elements", ".", "get", "(", "i", "+", "1", ")", ";", "}", "else", "{", "next", "=", "context", ".", "getTerminator", "(", ")", ";", "}", "flag", "=", "current", ".", "parse", "(", "context", ",", "next", ")", ";", "}", "if", "(", "!", "flag", ")", "{", "if", "(", "log", ".", "isTraceEnabled", "(", ")", ")", "{", "log", ".", "trace", "(", "\"[{}] Rollback {} on {} element\"", ",", "source", ".", "getOffset", "(", ")", ",", "this", ",", "i", ")", ";", "}", "source", ".", "setOffset", "(", "offset", ")", ";", "}", "else", "{", "if", "(", "log", ".", "isTraceEnabled", "(", ")", ")", "{", "log", ".", "trace", "(", "\"[{}] Complete {}\"", ",", "source", ".", "getOffset", "(", ")", ",", "this", ")", ";", "}", "}", "return", "flag", ";", "}" ]

[ "Parse", "context", "with", "this", "pattern" ]

[ "public", "boolean", "process", "(", "Context", "context", ")", "throws", "NestingException", "{", "for", "(", "ProcPattern", "pattern", ":", "patterns", ")", "{", "Context", "codeContext", "=", "new", "Context", "(", "context", ")", ";", "if", "(", "pattern", ".", "parse", "(", "codeContext", ")", ")", "{", "if", "(", "transparent", ")", "{", "codeContext", ".", "mergeWithParent", "(", ")", ";", "}", "template", ".", "generate", "(", "codeContext", ")", ";", "if", "(", "logContext", ".", "isTraceEnabled", "(", ")", ")", "{", "for", "(", "Map", ".", "Entry", "<", "String", ",", "CharSequence", ">", "entry", ":", "context", ".", "getAttributes", "(", ")", ".", "entrySet", "(", ")", ")", "{", "logContext", ".", "trace", "(", "\"Context: {} = {}\"", ",", "entry", ".", "getKey", "(", ")", ",", "entry", ".", "getValue", "(", ")", ")", ";", "}", "}", "if", "(", "logGenerate", ".", "isTraceEnabled", "(", ")", ")", "{", "logGenerate", ".", "trace", "(", "\"Generated text: {}\"", ",", "codeContext", ".", "getTarget", "(", ")", ")", ";", "}", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Parse", "bb", "-", "code" ]

[ "public", "boolean", "suspicious", "(", "Context", "context", ")", "{", "for", "(", "ProcPattern", "pattern", ":", "patterns", ")", "{", "if", "(", "pattern", ".", "suspicious", "(", "context", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "if", "next", "sequence", "can", "be", "parsed", "with", "this", "code", ".", "It", "s", "most", "called", "method", "in", "this", "project", "." ]

[ "public", "static", "InputStream", "openResourceStream", "(", "String", "resourceName", ")", "{", "InputStream", "stream", "=", "null", ";", "ClassLoader", "classLoader", "=", "Utils", ".", "class", ".", "getClassLoader", "(", ")", ";", "if", "(", "classLoader", "!=", "null", ")", "{", "stream", "=", "classLoader", ".", "getResourceAsStream", "(", "resourceName", ")", ";", "}", "if", "(", "stream", "==", "null", ")", "{", "stream", "=", "ClassLoader", ".", "getSystemResourceAsStream", "(", "resourceName", ")", ";", "}", "return", "stream", ";", "}" ]

[ "Open", "the", "resource", "stream", "for", "named", "resource", ".", "Stream", "must", "be", "closed", "by", "user", "after", "usage", "." ]

[ "private", "char", "[", "]", "getConstantChars", "(", ")", "{", "Set", "<", "Character", ">", "chars", "=", "new", "TreeSet", "<", "Character", ">", "(", ")", ";", "chars", ".", "add", "(", "'", "'", ")", ";", "chars", ".", "add", "(", "'", "'", ")", ";", "for", "(", "PatternConstant", "constant", ":", "constantSet", ")", "{", "char", "c", "=", "constant", ".", "getValue", "(", ")", ".", "charAt", "(", "0", ")", ";", "if", "(", "constant", ".", "isIgnoreCase", "(", ")", ")", "{", "chars", ".", "add", "(", "Character", ".", "toLowerCase", "(", "c", ")", ")", ";", "chars", ".", "add", "(", "Character", ".", "toUpperCase", "(", "c", ")", ")", ";", "}", "else", "{", "chars", ".", "add", "(", "c", ")", ";", "}", "}", "char", "[", "]", "cs", "=", "new", "char", "[", "chars", ".", "size", "(", ")", "]", ";", "int", "j", "=", "0", ";", "for", "(", "Character", "c", ":", "chars", ")", "{", "cs", "[", "j", "]", "=", "c", ";", "j", "++", ";", "}", "Arrays", ".", "sort", "(", "cs", ")", ";", "return", "cs", ";", "}" ]

[ "Collect", "first", "chars", "of", "constants", "of", "configuration", "." ]

[ "public", "boolean", "nextIs", "(", "PatternConstant", "constant", ")", "{", "char", "[", "]", "cs", "=", "constant", ".", "getCharArray", "(", ")", ";", "int", "length", "=", "cs", ".", "length", ";", "if", "(", "length", ">", "textLength", "-", "offset", ")", "{", "return", "false", ";", "}", "if", "(", "!", "constant", ".", "isIgnoreCase", "(", ")", ")", "{", "int", "i", ";", "//noinspection StatementWithEmptyBody", "for", "(", "i", "=", "0", ";", "i", "<", "length", "&&", "text", "[", "offset", "+", "i", "]", "==", "cs", "[", "i", "]", ";", "i", "++", ")", ";", "return", "i", "==", "length", ";", "}", "else", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "length", ";", "i", "++", ")", "{", "char", "ct", "=", "text", "[", "offset", "+", "i", "]", ";", "char", "cv", "=", "cs", "[", "i", "]", ";", "if", "(", "ct", "==", "cv", "||", "Character", ".", "toUpperCase", "(", "ct", ")", "==", "Character", ".", "toUpperCase", "(", "cv", ")", "||", "Character", ".", "toLowerCase", "(", "ct", ")", "==", "Character", ".", "toLowerCase", "(", "cv", ")", ")", "{", "continue", ";", "}", "return", "false", ";", "}", "return", "true", ";", "}", "}" ]

[ "Test", "id", "next", "sequence", "the", "constant?" ]

[ "public", "int", "find", "(", "PatternConstant", "constant", ")", "{", "char", "[", "]", "cs", "=", "constant", ".", "getCharArray", "(", ")", ";", "boolean", "ignoreCase", "=", "constant", ".", "isIgnoreCase", "(", ")", ";", "return", "find", "(", "cs", ",", "ignoreCase", ")", ";", "}" ]

[ "Find", "constant", "in", "source", "text", "." ]

[ "public", "void", "generate", "(", "Context", "context", ")", "{", "Appendable", "target", "=", "context", ".", "getTarget", "(", ")", ";", "for", "(", "ProcTemplateElement", "element", ":", "elements", ")", "{", "try", "{", "target", ".", "append", "(", "element", ".", "generate", "(", "context", ")", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "// Nothing! Because StringBuilder doesn't catch IOException", "}", "}", "}" ]

[ "Append", "to", "result", "string", "processed", "text", "." ]

[ "public", "int", "getCurrentPosition", "(", ")", "{", "int", "curPosition", "=", "-", "1", ";", "if", "(", "getLayoutManager", "(", ")", ".", "canScrollHorizontally", "(", ")", ")", "{", "curPosition", "=", "ViewUtils", ".", "getCenterXChildPosition", "(", "this", ")", ";", "}", "else", "{", "curPosition", "=", "ViewUtils", ".", "getCenterYChildPosition", "(", "this", ")", ";", "}", "if", "(", "curPosition", "<", "0", ")", "{", "curPosition", "=", "mSmoothScrollTargetPosition", ";", "}", "return", "curPosition", ";", "}" ]

[ "get", "item", "position", "in", "center", "of", "viewpager" ]

[ "public", "static", "View", "getCenterXChild", "(", "RecyclerView", "recyclerView", ")", "{", "int", "childCount", "=", "recyclerView", ".", "getChildCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "childCount", ";", "i", "++", ")", "{", "View", "child", "=", "recyclerView", ".", "getChildAt", "(", "i", ")", ";", "if", "(", "isChildInCenterX", "(", "recyclerView", ",", "child", ")", ")", "{", "return", "child", ";", "}", "}", "return", "null", ";", "}" ]

[ "Get", "center", "child", "in", "X", "Axes" ]

[ "public", "static", "int", "getCenterXChildPosition", "(", "RecyclerView", "recyclerView", ")", "{", "int", "childCount", "=", "recyclerView", ".", "getChildCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "childCount", ";", "i", "++", ")", "{", "View", "child", "=", "recyclerView", ".", "getChildAt", "(", "i", ")", ";", "if", "(", "isChildInCenterX", "(", "recyclerView", ",", "child", ")", ")", "{", "return", "recyclerView", ".", "getChildAdapterPosition", "(", "child", ")", ";", "}", "}", "return", "childCount", ";", "}" ]

[ "Get", "position", "of", "center", "child", "in", "X", "Axes" ]

[ "public", "static", "View", "getCenterYChild", "(", "RecyclerView", "recyclerView", ")", "{", "int", "childCount", "=", "recyclerView", ".", "getChildCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "childCount", ";", "i", "++", ")", "{", "View", "child", "=", "recyclerView", ".", "getChildAt", "(", "i", ")", ";", "if", "(", "isChildInCenterY", "(", "recyclerView", ",", "child", ")", ")", "{", "return", "child", ";", "}", "}", "return", "null", ";", "}" ]

[ "Get", "center", "child", "in", "Y", "Axes" ]

[ "public", "static", "int", "getCenterYChildPosition", "(", "RecyclerView", "recyclerView", ")", "{", "int", "childCount", "=", "recyclerView", ".", "getChildCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "childCount", ";", "i", "++", ")", "{", "View", "child", "=", "recyclerView", ".", "getChildAt", "(", "i", ")", ";", "if", "(", "isChildInCenterY", "(", "recyclerView", ",", "child", ")", ")", "{", "return", "recyclerView", ".", "getChildAdapterPosition", "(", "child", ")", ";", "}", "}", "return", "childCount", ";", "}" ]

[ "Get", "position", "of", "center", "child", "in", "Y", "Axes" ]

[ "public", "void", "setStatusBarColor", "(", "View", "statusBar", ",", "int", "color", ")", "{", "if", "(", "Build", ".", "VERSION", ".", "SDK_INT", ">=", "Build", ".", "VERSION_CODES", ".", "KITKAT", ")", "{", "Window", "w", "=", "getWindow", "(", ")", ";", "w", ".", "setFlags", "(", "WindowManager", ".", "LayoutParams", ".", "FLAG_TRANSLUCENT_STATUS", ",", "WindowManager", ".", "LayoutParams", ".", "FLAG_TRANSLUCENT_STATUS", ")", ";", "//status bar height", "int", "actionBarHeight", "=", "getActionBarHeight", "(", ")", ";", "int", "statusBarHeight", "=", "getStatusBarHeight", "(", ")", ";", "// System.out.println(\"actionBarHeight:\" + actionBarHeight);", "// System.out.println(\"statusBarHeight:\" + statusBarHeight);", "//action bar height", "statusBar", ".", "getLayoutParams", "(", ")", ".", "height", "=", "statusBarHeight", ";", "statusBar", ".", "setBackgroundColor", "(", "color", ")", ";", "}", "}" ]

[ "only", "work", "for", ">", "=", "19" ]

[ "private", "void", "clipViewOnTheRight", "(", "Rect", "curViewBound", ",", "float", "curViewWidth", ",", "int", "right", ")", "{", "curViewBound", ".", "right", "=", "(", "int", ")", "(", "right", "-", "mClipPadding", ")", ";", "curViewBound", ".", "left", "=", "(", "int", ")", "(", "curViewBound", ".", "right", "-", "curViewWidth", ")", ";", "}" ]

[ "Set", "bounds", "for", "the", "right", "textView", "including", "clip", "padding", "." ]

[ "private", "void", "clipViewOnTheLeft", "(", "Rect", "curViewBound", ",", "float", "curViewWidth", ",", "int", "left", ")", "{", "curViewBound", ".", "left", "=", "(", "int", ")", "(", "left", "+", "mClipPadding", ")", ";", "curViewBound", ".", "right", "=", "(", "int", ")", "(", "mClipPadding", "+", "curViewWidth", ")", ";", "}" ]

[ "Set", "bounds", "for", "the", "left", "textView", "including", "clip", "padding", "." ]

[ "private", "ArrayList", "<", "Rect", ">", "calculateAllBounds", "(", "Paint", "paint", ")", "{", "ArrayList", "<", "Rect", ">", "list", "=", "new", "ArrayList", "<", "Rect", ">", "(", ")", ";", "//For each views (If no values then add a fake one)", "final", "int", "count", "=", "mRecyclerView", ".", "getAdapter", "(", ")", ".", "getItemCount", "(", ")", ";", "final", "int", "width", "=", "getWidth", "(", ")", ";", "final", "int", "halfWidth", "=", "width", "/", "2", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "count", ";", "i", "++", ")", "{", "Rect", "bounds", "=", "calcBounds", "(", "i", ",", "paint", ")", ";", "int", "w", "=", "bounds", ".", "right", "-", "bounds", ".", "left", ";", "int", "h", "=", "bounds", ".", "bottom", "-", "bounds", ".", "top", ";", "bounds", ".", "left", "=", "(", "int", ")", "(", "halfWidth", "-", "(", "w", "/", "2f", ")", "+", "(", "(", "i", "-", "mCurrentPage", "-", "mPageOffset", ")", "*", "width", ")", ")", ";", "bounds", ".", "right", "=", "bounds", ".", "left", "+", "w", ";", "bounds", ".", "top", "=", "0", ";", "bounds", ".", "bottom", "=", "h", ";", "list", ".", "add", "(", "bounds", ")", ";", "}", "return", "list", ";", "}" ]

[ "Calculate", "views", "bounds", "and", "scroll", "them", "according", "to", "the", "current", "index" ]

[ "private", "Rect", "calcBounds", "(", "int", "index", ",", "Paint", "paint", ")", "{", "//Calculate the text bounds", "Rect", "bounds", "=", "new", "Rect", "(", ")", ";", "CharSequence", "title", "=", "getTitle", "(", "index", ")", ";", "bounds", ".", "right", "=", "(", "int", ")", "paint", ".", "measureText", "(", "title", ",", "0", ",", "title", ".", "length", "(", ")", ")", ";", "bounds", ".", "bottom", "=", "(", "int", ")", "(", "paint", ".", "descent", "(", ")", "-", "paint", ".", "ascent", "(", ")", ")", ";", "return", "bounds", ";", "}" ]

[ "Calculate", "the", "bounds", "for", "a", "view", "s", "title" ]

[ "public", "static", "void", "initialize", "(", ")", "{", "if", "(", "initialized", ")", "return", ";", "SniffyConfiguration", ".", "INSTANCE", ".", "addTopSqlCapacityListener", "(", "new", "PropertyChangeListener", "(", ")", "{", "@", "Override", "public", "void", "propertyChange", "(", "PropertyChangeEvent", "evt", ")", "{", "ConcurrentLinkedHashMap", "<", "String", ",", "Timer", ">", "oldValues", "=", "globalSqlStats", ";", "globalSqlStats", "=", "new", "ConcurrentLinkedHashMap", ".", "Builder", "<", "String", ",", "Timer", ">", "(", ")", ".", "maximumWeightedCapacity", "(", "SniffyConfiguration", ".", "INSTANCE", ".", "getTopSqlCapacity", "(", ")", ")", ".", "build", "(", ")", ";", "globalSqlStats", ".", "putAll", "(", "oldValues", ")", ";", "}", "}", ")", ";", "if", "(", "SniffyConfiguration", ".", "INSTANCE", ".", "isMonitorSocket", "(", ")", ")", "{", "try", "{", "SnifferSocketImplFactory", ".", "install", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}", "else", "{", "SniffyConfiguration", ".", "INSTANCE", ".", "addMonitorSocketListener", "(", "new", "PropertyChangeListener", "(", ")", "{", "private", "boolean", "sniffySocketImplFactoryInstalled", "=", "false", ";", "@", "Override", "public", "synchronized", "void", "propertyChange", "(", "PropertyChangeEvent", "evt", ")", "{", "if", "(", "sniffySocketImplFactoryInstalled", ")", "return", ";", "if", "(", "Boolean", ".", "TRUE", ".", "equals", "(", "evt", ".", "getNewValue", "(", ")", ")", ")", "{", "try", "{", "SnifferSocketImplFactory", ".", "install", "(", ")", ";", "sniffySocketImplFactoryInstalled", "=", "true", ";", "}", "catch", "(", "IOException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "}", "}", "}", ")", ";", "}", "initialized", "=", "true", ";", "}" ]

[ "If", "socket", "monitoring", "is", "already", "enabled", "it", "cannot", "be", "disabled", "afterwards", "Otherwise", "one", "webapp", "would", "enable", "it", "but", "another", "one", "would", "disable" ]

[ "private", "void", "grow", "(", "int", "minCapacity", ")", "{", "// overflow-conscious code", "int", "oldCapacity", "=", "buf", ".", "length", ";", "int", "newCapacity", "=", "oldCapacity", "<<", "1", ";", "if", "(", "newCapacity", "-", "minCapacity", "<", "0", ")", "newCapacity", "=", "minCapacity", ";", "if", "(", "newCapacity", "<", "0", ")", "{", "if", "(", "minCapacity", "<", "0", ")", "// overflow", "throw", "new", "OutOfMemoryError", "(", ")", ";", "newCapacity", "=", "Integer", ".", "MAX_VALUE", ";", "}", "buf", "=", "copyOf", "(", "buf", ",", "newCapacity", ")", ";", "}" ]

[ "Increases", "the", "capacity", "to", "ensure", "that", "it", "can", "hold", "at", "least", "the", "number", "of", "elements", "specified", "by", "the", "minimum", "capacity", "argument", "." ]

[ "protected", "void", "flushIfPossible", "(", ")", "throws", "IOException", "{", "// TODO: do not flush if wasn't requested by underlying application", "if", "(", "null", "!=", "bufferedServletOutputStream", ")", "bufferedServletOutputStream", ".", "setLastChunk", "(", ")", ";", "if", "(", "null", "!=", "writer", ")", "writer", ".", "flushIfOpen", "(", ")", ";", "else", "if", "(", "null", "!=", "outputStream", ")", "outputStream", ".", "flushIfOpen", "(", ")", ";", "else", "{", "if", "(", "!", "isCommitted", "(", ")", ")", "{", "notifyBeforeCommit", "(", ")", ";", "}", "notifyBeforeClose", "(", ")", ";", "}", "}" ]

[ "Flush", "the", "sniffer", "buffer", "and", "append", "the", "information", "about", "the", "executed", "queries", "to", "the", "output", "stream" ]

[ "@", "Override", "public", "void", "sendError", "(", "int", "sc", ",", "String", "msg", ")", "throws", "IOException", "{", "if", "(", "isCommitted", "(", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Cannot set error status - response is already committed\"", ")", ";", "}", "notifyBeforeCommit", "(", ")", ";", "super", ".", "sendError", "(", "sc", ",", "msg", ")", ";", "setCommitted", "(", ")", ";", "}" ]

[ "headers", "relates", "methods" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "@", "Override", "public", "<", "T", ">", "T", "[", "]", "asArrayOf", "(", "final", "Class", "<", "T", ">", "componentType", ")", "{", "Class", "<", "?", ">", "callerClass", "=", "ReflectionHelper", ".", "getDirectCallerClass", "(", ")", ";", "List", "<", "T", ">", "list", "=", "evaluateMultiValues", "(", "componentType", ",", "callerClass", ")", ";", "return", "list", ".", "toArray", "(", "(", "T", "[", "]", ")", "java", ".", "lang", ".", "reflect", ".", "Array", ".", "newInstance", "(", "componentType", ",", "list", ".", "size", "(", ")", ")", ")", ";", "}" ]

[ "Evaluate", "the", "XPath", "as", "an", "array", "of", "the", "given", "type", "." ]

[ "public", "static", "List", "<", "?", ">", "evaluateAsList", "(", "final", "XPathExpression", "expression", ",", "final", "Node", "node", ",", "final", "Method", "method", ",", "final", "InvocationContext", "invocationContext", ")", "throws", "XPathExpressionException", "{", "//assert targetComponentType != null;", "final", "Class", "<", "?", ">", "targetComponentType", "=", "invocationContext", ".", "getTargetComponentType", "(", ")", ";", "final", "NodeList", "nodes", "=", "(", "NodeList", ")", "expression", ".", "evaluate", "(", "node", ",", "XPathConstants", ".", "NODESET", ")", ";", "final", "List", "<", "Object", ">", "linkedList", "=", "new", "LinkedList", "<", "Object", ">", "(", ")", ";", "final", "TypeConverter", "typeConverter", "=", "invocationContext", ".", "getProjector", "(", ")", ".", "config", "(", ")", ".", "getTypeConverter", "(", ")", ";", "if", "(", "typeConverter", ".", "isConvertable", "(", "targetComponentType", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nodes", ".", "getLength", "(", ")", ";", "++", "i", ")", "{", "linkedList", ".", "add", "(", "typeConverter", ".", "convertTo", "(", "targetComponentType", ",", "nodes", ".", "item", "(", "i", ")", ".", "getTextContent", "(", ")", ",", "invocationContext", ".", "getExpressionFormatPattern", "(", ")", ")", ")", ";", "}", "return", "linkedList", ";", "}", "if", "(", "Node", ".", "class", ".", "equals", "(", "targetComponentType", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nodes", ".", "getLength", "(", ")", ";", "++", "i", ")", "{", "linkedList", ".", "add", "(", "nodes", ".", "item", "(", "i", ")", ")", ";", "}", "return", "linkedList", ";", "}", "if", "(", "targetComponentType", ".", "isInterface", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nodes", ".", "getLength", "(", ")", ";", "++", "i", ")", "{", "Object", "subprojection", "=", "invocationContext", ".", "getProjector", "(", ")", ".", "projectDOMNode", "(", "nodes", ".", "item", "(", "i", ")", ",", "targetComponentType", ")", ";", "linkedList", ".", "add", "(", "subprojection", ")", ";", "}", "return", "linkedList", ";", "}", "throw", "new", "IllegalArgumentException", "(", "\"Return type \"", "+", "targetComponentType", "+", "\" is not valid for list or array component type returning from method \"", "+", "method", "+", "\" using the current type converter:\"", "+", "invocationContext", ".", "getProjector", "(", ")", ".", "config", "(", ")", ".", "getTypeConverter", "(", ")", "+", "\". Please change the return type to a sub projection or add a conversion to the type converter.\"", ")", ";", "}" ]

[ "Perform", "an", "XPath", "evaluation", "on", "an", "invocation", "context", "." ]

[ "private", "DOMAccess", "checkProjectionInstance", "(", "final", "Object", "projection", ")", "{", "if", "(", "java", ".", "lang", ".", "reflect", ".", "Proxy", ".", "isProxyClass", "(", "projection", ".", "getClass", "(", ")", ")", ")", "{", "InvocationHandler", "invocationHandler", "=", "java", ".", "lang", ".", "reflect", ".", "Proxy", ".", "getInvocationHandler", "(", "projection", ")", ";", "if", "(", "invocationHandler", "instanceof", "ProjectionInvocationHandler", ")", "{", "if", "(", "projection", "instanceof", "DOMAccess", ")", "{", "return", "(", "DOMAccess", ")", "projection", ";", "}", "}", "}", "throw", "new", "IllegalArgumentException", "(", "\"Given object \"", "+", "projection", "+", "\" is not a projection.\"", ")", ";", "}" ]

[ "Ensures", "that", "the", "given", "object", "is", "a", "projection", "created", "by", "a", "projector", "." ]

[ "private", "static", "int", "countTrue", "(", "final", "boolean", "...", "b", ")", "{", "if", "(", "b", "==", "null", ")", "{", "return", "0", ";", "}", "int", "count", "=", "0", ";", "for", "(", "boolean", "bb", ":", "b", ")", "{", "if", "(", "bb", ")", "{", "++", "count", ";", "}", "}", "return", "count", ";", "}" ]

[ "Count", "how", "many", "parameters", "are", "true", "." ]

[ "public", "<", "T", ">", "XBAutoMap", "<", "T", ">", "autoMapEmptyDocument", "(", "final", "Class", "<", "T", ">", "valueType", ")", "{", "Document", "document", "=", "xMLFactoriesConfig", ".", "createDocumentBuilder", "(", ")", ".", "newDocument", "(", ")", ";", "return", "createAutoMapForDocument", "(", "valueType", ",", "document", ")", ";", "}" ]

[ "Create", "an", "empty", "document", "and", "bind", "an", "XBAutoMap", "to", "it", "." ]

[ "@", "Scope", "(", "DocScope", ".", "IO", ")", "public", "<", "T", ">", "T", "read", "(", "final", "Class", "<", "T", ">", "projectionInterface", ")", "throws", "IOException", "{", "Document", "document", "=", "readDocument", "(", ")", ";", "return", "projector", ".", "projectDOMNode", "(", "document", ",", "projectionInterface", ")", ";", "}" ]

[ "Create", "a", "new", "projection", "by", "parsing", "the", "data", "provided", "by", "the", "input", "stream", "." ]

[ "public", "ExpressionType", "getExpressionType", "(", ")", "{", "try", "{", "//TODO: cache expression type ?", "final", "ExpressionType", "expressionType", "=", "node", ".", "firstChildAccept", "(", "new", "ExpressionTypeEvaluationVisitor", "(", ")", ",", "null", ")", ";", "return", "expressionType", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Please report this bug: Can not determine type of XPath:\"", "+", "xpath", ",", "e", ")", ";", "}", "}" ]

[ "Calculates", "the", "return", "type", "of", "the", "expression", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "org", ".", "w3c", ".", "dom", ".", "Node", "ensureExistence", "(", "final", "org", ".", "w3c", ".", "dom", ".", "Node", "contextNode", ")", "{", "final", "Document", "document", "=", "DOMHelper", ".", "getOwnerDocumentFor", "(", "contextNode", ")", ";", "final", "Map", "<", "String", ",", "String", ">", "namespaceMapping", "=", "new", "HashMap", "<", "String", ",", "String", ">", "(", "userDefinedMapping", ")", ";", "namespaceMapping", ".", "putAll", "(", "DOMHelper", ".", "getNamespaceMapping", "(", "document", ")", ")", ";", "//node.dump(\"\");", "return", "(", "(", "List", "<", "org", ".", "w3c", ".", "dom", ".", "Node", ">", ")", "node", ".", "firstChildAccept", "(", "new", "BuildDocumentVisitor", "(", "variableResolver", ",", "namespaceMapping", ")", ",", "contextNode", ")", ")", ".", "get", "(", "0", ")", ";", "}" ]

[ "Creates", "nodes", "until", "selecting", "such", "a", "path", "would", "return", "something", "." ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "@", "Scope", "(", "DocScope", ".", "IO", ")", "public", "String", "write", "(", "final", "Object", "projection", ")", "throws", "IOException", "{", "return", "IOHelper", ".", "inputStreamToString", "(", "IOHelper", ".", "httpPost", "(", "url", ",", "projection", ".", "toString", "(", ")", ",", "requestProperties", ")", ")", ";", "}" ]

[ "Post", "the", "projected", "document", "to", "a", "HTTP", "URL", ".", "The", "response", "is", "provided", "as", "a", "raw", "string", "." ]

[ "@", "Scope", "(", "DocScope", ".", "IO", ")", "public", "UrlIO", "addRequestProperties", "(", "final", "Map", "<", "String", ",", "String", ">", "params", ")", "{", "requestProperties", ".", "putAll", "(", "params", ")", ";", "return", "this", ";", "}" ]

[ "Allows", "to", "add", "some", "request", "properties", "." ]

[ "@", "Scope", "(", "DocScope", ".", "IO", ")", "public", "UrlIO", "addRequestProperty", "(", "final", "String", "name", ",", "final", "String", "value", ")", "{", "requestProperties", ".", "put", "(", "name", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "Allows", "to", "add", "a", "single", "request", "property", "." ]

[ "@", "Override", "@", "Scope", "(", "DocScope", ".", "IO", ")", "public", "XPathEvaluator", "evalXPath", "(", "final", "String", "xpath", ")", "{", "return", "new", "DefaultXPathEvaluator", "(", "projector", ",", "new", "DocumentResolver", "(", ")", "{", "@", "Override", "public", "Document", "resolve", "(", "final", "Class", "<", "?", ">", "...", "resourceAwareClasses", ")", "throws", "IOException", "{", "return", "IOHelper", ".", "getDocumentFromURL", "(", "projector", ".", "config", "(", ")", ".", "createDocumentBuilder", "(", ")", ",", "url", ",", "requestProperties", ",", "resourceAwareClasses", ")", ";", "}", "}", ",", "xpath", ")", ";", "}" ]

[ "Evaluate", "XPath", "on", "the", "url", "document", "." ]

[ "@", "Scope", "(", "DocScope", ".", "IO", ")", "public", "<", "T", ">", "XBAutoMap", "<", "T", ">", "readAsMapOf", "(", "final", "Class", "<", "T", ">", "valueType", ")", "throws", "IOException", "{", "DefaultXPathBinder", ".", "validateEvaluationType", "(", "valueType", ")", ";", "final", "Class", "<", "?", ">", "resourceAwareClass", "=", "ReflectionHelper", ".", "getDirectCallerClass", "(", ")", ";", "Document", "document", "=", "IOHelper", ".", "getDocumentFromURL", "(", "projector", ".", "config", "(", ")", ".", "createDocumentBuilder", "(", ")", ",", "url", ",", "requestProperties", ",", "resourceAwareClass", ")", ";", "InvocationContext", "invocationContext", "=", "new", "InvocationContext", "(", "null", ",", "null", ",", "null", ",", "null", ",", "null", ",", "valueType", ",", "projector", ")", ";", "return", "new", "AutoMap", "<", "T", ">", "(", "document", ",", "invocationContext", ",", "valueType", ")", ";", "}" ]

[ "Read", "complete", "document", "to", "a", "Map", "." ]

[ "private", "static", "void", "unwrapArgs", "(", "final", "Class", "<", "?", ">", "[", "]", "types", ",", "final", "Object", "[", "]", "args", ")", "{", "if", "(", "args", "==", "null", ")", "{", "return", ";", "}", "try", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "args", ".", "length", ";", "++", "i", ")", "{", "args", "[", "i", "]", "=", "ReflectionHelper", ".", "unwrap", "(", "types", "[", "i", "]", ",", "args", "[", "i", "]", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "e", ")", ";", "}", "}" ]

[ "If", "parameter", "is", "instance", "of", "Callable", "or", "Supplier", "then", "resolve", "its", "value", "." ]

[ "private", "static", "Class", "<", "?", ">", "findTargetComponentType", "(", "final", "Method", "method", ")", "{", "final", "Class", "<", "?", ">", "returnType", "=", "method", ".", "getReturnType", "(", ")", ";", "if", "(", "returnType", ".", "isArray", "(", ")", ")", "{", "return", "method", ".", "getReturnType", "(", ")", ".", "getComponentType", "(", ")", ";", "}", "if", "(", "!", "(", "List", ".", "class", ".", "equals", "(", "returnType", ")", "||", "(", "Map", ".", "class", ".", "equals", "(", "returnType", ")", ")", "||", "XBAutoMap", ".", "class", ".", "isAssignableFrom", "(", "returnType", ")", "||", "XBAutoList", ".", "class", ".", "equals", "(", "returnType", ")", "||", "XBAutoValue", ".", "class", ".", "equals", "(", "returnType", ")", "||", "ReflectionHelper", ".", "isStreamClass", "(", "returnType", ")", ")", ")", "{", "return", "null", ";", "}", "final", "Type", "type", "=", "method", ".", "getGenericReturnType", "(", ")", ";", "if", "(", "!", "(", "type", "instanceof", "ParameterizedType", ")", "||", "(", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getActualTypeArguments", "(", ")", "==", "null", ")", "||", "(", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getActualTypeArguments", "(", ")", ".", "length", "<", "1", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"When using List as return type for method \"", "+", "method", "+", "\", please specify a generic type for the List. Otherwise I do not know which type I should fill the List with.\"", ")", ";", "}", "int", "index", "=", "Map", ".", "class", ".", "equals", "(", "returnType", ")", "?", "1", ":", "0", ";", "assert", "index", "<", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getActualTypeArguments", "(", ")", ".", "length", ";", "Type", "componentType", "=", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getActualTypeArguments", "(", ")", "[", "index", "]", ";", "if", "(", "!", "(", "componentType", "instanceof", "Class", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"I don't know how to instantiate the generic type for the return type of method \"", "+", "method", ")", ";", "}", "return", "(", "Class", "<", "?", ">", ")", "componentType", ";", "}" ]

[ "When", "reading", "collections", "determine", "the", "collection", "component", "type", "." ]

[ "public", "T", "remove", "(", "final", "CharSequence", "xpath", ")", "{", "if", "(", "(", "xpath", "==", "null", ")", "||", "(", "xpath", ".", "length", "(", ")", "==", "0", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Parameter path must not be empty or null\"", ")", ";", "}", "domChangeTracker", ".", "refreshForReadIfNeeded", "(", ")", ";", "final", "Document", "document", "=", "DOMHelper", ".", "getOwnerDocumentFor", "(", "baseNode", ")", ";", "final", "DuplexExpression", "duplexExpression", "=", "new", "DuplexXPathParser", "(", "invocationContext", ".", "getProjector", "(", ")", ".", "config", "(", ")", ".", "getUserDefinedNamespaceMapping", "(", ")", ")", ".", "compile", "(", "xpath", ")", ";", "try", "{", "final", "XPathExpression", "expression", "=", "invocationContext", ".", "getProjector", "(", ")", ".", "config", "(", ")", ".", "createXPath", "(", "document", ")", ".", "compile", "(", "duplexExpression", ".", "getExpressionAsStringWithoutFormatPatterns", "(", ")", ")", ";", "Node", "prevNode", "=", "(", "Node", ")", "expression", ".", "evaluate", "(", "boundNode", ",", "XPathConstants", ".", "NODE", ")", ";", "if", "(", "prevNode", "==", "null", ")", "{", "return", "null", ";", "}", "final", "T", "value", "=", "DefaultXPathEvaluator", ".", "convertToComponentType", "(", "invocationContext", ",", "prevNode", ",", "invocationContext", ".", "getTargetComponentType", "(", ")", ")", ";", "duplexExpression", ".", "deleteAllMatchingChildren", "(", "prevNode", ".", "getParentNode", "(", ")", ")", ";", "return", "value", ";", "}", "catch", "(", "XPathExpressionException", "e", ")", "{", "throw", "new", "XBPathException", "(", "e", ",", "xpath", ")", ";", "}", "}" ]

[ "Remove", "element", "at", "relative", "location", "." ]

[ "public", "static", "boolean", "hasReturnType", "(", "final", "Method", "method", ")", "{", "if", "(", "method", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "method", ".", "getReturnType", "(", ")", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "Void", ".", "class", ".", "equals", "(", "method", ".", "getReturnType", "(", ")", ")", ")", "{", "return", "false", ";", "}", "return", "!", "Void", ".", "TYPE", ".", "equals", "(", "method", ".", "getReturnType", "(", ")", ")", ";", "}" ]

[ "Defensive", "implemented", "method", "to", "determine", "if", "method", "has", "a", "return", "type", "." ]

[ "public", "static", "Method", "getCallableFactoryForParams", "(", "final", "Class", "<", "?", ">", "type", ",", "final", "Class", "<", "?", ">", "...", "params", ")", "{", "for", "(", "Method", "m", ":", "type", ".", "getMethods", "(", ")", ")", "{", "if", "(", "(", "m", ".", "getModifiers", "(", ")", "&", "PUBLIC_STATIC_MODIFIER", ")", "!=", "PUBLIC_STATIC_MODIFIER", ")", "{", "continue", ";", "}", "if", "(", "!", "type", ".", "isAssignableFrom", "(", "m", ".", "getReturnType", "(", ")", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "Arrays", ".", "equals", "(", "m", ".", "getParameterTypes", "(", ")", ",", "params", ")", ")", "{", "continue", ";", "}", "if", "(", "!", "VALID_FACTORY_METHOD_NAMES", ".", "matcher", "(", "m", ".", "getName", "(", ")", ")", ".", "matches", "(", ")", ")", "{", "continue", ";", "}", "return", "m", ";", "}", "return", "null", ";", "}" ]

[ "Search", "for", "a", "static", "factory", "method", "returning", "the", "target", "type", "." ]

[ "public", "static", "Object", "unwrap", "(", "final", "Class", "<", "?", ">", "type", ",", "final", "Object", "object", ")", "throws", "Exception", "{", "if", "(", "object", "==", "null", ")", "{", "return", "null", ";", "}", "if", "(", "type", "==", "null", ")", "{", "return", "object", ";", "}", "if", "(", "Callable", ".", "class", ".", "equals", "(", "type", ")", ")", "{", "assert", "(", "object", "instanceof", "Callable", ")", ";", "return", "(", "(", "Callable", "<", "?", ">", ")", "object", ")", ".", "call", "(", ")", ";", "}", "if", "(", "\"java.util.function.Supplier\"", ".", "equals", "(", "type", ".", "getName", "(", ")", ")", ")", "{", "return", "findMethodByName", "(", "type", ",", "\"get\"", ")", ".", "invoke", "(", "object", ",", "(", "Object", "[", "]", ")", "null", ")", ";", "}", "return", "object", ";", "}" ]

[ "Unwrap", "a", "given", "object", "until", "we", "assume", "it", "is", "a", "value", ".", "Supports", "Callable", "and", "Supplier", "so", "far", "." ]

[ "public", "static", "boolean", "isOptional", "(", "final", "Type", "type", ")", "{", "if", "(", "OPTIONAL_CLASS", "==", "null", ")", "{", "return", "false", ";", "}", "if", "(", "!", "(", "type", "instanceof", "ParameterizedType", ")", ")", "{", "// Either this is no Optional, or it's a raw optional which is useless for us anyway...", "return", "false", ";", "}", "return", "OPTIONAL_CLASS", ".", "equals", "(", "(", "(", "ParameterizedType", ")", "type", ")", ".", "getRawType", "(", ")", ")", ";", "}" ]

[ "Checks", "if", "given", "type", "is", "java", ".", "util", ".", "Optional", "with", "a", "generic", "type", "parameter", "." ]

[ "public", "static", "boolean", "isRawType", "(", "final", "Type", "type", ")", "{", "if", "(", "type", "instanceof", "Class", ")", "{", "final", "Class", "<", "?", ">", "clazz", "=", "(", "Class", "<", "?", ">", ")", "type", ";", "return", "(", "clazz", ".", "getTypeParameters", "(", ")", ".", "length", ">", "0", ")", ";", "}", "if", "(", "type", "instanceof", "ParameterizedType", ")", "{", "final", "ParameterizedType", "ptype", "=", "(", "ParameterizedType", ")", "type", ";", "return", "(", "ptype", ".", "getActualTypeArguments", "(", ")", ".", "length", "==", "0", ")", ";", "}", "return", "false", ";", "}" ]

[ "Checks", "if", "a", "given", "type", "is", "a", "raw", "type", "." ]

[ "public", "static", "Object", "createOptional", "(", "final", "Object", "value", ")", "{", "if", "(", "(", "OPTIONAL_CLASS", "==", "null", ")", "||", "(", "OFNULLABLE", "==", "null", ")", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Unreachable Code executed. You just found a bug. Please report!\"", ")", ";", "}", "try", "{", "return", "OFNULLABLE", ".", "invoke", "(", "null", ",", "value", ")", ";", "}", "catch", "(", "IllegalArgumentException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "catch", "(", "IllegalAccessException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "catch", "(", "InvocationTargetException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Create", "an", "instance", "of", "java", ".", "util", ".", "Optional", "for", "given", "value", "." ]

[ "public", "static", "void", "throwThrowable", "(", "final", "Class", "<", "?", ">", "throwableType", ",", "final", "Object", "[", "]", "args", ",", "final", "Throwable", "optionalCause", ")", "throws", "Throwable", "{", "Class", "<", "?", ">", "[", "]", "argsClasses", "=", "getClassesOfObjects", "(", "args", ")", ";", "Constructor", "<", "?", ">", "constructor", "=", "ReflectionHelper", ".", "getCallableConstructorForParams", "(", "throwableType", ",", "argsClasses", ")", ";", "Throwable", "throwable", "=", "null", ";", "if", "(", "constructor", "!=", "null", ")", "{", "throwable", "=", "(", "Throwable", ")", "constructor", ".", "newInstance", "(", "args", ")", ";", "}", "else", "{", "throwable", "=", "(", "Throwable", ")", "throwableType", ".", "newInstance", "(", ")", ";", "}", "if", "(", "optionalCause", "!=", "null", ")", "{", "throwable", ".", "initCause", "(", "optionalCause", ")", ";", "}", "throw", "throwable", ";", "}" ]

[ "Throws", "a", "throwable", "of", "type", "throwableType", ".", "The", "throwable", "will", "be", "created", "using", "an", "args", "matching", "constructor", "or", "the", "default", "constructor", "if", "no", "matching", "constructor", "can", "be", "found", "." ]

[ "public", "static", "Map", "<", "String", ",", "String", ">", "getNamespaceMapping", "(", "final", "Document", "document", ")", "{", "Map", "<", "String", ",", "String", ">", "map", "=", "new", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "map", ".", "put", "(", "\"xmlns\"", ",", "\"http://www.w3.org/2000/xmlns/\"", ")", ";", "map", ".", "put", "(", "\"xml\"", ",", "\"http://www.w3.org/XML/1998/namespace\"", ")", ";", "// if (childName.equals(\"xmlns\") || childName.startsWith(\"xmlns:\")) {", "// return \"http://www.w3.org/2000/xmlns/\";", "// }", "// if (childName.startsWith(\"xml:\")) {", "// return \"http://www.w3.org/XML/1998/namespace\";", "// }", "Element", "root", "=", "document", ".", "getDocumentElement", "(", ")", ";", "if", "(", "root", "==", "null", ")", "{", "// No document, no namespaces.", "return", "map", ";", "}", "fillNSMapWithPrefixesDeclaredInElement", "(", "map", ",", "root", ")", ";", "return", "map", ";", "}" ]

[ "Parse", "namespace", "prefixes", "defined", "anywhere", "in", "the", "document", "." ]

[ "public", "static", "void", "setDocumentElement", "(", "final", "Document", "document", ",", "final", "Element", "element", ")", "{", "Element", "documentElement", "=", "document", ".", "getDocumentElement", "(", ")", ";", "if", "(", "documentElement", "!=", "null", ")", "{", "document", ".", "removeChild", "(", "documentElement", ")", ";", "}", "if", "(", "element", "!=", "null", ")", "{", "if", "(", "element", ".", "getOwnerDocument", "(", ")", ".", "equals", "(", "document", ")", ")", "{", "document", ".", "appendChild", "(", "element", ")", ";", "return", ";", "}", "Node", "node", "=", "document", ".", "adoptNode", "(", "element", ")", ";", "document", ".", "appendChild", "(", "node", ")", ";", "}", "}" ]

[ "Replace", "the", "current", "root", "element", ".", "If", "element", "is", "null", "the", "current", "root", "element", "will", "be", "removed", "." ]

[ "private", "static", "boolean", "nodeListsAreEqual", "(", "final", "NodeList", "a", ",", "final", "NodeList", "b", ")", "{", "if", "(", "a", "==", "b", ")", "{", "return", "true", ";", "}", "if", "(", "(", "a", "==", "null", ")", "||", "(", "b", "==", "null", ")", ")", "{", "return", "false", ";", "}", "if", "(", "a", ".", "getLength", "(", ")", "!=", "b", ".", "getLength", "(", ")", ")", "{", "return", "false", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "a", ".", "getLength", "(", ")", ";", "++", "i", ")", "{", "if", "(", "!", "nodesAreEqual", "(", "a", ".", "item", "(", "i", ")", ",", "b", ".", "item", "(", "i", ")", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "NodelLists", "are", "equal", "if", "and", "only", "if", "their", "size", "is", "equal", "and", "the", "containing", "nodes", "at", "the", "same", "indexes", "are", "equal", "." ]

[ "public", "static", "void", "removeAllChildren", "(", "final", "Node", "node", ")", "{", "assert", "node", "!=", "null", ";", "assert", "node", ".", "getNodeType", "(", ")", "!=", "Node", ".", "ATTRIBUTE_NODE", ";", "if", "(", "node", ".", "getNodeType", "(", ")", "==", "Node", ".", "DOCUMENT_TYPE_NODE", ")", "{", "Element", "documentElement", "=", "(", "(", "Document", ")", "node", ")", ".", "getDocumentElement", "(", ")", ";", "if", "(", "documentElement", "!=", "null", ")", "{", "(", "(", "Document", ")", "node", ")", ".", "removeChild", "(", "documentElement", ")", ";", "}", "return", ";", "}", "if", "(", "node", ".", "getNodeType", "(", ")", "==", "Node", ".", "ELEMENT_NODE", ")", "{", "Element", "element", "=", "(", "Element", ")", "node", ";", "for", "(", "Node", "n", "=", "element", ".", "getFirstChild", "(", ")", ";", "n", "!=", "null", ";", "n", "=", "element", ".", "getFirstChild", "(", ")", ")", "{", "element", ".", "removeChild", "(", "n", ")", ";", "}", "}", "}" ]

[ "Simply", "removes", "all", "child", "nodes", "." ]

[ "public", "static", "void", "setDirectTextContent", "(", "final", "Node", "elementToChange", ",", "final", "String", "asString", ")", "{", "assert", "elementToChange", ".", "getNodeType", "(", ")", "!=", "Node", ".", "DOCUMENT_NODE", ";", "if", "(", "Node", ".", "ATTRIBUTE_NODE", "==", "elementToChange", ".", "getNodeType", "(", ")", ")", "{", "elementToChange", ".", "setTextContent", "(", "asString", ")", ";", "return", ";", "}", "List", "<", "Node", ">", "nodes", "=", "new", "LinkedList", "<", "Node", ">", "(", ")", ";", "List", "<", "Node", ">", "nodes2", "=", "new", "LinkedList", "<", "Node", ">", "(", ")", ";", "for", "(", "Node", "n", ":", "nodeListToIterator", "(", "elementToChange", ".", "getChildNodes", "(", ")", ")", ")", "{", "if", "(", "Node", ".", "TEXT_NODE", "==", "n", ".", "getNodeType", "(", ")", ")", "{", "continue", ";", "}", "nodes", ".", "add", "(", "n", ")", ";", "}", "if", "(", "(", "asString", "!=", "null", ")", "&&", "(", "!", "asString", ".", "isEmpty", "(", ")", ")", ")", "{", "elementToChange", ".", "setTextContent", "(", "asString", ")", ";", "for", "(", "Node", "n", ":", "nodeListToIterator", "(", "elementToChange", ".", "getChildNodes", "(", ")", ")", ")", "{", "if", "(", "Node", ".", "TEXT_NODE", "!=", "n", ".", "getNodeType", "(", ")", ")", "{", "continue", ";", "}", "nodes", ".", "add", "(", "n", ")", ";", "}", "}", "removeAllChildren", "(", "elementToChange", ")", ";", "for", "(", "Node", "n", ":", "nodes", ")", "{", "elementToChange", ".", "appendChild", "(", "n", ")", ";", "}", "for", "(", "Node", "n", ":", "nodes2", ")", "{", "elementToChange", ".", "appendChild", "(", "n", ")", ";", "}", "}" ]

[ "Set", "text", "content", "of", "given", "element", "without", "removing", "existing", "child", "nodes", ".", "Text", "nodes", "are", "added", "after", "child", "element", "nodes", "always", "." ]

[ "private", "static", "void", "addRequestProperties", "(", "final", "Map", "<", "String", ",", "String", ">", "requestProperties", ",", "final", "HttpURLConnection", "connection", ")", "{", "if", "(", "requestProperties", "!=", "null", ")", "{", "for", "(", "Entry", "<", "String", ",", "String", ">", "entry", ":", "requestProperties", ".", "entrySet", "(", ")", ")", "{", "connection", ".", "addRequestProperty", "(", "entry", ".", "getKey", "(", ")", ",", "entry", ".", "getValue", "(", ")", ")", ";", "}", "}", "}" ]

[ "Copies", "request", "properties", "to", "a", "connection", "." ]

[ "public", "static", "Map", "<", "String", ",", "String", ">", "createBasicAuthenticationProperty", "(", "final", "String", "username", ",", "final", "String", "password", ")", "{", "Map", "<", "String", ",", "String", ">", "map", "=", "new", "TreeMap", "<", "String", ",", "String", ">", "(", ")", ";", "try", "{", "String", "base64Binary", "=", "DatatypeConverter", ".", "printBase64Binary", "(", "(", "username", "+", "\":\"", "+", "password", ")", ".", "getBytes", "(", "\"US-ASCII\"", ")", ")", ";", "map", ".", "put", "(", "\"Authorization\"", ",", "\"Basic \"", "+", "base64Binary", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "// unreachable code", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "return", "map", ";", "}" ]

[ "Create", "HTTP", "Basic", "credentials", "to", "be", "used", "in", "HTTP", "get", "or", "post", "methods", "." ]

[ "public", "static", "byte", "[", "]", "dropUTF8BOM", "(", "final", "byte", "[", "]", "source", ")", "{", "if", "(", "source", "==", "null", ")", "{", "return", "null", ";", "}", "if", "(", "source", ".", "length", "<", "3", ")", "{", "return", "source", ";", "}", "if", "(", "(", "source", "[", "0", "]", "==", "(", "byte", ")", "0xef", ")", "&&", "(", "source", "[", "1", "]", "==", "(", "byte", ")", "0xbb", ")", "&&", "(", "source", "[", "2", "]", "==", "(", "byte", ")", "0xbf", ")", ")", "{", "return", "Arrays", ".", "copyOfRange", "(", "source", ",", "3", ",", "source", ".", "length", ")", ";", "}", "return", "source", ";", "}" ]

[ "Silently", "drop", "UTF8", "BOM" ]

[ "@", "Override", "public", "<", "T", ">", "T", "read", "(", "final", "Class", "<", "T", ">", "projectionInterface", ")", "throws", "IOException", "{", "try", "{", "Document", "document", "=", "projector", ".", "config", "(", ")", ".", "createDocumentBuilder", "(", ")", ".", "parse", "(", "file", ")", ";", "return", "projector", ".", "projectDOMNode", "(", "document", ",", "projectionInterface", ")", ";", "}", "catch", "(", "SAXException", "e", ")", "{", "throw", "new", "XBDocumentParsingException", "(", "e", ")", ";", "}", "}" ]

[ "Read", "a", "XML", "document", "and", "return", "a", "projection", "to", "it", "." ]

[ "@", "Override", "public", "FileIO", "setAppend", "(", "final", "boolean", "...", "append", ")", "{", "this", ".", "append", "=", "(", "append", "!=", "null", ")", "&&", "(", "(", "append", ".", "length", "==", "0", ")", "||", "(", "(", "append", ".", "length", ">", "0", ")", "&&", "append", "[", "0", "]", ")", ")", ";", "return", "this", ";", "}" ]

[ "Set", "whether", "output", "should", "be", "append", "to", "existing", "file", ".", "When", "this", "method", "is", "not", "invoked", "or", "invoked", "with", "false", "The", "file", "will", "be", "replaced", "on", "writing", "operations", "." ]

[ "private", "void", "configureProcessName", "(", ")", "throws", "XPathExpressionException", "{", "if", "(", "processName", "!=", "null", ")", "{", "return", ";", "}", "processName", "=", "\"\"", ";", "Node", "jvm", "=", "getXmlNode", "(", "\"/jmxetric-config/jvm\"", ",", "inputSource", ")", ";", "if", "(", "jvm", "!=", "null", ")", "{", "processName", "=", "jvm", ".", "getAttributes", "(", ")", ".", "getNamedItem", "(", "\"process\"", ")", ".", "getNodeValue", "(", ")", ";", "}", "}" ]

[ "The", "XML", "file", "may", "specify", "a", "processName", "to", "be", "used", "which", "can", "be", "different", "from", "the", "one", "used", "in", "the", "constructor", ".", "The", "name", "in", "XML", "takes", "priority", "." ]

[ "private", "void", "addMBeanAttributeToSampler", "(", "MBeanSampler", "mBeanSampler", ",", "String", "mBeanName", ",", "MBeanAttribute", "mBeanAttribute", ")", "throws", "Exception", "{", "if", "(", "mBeanAttribute", ".", "getSampler", "(", ")", "==", "null", ")", "{", "mBeanAttribute", ".", "setSampler", "(", "mBeanSampler", ")", ";", "}", "mBeanSampler", ".", "addMBeanAttribute", "(", "mBeanName", ",", "mBeanAttribute", ")", ";", "}" ]

[ "Adds", "a", "MBeanAttribute", "to", "an", "MBeanSampler", ".", "This", "also", "checks", "if", "the", "MBeanAttribute", "to", "be", "added", "already", "has", "a", "MBeanSampler", "set", "if", "not", "it", "will", "set", "it", "." ]

[ "private", "int", "parseDMax", "(", "String", "dMaxString", ")", "{", "int", "dMax", ";", "try", "{", "dMax", "=", "Integer", ".", "parseInt", "(", "dMaxString", ")", ";", "}", "catch", "(", "NumberFormatException", "e", ")", "{", "dMax", "=", "0", ";", "}", "return", "dMax", ";", "}" ]

[ "Parses", "dMaxString", "which", "is", "the", "value", "of", "dmax", "read", "in", "from", "a", "configuration", "file", "." ]

[ "private", "String", "buildMetricName", "(", "String", "process", ",", "String", "mbeanName", ",", "String", "mbeanPublishName", ",", "String", "attribute", ",", "String", "attrPublishName", ")", "{", "StringBuilder", "buf", "=", "new", "StringBuilder", "(", ")", ";", "if", "(", "process", "!=", "null", ")", "{", "buf", ".", "append", "(", "process", ")", ";", "buf", ".", "append", "(", "\"_\"", ")", ";", "}", "if", "(", "mbeanPublishName", "!=", "null", ")", "{", "buf", ".", "append", "(", "mbeanPublishName", ")", ";", "}", "else", "{", "buf", ".", "append", "(", "mbeanName", ")", ";", "}", "buf", ".", "append", "(", "\"_\"", ")", ";", "if", "(", "!", "\"\"", ".", "equals", "(", "attrPublishName", ")", ")", "{", "buf", ".", "append", "(", "attrPublishName", ")", ";", "}", "else", "{", "buf", ".", "append", "(", "attribute", ")", ";", "}", "return", "buf", ".", "toString", "(", ")", ";", "}" ]

[ "Builds", "the", "metric", "name", "in", "ganglia" ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "{", "PrintStream", "out", "=", "System", ".", "out", ";", "if", "(", "args", ".", "length", ">", "0", ")", "{", "try", "{", "out", "=", "new", "PrintStream", "(", "new", "File", "(", "args", "[", "0", "]", ")", ")", ";", "}", "catch", "(", "FileNotFoundException", "e", ")", "{", "System", ".", "out", ".", "printf", "(", "ERR_FILE", ",", "args", "[", "0", "]", ")", ";", "}", "}", "MBeanScanner", "mBeanScanner", "=", "new", "MBeanScanner", "(", ")", ";", "List", "<", "Config", ">", "configs", "=", "mBeanScanner", ".", "scan", "(", ")", ";", "ConfigWriter", "cw", ";", "cw", "=", "new", "ConfigWriter", "(", "out", ",", "configs", ")", ";", "cw", ".", "write", "(", ")", ";", "}" ]

[ "Used", "mainly", "for", "testing", "purposed", "to", "output", "a", "test", "configuration", "file", "to", "System", ".", "out", ".", "Also", "shows", "how", "to", "use", "this", "class", "." ]

[ "public", "List", "<", "Config", ">", "scan", "(", ")", "{", "Set", "<", "ObjectInstance", ">", "mBeanObjects", "=", "mBeanServer", ".", "queryMBeans", "(", "null", ",", "null", ")", ";", "List", "<", "Config", ">", "configs", "=", "getConfigForAllMBeans", "(", "mBeanObjects", ")", ";", "return", "configs", ";", "}" ]

[ "Scans", "the", "platform", "MBean", "server", "for", "registered", "MBeans", "creating", "see", "Config", "objects", "to", "represent", "these", "MBeans", "." ]

[ "private", "List", "<", "Config", ">", "getConfigForAllMBeans", "(", "Set", "<", "ObjectInstance", ">", "mBeanObjects", ")", "{", "List", "<", "Config", ">", "configs", "=", "new", "Vector", "<", "Config", ">", "(", ")", ";", "for", "(", "ObjectInstance", "objectInstance", ":", "mBeanObjects", ")", "{", "Config", "configMB", "=", "scanOneMBeanObject", "(", "objectInstance", ")", ";", "configs", ".", "add", "(", "configMB", ")", ";", "}", "return", "configs", ";", "}" ]

[ "Constructs", "a", "configuration", "for", "all", "MBeans", "." ]

[ "private", "void", "scanMBeanAttributes", "(", "MBeanConfig", "mBeanConfig", ",", "ObjectName", "mBeanName", ")", "{", "MBeanInfo", "mBeanInfo", ";", "try", "{", "mBeanInfo", "=", "mBeanServer", ".", "getMBeanInfo", "(", "mBeanName", ")", ";", "MBeanAttributeInfo", "[", "]", "infos", "=", "mBeanInfo", ".", "getAttributes", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "infos", ".", "length", ";", "i", "++", ")", "{", "MBeanAttributeConfig", "cMBAttr", "=", "makeConfigMBeanAttribute", "(", "mBeanName", ",", "infos", "[", "i", "]", ")", ";", "mBeanConfig", ".", "addChild", "(", "cMBAttr", ")", ";", "}", "}", "catch", "(", "IntrospectionException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "InstanceNotFoundException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "ReflectionException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "}" ]

[ "Stores", "all", "attributes", "of", "an", "MBean", "into", "its", "MBeanConfig", "object" ]

[ "private", "MBeanAttributeConfig", "makeConfigMBeanAttribute", "(", "ObjectName", "mBeanName", ",", "MBeanAttributeInfo", "attributeInfo", ")", "{", "// type determines if this should be composite", "Object", "attr", ";", "try", "{", "attr", "=", "mBeanServer", ".", "getAttribute", "(", "mBeanName", ",", "attributeInfo", ".", "getName", "(", ")", ")", ";", "MBeanAttributeConfig", "config", "=", "new", "MBeanAttributeConfig", "(", ")", ";", "config", ".", "addField", "(", "\"name\"", ",", "attributeInfo", ".", "getName", "(", ")", ")", ";", "if", "(", "attr", "==", "null", ")", "{", "return", "null", ";", "}", "else", "if", "(", "attr", "instanceof", "CompositeData", ")", "{", "addComposites", "(", "config", ",", "(", "CompositeData", ")", "attr", ")", ";", "}", "else", "{", "config", ".", "addField", "(", "\"type\"", ",", "translateDataType", "(", "attributeInfo", ".", "getType", "(", ")", ")", ")", ";", "}", "return", "config", ";", "}", "catch", "(", "RuntimeMBeanException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "AttributeNotFoundException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "InstanceNotFoundException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "MBeanException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "ReflectionException", "e", ")", "{", "System", ".", "err", ".", "println", "(", "e", ".", "getMessage", "(", ")", ")", ";", "}", "return", "null", ";", "}" ]

[ "Creates", "an", "object", "to", "represent", "a", "single", "attribute", "of", "an", "MBean", ".", "An", "attribute", "can", "be", "a", "simple", "attribute", "or", "made", "up", "composites", "." ]

[ "private", "void", "addComposites", "(", "MBeanAttributeConfig", "config", ",", "CompositeData", "compositeData", ")", "{", "CompositeType", "compositeType", "=", "compositeData", ".", "getCompositeType", "(", ")", ";", "for", "(", "String", "key", ":", "compositeType", ".", "keySet", "(", ")", ")", "{", "config", ".", "addChild", "(", "makeComposite", "(", "compositeType", ",", "key", ")", ")", ";", "}", "}" ]

[ "Adds", "the", "composite", "data", "of", "an", "MBean", "s", "attribute", "to", "an", "MBeanAttributeConfig" ]

[ "private", "MBeanCompositeConfig", "makeComposite", "(", "CompositeType", "compositeType", ",", "String", "name", ")", "{", "MBeanCompositeConfig", "config", "=", "new", "MBeanCompositeConfig", "(", ")", ";", "config", ".", "addField", "(", "\"name\"", ",", "name", ")", ";", "String", "rawType", "=", "compositeType", ".", "getType", "(", "name", ")", ".", "toString", "(", ")", ";", "config", ".", "addField", "(", "\"type\"", ",", "translateDataType", "(", "rawType", ")", ")", ";", "return", "config", ";", "}" ]

[ "Makes", "a", "configuration", "for", "JMXetric", "that", "represents", "the", "composite", "tag" ]

[ "public", "GMetric", "getConfig", "(", ")", "throws", "IOException", ",", "XPathExpressionException", "{", "// TODO what happens when the node cannot be found? do we use all", "// default values?", "ganglia", "=", "getXmlNode", "(", "\"/jmxetric-config/ganglia\"", ",", "inputSource", ")", ";", "// Gets the config for ganglia", "// Note that the ganglia config needs to be found before the samplers", "// are created.", "GMetric", "gmetric", "=", "makeGMetricFromXml", "(", ")", ";", "return", "gmetric", ";", "}" ]

[ "Creates", "a", "GMetric", "attribute", "on", "the", "JMXetricAgent", "from", "the", "XML", "config" ]

[ "GMetric", "makeGMetricFromXml", "(", ")", "throws", "IOException", "{", "String", "hostname", "=", "getHostName", "(", ")", ";", "int", "port", "=", "getPort", "(", ")", ";", "UDPAddressingMode", "addressingMode", "=", "getAddressingMode", "(", ")", ";", "boolean", "v31x", "=", "getV31", "(", ")", ";", "String", "spoof", "=", "getSpoof", "(", ")", ";", "StringBuilder", "buf", "=", "new", "StringBuilder", "(", ")", ";", "buf", ".", "append", "(", "\"GMetric host=\"", ")", ".", "append", "(", "hostname", ")", ";", "buf", ".", "append", "(", "\" port=\"", ")", ".", "append", "(", "port", ")", ";", "buf", ".", "append", "(", "\" mode=\"", ")", ".", "append", "(", "addressingMode", ")", ";", "buf", ".", "append", "(", "\" v31x=\"", ")", ".", "append", "(", "v31x", ")", ";", "buf", ".", "append", "(", "\" spoof=\"", ")", ".", "append", "(", "spoof", ")", ";", "log", ".", "fine", "(", "buf", ".", "toString", "(", ")", ")", ";", "System", ".", "out", ".", "println", "(", "buf", ".", "toString", "(", ")", ")", ";", "return", "new", "GMetric", "(", "hostname", ",", "port", ",", "addressingMode", ",", "DEFAULT_TTL", ",", "v31x", ",", "null", ",", "spoof", ")", ";", "}" ]

[ "Makes", "a", "GMetric", "object", "that", "can", "be", "use", "to", "define", "configuration", "for", "an", "agent", "." ]

[ "private", "int", "getPort", "(", ")", "{", "String", "port", "=", "getGangliaConfig", "(", "args", ".", "getPort", "(", ")", ",", "ganglia", ",", "\"port\"", ",", "DEFAULT_PORT", ")", ";", "return", "Integer", ".", "parseInt", "(", "port", ")", ";", "}" ]

[ "Gets", "the", "port", "that", "JMXetric", "will", "announce", "to", "this", "is", "usually", "the", "port", "gmond", "is", "running", "on" ]

[ "private", "UDPAddressingMode", "getAddressingMode", "(", ")", "{", "String", "mode", "=", "getGangliaConfig", "(", "args", ".", "getMode", "(", ")", ",", "ganglia", ",", "\"mode\"", ",", "DEFAULT_MODE", ")", ";", "if", "(", "mode", ".", "toLowerCase", "(", ")", ".", "equals", "(", "\"unicast\"", ")", ")", "{", "return", "UDPAddressingMode", ".", "UNICAST", ";", "}", "else", "{", "return", "UDPAddressingMode", ".", "MULTICAST", ";", "}", "}" ]

[ "UDPAddressingMode", "to", "use", "for", "reporting" ]

[ "private", "boolean", "getV31", "(", ")", "{", "String", "stringv31x", "=", "getGangliaConfig", "(", "args", ".", "getWireformat", "(", ")", ",", "ganglia", ",", "\"wireformat31x\"", ",", "\"false\"", ")", ";", "return", "Boolean", ".", "parseBoolean", "(", "stringv31x", ")", ";", "}" ]

[ "Whether", "the", "reporting", "be", "done", "on", "the", "new", "wire", "format", "31", "." ]

[ "private", "String", "getGangliaConfig", "(", "String", "cmdLine", ",", "Node", "ganglia", ",", "String", "attributeName", ",", "String", "defaultValue", ")", "{", "if", "(", "cmdLine", "==", "null", ")", "{", "return", "selectParameterFromNode", "(", "ganglia", ",", "attributeName", ",", "defaultValue", ")", ";", "}", "else", "{", "return", "cmdLine", ";", "}", "}" ]

[ "Gets", "a", "configuration", "parameter", "for", "Ganglia", ".", "First", "checks", "if", "it", "was", "given", "on", "the", "command", "line", "arguments", ".", "If", "it", "is", "not", "available", "it", "looks", "for", "the", "value", "in", "the", "XML", "node", "." ]

[ "String", "getConfigString", "(", ")", "throws", "XPathExpressionException", "{", "ganglia", "=", "getXmlNode", "(", "\"/jmxetric-config/ganglia\"", ",", "inputSource", ")", ";", "String", "hostname", "=", "getHostName", "(", ")", ";", "int", "port", "=", "getPort", "(", ")", ";", "UDPAddressingMode", "addressingMode", "=", "getAddressingMode", "(", ")", ";", "boolean", "v31x", "=", "getV31", "(", ")", ";", "String", "spoof", "=", "getSpoof", "(", ")", ";", "StringBuilder", "buf", "=", "new", "StringBuilder", "(", ")", ";", "buf", ".", "append", "(", "\"GMetric host=\"", ")", ".", "append", "(", "hostname", ")", ";", "buf", ".", "append", "(", "\" port=\"", ")", ".", "append", "(", "port", ")", ";", "buf", ".", "append", "(", "\" mode=\"", ")", ".", "append", "(", "addressingMode", ")", ";", "buf", ".", "append", "(", "\" v31x=\"", ")", ".", "append", "(", "v31x", ")", ";", "buf", ".", "append", "(", "\" spoof=\"", ")", ".", "append", "(", "spoof", ")", ";", "return", "buf", ".", "toString", "(", ")", ";", "}" ]

[ "Method", "used", "by", "tests", "to", "print", "out", "the", "read", "in", "configuration", "." ]

[ "public", "static", "void", "main", "(", "String", "[", "]", "args", ")", "throws", "Exception", "{", "while", "(", "true", ")", "{", "Thread", ".", "sleep", "(", "1000", "*", "60", "*", "5", ")", ";", "System", ".", "out", ".", "println", "(", "\"Test wakeup\"", ")", ";", "}", "}" ]

[ "A", "log", "running", "trivial", "main", "method", "for", "test", "purposes", "premain", "method" ]

[ "public", "static", "void", "premain", "(", "String", "agentArgs", ",", "Instrumentation", "inst", ")", "{", "System", ".", "out", ".", "println", "(", "STARTUP_NOTICE", ")", ";", "JMXetricAgent", "a", "=", "null", ";", "try", "{", "a", "=", "new", "JMXetricAgent", "(", ")", ";", "XMLConfigurationService", ".", "configure", "(", "a", ",", "agentArgs", ")", ";", "a", ".", "start", "(", ")", ";", "}", "catch", "(", "Exception", "ex", ")", "{", "// log.severe(\"Exception starting JMXetricAgent\");", "ex", ".", "printStackTrace", "(", ")", ";", "}", "}" ]

[ "The", "JVM", "agent", "entry", "point" ]

[ "public", "void", "run", "(", ")", "{", "try", "{", "for", "(", "String", "mbean", ":", "mbeanMap", ".", "keySet", "(", ")", ")", "{", "MBeanHolder", "h", "=", "mbeanMap", ".", "get", "(", "mbean", ")", ";", "h", ".", "publish", "(", ")", ";", "}", "}", "catch", "(", "Exception", "ex", ")", "{", "// Robust exception to prevent thread death", "log", ".", "warning", "(", "\"Exception thrown sampling Mbeans\"", ")", ";", "log", ".", "throwing", "(", "this", ".", "getClass", "(", ")", ".", "getName", "(", ")", ",", "\"Exception thrown sampling Mbeans:\"", ",", "ex", ")", ";", "}", "}" ]

[ "Called", "by", "the", "JMXAgent", "periodically", "to", "sample", "the", "mbeans" ]

[ "public", "static", "void", "configure", "(", "JMXetricAgent", "agent", ",", "String", "agentArgs", ")", "throws", "Exception", "{", "CommandLineArgs", "args", "=", "new", "CommandLineArgs", "(", "agentArgs", ")", ";", "InputSource", "inputSource", "=", "new", "InputSource", "(", "args", ".", "getConfig", "(", ")", ")", ";", "configureGanglia", "(", "agent", ",", "inputSource", ",", "args", ")", ";", "configureJMXetric", "(", "agent", ",", "inputSource", ",", "args", ")", ";", "}" ]

[ "Configures", "the", "JMXetricAgent", "based", "on", "the", "supplied", "agentArgs", "Command", "line", "arguments", "overwrites", "XML", "arguments", ".", "Any", "arguments", "that", "is", "required", "but", "no", "supplied", "will", "be", "defaulted", "." ]

[ "String", "readString", "(", ")", "throws", "IOException", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", "50", ")", ";", "// first char must be \":", "char", "ch", "=", "reader", ".", "next", "(", ")", ";", "if", "(", "ch", "!=", "'", "'", ")", "{", "throw", "new", "JsonParseException", "(", "\"Expected \\\" but actual is: \"", "+", "ch", ",", "reader", ".", "readed", ")", ";", "}", "for", "(", ";", ";", ")", "{", "ch", "=", "reader", ".", "next", "(", ")", ";", "if", "(", "ch", "==", "'", "'", ")", "{", "// escape: \\\" \\\\ \\/ \\b \\f \\n \\r \\t", "char", "ech", "=", "reader", ".", "next", "(", ")", ";", "switch", "(", "ech", ")", "{", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "sb", ".", "append", "(", "'", "'", ")", ";", "break", ";", "case", "'", "'", ":", "// read an unicode uXXXX:", "int", "u", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "4", ";", "i", "++", ")", "{", "char", "uch", "=", "reader", ".", "next", "(", ")", ";", "if", "(", "uch", ">=", "'", "'", "&&", "uch", "<=", "'", "'", ")", "{", "u", "=", "(", "u", "<<", "4", ")", "+", "(", "uch", "-", "'", "'", ")", ";", "}", "else", "if", "(", "uch", ">=", "'", "'", "&&", "uch", "<=", "'", "'", ")", "{", "u", "=", "(", "u", "<<", "4", ")", "+", "(", "uch", "-", "'", "'", ")", "+", "10", ";", "}", "else", "if", "(", "uch", ">=", "'", "'", "&&", "uch", "<=", "'", "'", ")", "{", "u", "=", "(", "u", "<<", "4", ")", "+", "(", "uch", "-", "'", "'", ")", "+", "10", ";", "}", "else", "{", "throw", "new", "JsonParseException", "(", "\"Unexpected char: \"", "+", "uch", ",", "reader", ".", "readed", ")", ";", "}", "}", "sb", ".", "append", "(", "(", "char", ")", "u", ")", ";", "break", ";", "default", ":", "throw", "new", "JsonParseException", "(", "\"Unexpected char: \"", "+", "ch", ",", "reader", ".", "readed", ")", ";", "}", "}", "else", "if", "(", "ch", "==", "'", "'", ")", "{", "// end of string:", "break", ";", "}", "else", "if", "(", "ch", "==", "'", "'", "||", "ch", "==", "'", "'", ")", "{", "throw", "new", "JsonParseException", "(", "\"Unexpected char: \"", "+", "ch", ",", "reader", ".", "readed", ")", ";", "}", "else", "{", "sb", ".", "append", "(", "ch", ")", ";", "}", "}", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "read", "string", "like", "a", "encoded", "\\", "u0098", "\\", "str" ]

[ "double", "string2Fraction", "(", "CharSequence", "cs", ",", "int", "readed", ")", "{", "if", "(", "cs", ".", "length", "(", ")", ">", "16", ")", "{", "throw", "new", "JsonParseException", "(", "\"Number string is too long.\"", ",", "readed", ")", ";", "}", "double", "d", "=", "0.0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "cs", ".", "length", "(", ")", ";", "i", "++", ")", "{", "int", "n", "=", "cs", ".", "charAt", "(", "i", ")", "-", "'", "'", ";", "d", "=", "d", "+", "(", "n", "==", "0", "?", "0", ":", "n", "/", "Math", ".", "pow", "(", "10", ",", "i", "+", "1", ")", ")", ";", "}", "return", "d", ";", "}" ]

[ "parse", "0123", "as", "0", ".", "0123" ]

[ "public", "<", "T", ">", "JsonBuilder", "registerTypeAdapter", "(", "Class", "<", "T", ">", "clazz", ",", "TypeAdapter", "<", "T", ">", "typeAdapter", ")", "{", "typeAdapters", ".", "registerTypeAdapter", "(", "clazz", ",", "typeAdapter", ")", ";", "return", "this", ";", "}" ]

[ "Register", "a", "TypeAdapter", "." ]

[ "public", "JsonReader", "createReader", "(", "Reader", "reader", ")", "{", "return", "new", "JsonReader", "(", "reader", ",", "jsonObjectFactory", ",", "jsonArrayFactory", ",", "objectMapper", ",", "typeAdapters", ")", ";", "}" ]

[ "Create", "a", "JsonReader", "by", "providing", "a", "Reader", "." ]

[ "public", "JsonReader", "createReader", "(", "InputStream", "input", ")", "{", "try", "{", "return", "createReader", "(", "new", "InputStreamReader", "(", "input", ",", "\"UTF-8\"", ")", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Create", "a", "JsonReader", "by", "providing", "an", "InputStream", "." ]

[ "public", "JsonWriter", "createWriter", "(", "OutputStream", "output", ")", "{", "Writer", "writer", "=", "null", ";", "try", "{", "writer", "=", "new", "OutputStreamWriter", "(", "output", ",", "\"UTF-8\"", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "return", "new", "JsonWriter", "(", "writer", ",", "typeAdapters", ")", ";", "}" ]

[ "Create", "a", "JsonWriter", "that", "write", "JSON", "to", "specified", "OutputStream", "." ]

[ "private", "static", "String", "getSetterName", "(", "Method", "m", ")", "{", "String", "name", "=", "m", ".", "getName", "(", ")", ";", "if", "(", "name", ".", "startsWith", "(", "\"set\"", ")", "&&", "(", "name", ".", "length", "(", ")", ">=", "4", ")", "&&", "m", ".", "getReturnType", "(", ")", ".", "equals", "(", "void", ".", "class", ")", "&&", "(", "m", ".", "getParameterTypes", "(", ")", ".", "length", "==", "1", ")", ")", "{", "return", "Character", ".", "toLowerCase", "(", "name", ".", "charAt", "(", "3", ")", ")", "+", "name", ".", "substring", "(", "4", ")", ";", "}", "return", "null", ";", "}" ]

[ "Get", "setter", "name", ".", "setName", "-", ">", "name" ]

[ "public", "void", "remove", "(", "final", "View", "view", ")", "{", "if", "(", "view", ".", "getParent", "(", ")", "instanceof", "ViewGroup", ")", "{", "final", "ViewGroup", "parent", "=", "(", "ViewGroup", ")", "view", ".", "getParent", "(", ")", ";", "if", "(", "durationSet", ")", "{", "view", ".", "animate", "(", ")", ".", "setDuration", "(", "duration", ")", ";", "}", "view", ".", "animate", "(", ")", ".", "alpha", "(", "0f", ")", ".", "setListener", "(", "new", "AnimatorListenerAdapter", "(", ")", "{", "@", "Override", "public", "void", "onAnimationEnd", "(", "Animator", "animation", ")", "{", "parent", ".", "removeView", "(", "view", ")", ";", "view", ".", "setAlpha", "(", "1", ")", ";", "view", ".", "animate", "(", ")", ".", "setListener", "(", "null", ")", ";", "}", "}", ")", ";", "}", "}" ]

[ "Fades", "out", "the", "given", "view", "and", "then", "removes", "in", "from", "its", "parent", ".", "If", "the", "view", "is", "not", "currently", "parented", "the", "method", "simply", "returns", "without", "doing", "anything", "." ]

[ "public", "void", "add", "(", "final", "View", "view", ",", "final", "ViewGroup", "parent", ",", "int", "index", ")", "{", "if", "(", "view", ".", "getParent", "(", ")", "==", "null", ")", "{", "view", ".", "setAlpha", "(", "0", ")", ";", "parent", ".", "addView", "(", "view", ",", "index", ")", ";", "if", "(", "durationSet", ")", "{", "view", ".", "animate", "(", ")", ".", "setDuration", "(", "duration", ")", ";", "}", "view", ".", "animate", "(", ")", ".", "alpha", "(", "1", ")", ";", "}", "}" ]

[ "Adds", "a", "view", "to", "the", "specified", "parent", "at", "the", "specified", "index", "in", "the", "parent", "s", "child", "list", "and", "then", "fades", "in", "the", "view", ".", "The", "view", "must", "not", "currently", "be", "parented", "-", "if", "its", "parent", "is", "not", "null", "the", "method", "returns", "without", "doing", "anything", "." ]

[ "public", "void", "show", "(", "final", "View", "view", ")", "{", "if", "(", "view", ".", "getVisibility", "(", ")", "!=", "View", ".", "VISIBLE", ")", "{", "view", ".", "setAlpha", "(", "0", ")", ";", "view", ".", "setVisibility", "(", "View", ".", "VISIBLE", ")", ";", "if", "(", "durationSet", ")", "{", "view", ".", "animate", "(", ")", ".", "setDuration", "(", "duration", ")", ";", "}", "view", ".", "animate", "(", ")", ".", "alpha", "(", "1", ")", ";", "}", "}" ]

[ "Sets", "the", "visibility", "of", "the", "specified", "view", "to", "View", ".", "VISIBLE", "and", "then", "fades", "it", "in", ".", "If", "the", "view", "is", "already", "visible", "the", "method", "will", "return", "without", "doing", "anything", "." ]

[ "public", "static", "long", "start", "(", "String", "key", ")", "{", "if", "(", "key", ".", "isEmpty", "(", ")", ")", "{", "throw", "new", "InvalidKeyForTimeStampException", "(", ")", ";", "}", "// current timestamp", "long", "timestamp", "=", "QuickUtils", ".", "date", ".", "getCurrentTimeInMiliseconds", "(", ")", ";", "// save the timestamp", "QuickUtils", ".", "prefs", ".", "save", "(", "TIMER_PREFIX", "+", "key", ",", "timestamp", ")", ";", "return", "timestamp", ";", "}" ]

[ "Start", "counting", "time" ]

[ "public", "static", "void", "resetAllTimestamps", "(", ")", "{", "Map", "<", "String", ",", "?", ">", "allEntries", "=", "QuickUtils", ".", "prefs", ".", "getAll", "(", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "?", ">", "entry", ":", "allEntries", ".", "entrySet", "(", ")", ")", "{", "if", "(", "entry", ".", "getKey", "(", ")", ".", "startsWith", "(", "TIMER_PREFIX", ")", ")", "{", "QuickUtils", ".", "prefs", ".", "remove", "(", "entry", ".", "getKey", "(", ")", ")", ";", "}", "}", "}" ]

[ "Resets", "all", "the", "timestamps" ]

[ "public", "static", "double", "round", "(", "double", "toBeRounded", ",", "int", "digits", ")", "{", "if", "(", "digits", "<", "0", ")", "{", "QuickUtils", ".", "log", ".", "e", "(", "\"must be greater than 0\"", ")", ";", "return", "0", ";", "}", "String", "formater", "=", "\"\"", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "digits", ";", "i", "++", ")", "{", "formater", "+=", "\"#\"", ";", "}", "DecimalFormat", "twoDForm", "=", "new", "DecimalFormat", "(", "\"#.\"", "+", "formater", ",", "new", "DecimalFormatSymbols", "(", "Locale", ".", "US", ")", ")", ";", "return", "Double", ".", "valueOf", "(", "twoDForm", ".", "format", "(", "toBeRounded", ")", ")", ";", "}" ]

[ "Rounds", "a", "double", "value", "to", "a", "certain", "number", "of", "digits" ]

[ "public", "static", "int", "getRandomInteger", "(", "int", "min", ",", "int", "max", ")", "{", "Random", "r", "=", "new", "Random", "(", ")", ";", "return", "r", ".", "nextInt", "(", "max", "-", "min", "+", "1", ")", "+", "min", ";", "}" ]

[ "Returns", "a", "random", "integer", "between", "MIN", "inclusive", "and", "MAX", "inclusive", "." ]

[ "public", "static", "double", "getRandomDouble", "(", "double", "min", ",", "double", "max", ")", "{", "Random", "r", "=", "new", "Random", "(", ")", ";", "return", "min", "+", "(", "max", "-", "min", ")", "*", "r", ".", "nextDouble", "(", ")", ";", "}" ]

[ "Returns", "a", "random", "double", "between", "MIN", "inclusive", "and", "MAX", "inclusive", "." ]

[ "public", "static", "int", "getRandomNumber", "(", "int", "min", ",", "int", "max", ")", "{", "Random", "r", "=", "new", "Random", "(", ")", ";", "return", "r", ".", "nextInt", "(", "max", "-", "min", "+", "1", ")", "+", "min", ";", "}" ]

[ "Returns", "a", "random", "number", "between", "MIN", "inclusive", "and", "MAX", "exclusive", "." ]

[ "public", "static", "double", "truncate", "(", "double", "value", ",", "int", "places", ")", "{", "if", "(", "places", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", ")", ";", "}", "long", "factor", "=", "(", "long", ")", "java", ".", "lang", ".", "Math", ".", "pow", "(", "10", ",", "places", ")", ";", "value", "=", "value", "*", "factor", ";", "long", "tmp", "=", "(", "long", ")", "value", ";", "return", "(", "double", ")", "tmp", "/", "factor", ";", "}" ]

[ "Truncates", "a", "value" ]

[ "private", "static", "String", "privateBase64Encoder", "(", "String", "toEncode", ",", "int", "flags", ")", "{", "byte", "[", "]", "data", "=", "null", ";", "try", "{", "data", "=", "toEncode", ".", "getBytes", "(", "\"UTF-8\"", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e1", ")", "{", "e1", ".", "printStackTrace", "(", ")", ";", "}", "if", "(", "flags", "==", "-", "1", ")", "{", "flags", "=", "Base64", ".", "DEFAULT", ";", "}", "return", "Base64", ".", "encodeToString", "(", "data", ",", "flags", ")", ";", "}" ]

[ "private", "Encoder", "in", "base64" ]

[ "private", "static", "String", "privateBase64Decoder", "(", "String", "decode", ",", "int", "flags", ")", "{", "if", "(", "flags", "==", "-", "1", ")", "{", "flags", "=", "Base64", ".", "DEFAULT", ";", "}", "byte", "[", "]", "data1", "=", "Base64", ".", "decode", "(", "decode", ",", "flags", ")", ";", "String", "decodedBase64", "=", "null", ";", "try", "{", "decodedBase64", "=", "new", "String", "(", "data1", ",", "\"UTF-8\"", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "}", "return", "decodedBase64", ";", "}" ]

[ "Private", "decoder", "in", "base64" ]

[ "public", "static", "String", "calculateMD5", "(", "String", "string", ")", "{", "byte", "[", "]", "hash", ";", "try", "{", "hash", "=", "MessageDigest", ".", "getInstance", "(", "\"MD5\"", ")", ".", "digest", "(", "string", ".", "getBytes", "(", "\"UTF-8\"", ")", ")", ";", "}", "catch", "(", "NoSuchAlgorithmException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Huh, MD5 should be supported?\"", ",", "e", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "\"Huh, UTF-8 should be supported?\"", ",", "e", ")", ";", "}", "StringBuilder", "hex", "=", "new", "StringBuilder", "(", "hash", ".", "length", "*", "2", ")", ";", "for", "(", "byte", "b", ":", "hash", ")", "{", "int", "i", "=", "(", "b", "&", "0xFF", ")", ";", "if", "(", "i", "<", "0x10", ")", "hex", ".", "append", "(", "'", "'", ")", ";", "hex", ".", "append", "(", "Integer", ".", "toHexString", "(", "i", ")", ")", ";", "}", "return", "hex", ".", "toString", "(", ")", ";", "}" ]

[ "Calculate", "the", "MD5", "of", "a", "given", "String" ]

[ "public", "static", "String", "calculateSHA1", "(", "String", "string", ")", "{", "MessageDigest", "md", "=", "null", ";", "try", "{", "md", "=", "MessageDigest", ".", "getInstance", "(", "\"SHA-1\"", ")", ";", "}", "catch", "(", "NoSuchAlgorithmException", "e", ")", "{", "QuickUtils", ".", "log", ".", "e", "(", "\"NoSuchAlgorithmException\"", ",", "e", ")", ";", "}", "try", "{", "md", ".", "update", "(", "string", ".", "getBytes", "(", "\"iso-8859-1\"", ")", ",", "0", ",", "string", ".", "length", "(", ")", ")", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "QuickUtils", ".", "log", ".", "e", "(", "\"UnsupportedEncodingException\"", ",", "e", ")", ";", "}", "byte", "[", "]", "sha1hash", "=", "md", ".", "digest", "(", ")", ";", "return", "convertToHex", "(", "sha1hash", ")", ";", "}" ]

[ "Calculate", "the", "SHA", "-", "1", "of", "a", "given", "String" ]