Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "private", "static", "boolean", "areSame", "(", "Credentials", "c1", ",", "Credentials", "c2", ")", "{", "if", "(", "c1", "==", "null", ")", "{", "return", "c2", "==", "null", ";", "}", "else", "{", "return", "StringUtils", ".", "equals", "(", "c1", ".", "getUserPrincipal", "(", ")", ".", "getName", "(", ")", ",", "c1", ".", "getUserPrincipal", "(", ")", ".", "getName", "(", ")", ")", "&&", "StringUtils", ".", "equals", "(", "c1", ".", "getPassword", "(", ")", ",", "c1", ".", "getPassword", "(", ")", ")", ";", "}", "}" ]

[ "Compare", "two", "instances", "of", "Credentials", "." ]

[ "public", "List", "<", "DeepTokenRange", ">", "getRanges", "(", ")", "{", "try", "{", "List", "<", "TokenRange", ">", "tokenRanges", ";", "ThriftClient", "client", "=", "ThriftClient", ".", "build", "(", "host", ",", "rpcPort", ")", ";", "try", "{", "tokenRanges", "=", "client", ".", "describe_local_ring", "(", "keyspace", ")", ";", "}", "catch", "(", "TApplicationException", "e", ")", "{", "if", "(", "e", ".", "getType", "(", ")", "==", "TApplicationException", ".", "UNKNOWN_METHOD", ")", "{", "tokenRanges", "=", "client", ".", "describe_ring", "(", "keyspace", ")", ";", "}", "else", "{", "throw", "new", "DeepGenericException", "(", "\"Unknown server error\"", ",", "e", ")", ";", "}", "}", "client", ".", "close", "(", ")", ";", "List", "<", "DeepTokenRange", ">", "deepTokenRanges", "=", "new", "ArrayList", "<>", "(", "tokenRanges", ".", "size", "(", ")", ")", ";", "for", "(", "TokenRange", "tokenRange", ":", "tokenRanges", ")", "{", "Comparable", "start", "=", "tokenAsComparable", "(", "tokenRange", ".", "getStart_token", "(", ")", ")", ";", "Comparable", "end", "=", "tokenAsComparable", "(", "tokenRange", ".", "getEnd_token", "(", ")", ")", ";", "deepTokenRanges", ".", "add", "(", "new", "DeepTokenRange", "(", "start", ",", "end", ",", "tokenRange", ".", "getEndpoints", "(", ")", ")", ")", ";", "}", "return", "deepTokenRanges", ";", "}", "catch", "(", "TException", "e", ")", "{", "throw", "new", "DeepGenericException", "(", "\"No available replicas for get ring token ranges\"", ",", "e", ")", ";", "}", "}" ]

[ "Returns", "the", "token", "ranges", "of", "the", "Cassandra", "ring", "that", "will", "be", "mapped", "to", "Spark", "partitions", ".", "The", "returned", "ranges", "are", "the", "Cassandra", "s", "physical", "ones", "without", "any", "splitting", "." ]

[ "public", "Integer", "getIntegerProperty", "(", "String", "pstrSection", ",", "String", "pstrProp", ")", "{", "Integer", "intRet", "=", "null", ";", "String", "strVal", "=", "null", ";", "INIProperty", "objProp", "=", "null", ";", "INISection", "objSec", "=", "null", ";", "objSec", "=", "(", "INISection", ")", "this", ".", "mhmapSections", ".", "get", "(", "pstrSection", ")", ";", "if", "(", "objSec", "!=", "null", ")", "{", "objProp", "=", "objSec", ".", "getProperty", "(", "pstrProp", ")", ";", "try", "{", "if", "(", "objProp", "!=", "null", ")", "{", "strVal", "=", "objProp", ".", "getPropValue", "(", ")", ";", "if", "(", "strVal", "!=", "null", ")", "intRet", "=", "new", "Integer", "(", "strVal", ")", ";", "}", "}", "catch", "(", "NumberFormatException", "NFExIgnore", ")", "{", "}", "finally", "{", "if", "(", "objProp", "!=", "null", ")", "objProp", "=", "null", ";", "}", "objSec", "=", "null", ";", "}", "return", "intRet", ";", "}" ]

[ "Returns", "the", "specified", "integer", "property", "from", "the", "specified", "section", "." ]

[ "public", "double", "acuteAngle", "(", "SquareNode", "a", ",", "int", "sideA", ",", "SquareNode", "b", ",", "int", "sideB", ")", "{", "Point2D_F64", "a0", "=", "a", ".", "square", ".", "get", "(", "sideA", ")", ";", "Point2D_F64", "a1", "=", "a", ".", "square", ".", "get", "(", "add", "(", "sideA", ",", "1", ")", ")", ";", "Point2D_F64", "b0", "=", "b", ".", "square", ".", "get", "(", "sideB", ")", ";", "Point2D_F64", "b1", "=", "b", ".", "square", ".", "get", "(", "add", "(", "sideB", ",", "1", ")", ")", ";", "vector0", ".", "set", "(", "a1", ".", "x", "-", "a0", ".", "x", ",", "a1", ".", "y", "-", "a0", ".", "y", ")", ";", "vector1", ".", "set", "(", "b1", ".", "x", "-", "b0", ".", "x", ",", "b1", ".", "y", "-", "b0", ".", "y", ")", ";", "double", "acute", "=", "vector0", ".", "acute", "(", "vector1", ")", ";", "return", "Math", ".", "min", "(", "UtilAngle", ".", "dist", "(", "Math", ".", "PI", ",", "acute", ")", ",", "acute", ")", ";", "}" ]

[ "Returns", "an", "angle", "between", "0", "and", "PI", "/", "4", "which", "describes", "the", "difference", "in", "slope", "between", "the", "two", "sides" ]

[ "public", "ToStringOption", "setAppendTransient", "(", "boolean", "appendTransient", ")", "{", "ToStringOption", "op", "=", "this", ";", "if", "(", "this", "==", "DEFAULT_OPTION", ")", "{", "op", "=", "new", "ToStringOption", "(", "this", ".", "appendStatic", ",", "this", ".", "appendTransient", ")", ";", "}", "op", ".", "appendTransient", "=", "appendTransient", ";", "return", "op", ";", "}" ]

[ "Return", "a", "<code", ">", "ToStringOption<", "/", "code", ">", "instance", "with", "{", "@link", "#appendTransient", "}", "option", "set", ".", "if", "the", "current", "instance", "is", "not", "{", "@link", "#DEFAULT_OPTION", "default", "instance", "}", "then", "set", "on", "the", "current", "instance", "and", "return", "the", "current", "instance", ".", "Otherwise", "clone", "the", "default", "instance", "and", "set", "on", "the", "clone", "and", "return", "the", "clone" ]

[ "public", "static", "void", "minus", "(", "Complex_F64", "a", ",", "Complex_F64", "b", ",", "Complex_F64", "result", ")", "{", "result", ".", "real", "=", "a", ".", "real", "-", "b", ".", "real", ";", "result", ".", "imaginary", "=", "a", ".", "imaginary", "-", "b", ".", "imaginary", ";", "}" ]

[ "<p", ">", "Subtraction", ":", "result", "=", "a", "-", "b", "<", "/", "p", ">" ]

[ "public", "void", "dragAndDrop", "(", "WebElement", "source", ",", "WebElement", "target", ")", "{", "getActions", "(", ")", ".", "dragAndDrop", "(", "source", ",", "target", ")", ".", "perform", "(", ")", ";", "}" ]

[ "Simulates", "a", "drag", "from", "source", "element", "and", "drop", "to", "target", "element" ]

[ "public", "static", "double", "computeHouseholder", "(", "double", "[", "]", "x", ",", "int", "xStart", ",", "int", "xEnd", ",", "double", "max", ",", "DScalar", "gamma", ")", "{", "double", "tau", "=", "0", ";", "for", "(", "int", "i", "=", "xStart", ";", "i", "<", "xEnd", ";", "i", "++", ")", "{", "double", "val", "=", "x", "[", "i", "]", "/=", "max", ";", "tau", "+=", "val", "*", "val", ";", "}", "tau", "=", "Math", ".", "sqrt", "(", "tau", ")", ";", "if", "(", "x", "[", "xStart", "]", "<", "0", ")", "{", "tau", "=", "-", "tau", ";", "}", "double", "u_0", "=", "x", "[", "xStart", "]", "+", "tau", ";", "gamma", ".", "value", "=", "u_0", "/", "tau", ";", "x", "[", "xStart", "]", "=", "1", ";", "for", "(", "int", "i", "=", "xStart", "+", "1", ";", "i", "<", "xEnd", ";", "i", "++", ")", "{", "x", "[", "i", "]", "/=", "u_0", ";", "}", "return", "-", "tau", "*", "max", ";", "}" ]

[ "Creates", "a", "householder", "reflection", "." ]

[ "private", "void", "readTag", "(", "RandomAccessInputStream", "raf", ")", "throws", "FileNotFoundException", ",", "IOException", "{", "raf", ".", "seek", "(", "raf", ".", "length", "(", ")", "-", "TAG_SIZE", ")", ";", "byte", "[", "]", "buf", "=", "new", "byte", "[", "TAG_SIZE", "]", ";", "raf", ".", "read", "(", "buf", ",", "0", ",", "TAG_SIZE", ")", ";", "String", "tag", "=", "new", "String", "(", "buf", ",", "0", ",", "TAG_SIZE", ",", "ENC_TYPE", ")", ";", "int", "start", "=", "TAG_START", ".", "length", "(", ")", ";", "title", "=", "tag", ".", "substring", "(", "start", ",", "start", "+=", "TITLE_SIZE", ")", ";", "artist", "=", "tag", ".", "substring", "(", "start", ",", "start", "+=", "ARTIST_SIZE", ")", ";", "album", "=", "tag", ".", "substring", "(", "start", ",", "start", "+=", "ALBUM_SIZE", ")", ";", "year", "=", "tag", ".", "substring", "(", "start", ",", "start", "+=", "YEAR_SIZE", ")", ";", "comment", "=", "tag", ".", "substring", "(", "start", ",", "start", "+=", "COMMENT_SIZE", ")", ";", "track", "=", "(", "int", ")", "tag", ".", "charAt", "(", "TRACK_LOCATION", ")", ";", "genre", "=", "(", "int", ")", "tag", ".", "charAt", "(", "GENRE_LOCATION", ")", ";", "}" ]

[ "Reads", "the", "data", "from", "the", "id3v1", "tag" ]

[ "@", "Override", "public", "StorageObjectSummaryCollection", "listObjects", "(", "String", "remoteStorageLocation", ",", "String", "prefix", ")", "throws", "StorageProviderException", "{", "StorageObjectSummaryCollection", "storageObjectSummaries", ";", "try", "{", "CloudBlobContainer", "container", "=", "azStorageClient", ".", "getContainerReference", "(", "remoteStorageLocation", ")", ";", "Iterable", "<", "ListBlobItem", ">", "listBlobItemIterable", "=", "container", ".", "listBlobs", "(", "prefix", ",", "// List the BLOBs under this prefix", "true", "// List the BLOBs as a flat list, i.e. do not list directories", ")", ";", "storageObjectSummaries", "=", "new", "StorageObjectSummaryCollection", "(", "listBlobItemIterable", ")", ";", "}", "catch", "(", "URISyntaxException", "|", "StorageException", "ex", ")", "{", "logger", ".", "debug", "(", "\"Failed to list objects: {}\"", ",", "ex", ")", ";", "throw", "new", "StorageProviderException", "(", "ex", ")", ";", "}", "return", "storageObjectSummaries", ";", "}" ]

[ "For", "a", "set", "of", "remote", "storage", "objects", "under", "a", "remote", "location", "and", "a", "given", "prefix", "/", "path", "returns", "their", "properties", "wrapped", "in", "ObjectSummary", "objects" ]

[ "public", "static", "BoxFile", "createFromIdAndName", "(", "String", "fileId", ",", "String", "name", ")", "{", "JsonObject", "object", "=", "new", "JsonObject", "(", ")", ";", "object", ".", "add", "(", "BoxItem", ".", "FIELD_ID", ",", "fileId", ")", ";", "object", ".", "add", "(", "BoxItem", ".", "FIELD_TYPE", ",", "BoxFile", ".", "TYPE", ")", ";", "if", "(", "!", "TextUtils", ".", "isEmpty", "(", "name", ")", ")", "{", "object", ".", "add", "(", "BoxItem", ".", "FIELD_NAME", ",", "name", ")", ";", "}", "return", "new", "BoxFile", "(", "object", ")", ";", "}" ]

[ "A", "convenience", "method", "to", "create", "an", "empty", "file", "with", "just", "the", "id", "and", "type", "fields", "set", ".", "This", "allows", "the", "ability", "to", "interact", "with", "the", "content", "sdk", "in", "a", "more", "descriptive", "and", "type", "safe", "manner" ]

