Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "@", "Override", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "<", "T", ">", "T", "doGet", "(", "String", "url", ",", "Type", "returnType", ")", "throws", "ServerCommunicationException", "{", "RestClientResponse", "response", "=", "doGet", "(", "url", ")", ";", "String", "responseBody", "=", "response", ".", "getResponseBody", "(", ")", ";", "return", "(", "T", ")", "gson", ".", "fromJson", "(", "responseBody", ",", "returnType", ")", ";", "}" ]

[ "Delegate", "to", "{", "@link", "AsyncHttpClientRestClient#doGet", "(", "String", ")", "}", "and", "also", "use", "{", "@link", "Gson", "}", "to", "parse", "the", "returned", "json", "into", "the", "requested", "object" ]

[ "public", "static", "void", "setCloseConnection", "(", "Stub", "stub", ",", "boolean", "close", ")", "{", "Hashtable", "headers", "=", "getRequestHeaders", "(", "stub", ")", ";", "if", "(", "close", ")", "{", "headers", ".", "put", "(", "HTTPConstants", ".", "HEADER_CONNECTION", ",", "HTTPConstants", ".", "HEADER_CONNECTION_CLOSE", ")", ";", "}", "else", "{", "headers", ".", "remove", "(", "HTTPConstants", ".", "HEADER_CONNECTION", ")", ";", "}", "}" ]

[ "Sets", "on", "option", "on", "the", "stub", "to", "close", "the", "connection", "after", "receiving", "the", "reply", "(", "connection", "will", "not", "be", "reused", ")", "." ]

[ "private", "float", "processBubble", "(", "BubbleValue", "bubbleValue", ",", "PointF", "point", ")", "{", "final", "float", "rawX", "=", "computator", ".", "computeRawX", "(", "bubbleValue", ".", "getX", "(", ")", ")", ";", "final", "float", "rawY", "=", "computator", ".", "computeRawY", "(", "bubbleValue", ".", "getY", "(", ")", ")", ";", "float", "radius", "=", "(", "float", ")", "Math", ".", "sqrt", "(", "Math", ".", "abs", "(", "bubbleValue", ".", "getZ", "(", ")", ")", "/", "Math", ".", "PI", ")", ";", "float", "rawRadius", ";", "if", "(", "isBubbleScaledByX", ")", "{", "radius", "*=", "bubbleScaleX", ";", "rawRadius", "=", "computator", ".", "computeRawDistanceX", "(", "radius", ")", ";", "}", "else", "{", "radius", "*=", "bubbleScaleY", ";", "rawRadius", "=", "computator", ".", "computeRawDistanceY", "(", "radius", ")", ";", "}", "if", "(", "rawRadius", "<", "minRawRadius", "+", "touchAdditional", ")", "{", "rawRadius", "=", "minRawRadius", "+", "touchAdditional", ";", "}", "bubbleCenter", ".", "set", "(", "rawX", ",", "rawY", ")", ";", "if", "(", "ValueShape", ".", "SQUARE", ".", "equals", "(", "bubbleValue", ".", "getShape", "(", ")", ")", ")", "{", "bubbleRect", ".", "set", "(", "rawX", "-", "rawRadius", ",", "rawY", "-", "rawRadius", ",", "rawX", "+", "rawRadius", ",", "rawY", "+", "rawRadius", ")", ";", "}", "return", "rawRadius", ";", "}" ]

[ "Calculate", "bubble", "radius", "and", "center", "x", "and", "y", "coordinates", ".", "Center", "x", "and", "x", "will", "be", "stored", "in", "point", "parameter", "radius", "will", "be", "returned", "as", "float", "value", "." ]

[ "public", "static", "Properties", "parseInstructions", "(", "final", "String", "query", ")", "throws", "MalformedURLException", "{", "final", "Properties", "instructions", "=", "new", "Properties", "(", ")", ";", "if", "(", "query", "!=", "null", ")", "{", "try", "{", "// just ignore for the moment and try out if we have valid properties separated by \"&\"", "final", "String", "segments", "[", "]", "=", "query", ".", "split", "(", "\"&\"", ")", ";", "for", "(", "String", "segment", ":", "segments", ")", "{", "// do not parse empty strings", "if", "(", "segment", ".", "trim", "(", ")", ".", "length", "(", ")", ">", "0", ")", "{", "final", "Matcher", "matcher", "=", "INSTRUCTIONS_PATTERN", ".", "matcher", "(", "segment", ")", ";", "if", "(", "matcher", ".", "matches", "(", ")", ")", "{", "String", "key", "=", "matcher", ".", "group", "(", "1", ")", ";", "String", "val", "=", "matcher", ".", "group", "(", "2", ")", ";", "instructions", ".", "setProperty", "(", "verifyKey", "(", "key", ")", ",", "val", "!=", "null", "?", "URLDecoder", ".", "decode", "(", "val", ",", "\"UTF-8\"", ")", ":", "\"\"", ")", ";", "}", "else", "{", "throw", "new", "MalformedURLException", "(", "\"Invalid syntax for instruction [\"", "+", "segment", "+", "\"]. Take a look at http://www.aqute.biz/Code/Bnd.\"", ")", ";", "}", "}", "}", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "// thrown by URLDecoder but it should never happen", "throwAsMalformedURLException", "(", "\"Could not retrieve the instructions from [\"", "+", "query", "+", "\"]\"", ",", "e", ")", ";", "}", "}", "return", "instructions", ";", "}" ]

[ "Parses", "bnd", "instructions", "out", "of", "an", "url", "query", "string", "." ]

[ "public", "void", "setCMYKColorFill", "(", "int", "cyan", ",", "int", "magenta", ",", "int", "yellow", ",", "int", "black", ")", "{", "content", ".", "append", "(", "(", "float", ")", "(", "cyan", "&", "0xFF", ")", "/", "0xFF", ")", ";", "content", ".", "append", "(", "'", "'", ")", ";", "content", ".", "append", "(", "(", "float", ")", "(", "magenta", "&", "0xFF", ")", "/", "0xFF", ")", ";", "content", ".", "append", "(", "'", "'", ")", ";", "content", ".", "append", "(", "(", "float", ")", "(", "yellow", "&", "0xFF", ")", "/", "0xFF", ")", ";", "content", ".", "append", "(", "'", "'", ")", ";", "content", ".", "append", "(", "(", "float", ")", "(", "black", "&", "0xFF", ")", "/", "0xFF", ")", ";", "content", ".", "append", "(", "\" k\"", ")", ".", "append_i", "(", "separator", ")", ";", "}" ]

[ "Changes", "the", "current", "color", "for", "filling", "paths", "(", "device", "dependent", "colors!", ")", ".", "<P", ">", "Sets", "the", "color", "space", "to", "<B", ">", "DeviceCMYK<", "/", "B", ">", "(", "or", "the", "<B", ">", "DefaultCMYK<", "/", "B", ">", "color", "space", ")", "and", "sets", "the", "color", "to", "use", "for", "filling", "paths", ".", "<", "/", "P", ">", "<P", ">", "This", "method", "is", "described", "in", "the", "Portable", "Document", "Format", "Reference", "Manual", "version", "1", ".", "3", "section", "8", ".", "5", ".", "2", ".", "1", "(", "page", "331", ")", ".", "<", "/", "P", ">", "<P", ">", "Following", "the", "PDF", "manual", "each", "operand", "must", "be", "a", "number", "between", "0", "(", "no", "ink", ")", "and", "1", "(", "maximum", "ink", ")", ".", "This", "method", "however", "accepts", "only", "integers", "between", "0x00", "and", "0xFF", ".", "<", "/", "P", ">" ]

[ "public", "static", "<", "T", ">", "T", "createStrictMock", "(", "Class", "<", "T", ">", "type", ",", "ConstructorArgs", "constructorArgs", ",", "Method", "...", "methods", ")", "{", "return", "doMock", "(", "type", ",", "false", ",", "new", "StrictMockStrategy", "(", ")", ",", "constructorArgs", ",", "methods", ")", ";", "}" ]

[ "Creates", "a", "strict", "mock", "object", "that", "supports", "mocking", "of", "final", "and", "native", "methods", "and", "invokes", "a", "specific", "constructor", "." ]

[ "public", "double", "getAverageDOMLoadTime", "(", "final", "String", "intervalName", ",", "final", "TimeUnit", "unit", ")", "{", "return", "unit", ".", "transformMillis", "(", "totalDomLoadTime", ".", "getValueAsLong", "(", "intervalName", ")", ")", "/", "numberOfLoads", ".", "getValueAsDouble", "(", "intervalName", ")", ";", "}" ]

[ "Returns", "the", "average", "DOM", "load", "time", "for", "given", "interval", "and", "{", "@link", "TimeUnit", "}", "." ]

[ "protected", "boolean", "invisibleCarbon", "(", "IAtom", "atom", ",", "IAtomContainer", "atomContainer", ",", "RendererModel", "model", ")", "{", "return", "isCarbon", "(", "atom", ")", "&&", "!", "showCarbon", "(", "atom", ",", "atomContainer", ",", "model", ")", ";", "}" ]

[ "Checks", "an", "atom", "to", "see", "if", "it", "is", "an", "invisible", "carbon", "-", "that", "is", "it", "is", ":", "a", ")", "a", "carbon", "atom", "and", "b", ")", "this", "carbon", "should", "not", "be", "shown", "." ]

[ "public", "OvhRtmRaid", "serviceName_statistics_raid_unit_GET", "(", "String", "serviceName", ",", "String", "unit", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/dedicated/server/{serviceName}/statistics/raid/{unit}\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ",", "unit", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"GET\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhRtmRaid", ".", "class", ")", ";", "}" ]

[ "Get", "this", "object", "properties" ]

[ "private", "static", "double", "QUARD_MINIMIZER", "(", "double", "qm", ",", "double", "u", ",", "double", "fu", ",", "double", "du", ",", "double", "v", ",", "double", "fv", ")", "{", "double", "a", ",", "d", ",", "gamma", ",", "theta", ",", "p", ",", "q", ",", "r", ",", "s", ";", "a", "=", "(", "v", ")", "-", "(", "u", ")", ";", "(", "qm", ")", "=", "(", "u", ")", "+", "(", "du", ")", "/", "(", "(", "(", "fu", ")", "-", "(", "fv", ")", ")", "/", "a", "+", "(", "du", ")", ")", "/", "2", "*", "a", ";", "return", "qm", ";", "}" ]

[ "Find", "a", "minimizer", "of", "an", "interpolated", "quadratic", "function", "." ]

[ "public", "static", "CameraPinholeBrown", "createIntrinsic", "(", "int", "width", ",", "int", "height", ",", "double", "hfov", ")", "{", "CameraPinholeBrown", "intrinsic", "=", "new", "CameraPinholeBrown", "(", ")", ";", "intrinsic", ".", "width", "=", "width", ";", "intrinsic", ".", "height", "=", "height", ";", "intrinsic", ".", "cx", "=", "width", "/", "2", ";", "intrinsic", ".", "cy", "=", "height", "/", "2", ";", "intrinsic", ".", "fx", "=", "intrinsic", ".", "cx", "/", "Math", ".", "tan", "(", "UtilAngle", ".", "degreeToRadian", "(", "hfov", "/", "2.0", ")", ")", ";", "intrinsic", ".", "fy", "=", "intrinsic", ".", "fx", ";", "return", "intrinsic", ";", "}" ]

[ "Creates", "a", "set", "of", "intrinsic", "parameters", "without", "distortion", "for", "a", "camera", "with", "the", "specified", "characteristics", ".", "The", "focal", "length", "is", "assumed", "to", "be", "the", "same", "for", "x", "and", "y", "." ]

[ "public", "static", "DMatrixRMaj", "fundamentalToEssential", "(", "DMatrixRMaj", "F", ",", "DMatrixRMaj", "K", ",", "@", "Nullable", "DMatrixRMaj", "outputE", ")", "{", "if", "(", "outputE", "==", "null", ")", "outputE", "=", "new", "DMatrixRMaj", "(", "3", ",", "3", ")", ";", "PerspectiveOps", ".", "multTranA", "(", "K", ",", "F", ",", "K", ",", "outputE", ")", ";", "// this is unlikely to be a perfect essential matrix. reduce the error by enforcing essential constraints", "SingularValueDecomposition_F64", "<", "DMatrixRMaj", ">", "svd", "=", "DecompositionFactory_DDRM", ".", "svd", "(", "true", ",", "true", ",", "false", ")", ";", "svd", ".", "decompose", "(", "outputE", ")", ";", "DMatrixRMaj", "U", "=", "svd", ".", "getU", "(", "null", ",", "false", ")", ";", "DMatrixRMaj", "W", "=", "svd", ".", "getW", "(", "null", ")", ";", "DMatrixRMaj", "V", "=", "svd", ".", "getV", "(", "null", ",", "false", ")", ";", "// settings value of singular values to be [1,1,0]. The first two singular values just need to be equal", "// for it to be an essential matrix", "SingularOps_DDRM", ".", "descendingOrder", "(", "U", ",", "false", ",", "W", ",", "V", ",", "false", ")", ";", "W", ".", "set", "(", "0", ",", "0", ",", "1", ")", ";", "W", ".", "set", "(", "1", ",", "1", ",", "1", ")", ";", "W", ".", "set", "(", "2", ",", "2", ",", "0", ")", ";", "PerspectiveOps", ".", "multTranC", "(", "U", ",", "W", ",", "V", ",", "outputE", ")", ";", "return", "outputE", ";", "}" ]

[ "Given", "the", "calibration", "matrix", "convert", "the", "fundamental", "matrix", "into", "an", "essential", "matrix", ".", "E", "=", "K", "*", "F", "*", "k", ".", "The", "singular", "values", "of", "the", "resulting", "E", "matrix", "are", "forced", "to", "be", "[", "1", "1", "0", "]" ]