[ "public", "static", "String", "getQualifiedTableName", "(", "String", "scope", ",", "String", "...", "tokens", ")", "{", "Preconditions", ".", "checkArgument", "(", "tokens", "!=", "null", "&&", "tokens", ".", "length", ">", "0", ")", ";", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "sb", ".", "append", "(", "String", ".", "format", "(", "\"%s/%s\"", ",", "scope", ",", "TABLES", ")", ")", ";", "for", "(", "String", "token", ":", "tokens", ")", "{", "sb", ".", "append", "(", "'", "'", ")", ";", "sb", ".", "append", "(", "token", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Method", "to", "generate", "Fully", "Qualified", "table", "name", "using", "scope", "and", "other", "tokens", "to", "be", "used", "to", "compose", "the", "table", "name", ".", "The", "composed", "name", "has", "following", "format", "\\", "<scope", "\\", ">", "/", "_tables", "/", "\\", "<tokens", "[", "0", "]", "\\", ">", "/", "\\", "<tokens", "[", "1", "]", "\\", ">", "..." ]

[ "public", "String", "decorateTagAction", "(", "String", "content", ",", "String", "configFile", ",", "String", "locale", ",", "ServletRequest", "req", ")", "{", "try", "{", "Locale", "loc", "=", "null", ";", "CmsFlexController", "controller", "=", "CmsFlexController", ".", "getController", "(", "req", ")", ";", "if", "(", "CmsStringUtil", ".", "isEmpty", "(", "locale", ")", ")", "{", "loc", "=", "controller", ".", "getCmsObject", "(", ")", ".", "getRequestContext", "(", ")", ".", "getLocale", "(", ")", ";", "}", "else", "{", "loc", "=", "CmsLocaleManager", ".", "getLocale", "(", "locale", ")", ";", "}", "// read the decorator configurator class", "CmsProperty", "decoratorClass", "=", "controller", ".", "getCmsObject", "(", ")", ".", "readPropertyObject", "(", "configFile", ",", "PROPERTY_CATEGORY", ",", "false", ")", ";", "String", "decoratorClassName", "=", "decoratorClass", ".", "getValue", "(", ")", ";", "if", "(", "CmsStringUtil", ".", "isEmpty", "(", "decoratorClassName", ")", ")", "{", "decoratorClassName", "=", "DEFAULT_DECORATOR_CONFIGURATION", ";", "}", "String", "encoding", "=", "controller", ".", "getCmsObject", "(", ")", ".", "getRequestContext", "(", ")", ".", "getEncoding", "(", ")", ";", "// use the correct decorator configurator and initialize it", "I_CmsDecoratorConfiguration", "config", "=", "(", "I_CmsDecoratorConfiguration", ")", "Class", ".", "forName", "(", "decoratorClassName", ")", ".", "newInstance", "(", ")", ";", "config", ".", "init", "(", "controller", ".", "getCmsObject", "(", ")", ",", "configFile", ",", "loc", ")", ";", "CmsHtmlDecorator", "decorator", "=", "new", "CmsHtmlDecorator", "(", "controller", ".", "getCmsObject", "(", ")", ",", "config", ")", ";", "decorator", ".", "setNoAutoCloseTags", "(", "m_noAutoCloseTags", ")", ";", "return", "decorator", ".", "doDecoration", "(", "content", ",", "encoding", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "if", "(", "LOG", ".", "isErrorEnabled", "(", ")", ")", "{", "LOG", ".", "error", "(", "Messages", ".", "get", "(", ")", ".", "getBundle", "(", ")", ".", "key", "(", "Messages", ".", "ERR_PROCESS_TAG_1", ",", "\"decoration\"", ")", ",", "e", ")", ";", "}", "return", "content", ";", "}", "}" ]

[ "Internal", "action", "method", ".", "<p", ">" ]

[ "public", "static", "long", "sliceOffsetForTensor", "(", "int", "index", ",", "INDArray", "arr", ",", "int", "[", "]", "tensorShape", ")", "{", "long", "tensorLength", "=", "ArrayUtil", ".", "prodLong", "(", "tensorShape", ")", ";", "long", "lengthPerSlice", "=", "NDArrayMath", ".", "lengthPerSlice", "(", "arr", ")", ";", "long", "offset", "=", "index", "*", "tensorLength", "/", "lengthPerSlice", ";", "return", "offset", ";", "}" ]

[ "calculates", "the", "offset", "for", "a", "tensor" ]

[ "public", "MultimapWithProtoValuesFluentAssertion", "<", "M", ">", "ignoringFieldAbsenceOfFieldsForValues", "(", "int", "firstFieldNumber", ",", "int", "...", "rest", ")", "{", "return", "usingConfig", "(", "config", ".", "ignoringFieldAbsenceOfFields", "(", "asList", "(", "firstFieldNumber", ",", "rest", ")", ")", ")", ";", "}" ]

[ "Specifies", "that", "the", "has", "bit", "of", "these", "explicitly", "specified", "top", "-", "level", "field", "numbers", "should", "be", "ignored", "when", "comparing", "for", "equality", ".", "Sub", "-", "fields", "must", "be", "specified", "explicitly", "(", "via", "{", "@link", "FieldDescriptor", "}", ")", "if", "they", "are", "to", "be", "ignored", "as", "well", "." ]

[ "public", "static", "int", "lastIndexOf", "(", "ByteBuffer", "buffer", ",", "byte", "valueToFind", ",", "int", "startIndex", ")", "{", "assert", "buffer", "!=", "null", ";", "if", "(", "startIndex", "<", "buffer", ".", "position", "(", ")", ")", "{", "return", "-", "1", ";", "}", "else", "if", "(", "startIndex", ">=", "buffer", ".", "limit", "(", ")", ")", "{", "startIndex", "=", "buffer", ".", "limit", "(", ")", "-", "1", ";", "}", "for", "(", "int", "i", "=", "startIndex", ";", "i", ">=", "buffer", ".", "position", "(", ")", ";", "i", "--", ")", "{", "if", "(", "valueToFind", "==", "buffer", ".", "get", "(", "i", ")", ")", "return", "i", ";", "}", "return", "-", "1", ";", "}" ]

[ "ByteBuffer", "adaptation", "of", "org", ".", "apache", ".", "commons", ".", "lang", ".", "ArrayUtils", ".", "lastIndexOf", "method" ]

[ "public", "final", "static", "void", "getXteaSignature", "(", "byte", "[", "]", "array", ",", "int", "offset", ",", "int", "keyid", ")", "{", "int", "num_rounds", "=", "32", ";", "int", "v0", ",", "v1", ",", "sum", "=", "0", ",", "delta", "=", "0x9E3779B9", ";", "int", "[", "]", "k", "=", "XTEA_KEYS", "[", "keyid", "]", ";", "v0", "=", "ByteBuffer", ".", "wrap", "(", "array", ",", "offset", ",", "4", ")", ".", "getInt", "(", ")", ";", "v1", "=", "ByteBuffer", ".", "wrap", "(", "array", ",", "offset", "+", "4", ",", "4", ")", ".", "getInt", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "num_rounds", ";", "i", "++", ")", "{", "v0", "+=", "(", "(", "(", "v1", "<<", "4", ")", "^", "(", "v1", ">>", "5", ")", ")", "+", "v1", ")", "^", "(", "sum", "+", "k", "[", "sum", "&", "3", "]", ")", ";", "sum", "+=", "delta", ";", "v1", "+=", "(", "(", "(", "v0", "<<", "4", ")", "^", "(", "v0", ">>", "5", ")", ")", "+", "v0", ")", "^", "(", "sum", "+", "k", "[", "(", "sum", ">>", "11", ")", "&", "3", "]", ")", ";", "}", "ByteBuffer", "tmp", "=", "ByteBuffer", ".", "allocate", "(", "4", ")", ";", "tmp", ".", "putInt", "(", "v0", ")", ";", "tmp", ".", "flip", "(", ")", ";", "System", ".", "arraycopy", "(", "tmp", ".", "array", "(", ")", ",", "0", ",", "array", ",", "offset", ",", "4", ")", ";", "tmp", ".", "clear", "(", ")", ";", "tmp", ".", "putInt", "(", "v1", ")", ";", "tmp", ".", "flip", "(", ")", ";", "System", ".", "arraycopy", "(", "tmp", ".", "array", "(", ")", ",", "0", ",", "array", ",", "offset", "+", "4", ",", "4", ")", ";", "}" ]

[ "RTMPE", "type", "8", "uses", "XTEA", "on", "the", "regular", "signature", "http", ":", "//", "en", ".", "wikipedia", ".", "org", "/", "wiki", "/", "XTEA" ]

[ "public", "static", "void", "removeAppNameSubContext", "(", "Context", "envCtx", ",", "String", "appName", ")", "{", "if", "(", "envCtx", "!=", "null", ")", "{", "try", "{", "javax", ".", "naming", ".", "Context", "sipContext", "=", "(", "javax", ".", "naming", ".", "Context", ")", "envCtx", ".", "lookup", "(", "SIP_SUBCONTEXT", ")", ";", "sipContext", ".", "destroySubcontext", "(", "appName", ")", ";", "}", "catch", "(", "NamingException", "e", ")", "{", "logger", ".", "error", "(", "sm", ".", "getString", "(", "\"naming.unbindFailed\"", ",", "e", ")", ")", ";", "}", "}", "}" ]

[ "Removes", "the", "app", "name", "subcontext", "from", "the", "jndi", "mapping" ]

[ "public", "static", "String", "[", "]", "getSelectColumns", "(", "String", "sql", ")", "{", "Asserts", ".", "notBlank", "(", "sql", ")", ";", "sql", "=", "sql", ".", "trim", "(", ")", ";", "if", "(", "sql", ".", "startsWith", "(", "\"select \"", ")", "||", "sql", ".", "startsWith", "(", "\"SELECT \"", ")", ")", "{", "sql", "=", "sql", ".", "substring", "(", "7", ")", ".", "trim", "(", ")", ";", "int", "idxFrom", "=", "sql", ".", "indexOf", "(", "\" from \"", ")", ";", "if", "(", "idxFrom", "==", "-", "1", ")", "idxFrom", "=", "sql", ".", "indexOf", "(", "\" FROM \"", ")", ";", "if", "(", "idxFrom", "==", "-", "1", ")", "throw", "new", "IllegalArgumentException", "(", "\"Bad sql, no from \"", ")", ";", "sql", "=", "sql", ".", "substring", "(", "0", ",", "idxFrom", ")", ".", "trim", "(", ")", ";", "String", "[", "]", "columns", "=", "sql", ".", "split", "(", "\",\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "columns", ".", "length", ";", "i", "++", ")", "{", "columns", "[", "i", "]", "=", "columns", "[", "i", "]", ".", "trim", "(", ")", ";", "}", "return", "columns", ";", "}", "else", "{", "throw", "new", "IllegalArgumentException", "(", "\"Not a select sql\"", ")", ";", "}", "}" ]

[ "Example", ":", "<br", ">", "<code", ">", "new", "String", "[]", "{", "id", "code", "name", "}", "equals", "SqlStrUtils", ".", "getSelectColumns", "(", "select", "id", "code", "name", "from", "user", ")", "<", "/", "code", ">" ]

[ "public", "static", "String", "toKml", "(", "Geometry", "geometry", ",", "boolean", "extrude", ",", "int", "altitudeModeEnum", ")", "throws", "SQLException", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "if", "(", "extrude", ")", "{", "KMLGeometry", ".", "toKMLGeometry", "(", "geometry", ",", "ExtrudeMode", ".", "TRUE", ",", "altitudeModeEnum", ",", "sb", ")", ";", "}", "else", "{", "KMLGeometry", ".", "toKMLGeometry", "(", "geometry", ",", "ExtrudeMode", ".", "FALSE", ",", "altitudeModeEnum", ",", "sb", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Generates", "a", "KML", "geometry", ".", "Specifies", "the", "extrude", "and", "altitudeMode", "." ]

[ "private", "static", "int", "parseTagString", "(", "String", "localeID", ",", "String", "tags", "[", "]", ")", "{", "LocaleIDParser", "parser", "=", "new", "LocaleIDParser", "(", "localeID", ")", ";", "String", "lang", "=", "parser", ".", "getLanguage", "(", ")", ";", "String", "script", "=", "parser", ".", "getScript", "(", ")", ";", "String", "region", "=", "parser", ".", "getCountry", "(", ")", ";", "if", "(", "isEmptyString", "(", "lang", ")", ")", "{", "tags", "[", "0", "]", "=", "UNDEFINED_LANGUAGE", ";", "}", "else", "{", "tags", "[", "0", "]", "=", "lang", ";", "}", "if", "(", "script", ".", "equals", "(", "UNDEFINED_SCRIPT", ")", ")", "{", "tags", "[", "1", "]", "=", "\"\"", ";", "}", "else", "{", "tags", "[", "1", "]", "=", "script", ";", "}", "if", "(", "region", ".", "equals", "(", "UNDEFINED_REGION", ")", ")", "{", "tags", "[", "2", "]", "=", "\"\"", ";", "}", "else", "{", "tags", "[", "2", "]", "=", "region", ";", "}", "/*\n * Search for the variant. If there is one, then return the index of\n * the preceeding separator.\n * If there's no variant, search for the keyword delimiter,\n * and return its index. Otherwise, return the length of the\n * string.\n *\n * $TOTO(dbertoni) we need to take into account that we might\n * find a part of the language as the variant, since it can\n * can have a variant portion that is long enough to contain\n * the same characters as the variant.\n */", "String", "variant", "=", "parser", ".", "getVariant", "(", ")", ";", "if", "(", "!", "isEmptyString", "(", "variant", ")", ")", "{", "int", "index", "=", "localeID", ".", "indexOf", "(", "variant", ")", ";", "return", "index", ">", "0", "?", "index", "-", "1", ":", "index", ";", "}", "else", "{", "int", "index", "=", "localeID", ".", "indexOf", "(", "'", "'", ")", ";", "return", "index", "==", "-", "1", "?", "localeID", ".", "length", "(", ")", ":", "index", ";", "}", "}" ]

[ "Parse", "the", "language", "script", "and", "region", "subtags", "from", "a", "tag", "string", "and", "return", "the", "results", "." ]

[ "private", "void", "_serializeList", "(", "List", "list", ",", "StringBuilder", "sb", ",", "Set", "<", "Object", ">", "done", ")", "throws", "ConverterException", "{", "sb", ".", "append", "(", "goIn", "(", ")", ")", ";", "sb", ".", "append", "(", "\"[\"", ")", ";", "boolean", "doIt", "=", "false", ";", "ListIterator", "it", "=", "list", ".", "listIterator", "(", ")", ";", "while", "(", "it", ".", "hasNext", "(", ")", ")", "{", "if", "(", "doIt", ")", "sb", ".", "append", "(", "'", "'", ")", ";", "doIt", "=", "true", ";", "_serialize", "(", "it", ".", "next", "(", ")", ",", "sb", ",", "done", ")", ";", "}", "sb", ".", "append", "(", "'", "'", ")", ";", "}" ]

[ "serialize", "a", "List", "(", "as", "Array", ")" ]

[ "public", "boolean", "isTrusted", "(", "String", "hostAddr", ",", "String", "headerName", ")", "{", "if", "(", "!", "wcTrusted", ")", "{", "return", "false", ";", "}", "if", "(", "HttpHeaderKeys", ".", "isSensitivePrivateHeader", "(", "headerName", ")", ")", "{", "// if this is a sensitive private header, check trustedSensitiveHeaderOrigin values", "return", "isTrustedForSensitiveHeaders", "(", "hostAddr", ")", ";", "}", "if", "(", "!", "usePrivateHeaders", ")", "{", "// trustedHeaderOrigin list is explicitly set to \"none\"", "return", "isTrustedForSensitiveHeaders", "(", "hostAddr", ")", ";", "}", "if", "(", "restrictPrivateHeaderOrigin", "==", "null", ")", "{", "// trustedHeaderOrigin list is set to \"*\"", "return", "true", ";", "}", "else", "{", "// check trustedHeaderOrigin for given host IP", "boolean", "trustedOrigin", "=", "restrictPrivateHeaderOrigin", ".", "contains", "(", "hostAddr", ".", "toLowerCase", "(", ")", ")", ";", "if", "(", "!", "trustedOrigin", ")", "{", "// if hostAddr is not in trustedHeaderOrigin, allow trustedSensitiveHeaderOrigin to override trust", "trustedOrigin", "=", "isTrustedForSensitiveHeaders", "(", "hostAddr", ")", ";", "}", "return", "trustedOrigin", ";", "}", "}" ]

[ "Check", "to", "see", "if", "the", "source", "host", "address", "is", "one", "we", "allow", "for", "specification", "of", "private", "headers" ]

[ "private", "static", "String", "getFilePath", "(", "String", "defaultPath", ",", "String", "filePath", ")", "{", "return", "defaultPath", "+", "File", ".", "separator", "+", "filePath", ";", "}" ]

[ "Crea", "el", "path", "para", "el", "fichero", "a", "partir", "del", "path", "por", "defecto" ]

[ "public", "YearMonthDay", "withField", "(", "DateTimeFieldType", "fieldType", ",", "int", "value", ")", "{", "int", "index", "=", "indexOfSupported", "(", "fieldType", ")", ";", "if", "(", "value", "==", "getValue", "(", "index", ")", ")", "{", "return", "this", ";", "}", "int", "[", "]", "newValues", "=", "getValues", "(", ")", ";", "newValues", "=", "getField", "(", "index", ")", ".", "set", "(", "this", ",", "index", ",", "newValues", ",", "value", ")", ";", "return", "new", "YearMonthDay", "(", "this", ",", "newValues", ")", ";", "}" ]

[ "Returns", "a", "copy", "of", "this", "date", "with", "the", "specified", "field", "set", "to", "a", "new", "value", ".", "<p", ">", "For", "example", "if", "the", "field", "type", "is", "<code", ">", "dayOfMonth<", "/", "code", ">", "then", "the", "day", "would", "be", "changed", "in", "the", "returned", "instance", ".", "<p", ">", "These", "three", "lines", "are", "equivalent", ":", "<pre", ">", "YearMonthDay", "updated", "=", "ymd", ".", "withField", "(", "DateTimeFieldType", ".", "dayOfMonth", "()", "6", ")", ";", "YearMonthDay", "updated", "=", "ymd", ".", "dayOfMonth", "()", ".", "setCopy", "(", "6", ")", ";", "YearMonthDay", "updated", "=", "ymd", ".", "property", "(", "DateTimeFieldType", ".", "dayOfMonth", "()", ")", ".", "setCopy", "(", "6", ")", ";", "<", "/", "pre", ">" ]

[ "private", "void", "addAttributeInternal", "(", "EntityType", "entityType", ",", "Attribute", "attr", ")", "{", "if", "(", "!", "isPersisted", "(", "attr", ")", ")", "{", "return", ";", "}", "if", "(", "isMultipleReferenceType", "(", "attr", ")", ")", "{", "createJunctionTable", "(", "entityType", ",", "attr", ")", ";", "if", "(", "attr", ".", "getDefaultValue", "(", ")", "!=", "null", "&&", "!", "attr", ".", "isNillable", "(", ")", ")", "{", "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "Iterable", "<", "Entity", ">", "defaultRefEntities", "=", "(", "Iterable", "<", "Entity", ">", ")", "AttributeUtils", ".", "getDefaultTypedValue", "(", "attr", ")", ";", "if", "(", "!", "Iterables", ".", "isEmpty", "(", "defaultRefEntities", ")", ")", "{", "createJunctionTableRows", "(", "entityType", ",", "attr", ",", "defaultRefEntities", ")", ";", "}", "}", "}", "else", "{", "createColumn", "(", "entityType", ",", "attr", ")", ";", "}", "}" ]

[ "Add", "attribute", "to", "entityType", "." ]

[ "public", "Schedule", "generateSchedule", "(", "LocalDate", "referenceDate", ",", "int", "maturity", ",", "int", "termination", ")", "{", "return", "generateSchedule", "(", "referenceDate", ",", "maturity", ",", "termination", ",", "OffsetUnit", ".", "MONTHS", ")", ";", "}" ]

[ "Generate", "a", "schedule", "with", "start", "/", "end", "date", "determined", "by", "an", "offset", "in", "months", "from", "the", "reference", "date", "." ]

[ "public", "static", "String", "mapToPtPath", "(", "final", "String", "aBasePath", ",", "final", "String", "aID", ",", "final", "String", "aEncapsulatedName", ")", "{", "final", "String", "ptPath", ";", "Objects", ".", "requireNonNull", "(", "aID", ")", ";", "if", "(", "aEncapsulatedName", "==", "null", ")", "{", "ptPath", "=", "concat", "(", "aBasePath", ",", "mapToPtPath", "(", "aID", ")", ")", ";", "}", "else", "{", "ptPath", "=", "concat", "(", "aBasePath", ",", "mapToPtPath", "(", "aID", ")", ",", "encodeID", "(", "aEncapsulatedName", ")", ")", ";", "}", "return", "ptPath", ";", "}" ]

[ "Maps", "the", "supplied", "ID", "to", "a", "Pairtree", "path", "using", "the", "supplied", "base", "path", "." ]

[ "public", "static", "void", "discardStream", "(", "InputStream", "is", ",", "int", "size", ")", "throws", "IOException", "{", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "size", "]", ";", "while", "(", "is", ".", "read", "(", "buffer", ",", "0", ",", "size", ")", "!=", "-", "1", ")", "{", "}", "}" ]

[ "throw", "away", "all", "bytes", "from", "stream", "argument" ]

[ "public", "static", "void", "dumpRow", "(", "Map", "<", "String", ",", "Object", ">", "row", ")", "{", "for", "(", "Entry", "<", "String", ",", "Object", ">", "entry", ":", "row", ".", "entrySet", "(", ")", ")", "{", "Object", "value", "=", "entry", ".", "getValue", "(", ")", ";", "System", ".", "out", ".", "println", "(", "entry", ".", "getKey", "(", ")", "+", "\" = \"", "+", "value", "+", "\" ( \"", "+", "(", "value", "==", "null", "?", "\"\"", ":", "value", ".", "getClass", "(", ")", ".", "getName", "(", ")", ")", "+", "\")\"", ")", ";", "}", "}" ]

[ "Dump", "the", "contents", "of", "a", "row", "from", "an", "MPD", "file", "." ]

[ "@", "Builder", "(", "builderMethodName", "=", "\"throttleInputStream\"", ",", "builderClassName", "=", "\"InputStreamThrottler\"", ")", "private", "ThrottledInputStream", "doThrottleInputStream", "(", "InputStream", "inputStream", ",", "URI", "sourceURI", ",", "URI", "targetURI", ")", "{", "Preconditions", ".", "checkNotNull", "(", "inputStream", ",", "\"InputStream cannot be null.\"", ")", ";", "Limiter", "limiter", "=", "new", "NoopLimiter", "(", ")", ";", "if", "(", "sourceURI", "!=", "null", "&&", "targetURI", "!=", "null", ")", "{", "StreamCopierSharedLimiterKey", "key", "=", "new", "StreamCopierSharedLimiterKey", "(", "sourceURI", ",", "targetURI", ")", ";", "try", "{", "limiter", "=", "new", "MultiLimiter", "(", "limiter", ",", "this", ".", "broker", ".", "getSharedResource", "(", "new", "SharedLimiterFactory", "<", "S", ">", "(", ")", ",", "key", ")", ")", ";", "}", "catch", "(", "NotConfiguredException", "nce", ")", "{", "log", ".", "warn", "(", "\"Could not create a Limiter for key \"", "+", "key", ",", "nce", ")", ";", "}", "}", "else", "{", "log", ".", "info", "(", "\"Not throttling input stream because source or target URIs are not defined.\"", ")", ";", "}", "Optional", "<", "MeteredInputStream", ">", "meteredStream", "=", "MeteredInputStream", ".", "findWrappedMeteredInputStream", "(", "inputStream", ")", ";", "if", "(", "!", "meteredStream", ".", "isPresent", "(", ")", ")", "{", "meteredStream", "=", "Optional", ".", "of", "(", "MeteredInputStream", ".", "builder", "(", ")", ".", "in", "(", "inputStream", ")", ".", "build", "(", ")", ")", ";", "inputStream", "=", "meteredStream", ".", "get", "(", ")", ";", "}", "return", "new", "ThrottledInputStream", "(", "inputStream", ",", "limiter", ",", "meteredStream", ".", "get", "(", ")", ")", ";", "}" ]

[ "Throttles", "an", "{" ]

[ "public", "ZooKeeperUpdatingListener", "build", "(", ")", "{", "final", "boolean", "internalClient", ";", "if", "(", "client", "==", "null", ")", "{", "client", "=", "CuratorFrameworkFactory", ".", "builder", "(", ")", ".", "connectString", "(", "connectionStr", ")", ".", "retryPolicy", "(", "ZooKeeperDefaults", ".", "DEFAULT_RETRY_POLICY", ")", ".", "connectionTimeoutMs", "(", "connectTimeoutMillis", ")", ".", "sessionTimeoutMs", "(", "sessionTimeoutMillis", ")", ".", "build", "(", ")", ";", "internalClient", "=", "true", ";", "}", "else", "{", "internalClient", "=", "false", ";", "}", "return", "new", "ZooKeeperUpdatingListener", "(", "client", ",", "zNodePath", ",", "nodeValueCodec", ",", "endpoint", ",", "internalClient", ")", ";", "}" ]

[ "Returns", "a", "newly", "-", "created", "{" ]

[ "public", "void", "dispatchToEvents", "(", "int", "nodeHandle", ",", "org", ".", "xml", ".", "sax", ".", "ContentHandler", "ch", ")", "throws", "org", ".", "xml", ".", "sax", ".", "SAXException", "{", "TreeWalker", "treeWalker", "=", "m_walker", ";", "ContentHandler", "prevCH", "=", "treeWalker", ".", "getContentHandler", "(", ")", ";", "if", "(", "null", "!=", "prevCH", ")", "{", "treeWalker", "=", "new", "TreeWalker", "(", "null", ")", ";", "}", "treeWalker", ".", "setContentHandler", "(", "ch", ")", ";", "try", "{", "Node", "node", "=", "getNode", "(", "nodeHandle", ")", ";", "treeWalker", ".", "traverseFragment", "(", "node", ")", ";", "}", "finally", "{", "treeWalker", ".", "setContentHandler", "(", "null", ")", ";", "}", "}" ]

[ "Directly", "create", "SAX", "parser", "events", "from", "a", "subtree", "." ]

[ "public", "static", "Driver", "createDriver", "(", "FeedPartition", "feedPartition", ",", "Plan", "plan", ",", "MetricRegistry", "metricRegistry", ")", "{", "populateFeedMetricInfo", "(", "plan", ",", "feedPartition", ",", "metricRegistry", ")", ";", "OperatorDesc", "desc", "=", "plan", ".", "getRootOperator", "(", ")", ";", "Operator", "oper", "=", "buildOperator", "(", "desc", ",", "metricRegistry", ",", "plan", ".", "getName", "(", ")", ",", "feedPartition", ")", ";", "OffsetStorage", "offsetStorage", "=", "null", ";", "OffsetStorageDesc", "offsetDesc", "=", "plan", ".", "getOffsetStorageDesc", "(", ")", ";", "if", "(", "offsetDesc", "!=", "null", "&&", "feedPartition", ".", "supportsOffsetManagement", "(", ")", ")", "{", "offsetStorage", "=", "buildOffsetStorage", "(", "feedPartition", ",", "plan", ",", "offsetDesc", ")", ";", "Offset", "offset", "=", "offsetStorage", ".", "findLatestPersistedOffset", "(", ")", ";", "if", "(", "offset", "!=", "null", ")", "{", "feedPartition", ".", "setOffset", "(", "new", "String", "(", "offset", ".", "serialize", "(", ")", ",", "Charsets", ".", "UTF_8", ")", ")", ";", "}", "}", "CollectorProcessor", "cp", "=", "new", "CollectorProcessor", "(", ")", ";", "cp", ".", "setTupleRetry", "(", "plan", ".", "getTupleRetry", "(", ")", ")", ";", "int", "offsetCommitInterval", "=", "plan", ".", "getOffsetCommitInterval", "(", ")", ";", "Driver", "driver", "=", "new", "Driver", "(", "feedPartition", ",", "oper", ",", "offsetStorage", ",", "cp", ",", "offsetCommitInterval", ",", "metricRegistry", ",", "plan", ".", "getName", "(", ")", ")", ";", "recurseOperatorAndDriverNode", "(", "desc", ",", "driver", ".", "getDriverNode", "(", ")", ",", "metricRegistry", ",", "feedPartition", ")", ";", "return", "driver", ";", "}" ]

[ "Given", "a", "FeedParition", "and", "Plan", "create", "a", "Driver", "that", "will", "consume", "from", "the", "feed", "partition", "and", "execute", "the", "plan", "." ]

[ "public", "void", "setExceptionGen", "(", "@", "Nullable", "TypeMerger", "m", ",", "CodeExceptionGen", "exceptionGen", ")", "{", "if", "(", "this", ".", "exceptionGen", "!=", "null", ")", "{", "AnalysisContext", ".", "logError", "(", "\"Multiple exception handlers\"", ")", ";", "}", "this", ".", "exceptionGen", "=", "exceptionGen", ";", "}" ]

[ "Set", "the", "CodeExceptionGen", "object", ".", "Marks", "this", "basic", "block", "as", "the", "entry", "point", "of", "an", "exception", "handler", "." ]

[ "public", "void", "setInitializer", "(", "/* @Nullable */", "JvmField", "field", ",", "/* @Nullable */", "XExpression", "expr", ")", "{", "if", "(", "field", "==", "null", "||", "expr", "==", "null", ")", "return", ";", "removeExistingBody", "(", "field", ")", ";", "associator", ".", "associateLogicalContainer", "(", "expr", ",", "field", ")", ";", "}" ]

[ "Sets", "the", "given", "{", "@link", "JvmField", "}", "as", "the", "logical", "container", "for", "the", "given", "{", "@link", "XExpression", "}", ".", "This", "defines", "the", "context", "and", "the", "scope", "for", "the", "given", "expression", "." ]

[ "protected", "StrutsException", "fieldError", "(", "String", "field", ",", "String", "errorMsg", ",", "Exception", "e", ")", "{", "String", "msg", "=", "\"tag '\"", "+", "getComponentName", "(", ")", "+", "\"', field '\"", "+", "field", "+", "(", "parameters", "!=", "null", "&&", "parameters", ".", "containsKey", "(", "\"name\"", ")", "?", "\"', name '\"", "+", "parameters", ".", "get", "(", "\"name\"", ")", ":", "\"\"", ")", "+", "\"': \"", "+", "errorMsg", ";", "throw", "new", "StrutsException", "(", "msg", ",", "e", ")", ";", "}" ]

[ "Constructs", "a", "<code", ">", "RuntimeException<", "/", "code", ">", "based", "on", "the", "given", "information", ".", "<p", "/", ">", "A", "message", "is", "constructed", "and", "logged", "at", "ERROR", "level", "before", "being", "returned", "as", "a", "<code", ">", "RuntimeException<", "/", "code", ">", "." ]