[ "public", "void", "addFileAppender", "(", "final", "String", "fileName", ",", "final", "String", "deviceName", ")", "throws", "DevFailed", "{", "if", "(", "rootLoggerBack", "!=", "null", ")", "{", "logger", ".", "debug", "(", "\"add file appender of {} in {}\"", ",", "deviceName", ",", "fileName", ")", ";", "final", "String", "deviceNameLower", "=", "deviceName", ".", "toLowerCase", "(", "Locale", ".", "ENGLISH", ")", ";", "final", "File", "f", "=", "new", "File", "(", "fileName", ")", ";", "if", "(", "!", "f", ".", "exists", "(", ")", ")", "{", "try", "{", "f", ".", "createNewFile", "(", ")", ";", "}", "catch", "(", "final", "IOException", "e", ")", "{", "throw", "DevFailedUtils", ".", "newDevFailed", "(", "ExceptionMessages", ".", "CANNOT_OPEN_FILE", ",", "\"impossible to open file \"", "+", "fileName", ")", ";", "}", "}", "if", "(", "!", "f", ".", "canWrite", "(", ")", ")", "{", "throw", "DevFailedUtils", ".", "newDevFailed", "(", "ExceptionMessages", ".", "CANNOT_OPEN_FILE", ",", "\"impossible to open file \"", "+", "fileName", ")", ";", "}", "// debug level by default", "// setLoggingLevel(deviceName, LoggingLevel.DEBUG.toInt());", "System", ".", "out", ".", "println", "(", "\"create file \"", "+", "f", ")", ";", "final", "LoggerContext", "loggerContext", "=", "(", "LoggerContext", ")", "LoggerFactory", ".", "getILoggerFactory", "(", ")", ";", "final", "FileAppender", "rfAppender", "=", "new", "FileAppender", "(", "deviceNameLower", ")", ";", "fileAppenders", ".", "put", "(", "deviceNameLower", ",", "rfAppender", ")", ";", "rfAppender", ".", "setName", "(", "\"FILE-\"", "+", "deviceNameLower", ")", ";", "rfAppender", ".", "setLevel", "(", "rootLoggingLevel", ")", ";", "// rfAppender.setContext(appender.getContext());", "rfAppender", ".", "setFile", "(", "fileName", ")", ";", "rfAppender", ".", "setAppend", "(", "true", ")", ";", "rfAppender", ".", "setContext", "(", "loggerContext", ")", ";", "final", "FixedWindowRollingPolicy", "rollingPolicy", "=", "new", "FixedWindowRollingPolicy", "(", ")", ";", "// rolling policies need to know their parent", "// it's one of the rare cases, where a sub-component knows about its parent", "rollingPolicy", ".", "setParent", "(", "rfAppender", ")", ";", "rollingPolicy", ".", "setContext", "(", "loggerContext", ")", ";", "rollingPolicy", ".", "setFileNamePattern", "(", "fileName", "+", "\"%i\"", ")", ";", "rollingPolicy", ".", "setMaxIndex", "(", "1", ")", ";", "rollingPolicy", ".", "setMaxIndex", "(", "3", ")", ";", "rollingPolicy", ".", "start", "(", ")", ";", "final", "SizeBasedTriggeringPolicy", "<", "ILoggingEvent", ">", "triggeringPolicy", "=", "new", "SizeBasedTriggeringPolicy", "<", "ILoggingEvent", ">", "(", ")", ";", "triggeringPolicy", ".", "setMaxFileSize", "(", "FileSize", ".", "valueOf", "(", "\"5 mb\"", ")", ")", ";", "triggeringPolicy", ".", "setContext", "(", "loggerContext", ")", ";", "triggeringPolicy", ".", "start", "(", ")", ";", "final", "PatternLayoutEncoder", "encoder", "=", "new", "PatternLayoutEncoder", "(", ")", ";", "encoder", ".", "setContext", "(", "loggerContext", ")", ";", "encoder", ".", "setPattern", "(", "\"%-5level %d %X{deviceName} - %thread | %logger{25}.%M:%L - %msg%n\"", ")", ";", "encoder", ".", "start", "(", ")", ";", "rfAppender", ".", "setEncoder", "(", "encoder", ")", ";", "rfAppender", ".", "setRollingPolicy", "(", "rollingPolicy", ")", ";", "rfAppender", ".", "setTriggeringPolicy", "(", "triggeringPolicy", ")", ";", "rfAppender", ".", "start", "(", ")", ";", "rootLoggerBack", ".", "addAppender", "(", "rfAppender", ")", ";", "rfAppender", ".", "start", "(", ")", ";", "// OPTIONAL: print logback internal status messages", "// StatusPrinter.print(loggerContext);", "}", "}" ]

[ "Add", "an", "file", "appender", "for", "a", "device" ]

[ "@", "Override", "public", "FileChannel", "newFileChannel", "(", "Path", "path", ",", "Set", "<", "?", "extends", "OpenOption", ">", "options", ",", "FileAttribute", "<", "?", ">", "...", "attrs", ")", "throws", "IOException", "{", "checkNotNull", "(", "path", ")", ";", "initStorage", "(", ")", ";", "CloudStorageUtil", ".", "checkNotNullArray", "(", "attrs", ")", ";", "if", "(", "options", ".", "contains", "(", "StandardOpenOption", ".", "CREATE_NEW", ")", ")", "{", "Files", ".", "createFile", "(", "path", ",", "attrs", ")", ";", "}", "else", "if", "(", "options", ".", "contains", "(", "StandardOpenOption", ".", "CREATE", ")", "&&", "!", "Files", ".", "exists", "(", "path", ")", ")", "{", "Files", ".", "createFile", "(", "path", ",", "attrs", ")", ";", "}", "if", "(", "options", ".", "contains", "(", "StandardOpenOption", ".", "WRITE", ")", "||", "options", ".", "contains", "(", "StandardOpenOption", ".", "CREATE", ")", "||", "options", ".", "contains", "(", "StandardOpenOption", ".", "CREATE_NEW", ")", "||", "options", ".", "contains", "(", "StandardOpenOption", ".", "TRUNCATE_EXISTING", ")", ")", "{", "return", "new", "CloudStorageWriteFileChannel", "(", "newWriteChannel", "(", "path", ",", "options", ")", ")", ";", "}", "else", "{", "return", "new", "CloudStorageReadFileChannel", "(", "newReadChannel", "(", "path", ",", "options", ")", ")", ";", "}", "}" ]

[ "Open", "a", "file", "for", "reading", "OR", "writing", ".", "The", "{", "@link", "FileChannel", "}", "that", "is", "returned", "will", "only", "allow", "reads", "or", "writes", "depending", "on", "the", "{", "@link", "OpenOption", "}", "s", "that", "are", "specified", ".", "If", "any", "of", "the", "following", "have", "been", "specified", "the", "{", "@link", "FileChannel", "}", "will", "be", "write", "-", "only", ":", "{", "@link", "StandardOpenOption#CREATE", "}" ]

[ "public", "static", "ImmutableListMultimap", "<", "String", ",", "File", ">", "loadStringToFileListMultimap", "(", "final", "CharSource", "source", ")", "throws", "IOException", "{", "return", "loadMultimap", "(", "source", ",", "Functions", ".", "<", "String", ">", "identity", "(", ")", ",", "FileFunction", ".", "INSTANCE", ",", "IsCommentLine", ".", "INSTANCE", ")", ";", "}" ]

[ "Reads", "an", "{" ]

[ "private", "void", "renderDescription", "(", "CmsTabInfo", "tabInfo", ",", "Panel", "descriptionParent", ")", "{", "if", "(", "tabInfo", ".", "getDescription", "(", ")", "!=", "null", ")", "{", "HTML", "descriptionLabel", "=", "new", "HTML", "(", ")", ";", "descriptionLabel", ".", "addStyleName", "(", "I_CmsLayoutBundle", ".", "INSTANCE", ".", "form", "(", ")", ".", "tabDescription", "(", ")", ")", ";", "if", "(", "!", "tabInfo", ".", "getDescription", "(", ")", ".", "startsWith", "(", "\"<div\"", ")", ")", "{", "// add default styling in case of simple HTML\r", "descriptionLabel", ".", "addStyleName", "(", "I_CmsLayoutBundle", ".", "INSTANCE", ".", "form", "(", ")", ".", "tabDescriptionPanel", "(", ")", ")", ";", "}", "descriptionLabel", ".", "setHTML", "(", "tabInfo", ".", "getDescription", "(", ")", ")", ";", "descriptionParent", ".", "add", "(", "descriptionLabel", ")", ";", "}", "}" ]

[ "Renders", "the", "tab", "description", "in", "a", "given", "panel", ".", "<p", ">", "@param", "tabInfo", "the", "tab", "info", "object" ]

[ "private", "void", "pushCharArray", "(", "String", "ename", ",", "char", "[", "]", "ch", ",", "int", "start", ",", "int", "length", ")", "throws", "SAXException", "{", "// Push the existing status", "pushInput", "(", "ename", ")", ";", "if", "(", "(", "ename", "!=", "null", ")", "&&", "doReport", ")", "{", "dataBufferFlush", "(", ")", ";", "handler", ".", "startInternalEntity", "(", "ename", ")", ";", "}", "sourceType", "=", "INPUT_INTERNAL", ";", "readBuffer", "=", "ch", ";", "readBufferPos", "=", "start", ";", "readBufferLength", "=", "length", ";", "readBufferOverflow", "=", "-", "1", ";", "}" ]

[ "Push", "a", "new", "internal", "input", "source", ".", "<p", ">", "This", "method", "is", "useful", "for", "expanding", "an", "internal", "entity", "or", "for", "unreading", "a", "string", "of", "characters", ".", "It", "creates", "a", "new", "readBuffer", "containing", "the", "characters", "in", "the", "array", "instead", "of", "characters", "converted", "from", "an", "input", "byte", "stream", "." ]

[ "private", "void", "getTagIdMapping", "(", "String", "tagId", ",", "String", "value", ",", "AbstractRenderAppender", "results", ")", "{", "if", "(", "(", "_javaScriptFeatures", "&", "CoreScriptFeature", ".", "ALLOCATE_LEGACY", ".", "value", ")", "==", "0", ")", "{", "_javaScriptFeatures", "|=", "CoreScriptFeature", ".", "ALLOCATE_LEGACY", ".", "value", ";", "String", "s", "=", "getString", "(", "\"singleIdMappingTable\"", ",", "new", "Object", "[", "]", "{", "tagId", ",", "value", "}", ")", ";", "String", "meths", "=", "writeNetuiNameFunctions", "(", "null", ",", "true", ",", "false", ",", "false", ")", ";", "if", "(", "meths", "!=", "null", ")", "s", "+=", "meths", ";", "writeScriptBlock", "(", "_req", ",", "results", ",", "s", ")", ";", "}", "else", "{", "String", "s", "=", "getString", "(", "\"idMappingEntry\"", ",", "new", "Object", "[", "]", "{", "tagId", ",", "value", "}", ")", ";", "writeScriptBlock", "(", "_req", ",", "results", ",", "s", ")", ";", "}", "}" ]

[ "This", "method", "will", "write", "out", "a", "tagId", "map", "entry", "for", "when", "there", "isn", "t", "a", "ScriptContainer", "defined", "." ]

[ "private", "boolean", "validatePattern", "(", "Object", "validationObject", ",", "Annotation", "annotate", ")", "{", "if", "(", "checkNullObject", "(", "validationObject", ")", ")", "{", "return", "true", ";", "}", "java", ".", "util", ".", "regex", ".", "Pattern", "pattern", "=", "java", ".", "util", ".", "regex", ".", "Pattern", ".", "compile", "(", "(", "(", "Pattern", ")", "annotate", ")", ".", "regexp", "(", ")", ",", "(", "(", "Pattern", ")", "annotate", ")", ".", "flags", "(", ")", ".", "length", ")", ";", "Matcher", "matcherPattern", "=", "pattern", ".", "matcher", "(", "(", "String", ")", "validationObject", ")", ";", "if", "(", "!", "matcherPattern", ".", "matches", "(", ")", ")", "{", "throwValidationException", "(", "(", "(", "Pattern", ")", "annotate", ")", ".", "message", "(", ")", ")", ";", "}", "return", "true", ";", "}" ]

[ "Checks", "whether", "the", "given", "string", "is", "a", "valid", "pattern", "or", "not" ]

[ "public", "CMAPreviewApiKey", "fetchOne", "(", "String", "spaceId", ",", "String", "keyId", ")", "{", "assertNotNull", "(", "spaceId", ",", "\"entry\"", ")", ";", "assertNotNull", "(", "keyId", ",", "\"keyId\"", ")", ";", "return", "service", ".", "fetchOne", "(", "spaceId", ",", "keyId", ")", ".", "blockingFirst", "(", ")", ";", "}" ]

[ "Fetch", "only", "one", "preview", "api", "key", ".", "<p", ">", "This", "method", "will", "override", "the", "configuration", "specified", "through", "{", "@link", "CMAClient", ".", "Builder#setSpaceId", "(", "String", ")", "}", "and", "will", "ignore", "{", "@link", "CMAClient", ".", "Builder#setEnvironmentId", "(", "String", ")", "}", "." ]

[ "Diagnostic", "createDiagnostic", "(", "Instance", "instance", ")", "{", "Diagnostic", "result", "=", "new", "Diagnostic", "(", "InstanceHelpers", ".", "computeInstancePath", "(", "instance", ")", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "Boolean", ">", "entry", ":", "ComponentHelpers", ".", "findComponentDependenciesFor", "(", "instance", ".", "getComponent", "(", ")", ")", ".", "entrySet", "(", ")", ")", "{", "String", "facetOrComponentName", "=", "entry", ".", "getKey", "(", ")", ";", "Collection", "<", "Import", ">", "imports", "=", "instance", ".", "getImports", "(", ")", ".", "get", "(", "facetOrComponentName", ")", ";", "boolean", "resolved", "=", "imports", "!=", "null", "&&", "!", "imports", ".", "isEmpty", "(", ")", ";", "boolean", "optional", "=", "entry", ".", "getValue", "(", ")", ";", "result", ".", "getDependenciesInformation", "(", ")", ".", "add", "(", "new", "DependencyInformation", "(", "facetOrComponentName", ",", "optional", ",", "resolved", ")", ")", ";", "}", "return", "result", ";", "}" ]

[ "Creates", "a", "diagnostic", "for", "an", "instance", "." ]