[ "private", "static", "JsonNode", "federatedFlowStep1", "(", "LoginInput", "loginInput", ")", "throws", "SnowflakeSQLException", "{", "JsonNode", "dataNode", "=", "null", ";", "try", "{", "URIBuilder", "fedUriBuilder", "=", "new", "URIBuilder", "(", "loginInput", ".", "getServerUrl", "(", ")", ")", ";", "fedUriBuilder", ".", "setPath", "(", "SF_PATH_AUTHENTICATOR_REQUEST", ")", ";", "URI", "fedUrlUri", "=", "fedUriBuilder", ".", "build", "(", ")", ";", "Map", "<", "String", ",", "Object", ">", "data", "=", "new", "HashMap", "<>", "(", ")", ";", "data", ".", "put", "(", "ClientAuthnParameter", ".", "ACCOUNT_NAME", ".", "name", "(", ")", ",", "loginInput", ".", "getAccountName", "(", ")", ")", ";", "data", ".", "put", "(", "ClientAuthnParameter", ".", "AUTHENTICATOR", ".", "name", "(", ")", ",", "loginInput", ".", "getAuthenticator", "(", ")", ")", ";", "data", ".", "put", "(", "ClientAuthnParameter", ".", "CLIENT_APP_ID", ".", "name", "(", ")", ",", "loginInput", ".", "getAppId", "(", ")", ")", ";", "data", ".", "put", "(", "ClientAuthnParameter", ".", "CLIENT_APP_VERSION", ".", "name", "(", ")", ",", "loginInput", ".", "getAppVersion", "(", ")", ")", ";", "ClientAuthnDTO", "authnData", "=", "new", "ClientAuthnDTO", "(", ")", ";", "authnData", ".", "setData", "(", "data", ")", ";", "String", "json", "=", "mapper", ".", "writeValueAsString", "(", "authnData", ")", ";", "// attach the login info json body to the post request", "StringEntity", "input", "=", "new", "StringEntity", "(", "json", ",", "Charset", ".", "forName", "(", "\"UTF-8\"", ")", ")", ";", "input", ".", "setContentType", "(", "\"application/json\"", ")", ";", "HttpPost", "postRequest", "=", "new", "HttpPost", "(", "fedUrlUri", ")", ";", "postRequest", ".", "setEntity", "(", "input", ")", ";", "postRequest", ".", "addHeader", "(", "\"accept\"", ",", "\"application/json\"", ")", ";", "final", "String", "gsResponse", "=", "HttpUtil", ".", "executeRequest", "(", "postRequest", ",", "loginInput", ".", "getLoginTimeout", "(", ")", ",", "0", ",", "null", ")", ";", "logger", ".", "debug", "(", "\"authenticator-request response: {}\"", ",", "gsResponse", ")", ";", "JsonNode", "jsonNode", "=", "mapper", ".", "readTree", "(", "gsResponse", ")", ";", "// check the success field first", "if", "(", "!", "jsonNode", ".", "path", "(", "\"success\"", ")", ".", "asBoolean", "(", ")", ")", "{", "logger", ".", "debug", "(", "\"response = {}\"", ",", "gsResponse", ")", ";", "String", "errorCode", "=", "jsonNode", ".", "path", "(", "\"code\"", ")", ".", "asText", "(", ")", ";", "throw", "new", "SnowflakeSQLException", "(", "SqlState", ".", "SQLCLIENT_UNABLE_TO_ESTABLISH_SQLCONNECTION", ",", "ErrorCode", ".", "CONNECTION_ERROR", ".", "getMessageCode", "(", ")", ",", "errorCode", ",", "jsonNode", ".", "path", "(", "\"message\"", ")", ".", "asText", "(", ")", ")", ";", "}", "// session token is in the data field of the returned json response", "dataNode", "=", "jsonNode", ".", "path", "(", "\"data\"", ")", ";", "}", "catch", "(", "IOException", "|", "URISyntaxException", "ex", ")", "{", "handleFederatedFlowError", "(", "loginInput", ",", "ex", ")", ";", "}", "return", "dataNode", ";", "}" ]

[ "Query", "Snowflake", "to", "obtain", "IDP", "token", "url", "and", "IDP", "SSO", "url" ]

[ "public", "Observable", "<", "DatabaseInner", ">", "pauseAsync", "(", "String", "resourceGroupName", ",", "String", "serverName", ",", "String", "databaseName", ")", "{", "return", "pauseWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ",", "databaseName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "DatabaseInner", ">", ",", "DatabaseInner", ">", "(", ")", "{", "@", "Override", "public", "DatabaseInner", "call", "(", "ServiceResponse", "<", "DatabaseInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Pauses", "a", "database", "." ]

[ "public", "int", "doRecordChange", "(", "FieldInfo", "field", ",", "int", "iChangeType", ",", "boolean", "bDisplayOption", ")", "{", "// Read a valid record", "int", "iErrorCode", "=", "super", ".", "doRecordChange", "(", "field", ",", "iChangeType", ",", "bDisplayOption", ")", ";", "// Initialize the record", "if", "(", "iErrorCode", "!=", "DBConstants", ".", "NORMAL_RETURN", ")", "return", "iErrorCode", ";", "if", "(", "m_bUpdateOnUpdate", ")", "if", "(", "(", "iChangeType", "==", "DBConstants", ".", "AFTER_UPDATE_TYPE", ")", "||", "(", "iChangeType", "==", "DBConstants", ".", "AFTER_ADD_TYPE", ")", ")", "return", "this", ".", "writeAndRefresh", "(", ")", ";", "if", "(", "iChangeType", "==", "DBConstants", ".", "BEFORE_FREE_TYPE", ")", "if", "(", "m_bUpdateOnClose", ")", "this", ".", "writeAndRefresh", "(", ")", ";", "return", "iErrorCode", ";", "}" ]

[ "Called", "when", "a", "change", "in", "the", "record", "status", "is", "about", "to", "happen", "/", "has", "happened", "." ]

[ "public", "HttpClientResponseBuilder", "withCookie", "(", "String", "cookieName", ",", "String", "cookieValue", ")", "{", "Action", "lastAction", "=", "newRule", ".", "getLastAction", "(", ")", ";", "CookieAction", "cookieAction", "=", "new", "CookieAction", "(", "lastAction", ",", "cookieName", ",", "cookieValue", ")", ";", "newRule", ".", "overrideLastAction", "(", "cookieAction", ")", ";", "return", "this", ";", "}" ]

[ "Sets", "response", "cookie" ]

[ "public", "void", "setProperty", "(", "String", "name", ",", "Object", "value", ")", "throws", "IllegalArgumentException", ",", "IllegalStateException", "{", "if", "(", "name", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"property name can not be null\"", ")", ";", "}", "if", "(", "PROPERTY_SERIALIZER_INDENTATION", ".", "equals", "(", "name", ")", ")", "{", "indentationString", "=", "(", "String", ")", "value", ";", "}", "else", "if", "(", "PROPERTY_SERIALIZER_LINE_SEPARATOR", ".", "equals", "(", "name", ")", ")", "{", "lineSeparator", "=", "(", "String", ")", "value", ";", "}", "else", "if", "(", "PROPERTY_LOCATION", ".", "equals", "(", "name", ")", ")", "{", "location", "=", "(", "String", ")", "value", ";", "}", "else", "{", "throw", "new", "IllegalStateException", "(", "\"unsupported property \"", "+", "name", ")", ";", "}", "writeLineSepartor", "=", "lineSeparator", "!=", "null", "&&", "lineSeparator", ".", "length", "(", ")", ">", "0", ";", "writeIndentation", "=", "indentationString", "!=", "null", "&&", "indentationString", ".", "length", "(", ")", ">", "0", ";", "// optimize - do not write when nothing to write ...", "doIndent", "=", "indentationString", "!=", "null", "&&", "(", "writeLineSepartor", "||", "writeIndentation", ")", ";", "// NOTE: when indentationString == null there is no indentation", "// (even though writeLineSeparator may be true ...)", "rebuildIndentationBuf", "(", ")", ";", "seenTag", "=", "false", ";", "// for consistency", "}" ]

[ "Sets", "the", "property", "." ]

[ "public", "static", "KieServerControllerClient", "newRestClient", "(", "final", "String", "controllerUrl", ",", "final", "String", "login", ",", "final", "String", "password", ")", "{", "return", "new", "RestKieServerControllerClient", "(", "controllerUrl", ",", "login", ",", "password", ")", ";", "}" ]

[ "Creates", "a", "new", "Kie", "Controller", "Client", "using", "REST", "based", "service" ]

[ "public", "static", "void", "addDeclaredMethodsFromInterfaces", "(", "ClassNode", "cNode", ",", "Map", "<", "String", ",", "MethodNode", ">", "methodsMap", ")", "{", "// add in unimplemented abstract methods from the interfaces", "for", "(", "ClassNode", "iface", ":", "cNode", ".", "getInterfaces", "(", ")", ")", "{", "Map", "<", "String", ",", "MethodNode", ">", "ifaceMethodsMap", "=", "iface", ".", "getDeclaredMethodsMap", "(", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "MethodNode", ">", "entry", ":", "ifaceMethodsMap", ".", "entrySet", "(", ")", ")", "{", "String", "methSig", "=", "entry", ".", "getKey", "(", ")", ";", "if", "(", "!", "methodsMap", ".", "containsKey", "(", "methSig", ")", ")", "{", "methodsMap", ".", "put", "(", "methSig", ",", "entry", ".", "getValue", "(", ")", ")", ";", "}", "}", "}", "}" ]

[ "Add", "in", "methods", "from", "all", "interfaces", ".", "Existing", "entries", "in", "the", "methods", "map", "take", "precedence", ".", "Methods", "from", "interfaces", "visited", "early", "take", "precedence", "over", "later", "ones", "." ]

[ "public", "boolean", "validateHexColor_Pattern", "(", "String", "hexColor", ",", "DiagnosticChain", "diagnostics", ",", "Map", "<", "Object", ",", "Object", ">", "context", ")", "{", "return", "validatePattern", "(", "ColorPackage", ".", "Literals", ".", "HEX_COLOR", ",", "hexColor", ",", "HEX_COLOR__PATTERN__VALUES", ",", "diagnostics", ",", "context", ")", ";", "}" ]

[ "Validates", "the", "Pattern", "constraint", "of", "<em", ">", "Hex", "Color<", "/", "em", ">", ".", "<!", "--", "begin", "-", "user", "-", "doc", "--", ">", "<!", "--", "end", "-", "user", "-", "doc", "--", ">" ]

[ "public", "static", "void", "bindText", "(", "final", "Value", "<", "String", ">", "value", ",", "final", "TextBoxBase", "text", ")", "{", "text", ".", "addKeyUpHandler", "(", "new", "KeyUpHandler", "(", ")", "{", "public", "void", "onKeyUp", "(", "KeyUpEvent", "event", ")", "{", "value", ".", "updateIf", "(", "(", "(", "TextBoxBase", ")", "event", ".", "getSource", "(", ")", ")", ".", "getText", "(", ")", ")", ";", "}", "}", ")", ";", "text", ".", "addChangeHandler", "(", "new", "ChangeHandler", "(", ")", "{", "public", "void", "onChange", "(", "ChangeEvent", "event", ")", "{", "value", ".", "updateIf", "(", "(", "(", "TextBoxBase", ")", "event", ".", "getSource", "(", ")", ")", ".", "getText", "(", ")", ")", ";", "}", "}", ")", ";", "bindLabel", "(", "value", ",", "text", ")", ";", "}" ]

[ "Binds", "the", "contents", "of", "the", "supplied", "text", "box", "to", "the", "supplied", "string", "value", ".", "The", "binding", "is", "multidirectional", "i", ".", "e", ".", "changes", "to", "the", "value", "will", "update", "the", "text", "box", "and", "changes", "to", "the", "text", "box", "will", "update", "the", "value", ".", "The", "value", "is", "updated", "on", "key", "up", "as", "well", "as", "on", "change", "so", "that", "both", "keyboard", "initiated", "changes", "and", "non", "-", "keyboard", "initiated", "changes", "(", "paste", ")", "are", "handled", "." ]

[ "public", "Frames", "getVideoFrames", "(", "String", "teamName", ",", "String", "reviewId", ",", "GetVideoFramesOptionalParameter", "getVideoFramesOptionalParameter", ")", "{", "return", "getVideoFramesWithServiceResponseAsync", "(", "teamName", ",", "reviewId", ",", "getVideoFramesOptionalParameter", ")", ".", "toBlocking", "(", ")", ".", "single", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "The", "reviews", "created", "would", "show", "up", "for", "Reviewers", "on", "your", "team", ".", "As", "Reviewers", "complete", "reviewing", "results", "of", "the", "Review", "would", "be", "POSTED", "(", "i", ".", "e", ".", "HTTP", "POST", ")", "on", "the", "specified", "CallBackEndpoint", ".", "&lt", ";", "h3&gt", ";", "CallBack", "Schemas", "&lt", ";", "/", "h3&gt", ";", "&lt", ";", "h4&gt", ";", "Review", "Completion", "CallBack", "Sample&lt", ";", "/", "h4&gt", ";", "&lt", ";", "p&gt", ";", "{", "&lt", ";", "br", "/", "&gt", ";", "ReviewId", ":", "&lt", ";", "Review", "Id&gt", ";", "&lt", ";", "br", "/", "&gt", ";", "ModifiedOn", ":", "2016", "-", "10", "-", "11T22", ":", "36", ":", "32", ".", "9934851Z", "&lt", ";", "br", "/", "&gt", ";", "ModifiedBy", ":", "&lt", ";", "Name", "of", "the", "Reviewer&gt", ";", "&lt", ";", "br", "/", "&gt", ";", "CallBackType", ":", "Review", "&lt", ";", "br", "/", "&gt", ";", "ContentId", ":", "&lt", ";", "The", "ContentId", "that", "was", "specified", "input&gt", ";", "&lt", ";", "br", "/", "&gt", ";", "Metadata", ":", "{", "&lt", ";", "br", "/", "&gt", ";", "adultscore", ":", "0", ".", "xxx", "&lt", ";", "br", "/", "&gt", ";", "a", ":", "False", "&lt", ";", "br", "/", "&gt", ";", "racyscore", ":", "0", ".", "xxx", "&lt", ";", "br", "/", "&gt", ";", "r", ":", "True", "&lt", ";", "br", "/", "&gt", ";", "}", "&lt", ";", "br", "/", "&gt", ";", "ReviewerResultTags", ":", "{", "&lt", ";", "br", "/", "&gt", ";", "a", ":", "False", "&lt", ";", "br", "/", "&gt", ";", "r", ":", "True", "&lt", ";", "br", "/", "&gt", ";", "}", "&lt", ";", "br", "/", "&gt", ";", "}", "&lt", ";", "br", "/", "&gt", ";", "&lt", ";", "/", "p&gt", ";", "." ]

[ "public", "FessMessages", "addErrorsPropertyTypeDouble", "(", "String", "property", ",", "String", "arg0", ")", "{", "assertPropertyNotNull", "(", "property", ")", ";", "add", "(", "property", ",", "new", "UserMessage", "(", "ERRORS_property_type_double", ",", "arg0", ")", ")", ";", "return", "this", ";", "}" ]

[ "Add", "the", "created", "action", "message", "for", "the", "key", "errors", ".", "property_type_double", "with", "parameters", ".", "<pre", ">", "message", ":", "{", "0", "}", "should", "be", "numeric", ".", "<", "/", "pre", ">" ]