[ "public", "static", "ConnectionManager", "createConnectionManager", "(", "TransactionSupportEnum", "tse", ",", "ManagedConnectionFactory", "mcf", ",", "CachedConnectionManager", "ccm", ",", "ConnectionManagerConfiguration", "cmc", ",", "TransactionIntegration", "ti", ")", "{", "if", "(", "tse", "==", "TransactionSupportEnum", ".", "NoTransaction", ")", "{", "return", "new", "NoTransactionConnectionManager", "(", "mcf", ",", "ccm", ",", "cmc", ")", ";", "}", "else", "if", "(", "tse", "==", "TransactionSupportEnum", ".", "LocalTransaction", ")", "{", "return", "new", "LocalTransactionConnectionManager", "(", "mcf", ",", "ccm", ",", "cmc", ",", "ti", ")", ";", "}", "else", "{", "return", "new", "XATransactionConnectionManager", "(", "mcf", ",", "ccm", ",", "cmc", ",", "ti", ")", ";", "}", "}" ]

[ "Create", "a", "connection", "manager" ]

[ "@", "Override", "int", "findKey", "(", "final", "byte", "[", "]", "key", ")", "{", "final", "long", "[", "]", "hash", "=", "MurmurHash3", ".", "hash", "(", "key", ",", "SEED", ")", ";", "int", "entryIndex", "=", "getIndex", "(", "hash", "[", "0", "]", ",", "tableEntries_", ")", ";", "int", "firstDeletedIndex", "=", "-", "1", ";", "final", "int", "loopIndex", "=", "entryIndex", ";", "do", "{", "if", "(", "isBitClear", "(", "stateArr_", ",", "entryIndex", ")", ")", "{", "return", "firstDeletedIndex", "==", "-", "1", "?", "~", "entryIndex", ":", "~", "firstDeletedIndex", ";", "// found empty or deleted", "}", "if", "(", "couponsArr_", "[", "entryIndex", "*", "maxCouponsPerKey_", "]", "==", "0", ")", "{", "//found deleted", "if", "(", "firstDeletedIndex", "==", "-", "1", ")", "{", "firstDeletedIndex", "=", "entryIndex", ";", "}", "}", "else", "if", "(", "Map", ".", "arraysEqual", "(", "keysArr_", ",", "entryIndex", "*", "keySizeBytes_", ",", "key", ",", "0", ",", "keySizeBytes_", ")", ")", "{", "return", "entryIndex", ";", "// found key", "}", "entryIndex", "=", "(", "entryIndex", "+", "getStride", "(", "hash", "[", "1", "]", ",", "tableEntries_", ")", ")", "%", "tableEntries_", ";", "}", "while", "(", "entryIndex", "!=", "loopIndex", ")", ";", "throw", "new", "SketchesArgumentException", "(", "\"Key not found and no empty slots!\"", ")", ";", "}" ]

[ "Returns", "entryIndex", "if", "the", "given", "key", "is", "found", ".", "If", "not", "found", "returns", "one", "s", "complement", "entryIndex", "of", "an", "empty", "slot", "for", "insertion", "which", "may", "be", "over", "a", "deleted", "key", "." ]

[ "private", "static", "UUID", "generateRandomUuid", "(", ")", "{", "final", "Random", "rnd", "=", "ThreadLocalRandom", ".", "current", "(", ")", ";", "long", "mostSig", "=", "rnd", ".", "nextLong", "(", ")", ";", "long", "leastSig", "=", "rnd", ".", "nextLong", "(", ")", ";", "// Identify this as a version 4 UUID, that is one based on a random value.", "mostSig", "&=", "0xffffffffffff0fff", "", "L", ";", "mostSig", "|=", "0x0000000000004000", "", "L", ";", "// Set the variant identifier as specified for version 4 UUID values. The two", "// high order bits of the lower word are required to be one and zero, respectively.", "leastSig", "&=", "0x3fffffffffffffff", "", "L", ";", "leastSig", "|=", "0x8000000000000000", "", "L", ";", "return", "new", "UUID", "(", "mostSig", ",", "leastSig", ")", ";", "}" ]

[ "Generate", "a", "random", "UUID", "v4", "that", "will", "perform", "reasonably", "when", "used", "by", "multiple", "threads", "under", "load", "." ]

[ "public", "void", "addEventAsync", "(", "String", "eventCollection", ",", "Map", "<", "String", ",", "Object", ">", "event", ")", "{", "addEventAsync", "(", "eventCollection", ",", "event", ",", "null", ")", ";", "}" ]

[ "Adds", "an", "event", "to", "the", "default", "project", "with", "default", "Keen", "properties", "and", "no", "callbacks", "." ]

[ "public", "Point", "pointAlongLineSegment", "(", "double", "distance", ")", "{", "if", "(", "start", ".", "x", "==", "end", ".", "x", ")", "{", "// we have a vertical line", "if", "(", "start", ".", "y", ">", "end", ".", "y", ")", "{", "return", "new", "Point", "(", "end", ".", "x", ",", "end", ".", "y", "+", "distance", ")", ";", "}", "else", "{", "return", "new", "Point", "(", "start", ".", "x", ",", "start", ".", "y", "+", "distance", ")", ";", "}", "}", "else", "{", "double", "slope", "=", "(", "end", ".", "y", "-", "start", ".", "y", ")", "/", "(", "end", ".", "x", "-", "start", ".", "x", ")", ";", "double", "dx", "=", "Math", ".", "sqrt", "(", "(", "distance", "*", "distance", ")", "/", "(", "1", "+", "(", "slope", "*", "slope", ")", ")", ")", ";", "if", "(", "end", ".", "x", "<", "start", ".", "x", ")", "{", "dx", "*=", "-", "1", ";", "}", "return", "new", "Point", "(", "start", ".", "x", "+", "dx", ",", "start", ".", "y", "+", "slope", "*", "dx", ")", ";", "}", "}" ]

[ "Computes", "a", "Point", "along", "the", "line", "segment", "with", "a", "given", "distance", "to", "the", "start", "Point", "." ]

[ "public", "void", "setTags", "(", "java", ".", "util", ".", "Collection", "<", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", ">", "tags", ")", "{", "if", "(", "tags", "==", "null", ")", "{", "this", ".", "tags", "=", "null", ";", "return", ";", "}", "this", ".", "tags", "=", "new", "java", ".", "util", ".", "ArrayList", "<", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", ">", "(", "tags", ")", ";", "}" ]

[ "<p", ">", "A", "map", "of", "entity", "tags", "attached", "to", "the", "affected", "entity", ".", "<", "/", "p", ">" ]

[ "@", "Override", "public", "Page", "<", "ShortCode", ">", "previousPage", "(", "final", "Page", "<", "ShortCode", ">", "page", ",", "final", "TwilioRestClient", "client", ")", "{", "Request", "request", "=", "new", "Request", "(", "HttpMethod", ".", "GET", ",", "page", ".", "getPreviousPageUrl", "(", "Domains", ".", "MESSAGING", ".", "toString", "(", ")", ",", "client", ".", "getRegion", "(", ")", ")", ")", ";", "return", "pageForRequest", "(", "client", ",", "request", ")", ";", "}" ]

[ "Retrieve", "the", "previous", "page", "from", "the", "Twilio", "API", "." ]

[ "public", "Observable", "<", "Page", "<", "NetworkInterfaceInner", ">", ">", "listAsync", "(", "final", "String", "resourceGroupName", ",", "final", "String", "loadBalancerName", ")", "{", "return", "listWithServiceResponseAsync", "(", "resourceGroupName", ",", "loadBalancerName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "NetworkInterfaceInner", ">", ">", ",", "Page", "<", "NetworkInterfaceInner", ">", ">", "(", ")", "{", "@", "Override", "public", "Page", "<", "NetworkInterfaceInner", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "NetworkInterfaceInner", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "associated", "load", "balancer", "network", "interfaces", "." ]

[ "@", "CheckReturnValue", "LocalSyncWriteModelContainer", "desyncDocumentsFromRemote", "(", "final", "NamespaceSynchronizationConfig", "nsConfig", ",", "final", "BsonValue", "...", "documentIds", ")", "{", "this", ".", "waitUntilInitialized", "(", ")", ";", "final", "MongoNamespace", "namespace", "=", "nsConfig", ".", "getNamespace", "(", ")", ";", "final", "Lock", "lock", "=", "this", ".", "syncConfig", ".", "getNamespaceConfig", "(", "namespace", ")", ".", "getLock", "(", ")", ".", "writeLock", "(", ")", ";", "lock", ".", "lock", "(", ")", ";", "final", "DeleteManyModel", "<", "CoreDocumentSynchronizationConfig", ">", "configsToDelete", ";", "try", "{", "ongoingOperationsGroup", ".", "enter", "(", ")", ";", "configsToDelete", "=", "syncConfig", ".", "removeSynchronizedDocuments", "(", "namespace", ",", "documentIds", ")", ";", "}", "finally", "{", "lock", ".", "unlock", "(", ")", ";", "ongoingOperationsGroup", ".", "exit", "(", ")", ";", "}", "LocalSyncWriteModelContainer", "container", "=", "null", ";", "if", "(", "configsToDelete", "!=", "null", ")", "{", "container", "=", "newWriteModelContainer", "(", "nsConfig", ")", ";", "container", ".", "addDocIDs", "(", "documentIds", ")", ";", "container", ".", "addLocalWrite", "(", "new", "DeleteManyModel", "<>", "(", "new", "BsonDocument", "(", "\"_id\"", ",", "new", "BsonDocument", "(", "\"$in\"", ",", "new", "BsonArray", "(", "Arrays", ".", "asList", "(", "documentIds", ")", ")", ")", ")", ")", ")", ";", "container", ".", "addConfigWrite", "(", "configsToDelete", ")", ";", "}", "return", "container", ";", "}" ]

[ "Requests", "that", "a", "document", "be", "no", "longer", "be", "synchronized", "by", "the", "given", "_id", ".", "Any", "uncommitted", "writes", "will", "be", "lost", "." ]

[ "public", "static", "byte", "[", "]", "decodeSingleNullable", "(", "byte", "[", "]", "src", ",", "int", "prefixPadding", ",", "int", "suffixPadding", ")", "throws", "CorruptEncodingException", "{", "try", "{", "byte", "b", "=", "src", "[", "prefixPadding", "]", ";", "if", "(", "b", "==", "NULL_BYTE_HIGH", "||", "b", "==", "NULL_BYTE_LOW", ")", "{", "return", "null", ";", "}", "int", "length", "=", "src", ".", "length", "-", "suffixPadding", "-", "1", "-", "prefixPadding", ";", "if", "(", "length", "==", "0", ")", "{", "return", "EMPTY_BYTE_ARRAY", ";", "}", "byte", "[", "]", "value", "=", "new", "byte", "[", "length", "]", ";", "System", ".", "arraycopy", "(", "src", ",", "1", "+", "prefixPadding", ",", "value", ",", "0", ",", "length", ")", ";", "return", "value", ";", "}", "catch", "(", "IndexOutOfBoundsException", "e", ")", "{", "throw", "new", "CorruptEncodingException", "(", "null", ",", "e", ")", ";", "}", "}" ]

[ "Decodes", "the", "given", "byte", "array", "which", "was", "encoded", "by", "{", "@link", "DataEncoder#encodeSingleNullable", "}", ".", "Always", "returns", "a", "new", "byte", "array", "instance", "." ]

[ "public", "static", "void", "checkEigenvalues", "(", ")", "{", "DoubleMatrix", "A", "=", "new", "DoubleMatrix", "(", "new", "double", "[", "]", "[", "]", "{", "{", "3.0", ",", "2.0", ",", "0.0", "}", ",", "{", "2.0", ",", "3.0", ",", "2.0", "}", ",", "{", "0.0", ",", "2.0", ",", "3.0", "}", "}", ")", ";", "DoubleMatrix", "E", "=", "new", "DoubleMatrix", "(", "3", ",", "1", ")", ";", "NativeBlas", ".", "dsyev", "(", "'", "'", ",", "'", "'", ",", "3", ",", "A", ".", "data", ",", "0", ",", "3", ",", "E", ".", "data", ",", "0", ")", ";", "check", "(", "\"checking existence of dsyev...\"", ",", "true", ")", ";", "}" ]

[ "Compute", "eigenvalues", ".", "This", "is", "a", "routine", "not", "in", "ATLAS", "but", "in", "the", "original", "LAPACK", "." ]

[ "public", "static", "Predicate", "<", "Map", ".", "Entry", "<", "Long", ",", "Boolean", ">", ">", "amongDeadHsids", "(", "final", "Set", "<", "Long", ">", "hsids", ")", "{", "return", "new", "Predicate", "<", "Map", ".", "Entry", "<", "Long", ",", "Boolean", ">", ">", "(", ")", "{", "@", "Override", "public", "boolean", "apply", "(", "Entry", "<", "Long", ",", "Boolean", ">", "e", ")", "{", "return", "hsids", ".", "contains", "(", "e", ".", "getKey", "(", ")", ")", "&&", "e", ".", "getValue", "(", ")", ";", "}", "}", ";", "}" ]

[ "returns", "a", "map", "entry", "predicate", "that", "tests", "whether", "or", "not", "the", "given", "map", "entry", "describes", "a", "dead", "site" ]

[ "@", "Pure", "public", "BusHub", "getBusHub", "(", "String", "name", ",", "Comparator", "<", "String", ">", "nameComparator", ")", "{", "if", "(", "name", "==", "null", ")", "{", "return", "null", ";", "}", "final", "Comparator", "<", "String", ">", "cmp", "=", "nameComparator", "==", "null", "?", "BusNetworkUtilities", ".", "NAME_COMPARATOR", ":", "nameComparator", ";", "for", "(", "final", "BusHub", "busHub", ":", "this", ".", "validBusHubs", ")", "{", "if", "(", "cmp", ".", "compare", "(", "name", ",", "busHub", ".", "getName", "(", ")", ")", "==", "0", ")", "{", "return", "busHub", ";", "}", "}", "for", "(", "final", "BusHub", "busHub", ":", "this", ".", "invalidBusHubs", ")", "{", "if", "(", "cmp", ".", "compare", "(", "name", ",", "busHub", ".", "getName", "(", ")", ")", "==", "0", ")", "{", "return", "busHub", ";", "}", "}", "return", "null", ";", "}" ]

[ "Replies", "the", "bus", "hub", "with", "the", "specified", "name", "." ]

[ "public", "void", "enforceVersion", "(", "Log", "log", ",", "String", "variableName", ",", "String", "requiredVersionRange", ",", "ArtifactVersion", "actualVersion", ")", "throws", "EnforcerRuleException", "{", "if", "(", "StringUtils", ".", "isEmpty", "(", "requiredVersionRange", ")", ")", "{", "throw", "new", "EnforcerRuleException", "(", "variableName", "+", "\" version can't be empty.\"", ")", ";", "}", "else", "{", "VersionRange", "vr", ";", "String", "msg", "=", "\"Detected \"", "+", "variableName", "+", "\" Version: \"", "+", "actualVersion", ";", "// short circuit check if the strings are exactly equal", "if", "(", "actualVersion", ".", "toString", "(", ")", ".", "equals", "(", "requiredVersionRange", ")", ")", "{", "log", ".", "debug", "(", "msg", "+", "\" is allowed in the range \"", "+", "requiredVersionRange", "+", "\".\"", ")", ";", "}", "else", "{", "try", "{", "vr", "=", "VersionRange", ".", "createFromVersionSpec", "(", "requiredVersionRange", ")", ";", "if", "(", "containsVersion", "(", "vr", ",", "actualVersion", ")", ")", "{", "log", ".", "debug", "(", "msg", "+", "\" is allowed in the range \"", "+", "requiredVersionRange", "+", "\".\"", ")", ";", "}", "else", "{", "String", "message", "=", "getMessage", "(", ")", ";", "if", "(", "StringUtils", ".", "isEmpty", "(", "message", ")", ")", "{", "message", "=", "msg", "+", "\" is not in the allowed range \"", "+", "vr", "+", "\".\"", ";", "}", "throw", "new", "EnforcerRuleException", "(", "message", ")", ";", "}", "}", "catch", "(", "InvalidVersionSpecificationException", "e", ")", "{", "throw", "new", "EnforcerRuleException", "(", "\"The requested \"", "+", "variableName", "+", "\" version \"", "+", "requiredVersionRange", "+", "\" is invalid.\"", ",", "e", ")", ";", "}", "}", "}", "}" ]

[ "Compares", "the", "specified", "version", "to", "see", "if", "it", "is", "allowed", "by", "the", "defined", "version", "range", "." ]

[ "@", "SuppressWarnings", "(", "\"UnusedParameters\"", ")", "protected", "String", "serialize", "(", "String", "serviceName", ",", "String", "id", ",", "Payload", "payload", ")", "{", "return", "String", ".", "valueOf", "(", "payload", ")", ";", "}" ]

[ "Subclasses", "may", "override", "this", "to", "customize", "the", "persistent", "format", "of", "the", "payload", "." ]

[ "public", "void", "buildMemberSummary", "(", "XMLNode", "node", ",", "Content", "classContentTree", ")", "throws", "Exception", "{", "Content", "memberSummaryTree", "=", "writer", ".", "getMemberTreeHeader", "(", ")", ";", "configuration", ".", "getBuilderFactory", "(", ")", ".", "getMemberSummaryBuilder", "(", "writer", ")", ".", "buildChildren", "(", "node", ",", "memberSummaryTree", ")", ";", "classContentTree", ".", "addContent", "(", "writer", ".", "getMemberSummaryTree", "(", "memberSummaryTree", ")", ")", ";", "}" ]

[ "Build", "the", "member", "summary", "contents", "of", "the", "page", "." ]

[ "private", "void", "requirePkInitialized", "(", "CodeBuilder", "b", ",", "String", "methodName", ")", "{", "// Add code to call method which we are about to define.\r", "b", ".", "loadThis", "(", ")", ";", "b", ".", "invokeVirtual", "(", "methodName", ",", "null", ",", "null", ")", ";", "// Now define new method, discarding original builder object.\r", "b", "=", "new", "CodeBuilder", "(", "mClassFile", ".", "addMethod", "(", "Modifiers", ".", "PROTECTED", ",", "methodName", ",", "null", ",", "null", ")", ")", ";", "b", ".", "loadThis", "(", ")", ";", "b", ".", "invokeVirtual", "(", "IS_REQUIRED_PK_INITIALIZED_METHOD_NAME", ",", "TypeDesc", ".", "BOOLEAN", ",", "null", ")", ";", "Label", "pkInitialized", "=", "b", ".", "createLabel", "(", ")", ";", "b", ".", "ifZeroComparisonBranch", "(", "pkInitialized", ",", "\"!=\"", ")", ";", "CodeBuilderUtil", ".", "throwException", "(", "b", ",", "IllegalStateException", ".", "class", ",", "\"Primary key not fully specified\"", ")", ";", "pkInitialized", ".", "setLocation", "(", ")", ";", "b", ".", "returnVoid", "(", ")", ";", "}" ]

[ "Generates", "code", "that", "verifies", "that", "all", "primary", "keys", "are", "initialized", "." ]

[ "protected", "static", "boolean", "compareAttributes", "(", "Part", "left", ",", "Part", "right", ")", "{", "if", "(", "left", "==", "right", ")", "{", "return", "true", ";", "}", "else", "if", "(", "left", "==", "Part", ".", "ANY", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "This", "does", "not", "follow", "the", "spec", "precisely", "because", "ANY", "compared", "to", "NA", "is", "classified", "as", "undefined", "by", "the", "spec", ";", "however", "in", "this", "implementation", "ANY", "will", "match", "NA", "and", "return", "true", "." ]

[ "public", "static", "@", "NonNull", "ClickEvent", "runCommand", "(", "final", "@", "NonNull", "String", "command", ")", "{", "return", "new", "ClickEvent", "(", "Action", ".", "RUN_COMMAND", ",", "command", ")", ";", "}" ]

[ "Creates", "a", "click", "event", "that", "runs", "a", "command", "." ]

[ "private", "Environment", "checkWhile", "(", "Stmt", ".", "While", "stmt", ",", "Environment", "environment", ",", "EnclosingScope", "scope", ")", "{", "// Type loop invariant(s).", "checkConditions", "(", "stmt", ".", "getInvariant", "(", ")", ",", "true", ",", "environment", ")", ";", "// Type condition assuming its true to represent inside a loop", "// iteration.", "// Important if condition contains a type test, as we'll know it holds.", "Environment", "trueEnvironment", "=", "checkCondition", "(", "stmt", ".", "getCondition", "(", ")", ",", "true", ",", "environment", ")", ";", "// Type condition assuming its false to represent the terminated loop.", "// Important if condition contains a type test, as we'll know it doesn't", "// hold.", "Environment", "falseEnvironment", "=", "checkCondition", "(", "stmt", ".", "getCondition", "(", ")", ",", "false", ",", "environment", ")", ";", "// Type loop body using true environment", "checkBlock", "(", "stmt", ".", "getBody", "(", ")", ",", "trueEnvironment", ",", "scope", ")", ";", "// Determine and update modified variables", "Tuple", "<", "Decl", ".", "Variable", ">", "modified", "=", "FlowTypeUtils", ".", "determineModifiedVariables", "(", "stmt", ".", "getBody", "(", ")", ")", ";", "stmt", ".", "setModified", "(", "stmt", ".", "getHeap", "(", ")", ".", "allocate", "(", "modified", ")", ")", ";", "// Return false environment to represent flow after loop.", "return", "falseEnvironment", ";", "}" ]

[ "Type", "check", "a", "<code", ">", "whiley<", "/", "code", ">", "statement", "." ]

[ "protected", "String", "verifyPortletWindowId", "(", "HttpServletRequest", "request", ",", "IPortletWindowId", "portletWindowId", ")", "{", "final", "IUserInstance", "userInstance", "=", "this", ".", "userInstanceManager", ".", "getUserInstance", "(", "request", ")", ";", "final", "IUserPreferencesManager", "preferencesManager", "=", "userInstance", ".", "getPreferencesManager", "(", ")", ";", "final", "IUserLayoutManager", "userLayoutManager", "=", "preferencesManager", ".", "getUserLayoutManager", "(", ")", ";", "final", "IPortletWindow", "portletWindow", "=", "this", ".", "portletWindowRegistry", ".", "getPortletWindow", "(", "request", ",", "portletWindowId", ")", ";", "final", "IPortletWindowId", "delegationParentWindowId", "=", "portletWindow", ".", "getDelegationParentId", "(", ")", ";", "if", "(", "delegationParentWindowId", "!=", "null", ")", "{", "return", "verifyPortletWindowId", "(", "request", ",", "delegationParentWindowId", ")", ";", "}", "final", "IPortletEntity", "portletEntity", "=", "portletWindow", ".", "getPortletEntity", "(", ")", ";", "final", "String", "channelSubscribeId", "=", "portletEntity", ".", "getLayoutNodeId", "(", ")", ";", "final", "IUserLayoutNodeDescription", "node", "=", "userLayoutManager", ".", "getNode", "(", "channelSubscribeId", ")", ";", "if", "(", "node", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"No layout node exists for id \"", "+", "channelSubscribeId", "+", "\" of window \"", "+", "portletWindowId", ")", ";", "}", "return", "node", ".", "getId", "(", ")", ";", "}" ]

[ "Verify", "the", "requested", "portlet", "window", "corresponds", "to", "a", "node", "in", "the", "user", "s", "layout", "and", "return", "the", "corresponding", "layout", "node", "id" ]

[ "static", "String", "extractWhereConditions", "(", "boolean", "updateMode", ",", "SQLiteModelMethod", "method", ")", "{", "final", "One", "<", "String", ">", "whereCondition", "=", "new", "One", "<", "String", ">", "(", "\"\"", ")", ";", "final", "One", "<", "Boolean", ">", "found", "=", "new", "One", "<", "Boolean", ">", "(", "null", ")", ";", "JQLChecker", ".", "getInstance", "(", ")", ".", "replaceVariableStatements", "(", "method", ",", "method", ".", "jql", ".", "value", ",", "new", "JQLReplaceVariableStatementListenerImpl", "(", ")", "{", "@", "Override", "public", "String", "onWhere", "(", "String", "statement", ")", "{", "if", "(", "found", ".", "value0", "==", "null", ")", "{", "whereCondition", ".", "value0", "=", "statement", ";", "found", ".", "value0", "=", "true", ";", "}", "return", "null", ";", "}", "}", ")", ";", "return", "StringUtils", ".", "ifNotEmptyAppend", "(", "whereCondition", ".", "value0", ",", "\" \"", ")", ";", "}" ]

[ "Extract", "where", "conditions", "." ]

[ "public", "static", "DeviceListResult", "deviceList", "(", "String", "accessToken", ",", "DeviceList", "deviceList", ")", "{", "return", "deviceList", "(", "accessToken", ",", "JsonUtil", ".", "toJSONString", "(", "deviceList", ")", ")", ";", "}" ]

[ "Wi", "-", "Fi设备管理", "-", "查询设备", "可通过指定分页或具体门店ID的方式，查询当前MP账号下指定门店连网成功的设备信息。一次最多能查询20个门店的设备信息。" ]

[ "protected", "IWord", "[", "]", "getNextMatch", "(", "char", "[", "]", "chars", ",", "int", "index", ")", "{", "ArrayList", "<", "IWord", ">", "mList", "=", "new", "ArrayList", "<", "IWord", ">", "(", "8", ")", ";", "//StringBuilder isb = new StringBuilder();", "isb", ".", "clear", "(", ")", ";", "char", "c", "=", "chars", "[", "index", "]", ";", "isb", ".", "append", "(", "c", ")", ";", "String", "temp", "=", "isb", ".", "toString", "(", ")", ";", "if", "(", "dic", ".", "match", "(", "ILexicon", ".", "CJK_WORD", ",", "temp", ")", ")", "{", "mList", ".", "add", "(", "dic", ".", "get", "(", "ILexicon", ".", "CJK_WORD", ",", "temp", ")", ")", ";", "}", "String", "_key", "=", "null", ";", "for", "(", "int", "j", "=", "1", ";", "j", "<", "config", ".", "MAX_LENGTH", "&&", "(", "(", "j", "+", "index", ")", "<", "chars", ".", "length", ")", ";", "j", "++", ")", "{", "isb", ".", "append", "(", "chars", "[", "j", "+", "index", "]", ")", ";", "_key", "=", "isb", ".", "toString", "(", ")", ";", "if", "(", "dic", ".", "match", "(", "ILexicon", ".", "CJK_WORD", ",", "_key", ")", ")", "{", "mList", ".", "add", "(", "dic", ".", "get", "(", "ILexicon", ".", "CJK_WORD", ",", "_key", ")", ")", ";", "}", "}", "/*\n * if match no words from the current position \n * to idx+Config.MAX_LENGTH, just return the Word with\n * a value of temp as a unrecognited word. \n */", "if", "(", "mList", ".", "isEmpty", "(", ")", ")", "{", "mList", ".", "add", "(", "new", "Word", "(", "temp", ",", "ILexicon", ".", "UNMATCH_CJK_WORD", ")", ")", ";", "}", "/* for ( int j = 0; j < mList.size(); j++ ) {\n System.out.println(mList.get(j));\n }*/", "IWord", "[", "]", "words", "=", "new", "IWord", "[", "mList", ".", "size", "(", ")", "]", ";", "mList", ".", "toArray", "(", "words", ")", ";", "mList", ".", "clear", "(", ")", ";", "return", "words", ";", "}" ]

[ "match", "the", "next", "CJK", "word", "in", "the", "dictionary" ]

[ "public", "static", "void", "setWriterDirOctalPermissions", "(", "State", "state", ",", "int", "numBranches", ",", "int", "branchId", ",", "String", "octalPermissions", ")", "{", "state", ".", "setProp", "(", "ForkOperatorUtils", ".", "getPropertyNameForBranch", "(", "ConfigurationKeys", ".", "WRITER_DIR_PERMISSIONS", ",", "numBranches", ",", "branchId", ")", ",", "octalPermissions", ")", ";", "}" ]

[ "Given", "a", "{" ]

[ "public", "static", "void", "appendSize", "(", "StringBuilder", "buf", ",", "long", "size", ")", "{", "if", "(", "size", ">=", "104857600", ")", "{", "// >= 100 MiB", "buf", ".", "append", "(", "size", "/", "1048576", ")", ".", "append", "(", "\"MiB(\"", ")", ".", "append", "(", "size", ")", ".", "append", "(", "\"B)\"", ")", ";", "}", "else", "if", "(", "size", ">=", "102400", ")", "{", "// >= 100 KiB", "buf", ".", "append", "(", "size", "/", "1024", ")", ".", "append", "(", "\"KiB(\"", ")", ".", "append", "(", "size", ")", ".", "append", "(", "\"B)\"", ")", ";", "}", "else", "{", "buf", ".", "append", "(", "size", ")", ".", "append", "(", "'", "'", ")", ";", "}", "}" ]

[ "Appends", "the", "human", "-", "readable", "representation", "of", "the", "specified", "byte", "-", "unit", "{" ]

[ "@", "GwtIncompatible", "(", "\"incompatible method\"", ")", "public", "static", "void", "printRootCauseStackTrace", "(", "final", "Throwable", "throwable", ",", "final", "PrintStream", "stream", ")", "{", "if", "(", "throwable", "==", "null", ")", "{", "return", ";", "}", "Validate", ".", "isTrue", "(", "stream", "!=", "null", ",", "\"The PrintStream must not be null\"", ")", ";", "final", "String", "trace", "[", "]", "=", "getRootCauseStackTrace", "(", "throwable", ")", ";", "for", "(", "final", "String", "element", ":", "trace", ")", "{", "stream", ".", "println", "(", "element", ")", ";", "}", "stream", ".", "flush", "(", ")", ";", "}" ]

[ "<p", ">", "Prints", "a", "compact", "stack", "trace", "for", "the", "root", "cause", "of", "a", "throwable", ".", "<", "/", "p", ">" ]

[ "public", "void", "serviceName_zone_name_terminate_POST", "(", "String", "serviceName", ",", "String", "name", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/ipLoadbalancing/{serviceName}/zone/{name}/terminate\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ",", "name", ")", ";", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "null", ")", ";", "}" ]

[ "Terminate", "your", "service", "zone", "option" ]

[ "public", "static", "Collection", "beanMap", "(", "final", "String", "property", ",", "Iterator", "i", ",", "boolean", "includeNull", ")", "{", "return", "map", "(", "beanMapper", "(", "property", ")", ",", "i", ",", "includeNull", ")", ";", "}" ]

[ "Map", "dynamically", "using", "a", "bean", "property", "name", "." ]

[ "public", "PageImages", "listWorkspaceFilePages", "(", "String", "accountId", ",", "String", "workspaceId", ",", "String", "folderId", ",", "String", "fileId", ",", "WorkspacesApi", ".", "ListWorkspaceFilePagesOptions", "options", ")", "throws", "ApiException", "{", "Object", "localVarPostBody", "=", "\"{}\"", ";", "// verify the required parameter 'accountId' is set", "if", "(", "accountId", "==", "null", ")", "{", "throw", "new", "ApiException", "(", "400", ",", "\"Missing the required parameter 'accountId' when calling listWorkspaceFilePages\"", ")", ";", "}", "// verify the required parameter 'workspaceId' is set", "if", "(", "workspaceId", "==", "null", ")", "{", "throw", "new", "ApiException", "(", "400", ",", "\"Missing the required parameter 'workspaceId' when calling listWorkspaceFilePages\"", ")", ";", "}", "// verify the required parameter 'folderId' is set", "if", "(", "folderId", "==", "null", ")", "{", "throw", "new", "ApiException", "(", "400", ",", "\"Missing the required parameter 'folderId' when calling listWorkspaceFilePages\"", ")", ";", "}", "// verify the required parameter 'fileId' is set", "if", "(", "fileId", "==", "null", ")", "{", "throw", "new", "ApiException", "(", "400", ",", "\"Missing the required parameter 'fileId' when calling listWorkspaceFilePages\"", ")", ";", "}", "// create path and map variables", "String", "localVarPath", "=", "\"/v2/accounts/{accountId}/workspaces/{workspaceId}/folders/{folderId}/files/{fileId}/pages\"", ".", "replaceAll", "(", "\"\\\\{format\\\\}\"", ",", "\"json\"", ")", ".", "replaceAll", "(", "\"\\\\{\"", "+", "\"accountId\"", "+", "\"\\\\}\"", ",", "apiClient", ".", "escapeString", "(", "accountId", ".", "toString", "(", ")", ")", ")", ".", "replaceAll", "(", "\"\\\\{\"", "+", "\"workspaceId\"", "+", "\"\\\\}\"", ",", "apiClient", ".", "escapeString", "(", "workspaceId", ".", "toString", "(", ")", ")", ")", ".", "replaceAll", "(", "\"\\\\{\"", "+", "\"folderId\"", "+", "\"\\\\}\"", ",", "apiClient", ".", "escapeString", "(", "folderId", ".", "toString", "(", ")", ")", ")", ".", "replaceAll", "(", "\"\\\\{\"", "+", "\"fileId\"", "+", "\"\\\\}\"", ",", "apiClient", ".", "escapeString", "(", "fileId", ".", "toString", "(", ")", ")", ")", ";", "// query params", "java", ".", "util", ".", "List", "<", "Pair", ">", "localVarQueryParams", "=", "new", "java", ".", "util", ".", "ArrayList", "<", "Pair", ">", "(", ")", ";", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "localVarHeaderParams", "=", "new", "java", ".", "util", ".", "HashMap", "<", "String", ",", "String", ">", "(", ")", ";", "java", ".", "util", ".", "Map", "<", "String", ",", "Object", ">", "localVarFormParams", "=", "new", "java", ".", "util", ".", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "if", "(", "options", "!=", "null", ")", "{", "localVarQueryParams", ".", "addAll", "(", "apiClient", ".", "parameterToPairs", "(", "\"\"", ",", "\"count\"", ",", "options", ".", "count", ")", ")", ";", "localVarQueryParams", ".", "addAll", "(", "apiClient", ".", "parameterToPairs", "(", "\"\"", ",", "\"dpi\"", ",", "options", ".", "dpi", ")", ")", ";", "localVarQueryParams", ".", "addAll", "(", "apiClient", ".", "parameterToPairs", "(", "\"\"", ",", "\"max_height\"", ",", "options", ".", "maxHeight", ")", ")", ";", "localVarQueryParams", ".", "addAll", "(", "apiClient", ".", "parameterToPairs", "(", "\"\"", ",", "\"max_width\"", ",", "options", ".", "maxWidth", ")", ")", ";", "localVarQueryParams", ".", "addAll", "(", "apiClient", ".", "parameterToPairs", "(", "\"\"", ",", "\"start_position\"", ",", "options", ".", "startPosition", ")", ")", ";", "}", "final", "String", "[", "]", "localVarAccepts", "=", "{", "\"application/json\"", "}", ";", "final", "String", "localVarAccept", "=", "apiClient", ".", "selectHeaderAccept", "(", "localVarAccepts", ")", ";", "final", "String", "[", "]", "localVarContentTypes", "=", "{", "}", ";", "final", "String", "localVarContentType", "=", "apiClient", ".", "selectHeaderContentType", "(", "localVarContentTypes", ")", ";", "String", "[", "]", "localVarAuthNames", "=", "new", "String", "[", "]", "{", "\"docusignAccessCode\"", "}", ";", "//{ };", "GenericType", "<", "PageImages", ">", "localVarReturnType", "=", "new", "GenericType", "<", "PageImages", ">", "(", ")", "{", "}", ";", "return", "apiClient", ".", "invokeAPI", "(", "localVarPath", ",", "\"GET\"", ",", "localVarQueryParams", ",", "localVarPostBody", ",", "localVarHeaderParams", ",", "localVarFormParams", ",", "localVarAccept", ",", "localVarContentType", ",", "localVarAuthNames", ",", "localVarReturnType", ")", ";", "}" ]

[ "List", "File", "Pages", "Retrieves", "a", "workspace", "file", "as", "rasterized", "pages", "." ]

[ "private", "void", "removeSlotRequestFromSlot", "(", "SlotID", "slotId", ",", "AllocationID", "allocationId", ")", "{", "TaskManagerSlot", "taskManagerSlot", "=", "slots", ".", "get", "(", "slotId", ")", ";", "if", "(", "null", "!=", "taskManagerSlot", ")", "{", "if", "(", "taskManagerSlot", ".", "getState", "(", ")", "==", "TaskManagerSlot", ".", "State", ".", "PENDING", "&&", "Objects", ".", "equals", "(", "allocationId", ",", "taskManagerSlot", ".", "getAssignedSlotRequest", "(", ")", ".", "getAllocationId", "(", ")", ")", ")", "{", "TaskManagerRegistration", "taskManagerRegistration", "=", "taskManagerRegistrations", ".", "get", "(", "taskManagerSlot", ".", "getInstanceId", "(", ")", ")", ";", "if", "(", "taskManagerRegistration", "==", "null", ")", "{", "throw", "new", "IllegalStateException", "(", "\"Trying to remove slot request from slot for which there is no TaskManager \"", "+", "taskManagerSlot", ".", "getInstanceId", "(", ")", "+", "\" is registered.\"", ")", ";", "}", "// clear the pending slot request", "taskManagerSlot", ".", "clearPendingSlotRequest", "(", ")", ";", "updateSlotState", "(", "taskManagerSlot", ",", "taskManagerRegistration", ",", "null", ",", "null", ")", ";", "}", "else", "{", "LOG", ".", "debug", "(", "\"Ignore slot request removal for slot {}.\"", ",", "slotId", ")", ";", "}", "}", "else", "{", "LOG", ".", "debug", "(", "\"There was no slot with {} registered. Probably this slot has been already freed.\"", ",", "slotId", ")", ";", "}", "}" ]

[ "Removes", "a", "pending", "slot", "request", "identified", "by", "the", "given", "allocation", "id", "from", "a", "slot", "identified", "by", "the", "given", "slot", "id", "." ]

[ "public", "OvhOperation", "serviceName_output_graylog_stream_streamId_rule_POST", "(", "String", "serviceName", ",", "String", "streamId", ",", "String", "field", ",", "Boolean", "isInverted", ",", "OvhStreamRuleOperatorEnum", "operator", ",", "String", "value", ")", "throws", "IOException", "{", "String", "qPath", "=", "\"/dbaas/logs/{serviceName}/output/graylog/stream/{streamId}/rule\"", ";", "StringBuilder", "sb", "=", "path", "(", "qPath", ",", "serviceName", ",", "streamId", ")", ";", "HashMap", "<", "String", ",", "Object", ">", "o", "=", "new", "HashMap", "<", "String", ",", "Object", ">", "(", ")", ";", "addBody", "(", "o", ",", "\"field\"", ",", "field", ")", ";", "addBody", "(", "o", ",", "\"isInverted\"", ",", "isInverted", ")", ";", "addBody", "(", "o", ",", "\"operator\"", ",", "operator", ")", ";", "addBody", "(", "o", ",", "\"value\"", ",", "value", ")", ";", "String", "resp", "=", "exec", "(", "qPath", ",", "\"POST\"", ",", "sb", ".", "toString", "(", ")", ",", "o", ")", ";", "return", "convertTo", "(", "resp", ",", "OvhOperation", ".", "class", ")", ";", "}" ]

[ "Register", "a", "new", "rule", "on", "specified", "graylog", "stream" ]

[ "public", "static", "PactDslJsonArray", "arrayMinMaxLike", "(", "int", "minSize", ",", "int", "maxSize", ",", "PactDslJsonRootValue", "value", ")", "{", "return", "arrayMinMaxLike", "(", "minSize", ",", "maxSize", ",", "minSize", ",", "value", ")", ";", "}" ]

[ "Root", "level", "array", "with", "minimum", "and", "maximum", "size", "where", "each", "item", "must", "match", "the", "provided", "matcher" ]

[ "public", "Observable", "<", "Page", "<", "FirewallRuleInner", ">", ">", "listByServerAsync", "(", "final", "String", "resourceGroupName", ",", "final", "String", "serverName", ")", "{", "return", "listByServerWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "FirewallRuleInner", ">", ">", ",", "Page", "<", "FirewallRuleInner", ">", ">", "(", ")", "{", "@", "Override", "public", "Page", "<", "FirewallRuleInner", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "FirewallRuleInner", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "firewall", "rules", "." ]

[ "public", "static", "void", "putAt", "(", "StringBuilder", "self", ",", "IntRange", "range", ",", "Object", "value", ")", "{", "RangeInfo", "info", "=", "subListBorders", "(", "self", ".", "length", "(", ")", ",", "range", ")", ";", "self", ".", "replace", "(", "info", ".", "from", ",", "info", ".", "to", ",", "value", ".", "toString", "(", ")", ")", ";", "}" ]

[ "Support", "the", "range", "subscript", "operator", "for", "StringBuilder", ".", "Index", "values", "are", "treated", "as", "characters", "within", "the", "builder", "." ]

[ "private", "Asset", "getInlineAsset", "(", "Resource", "ntResourceResource", ",", "Media", "media", ",", "String", "fileName", ")", "{", "return", "new", "InlineAsset", "(", "ntResourceResource", ",", "media", ",", "fileName", ",", "adaptable", ")", ";", "}" ]

[ "Get", "implementation", "of", "inline", "media", "item" ]

[ "public", "HttpResponse", "withHeader", "(", "String", "name", ",", "String", "...", "values", ")", "{", "this", ".", "headers", ".", "withEntry", "(", "name", ",", "values", ")", ";", "return", "this", ";", "}" ]

[ "Add", "a", "header", "to", "return", "as", "a", "Header", "object", "if", "a", "header", "with", "the", "same", "name", "already", "exists", "this", "will", "NOT", "be", "modified", "but", "two", "headers", "will", "exist" ]

[ "public", "TransportApiResult", "<", "List", "<", "Agency", ">", ">", "getAgenciesNearby", "(", "AgencyQueryOptions", "options", ",", "double", "latitude", ",", "double", "longitude", ",", "int", "radiusInMeters", ")", "{", "if", "(", "options", "==", "null", ")", "{", "options", "=", "AgencyQueryOptions", ".", "defaultQueryOptions", "(", ")", ";", "}", "if", "(", "radiusInMeters", "<", "0", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Invalid limit. Valid values are positive numbers only.\"", ")", ";", "}", "return", "TransportApiClientCalls", ".", "getAgencies", "(", "tokenComponent", ",", "settings", ",", "options", ",", "new", "Point", "(", "longitude", ",", "latitude", ")", ",", "radiusInMeters", ",", "null", ")", ";", "}" ]

[ "Gets", "a", "list", "of", "agencies", "nearby", "ordered", "by", "distance", "from", "the", "point", "specified", "." ]

[ "public", "static", "<", "T", ">", "T", "requestParamaterToObject", "(", "NativeWebRequest", "req", ",", "Class", "<", "T", ">", "c", ")", "{", "return", "requestParamaterToObject", "(", "(", "HttpServletRequest", ")", "req", ".", "getNativeRequest", "(", ")", ",", "c", ",", "\"UTF-8\"", ")", ";", "}" ]

[ "Request", "paramater", "to", "object", "t", "." ]

[ "public", "static", "int", "copyAndCloseBoth", "(", "Reader", "input", ",", "Writer", "output", ")", "throws", "IOException", "{", "try", "{", "return", "copyAndCloseOutput", "(", "input", ",", "output", ")", ";", "}", "finally", "{", "input", ".", "close", "(", ")", ";", "}", "}" ]

[ "Copy", "input", "to", "output", "and", "close", "both", "the", "input", "and", "output", "streams", "before", "returning" ]

[ "public", "static", "void", "registerProvider", "(", "String", "providerName", ",", "Class", "<", "?", "extends", "StorageProvider", ">", "providerClass", ")", "{", "if", "(", "PROVIDERS", ".", "containsKey", "(", "providerName", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"A provider already exists with the name \"", "+", "providerName", ")", ";", "}", "PROVIDERS", ".", "put", "(", "providerName", ",", "providerClass", ")", ";", "LOGGER", ".", "debug", "(", "\"Registering new provider: {}\"", ",", "providerClass", ".", "getSimpleName", "(", ")", ")", ";", "}" ]

[ "Register", "a", "new", "{", "@link", "StorageProvider", "}" ]

[ "public", "void", "increment", "(", "int", "i", ",", "int", "j", ",", "double", "value", ")", "{", "if", "(", "Double", ".", "isNaN", "(", "value", ")", "||", "Double", ".", "isInfinite", "(", "value", ")", ")", "throw", "new", "ArithmeticException", "(", "\"Can not add a value \"", "+", "value", ")", ";", "set", "(", "i", ",", "j", ",", "get", "(", "i", ",", "j", ")", "+", "value", ")", ";", "}" ]

[ "Alters", "the", "current", "matrix", "at", "index", "<i", ">", "(", "i", "j", ")", "<", "/", "i", ">", "to", "be", "equal", "to", "<i", ">", "A<sub", ">", "i", "j<", "/", "sub", ">", "=", "A<sub", ">", "i", "j<", "/", "sub", ">", "+", "value<", "/", "i", ">" ]

[ "public", "static", "File", "[", "]", "getExtensionFilesToLoad", "(", "ExtensionsConfig", "config", ")", "{", "final", "File", "rootExtensionsDir", "=", "new", "File", "(", "config", ".", "getDirectory", "(", ")", ")", ";", "if", "(", "rootExtensionsDir", ".", "exists", "(", ")", "&&", "!", "rootExtensionsDir", ".", "isDirectory", "(", ")", ")", "{", "throw", "new", "ISE", "(", "\"Root extensions directory [%s] is not a directory!?\"", ",", "rootExtensionsDir", ")", ";", "}", "File", "[", "]", "extensionsToLoad", ";", "final", "LinkedHashSet", "<", "String", ">", "toLoad", "=", "config", ".", "getLoadList", "(", ")", ";", "if", "(", "toLoad", "==", "null", ")", "{", "extensionsToLoad", "=", "rootExtensionsDir", ".", "listFiles", "(", ")", ";", "}", "else", "{", "int", "i", "=", "0", ";", "extensionsToLoad", "=", "new", "File", "[", "toLoad", ".", "size", "(", ")", "]", ";", "for", "(", "final", "String", "extensionName", ":", "toLoad", ")", "{", "File", "extensionDir", "=", "new", "File", "(", "extensionName", ")", ";", "if", "(", "!", "extensionDir", ".", "isAbsolute", "(", ")", ")", "{", "extensionDir", "=", "new", "File", "(", "rootExtensionsDir", ",", "extensionName", ")", ";", "}", "if", "(", "!", "extensionDir", ".", "isDirectory", "(", ")", ")", "{", "throw", "new", "ISE", "(", "\"Extension [%s] specified in \\\"druid.extensions.loadList\\\" didn't exist!?\"", ",", "extensionDir", ".", "getAbsolutePath", "(", ")", ")", ";", "}", "extensionsToLoad", "[", "i", "++", "]", "=", "extensionDir", ";", "}", "}", "return", "extensionsToLoad", "==", "null", "?", "new", "File", "[", "]", "{", "}", ":", "extensionsToLoad", ";", "}" ]

[ "Find", "all", "the", "extension", "files", "that", "should", "be", "loaded", "by", "druid", ".", "<p", "/", ">", "If", "user", "explicitly", "specifies", "druid", ".", "extensions", ".", "loadList", "then", "it", "will", "look", "for", "those", "extensions", "under", "root", "extensions", "directory", ".", "If", "one", "of", "them", "is", "not", "found", "druid", "will", "fail", "loudly", ".", "<p", "/", ">", "If", "user", "doesn", "t", "specify", "druid", ".", "extension", ".", "toLoad", "(", "or", "its", "value", "is", "empty", ")", "druid", "will", "load", "all", "the", "extensions", "under", "the", "root", "extensions", "directory", "." ]

[ "public", "Frustum", "setToFrustum", "(", "double", "left", ",", "double", "right", ",", "double", "bottom", ",", "double", "top", ",", "double", "near", ",", "double", "far", ")", "{", "return", "setToProjection", "(", "left", ",", "right", ",", "bottom", ",", "top", ",", "near", ",", "far", ",", "Vector3", ".", "UNIT_Z", ",", "false", ",", "false", ")", ";", "}" ]

[ "Sets", "this", "frustum", "to", "one", "pointing", "in", "the", "Z", "-", "direction", "with", "the", "specified", "parameters", "determining", "its", "size", "and", "shape", "(", "see", "the", "OpenGL", "documentation", "for", "<code", ">", "glFrustum<", "/", "code", ">", ")", "." ]

[ "private", "void", "logIfEnabled", "(", "Level", "level", ",", "Throwable", "throwable", ",", "String", "format", ",", "Object", "[", "]", "arguments", ")", "{", "this", ".", "logIfEnabled", "(", "FQCN_SELF", ",", "level", ",", "throwable", ",", "format", ",", "arguments", ")", ";", "}" ]

[ "打印对应等级的日志" ]

[ "public", "SetRequestAuthResponse", "setRequestAuth", "(", "SetRequestAuthRequest", "request", ")", "{", "checkNotNull", "(", "request", ",", "\"The parameter request should NOT be null.\"", ")", ";", "InternalRequest", "internalRequest", "=", "createRequest", "(", "request", ",", "HttpMethodName", ".", "PUT", ",", "DOMAIN", ",", "request", ".", "getDomain", "(", ")", ",", "\"config\"", ")", ";", "internalRequest", ".", "addParameter", "(", "\"requestAuth\"", ",", "\"\"", ")", ";", "this", ".", "attachRequestToBody", "(", "request", ",", "internalRequest", ")", ";", "return", "invokeHttpClient", "(", "internalRequest", ",", "SetRequestAuthResponse", ".", "class", ")", ";", "}" ]

[ "Set", "the", "request", "authentication", "." ]

[ "public", "static", "Certificate", "readX509Certificate", "(", "InputStream", "in", ",", "char", "[", "]", "password", ",", "String", "alias", ")", "{", "return", "readCertificate", "(", "X509", ",", "in", ",", "password", ",", "alias", ")", ";", "}" ]

[ "读取X", ".", "509", "Certification文件<br", ">", "Certification为证书文件<br", ">", "see", ":", "http", ":", "//", "snowolf", ".", "iteye", ".", "com", "/", "blog", "/", "391931" ]

[ "public", "boolean", "handleRedirect", "(", "int", "statusCode", ",", "HttpHeaders", "responseHeaders", ")", "{", "String", "redirectLocation", "=", "responseHeaders", ".", "getLocation", "(", ")", ";", "if", "(", "getFollowRedirects", "(", ")", "&&", "HttpStatusCodes", ".", "isRedirect", "(", "statusCode", ")", "&&", "redirectLocation", "!=", "null", ")", "{", "// resolve the redirect location relative to the current location", "setUrl", "(", "new", "GenericUrl", "(", "url", ".", "toURL", "(", "redirectLocation", ")", ")", ")", ";", "// on 303 change method to GET", "if", "(", "statusCode", "==", "HttpStatusCodes", ".", "STATUS_CODE_SEE_OTHER", ")", "{", "setRequestMethod", "(", "HttpMethods", ".", "GET", ")", ";", "// GET requests do not support non-zero content length", "setContent", "(", "null", ")", ";", "}", "// remove Authorization and If-* headers", "headers", ".", "setAuthorization", "(", "(", "String", ")", "null", ")", ";", "headers", ".", "setIfMatch", "(", "(", "String", ")", "null", ")", ";", "headers", ".", "setIfNoneMatch", "(", "(", "String", ")", "null", ")", ";", "headers", ".", "setIfModifiedSince", "(", "(", "String", ")", "null", ")", ";", "headers", ".", "setIfUnmodifiedSince", "(", "(", "String", ")", "null", ")", ";", "headers", ".", "setIfRange", "(", "(", "String", ")", "null", ")", ";", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Sets", "up", "this", "request", "object", "to", "handle", "the", "necessary", "redirect", "if", "redirects", "are", "turned", "on", "it", "is", "a", "redirect", "status", "code", "and", "the", "header", "has", "a", "location", "." ]

[ "public", "<", "S", ",", "T", ">", "Binding", "<", "S", ",", "T", ">", "findBinding", "(", "Class", "<", "S", ">", "source", ",", "Class", "<", "T", ">", "target", ")", "{", "return", "findBinding", "(", "new", "ConverterKey", "<", "S", ",", "T", ">", "(", "source", ",", "target", ",", "DefaultBinding", ".", "class", ")", ")", ";", "}" ]

[ "Resolve", "a", "Binding", "with", "the", "given", "source", "and", "target", "class", ".", "A", "binding", "unifies", "a", "marshaller", "and", "an", "unmarshaller", "and", "both", "must", "be", "available", "to", "resolve", "a", "binding", "." ]

[ "@", "Override", "public", "RandomVariable", "getValue", "(", "double", "evaluationTime", ",", "LIBORModelMonteCarloSimulationModel", "model", ")", "throws", "CalculationException", "{", "/*\n\t\t * Calculate value of the swap at exercise date on each path (beware of perfect forsight - all rates are simulationTime=exerciseDate)\n\t\t */", "RandomVariable", "valueFixLeg", "=", "new", "RandomVariableFromDoubleArray", "(", "fixingDates", "[", "fixingDates", ".", "length", "-", "1", "]", ",", "0.0", ")", ";", "RandomVariable", "valueFloatLeg", "=", "new", "RandomVariableFromDoubleArray", "(", "paymentDates", "[", "paymentDates", ".", "length", "-", "1", "]", ",", "-", "1.0", ")", ";", "// Calculate the value of the swap by working backward through all periods", "for", "(", "int", "period", "=", "fixingDates", ".", "length", "-", "1", ";", "period", ">=", "0", ";", "period", "--", ")", "{", "double", "fixingDate", "=", "fixingDates", "[", "period", "]", ";", "double", "paymentDate", "=", "paymentDates", "[", "period", "]", ";", "double", "periodLength", "=", "periodLengths", "!=", "null", "?", "periodLengths", "[", "period", "]", ":", "paymentDate", "-", "fixingDate", ";", "// Get random variables - note that this is the rate at simulation time = exerciseDate", "RandomVariable", "libor", "=", "model", ".", "getLIBOR", "(", "exerciseDate", ",", "fixingDate", ",", "paymentDate", ")", ";", "// Add payment received at end of period", "RandomVariable", "payoff", "=", "new", "RandomVariableFromDoubleArray", "(", "paymentDate", ",", "1.0", "*", "periodLength", ")", ";", "valueFixLeg", "=", "valueFixLeg", ".", "add", "(", "payoff", ")", ";", "// Discount back to beginning of period", "valueFloatLeg", "=", "valueFloatLeg", ".", "discount", "(", "libor", ",", "periodLength", ")", ";", "valueFixLeg", "=", "valueFixLeg", ".", "discount", "(", "libor", ",", "periodLength", ")", ";", "}", "valueFloatLeg", "=", "valueFloatLeg", ".", "add", "(", "1.0", ")", ";", "RandomVariable", "parSwapRate", "=", "valueFloatLeg", ".", "div", "(", "valueFixLeg", ")", ";", "RandomVariable", "payoffUnit", "=", "new", "RandomVariableFromDoubleArray", "(", "paymentDates", "[", "0", "]", ",", "periodLengths", "[", "0", "]", ")", ";", "payoffUnit", "=", "payoffUnit", ".", "discount", "(", "model", ".", "getLIBOR", "(", "exerciseDate", ",", "fixingDates", "[", "0", "]", ",", "paymentDates", "[", "0", "]", ")", ",", "paymentDates", "[", "0", "]", "-", "fixingDates", "[", "0", "]", ")", ";", "RandomVariable", "value", "=", "parSwapRate", ".", "sub", "(", "strike", ")", ".", "floor", "(", "0.0", ")", ".", "mult", "(", "payoffUnit", ")", ";", "// If the exercise date is not the first periods start date, then discount back to the exercise date (calculate the forward starting swap)", "if", "(", "fixingDates", "[", "0", "]", "!=", "exerciseDate", ")", "{", "RandomVariable", "libor", "=", "model", ".", "getLIBOR", "(", "exerciseDate", ",", "exerciseDate", ",", "fixingDates", "[", "0", "]", ")", ";", "double", "periodLength", "=", "fixingDates", "[", "0", "]", "-", "exerciseDate", ";", "// Discount back to beginning of period", "value", "=", "value", ".", "discount", "(", "libor", ",", "periodLength", ")", ";", "}", "/*\n\t\t * Calculate value\n\t\t */", "RandomVariable", "numeraire", "=", "model", ".", "getNumeraire", "(", "exerciseDate", ")", ";", "RandomVariable", "monteCarloProbabilities", "=", "model", ".", "getMonteCarloWeights", "(", "model", ".", "getTimeIndex", "(", "exerciseDate", ")", ")", ";", "value", "=", "value", ".", "div", "(", "numeraire", ")", ".", "mult", "(", "monteCarloProbabilities", ")", ";", "RandomVariable", "numeraireAtZero", "=", "model", ".", "getNumeraire", "(", "evaluationTime", ")", ";", "RandomVariable", "monteCarloProbabilitiesAtZero", "=", "model", ".", "getMonteCarloWeights", "(", "evaluationTime", ")", ";", "value", "=", "value", ".", "mult", "(", "numeraireAtZero", ")", ".", "div", "(", "monteCarloProbabilitiesAtZero", ")", ";", "return", "value", ";", "}" ]

[ "This", "method", "returns", "the", "value", "random", "variable", "of", "the", "product", "within", "the", "specified", "model", "evaluated", "at", "a", "given", "evalutationTime", ".", "Note", ":", "For", "a", "lattice", "this", "is", "often", "the", "value", "conditional", "to", "evalutationTime", "for", "a", "Monte", "-", "Carlo", "simulation", "this", "is", "the", "(", "sum", "of", ")", "value", "discounted", "to", "evaluation", "time", ".", "Cashflows", "prior", "evaluationTime", "are", "not", "considered", "." ]

[ "public", "static", "PyExpr", "convertMapToOrderedDict", "(", "Map", "<", "PyExpr", ",", "PyExpr", ">", "dict", ")", "{", "List", "<", "String", ">", "values", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "Map", ".", "Entry", "<", "PyExpr", ",", "PyExpr", ">", "entry", ":", "dict", ".", "entrySet", "(", ")", ")", "{", "values", ".", "add", "(", "\"(\"", "+", "entry", ".", "getKey", "(", ")", ".", "getText", "(", ")", "+", "\", \"", "+", "entry", ".", "getValue", "(", ")", ".", "getText", "(", ")", "+", "\")\"", ")", ";", "}", "Joiner", "joiner", "=", "Joiner", ".", "on", "(", "\", \"", ")", ";", "return", "new", "PyExpr", "(", "\"collections.OrderedDict([\"", "+", "joiner", ".", "join", "(", "values", ")", "+", "\"])\"", ",", "Integer", ".", "MAX_VALUE", ")", ";", "}" ]

[ "Convert", "a", "java", "Map", "to", "valid", "PyExpr", "as", "dict", "." ]

[ "public", "void", "scalePercent", "(", "float", "percentX", ",", "float", "percentY", ")", "{", "plainWidth", "=", "(", "getWidth", "(", ")", "*", "percentX", ")", "/", "100f", ";", "plainHeight", "=", "(", "getHeight", "(", ")", "*", "percentY", ")", "/", "100f", ";", "float", "[", "]", "matrix", "=", "matrix", "(", ")", ";", "scaledWidth", "=", "matrix", "[", "DX", "]", "-", "matrix", "[", "CX", "]", ";", "scaledHeight", "=", "matrix", "[", "DY", "]", "-", "matrix", "[", "CY", "]", ";", "setWidthPercentage", "(", "0", ")", ";", "}" ]

[ "Scale", "the", "width", "and", "height", "of", "an", "image", "to", "a", "certain", "percentage", "." ]

[ "public", "ResultSegment", "runPartitionScanQueryOnPartitionChunk", "(", "Query", "query", ",", "int", "partitionId", ",", "int", "tableIndex", ",", "int", "fetchSize", ")", "{", "MapContainer", "mapContainer", "=", "mapServiceContext", ".", "getMapContainer", "(", "query", ".", "getMapName", "(", ")", ")", ";", "Predicate", "predicate", "=", "queryOptimizer", ".", "optimize", "(", "query", ".", "getPredicate", "(", ")", ",", "mapContainer", ".", "getIndexes", "(", "partitionId", ")", ")", ";", "QueryableEntriesSegment", "entries", "=", "partitionScanExecutor", ".", "execute", "(", "query", ".", "getMapName", "(", ")", ",", "predicate", ",", "partitionId", ",", "tableIndex", ",", "fetchSize", ")", ";", "ResultProcessor", "processor", "=", "resultProcessorRegistry", ".", "get", "(", "query", ".", "getResultType", "(", ")", ")", ";", "Result", "result", "=", "processor", ".", "populateResult", "(", "query", ",", "Long", ".", "MAX_VALUE", ",", "entries", ".", "getEntries", "(", ")", ",", "singletonPartitionIdSet", "(", "partitionCount", ",", "partitionId", ")", ")", ";", "return", "new", "ResultSegment", "(", "result", ",", "entries", ".", "getNextTableIndexToReadFrom", "(", ")", ")", ";", "}" ]

[ "Runs", "a", "query", "on", "a", "chunk", "of", "a", "single", "partition", ".", "The", "chunk", "is", "defined", "by", "the", "offset", "{", "@code", "tableIndex", "}", "and", "the", "soft", "limit", "{", "@code", "fetchSize", "}", "." ]

[ "public", "void", "paint", "(", "Graphics2D", "gfx", ",", "int", "x", ",", "int", "y", ")", "{", "_mirage", ".", "paint", "(", "gfx", ",", "x", ",", "y", ")", ";", "}" ]

[ "Render", "the", "tile", "image", "at", "the", "specified", "position", "in", "the", "given", "graphics", "context", "." ]

[ "public", "Observable", "<", "List", "<", "PartitionMetricInner", ">", ">", "listMetricsAsync", "(", "String", "resourceGroupName", ",", "String", "accountName", ",", "String", "databaseRid", ",", "String", "collectionRid", ",", "String", "filter", ")", "{", "return", "listMetricsWithServiceResponseAsync", "(", "resourceGroupName", ",", "accountName", ",", "databaseRid", ",", "collectionRid", ",", "filter", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "List", "<", "PartitionMetricInner", ">", ">", ",", "List", "<", "PartitionMetricInner", ">", ">", "(", ")", "{", "@", "Override", "public", "List", "<", "PartitionMetricInner", ">", "call", "(", "ServiceResponse", "<", "List", "<", "PartitionMetricInner", ">", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Retrieves", "the", "metrics", "determined", "by", "the", "given", "filter", "for", "the", "given", "collection", "split", "by", "partition", "." ]

[ "public", "void", "getLocalRotation", "(", "int", "boneindex", ",", "Quaternionf", "q", ")", "{", "Bone", "bone", "=", "mBones", "[", "boneindex", "]", ";", "if", "(", "(", "bone", ".", "Changed", "&", "(", "WORLD_POS", "|", "WORLD_ROT", ")", ")", "!=", "0", ")", "{", "calcLocal", "(", "bone", ",", "mSkeleton", ".", "getParentBoneIndex", "(", "boneindex", ")", ")", ";", "}", "bone", ".", "LocalMatrix", ".", "getUnnormalizedRotation", "(", "q", ")", ";", "q", ".", "normalize", "(", ")", ";", "}" ]

[ "Gets", "the", "local", "rotation", "for", "a", "bone", "given", "its", "index", ".", "@param", "boneindex", "zero", "based", "index", "of", "bone", "whose", "rotation", "is", "wanted", ".", "@return", "local", "rotation", "for", "the", "designated", "bone", "as", "a", "quaternion", "." ]

[ "public", "static", "WordTag", "stemStatic", "(", "String", "word", ",", "String", "tag", ")", "{", "initStaticLexer", "(", ")", ";", "return", "new", "WordTag", "(", "lemmatize", "(", "word", ",", "tag", ",", "staticLexer", ",", "staticLexer", ".", "option", "(", "1", ")", ")", ",", "tag", ")", ";", "}" ]

[ "Return", "a", "new", "WordTag", "which", "has", "the", "lemma", "as", "the", "value", "of", "word", "()", ".", "The", "default", "is", "to", "lowercase", "non", "-", "proper", "-", "nouns", "unless", "options", "have", "been", "set", "." ]

[ "public", "String", "stripAndTrim", "(", "String", "str", ")", "{", "MultivaluedMap", "<", "String", ",", "String", ">", "params", "=", "new", "MultivaluedHashMap", "<>", "(", ")", ";", "params", ".", "putSingle", "(", "\"string\"", ",", "str", ")", ";", "return", "getEntity", "(", "invokeGet", "(", "\"utils/nosymbols\"", ",", "params", ")", ",", "String", ".", "class", ")", ";", "}" ]

[ "Strips", "all", "symbols", "punctuation", "whitespace", "and", "control", "chars", "from", "a", "string", "." ]

[ "public", "void", "setFeature", "(", "String", "name", ",", "boolean", "value", ")", "throws", "SAXNotRecognizedException", ",", "SAXNotSupportedException", "{", "if", "(", "name", "==", "null", ")", "{", "throw", "new", "NullPointerException", "(", "\"name == null\"", ")", ";", "}", "throw", "new", "SAXNotRecognizedException", "(", "name", ")", ";", "}" ]

[ "Set", "the", "value", "of", "a", "feature", "flag", "." ]

[ "static", "void", "setHttpOnlyReflect", "(", "net", ".", "javapla", ".", "jawn", ".", "core", ".", "http", ".", "Cookie", "awCookie", ",", "javax", ".", "servlet", ".", "http", ".", "Cookie", "servletCookie", ")", "{", "try", "{", "servletCookie", ".", "getClass", "(", ")", ".", "getMethod", "(", "\"setHttpOnly\"", ",", "boolean", ".", "class", ")", ".", "invoke", "(", "servletCookie", ",", "awCookie", ".", "isHttpOnly", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "// Cookie.logger.warn(\"You are trying to set HttpOnly on a cookie, but it appears you are running on Servlet version before 3.0.\");", "}", "}" ]

[ "Need", "to", "call", "this", "by", "reflection", "for", "backwards", "compatibility", "with", "Servlet", "2", ".", "5" ]

[ "public", "static", "AxisAlignedBB", "[", "]", "getCollisionBoundingBoxes", "(", "World", "world", ",", "Block", "block", ",", "BlockPos", "pos", ")", "{", "return", "getCollisionBoundingBoxes", "(", "world", ",", "new", "MBlockState", "(", "pos", ",", "block", ")", ",", "false", ")", ";", "}" ]

[ "Gets", "the", "collision", "{", "@link", "AxisAlignedBB", "}", "for", "the", "{", "@link", "Block", "}", "as", "the", "{", "@link", "BlockPos", "}", "coordinates", "." ]

[ "public", "static", "void", "addDeepLogger", "(", "Object", "object", ",", "Level", "level", ")", "{", "addDeepLogger", "(", "object", ",", "m", "->", "logger", ".", "log", "(", "level", ",", "m", ")", ")", ";", "}" ]

[ "Attaches", "a", "deep", "property", "change", "listener", "to", "the", "given", "object", "that", "generates", "logging", "information", "about", "the", "property", "change", "events", "and", "prints", "them", "as", "log", "messages", "." ]

[ "public", "Observable", "<", "RunInner", ">", "scheduleRunAsync", "(", "String", "resourceGroupName", ",", "String", "registryName", ",", "RunRequest", "runRequest", ")", "{", "return", "scheduleRunWithServiceResponseAsync", "(", "resourceGroupName", ",", "registryName", ",", "runRequest", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "RunInner", ">", ",", "RunInner", ">", "(", ")", "{", "@", "Override", "public", "RunInner", "call", "(", "ServiceResponse", "<", "RunInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Schedules", "a", "new", "run", "based", "on", "the", "request", "parameters", "and", "add", "it", "to", "the", "run", "queue", "." ]

[ "public", "Observable", "<", "LiveEventInner", ">", "createAsync", "(", "String", "resourceGroupName", ",", "String", "accountName", ",", "String", "liveEventName", ",", "LiveEventInner", "parameters", ",", "Boolean", "autoStart", ")", "{", "return", "createWithServiceResponseAsync", "(", "resourceGroupName", ",", "accountName", ",", "liveEventName", ",", "parameters", ",", "autoStart", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "LiveEventInner", ">", ",", "LiveEventInner", ">", "(", ")", "{", "@", "Override", "public", "LiveEventInner", "call", "(", "ServiceResponse", "<", "LiveEventInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Create", "Live", "Event", ".", "Creates", "a", "Live", "Event", "." ]

[ "public", "Set", "<", "BugPattern", ">", "getReportedBugPatterns", "(", ")", "{", "Set", "<", "BugPattern", ">", "result", "=", "new", "TreeSet", "<>", "(", ")", ";", "StringTokenizer", "tok", "=", "new", "StringTokenizer", "(", "reports", ",", "\",\"", ")", ";", "while", "(", "tok", ".", "hasMoreTokens", "(", ")", ")", "{", "String", "type", "=", "tok", ".", "nextToken", "(", ")", ";", "BugPattern", "bugPattern", "=", "DetectorFactoryCollection", ".", "instance", "(", ")", ".", "lookupBugPattern", "(", "type", ")", ";", "if", "(", "bugPattern", "!=", "null", ")", "{", "result", ".", "add", "(", "bugPattern", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Get", "set", "of", "all", "BugPatterns", "this", "detector", "reports", ".", "An", "empty", "set", "means", "that", "we", "don", "t", "know", "what", "kind", "of", "bug", "patterns", "might", "be", "reported", "." ]

[ "private", "void", "reportSyntaxError", "(", "JCDiagnostic", ".", "DiagnosticPosition", "diagPos", ",", "String", "key", ",", "Object", "...", "args", ")", "{", "int", "pos", "=", "diagPos", ".", "getPreferredPosition", "(", ")", ";", "if", "(", "pos", ">", "S", ".", "errPos", "(", ")", "||", "pos", "==", "Position", ".", "NOPOS", ")", "{", "if", "(", "token", ".", "kind", "==", "EOF", ")", "{", "error", "(", "diagPos", ",", "\"premature.eof\"", ")", ";", "}", "else", "{", "error", "(", "diagPos", ",", "key", ",", "args", ")", ";", "}", "}", "S", ".", "errPos", "(", "pos", ")", ";", "if", "(", "token", ".", "pos", "==", "errorPos", ")", "nextToken", "(", ")", ";", "// guarantee progress", "errorPos", "=", "token", ".", "pos", ";", "}" ]

[ "Report", "a", "syntax", "error", "using", "the", "given", "DiagnosticPosition", "object", "and", "arguments", "unless", "one", "was", "already", "reported", "at", "the", "same", "position", "." ]

[ "private", "TrieNode", "buildTrie", "(", "BinaryComparable", "[", "]", "splits", ",", "int", "lower", ",", "int", "upper", ",", "byte", "[", "]", "prefix", ",", "int", "maxDepth", ")", "{", "final", "int", "depth", "=", "prefix", ".", "length", ";", "if", "(", "depth", ">=", "maxDepth", "||", "lower", "==", "upper", ")", "{", "return", "new", "LeafTrieNode", "(", "depth", ",", "splits", ",", "lower", ",", "upper", ")", ";", "}", "InnerTrieNode", "result", "=", "new", "InnerTrieNode", "(", "depth", ")", ";", "byte", "[", "]", "trial", "=", "Arrays", ".", "copyOf", "(", "prefix", ",", "prefix", ".", "length", "+", "1", ")", ";", "// append an extra byte on to the prefix", "int", "currentBound", "=", "lower", ";", "for", "(", "int", "ch", "=", "0", ";", "ch", "<", "255", ";", "++", "ch", ")", "{", "trial", "[", "depth", "]", "=", "(", "byte", ")", "(", "ch", "+", "1", ")", ";", "lower", "=", "currentBound", ";", "while", "(", "currentBound", "<", "upper", ")", "{", "if", "(", "splits", "[", "currentBound", "]", ".", "compareTo", "(", "trial", ",", "0", ",", "trial", ".", "length", ")", ">=", "0", ")", "{", "break", ";", "}", "currentBound", "+=", "1", ";", "}", "trial", "[", "depth", "]", "=", "(", "byte", ")", "ch", ";", "result", ".", "child", "[", "0xFF", "&", "ch", "]", "=", "buildTrie", "(", "splits", ",", "lower", ",", "currentBound", ",", "trial", ",", "maxDepth", ")", ";", "}", "// pick up the rest", "trial", "[", "depth", "]", "=", "127", ";", "result", ".", "child", "[", "255", "]", "=", "buildTrie", "(", "splits", ",", "currentBound", ",", "upper", ",", "trial", ",", "maxDepth", ")", ";", "return", "result", ";", "}" ]

[ "Given", "a", "sorted", "set", "of", "cut", "points", "build", "a", "trie", "that", "will", "find", "the", "correct", "partition", "quickly", "." ]

[ "@", "Override", "public", "List", "<", "CommerceNotificationAttachment", ">", "findAll", "(", "int", "start", ",", "int", "end", ")", "{", "return", "findAll", "(", "start", ",", "end", ",", "null", ")", ";", "}" ]

[ "Returns", "a", "range", "of", "all", "the", "commerce", "notification", "attachments", "." ]

[ "@", "Override", "public", "List", "<", "CPDefinition", ">", "findByGroupId", "(", "long", "groupId", ",", "int", "start", ",", "int", "end", ")", "{", "return", "findByGroupId", "(", "groupId", ",", "start", ",", "end", ",", "null", ")", ";", "}" ]

[ "Returns", "a", "range", "of", "all", "the", "cp", "definitions", "where", "groupId", "=", "&#63", ";", "." ]

[ "public", "static", "TemplatePathInfo", "forPage", "(", "@", "NotNull", "Page", "page", ",", "@", "NotNull", "TemplatePathInfo", "@", "NotNull", ".", ".", ".", "templates", ")", "{", "if", "(", "page", "==", "null", "||", "templates", "==", "null", ")", "{", "return", "null", ";", "}", "String", "templatePath", "=", "page", ".", "getProperties", "(", ")", ".", "get", "(", "NameConstants", ".", "PN_TEMPLATE", ",", "String", ".", "class", ")", ";", "return", "forTemplatePath", "(", "templatePath", ",", "templates", ")", ";", "}" ]

[ "Lookup", "template", "for", "given", "page", "." ]

[ "public", "JBBPOut", "Short", "(", "final", "String", "str", ",", "final", "JBBPBitOrder", "bitOrder", ")", "throws", "IOException", "{", "assertNotEnded", "(", ")", ";", "if", "(", "this", ".", "processCommands", ")", "{", "final", "boolean", "msb0", "=", "bitOrder", "==", "JBBPBitOrder", ".", "MSB0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "str", ".", "length", "(", ")", ";", "i", "++", ")", "{", "short", "value", "=", "(", "short", ")", "str", ".", "charAt", "(", "i", ")", ";", "if", "(", "msb0", ")", "{", "value", "=", "(", "short", ")", "JBBPFieldShort", ".", "reverseBits", "(", "value", ")", ";", "}", "_writeShort", "(", "value", ")", ";", "}", "}", "return", "this", ";", "}" ]

[ "Write", "codes", "of", "chars", "as", "16", "bit", "values", "into", "the", "stream", "." ]

[ "public", "final", "hqlParser", ".", "inList_return", "inList", "(", ")", "throws", "RecognitionException", "{", "hqlParser", ".", "inList_return", "retval", "=", "new", "hqlParser", ".", "inList_return", "(", ")", ";", "retval", ".", "start", "=", "input", ".", "LT", "(", "1", ")", ";", "CommonTree", "root_0", "=", "null", ";", "ParserRuleReturnScope", "compoundExpr180", "=", "null", ";", "RewriteRuleSubtreeStream", "stream_compoundExpr", "=", "new", "RewriteRuleSubtreeStream", "(", "adaptor", ",", "\"rule compoundExpr\"", ")", ";", "try", "{", "// hql.g:487:2: ( compoundExpr -> ^( IN_LIST[\\\"inList\\\"] compoundExpr ) )", "// hql.g:487:4: compoundExpr", "{", "pushFollow", "(", "FOLLOW_compoundExpr_in_inList2244", ")", ";", "compoundExpr180", "=", "compoundExpr", "(", ")", ";", "state", ".", "_fsp", "--", ";", "stream_compoundExpr", ".", "add", "(", "compoundExpr180", ".", "getTree", "(", ")", ")", ";", "// AST REWRITE", "// elements: compoundExpr", "// token labels:", "// rule labels: retval", "// token list labels:", "// rule list labels:", "// wildcard labels:", "retval", ".", "tree", "=", "root_0", ";", "RewriteRuleSubtreeStream", "stream_retval", "=", "new", "RewriteRuleSubtreeStream", "(", "adaptor", ",", "\"rule retval\"", ",", "retval", "!=", "null", "?", "retval", ".", "getTree", "(", ")", ":", "null", ")", ";", "root_0", "=", "(", "CommonTree", ")", "adaptor", ".", "nil", "(", ")", ";", "// 488:2: -> ^( IN_LIST[\\\"inList\\\"] compoundExpr )", "{", "// hql.g:488:5: ^( IN_LIST[\\\"inList\\\"] compoundExpr )", "{", "CommonTree", "root_1", "=", "(", "CommonTree", ")", "adaptor", ".", "nil", "(", ")", ";", "root_1", "=", "(", "CommonTree", ")", "adaptor", ".", "becomeRoot", "(", "adaptor", ".", "create", "(", "IN_LIST", ",", "\"inList\"", ")", ",", "root_1", ")", ";", "adaptor", ".", "addChild", "(", "root_1", ",", "stream_compoundExpr", ".", "nextTree", "(", ")", ")", ";", "adaptor", ".", "addChild", "(", "root_0", ",", "root_1", ")", ";", "}", "}", "retval", ".", "tree", "=", "root_0", ";", "}", "retval", ".", "stop", "=", "input", ".", "LT", "(", "-", "1", ")", ";", "retval", ".", "tree", "=", "(", "CommonTree", ")", "adaptor", ".", "rulePostProcessing", "(", "root_0", ")", ";", "adaptor", ".", "setTokenBoundaries", "(", "retval", ".", "tree", ",", "retval", ".", "start", ",", "retval", ".", "stop", ")", ";", "}", "catch", "(", "RecognitionException", "re", ")", "{", "reportError", "(", "re", ")", ";", "recover", "(", "input", ",", "re", ")", ";", "retval", ".", "tree", "=", "(", "CommonTree", ")", "adaptor", ".", "errorNode", "(", "input", ",", "retval", ".", "start", ",", "input", ".", "LT", "(", "-", "1", ")", ",", "re", ")", ";", "}", "finally", "{", "// do for sure before leaving", "}", "return", "retval", ";", "}" ]

[ "hql", ".", "g", ":", "486", ":", "1", ":", "inList", ":", "compoundExpr", "-", ">", "^", "(", "IN_LIST", "[", "\\", "inList", "\\", "]", "compoundExpr", ")", ";" ]

[ "public", "static", "String", "ensureRight", "(", "final", "String", "value", ",", "final", "String", "suffix", ",", "boolean", "caseSensitive", ")", "{", "validate", "(", "value", ",", "NULL_STRING_PREDICATE", ",", "NULL_STRING_MSG_SUPPLIER", ")", ";", "return", "endsWith", "(", "value", ",", "suffix", ",", "caseSensitive", ")", "?", "value", ":", "append", "(", "value", ",", "suffix", ")", ";", "}" ]

[ "Ensures", "that", "the", "value", "ends", "with", "suffix", ".", "If", "it", "doesn", "t", "it", "s", "appended", "." ]

[ "public", "VALUETO", "encodeFromRaw", "(", "Object", "o", ",", "Optional", "<", "CassandraOptions", ">", "cassandraOptions", ")", "{", "if", "(", "o", "==", "null", ")", "return", "null", ";", "return", "encodeFromRawInternal", "(", "o", ",", "cassandraOptions", ")", ";", "}" ]

[ "Encode", "given", "java", "raw", "object", "to", "CQL", "-", "compatible", "value", "using", "Achilles", "codec", "system", "and", "a", "CassandraOptions", "containing", "a", "runtime", "SchemaNameProvider", ".", "Use", "the", "<br", "/", ">", "<br", "/", ">", "<pre", "class", "=", "code", ">", "<code", "class", "=", "java", ">", "CassandraOptions", ".", "withSchemaNameProvider", "(", "SchemaNameProvider", "provider", ")", "<", "/", "code", ">", "<", "/", "pre", ">", "<br", "/", ">", "static", "method", "to", "build", "such", "a", "CassandraOptions", "instance" ]

[ "protected", "boolean", "matchBodyPattern", "(", "HttpMessage", "msg", ",", "Pattern", "pattern", ",", "StringBuilder", "sb", ")", "{", "// ZAP: Changed the type of the parameter \"sb\" to StringBuilder.\r", "Matcher", "matcher", "=", "pattern", ".", "matcher", "(", "msg", ".", "getResponseBody", "(", ")", ".", "toString", "(", ")", ")", ";", "boolean", "result", "=", "matcher", ".", "find", "(", ")", ";", "if", "(", "result", ")", "{", "if", "(", "sb", "!=", "null", ")", "{", "sb", ".", "append", "(", "matcher", ".", "group", "(", ")", ")", ";", "}", "}", "return", "result", ";", "}" ]

[ "Check", "if", "the", "given", "pattern", "can", "be", "found", "in", "the", "msg", "body", ".", "If", "the", "supplied", "StringBuilder", "is", "not", "null", "append", "the", "result", "to", "the", "StringBuilder", "." ]

[ "public", "static", "URI", "uriFromPath", "(", "String", "path", ")", "throws", "IllegalArgumentException", "{", "try", "{", "return", "new", "URI", "(", "null", ",", "null", ",", "path", ",", "null", ")", ";", "}", "catch", "(", "URISyntaxException", "e", ")", "{", "throw", "new", "IllegalArgumentException", "(", "e", ")", ";", "}", "}" ]

[ "Create", "a", "{", "@link", "URI", "}", "from", "a", "path", ".", "This", "is", "similar", "to", "calling", "new", "URI", "(", "null", "null", "path", "null", ")", "with", "the", "{", "@link", "URISyntaxException", "}", "converted", "to", "a", "{", "@link", "IllegalArgumentException", "}", "." ]

[ "private", "void", "updateAuthorizationList", "(", "final", "ChargingStation", "chargingStation", ",", "final", "Set", "<", "LocalAuthorization", ">", "updatedLocalAuthorizations", ")", "{", "Set", "<", "LocalAuthorization", ">", "authorizationList", "=", "chargingStation", ".", "getLocalAuths", "(", ")", ";", "Iterables", ".", "removeIf", "(", "authorizationList", ",", "new", "Predicate", "<", "LocalAuthorization", ">", "(", ")", "{", "@", "Override", "public", "boolean", "apply", "(", "@", "Nullable", "LocalAuthorization", "identifyingToken", ")", "{", "return", "updatedLocalAuthorizations", "!=", "null", "&&", "updatedLocalAuthorizations", ".", "contains", "(", "identifyingToken", ")", ";", "}", "}", ")", ";", "authorizationList", ".", "addAll", "(", "updatedLocalAuthorizations", ")", ";", "}" ]

[ "Updates", "the", "local", "representation", "of", "the", "charging", "station", "authorization", "list", ".", "Tokens", "in", "the", "updatedIdentificationTokens", "will", "be", "removed", "from", "the", "local", "operator", "api", "list", "." ]

[ "private", "void", "initializeConnection", "(", "String", "user", ",", "String", "password", ",", "String", "restApiBaseUrl", ",", "String", "proxyHost", ",", "Integer", "proxyPort", ",", "Proxy", ".", "Type", "proxyType", ",", "String", "proxyUser", ",", "String", "proxyPassword", ")", "{", "connection", "=", "ClientHelper", ".", "createClient", "(", "proxyHost", ",", "proxyPort", ",", "proxyType", ",", "proxyUser", ",", "proxyPassword", ")", ".", "register", "(", "HttpAuthenticationFeature", ".", "basic", "(", "user", ",", "password", ")", ")", ".", "target", "(", "restApiBaseUrl", ")", ";", "}" ]

[ "Initializes", "the", "connection", "." ]

[ "private", "String", "readNamespaceAttr", "(", "Document", "doc", ")", "{", "// lazy loading is mostly pointless but it keeps things together", "if", "(", "namespaceExpr", "==", "null", ")", "{", "namespaceExpr", "=", "initNamespaceAttrExpression", "(", ")", ";", "}", "String", "s", ";", "try", "{", "s", "=", "namespaceExpr", ".", "evaluate", "(", "doc", ")", ";", "}", "catch", "(", "XPathExpressionException", "e", ")", "{", "throw", "new", "PluginException", "(", "\"Error evaluating namespace XPath expression: \"", "+", "e", ",", "e", ")", ";", "}", "// xpath returns an empty string if not found, null is cleaner for callers", "return", "(", "s", "==", "null", "||", "s", ".", "length", "(", ")", "==", "0", ")", "?", "null", ":", "s", ";", "}" ]

[ "Retrieve", "namespace", "attr", "of", "interface", "definition", "or", "null", "if", "not", "found" ]