[ "private", "static", "String", "parseNonDigits", "(", "final", "String", "expression", ",", "final", "int", "startIndex", ")", "{", "final", "StringBuilder", "operatorBuffer", "=", "new", "StringBuilder", "(", ")", ";", "char", "currentCharacter", "=", "expression", ".", "charAt", "(", "startIndex", ")", ";", "int", "subExpressionIndex", "=", "startIndex", ";", "do", "{", "operatorBuffer", ".", "append", "(", "currentCharacter", ")", ";", "subExpressionIndex", "++", ";", "if", "(", "subExpressionIndex", "<", "expression", ".", "length", "(", ")", ")", "{", "currentCharacter", "=", "expression", ".", "charAt", "(", "subExpressionIndex", ")", ";", "}", "}", "while", "(", "subExpressionIndex", "<", "expression", ".", "length", "(", ")", "&&", "!", "Character", ".", "isDigit", "(", "currentCharacter", ")", "&&", "!", "isSeparatorToken", "(", "currentCharacter", ")", ")", ";", "return", "operatorBuffer", ".", "toString", "(", ")", ";", "}" ]

[ "This", "method", "reads", "non", "-", "digit", "characters", "from", "a", "given", "string", "starting", "at", "a", "given", "index", ".", "It", "will", "read", "till", "the", "end", "of", "the", "string", "or", "up", "until", "it", "encounters", "<p", ">", "-", "a", "digit", "-", "a", "separator", "token" ]

[ "public", "static", "ThymeleafTemplate", "wrap", "(", "TemplateEngine", "engine", ",", "String", "template", ",", "Charset", "charset", ")", "{", "return", "(", "null", "==", "engine", ")", "?", "null", ":", "new", "ThymeleafTemplate", "(", "engine", ",", "template", ",", "charset", ")", ";", "}" ]

[ "包装Thymeleaf模板" ]

[ "public", "static", "void", "saveToXml", "(", "Node", "doc", ",", "File", "file", ")", "throws", "AlipayApiException", "{", "OutputStream", "out", "=", "null", ";", "try", "{", "Transformer", "tf", "=", "TransformerFactory", ".", "newInstance", "(", ")", ".", "newTransformer", "(", ")", ";", "Properties", "props", "=", "tf", ".", "getOutputProperties", "(", ")", ";", "props", ".", "setProperty", "(", "OutputKeys", ".", "METHOD", ",", "XMLConstants", ".", "XML_NS_PREFIX", ")", ";", "props", ".", "setProperty", "(", "OutputKeys", ".", "INDENT", ",", "LOGIC_YES", ")", ";", "tf", ".", "setOutputProperties", "(", "props", ")", ";", "DOMSource", "dom", "=", "new", "DOMSource", "(", "doc", ")", ";", "out", "=", "getOutputStream", "(", "file", ")", ";", "Result", "result", "=", "new", "StreamResult", "(", "out", ")", ";", "tf", ".", "transform", "(", "dom", ",", "result", ")", ";", "}", "catch", "(", "TransformerException", "e", ")", "{", "throw", "new", "AlipayApiException", "(", "\"XML_TRANSFORM_ERROR\"", ",", "e", ")", ";", "}", "finally", "{", "if", "(", "out", "!=", "null", ")", "{", "try", "{", "out", ".", "close", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "// nothing to do", "}", "}", "}", "}" ]

[ "Saves", "the", "node", "/", "document", "/", "element", "as", "XML", "file", "." ]

[ "public", "Places", "getChildrenWithPhotosPublic", "(", "String", "placeId", ",", "String", "woeId", ")", "throws", "JinxException", "{", "if", "(", "JinxUtils", ".", "isNullOrEmpty", "(", "placeId", ")", ")", "{", "JinxUtils", ".", "validateParams", "(", "woeId", ")", ";", "}", "Map", "<", "String", ",", "String", ">", "params", "=", "new", "TreeMap", "<>", "(", ")", ";", "params", ".", "put", "(", "\"method\"", ",", "\"flickr.places.getChildrenWithPhotosPublic\"", ")", ";", "if", "(", "JinxUtils", ".", "isNullOrEmpty", "(", "placeId", ")", ")", "{", "params", ".", "put", "(", "\"woe_id\"", ",", "woeId", ")", ";", "}", "else", "{", "params", ".", "put", "(", "\"place_id\"", ",", "placeId", ")", ";", "}", "return", "jinx", ".", "flickrGet", "(", "params", ",", "Places", ".", "class", ",", "false", ")", ";", "}" ]

[ "Return", "a", "list", "of", "locations", "with", "public", "photos", "that", "are", "parented", "by", "a", "Where", "on", "Earth", "(", "WOE", ")", "or", "Places", "ID", ".", "Authentication", "<p", ">", "This", "method", "does", "not", "require", "authentication", ".", "<p", ">", "You", "must", "provide", "a", "valid", "placesId", "or", "woeId", ".", "If", "you", "provide", "both", "the", "placesId", "will", "be", "used", ".", "<p", ">" ]

[ "private", "boolean", "sameAndNotCoveredByDescendants", "(", "TraitProxy", "proxy", ",", "BitSet", "typeMask", ")", "{", "boolean", "isSameType", "=", "typeMask", ".", "equals", "(", "proxy", ".", "_getTypeCode", "(", ")", ")", ";", "if", "(", "isSameType", ")", "{", "TraitTypeMap", "<", "String", ",", "Thing", "<", "?", ">", ",", "?", ">", "ttm", "=", "(", "TraitTypeMap", "<", "String", ",", "Thing", "<", "?", ">", ",", "?", ">", ")", "proxy", ".", "getObject", "(", ")", ".", "_getTraitMap", "(", ")", ";", "Collection", "<", "Thing", "<", "?", ">", ">", "descs", "=", "ttm", ".", "lowerDescendants", "(", "typeMask", ")", ";", "// we have to exclude the \"mock\" bottom proxy", "if", "(", "descs", "==", "null", "||", "descs", ".", "isEmpty", "(", ")", ")", "{", "return", "true", ";", "}", "else", "{", "for", "(", "Thing", "sub", ":", "descs", ")", "{", "TraitType", "tt", "=", "(", "TraitType", ")", "sub", ";", "if", "(", "tt", "!=", "proxy", "&&", "tt", ".", "_hasTypeCode", "(", "typeMask", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}", "}", "else", "{", "return", "false", ";", "}", "}" ]

[ "Edge", "case", ":", "due", "to", "the", "way", "traits", "are", "encoded", "consider", "this", "hierarchy", ":", "A", "B", "C", "D", "On", "don", "/", "insertion", "of", "C", "C", "may", "be", "vetoed", "by", "its", "parents", "but", "might", "have", "been", "already", "covered", "by", "one", "of", "its", "descendants", "(", "D", ")" ]

[ "public", "static", "int", "cudnnRestoreDropoutDescriptor", "(", "cudnnDropoutDescriptor", "dropoutDesc", ",", "cudnnHandle", "handle", ",", "float", "dropout", ",", "Pointer", "states", ",", "long", "stateSizeInBytes", ",", "long", "seed", ")", "{", "return", "checkResult", "(", "cudnnRestoreDropoutDescriptorNative", "(", "dropoutDesc", ",", "handle", ",", "dropout", ",", "states", ",", "stateSizeInBytes", ",", "seed", ")", ")", ";", "}" ]

[ "Restores", "the", "dropout", "descriptor", "to", "a", "previously", "saved", "-", "off", "state" ]

[ "public", "Bigquery", "getBigQuery", "(", "Configuration", "config", ")", "throws", "GeneralSecurityException", ",", "IOException", "{", "logger", ".", "atInfo", "(", ")", ".", "log", "(", "\"Creating BigQuery from default credential.\"", ")", ";", "Credential", "credential", "=", "createBigQueryCredential", "(", "config", ")", ";", "// Use the credential to create an authorized BigQuery client", "return", "getBigQueryFromCredential", "(", "credential", ",", "BQC_ID", ")", ";", "}" ]

[ "Constructs", "a", "BigQuery", "from", "the", "credential", "constructed", "from", "the", "environment", "." ]

[ "public", "ConfigurationSourceKey", "getConfigName", "(", ")", "{", "return", "new", "ConfigurationSourceKey", "(", "ConfigurationSourceKey", ".", "Type", ".", "FILE", ",", "ConfigurationSourceKey", ".", "Format", ".", "JSON", ",", "configurationName", ")", ";", "}" ]

[ "Get", "configuration", "name", "of", "the", "linked", "config" ]

[ "protected", "void", "writeXml", "(", "MListTable", "<", "?", ">", "table", ",", "OutputStream", "outputStream", ")", "throws", "IOException", "{", "final", "List", "<", "?", ">", "list", "=", "table", ".", "getList", "(", ")", ";", "TransportFormatAdapter", ".", "writeXml", "(", "(", "Serializable", ")", "list", ",", "outputStream", ")", ";", "}" ]

[ "Exporte", "une", "MListTable", "dans", "un", "fichier", "au", "format", "xml", "." ]

[ "private", "MultipartBody", "createMultipartBody", "(", ")", "throws", "Exception", "{", "List", "<", "Attachment", ">", "atts", "=", "new", "LinkedList", "<", "Attachment", ">", "(", ")", ";", "atts", ".", "add", "(", "new", "Attachment", "(", "\"book1\"", ",", "\"application/xml\"", ",", "new", "Book", "(", "\"JAXB\"", ",", "1L", ")", ")", ")", ";", "atts", ".", "add", "(", "new", "Attachment", "(", "\"book2\"", ",", "\"application/json\"", ",", "new", "Book", "(", "\"JSON\"", ",", "2L", ")", ")", ")", ";", "atts", ".", "add", "(", "new", "Attachment", "(", "\"image\"", ",", "\"application/octet-stream\"", ",", "getClass", "(", ")", ".", "getResourceAsStream", "(", "\"/java.jpg\"", ")", ")", ")", ";", "return", "new", "MultipartBody", "(", "atts", ",", "true", ")", ";", "}" ]

[ "Creates", "MultipartBody", ".", "It", "contains", "3", "parts", "book1", "book2", "and", "image", ".", "These", "individual", "parts", "have", "their", "Content", "-", "Type", "set", "to", "application", "/", "xml", "application", "/", "json", "and", "application", "/", "octet", "-", "stream" ]

[ "public", "static", "<", "T", ">", "T", "findLast", "(", "Iterator", "<", "T", ">", "iterator", ",", "Functions", ".", "Function1", "<", "?", "super", "T", ",", "Boolean", ">", "predicate", ")", "{", "if", "(", "predicate", "==", "null", ")", "throw", "new", "NullPointerException", "(", "\"predicate\"", ")", ";", "T", "result", "=", "null", ";", "while", "(", "iterator", ".", "hasNext", "(", ")", ")", "{", "T", "t", "=", "iterator", ".", "next", "(", ")", ";", "if", "(", "predicate", ".", "apply", "(", "t", ")", ")", "result", "=", "t", ";", "}", "return", "result", ";", "}" ]

[ "Finds", "the", "last", "element", "in", "the", "given", "iterator", "that", "fulfills", "the", "predicate", ".", "If", "none", "is", "found", "or", "the", "iterator", "is", "empty", "<code", ">", "null<", "/", "code", ">", "is", "returned", "." ]

[ "public", "TileBasedLayer", "createLayer", "(", "String", "id", ",", "TileConfiguration", "conf", ",", "String", "url", ")", "{", "List", "<", "String", ">", "urls", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "urls", ".", "add", "(", "url", ")", ";", "return", "createLayer", "(", "id", ",", "conf", ",", "urls", ")", ";", "}" ]

[ "Create", "a", "new", "tile", "based", "layer", "with", "an", "URL", "to", "a", "tile", "service", ".", "<p", "/", ">", "The", "URL", "should", "have", "placeholders", "for", "the", "x", "-", "and", "y", "-", "coordinate", "and", "tile", "level", "in", "the", "form", "of", "{", "x", "}", "{", "y", "}", "{", "z", "}", ".", "The", "Y", "-", "coordinate", "can", "be", "inverted", "by", "specifying", "{", "-", "y", "}", "instead", "of", "{", "y", "}", ".", "The", "file", "extension", "of", "the", "tiles", "should", "be", "part", "of", "the", "URL", "." ]

[ "protected", "ArrayDBIDs", "affectedkNN", "(", "List", "<", "?", "extends", "KNNList", ">", "extract", ",", "DBIDs", "remove", ")", "{", "HashSetModifiableDBIDs", "ids", "=", "DBIDUtil", ".", "newHashSet", "(", ")", ";", "for", "(", "KNNList", "drps", ":", "extract", ")", "{", "for", "(", "DBIDIter", "iter", "=", "drps", ".", "iter", "(", ")", ";", "iter", ".", "valid", "(", ")", ";", "iter", ".", "advance", "(", ")", ")", "{", "ids", ".", "add", "(", "iter", ")", ";", "}", "}", "ids", ".", "removeDBIDs", "(", "remove", ")", ";", "// Convert back to array", "return", "DBIDUtil", ".", "newArray", "(", "ids", ")", ";", "}" ]

[ "Extracts", "and", "removes", "the", "DBIDs", "in", "the", "given", "collections", "." ]

[ "@", "VisibleForTesting", "protected", "static", "Config", "resolveConfig", "(", "Config", "datasetConfig", ",", "DbAndTable", "realDbAndTable", ",", "DbAndTable", "logicalDbAndTable", ")", "{", "Preconditions", ".", "checkNotNull", "(", "datasetConfig", ",", "\"Dataset config should not be null\"", ")", ";", "Preconditions", ".", "checkNotNull", "(", "realDbAndTable", ",", "\"Real DB and table should not be null\"", ")", ";", "Preconditions", ".", "checkNotNull", "(", "logicalDbAndTable", ",", "\"Logical DB and table should not be null\"", ")", ";", "Properties", "resolvedProperties", "=", "new", "Properties", "(", ")", ";", "Config", "resolvedConfig", "=", "datasetConfig", ".", "resolve", "(", ")", ";", "for", "(", "Map", ".", "Entry", "<", "String", ",", "ConfigValue", ">", "entry", ":", "resolvedConfig", ".", "entrySet", "(", ")", ")", "{", "if", "(", "ConfigValueType", ".", "LIST", ".", "equals", "(", "entry", ".", "getValue", "(", ")", ".", "valueType", "(", ")", ")", ")", "{", "List", "<", "String", ">", "rawValueList", "=", "resolvedConfig", ".", "getStringList", "(", "entry", ".", "getKey", "(", ")", ")", ";", "List", "<", "String", ">", "resolvedValueList", "=", "Lists", ".", "newArrayList", "(", ")", ";", "for", "(", "String", "rawValue", ":", "rawValueList", ")", "{", "String", "resolvedValue", "=", "StringUtils", ".", "replaceEach", "(", "rawValue", ",", "new", "String", "[", "]", "{", "DATABASE_TOKEN", ",", "TABLE_TOKEN", ",", "LOGICAL_DB_TOKEN", ",", "LOGICAL_TABLE_TOKEN", "}", ",", "new", "String", "[", "]", "{", "realDbAndTable", ".", "getDb", "(", ")", ",", "realDbAndTable", ".", "getTable", "(", ")", ",", "logicalDbAndTable", ".", "getDb", "(", ")", ",", "logicalDbAndTable", ".", "getTable", "(", ")", "}", ")", ";", "resolvedValueList", ".", "add", "(", "resolvedValue", ")", ";", "}", "StringBuilder", "listToStringWithQuotes", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "String", "resolvedValueStr", ":", "resolvedValueList", ")", "{", "if", "(", "listToStringWithQuotes", ".", "length", "(", ")", ">", "0", ")", "{", "listToStringWithQuotes", ".", "append", "(", "\",\"", ")", ";", "}", "listToStringWithQuotes", ".", "append", "(", "\"\\\"\"", ")", ".", "append", "(", "resolvedValueStr", ")", ".", "append", "(", "\"\\\"\"", ")", ";", "}", "resolvedProperties", ".", "setProperty", "(", "entry", ".", "getKey", "(", ")", ",", "listToStringWithQuotes", ".", "toString", "(", ")", ")", ";", "}", "else", "{", "String", "resolvedValue", "=", "StringUtils", ".", "replaceEach", "(", "resolvedConfig", ".", "getString", "(", "entry", ".", "getKey", "(", ")", ")", ",", "new", "String", "[", "]", "{", "DATABASE_TOKEN", ",", "TABLE_TOKEN", ",", "LOGICAL_DB_TOKEN", ",", "LOGICAL_TABLE_TOKEN", "}", ",", "new", "String", "[", "]", "{", "realDbAndTable", ".", "getDb", "(", ")", ",", "realDbAndTable", ".", "getTable", "(", ")", ",", "logicalDbAndTable", ".", "getDb", "(", ")", ",", "logicalDbAndTable", ".", "getTable", "(", ")", "}", ")", ";", "resolvedProperties", ".", "setProperty", "(", "entry", ".", "getKey", "(", ")", ",", "resolvedValue", ")", ";", "}", "}", "return", "ConfigUtils", ".", "propertiesToConfig", "(", "resolvedProperties", ")", ";", "}" ]

[ "*", "Replace", "various", "tokens", "(", "DB", "TABLE", "LOGICAL_DB", "LOGICAL_TABLE", ")", "with", "their", "values", "." ]

[ "@", "Override", "public", "void", "serializeInstance", "(", "SerializationStreamWriter", "streamWriter", ",", "OWLLiteralImplBoolean", "instance", ")", "throws", "SerializationException", "{", "serialize", "(", "streamWriter", ",", "instance", ")", ";", "}" ]

[ "Serializes", "the", "content", "of", "the", "object", "into", "the", "{" ]

[ "public", "DbxDelta", "<", "DbxEntry", ">", "getDelta", "(", "/*@Nullable*/", "String", "cursor", ",", "boolean", "includeMediaInfo", ")", "throws", "DbxException", "{", "return", "_getDelta", "(", "cursor", ",", "null", ",", "includeMediaInfo", ")", ";", "}" ]

[ "Return", "delta", "entries", "for", "the", "contents", "of", "a", "user", "s", "Dropbox", ".", "This", "lets", "you", "efficiently", "keep", "up", "with", "the", "latest", "state", "of", "the", "files", "and", "folders", ".", "See", "{", "@link", "DbxDelta", "}", "for", "more", "documentation", "on", "what", "each", "entry", "means", "." ]

[ "private", "TreeNode", "setPos", "(", "TreeNode", "newNode", ",", "int", "pos", ",", "int", "endPos", ")", "{", "return", "newNode", ".", "setPosition", "(", "new", "SourcePosition", "(", "pos", ",", "endPos", "-", "pos", ",", "lineNumber", "(", "pos", ")", ")", ")", ";", "}" ]

[ "Set", "a", "TreeNode", "s", "position", "using", "begin", "and", "end", "source", "offsets", ".", "Its", "line", "number", "is", "unchanged", "." ]

[ "Table", "SYSTEM_VERSIONCOLUMNS", "(", ")", "{", "Table", "t", "=", "sysTables", "[", "SYSTEM_VERSIONCOLUMNS", "]", ";", "if", "(", "t", "==", "null", ")", "{", "t", "=", "createBlankTable", "(", "sysTableHsqlNames", "[", "SYSTEM_VERSIONCOLUMNS", "]", ")", ";", "// ----------------------------------------------------------------", "// required by DatabaseMetaData.getVersionColumns result set", "// ----------------------------------------------------------------", "addColumn", "(", "t", ",", "\"SCOPE\"", ",", "Type", ".", "SQL_INTEGER", ")", ";", "addColumn", "(", "t", ",", "\"COLUMN_NAME\"", ",", "SQL_IDENTIFIER", ")", ";", "// not null", "addColumn", "(", "t", ",", "\"DATA_TYPE\"", ",", "Type", ".", "SQL_SMALLINT", ")", ";", "// not null", "addColumn", "(", "t", ",", "\"TYPE_NAME\"", ",", "SQL_IDENTIFIER", ")", ";", "// not null", "addColumn", "(", "t", ",", "\"COLUMN_SIZE\"", ",", "Type", ".", "SQL_SMALLINT", ")", ";", "addColumn", "(", "t", ",", "\"BUFFER_LENGTH\"", ",", "Type", ".", "SQL_INTEGER", ")", ";", "addColumn", "(", "t", ",", "\"DECIMAL_DIGITS\"", ",", "Type", ".", "SQL_SMALLINT", ")", ";", "addColumn", "(", "t", ",", "\"PSEUDO_COLUMN\"", ",", "Type", ".", "SQL_SMALLINT", ")", ";", "// not null", "// -----------------------------------------------------------------", "// required by DatabaseMetaData.getVersionColumns filter parameters", "// -----------------------------------------------------------------", "addColumn", "(", "t", ",", "\"TABLE_CAT\"", ",", "SQL_IDENTIFIER", ")", ";", "addColumn", "(", "t", ",", "\"TABLE_SCHEM\"", ",", "SQL_IDENTIFIER", ")", ";", "addColumn", "(", "t", ",", "\"TABLE_NAME\"", ",", "SQL_IDENTIFIER", ")", ";", "// not null", "// -----------------------------------------------------------------", "HsqlName", "name", "=", "HsqlNameManager", ".", "newInfoSchemaObjectName", "(", "sysTableHsqlNames", "[", "SYSTEM_VERSIONCOLUMNS", "]", ".", "name", ",", "false", ",", "SchemaObject", ".", "INDEX", ")", ";", "t", ".", "createPrimaryKey", "(", "name", ",", "null", ",", "false", ")", ";", "return", "t", ";", "}", "return", "t", ";", "}" ]

[ "Retrieves", "a", "<code", ">", "Table<", "/", "code", ">", "object", "describing", "the", "accessible", "columns", "that", "are", "automatically", "updated", "when", "any", "value", "in", "a", "row", "is", "updated", ".", "<p", ">" ]

[ "public", "static", "<", "T", ">", "ToLongFunction", "<", "T", ">", "toLongFunction", "(", "CheckedToLongFunction", "<", "T", ">", "function", ",", "Consumer", "<", "Throwable", ">", "handler", ")", "{", "return", "t", "->", "{", "try", "{", "return", "function", ".", "applyAsLong", "(", "t", ")", ";", "}", "catch", "(", "Throwable", "e", ")", "{", "handler", ".", "accept", "(", "e", ")", ";", "throw", "new", "IllegalStateException", "(", "\"Exception handler must throw a RuntimeException\"", ",", "e", ")", ";", "}", "}", ";", "}" ]

[ "Wrap", "a", "{", "@link", "CheckedToLongFunction", "}", "in", "a", "{", "@link", "ToLongFunction", "}", "with", "a", "custom", "handler", "for", "checked", "exceptions", ".", "<p", ">", "Example", ":", "<code", ">", "<pre", ">", "map", ".", "forEach", "(", "Unchecked", ".", "toLongFunction", "(", "k", "-", ">", "{", "if", "(", "k", ".", "length", "()", ">", "10", ")", "throw", "new", "Exception", "(", "Only", "short", "strings", "allowed", ")", ";" ]

[ "private", "static", "Point", "getScreenSize", "(", "Context", "context", ",", "Point", "p", ")", "{", "if", "(", "p", "==", "null", ")", "{", "p", "=", "new", "Point", "(", ")", ";", "}", "WindowManager", "windowManager", "=", "(", "WindowManager", ")", "context", ".", "getSystemService", "(", "Context", ".", "WINDOW_SERVICE", ")", ";", "Display", "display", "=", "windowManager", ".", "getDefaultDisplay", "(", ")", ";", "display", ".", "getSize", "(", "p", ")", ";", "return", "p", ";", "}" ]

[ "Returns", "screen", "height", "and", "width" ]

[ "public", "static", "<", "T", ",", "V", "extends", "Comparable", "<", "T", ">", ">", "V", "inclusiveBetween", "(", "final", "T", "start", ",", "final", "T", "end", ",", "final", "V", "value", ")", "{", "return", "INSTANCE", ".", "inclusiveBetween", "(", "start", ",", "end", ",", "value", ")", ";", "}" ]

[ "<p", ">", "Validate", "that", "the", "specified", "argument", "object", "fall", "between", "the", "two", "inclusive", "values", "specified", ";", "otherwise", "throws", "an", "exception", ".", "<", "/", "p", ">", "<pre", ">", "Validate", ".", "inclusiveBetween", "(", "0", "2", "1", ")", ";", "<", "/", "pre", ">" ]

[ "public", "static", "<", "T", ">", "T", "getService", "(", "String", "name", ",", "Class", "<", "T", ">", "clazz", ")", "throws", "NamingException", "{", "Object", "object", "=", "SingletonHolder", ".", "locator", ".", "context", ".", "lookup", "(", "name", ")", ";", "if", "(", "object", "!=", "null", ")", "{", "return", "clazz", ".", "cast", "(", "object", ")", ";", "}", "return", "null", ";", "}" ]

[ "Locates", "a", "service", "given", "its", "JNDI", "name", "and", "automatically", "casts", "its", "reference", "to", "the", "appropriate", "class", "as", "specified", "by", "the", "caller", "." ]

[ "private", "synchronized", "void", "finishTransition", "(", "final", "InternalState", "current", ",", "final", "InternalState", "next", ")", "{", "internalSetState", "(", "getTransitionTask", "(", "next", ")", ",", "current", ",", "next", ")", ";", "transition", "(", ")", ";", "}" ]

[ "Finish", "a", "state", "transition", "from", "a", "notification", "." ]

[ "private", "CacheKeyTO", "getCacheKey", "(", "CacheAopProxyChain", "pjp", ",", "Object", "[", "]", "arguments", ",", "ExCache", "exCache", ",", "Object", "result", ")", "{", "Object", "target", "=", "pjp", ".", "getTarget", "(", ")", ";", "String", "methodName", "=", "pjp", ".", "getMethod", "(", ")", ".", "getName", "(", ")", ";", "String", "keyExpression", "=", "exCache", ".", "key", "(", ")", ";", "if", "(", "null", "==", "keyExpression", "||", "keyExpression", ".", "trim", "(", ")", ".", "length", "(", ")", "==", "0", ")", "{", "return", "null", ";", "}", "String", "hfieldExpression", "=", "exCache", ".", "hfield", "(", ")", ";", "return", "getCacheKey", "(", "target", ",", "methodName", ",", "arguments", ",", "keyExpression", ",", "hfieldExpression", ",", "result", ",", "true", ")", ";", "}" ]

[ "生成缓存", "Key" ]

[ "public", "static", "String", "uriEncode", "(", "String", "value", ",", "boolean", "encodeSlash", ")", "{", "try", "{", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "byte", "b", ":", "value", ".", "getBytes", "(", "AipClientConst", ".", "DEFAULT_ENCODING", ")", ")", "{", "if", "(", "URI_UNRESERVED_CHARACTERS", ".", "get", "(", "b", "&", "0xFF", ")", ")", "{", "builder", ".", "append", "(", "(", "char", ")", "b", ")", ";", "}", "else", "{", "builder", ".", "append", "(", "PERCENT_ENCODED_STRINGS", "[", "b", "&", "0xFF", "]", ")", ";", "}", "}", "String", "encodeString", "=", "builder", ".", "toString", "(", ")", ";", "if", "(", "!", "encodeSlash", ")", "{", "return", "encodeString", ".", "replace", "(", "\"%2F\"", ",", "\"/\"", ")", ";", "}", "return", "encodeString", ";", "}", "catch", "(", "UnsupportedEncodingException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Normalize", "a", "string", "for", "use", "in", "BCE", "web", "service", "APIs", ".", "The", "normalization", "algorithm", "is", ":", "<ol", ">", "<li", ">", "Convert", "the", "string", "into", "a", "UTF", "-", "8", "byte", "array", ".", "<", "/", "li", ">", "<li", ">", "Encode", "all", "octets", "into", "percent", "-", "encoding", "except", "all", "URI", "unreserved", "characters", "per", "the", "RFC", "3986", ".", "<", "/", "li", ">", "<", "/", "ol", ">" ]

[ "public", "OrganizationModel", "attachOrganization", "(", "ArchiveModel", "archiveModel", ",", "String", "organizationName", ")", "{", "OrganizationModel", "model", "=", "getUnique", "(", "getQuery", "(", ")", ".", "traverse", "(", "g", "->", "g", ".", "has", "(", "OrganizationModel", ".", "NAME", ",", "organizationName", ")", ")", ".", "getRawTraversal", "(", ")", ")", ";", "if", "(", "model", "==", "null", ")", "{", "model", "=", "create", "(", ")", ";", "model", ".", "setName", "(", "organizationName", ")", ";", "model", ".", "addArchiveModel", "(", "archiveModel", ")", ";", "}", "else", "{", "return", "attachOrganization", "(", "model", ",", "archiveModel", ")", ";", "}", "return", "model", ";", "}" ]

[ "Attach", "a", "{" ]

[ "public", "<", "T", ">", "T", "actorFor", "(", "final", "Class", "<", "T", ">", "protocol", ",", "final", "Definition", "definition", ")", "{", "return", "actorFor", "(", "protocol", ",", "definition", ",", "definition", ".", "parentOr", "(", "world", ".", "defaultParent", "(", ")", ")", ",", "definition", ".", "supervisor", "(", ")", ",", "definition", ".", "loggerOr", "(", "world", ".", "defaultLogger", "(", ")", ")", ")", ";", "}" ]

[ "Answers", "the", "{" ]

[ "public", "static", "void", "gracefulShutdown", "(", "long", "timeout", ",", "TimeUnit", "unit", ",", "ExecutorService", "...", "executorServices", ")", "{", "for", "(", "ExecutorService", "executorService", ":", "executorServices", ")", "{", "executorService", ".", "shutdown", "(", ")", ";", "}", "boolean", "wasInterrupted", "=", "false", ";", "final", "long", "endTime", "=", "unit", ".", "toMillis", "(", "timeout", ")", "+", "System", ".", "currentTimeMillis", "(", ")", ";", "long", "timeLeft", "=", "unit", ".", "toMillis", "(", "timeout", ")", ";", "boolean", "hasTimeLeft", "=", "timeLeft", ">", "0L", ";", "for", "(", "ExecutorService", "executorService", ":", "executorServices", ")", "{", "if", "(", "wasInterrupted", "||", "!", "hasTimeLeft", ")", "{", "executorService", ".", "shutdownNow", "(", ")", ";", "}", "else", "{", "try", "{", "if", "(", "!", "executorService", ".", "awaitTermination", "(", "timeLeft", ",", "TimeUnit", ".", "MILLISECONDS", ")", ")", "{", "LOG", ".", "warn", "(", "\"ExecutorService did not terminate in time. Shutting it down now.\"", ")", ";", "executorService", ".", "shutdownNow", "(", ")", ";", "}", "}", "catch", "(", "InterruptedException", "e", ")", "{", "LOG", ".", "warn", "(", "\"Interrupted while shutting down executor services. Shutting all \"", "+", "\"remaining ExecutorServices down now.\"", ",", "e", ")", ";", "executorService", ".", "shutdownNow", "(", ")", ";", "wasInterrupted", "=", "true", ";", "Thread", ".", "currentThread", "(", ")", ".", "interrupt", "(", ")", ";", "}", "timeLeft", "=", "endTime", "-", "System", ".", "currentTimeMillis", "(", ")", ";", "hasTimeLeft", "=", "timeLeft", ">", "0L", ";", "}", "}", "}" ]

[ "Gracefully", "shutdown", "the", "given", "{", "@link", "ExecutorService", "}", ".", "The", "call", "waits", "the", "given", "timeout", "that", "all", "ExecutorServices", "terminate", ".", "If", "the", "ExecutorServices", "do", "not", "terminate", "in", "this", "time", "they", "will", "be", "shut", "down", "hard", "." ]

[ "public", "Collection", "<", "SingularityPendingRequest", ">", "getPendingSingularityRequests", "(", ")", "{", "final", "Function", "<", "String", ",", "String", ">", "requestUri", "=", "(", "host", ")", "-", ">", "String", ".", "format", "(", "REQUESTS_GET_PENDING_FORMAT", ",", "getApiBase", "(", "host", ")", ")", ";", "return", "getCollection", "(", "requestUri", ",", "\"pending requests\"", ",", "PENDING_REQUESTS_COLLECTION", ")", ";", "}" ]

[ "Get", "all", "requests", "that", "are", "pending", "to", "become", "ACTIVE" ]

[ "private", "void", "waitForLastTxIdNode", "(", "AvatarZooKeeperClient", "zk", ",", "Configuration", "conf", ")", "throws", "Exception", "{", "// Gather session id and transaction id data.", "String", "address", "=", "conf", ".", "get", "(", "NameNode", ".", "DFS_NAMENODE_RPC_ADDRESS_KEY", ")", ";", "long", "maxWaitTime", "=", "this", ".", "getMaxWaitTimeForWaitTxid", "(", ")", ";", "long", "start", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "while", "(", "true", ")", "{", "if", "(", "System", ".", "currentTimeMillis", "(", ")", "-", "start", ">", "maxWaitTime", ")", "{", "throw", "new", "IOException", "(", "\"No valid last txid znode found\"", ")", ";", "}", "try", "{", "long", "sessionId", "=", "zk", ".", "getPrimarySsId", "(", "address", ",", "false", ")", ";", "ZookeeperTxId", "zkTxId", "=", "zk", ".", "getPrimaryLastTxId", "(", "address", ",", "false", ")", ";", "if", "(", "sessionId", "!=", "zkTxId", ".", "getSessionId", "(", ")", ")", "{", "LOG", ".", "warn", "(", "\"Session Id in the ssid node : \"", "+", "sessionId", "+", "\" does not match the session Id in the txid node : \"", "+", "zkTxId", ".", "getSessionId", "(", ")", "+", "\" retrying...\"", ")", ";", "Thread", ".", "sleep", "(", "retrySleep", ")", ";", "continue", ";", "}", "}", "catch", "(", "Throwable", "e", ")", "{", "LOG", ".", "warn", "(", "\"Caught exception : \"", "+", "e", "+", "\" retrying ...\"", ")", ";", "Thread", ".", "sleep", "(", "retrySleep", ")", ";", "continue", ";", "}", "break", ";", "}", "}" ]

[ "Waits", "till", "the", "last", "txid", "node", "appears", "in", "Zookeeper", "such", "that", "it", "matches", "the", "ssid", "node", "." ]

[ "public", "static", "double", "getDistanceBetween", "(", "IHMConnection", "connection", ",", "Coordinate", "p1", ",", "Coordinate", "p2", ",", "int", "srid", ")", "throws", "Exception", "{", "if", "(", "srid", "<", "0", ")", "{", "srid", "=", "4326", ";", "}", "GeometryFactory", "gf", "=", "new", "GeometryFactory", "(", ")", ";", "LineString", "lineString", "=", "gf", ".", "createLineString", "(", "new", "Coordinate", "[", "]", "{", "p1", ",", "p2", "}", ")", ";", "String", "sql", "=", "\"select GeodesicLength(LineFromText(\\\"\"", "+", "lineString", ".", "toText", "(", ")", "+", "\"\\\",\"", "+", "srid", "+", "\"));\"", ";", "try", "(", "IHMStatement", "stmt", "=", "connection", ".", "createStatement", "(", ")", ";", "IHMResultSet", "rs", "=", "stmt", ".", "executeQuery", "(", "sql", ")", ";", ")", "{", "if", "(", "rs", ".", "next", "(", ")", ")", "{", "double", "length", "=", "rs", ".", "getDouble", "(", "1", ")", ";", "return", "length", ";", "}", "throw", "new", "RuntimeException", "(", "\"Could not calculate distance.\"", ")", ";", "}", "}" ]

[ "Calculates", "the", "GeodesicLength", "between", "to", "points", "." ]

[ "public", "static", "float", "intersectRayPlane", "(", "Vector3fc", "origin", ",", "Vector3fc", "dir", ",", "Vector3fc", "point", ",", "Vector3fc", "normal", ",", "float", "epsilon", ")", "{", "return", "intersectRayPlane", "(", "origin", ".", "x", "(", ")", ",", "origin", ".", "y", "(", ")", ",", "origin", ".", "z", "(", ")", ",", "dir", ".", "x", "(", ")", ",", "dir", ".", "y", "(", ")", ",", "dir", ".", "z", "(", ")", ",", "point", ".", "x", "(", ")", ",", "point", ".", "y", "(", ")", ",", "point", ".", "z", "(", ")", ",", "normal", ".", "x", "(", ")", ",", "normal", ".", "y", "(", ")", ",", "normal", ".", "z", "(", ")", ",", "epsilon", ")", ";", "}" ]

[ "Test", "whether", "the", "ray", "with", "given", "<code", ">", "origin<", "/", "code", ">", "and", "direction", "<code", ">", "dir<", "/", "code", ">", "intersects", "the", "plane", "containing", "the", "given", "<code", ">", "point<", "/", "code", ">", "and", "having", "the", "given", "<code", ">", "normal<", "/", "code", ">", "and", "return", "the", "value", "of", "the", "parameter", "<i", ">", "t<", "/", "i", ">", "in", "the", "ray", "equation", "<i", ">", "p", "(", "t", ")", "=", "origin", "+", "t", "*", "dir<", "/", "i", ">", "of", "the", "intersection", "point", ".", "<p", ">", "This", "method", "returns", "<code", ">", "-", "1", ".", "0<", "/", "code", ">", "if", "the", "ray", "does", "not", "intersect", "the", "plane", "because", "it", "is", "either", "parallel", "to", "the", "plane", "or", "its", "direction", "points", "away", "from", "the", "plane", "or", "the", "ray", "s", "origin", "is", "on", "the", "<i", ">", "negative<", "/", "i", ">", "side", "of", "the", "plane", "(", "i", ".", "e", ".", "the", "plane", "s", "normal", "points", "away", "from", "the", "ray", "s", "origin", ")", ".", "<p", ">", "Reference", ":", "<a", "href", "=", "https", ":", "//", "www", ".", "siggraph", ".", "org", "/", "education", "/", "materials", "/", "HyperGraph", "/", "raytrace", "/", "rayplane_intersection", ".", "htm", ">", "https", ":", "//", "www", ".", "siggraph", ".", "org", "/", "<", "/", "a", ">" ]

[ "private", "boolean", "kernelMatch", "(", "Point", "p", ",", "int", "[", "]", "[", "]", "pixels", ",", "int", "w", ",", "int", "h", ",", "int", "[", "]", "kernel", ")", "{", "int", "matched", "=", "0", ";", "for", "(", "int", "j", "=", "-", "1", ";", "j", "<", "2", ";", "++", "j", ")", "{", "for", "(", "int", "i", "=", "-", "1", ";", "i", "<", "2", ";", "++", "i", ")", "{", "if", "(", "kernel", "[", "(", "(", "j", "+", "1", ")", "*", "3", ")", "+", "(", "i", "+", "1", ")", "]", "==", "2", ")", "{", "++", "matched", ";", "}", "else", "if", "(", "(", "p", ".", "x", "+", "i", ">=", "0", ")", "&&", "(", "p", ".", "x", "+", "i", "<", "w", ")", "&&", "(", "p", ".", "y", "+", "j", ">=", "0", ")", "&&", "(", "p", ".", "y", "+", "j", "<", "h", ")", "&&", "(", "(", "(", "pixels", "[", "p", ".", "x", "+", "i", "]", "[", "p", ".", "y", "+", "j", "]", "==", "BinaryFast", ".", "FOREGROUND", ")", "&&", "(", "kernel", "[", "(", "(", "j", "+", "1", ")", "*", "3", ")", "+", "(", "i", "+", "1", ")", "]", "==", "1", ")", ")", "||", "(", "(", "pixels", "[", "p", ".", "x", "+", "i", "]", "[", "p", ".", "y", "+", "j", "]", "==", "BinaryFast", ".", "BACKGROUND", ")", "&&", "(", "kernel", "[", "(", "(", "j", "+", "1", ")", "*", "3", ")", "+", "(", "i", "+", "1", ")", "]", "==", "0", ")", ")", ")", ")", "{", "++", "matched", ";", "}", "}", "}", "if", "(", "matched", "==", "9", ")", "{", "return", "true", ";", "}", "else", "return", "false", ";", "}" ]

[ "Returns", "true", "if", "the", "8", "neighbours", "of", "p", "match", "the", "kernel", "0", "is", "background", "1", "is", "foreground", "2", "is", "don", "t", "care", "." ]

[ "private", "static", "StartupEntry", "readFile", "(", "String", "filename", ",", "String", "context", ",", "MessageHandler", "mh", ")", "{", "if", "(", "filename", "!=", "null", ")", "{", "try", "{", "byte", "[", "]", "encoded", "=", "Files", ".", "readAllBytes", "(", "toPathResolvingUserHome", "(", "filename", ")", ")", ";", "return", "new", "StartupEntry", "(", "false", ",", "filename", ",", "new", "String", "(", "encoded", ")", ",", "LocalDateTime", ".", "now", "(", ")", ".", "format", "(", "DateTimeFormatter", ".", "ofLocalizedDateTime", "(", "FormatStyle", ".", "MEDIUM", ")", ")", ")", ";", "}", "catch", "(", "AccessDeniedException", "e", ")", "{", "mh", ".", "errormsg", "(", "\"jshell.err.file.not.accessible\"", ",", "context", ",", "filename", ",", "e", ".", "getMessage", "(", ")", ")", ";", "}", "catch", "(", "NoSuchFileException", "e", ")", "{", "String", "resource", "=", "getResource", "(", "filename", ")", ";", "if", "(", "resource", "!=", "null", ")", "{", "// Not found as file, but found as resource", "return", "new", "StartupEntry", "(", "true", ",", "filename", ",", "resource", ")", ";", "}", "mh", ".", "errormsg", "(", "\"jshell.err.file.not.found\"", ",", "context", ",", "filename", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "mh", ".", "errormsg", "(", "\"jshell.err.file.exception\"", ",", "context", ",", "filename", ",", "e", ")", ";", "}", "}", "else", "{", "mh", ".", "errormsg", "(", "\"jshell.err.file.filename\"", ",", "context", ")", ";", "}", "return", "null", ";", "}" ]

[ "Read", "a", "external", "file", "or", "a", "resource", "." ]

[ "public", "static", "Integer", "strToInt", "(", "String", "_str", ",", "Integer", "_default", ")", "{", "if", "(", "_str", "==", "null", ")", "{", "return", "_default", ";", "}", "if", "(", "TypeUtil", ".", "isInteger", "(", "_str", ",", "true", ")", ")", "{", "return", "Integer", ".", "valueOf", "(", "_str", ")", ";", "}", "else", "{", "return", "_default", ";", "}", "}" ]

[ "Convert", "given", "String", "to", "Integer", "returns", "_default", "if", "String", "is", "not", "an", "integer", "." ]

[ "public", "int", "getDigestOffset", "(", "int", "algorithm", ",", "byte", "[", "]", "handshake", ",", "int", "bufferOffset", ")", "{", "switch", "(", "algorithm", ")", "{", "case", "1", ":", "return", "getDigestOffset2", "(", "handshake", ",", "bufferOffset", ")", ";", "default", ":", "case", "0", ":", "return", "getDigestOffset1", "(", "handshake", ",", "bufferOffset", ")", ";", "}", "}" ]

[ "Returns", "the", "digest", "offset", "using", "current", "validation", "scheme", "." ]

[ "public", "void", "setSafariBuiltinFavorites", "(", ")", "{", "File", "[", "]", "files", "=", "app", ".", "listFiles", "(", "new", "FilenameFilter", "(", ")", "{", "@", "Override", "public", "boolean", "accept", "(", "File", "dir", ",", "String", "name", ")", "{", "return", "name", ".", "startsWith", "(", "\"BuiltinFavorites\"", ")", "&&", "name", ".", "endsWith", "(", "\".plist\"", ")", ";", "}", "}", ")", ";", "for", "(", "File", "plist", ":", "files", ")", "{", "setSafariBuiltinFavories", "(", "plist", ")", ";", "}", "}" ]

[ "Modifies", "the", "BuiltinFavorites", "....", "plist", "in", "safariCopies", "/", "safari", ".", "app", "to", "contain", "only", "about", ":", "blank" ]

[ "public", "CreateChannelRequest", "withTags", "(", "java", ".", "util", ".", "Map", "<", "String", ",", "String", ">", "tags", ")", "{", "setTags", "(", "tags", ")", ";", "return", "this", ";", "}" ]

[ "A", "collection", "of", "key", "-", "value", "pairs", "." ]

[ "public", "static", "Color", "rgbToColorConverter", "(", "final", "String", "value", ")", "{", "if", "(", "StringUtils", ".", "isEmpty", "(", "value", ")", "||", "(", "!", "StringUtils", ".", "isEmpty", "(", "value", ")", "&&", "!", "value", ".", "startsWith", "(", "\"rgb\"", ")", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"String to convert is empty or of invalid format - value: '\"", "+", "value", "+", "\"'\"", ")", ";", "}", "// RGB color format rgb/rgba(255,255,255,0.1)", "final", "String", "[", "]", "colors", "=", "value", ".", "substring", "(", "value", ".", "indexOf", "(", "'", "'", ")", "+", "1", ",", "value", ".", "length", "(", ")", "-", "1", ")", ".", "split", "(", "\",\"", ")", ";", "final", "int", "red", "=", "Integer", ".", "parseInt", "(", "colors", "[", "0", "]", ")", ";", "final", "int", "green", "=", "Integer", ".", "parseInt", "(", "colors", "[", "1", "]", ")", ";", "final", "int", "blue", "=", "Integer", ".", "parseInt", "(", "colors", "[", "2", "]", ")", ";", "if", "(", "colors", ".", "length", ">", "3", ")", "{", "final", "int", "alpha", "=", "(", "int", ")", "(", "Double", ".", "parseDouble", "(", "colors", "[", "3", "]", ")", "*", "255D", ")", ";", "return", "new", "Color", "(", "red", ",", "green", ",", "blue", ",", "alpha", ")", ";", "}", "return", "new", "Color", "(", "red", ",", "green", ",", "blue", ")", ";", "}" ]

[ "Covert", "RGB", "code", "to", "{", "@link", "Color", "}", "." ]

[ "private", "void", "processQualityCCScore", "(", "ScoreComponentSettings", "qualityCCSettings", ",", "Iterable", "<", "CodeQuality", ">", "codeQualityIterable", ",", "List", "<", "ScoreWeight", ">", "categoryScores", ")", "{", "ScoreWeight", "qualityCCScore", "=", "getCategoryScoreByIdName", "(", "categoryScores", ",", "WIDGET_QUALITY_CC_ID_NAME", ")", ";", "Double", "qualityCCRatio", "=", "fetchQualityValue", "(", "codeQualityIterable", ",", "QUALITY_PARAM_CC", ")", ";", "if", "(", "null", "==", "qualityCCRatio", ")", "{", "qualityCCScore", ".", "setScore", "(", "qualityCCSettings", ".", "getCriteria", "(", ")", ".", "getNoDataFound", "(", ")", ")", ";", "qualityCCScore", ".", "setMessage", "(", "Constants", ".", "SCORE_ERROR_NO_DATA_FOUND", ")", ";", "qualityCCScore", ".", "setState", "(", "ScoreWeight", ".", "ProcessingState", ".", "criteria_failed", ")", ";", "}", "else", "{", "try", "{", "//Check thresholds at widget level", "checkPercentThresholds", "(", "qualityCCSettings", ",", "qualityCCRatio", ")", ";", "qualityCCScore", ".", "setScore", "(", "new", "ScoreTypeValue", "(", "qualityCCRatio", ")", ")", ";", "qualityCCScore", ".", "setState", "(", "ScoreWeight", ".", "ProcessingState", ".", "complete", ")", ";", "}", "catch", "(", "ThresholdException", "ex", ")", "{", "setThresholdFailureWeight", "(", "ex", ",", "qualityCCScore", ")", ";", "}", "}", "}" ]

[ "Process", "Code", "Coverage", "score" ]

[ "public", "static", "void", "isNotGreaterThan", "(", "int", "argument", ",", "int", "notGreaterThanValue", ",", "String", "name", ")", "{", "if", "(", "argument", ">", "notGreaterThanValue", ")", "{", "throw", "new", "IllegalArgumentException", "(", "CommonI18n", ".", "argumentMayNotBeGreaterThan", ".", "text", "(", "name", ",", "argument", ",", "notGreaterThanValue", ")", ")", ";", "}", "}" ]

[ "Check", "that", "the", "argument", "is", "not", "greater", "than", "the", "supplied", "value" ]

[ "public", "SecurityGroupViewResultInner", "getVMSecurityRules", "(", "String", "resourceGroupName", ",", "String", "networkWatcherName", ",", "String", "targetResourceId", ")", "{", "return", "getVMSecurityRulesWithServiceResponseAsync", "(", "resourceGroupName", ",", "networkWatcherName", ",", "targetResourceId", ")", ".", "toBlocking", "(", ")", ".", "last", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Gets", "the", "configured", "and", "effective", "security", "group", "rules", "on", "the", "specified", "VM", "." ]

[ "public", "Observable", "<", "PublicIPAddressInner", ">", "beginUpdateTagsAsync", "(", "String", "resourceGroupName", ",", "String", "publicIpAddressName", ")", "{", "return", "beginUpdateTagsWithServiceResponseAsync", "(", "resourceGroupName", ",", "publicIpAddressName", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "PublicIPAddressInner", ">", ",", "PublicIPAddressInner", ">", "(", ")", "{", "@", "Override", "public", "PublicIPAddressInner", "call", "(", "ServiceResponse", "<", "PublicIPAddressInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Updates", "public", "IP", "address", "tags", "." ]

[ "private", "static", "void", "failFastOnInitCheck", "(", "EurekaClientConfig", "clientConfig", ",", "String", "msg", ")", "{", "if", "(", "\"true\"", ".", "equals", "(", "clientConfig", ".", "getExperimental", "(", "\"clientTransportFailFastOnInit\"", ")", ")", ")", "{", "throw", "new", "RuntimeException", "(", "msg", ")", ";", "}", "}" ]

[ "potential", "future", "feature", "guarding", "with", "experimental", "flag", "for", "now" ]

[ "public", "JSONObject", "getTaskInfo", "(", "int", "id", ",", "HashMap", "<", "String", ",", "String", ">", "options", ")", "{", "AipRequest", "request", "=", "new", "AipRequest", "(", ")", ";", "preOperation", "(", "request", ")", ";", "request", ".", "addBody", "(", "\"id\"", ",", "id", ")", ";", "if", "(", "options", "!=", "null", ")", "{", "request", ".", "addBody", "(", "options", ")", ";", "}", "request", ".", "setUri", "(", "KnowledgeGraphicConsts", ".", "TASK_INFO", ")", ";", "postOperation", "(", "request", ")", ";", "return", "requestServer", "(", "request", ")", ";", "}" ]

[ "获取任务详情接口", "根据任务id获取单个任务的详细信息" ]

[ "public", "static", "Pattern", "reactsWith", "(", "Blacklist", "blacklist", ")", "{", "Pattern", "p", "=", "new", "Pattern", "(", "SmallMoleculeReference", ".", "class", ",", "\"SMR1\"", ")", ";", "p", ".", "add", "(", "erToPE", "(", ")", ",", "\"SMR1\"", ",", "\"SPE1\"", ")", ";", "p", ".", "add", "(", "notGeneric", "(", ")", ",", "\"SPE1\"", ")", ";", "p", ".", "add", "(", "linkToComplex", "(", "blacklist", ")", ",", "\"SPE1\"", ",", "\"PE1\"", ")", ";", "p", ".", "add", "(", "new", "ParticipatesInConv", "(", "RelType", ".", "INPUT", ",", "blacklist", ")", ",", "\"PE1\"", ",", "\"Conv\"", ")", ";", "p", ".", "add", "(", "type", "(", "BiochemicalReaction", ".", "class", ")", ",", "\"Conv\"", ")", ";", "p", ".", "add", "(", "new", "InterToPartER", "(", "InterToPartER", ".", "Direction", ".", "ONESIDERS", ")", ",", "\"Conv\"", ",", "\"SMR1\"", ")", ";", "p", ".", "add", "(", "new", "ConversionSide", "(", "ConversionSide", ".", "Type", ".", "SAME_SIDE", ",", "blacklist", ",", "RelType", ".", "INPUT", ")", ",", "\"PE1\"", ",", "\"Conv\"", ",", "\"PE2\"", ")", ";", "p", ".", "add", "(", "type", "(", "SmallMolecule", ".", "class", ")", ",", "\"PE2\"", ")", ";", "p", ".", "add", "(", "linkToSpecific", "(", ")", ",", "\"PE2\"", ",", "\"SPE2\"", ")", ";", "p", ".", "add", "(", "notGeneric", "(", ")", ",", "\"SPE2\"", ")", ";", "p", ".", "add", "(", "new", "PEChainsIntersect", "(", "false", ")", ",", "\"SPE1\"", ",", "\"PE1\"", ",", "\"SPE2\"", ",", "\"PE2\"", ")", ";", "p", ".", "add", "(", "peToER", "(", ")", ",", "\"SPE2\"", ",", "\"SMR2\"", ")", ";", "p", ".", "add", "(", "equal", "(", "false", ")", ",", "\"SMR1\"", ",", "\"SMR2\"", ")", ";", "p", ".", "add", "(", "new", "InterToPartER", "(", "InterToPartER", ".", "Direction", ".", "ONESIDERS", ")", ",", "\"Conv\"", ",", "\"SMR2\"", ")", ";", "return", "p", ";", "}" ]

[ "Constructs", "a", "pattern", "where", "first", "and", "last", "small", "molecules", "are", "substrates", "to", "the", "same", "biochemical", "reaction", "." ]

[ "public", "static", "void", "addAdditionalNamenodesToProps", "(", "Props", "props", ",", "String", "additionalNamenodes", ")", "{", "String", "otherNamenodes", "=", "props", ".", "get", "(", "OTHER_NAMENODES_PROPERTY", ")", ";", "if", "(", "otherNamenodes", "!=", "null", "&&", "otherNamenodes", ".", "length", "(", ")", ">", "0", ")", "{", "props", ".", "put", "(", "OTHER_NAMENODES_PROPERTY", ",", "otherNamenodes", "+", "\",\"", "+", "additionalNamenodes", ")", ";", "}", "else", "{", "props", ".", "put", "(", "OTHER_NAMENODES_PROPERTY", ",", "additionalNamenodes", ")", ";", "}", "}" ]

[ "Takes", "the", "list", "of", "other", "Namenodes", "from", "which", "to", "fetch", "delegation", "tokens", "the", "{", "@link", "#OTHER_NAMENODES_PROPERTY", "}", "property", "from", "Props", "and", "inserts", "it", "back", "with", "the", "addition", "of", "the", "the", "potentially", "JobType", "-", "specific", "Namenode", "URIs", "from", "additionalNamenodes", ".", "Modifies", "props", "in", "-", "place", "." ]

[ "public", "ReturnCode", "introspectServer", "(", "String", "dumpTimestamp", ",", "Set", "<", "JavaDumpAction", ">", "javaDumpActions", ")", "{", "// Since \"server dump\" is used for diagnostics, we go out of our way to", "// not send an unrecognized command to the server even if the user has", "// broken their environment such that the client process supports java", "// dumps but the server doesn't.", "String", "command", ";", "if", "(", "javaDumpActions", ".", "isEmpty", "(", ")", ")", "{", "command", "=", "INTROSPECT_COMMAND", "+", "DELIM", "+", "dumpTimestamp", ";", "}", "else", "{", "StringBuilder", "commandBuilder", "=", "new", "StringBuilder", "(", ")", ".", "append", "(", "INTROSPECT_JAVADUMP_COMMAND", ")", ".", "append", "(", "DELIM", ")", ".", "append", "(", "dumpTimestamp", ")", ";", "for", "(", "JavaDumpAction", "javaDumpAction", ":", "javaDumpActions", ")", "{", "commandBuilder", ".", "append", "(", "'", "'", ")", ".", "append", "(", "javaDumpAction", ".", "name", "(", ")", ")", ";", "}", "command", "=", "commandBuilder", ".", "toString", "(", ")", ";", "}", "return", "write", "(", "command", ",", "ReturnCode", ".", "DUMP_ACTION", ",", "ReturnCode", ".", "ERROR_SERVER_DUMP", ")", ";", "}" ]

[ "Dump", "the", "server", "by", "issuing", "a", "introspect", "instruction", "to", "the", "server", "listener" ]

[ "public", "void", "runHandler", "(", "OrtcClient", "sender", ",", "String", "channel", ",", "String", "message", ")", "{", "this", ".", "runHandler", "(", "sender", ",", "channel", ",", "message", ",", "false", ",", "null", ")", ";", "}" ]

[ "Fires", "the", "event", "handler", "that", "is", "associated", "the", "subscribed", "channel" ]

[ "public", "void", "dispatchRequest", "(", "HttpRequest", "httpRequest", ")", "throws", "IOException", "{", "for", "(", "HttpRequestHandler", "handler", ":", "handlers", ")", "{", "HttpResponse", "resp", "=", "handler", ".", "handleRequest", "(", "httpRequest", ")", ";", "if", "(", "resp", "!=", "null", ")", "{", "httpRequest", ".", "getSession", "(", ")", ".", "sendResponse", "(", "resp", ")", ";", "return", ";", "}", "}", "if", "(", "!", "hasCapability", "(", "HttpCapability", ".", "THREADEDRESPONSE", ")", ")", "{", "// If it's still here nothing handled it.", "httpRequest", ".", "getSession", "(", ")", ".", "sendResponse", "(", "new", "HttpResponse", "(", "HttpStatus", ".", "NOT_FOUND", ",", "HttpStatus", ".", "NOT_FOUND", ".", "toString", "(", ")", ")", ")", ";", "}", "}" ]

[ "Dispatch", "a", "request", "to", "all", "handlers" ]

[ "public", "Vector3d", "fma", "(", "Vector3dc", "a", ",", "Vector3dc", "b", ")", "{", "return", "fma", "(", "a", ",", "b", ",", "thisOrNew", "(", ")", ")", ";", "}" ]

[ "Add", "the", "component", "-", "wise", "multiplication", "of", "<code", ">", "a", "*", "b<", "/", "code", ">", "to", "this", "vector", "." ]

[ "@", "Deprecated", "public", "static", "String", "encodeRFC2396", "(", "String", "url", ")", "{", "try", "{", "return", "new", "URI", "(", "null", ",", "url", ",", "null", ")", ".", "toASCIIString", "(", ")", ";", "}", "catch", "(", "URISyntaxException", "e", ")", "{", "LOGGER", ".", "log", "(", "Level", ".", "WARNING", ",", "\"Failed to encode {0}\"", ",", "url", ")", ";", "// could this ever happen?", "return", "url", ";", "}", "}" ]

[ "Encodes", "the", "URL", "by", "RFC", "2396", "." ]