Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "BaseTable", "doMakeTable", "(", "Record", "record", ")", "{", "BaseTable", "table", "=", "null", ";", "boolean", "bIsQueryRecord", "=", "record", ".", "isQueryRecord", "(", ")", ";", "if", "(", "m_pDatabase", "==", "null", ")", "{", "try", "{", "this", ".", "open", "(", ")", ";", "}", "catch", "(", "DBException", "ex", ")", "{", "return", "null", ";", "// No database", "}", "}", "if", "(", "bIsQueryRecord", ")", "{", "// Physical Tables cannot process SQL queries, so use QueryTable!", "PassThruTable", "passThruTable", "=", "new", "QueryTable", "(", "this", ",", "record", ")", ";", "passThruTable", ".", "addTable", "(", "record", ".", "getRecordlistAt", "(", "0", ")", ".", "getTable", "(", ")", ")", ";", "return", "passThruTable", ";", "}", "table", "=", "this", ".", "makePhysicalTable", "(", "record", ")", ";", "return", "table", ";", "}" ]

[ "Make", "a", "table", "for", "this", "database", "." ]

[ "public", "static", "CompactDecimalFormat", "getInstance", "(", "Locale", "locale", ",", "CompactStyle", "style", ")", "{", "return", "new", "CompactDecimalFormat", "(", "ULocale", ".", "forLocale", "(", "locale", ")", ",", "style", ")", ";", "}" ]

[ "Create", "a", "CompactDecimalFormat", "appropriate", "for", "a", "locale", ".", "The", "result", "may", "be", "affected", "by", "the", "number", "system", "in", "the", "locale", "such", "as", "ar", "-", "u", "-", "nu", "-", "latn", "." ]

[ "public", "void", "formatTo", "(", "TemporalAccessor", "temporal", ",", "Appendable", "appendable", ")", "{", "Objects", ".", "requireNonNull", "(", "temporal", ",", "\"temporal\"", ")", ";", "Objects", ".", "requireNonNull", "(", "appendable", ",", "\"appendable\"", ")", ";", "try", "{", "DateTimePrintContext", "context", "=", "new", "DateTimePrintContext", "(", "temporal", ",", "this", ")", ";", "if", "(", "appendable", "instanceof", "StringBuilder", ")", "{", "printerParser", ".", "format", "(", "context", ",", "(", "StringBuilder", ")", "appendable", ")", ";", "}", "else", "{", "// buffer output to avoid writing to appendable in case of error", "StringBuilder", "buf", "=", "new", "StringBuilder", "(", "32", ")", ";", "printerParser", ".", "format", "(", "context", ",", "buf", ")", ";", "appendable", ".", "append", "(", "buf", ")", ";", "}", "}", "catch", "(", "IOException", "ex", ")", "{", "throw", "new", "DateTimeException", "(", "ex", ".", "getMessage", "(", ")", ",", "ex", ")", ";", "}", "}" ]

[ "Formats", "a", "date", "-", "time", "object", "to", "an", "{", "@code", "Appendable", "}", "using", "this", "formatter", ".", "<p", ">", "This", "outputs", "the", "formatted", "date", "-", "time", "to", "the", "specified", "destination", ".", "{", "@link", "Appendable", "}", "is", "a", "general", "purpose", "interface", "that", "is", "implemented", "by", "all", "key", "character", "output", "classes", "including", "{", "@code", "StringBuffer", "}", "{", "@code", "StringBuilder", "}", "{", "@code", "PrintStream", "}", "and", "{", "@code", "Writer", "}", ".", "<p", ">", "Although", "{", "@code", "Appendable", "}", "methods", "throw", "an", "{", "@code", "IOException", "}", "this", "method", "does", "not", ".", "Instead", "any", "{", "@code", "IOException", "}", "is", "wrapped", "in", "a", "runtime", "exception", "." ]

[ "public", "ProcessEngineConfiguration", "addWsEndpointAddress", "(", "QName", "endpointName", ",", "URL", "address", ")", "{", "this", ".", "wsOverridenEndpointAddresses", ".", "put", "(", "endpointName", ",", "address", ")", ";", "return", "this", ";", "}" ]

[ "Add", "or", "replace", "the", "address", "of", "the", "given", "web", "-", "service", "endpoint", "with", "the", "given", "value" ]

[ "protected", "void", "tryToUnlock", "(", "CmsObject", "cms", ",", "String", "folderPath", ")", "throws", "CmsException", "{", "// Get path of first ancestor that actually exists", "while", "(", "!", "cms", ".", "existsResource", "(", "folderPath", ")", ")", "{", "folderPath", "=", "CmsResource", ".", "getParentFolder", "(", "folderPath", ")", ";", "}", "CmsResource", "resource", "=", "cms", ".", "readResource", "(", "folderPath", ")", ";", "CmsLock", "lock", "=", "cms", ".", "getLock", "(", "resource", ")", ";", "// we are only interested in locks we can safely unlock, i.e. locks by the current user", "if", "(", "lock", ".", "isOwnedBy", "(", "cms", ".", "getRequestContext", "(", ")", ".", "getCurrentUser", "(", ")", ")", ")", "{", "// walk up the tree until we get to the location from which the lock is inherited", "while", "(", "lock", ".", "isInherited", "(", ")", ")", "{", "folderPath", "=", "CmsResource", ".", "getParentFolder", "(", "folderPath", ")", ";", "resource", "=", "cms", ".", "readResource", "(", "folderPath", ")", ";", "lock", "=", "cms", ".", "getLock", "(", "resource", ")", ";", "}", "cms", ".", "unlockResource", "(", "folderPath", ")", ";", "}", "}" ]

[ "Tries", "to", "remove", "a", "lock", "on", "an", "ancestor", "of", "a", "given", "path", "owned", "by", "the", "current", "user", ".", "<p", ">" ]

[ "public", "boolean", "importFont", "(", "String", "fontNr", ",", "String", "fontName", ",", "String", "fontFamily", ",", "int", "charset", ")", "{", "RtfFont", "rtfFont", "=", "new", "RtfFont", "(", "fontName", ")", ";", "if", "(", "charset", ">=", "0", ")", "rtfFont", ".", "setCharset", "(", "charset", ")", ";", "if", "(", "fontFamily", "!=", "null", "&&", "fontFamily", ".", "length", "(", ")", ">", "0", ")", "rtfFont", ".", "setFamily", "(", "fontFamily", ")", ";", "rtfFont", ".", "setRtfDocument", "(", "this", ".", "rtfDoc", ")", ";", "this", ".", "importFontMapping", ".", "put", "(", "fontNr", ",", "Integer", ".", "toString", "(", "this", ".", "rtfDoc", ".", "getDocumentHeader", "(", ")", ".", "getFontNumber", "(", "rtfFont", ")", ")", ")", ";", "return", "true", ";", "}" ]

[ "Imports", "a", "font", ".", "The", "font", "name", "is", "looked", "up", "in", "the", "RtfDocumentHeader", "and", "then", "the", "mapping", "from", "original", "font", "number", "to", "actual", "font", "number", "is", "added", "." ]

[ "public", "P2SVpnServerConfigurationInner", "createOrUpdate", "(", "String", "resourceGroupName", ",", "String", "virtualWanName", ",", "String", "p2SVpnServerConfigurationName", ",", "P2SVpnServerConfigurationInner", "p2SVpnServerConfigurationParameters", ")", "{", "return", "createOrUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "virtualWanName", ",", "p2SVpnServerConfigurationName", ",", "p2SVpnServerConfigurationParameters", ")", ".", "toBlocking", "(", ")", ".", "last", "(", ")", ".", "body", "(", ")", ";", "}" ]

[ "Creates", "a", "P2SVpnServerConfiguration", "to", "associate", "with", "a", "VirtualWan", "if", "it", "doesn", "t", "exist", "else", "updates", "the", "existing", "P2SVpnServerConfiguration", "." ]

[ "public", "synchronized", "BrowserProxyQueue", "createBrowserProxyQueue", "(", ")", "// F171893", "throws", "SIResourceException", ",", "SIIncorrectCallException", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "tc", ",", "\"createBrowserProxyQueue\"", ")", ";", "// F171893", "checkClosed", "(", ")", ";", "short", "id", "=", "nextId", "(", ")", ";", "BrowserProxyQueue", "proxyQueue", "=", "new", "BrowserProxyQueueImpl", "(", "this", ",", "id", ",", "conversation", ")", ";", "idToProxyQueueMap", ".", "put", "(", "new", "ImmutableId", "(", "id", ")", ",", "proxyQueue", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "tc", ",", "\"createBrowserProxyQueue\"", ",", "proxyQueue", ")", ";", "return", "proxyQueue", ";", "}" ]

[ "Creates", "a", "new", "browser", "proxy", "queue", "for", "this", "group", "." ]

[ "public", "boolean", "isSocketBinding", "(", "String", "socketBindingGroupName", ",", "String", "socketBindingName", ")", "throws", "Exception", "{", "Address", "addr", "=", "Address", ".", "root", "(", ")", ".", "add", "(", "SOCKET_BINDING_GROUP", ",", "socketBindingGroupName", ")", ";", "String", "haystack", "=", "SOCKET_BINDING", ";", "return", "null", "!=", "findNodeInList", "(", "addr", ",", "haystack", ",", "socketBindingName", ")", ";", "}" ]

[ "Checks", "to", "see", "if", "there", "is", "already", "a", "socket", "binding", "in", "the", "given", "group", "." ]

[ "public", "Content", "getDocLink", "(", "LinkInfoImpl", ".", "Kind", "context", ",", "Element", "element", ",", "CharSequence", "label", ")", "{", "return", "getDocLink", "(", "context", ",", "utils", ".", "getEnclosingTypeElement", "(", "element", ")", ",", "element", ",", "new", "StringContent", "(", "label", ")", ")", ";", "}" ]

[ "Get", "the", "link", "for", "the", "given", "member", "." ]

[ "public", "static", "String", "getContextURL", "(", "ODataUri", "oDataUri", ",", "EntityDataModel", "entityDataModel", ",", "boolean", "isPrimitive", ")", "throws", "ODataRenderException", "{", "if", "(", "ODataUriUtil", ".", "isActionCallUri", "(", "oDataUri", ")", "||", "ODataUriUtil", ".", "isFunctionCallUri", "(", "oDataUri", ")", ")", "{", "return", "buildContextUrlFromOperationCall", "(", "oDataUri", ",", "entityDataModel", ",", "isPrimitive", ")", ";", "}", "Option", "<", "String", ">", "contextOption", "=", "getContextUrl", "(", "oDataUri", ")", ";", "if", "(", "contextOption", ".", "isEmpty", "(", ")", ")", "{", "throw", "new", "ODataRenderException", "(", "\"Could not construct context\"", ")", ";", "}", "return", "contextOption", ".", "get", "(", ")", ";", "}" ]

[ "This", "method", "returns", "odata", "context", "based", "on", "oDataUri", ".", "Throws", "ODataRenderException", "in", "case", "context", "is", "not", "defined", "." ]

[ "public", "Page", "<", "T", ">", "nextPage", "(", "final", "Page", "<", "T", ">", "page", ")", "{", "return", "nextPage", "(", "page", ",", "Twilio", ".", "getRestClient", "(", ")", ")", ";", "}" ]

[ "Fetch", "the", "following", "page", "of", "resources", "." ]

[ "@", "Override", "public", "void", "visitClassContext", "(", "ClassContext", "clsContext", ")", "{", "try", "{", "cls", "=", "clsContext", ".", "getJavaClass", "(", ")", ";", "catalogClass", "(", "cls", ")", ";", "if", "(", "isEntity", ")", "{", "if", "(", "hasHCEquals", "&&", "hasId", "&&", "hasGeneratedValue", ")", "{", "bugReporter", ".", "reportBug", "(", "new", "BugInstance", "(", "this", ",", "BugType", ".", "JPAI_HC_EQUALS_ON_MANAGED_ENTITY", ".", "name", "(", ")", ",", "LOW_PRIORITY", ")", ".", "addClass", "(", "cls", ")", ")", ";", "}", "if", "(", "hasEagerOneToMany", "&&", "!", "hasFetch", ")", "{", "bugReporter", ".", "reportBug", "(", "new", "BugInstance", "(", "this", ",", "BugType", ".", "JPAI_INEFFICIENT_EAGER_FETCH", ".", "name", "(", ")", ",", "LOW_PRIORITY", ")", ".", "addClass", "(", "cls", ")", ")", ";", "}", "}", "if", "(", "!", "transactionalMethods", ".", "isEmpty", "(", ")", ")", "{", "stack", "=", "new", "OpcodeStack", "(", ")", ";", "super", ".", "visitClassContext", "(", "clsContext", ")", ";", "}", "}", "finally", "{", "transactionalMethods", "=", "null", ";", "stack", "=", "null", ";", "}", "}" ]

[ "implements", "the", "visitor", "to", "find", "@Entity", "classes", "that", "have", "both", "generated", "@Ids", "and", "have", "implemented", "hashCode", "/", "equals", ".", "Also", "looks", "for", "eager", "one", "to", "many", "join", "fetches", "as", "that", "leads", "to", "1", "+", "n", "queries", "." ]

[ "protected", "<", "T", ">", "Optional", "<", "T", ">", "executeGetRequest", "(", "URI", "uri", ",", "Map", "<", "String", ",", "Object", ">", "headers", ",", "List", "<", "String", ">", "queryParams", ",", "GenericType", "<", "T", ">", "returnType", ")", "{", "WebTarget", "target", "=", "this", ".", "client", ".", "target", "(", "uri", ")", ";", "target", "=", "applyQueryParams", "(", "target", ",", "queryParams", ")", ";", "Invocation", ".", "Builder", "invocation", "=", "target", ".", "request", "(", "MediaType", ".", "APPLICATION_JSON", ")", ";", "applyHeaders", "(", "invocation", ",", "headers", ")", ";", "Response", "response", "=", "invocation", ".", "get", "(", ")", ";", "handleResponseError", "(", "\"GET\"", ",", "uri", ",", "response", ")", ";", "logResponse", "(", "uri", ",", "response", ")", ";", "return", "extractEntityFromResponse", "(", "response", ",", "returnType", ")", ";", "}" ]

[ "Execute", "a", "GET", "request", "and", "return", "the", "result", "." ]

[ "public", "void", "setPageAction", "(", "PdfName", "actionType", ",", "PdfAction", "action", ",", "int", "page", ")", "throws", "PdfException", "{", "stamper", ".", "setPageAction", "(", "actionType", ",", "action", ",", "page", ")", ";", "}" ]

[ "Sets", "the", "open", "and", "close", "page", "additional", "action", "." ]

[ "public", "static", "boolean", "checkMethodSignature", "(", "final", "Method", "method", ",", "final", "List", "<", "WaveItem", "<", "?", ">", ">", "wParams", ")", "{", "boolean", "isCompliant", "=", "false", ";", "final", "Type", "[", "]", "mParams", "=", "method", ".", "getGenericParameterTypes", "(", ")", ";", "if", "(", "wParams", ".", "isEmpty", "(", ")", "&&", "Wave", ".", "class", ".", "isAssignableFrom", "(", "ClassUtility", ".", "getClassFromType", "(", "mParams", "[", "0", "]", ")", ")", ")", "{", "isCompliant", "=", "true", ";", "}", "else", "if", "(", "mParams", ".", "length", "-", "1", "==", "wParams", ".", "size", "(", ")", ")", "{", "// Flag used to skip a method not compliant", "boolean", "skipMethod", "=", "false", ";", "// Check each parameter", "for", "(", "int", "i", "=", "0", ";", "!", "skipMethod", "&&", "i", "<", "mParams", ".", "length", "-", "1", "&&", "!", "isCompliant", ";", "i", "++", ")", "{", "if", "(", "!", "ClassUtility", ".", "getClassFromType", "(", "mParams", "[", "i", "]", ")", ".", "isAssignableFrom", "(", "ClassUtility", ".", "getClassFromType", "(", "wParams", ".", "get", "(", "i", ")", ".", "type", "(", ")", ")", ")", ")", "{", "// This method has not the right parameters", "skipMethod", "=", "true", ";", "}", "if", "(", "i", "==", "mParams", ".", "length", "-", "2", "&&", "Wave", ".", "class", ".", "isAssignableFrom", "(", "ClassUtility", ".", "getClassFromType", "(", "mParams", "[", "i", "+", "1", "]", ")", ")", ")", "{", "// This method is compliant with wave type", "isCompliant", "=", "true", ";", "}", "}", "}", "return", "isCompliant", ";", "}" ]

[ "Compare", "method", "parameters", "with", "wave", "parameters", "." ]

[ "private", "void", "labelIndicatorMouseEntered", "(", "MouseEvent", "e", ")", "{", "// Skip this function if the settings have not been applied.", "if", "(", "settings", "==", "null", ")", "{", "return", ";", "}", "JLabel", "label", "=", "(", "(", "JLabel", ")", "e", ".", "getSource", "(", ")", ")", ";", "// Do not highlight the today label if today is vetoed.", "if", "(", "label", "==", "labelSetDateToToday", ")", "{", "DateVetoPolicy", "vetoPolicy", "=", "settings", ".", "getVetoPolicy", "(", ")", ";", "boolean", "todayIsVetoed", "=", "InternalUtilities", ".", "isDateVetoed", "(", "vetoPolicy", ",", "LocalDate", ".", "now", "(", ")", ")", ";", "if", "(", "todayIsVetoed", ")", "{", "return", ";", "}", "}", "// Do not highlight the month label if the month menu is disabled.", "if", "(", "(", "label", "==", "labelMonth", ")", "&&", "(", "settings", ".", "getEnableMonthMenu", "(", ")", "==", "false", ")", ")", "{", "return", ";", "}", "// Do not highlight the year label if the year menu is disabled.", "if", "(", "(", "label", "==", "labelYear", ")", "&&", "(", "settings", ".", "getEnableYearMenu", "(", ")", "==", "false", ")", ")", "{", "return", ";", "}", "// Highlight the label.", "label", ".", "setBackground", "(", "new", "Color", "(", "184", ",", "207", ",", "229", ")", ")", ";", "label", ".", "setBorder", "(", "new", "CompoundBorder", "(", "new", "LineBorder", "(", "Color", ".", "GRAY", ")", ",", "labelIndicatorEmptyBorder", ")", ")", ";", "}" ]

[ "labelIndicatorMouseEntered", "This", "event", "is", "called", "when", "the", "user", "move", "the", "mouse", "inside", "a", "monitored", "label", ".", "This", "is", "used", "to", "generate", "mouse", "over", "effects", "for", "the", "calendar", "panel", "." ]

[ "public", "void", "getGuildTeamsInfo", "(", "String", "id", ",", "String", "api", ",", "Callback", "<", "List", "<", "GuildTeam", ">", ">", "callback", ")", "throws", "GuildWars2Exception", ",", "NullPointerException", "{", "isParamValid", "(", "new", "ParamChecker", "(", "ParamType", ".", "GUILD", ",", "id", ")", ",", "new", "ParamChecker", "(", "ParamType", ".", "API", ",", "api", ")", ")", ";", "gw2API", ".", "getGuildTeamsInfo", "(", "id", ",", "api", ")", ".", "enqueue", "(", "callback", ")", ";", "}" ]

[ "For", "more", "info", "on", "guild", "teams", "API", "go", "<a", "href", "=", "https", ":", "//", "wiki", ".", "guildwars2", ".", "com", "/", "wiki", "/", "API", ":", "2", "/", "guild", "/", ":", "id", "/", "teams", ">", "here<", "/", "a", ">", "<br", "/", ">", "Give", "user", "the", "access", "to", "{", "@link", "Callback#onResponse", "(", "Call", "Response", ")", "}", "and", "{", "@link", "Callback#onFailure", "(", "Call", "Throwable", ")", "}", "methods", "for", "custom", "interactions<br", "/", ">" ]

[ "private", "Map", "<", "Object", ",", "Object", ">", "getExplodedWarManifestAttributes", "(", ")", "{", "Map", "<", "Object", ",", "Object", ">", "manifestAttributes", "=", "null", ";", "FileInputStream", "fis", "=", "null", ";", "try", "{", "if", "(", "servletContext", "!=", "null", ")", "{", "final", "String", "appServerHome", "=", "servletContext", ".", "getRealPath", "(", "\"\"", ")", ";", "final", "File", "manifestFile", "=", "new", "File", "(", "appServerHome", ",", "MANIFEST", ")", ";", "LOGGER", ".", "debug", "(", "\"Using Manifest file:{}\"", ",", "manifestFile", ".", "getPath", "(", ")", ")", ";", "fis", "=", "new", "FileInputStream", "(", "manifestFile", ")", ";", "Manifest", "mf", "=", "new", "Manifest", "(", "fis", ")", ";", "manifestAttributes", "=", "mf", ".", "getMainAttributes", "(", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "LOGGER", ".", "warn", "(", "\"Unable to read the manifest file from the servlet context.\"", ")", ";", "LOGGER", ".", "debug", "(", "\"Unable to read the manifest file\"", ",", "e", ")", ";", "}", "finally", "{", "IOUtils", ".", "closeQuietly", "(", "fis", ")", ";", "}", "return", "manifestAttributes", ";", "}" ]

[ "reads", "the", "manifest", "from", "a", "exploded", "WAR" ]

[ "public", "SubGraphPredicate", "withInputMatching", "(", "int", "inputNum", ",", "@", "NonNull", "OpPredicate", "opPredicate", ")", "{", "opInputMatchPredicates", ".", "put", "(", "inputNum", ",", "opPredicate", ")", ";", "return", "this", ";", "}" ]

[ "Require", "the", "subgraph", "to", "match", "the", "specified", "predicate", "for", "the", "specified", "input", ".", "<br", ">", "Note", "that", "this", "does", "NOT", "add", "the", "specified", "input", "to", "part", "of", "the", "subgraph<br", ">", "i", ".", "e", ".", "the", "subgraph", "matches", "if", "the", "input", "matches", "the", "predicate", "but", "when", "returning", "the", "SubGraph", "itself", "the", "function", "for", "this", "input", "is", "not", "added", "to", "the", "SubGraph" ]

[ "private", "static", "void", "adjustQuality", "(", "Map", "<", "String", ",", "Float", ">", "pFormatQuality", ",", "String", "pFormat", ",", "float", "pFactor", ")", "{", "Float", "oldValue", "=", "pFormatQuality", ".", "get", "(", "pFormat", ")", ";", "if", "(", "oldValue", "!=", "null", ")", "{", "pFormatQuality", ".", "put", "(", "pFormat", ",", "oldValue", "*", "pFactor", ")", ";", "//System.out.println(\"New vallue after multiplying with \" + pFactor + \" is \" + pFormatQuality.get(pFormat));\r", "}", "}" ]

[ "Updates", "the", "quality", "in", "the", "map", "." ]

[ "public", "static", "void", "waitForOrKill", "(", "Process", "self", ",", "long", "numberOfMillis", ")", "{", "ProcessRunner", "runnable", "=", "new", "ProcessRunner", "(", "self", ")", ";", "Thread", "thread", "=", "new", "Thread", "(", "runnable", ")", ";", "thread", ".", "start", "(", ")", ";", "runnable", ".", "waitForOrKill", "(", "numberOfMillis", ")", ";", "}" ]

[ "Wait", "for", "the", "process", "to", "finish", "during", "a", "certain", "amount", "of", "time", "otherwise", "stops", "the", "process", "." ]

[ "protected", "void", "callChildVisitors", "(", "XSLTVisitor", "visitor", ",", "boolean", "callAttrs", ")", "{", "if", "(", "callAttrs", ")", "{", "if", "(", "null", "!=", "m_name_avt", ")", "m_name_avt", ".", "callVisitors", "(", "visitor", ")", ";", "if", "(", "null", "!=", "m_namespace_avt", ")", "m_namespace_avt", ".", "callVisitors", "(", "visitor", ")", ";", "}", "super", ".", "callChildVisitors", "(", "visitor", ",", "callAttrs", ")", ";", "}" ]

[ "Call", "the", "children", "visitors", "." ]

[ "public", "static", "AbstractHBCIJob", "newJob", "(", "String", "jobname", ",", "HBCIPassportInternal", "passport", ")", "{", "log", ".", "debug", "(", "\"creating new job \"", "+", "jobname", ")", ";", "if", "(", "jobname", "==", "null", "||", "jobname", ".", "length", "(", ")", "==", "0", ")", "throw", "new", "InvalidArgumentException", "(", "HBCIUtils", ".", "getLocMsg", "(", "\"EXCMSG_EMPTY_JOBNAME\"", ")", ")", ";", "AbstractHBCIJob", "ret", "=", "null", ";", "String", "className", "=", "\"org.kapott.hbci.GV.GV\"", "+", "jobname", ";", "try", "{", "Class", "cl", "=", "Class", ".", "forName", "(", "className", ")", ";", "Constructor", "cons", "=", "cl", ".", "getConstructor", "(", "HBCIPassportInternal", ".", "class", ")", ";", "ret", "=", "(", "AbstractHBCIJob", ")", "cons", ".", "newInstance", "(", "new", "Object", "[", "]", "{", "passport", "}", ")", ";", "}", "catch", "(", "ClassNotFoundException", "e", ")", "{", "throw", "new", "InvalidUserDataException", "(", "\"*** there is no highlevel job named \"", "+", "jobname", "+", "\" - need class \"", "+", "className", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "String", "msg", "=", "HBCIUtils", ".", "getLocMsg", "(", "\"EXCMSG_JOB_CREATE_ERR\"", ",", "jobname", ")", ";", "throw", "new", "HBCI_Exception", "(", "msg", ",", "e", ")", ";", "}", "return", "ret", ";", "}" ]

[ "<p", ">", "Erzeugen", "eines", "neuen", "Highlevel", "-", "HBCI", "-", "Jobs", ".", "Diese", "Methode", "gibt", "ein", "neues", "Job", "-", "Objekt", "zurück", ".", "Dieses", "Objekt", "wird", "allerdings", "noch", "<em", ">", "nicht<", "/", "em", ">", "zum", "HBCI", "-", "Dialog", "hinzugefügt", ".", "Statt", "dessen", "müssen", "erst", "alle", "zur", "Beschreibung", "des", "jeweiligen", "Jobs", "benötigten", "Parameter", "gesetzt", "werden", ".", "<p", ">", "Eine", "Beschreibung", "aller", "unterstützten", "Geschäftsvorfälle", "befindet", "sich", "im", "Package", "<code", ">", "org", ".", "kapott", ".", "hbci", ".", "GV<", "/", "code", ">", ".", "<", "/", "p", ">" ]

[ "public", "static", "void", "randomShuffle", "(", "ArrayModifiableDBIDs", "ids", ",", "Random", "random", ",", "final", "int", "limit", ")", "{", "final", "int", "end", "=", "ids", ".", "size", "(", ")", ";", "for", "(", "int", "i", "=", "1", ";", "i", "<", "limit", ";", "i", "++", ")", "{", "ids", ".", "swap", "(", "i", "-", "1", ",", "i", "+", "random", ".", "nextInt", "(", "end", "-", "i", ")", ")", ";", "}", "}" ]

[ "Produce", "a", "random", "shuffling", "of", "the", "given", "DBID", "array", "." ]

[ "public", "RegistryEntry", "findEntry", "(", "String", "searchType", ",", "Class", "<", "?", ">", "clazz", ")", "{", "RegistryEntry", "entry", "=", "getEntry", "(", "searchType", ")", ";", "if", "(", "entry", "==", "null", ")", "{", "return", "getEntry", "(", "clazz", ",", "false", ")", ";", "}", "return", "entry", ";", "}" ]

[ "Searches", "the", "registry", "for", "a", "resource", "identified", "by", "1", ")", "JSON", "API", "resource", "type", ".", "2", ")", "JSON", "API", "resource", "class", ".", "<p", ">", "If", "a", "resource", "cannot", "be", "found", "{", "@link", "ResourceNotFoundInitializationException", "}", "is", "thrown", "." ]

[ "@", "Pure", "public", "static", "GeodesicPosition", "L3_WSG84", "(", "double", "x", ",", "double", "y", ")", "{", "final", "Point2d", "ntfLambdaPhi", "=", "NTFLambert_NTFLambdaPhi", "(", "x", ",", "y", ",", "LAMBERT_3_N", ",", "LAMBERT_3_C", ",", "LAMBERT_3_XS", ",", "LAMBERT_3_YS", ")", ";", "return", "NTFLambdaPhi_WSG84", "(", "ntfLambdaPhi", ".", "getX", "(", ")", ",", "ntfLambdaPhi", ".", "getY", "(", ")", ")", ";", "}" ]

[ "This", "function", "convert", "France", "Lambert", "III", "coordinate", "to", "geographic", "WSG84", "Data", "." ]

[ "public", "PreparedStatement", "getPreparedStatement", "(", "Q", "query", ",", "boolean", "useCaching", ")", "{", "PreparedStatement", "pStatement", "=", "null", ";", "if", "(", "useCaching", ")", "{", "pStatement", "=", "cachedStatement", ".", "get", "(", ")", ";", "}", "if", "(", "pStatement", "==", "null", ")", "{", "try", "{", "RegularStatement", "stmt", "=", "getQueryGen", "(", "query", ")", ".", "call", "(", ")", ";", "if", "(", "LOG", ".", "isDebugEnabled", "(", ")", ")", "{", "LOG", ".", "debug", "(", "\"Query: \"", "+", "stmt", ".", "getQueryString", "(", ")", ")", ";", "}", "pStatement", "=", "sessionRef", ".", "get", "(", ")", ".", "prepare", "(", "stmt", ".", "getQueryString", "(", ")", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}", "if", "(", "useCaching", "&&", "cachedStatement", ".", "get", "(", ")", "==", "null", ")", "{", "cachedStatement", ".", "set", "(", "pStatement", ")", ";", "}", "return", "pStatement", ";", "}" ]

[ "Get", "the", "bound", "statemnent", "by", "either", "constructing", "the", "query", "or", "using", "the", "cached", "statement", "underneath", ".", "Note", "that", "the", "caller", "can", "provide", "useCaching", "as", "a", "knob", "to", "turn", "caching", "ON", "/", "OFF", ".", "If", "false", "then", "the", "query", "is", "just", "constructed", "using", "the", "extending", "class", "and", "returned", ".", "If", "true", "then", "the", "cached", "reference", "is", "consulted", ".", "If", "the", "cache", "is", "empty", "then", "the", "query", "is", "constructed", "and", "used", "to", "seed", "the", "cache", "." ]

[ "public", "ChannelBuffer", "formatQueryStatsV1", "(", "final", "Map", "<", "String", ",", "Object", ">", "query_stats", ")", "{", "throw", "new", "BadRequestException", "(", "HttpResponseStatus", ".", "NOT_IMPLEMENTED", ",", "\"The requested API endpoint has not been implemented\"", ",", "this", ".", "getClass", "(", ")", ".", "getCanonicalName", "(", ")", "+", "\" has not implemented formatQueryStatsV1\"", ")", ";", "}" ]

[ "Format", "the", "query", "stats" ]

[ "private", "void", "handleLogin", "(", "GwtCommand", "command", ",", "Deferred", "deferred", ")", "{", "final", "String", "oldToken", "=", "notNull", "(", "command", ".", "getUserToken", "(", ")", ")", ";", "if", "(", "!", "afterLoginCommands", ".", "containsKey", "(", "oldToken", ")", ")", "{", "afterLoginCommands", ".", "put", "(", "oldToken", ",", "new", "ArrayList", "<", "RetryCommand", ">", "(", ")", ")", ";", "login", "(", "oldToken", ")", ";", "}", "afterLogin", "(", "command", ",", "deferred", ")", ";", "}" ]

[ "Method", "which", "forces", "retry", "of", "a", "command", "after", "login", ".", "<p", "/", ">", "This", "method", "assumes", "the", "single", "threaded", "nature", "of", "JavaScript", "execution", "for", "correctness", "." ]

[ "public", "void", "waitForJoiningHostsToBeReady", "(", "int", "expectedHosts", ",", "int", "localHostId", ")", "{", "try", "{", "//register this host as joining. The host registration will be deleted after joining is completed.", "m_zk", ".", "create", "(", "ZKUtil", ".", "joinZKPath", "(", "CoreZK", ".", "readyjoininghosts", ",", "Integer", ".", "toString", "(", "localHostId", ")", ")", ",", "null", ",", "Ids", ".", "OPEN_ACL_UNSAFE", ",", "CreateMode", ".", "PERSISTENT", ")", ";", "while", "(", "true", ")", "{", "ZKUtil", ".", "FutureWatcher", "fw", "=", "new", "ZKUtil", ".", "FutureWatcher", "(", ")", ";", "int", "readyHosts", "=", "m_zk", ".", "getChildren", "(", "CoreZK", ".", "readyjoininghosts", ",", "fw", ")", ".", "size", "(", ")", ";", "if", "(", "readyHosts", "==", "expectedHosts", ")", "{", "break", ";", "}", "fw", ".", "get", "(", ")", ";", "}", "}", "catch", "(", "KeeperException", "|", "InterruptedException", "e", ")", "{", "org", ".", "voltdb", ".", "VoltDB", ".", "crashLocalVoltDB", "(", "\"Error waiting for hosts to be ready\"", ",", "false", ",", "e", ")", ";", "}", "}" ]

[ "For", "elastic", "join", ".", "Block", "on", "this", "call", "until", "the", "number", "of", "ready", "hosts", "is", "equal", "to", "the", "number", "of", "expected", "joining", "hosts", "." ]

[ "public", "static", "String", "feature2Dxf", "(", "FeatureMate", "featureMate", ",", "String", "layerName", ",", "String", "elevationAttrName", ",", "boolean", "suffix", ",", "boolean", "force2CoordsToLine", ")", "{", "Geometry", "g", "=", "featureMate", ".", "getGeometry", "(", ")", ";", "if", "(", "EGeometryType", ".", "isPoint", "(", "g", ")", ")", "{", "return", "point2Dxf", "(", "featureMate", ",", "layerName", ",", "elevationAttrName", ")", ";", "}", "else", "if", "(", "EGeometryType", ".", "isLine", "(", "g", ")", ")", "{", "return", "lineString2Dxf", "(", "featureMate", ",", "layerName", ",", "elevationAttrName", ",", "force2CoordsToLine", ")", ";", "}", "else", "if", "(", "EGeometryType", ".", "isPolygon", "(", "g", ")", ")", "{", "return", "polygon2Dxf", "(", "featureMate", ",", "layerName", ",", "elevationAttrName", ",", "suffix", ")", ";", "}", "else", "if", "(", "g", "instanceof", "GeometryCollection", ")", "{", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "g", ".", "getNumGeometries", "(", ")", ";", "i", "++", ")", "{", "SimpleFeature", "ff", "=", "SimpleFeatureBuilder", ".", "copy", "(", "featureMate", ".", "getFeature", "(", ")", ")", ";", "ff", ".", "setDefaultGeometry", "(", "g", ".", "getGeometryN", "(", "i", ")", ")", ";", "FeatureMate", "fm", "=", "new", "FeatureMate", "(", "ff", ")", ";", "sb", ".", "append", "(", "feature2Dxf", "(", "fm", ",", "layerName", ",", "elevationAttrName", ",", "suffix", ",", "force2CoordsToLine", ")", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}", "else", "{", "return", "null", ";", "}", "}" ]

[ "Write", "a", "{", "@link", "SimpleFeature", "}", "to", "dxf", "string", "." ]

[ "public", "static", "void", "tryAccessibilityAnnounce", "(", "View", "view", ",", "CharSequence", "text", ")", "{", "if", "(", "view", "!=", "null", "&&", "text", "!=", "null", ")", "{", "view", ".", "announceForAccessibility", "(", "text", ")", ";", "}", "}" ]

[ "Try", "to", "speak", "the", "specified", "text", "for", "accessibility", ".", "Only", "available", "on", "JB", "or", "later", "." ]

[ "private", "SortedQueue", "getQueueReadOnly", "(", "String", "queueName", ",", "Duration", "waitDuration", ")", "{", "DedupQueue", "service", "=", "getQueueReadWrite", "(", "queueName", ",", "waitDuration", ")", ";", "if", "(", "service", "!=", "null", ")", "{", "try", "{", "return", "service", ".", "getQueue", "(", ")", ";", "}", "catch", "(", "ReadOnlyQueueException", "e", ")", "{", "// Fall through", "}", "}", "return", "_sortedQueueFactory", ".", "create", "(", "queueName", ",", "true", ",", "_queueDAO", ")", ";", "}" ]

[ "Returns", "the", "persistent", "sorted", "queue", "managed", "by", "this", "JVM", "or", "a", "stub", "that", "supports", "only", "read", "-", "only", "operations", "if", "not", "managed", "by", "this", "JVM", "." ]

[ "public", "static", "<", "T", ">", "T", "isInstanceOf", "(", "Class", "<", "?", ">", "type", ",", "T", "obj", ",", "String", "errorMsgTemplate", ",", "Object", "...", "params", ")", "throws", "IllegalArgumentException", "{", "notNull", "(", "type", ",", "\"Type to check against must not be null\"", ")", ";", "if", "(", "false", "==", "type", ".", "isInstance", "(", "obj", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "StrUtil", ".", "format", "(", "errorMsgTemplate", ",", "params", ")", ")", ";", "}", "return", "obj", ";", "}" ]

[ "断言给定对象是否是给定类的实例" ]

[ "protected", "void", "setJobWatermark", "(", "SourceState", "state", ",", "String", "watermark", ")", "{", "state", ".", "setProp", "(", "ComplianceConfigurationKeys", ".", "HIVE_PURGER_WATERMARK", ",", "watermark", ")", ";", "log", ".", "info", "(", "\"Setting job watermark for the job: \"", "+", "watermark", ")", ";", "}" ]

[ "Sets", "Job", "Watermark", "in", "the", "SourceState", "which", "will", "be", "copied", "to", "all", "WorkUnitStates", ".", "Job", "Watermark", "is", "a", "complete", "partition", "name", ".", "During", "next", "run", "of", "this", "job", "fresh", "work", "units", "will", "be", "created", "starting", "from", "this", "partition", "." ]

[ "@", "Override", "public", "float", "calculatePriority", "(", "int", "node", ")", "{", "CalcShortcutsResult", "calcShortcutsResult", "=", "calcShortcutCount", "(", "node", ")", ";", "// # huge influence: the bigger the less shortcuts gets created and the faster is the preparation", "//", "// every adjNode has an 'original edge' number associated. initially it is r=1", "// when a new shortcut is introduced then r of the associated edges is summed up:", "// r(u,w)=r(u,v)+r(v,w) now we can define", "// originalEdgesCount = σ(v) := sum_{ (u,w) ∈ shortcuts(v) } of r(u, w)", "int", "originalEdgesCount", "=", "calcShortcutsResult", ".", "originalEdgesCount", ";", "// # lowest influence on preparation speed or shortcut creation count", "// (but according to paper should speed up queries)", "//", "// number of already contracted neighbors of v", "int", "contractedNeighbors", "=", "0", ";", "int", "degree", "=", "0", ";", "CHEdgeIterator", "iter", "=", "remainingEdgeExplorer", ".", "setBaseNode", "(", "node", ")", ";", "while", "(", "iter", ".", "next", "(", ")", ")", "{", "degree", "++", ";", "if", "(", "iter", ".", "isShortcut", "(", ")", ")", "contractedNeighbors", "++", ";", "}", "// from shortcuts we can compute the edgeDifference", "// # low influence: with it the shortcut creation is slightly faster", "//", "// |shortcuts(v)| − |{(u, v) | v uncontracted}| − |{(v, w) | v uncontracted}|", "// meanDegree is used instead of outDegree+inDegree as if one adjNode is in both directions", "// only one bucket memory is used. Additionally one shortcut could also stand for two directions.", "int", "edgeDifference", "=", "calcShortcutsResult", ".", "shortcutsCount", "-", "degree", ";", "// according to the paper do a simple linear combination of the properties to get the priority.", "return", "params", ".", "edgeDifferenceWeight", "*", "edgeDifference", "+", "params", ".", "originalEdgesCountWeight", "*", "originalEdgesCount", "+", "params", ".", "contractedNeighborsWeight", "*", "contractedNeighbors", ";", "}" ]

[ "Warning", ":", "the", "calculated", "priority", "must", "NOT", "depend", "on", "priority", "(", "v", ")", "and", "therefore", "findShortcuts", "should", "also", "not", "depend", "on", "the", "priority", "(", "v", ")", ".", "Otherwise", "updating", "the", "priority", "before", "contracting", "in", "contractNodes", "()", "could", "lead", "to", "a", "slowish", "or", "even", "endless", "loop", "." ]

[ "public", "void", "deleteMails", "(", "String", "as", "[", "]", ",", "String", "as1", "[", "]", ")", "throws", "MessagingException", ",", "IOException", "{", "Folder", "folder", ";", "Message", "amessage", "[", "]", ";", "folder", "=", "_store", ".", "getFolder", "(", "\"INBOX\"", ")", ";", "folder", ".", "open", "(", "2", ")", ";", "Map", "<", "String", ",", "Message", ">", "map", "=", "getMessages", "(", "null", ",", "folder", ",", "as1", ",", "as", ",", "startrow", ",", "maxrows", ",", "false", ")", ";", "Iterator", "<", "String", ">", "iterator", "=", "map", ".", "keySet", "(", ")", ".", "iterator", "(", ")", ";", "amessage", "=", "new", "Message", "[", "map", ".", "size", "(", ")", "]", ";", "int", "i", "=", "0", ";", "while", "(", "iterator", ".", "hasNext", "(", ")", ")", "{", "amessage", "[", "i", "++", "]", "=", "map", ".", "get", "(", "iterator", ".", "next", "(", ")", ")", ";", "}", "try", "{", "folder", ".", "setFlags", "(", "amessage", ",", "new", "Flags", "(", "javax", ".", "mail", ".", "Flags", ".", "Flag", ".", "DELETED", ")", ",", "true", ")", ";", "}", "finally", "{", "folder", ".", "close", "(", "true", ")", ";", "}", "}" ]

[ "delete", "all", "message", "in", "ibox", "that", "match", "given", "criteria" ]

[ "public", "void", "getContinentFloorInfo", "(", "int", "continentID", ",", "int", "[", "]", "ids", ",", "Callback", "<", "List", "<", "ContinentFloor", ">", ">", "callback", ")", "throws", "GuildWars2Exception", ",", "NullPointerException", "{", "isParamValid", "(", "new", "ParamChecker", "(", "ids", ")", ")", ";", "gw2API", ".", "getContinentFloorInfo", "(", "Integer", ".", "toString", "(", "continentID", ")", ",", "processIds", "(", "ids", ")", ",", "GuildWars2", ".", "lang", ".", "getValue", "(", ")", ")", ".", "enqueue", "(", "callback", ")", ";", "}" ]

[ "For", "more", "info", "on", "continents", "API", "go", "<a", "href", "=", "https", ":", "//", "wiki", ".", "guildwars2", ".", "com", "/", "wiki", "/", "API", ":", "2", "/", "continents", ">", "here<", "/", "a", ">", "<br", "/", ">", "Give", "user", "the", "access", "to", "{", "@link", "Callback#onResponse", "(", "Call", "Response", ")", "}", "and", "{", "@link", "Callback#onFailure", "(", "Call", "Throwable", ")", "}", "methods", "for", "custom", "interactions" ]

[ "@", "Override", "public", "void", "writeClassBody", "(", "Definition", "def", ",", "Writer", "out", ")", "throws", "IOException", "{", "int", "indent", "=", "1", ";", "out", ".", "write", "(", "\"public interface \"", "+", "getClassName", "(", "def", ")", ")", ";", "writeLeftCurlyBracket", "(", "out", ",", "0", ")", ";", "if", "(", "def", ".", "getMcfDefs", "(", ")", ".", "get", "(", "getNumOfMcf", "(", ")", ")", ".", "isDefineMethodInConnection", "(", ")", ")", "{", "if", "(", "def", ".", "getMcfDefs", "(", ")", ".", "get", "(", "getNumOfMcf", "(", ")", ")", ".", "getMethods", "(", ")", ".", "size", "(", ")", ">", "0", ")", "{", "for", "(", "MethodForConnection", "method", ":", "def", ".", "getMcfDefs", "(", ")", ".", "get", "(", "getNumOfMcf", "(", ")", ")", ".", "getMethods", "(", ")", ")", "{", "writeMethodSignature", "(", "out", ",", "indent", ",", "method", ")", ";", "out", ".", "write", "(", "\";\\n\"", ")", ";", "}", "}", "}", "else", "{", "writeSimpleMethodSignature", "(", "out", ",", "indent", ",", "\" * Call me\"", ",", "\"public void callMe();\"", ")", ";", "}", "writeEol", "(", "out", ")", ";", "writeSimpleMethodSignature", "(", "out", ",", "indent", ",", "\" * Close\"", ",", "\"public void close();\"", ")", ";", "writeRightCurlyBracket", "(", "out", ",", "0", ")", ";", "}" ]

[ "Output", "class" ]

[ "private", "void", "notifyListeners", "(", "IMessagingClientFactory", "factory", ",", "boolean", "isAdded", ")", "{", "for", "(", "MessagingClientFactoryListener", "listener", ":", "this", ".", "listeners", ")", "{", "try", "{", "if", "(", "isAdded", ")", "listener", ".", "addMessagingClientFactory", "(", "factory", ")", ";", "else", "listener", ".", "removeMessagingClientFactory", "(", "factory", ")", ";", "}", "catch", "(", "Throwable", "t", ")", "{", "// Log the exception, but *do not* interrupt the notification of the other listeners.", "this", ".", "logger", ".", "warning", "(", "\"Messaging client factory listener has thrown an exception: \"", "+", "listener", ")", ";", "Utils", ".", "logException", "(", "this", ".", "logger", ",", "new", "RuntimeException", "(", "t", ")", ")", ";", "}", "}", "}" ]

[ "Notifies", "the", "messaging", "client", "factory", "listeners", "that", "a", "factory", "has", "been", "added", "/", "removed", "." ]

[ "@", "ArgumentsChecked", "@", "Throws", "(", "{", "IllegalNullArgumentException", ".", "class", ",", "IllegalEmptyArgumentException", ".", "class", "}", ")", "public", "static", "<", "T", "extends", "Iterable", "<", "?", ">", ">", "T", "notEmpty", "(", "@", "Nonnull", "final", "T", "iterable", ",", "@", "Nullable", "final", "String", "name", ")", "{", "notNull", "(", "iterable", ",", "name", ")", ";", "notEmpty", "(", "iterable", ",", "!", "iterable", ".", "iterator", "(", ")", ".", "hasNext", "(", ")", ",", "name", ")", ";", "return", "iterable", ";", "}" ]

[ "Ensures", "that", "a", "passed", "iterable", "as", "a", "parameter", "of", "the", "calling", "method", "is", "not", "empty", "." ]

[ "public", "static", "void", "doPreIntercept", "(", "InterceptorContext", "context", ",", "List", "/*< Interceptor >*/", "interceptors", ")", "throws", "InterceptorException", "{", "if", "(", "interceptors", "!=", "null", ")", "{", "PreInvokeInterceptorChain", "chain", "=", "new", "PreInvokeInterceptorChain", "(", "context", ",", "interceptors", ")", ";", "chain", ".", "continueChain", "(", ")", ";", "}", "}" ]

[ "Execute", "a", "pre", "interceptor", "chain", ".", "This", "will", "execute", "the", "{", "@link", "Interceptor#preInvoke", "(", "InterceptorContext", "InterceptorChain", ")", "}", "method", "to", "be", "invoked", "on", "each", "interceptor", "in", "a", "chain", "." ]

[ "@", "Override", "public", "Point3d", "[", "]", "getVertices", "(", ")", "{", "Point3d", "[", "]", "octahedron", "=", "new", "Point3d", "[", "6", "]", ";", "octahedron", "[", "0", "]", "=", "new", "Point3d", "(", "-", "cirumscribedRadius", ",", "0", ",", "0", ")", ";", "octahedron", "[", "1", "]", "=", "new", "Point3d", "(", "cirumscribedRadius", ",", "0", ",", "0", ")", ";", "octahedron", "[", "2", "]", "=", "new", "Point3d", "(", "0", ",", "-", "cirumscribedRadius", ",", "0", ")", ";", "octahedron", "[", "3", "]", "=", "new", "Point3d", "(", "0", ",", "cirumscribedRadius", ",", "0", ")", ";", "octahedron", "[", "4", "]", "=", "new", "Point3d", "(", "0", ",", "0", ",", "-", "cirumscribedRadius", ")", ";", "octahedron", "[", "5", "]", "=", "new", "Point3d", "(", "0", ",", "0", ",", "cirumscribedRadius", ")", ";", "return", "octahedron", ";", "}" ]

[ "Returns", "the", "vertices", "of", "an", "n", "-", "fold", "polygon", "of", "given", "radius", "and", "center" ]

[ "public", "synchronized", "void", "removeSession", "(", "Endpoint", "ep", ",", "SessionExt", "sess", ")", "{", "Class", "<", "?", ">", "cl", "=", "ep", ".", "getClass", "(", ")", ";", "if", "(", "cl", ".", "equals", "(", "AnnotatedEndpoint", ".", "class", ")", ")", "{", "AnnotatedEndpoint", "ae", "=", "(", "AnnotatedEndpoint", ")", "ep", ";", "cl", "=", "ae", ".", "getServerEndpointClass", "(", ")", ";", "}", "// Always try to remove http session if we can.", "String", "id", "=", "sess", ".", "getSessionImpl", "(", ")", ".", "getHttpSessionID", "(", ")", ";", "if", "(", "id", "!=", "null", ")", "{", "httpSessionMap", ".", "remove", "(", "id", ")", ";", "}", "// find the session array for the given endpoint", "ArrayList", "<", "Session", ">", "sa", "=", "endpointSessionMap", ".", "get", "(", "cl", ")", ";", "// nothing to remove if we don't have a session", "if", "(", "sa", "==", "null", ")", "{", "return", ";", "}", "// remove the new session from the list for this endpoint", "sa", ".", "remove", "(", "sess", ")", ";", "// put the updated list back into the Map", "endpointSessionMap", ".", "put", "(", "cl", ",", "sa", ")", ";", "if", "(", "tc", ".", "isDebugEnabled", "(", ")", ")", "{", "Tr", ".", "debug", "(", "tc", ",", "\"removed session of: \"", "+", "sess", ".", "getId", "(", ")", "+", "\" from endpoint class of: \"", "+", "cl", ".", "getName", "(", ")", "+", "\" in endpointmanager of: \"", "+", "this", ".", "hashCode", "(", ")", ")", ";", "}", "}" ]

[ "/", "*", "closeAllSessions", "will", "call", "this", "with", "the", "session", "already", "removed", "..." ]

[ "private", "Color", "getCellColour", "(", "double", "data", ",", "double", "min", ",", "double", "max", ")", "{", "double", "range", "=", "max", "-", "min", ";", "double", "position", "=", "data", "-", "min", ";", "// What proportion of the way through the possible values is that.", "double", "percentPosition", "=", "position", "/", "range", ";", "// Which colour group does that put us in.", "// int colourPosition = getColourPosition(percentPosition);", "int", "r", "=", "(", "int", ")", "(", "255", "*", "red", "(", "percentPosition", "*", "2", "-", "1", ")", ")", ";", "int", "g", "=", "(", "int", ")", "(", "255", "*", "green", "(", "percentPosition", "*", "2", "-", "1", ")", ")", ";", "int", "b", "=", "(", "int", ")", "(", "255", "*", "blue", "(", "percentPosition", "*", "2", "-", "1", ")", ")", ";", "// int r = lowValueColour.getRed();", "// int g = lowValueColour.getGreen();", "// int b = lowValueColour.getBlue();", "//", "// // Make n shifts of the colour, where n is the colourPosition.", "// for (int i = 0; i < colourPosition; i++) {", "// int rDistance = r - highValueColour.getRed();", "// int gDistance = g - highValueColour.getGreen();", "// int bDistance = b - highValueColour.getBlue();", "//", "// if ((Math.abs(rDistance) >= Math.abs(gDistance))", "// && (Math.abs(rDistance) >= Math.abs(bDistance))) {", "// // Red must be the largest.", "// r = changeColourValue(r, rDistance);", "// }", "// else if (Math.abs(gDistance) >= Math.abs(bDistance)) {", "// // Green must be the largest.", "// g = changeColourValue(g, gDistance);", "// }", "// else {", "// // Blue must be the largest.", "// b = changeColourValue(b, bDistance);", "// }", "// }", "return", "new", "Color", "(", "r", ",", "g", ",", "b", ")", ";", "}" ]

[ "/", "*", "Determines", "what", "colour", "a", "heat", "map", "cell", "should", "be", "based", "upon", "the", "cell", "values", "." ]

[ "public", "static", "PropertyBuilder", "getInstance", "(", "Context", "context", ",", "ClassDoc", "classDoc", ",", "PropertyWriter", "writer", ")", "{", "return", "new", "PropertyBuilder", "(", "context", ",", "classDoc", ",", "writer", ")", ";", "}" ]

[ "Construct", "a", "new", "PropertyBuilder", "." ]

[ "protected", "void", "setRegion", "(", "float", "cx", ",", "float", "cy", ")", "{", "x0", "=", "cx", "-", "radius", ";", "y0", "=", "cy", "-", "radius", ";", "if", "(", "x0", "<", "0", ")", "{", "x0", "=", "0", ";", "}", "else", "if", "(", "x0", "+", "width", ">", "image", ".", "width", ")", "{", "x0", "=", "image", ".", "width", "-", "width", ";", "}", "if", "(", "y0", "<", "0", ")", "{", "y0", "=", "0", ";", "}", "else", "if", "(", "y0", "+", "width", ">", "image", ".", "height", ")", "{", "y0", "=", "image", ".", "height", "-", "width", ";", "}", "}" ]

[ "Updates", "the", "location", "of", "the", "rectangular", "bounding", "box" ]

[ "@", "Override", "public", "void", "doRender", "(", "final", "WComponent", "component", ",", "final", "WebXmlRenderContext", "renderContext", ")", "{", "WCollapsibleToggle", "toggle", "=", "(", "WCollapsibleToggle", ")", "component", ";", "XmlStringBuilder", "xml", "=", "renderContext", ".", "getWriter", "(", ")", ";", "xml", ".", "appendTagOpen", "(", "\"ui:collapsibletoggle\"", ")", ";", "xml", ".", "appendAttribute", "(", "\"id\"", ",", "component", ".", "getId", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"class\"", ",", "component", ".", "getHtmlClass", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"track\"", ",", "component", ".", "isTracking", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendAttribute", "(", "\"groupName\"", ",", "toggle", ".", "getGroupName", "(", ")", ")", ";", "xml", ".", "appendEnd", "(", ")", ";", "}" ]

[ "Paints", "the", "given", "WCollapsibleToggle", "." ]

[ "public", "Observable", "<", "Page", "<", "PoolUsageMetrics", ">", ">", "listUsageMetricsNextAsync", "(", "final", "String", "nextPageLink", ",", "final", "PoolListUsageMetricsNextOptions", "poolListUsageMetricsNextOptions", ")", "{", "return", "listUsageMetricsNextWithServiceResponseAsync", "(", "nextPageLink", ",", "poolListUsageMetricsNextOptions", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponseWithHeaders", "<", "Page", "<", "PoolUsageMetrics", ">", ",", "PoolListUsageMetricsHeaders", ">", ",", "Page", "<", "PoolUsageMetrics", ">", ">", "(", ")", "{", "@", "Override", "public", "Page", "<", "PoolUsageMetrics", ">", "call", "(", "ServiceResponseWithHeaders", "<", "Page", "<", "PoolUsageMetrics", ">", ",", "PoolListUsageMetricsHeaders", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Lists", "the", "usage", "metrics", "aggregated", "by", "pool", "across", "individual", "time", "intervals", "for", "the", "specified", "account", ".", "If", "you", "do", "not", "specify", "a", "$filter", "clause", "including", "a", "poolId", "the", "response", "includes", "all", "pools", "that", "existed", "in", "the", "account", "in", "the", "time", "range", "of", "the", "returned", "aggregation", "intervals", ".", "If", "you", "do", "not", "specify", "a", "$filter", "clause", "including", "a", "startTime", "or", "endTime", "these", "filters", "default", "to", "the", "start", "and", "end", "times", "of", "the", "last", "aggregation", "interval", "currently", "available", ";", "that", "is", "only", "the", "last", "aggregation", "interval", "is", "returned", "." ]

[ "public", "BytecodeVariable", "defineVariable", "(", "Variable", "v", ",", "boolean", "initFromStack", ")", "{", "return", "defineVariable", "(", "v", ",", "v", ".", "getOriginType", "(", ")", ",", "initFromStack", ")", ";", "}" ]

[ "Defines", "a", "new", "Variable", "using", "an", "AST", "variable", "." ]

[ "public", "void", "addClassPath", "(", "String", "path", ")", "{", "String", "[", "]", "paths", "=", "path", ".", "split", "(", "File", ".", "pathSeparator", ")", ";", "for", "(", "String", "cpPath", ":", "paths", ")", "{", "// Check to support wild card classpath", "if", "(", "cpPath", ".", "endsWith", "(", "\"*\"", ")", ")", "{", "File", "dir", "=", "new", "File", "(", "cpPath", ".", "substring", "(", "0", ",", "cpPath", ".", "length", "(", ")", "-", "1", ")", ")", ";", "File", "[", "]", "files", "=", "dir", ".", "listFiles", "(", ")", ";", "if", "(", "files", "!=", "null", ")", "{", "for", "(", "File", "file", ":", "files", ")", "{", "if", "(", "file", ".", "isFile", "(", ")", "&&", "file", ".", "getName", "(", ")", ".", "endsWith", "(", "\".jar\"", ")", ")", "addFile", "(", "file", ")", ";", "}", "}", "}", "else", "{", "addFile", "(", "new", "File", "(", "cpPath", ")", ")", ";", "}", "}", "}" ]

[ "Adds", "a", "classpath", "to", "this", "configuration", ".", "It", "expects", "a", "string", "with", "multiple", "paths", "separated", "by", "the", "system", "dependent", "path", "separator", ".", "Expands", "wildcards", "e", ".", "g", ".", "dir", "/", "*", "into", "all", "the", "jars", "in", "dir", "." ]

[ "public", "static", "void", "runExample", "(", "AdManagerServices", "adManagerServices", ",", "AdManagerSession", "session", ")", "throws", "RemoteException", "{", "// Get the LabelService.", "LabelServiceInterface", "labelService", "=", "adManagerServices", ".", "get", "(", "session", ",", "LabelServiceInterface", ".", "class", ")", ";", "// Create a competitive exclusion label.", "Label", "competitiveExclusionLabel", "=", "new", "Label", "(", ")", ";", "competitiveExclusionLabel", ".", "setName", "(", "\"Car company label #\"", "+", "new", "Random", "(", ")", ".", "nextInt", "(", "Integer", ".", "MAX_VALUE", ")", ")", ";", "competitiveExclusionLabel", ".", "setTypes", "(", "new", "LabelType", "[", "]", "{", "LabelType", ".", "COMPETITIVE_EXCLUSION", "}", ")", ";", "// Create an ad unit frequency cap label.", "Label", "adUnitFrequencyCapLabel", "=", "new", "Label", "(", ")", ";", "adUnitFrequencyCapLabel", ".", "setName", "(", "\"Don't run too often label #\"", "+", "new", "Random", "(", ")", ".", "nextInt", "(", "Integer", ".", "MAX_VALUE", ")", ")", ";", "adUnitFrequencyCapLabel", ".", "setTypes", "(", "new", "LabelType", "[", "]", "{", "LabelType", ".", "AD_UNIT_FREQUENCY_CAP", "}", ")", ";", "// Create the labels on the server.", "Label", "[", "]", "labels", "=", "labelService", ".", "createLabels", "(", "new", "Label", "[", "]", "{", "competitiveExclusionLabel", ",", "adUnitFrequencyCapLabel", "}", ")", ";", "for", "(", "Label", "createdLabel", ":", "labels", ")", "{", "System", ".", "out", ".", "printf", "(", "\"A label with ID %d and name '%s' was created.%n\"", ",", "createdLabel", ".", "getId", "(", ")", ",", "createdLabel", ".", "getName", "(", ")", ")", ";", "}", "}" ]

[ "Runs", "the", "example", "." ]

[ "public", "Observable", "<", "Void", ">", "cancelAsync", "(", "String", "resourceGroupName", ",", "String", "serverName", ",", "String", "databaseName", ",", "UUID", "operationId", ")", "{", "return", "cancelWithServiceResponseAsync", "(", "resourceGroupName", ",", "serverName", ",", "databaseName", ",", "operationId", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "Void", ">", ",", "Void", ">", "(", ")", "{", "@", "Override", "public", "Void", "call", "(", "ServiceResponse", "<", "Void", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "Cancels", "the", "asynchronous", "operation", "on", "the", "database", "." ]

[ "static", "void", "writeInfo", "(", "String", "parent", ",", "HdfsFileStatus", "i", ",", "XMLOutputter", "doc", ")", "throws", "IOException", "{", "final", "SimpleDateFormat", "ldf", "=", "df", ".", "get", "(", ")", ";", "doc", ".", "startTag", "(", "i", ".", "isDir", "(", ")", "?", "\"directory\"", ":", "\"file\"", ")", ";", "doc", ".", "attribute", "(", "\"path\"", ",", "i", ".", "getFullPath", "(", "new", "Path", "(", "parent", ")", ")", ".", "toUri", "(", ")", ".", "getPath", "(", ")", ")", ";", "doc", ".", "attribute", "(", "\"modified\"", ",", "ldf", ".", "format", "(", "new", "Date", "(", "i", ".", "getModificationTime", "(", ")", ")", ")", ")", ";", "doc", ".", "attribute", "(", "\"accesstime\"", ",", "ldf", ".", "format", "(", "new", "Date", "(", "i", ".", "getAccessTime", "(", ")", ")", ")", ")", ";", "if", "(", "!", "i", ".", "isDir", "(", ")", ")", "{", "doc", ".", "attribute", "(", "\"size\"", ",", "String", ".", "valueOf", "(", "i", ".", "getLen", "(", ")", ")", ")", ";", "doc", ".", "attribute", "(", "\"replication\"", ",", "String", ".", "valueOf", "(", "i", ".", "getReplication", "(", ")", ")", ")", ";", "doc", ".", "attribute", "(", "\"blocksize\"", ",", "String", ".", "valueOf", "(", "i", ".", "getBlockSize", "(", ")", ")", ")", ";", "}", "doc", ".", "attribute", "(", "\"permission\"", ",", "(", "i", ".", "isDir", "(", ")", "?", "\"d\"", ":", "\"-\"", ")", "+", "i", ".", "getPermission", "(", ")", ")", ";", "doc", ".", "attribute", "(", "\"owner\"", ",", "i", ".", "getOwner", "(", ")", ")", ";", "doc", ".", "attribute", "(", "\"group\"", ",", "i", ".", "getGroup", "(", ")", ")", ";", "doc", ".", "endTag", "(", ")", ";", "}" ]

[ "Write", "a", "node", "to", "output", ".", "Node", "information", "includes", "path", "modification", "permission", "owner", "and", "group", ".", "For", "files", "it", "also", "includes", "size", "replication", "and", "block", "-", "size", "." ]

[ "public", "static", "Trade", "adaptTrade", "(", "LakeBTCTradeResponse", "tx", ",", "CurrencyPair", "currencyPair", ",", "int", "timeScale", ")", "{", "final", "String", "tradeId", "=", "String", ".", "valueOf", "(", "tx", ".", "getId", "(", ")", ")", ";", "Date", "date", "=", "DateUtils", ".", "fromMillisUtc", "(", "tx", ".", "getAt", "(", ")", "*", "timeScale", ")", ";", "// polled order", "// books provide", "// a timestamp", "// in seconds,", "// stream in ms", "return", "new", "Trade", "(", "null", ",", "tx", ".", "getAmount", "(", ")", ",", "currencyPair", ",", "tx", ".", "getTotal", "(", ")", ",", "date", ",", "tradeId", ")", ";", "}" ]

[ "Adapts", "a", "Transaction", "to", "a", "Trade", "Object" ]

[ "void", "wrappedSmoothScrollBy", "(", "int", "dx", ",", "int", "dy", ")", "{", "if", "(", "!", "mScrollable", ")", "{", "return", ";", "}", "smoothScrollBy", "(", "dx", ",", "dy", ")", ";", "if", "(", "mLockableScrollChangedListener", "!=", "null", ")", "{", "mLockableScrollChangedListener", ".", "onSmoothScrollBy", "(", "dx", ",", "dy", ")", ";", "}", "}" ]

[ "Wrapping", "the", "{", "@link", "HorizontalScrollView#smoothScrollBy", "(", "int", "int", ")", "}", "function", "to", "increase", "testability", "." ]

[ "public", "static", "Object", "createInstanceByType", "(", "Class", "<", "?", ">", "type", ",", "Object", "...", "args", ")", "throws", "Exception", "{", "if", "(", "args", ".", "length", "==", "0", ")", "{", "Constructor", "<", "?", ">", "constructor", "=", "type", ".", "getConstructor", "(", ")", ";", "return", "constructor", ".", "newInstance", "(", ")", ";", "}", "else", "{", "throw", "new", "UnsupportedException", "(", "null", ",", "\"NOT_SUPPORTED\"", ",", "\"Constructors with parameters are not supported\"", ")", ";", "}", "}" ]

[ "Creates", "an", "instance", "of", "an", "object", "type", "." ]

[ "public", "static", "void", "boundImage", "(", "GrayS64", "img", ",", "long", "min", ",", "long", "max", ")", "{", "ImplPixelMath", ".", "boundImage", "(", "img", ",", "min", ",", "max", ")", ";", "}" ]

[ "Bounds", "image", "pixels", "to", "be", "between", "these", "two", "values" ]

[ "private", "KNXNetworkLink", "createLink", "(", ")", "throws", "KNXException", "{", "final", "KNXMediumSettings", "medium", "=", "(", "KNXMediumSettings", ")", "options", ".", "get", "(", "\"medium\"", ")", ";", "if", "(", "options", ".", "containsKey", "(", "\"serial\"", ")", ")", "{", "// create FT1.2 network link\r", "final", "String", "p", "=", "(", "String", ")", "options", ".", "get", "(", "\"serial\"", ")", ";", "try", "{", "return", "new", "KNXNetworkLinkFT12", "(", "Integer", ".", "parseInt", "(", "p", ")", ",", "medium", ")", ";", "}", "catch", "(", "final", "NumberFormatException", "e", ")", "{", "return", "new", "KNXNetworkLinkFT12", "(", "p", ",", "medium", ")", ";", "}", "}", "// create local and remote socket address for network link\r", "final", "InetSocketAddress", "local", "=", "createLocalSocket", "(", "(", "InetAddress", ")", "options", ".", "get", "(", "\"localhost\"", ")", ",", "(", "Integer", ")", "options", ".", "get", "(", "\"localport\"", ")", ")", ";", "final", "InetSocketAddress", "host", "=", "new", "InetSocketAddress", "(", "(", "InetAddress", ")", "options", ".", "get", "(", "\"host\"", ")", ",", "(", "(", "Integer", ")", "options", ".", "get", "(", "\"port\"", ")", ")", ".", "intValue", "(", ")", ")", ";", "final", "int", "mode", "=", "options", ".", "containsKey", "(", "\"routing\"", ")", "?", "KNXNetworkLinkIP", ".", "ROUTER", ":", "KNXNetworkLinkIP", ".", "TUNNEL", ";", "return", "new", "KNXNetworkLinkIP", "(", "mode", ",", "local", ",", "host", ",", "options", ".", "containsKey", "(", "\"nat\"", ")", ",", "medium", ")", ";", "}" ]

[ "Creates", "the", "KNX", "network", "link", "to", "access", "the", "network", "specified", "in", "<code", ">", "options<", "/", "code", ">", ".", "<p", ">" ]

[ "public", "static", "Long", "[", "]", "splitToLong", "(", "final", "String", "ids", ")", "{", "if", "(", "isEmpty", "(", "ids", ")", ")", "{", "return", "new", "Long", "[", "0", "]", ";", "}", "else", "{", "return", "transformToLong", "(", "split", "(", "ids", ",", "'", "'", ")", ")", ";", "}", "}" ]

[ "<p", ">", "splitToLong", ".", "<", "/", "p", ">" ]

[ "public", "static", "String", "concatenateAndUriEncode", "(", "Collection", "<", "?", ">", "list", ",", "String", "delimiter", ")", "{", "Collection", "<", "String", ">", "escaped", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "if", "(", "list", "!=", "null", ")", "{", "for", "(", "Object", "object", ":", "list", ")", "{", "escaped", ".", "add", "(", "encode", "(", "object", ".", "toString", "(", ")", ")", ")", ";", "}", "}", "return", "StringUtils", ".", "concatenate", "(", "escaped", ",", "delimiter", ")", ";", "}" ]

[ "Encodes", "each", "string", "value", "of", "the", "list", "and", "concatenates", "the", "results", "using", "the", "supplied", "delimiter", "." ]

[ "private", "void", "checkBasicCall", "(", "CallBasicNode", "node", ",", "TemplateRegistry", "registry", ")", "{", "TemplateMetadata", "callee", "=", "registry", ".", "getBasicTemplateOrElement", "(", "node", ".", "getCalleeName", "(", ")", ")", ";", "if", "(", "callee", "==", "null", ")", "{", "String", "extraErrorMessage", "=", "SoyErrors", ".", "getDidYouMeanMessage", "(", "registry", ".", "getBasicTemplateOrElementNames", "(", ")", ",", "node", ".", "getCalleeName", "(", ")", ")", ";", "errorReporter", ".", "report", "(", "node", ".", "getSourceLocation", "(", ")", ",", "CALL_TO_UNDEFINED_TEMPLATE", ",", "node", ".", "getCalleeName", "(", ")", ",", "extraErrorMessage", ")", ";", "}", "else", "{", "SoyFileKind", "calleeKind", "=", "callee", ".", "getSoyFileKind", "(", ")", ";", "String", "callerFilePath", "=", "node", ".", "getSourceLocation", "(", ")", ".", "getFilePath", "(", ")", ";", "String", "calleeFilePath", "=", "callee", ".", "getSourceLocation", "(", ")", ".", "getFilePath", "(", ")", ";", "if", "(", "calleeKind", "==", "SoyFileKind", ".", "INDIRECT_DEP", ")", "{", "errorReporter", ".", "report", "(", "node", ".", "getSourceLocation", "(", ")", ",", "CALL_TO_INDIRECT_DEPENDENCY", ",", "calleeFilePath", ")", ";", "}", "}", "}" ]

[ "in", "a", "different", "part", "of", "the", "dependency", "graph", "(", "if", "it", "s", "late", "-", "bound", ")", "." ]

[ "public", "SqlInfo", "buildLikeSql", "(", "String", "fieldText", ",", "String", "valueText", ",", "String", "patternText", ")", "{", "if", "(", "StringHelper", ".", "isNotBlank", "(", "valueText", ")", "&&", "StringHelper", ".", "isBlank", "(", "patternText", ")", ")", "{", "return", "super", ".", "buildLikeSql", "(", "fieldText", ",", "ParseHelper", ".", "parseExpressWithException", "(", "valueText", ",", "context", ")", ")", ";", "}", "else", "if", "(", "StringHelper", ".", "isBlank", "(", "valueText", ")", "&&", "StringHelper", ".", "isNotBlank", "(", "patternText", ")", ")", "{", "return", "super", ".", "buildLikePatternSql", "(", "fieldText", ",", "patternText", ")", ";", "}", "else", "{", "throw", "new", "ValidFailException", "(", "\"<like /> 标签中的'value'属性和'pattern'属性不能同时为空或者同时不为空！\");", "", "", "}", "}" ]

[ "构建Like模糊查询的sqlInfo信息", "." ]

[ "public", "static", "int", "copyStreamCount", "(", "final", "InputStream", "in", ",", "final", "OutputStream", "out", ")", "throws", "IOException", "{", "final", "byte", "[", "]", "buffer", "=", "new", "byte", "[", "10240", "]", ";", "int", "tot", "=", "0", ";", "int", "c", ";", "c", "=", "in", ".", "read", "(", "buffer", ")", ";", "while", "(", "c", ">=", "0", ")", "{", "if", "(", "c", ">", "0", ")", "{", "out", ".", "write", "(", "buffer", ",", "0", ",", "c", ")", ";", "tot", "+=", "c", ";", "}", "c", "=", "in", ".", "read", "(", "buffer", ")", ";", "}", "return", "tot", ";", "}" ]

[ "Read", "the", "data", "from", "the", "input", "stream", "and", "copy", "to", "the", "outputstream", "." ]

[ "public", "UriMappingResolver", "addDomain", "(", "String", "domain", ",", "String", "replacement", ")", "{", "addDomainPattern", "(", "quote", "(", "domain", ")", "+", "\"[/]*(.*)\"", ",", "replacement", ")", ";", "return", "this", ";", "}" ]

[ "Adds", "a", "domain", "for", "relative", "lookup", ".", "All", "uris", "starting", "with", "{" ]

[ "public", "static", "<", "T", "extends", "Chunkable", ">", "int", "chunkCountFrom", "(", "T", "chunkable", ",", "int", "chunkLength", ")", "{", "byte", "[", "]", "data", "=", "chunkable", ".", "getChunkableData", "(", ")", ";", "return", "(", "int", ")", "Math", ".", "ceil", "(", "data", ".", "length", "*", "1.0", "/", "chunkLength", ")", ";", "}" ]

[ "Retrieve", "the", "count", "of", "chunks", "for", "a", "given", "chunk", "length", "." ]

[ "private", "JTable", "getMainPanel", "(", ")", "{", "if", "(", "table", "==", "null", ")", "{", "model", "=", "new", "ScanProgressTableModel", "(", ")", ";", "table", "=", "new", "JTable", "(", ")", ";", "table", ".", "setModel", "(", "model", ")", ";", "table", ".", "setRowSelectionAllowed", "(", "false", ")", ";", "table", ".", "setColumnSelectionAllowed", "(", "false", ")", ";", "table", ".", "setDoubleBuffered", "(", "true", ")", ";", "// First column is for plugin's name", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "0", ")", ".", "setPreferredWidth", "(", "256", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "1", ")", ".", "setPreferredWidth", "(", "80", ")", ";", "// Second column is for plugin's status", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "2", ")", ".", "setPreferredWidth", "(", "80", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "2", ")", ".", "setCellRenderer", "(", "new", "ScanProgressBarRenderer", "(", ")", ")", ";", "// Third column is for plugin's elapsed time", "DefaultTableCellRenderer", "centerRenderer", "=", "new", "DefaultTableCellRenderer", "(", ")", ";", "centerRenderer", ".", "setHorizontalAlignment", "(", "JLabel", ".", "CENTER", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "3", ")", ".", "setPreferredWidth", "(", "85", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "3", ")", ".", "setCellRenderer", "(", "centerRenderer", ")", ";", "// Forth column is for plugin's request count", "DefaultTableCellRenderer", "rightRenderer", "=", "new", "DefaultTableCellRenderer", "(", ")", ";", "rightRenderer", ".", "setHorizontalAlignment", "(", "JLabel", ".", "RIGHT", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "4", ")", ".", "setPreferredWidth", "(", "60", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "4", ")", ".", "setCellRenderer", "(", "rightRenderer", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "5", ")", ".", "setPreferredWidth", "(", "60", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "5", ")", ".", "setCellRenderer", "(", "rightRenderer", ")", ";", "// Fifth column is for plugin's completion and actions", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "6", ")", ".", "setPreferredWidth", "(", "40", ")", ";", "table", ".", "getColumnModel", "(", ")", ".", "getColumn", "(", "6", ")", ".", "setCellRenderer", "(", "new", "ScanProgressActionRenderer", "(", ")", ")", ";", "ScanProgressActionListener", "listener", "=", "new", "ScanProgressActionListener", "(", "table", ",", "model", ")", ";", "table", ".", "addMouseListener", "(", "listener", ")", ";", "table", ".", "addMouseMotionListener", "(", "listener", ")", ";", "}", "return", "table", ";", "}" ]

[ "Get", "the", "main", "content", "panel", "of", "the", "dialog" ]

[ "public", "static", "String", "toDecamelize", "(", "final", "String", "value", ",", "final", "String", "chr", ")", "{", "String", "camelCasedString", "=", "toCamelCase", "(", "value", ")", ";", "String", "[", "]", "words", "=", "camelCasedString", ".", "split", "(", "\"(?=\\\\p{Upper})\"", ")", ";", "return", "Arrays", ".", "stream", "(", "words", ")", ".", "map", "(", "String", "::", "toLowerCase", ")", ".", "collect", "(", "joining", "(", "Optional", ".", "ofNullable", "(", "chr", ")", ".", "orElse", "(", "\" \"", ")", ")", ")", ";", "}" ]

[ "Decamelize", "String" ]

[ "protected", "void", "processMetadataInitialization", "(", "HttpServletRequest", "request", ")", "throws", "ServletException", "{", "// In case the hosted IdP metadata weren't initialized, let's do it now", "if", "(", "manager", ".", "getHostedIdpName", "(", ")", "==", "null", ")", "{", "synchronized", "(", "IdpMetadataManager", ".", "class", ")", "{", "if", "(", "manager", ".", "getHostedIdpName", "(", ")", "==", "null", ")", "{", "try", "{", "log", ".", "info", "(", "\"No default metadata configured, generating with default values, please pre-configure metadata for production use\"", ")", ";", "// Defaults", "String", "alias", "=", "generator", ".", "getEntityAlias", "(", ")", ";", "String", "baseURL", "=", "getDefaultBaseURL", "(", "request", ")", ";", "// Use default baseURL if not set", "if", "(", "generator", ".", "getEntityBaseURL", "(", ")", "==", "null", ")", "{", "log", ".", "warn", "(", "\"Generated default entity base URL {} based on values in the first server request. Please set property entityBaseURL on MetadataGenerator bean to fixate the value.\"", ",", "baseURL", ")", ";", "generator", ".", "setEntityBaseURL", "(", "baseURL", ")", ";", "}", "else", "{", "baseURL", "=", "generator", ".", "getEntityBaseURL", "(", ")", ";", "}", "// Use default entityID if not set", "if", "(", "generator", ".", "getEntityId", "(", ")", "==", "null", ")", "{", "generator", ".", "setEntityId", "(", "getDefaultEntityID", "(", "baseURL", ",", "alias", ")", ")", ";", "}", "// Ensure supported nameID formats in uaa are listed in the metadata", "Collection", "<", "String", ">", "supportedNameID", "=", "Arrays", ".", "asList", "(", "NameIDType", ".", "EMAIL", ",", "NameIDType", ".", "PERSISTENT", ",", "NameIDType", ".", "UNSPECIFIED", ")", ";", "generator", ".", "setNameID", "(", "supportedNameID", ")", ";", "EntityDescriptor", "descriptor", "=", "generator", ".", "generateMetadata", "(", ")", ";", "ExtendedMetadata", "extendedMetadata", "=", "generator", ".", "generateExtendedMetadata", "(", ")", ";", "log", ".", "info", "(", "\"Created default metadata for system with entityID: \"", "+", "descriptor", ".", "getEntityID", "(", ")", ")", ";", "MetadataMemoryProvider", "memoryProvider", "=", "new", "MetadataMemoryProvider", "(", "descriptor", ")", ";", "memoryProvider", ".", "initialize", "(", ")", ";", "MetadataProvider", "metadataProvider", "=", "new", "ExtendedMetadataDelegate", "(", "memoryProvider", ",", "extendedMetadata", ")", ";", "manager", ".", "addMetadataProvider", "(", "metadataProvider", ")", ";", "manager", ".", "setHostedIdpName", "(", "descriptor", ".", "getEntityID", "(", ")", ")", ";", "manager", ".", "refreshMetadata", "(", ")", ";", "}", "catch", "(", "MetadataProviderException", "e", ")", "{", "log", ".", "error", "(", "\"Error generating system metadata\"", ",", "e", ")", ";", "throw", "new", "ServletException", "(", "\"Error generating system metadata\"", ",", "e", ")", ";", "}", "}", "}", "}", "}" ]

[ "Verifies", "whether", "generation", "is", "needed", "and", "if", "so", "the", "metadata", "document", "is", "created", "and", "stored", "in", "metadata", "manager", "." ]

[ "protected", "static", "final", "LocalDate", "moveDate", "(", "final", "MoveableHoliday", "aMoveableHoliday", ",", "final", "LocalDate", "aFixed", ")", "{", "for", "(", "final", "MovingCondition", "aMoveCond", ":", "aMoveableHoliday", ".", "getMovingCondition", "(", ")", ")", "if", "(", "shallBeMoved", "(", "aFixed", ",", "aMoveCond", ")", ")", "return", "_moveDate", "(", "aMoveCond", ",", "aFixed", ")", ";", "return", "aFixed", ";", "}" ]

[ "Moves", "a", "date", "if", "there", "are", "any", "moving", "conditions", "for", "this", "holiday", "and", "any", "of", "them", "fit", "." ]

[ "public", "static", "<", "K", ",", "OLD", ",", "NEW", ">", "DataSet", "<", "Vertex", "<", "K", ",", "NEW", ">", ">", "translateVertexValues", "(", "DataSet", "<", "Vertex", "<", "K", ",", "OLD", ">", ">", "vertices", ",", "TranslateFunction", "<", "OLD", ",", "NEW", ">", "translator", ")", "{", "return", "translateVertexValues", "(", "vertices", ",", "translator", ",", "PARALLELISM_DEFAULT", ")", ";", "}" ]

[ "Translate", "{", "@link", "Vertex", "}", "values", "using", "the", "given", "{", "@link", "TranslateFunction", "}", "." ]

[ "public", "static", "boolean", "isInside", "(", "Circle", "c1", ",", "Circle", "c2", ")", "{", "return", "distanceFromCenter", "(", "c1", ",", "c2", ".", "getX", "(", ")", ",", "c2", ".", "getY", "(", ")", ")", "+", "c2", ".", "getRadius", "(", ")", "<", "c1", ".", "getRadius", "(", ")", ";", "}" ]

[ "Returns", "true", "if", "c2", "is", "inside", "of", "c1" ]

[ "public", "static", "<", "T", ">", "boolean", "ge", "(", "Comparable", "<", "T", ">", "a", ",", "T", "b", ")", "{", "return", "ge", "(", "a", ".", "compareTo", "(", "b", ")", ")", ";", "}" ]

[ "<code", ">", "a", ">", "=", "b<", "/", "code", ">" ]

[ "private", "ErrorCode", "sendPing", "(", ")", "throws", "IOException", "{", "if", "(", "LOGGER", ".", "isTraceEnabled", "(", ")", ")", "{", "LOGGER", ".", "trace", "(", "\"......................send Ping\"", ")", ";", "}", "lastPingSentNs", "=", "System", ".", "currentTimeMillis", "(", ")", ";", "ProtocolHeader", "h", "=", "new", "ProtocolHeader", "(", "-", "2", ",", "ProtocolType", ".", "Ping", ")", ";", "sendAdminPacket", "(", "h", ",", "null", ")", ";", "int", "waitTime", "=", "session", ".", "pingWaitTimeOut", ";", "synchronized", "(", "pingResponse", ")", "{", "while", "(", "waitTime", ">", "0", ")", "{", "try", "{", "pingResponse", ".", "wait", "(", "waitTime", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "// Do nothing.", "}", "ResponseHeader", "header", "=", "pingResponse", ".", "get", "(", ")", ";", "if", "(", "header", "!=", "null", ")", "{", "pingResponse", ".", "set", "(", "null", ")", ";", "return", "header", ".", "getErr", "(", ")", ";", "}", "waitTime", "-=", "(", "System", ".", "currentTimeMillis", "(", ")", "-", "lastPingSentNs", ")", ";", "}", "}", "return", "ErrorCode", ".", "PING_TIMEOUT", ";", "}" ]

[ "Send", "the", "Ping", "Request", "." ]

[ "public", "String", "RTMPPublishURL", "(", "String", "domain", ",", "String", "hub", ",", "String", "streamKey", ",", "int", "expireAfterSeconds", ")", "{", "long", "expire", "=", "System", ".", "currentTimeMillis", "(", ")", "/", "1000", "+", "expireAfterSeconds", ";", "String", "path", "=", "String", ".", "format", "(", "\"/%s/%s?e=%d\"", ",", "hub", ",", "streamKey", ",", "expire", ")", ";", "String", "token", ";", "try", "{", "token", "=", "this", ".", "cli", ".", "getMac", "(", ")", ".", "sign", "(", "path", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "e", ".", "printStackTrace", "(", ")", ";", "return", "null", ";", "}", "return", "String", ".", "format", "(", "\"rtmp://%s%s&token=%s\"", ",", "domain", ",", "path", ",", "token", ")", ";", "}" ]

[ "/", "*", "RTMPPublishURL", "generates", "RTMP", "publish", "URL", "expireAfterSeconds", "means", "URL", "will", "be", "invalid", "after", "expireAfterSeconds", "." ]

[ "private", "void", "switchAccountStatusTree", "(", "Account", "parentAccount", ",", "UserIdentityContext", "userIdentityContext", ")", "{", "logger", ".", "debug", "(", "\"Status transition requested\"", ")", ";", "// transition child accounts", "List", "<", "String", ">", "subAccountsToSwitch", "=", "accountsDao", ".", "getSubAccountSidsRecursive", "(", "parentAccount", ".", "getSid", "(", ")", ")", ";", "if", "(", "subAccountsToSwitch", "!=", "null", "&&", "!", "subAccountsToSwitch", ".", "isEmpty", "(", ")", ")", "{", "int", "i", "=", "subAccountsToSwitch", ".", "size", "(", ")", ";", "// is is the count of accounts left to process", "// we iterate backwards to handle child accounts first, parent accounts next", "while", "(", "i", ">", "0", ")", "{", "i", "--", ";", "String", "removedSid", "=", "subAccountsToSwitch", ".", "get", "(", "i", ")", ";", "try", "{", "Account", "subAccount", "=", "accountsDao", ".", "getAccount", "(", "new", "Sid", "(", "removedSid", ")", ")", ";", "switchAccountStatus", "(", "subAccount", ",", "parentAccount", ".", "getStatus", "(", ")", ",", "userIdentityContext", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "// if anything bad happens, log the error and continue removing the rest of the accounts.", "logger", ".", "error", "(", "\"Failed switching status (child) account '\"", "+", "removedSid", "+", "\"'\"", ")", ";", "}", "}", "}", "// switch parent account too", "switchAccountStatus", "(", "parentAccount", ",", "parentAccount", ".", "getStatus", "(", ")", ",", "userIdentityContext", ")", ";", "}" ]

[ "Switches", "status", "of", "account", "along", "with", "all", "its", "children", "(", "the", "whole", "tree", ")", "." ]

[ "@", "SuppressWarnings", "(", "\"rawtypes\"", ")", "private", "static", "boolean", "isQueueEmpty", "(", "MuleContext", "muleContext", ",", "String", "muleJmsConnectorName", ",", "String", "queueName", ")", "throws", "JMSException", "{", "JmsConnector", "muleCon", "=", "(", "JmsConnector", ")", "MuleUtil", ".", "getSpringBean", "(", "muleContext", ",", "muleJmsConnectorName", ")", ";", "Session", "s", "=", "null", ";", "QueueBrowser", "b", "=", "null", ";", "try", "{", "// Get a jms connection from mule and create a jms session", "s", "=", "muleCon", ".", "getConnection", "(", ")", ".", "createSession", "(", "false", ",", "Session", ".", "AUTO_ACKNOWLEDGE", ")", ";", "Queue", "q", "=", "s", ".", "createQueue", "(", "queueName", ")", ";", "b", "=", "s", ".", "createBrowser", "(", "q", ")", ";", "Enumeration", "e", "=", "b", ".", "getEnumeration", "(", ")", ";", "return", "!", "e", ".", "hasMoreElements", "(", ")", ";", "}", "finally", "{", "try", "{", "if", "(", "b", "!=", "null", ")", "b", ".", "close", "(", ")", ";", "}", "catch", "(", "JMSException", "e", ")", "{", "}", "try", "{", "if", "(", "s", "!=", "null", ")", "s", ".", "close", "(", ")", ";", "}", "catch", "(", "JMSException", "e", ")", "{", "}", "}", "}" ]

[ "Browse", "a", "queue", "for", "messages" ]

[ "public", "ApiSuccessResponse", "acceptEmail", "(", "String", "id", ",", "AcceptData5", "acceptData", ")", "throws", "ApiException", "{", "ApiResponse", "<", "ApiSuccessResponse", ">", "resp", "=", "acceptEmailWithHttpInfo", "(", "id", ",", "acceptData", ")", ";", "return", "resp", ".", "getData", "(", ")", ";", "}" ]

[ "Accept", "the", "email", "interaction", "Accept", "the", "interaction", "specified", "in", "the", "id", "path", "parameter" ]

[ "public", "boolean", "isSponsorInHierarchy", "(", "DevelopmentProposalContract", "sponsorable", ",", "String", "sponsorHierarchy", ",", "String", "level1", ")", "{", "return", "sponsorHierarchyService", ".", "isSponsorInHierarchy", "(", "sponsorable", ".", "getSponsor", "(", ")", ".", "getSponsorCode", "(", ")", ",", "sponsorHierarchy", ",", "1", ",", "level1", ")", ";", "}" ]

[ "This", "method", "tests", "whether", "a", "document", "s", "sponsor", "is", "in", "a", "given", "sponsor", "hierarchy", "." ]

[ "public", "PublicResolver", "obtainPublicResolver", "(", "String", "ensName", ")", "{", "if", "(", "isValidEnsName", "(", "ensName", ")", ")", "{", "try", "{", "if", "(", "!", "isSynced", "(", ")", ")", "{", "throw", "new", "EnsResolutionException", "(", "\"Node is not currently synced\"", ")", ";", "}", "else", "{", "return", "lookupResolver", "(", "ensName", ")", ";", "}", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "EnsResolutionException", "(", "\"Unable to determine sync status of node\"", ",", "e", ")", ";", "}", "}", "else", "{", "throw", "new", "EnsResolutionException", "(", "\"EnsName is invalid: \"", "+", "ensName", ")", ";", "}", "}" ]

[ "Provides", "an", "access", "to", "a", "valid", "public", "resolver", "in", "order", "to", "access", "other", "API", "methods", "." ]

[ "public", "Observable", "<", "ServiceResponse", "<", "Page", "<", "SecretItem", ">", ">", ">", "getSecretsWithServiceResponseAsync", "(", "final", "String", "vaultBaseUrl", ",", "final", "Integer", "maxresults", ")", "{", "return", "getSecretsSinglePageAsync", "(", "vaultBaseUrl", ",", "maxresults", ")", ".", "concatMap", "(", "new", "Func1", "<", "ServiceResponse", "<", "Page", "<", "SecretItem", ">", ">", ",", "Observable", "<", "ServiceResponse", "<", "Page", "<", "SecretItem", ">", ">", ">", ">", "(", ")", "{", "@", "Override", "public", "Observable", "<", "ServiceResponse", "<", "Page", "<", "SecretItem", ">", ">", ">", "call", "(", "ServiceResponse", "<", "Page", "<", "SecretItem", ">", ">", "page", ")", "{", "String", "nextPageLink", "=", "page", ".", "body", "(", ")", ".", "nextPageLink", "(", ")", ";", "if", "(", "nextPageLink", "==", "null", ")", "{", "return", "Observable", ".", "just", "(", "page", ")", ";", "}", "return", "Observable", ".", "just", "(", "page", ")", ".", "concatWith", "(", "getSecretsNextWithServiceResponseAsync", "(", "nextPageLink", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "List", "secrets", "in", "a", "specified", "key", "vault", ".", "The", "Get", "Secrets", "operation", "is", "applicable", "to", "the", "entire", "vault", ".", "However", "only", "the", "base", "secret", "identifier", "and", "its", "attributes", "are", "provided", "in", "the", "response", ".", "Individual", "secret", "versions", "are", "not", "listed", "in", "the", "response", ".", "This", "operation", "requires", "the", "secrets", "/", "list", "permission", "." ]

[ "@", "Override", "public", "String", "getName", "(", "String", "languageId", ",", "boolean", "useDefault", ")", "{", "return", "_cpDefinitionOptionRel", ".", "getName", "(", "languageId", ",", "useDefault", ")", ";", "}" ]

[ "Returns", "the", "localized", "name", "of", "this", "cp", "definition", "option", "rel", "in", "the", "language", "optionally", "using", "the", "default", "language", "if", "no", "localization", "exists", "for", "the", "requested", "language", "." ]

[ "public", "PageFlowController", "getPageFlowForRequest", "(", "RequestContext", "context", ")", "throws", "InstantiationException", ",", "IllegalAccessException", "{", "String", "servletPath", "=", "InternalUtils", ".", "getDecodedServletPath", "(", "context", ".", "getHttpRequest", "(", ")", ")", ";", "return", "getPageFlowForPath", "(", "context", ",", "servletPath", ")", ";", "}" ]

[ "Get", "the", "page", "flow", "instance", "that", "should", "be", "associated", "with", "the", "given", "request", ".", "If", "it", "doesn", "t", "exist", "create", "it", ".", "If", "one", "is", "created", "the", "page", "flow", "stack", "(", "for", "nesting", ")", "will", "be", "cleared", "or", "pushed", "and", "the", "new", "instance", "will", "be", "stored", "as", "the", "current", "page", "flow", "." ]

[ "public", "void", "resolveEqualsHashCodeStyle", "(", "File", "file", ",", "int", "lineIndex", ")", "{", "if", "(", "equalsHashCodeStyle", ".", "equals", "(", "\"smart\"", ")", ")", "{", "equalsHashCodeStyle", "=", "(", "bean", ".", "isImmutable", "(", ")", "?", "\"field\"", ":", "\"getter\"", ")", ";", "}", "if", "(", "equalsHashCodeStyle", ".", "equals", "(", "\"omit\"", ")", "||", "equalsHashCodeStyle", ".", "equals", "(", "\"getter\"", ")", "||", "equalsHashCodeStyle", ".", "equals", "(", "\"field\"", ")", ")", "{", "return", ";", "}", "throw", "new", "BeanCodeGenException", "(", "\"Invalid equals/hashCode style: \"", "+", "equalsHashCodeStyle", "+", "\" in \"", "+", "getBean", "(", ")", ".", "getTypeRaw", "(", ")", "+", "\".\"", "+", "getPropertyName", "(", ")", ",", "file", ",", "lineIndex", ")", ";", "}" ]

[ "Resolves", "the", "equals", "hashCode", "generator", "." ]

[ "public", "Observable", "<", "VirtualMachineExtensionInner", ">", "beginUpdateAsync", "(", "String", "resourceGroupName", ",", "String", "vmName", ",", "String", "vmExtensionName", ",", "VirtualMachineExtensionUpdate", "extensionParameters", ")", "{", "return", "beginUpdateWithServiceResponseAsync", "(", "resourceGroupName", ",", "vmName", ",", "vmExtensionName", ",", "extensionParameters", ")", ".", "map", "(", "new", "Func1", "<", "ServiceResponse", "<", "VirtualMachineExtensionInner", ">", ",", "VirtualMachineExtensionInner", ">", "(", ")", "{", "@", "Override", "public", "VirtualMachineExtensionInner", "call", "(", "ServiceResponse", "<", "VirtualMachineExtensionInner", ">", "response", ")", "{", "return", "response", ".", "body", "(", ")", ";", "}", "}", ")", ";", "}" ]

[ "The", "operation", "to", "update", "the", "extension", "." ]

[ "public", "void", "declareShovel", "(", "String", "vhost", ",", "ShovelInfo", "info", ")", "{", "Map", "<", "String", ",", "Object", ">", "props", "=", "info", ".", "getDetails", "(", ")", ".", "getPublishProperties", "(", ")", ";", "if", "(", "props", "!=", "null", "&&", "props", ".", "isEmpty", "(", ")", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Shovel publish properties must be a non-empty map or null\"", ")", ";", "}", "final", "URI", "uri", "=", "uriWithPath", "(", "\"./parameters/shovel/\"", "+", "encodePathSegment", "(", "vhost", ")", "+", "\"/\"", "+", "encodePathSegment", "(", "info", ".", "getName", "(", ")", ")", ")", ";", "this", ".", "rt", ".", "put", "(", "uri", ",", "info", ")", ";", "}" ]

[ "Declares", "a", "shovel", "." ]

[ "public", "static", "double", "linSimilarity", "(", "int", "[", "]", "a", ",", "int", "[", "]", "b", ")", "{", "check", "(", "a", ",", "b", ")", ";", "// The total amount of information contained in a.", "double", "aInformation", "=", "0", ";", "// The total amount of information contained in b.", "double", "bInformation", "=", "0", ";", "// The total amount of information contained in both vectors.", "double", "combinedInformation", "=", "0", ";", "// Compute the information between the two vectors by iterating over", "// all known values.", "for", "(", "int", "i", "=", "0", ";", "i", "<", "a", ".", "length", ";", "++", "i", ")", "{", "aInformation", "+=", "a", "[", "i", "]", ";", "bInformation", "+=", "b", "[", "i", "]", ";", "if", "(", "a", "[", "i", "]", "!=", "0d", "&&", "b", "[", "i", "]", "!=", "0d", ")", "combinedInformation", "+=", "a", "[", "i", "]", "+", "b", "[", "i", "]", ";", "}", "return", "combinedInformation", "/", "(", "aInformation", "+", "bInformation", ")", ";", "}" ]

[ "Computes", "the", "lin", "similarity", "measure", "which", "is", "motivated", "by", "information", "theory", "priniciples", ".", "This", "works", "best", "if", "both", "vectors", "have", "already", "been", "weighted", "using", "point", "-", "wise", "mutual", "information", ".", "This", "similarity", "measure", "is", "described", "in", "more", "detail", "in", "the", "following", "paper", ":" ]

[ "public", "static", "<", "T", ",", "U", "extends", "Closeable", ">", "T", "withCloseable", "(", "U", "self", ",", "@", "ClosureParams", "(", "value", "=", "FirstParam", ".", "class", ")", "Closure", "<", "T", ">", "action", ")", "throws", "IOException", "{", "try", "{", "T", "result", "=", "action", ".", "call", "(", "self", ")", ";", "Closeable", "temp", "=", "self", ";", "self", "=", "null", ";", "temp", ".", "close", "(", ")", ";", "return", "result", ";", "}", "finally", "{", "DefaultGroovyMethodsSupport", ".", "closeWithWarning", "(", "self", ")", ";", "}", "}" ]

[ "Allows", "this", "closeable", "to", "be", "used", "within", "the", "closure", "ensuring", "that", "it", "is", "closed", "once", "the", "closure", "has", "been", "executed", "and", "before", "this", "method", "returns", "." ]

[ "public", "List", "<", "ResidueRangeAndLength", ">", "getRanges", "(", ")", "{", "String", "currentChain", "=", "\"\"", ";", "ResidueNumber", "first", "=", "null", ";", "ResidueNumber", "prev", "=", "null", ";", "List", "<", "ResidueRangeAndLength", ">", "ranges", "=", "new", "ArrayList", "<", "ResidueRangeAndLength", ">", "(", ")", ";", "for", "(", "ResidueNumber", "rn", ":", "treeMap", ".", "keySet", "(", ")", ")", "{", "if", "(", "!", "rn", ".", "getChainName", "(", ")", ".", "equals", "(", "currentChain", ")", ")", "{", "if", "(", "first", "!=", "null", ")", "{", "ResidueRangeAndLength", "newRange", "=", "new", "ResidueRangeAndLength", "(", "currentChain", ",", "first", ",", "prev", ",", "this", ".", "getLength", "(", "first", ",", "prev", ")", ")", ";", "ranges", ".", "add", "(", "newRange", ")", ";", "}", "first", "=", "rn", ";", "}", "prev", "=", "rn", ";", "currentChain", "=", "rn", ".", "getChainName", "(", ")", ";", "}", "ResidueRangeAndLength", "newRange", "=", "new", "ResidueRangeAndLength", "(", "currentChain", ",", "first", ",", "prev", ",", "this", ".", "getLength", "(", "first", ",", "prev", ")", ")", ";", "ranges", ".", "add", "(", "newRange", ")", ";", "return", "ranges", ";", "}" ]

[ "Returns", "a", "list", "of", "{" ]

[ "public", "Branch", "getBranch", "(", "Object", "projectIdOrPath", ",", "String", "branchName", ")", "throws", "GitLabApiException", "{", "Response", "response", "=", "get", "(", "Response", ".", "Status", ".", "OK", ",", "null", ",", "\"projects\"", ",", "getProjectIdOrPath", "(", "projectIdOrPath", ")", ",", "\"repository\"", ",", "\"branches\"", ",", "urlEncode", "(", "branchName", ")", ")", ";", "return", "(", "response", ".", "readEntity", "(", "Branch", ".", "class", ")", ")", ";", "}" ]

[ "Get", "a", "single", "project", "repository", "branch", "." ]

[ "public", "static", "<", "E", ">", "void", "subtractInPlace", "(", "Counter", "<", "E", ">", "target", ",", "Counter", "<", "E", ">", "arg", ")", "{", "for", "(", "E", "key", ":", "arg", ".", "keySet", "(", ")", ")", "{", "target", ".", "decrementCount", "(", "key", ",", "arg", ".", "getCount", "(", "key", ")", ")", ";", "}", "}" ]

[ "Sets", "each", "value", "of", "target", "to", "be", "target", "[", "k", "]", "-", "arg", "[", "k", "]", "for", "all", "keys", "k", "in", "target", "." ]

[ "public", "void", "setIndexedValue", "(", "String", "propertyName", ",", "int", "index", ",", "Object", "value", ")", "{", "setIndexedValue", "(", "object", ",", "getPropertyOrThrow", "(", "bean", ",", "propertyName", ")", ",", "index", ",", "value", ",", "this", ")", ";", "}" ]

[ "Sets", "the", "value", "of", "the", "specified", "indexed", "property", "in", "the", "wrapped", "object", "." ]

[ "Optional", "<", "MsgEscapingStrategy", ">", "getMsgEscapingStrategy", "(", "SoyNode", "node", ")", "{", "switch", "(", "state", ")", "{", "case", "HTML_PCDATA", ":", "// In normal HTML PCDATA context, it makes sense to escape all of the print nodes, but not", "// escape the entire message. This allows Soy to support putting anchors and other small", "// bits of HTML in messages.", "return", "Optional", ".", "of", "(", "new", "MsgEscapingStrategy", "(", "this", ",", "ImmutableList", ".", "of", "(", ")", ")", ")", ";", "case", "CSS_DQ_STRING", ":", "case", "CSS_SQ_STRING", ":", "case", "JS_DQ_STRING", ":", "case", "JS_SQ_STRING", ":", "case", "TEXT", ":", "case", "URI", ":", "if", "(", "state", "==", "HtmlContext", ".", "URI", "&&", "uriPart", "!=", "UriPart", ".", "QUERY", ")", "{", "// NOTE: Only support the query portion of URIs.", "return", "Optional", ".", "absent", "(", ")", ";", "}", "// In other contexts like JS and CSS strings, it makes sense to treat the message's", "// placeholders as plain text, but escape the entire result of message evaluation.", "return", "Optional", ".", "of", "(", "new", "MsgEscapingStrategy", "(", "new", "Context", "(", "HtmlContext", ".", "TEXT", ")", ",", "getEscapingModes", "(", "node", ",", "ImmutableList", ".", "of", "(", ")", ")", ")", ")", ";", "case", "HTML_RCDATA", ":", "case", "HTML_NORMAL_ATTR_VALUE", ":", "case", "HTML_COMMENT", ":", "// The weirdest case is HTML attributes. Ideally, we'd like to treat these as a text string", "// and escape when done. However, many messages have HTML entities such as &raquo; in them.", "// A good way around this is to escape the print nodes in the message, but normalize", "// (escape except for ampersands) the final message.", "// Also, content inside <title>, <textarea>, and HTML comments have a similar requirement,", "// where any entities in the messages are probably intended to be preserved.", "return", "Optional", ".", "of", "(", "new", "MsgEscapingStrategy", "(", "this", ",", "ImmutableList", ".", "of", "(", "EscapingMode", ".", "NORMALIZE_HTML", ")", ")", ")", ";", "default", ":", "// Other contexts, primarily source code contexts, don't have a meaningful way to support", "// natural language text.", "return", "Optional", ".", "absent", "(", ")", ";", "}", "}" ]

[ "Determines", "the", "strategy", "to", "escape", "Soy", "msg", "tags", "." ]

[ "private", "void", "applyMandatoryAction", "(", "final", "WComponent", "target", ",", "final", "boolean", "mandatory", ")", "{", "if", "(", "target", "instanceof", "Mandatable", ")", "{", "(", "(", "Mandatable", ")", "target", ")", ".", "setMandatory", "(", "mandatory", ")", ";", "}", "else", "if", "(", "target", "instanceof", "Container", ")", "{", "// Apply to the Mandatable children", "Container", "cont", "=", "(", "Container", ")", "target", ";", "final", "int", "size", "=", "cont", ".", "getChildCount", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "++", ")", "{", "WComponent", "child", "=", "cont", ".", "getChildAt", "(", "i", ")", ";", "applyMandatoryAction", "(", "child", ",", "mandatory", ")", ";", "}", "}", "}" ]

[ "Apply", "the", "mandatory", "action", "against", "the", "target", "and", "its", "children", "." ]

[ "public", "static", "FileItem", "fromStream", "(", "DataInputStream", "dataInputStream", ")", "throws", "IOException", "{", "// Über die Version kann gesteuert werden, wieviele Felder gelesen", "// werden. Das ist aus Gründen der Abwärtskompatibilität notwendig.", "// Neue Felder dürfen nur am Ende hinzugefügt werden. Die Version", "// muss dann heraufgesetzt werden.", "byte", "binaryVersion", "=", "dataInputStream", ".", "readByte", "(", ")", ";", "if", "(", "binaryVersion", ">=", "1", ")", "{", "String", "name", "=", "dataInputStream", ".", "readUTF", "(", ")", ";", "long", "length", "=", "dataInputStream", ".", "readLong", "(", ")", ";", "long", "lastModified", "=", "dataInputStream", ".", "readLong", "(", ")", ";", "String", "blobId", "=", "dataInputStream", ".", "readUTF", "(", ")", ";", "return", "new", "FileItem", "(", "name", ",", "blobId", ",", "length", ",", "lastModified", ")", ";", "}", "else", "{", "throw", "new", "IllegalStateException", "(", "\"Unsupported binary version <\"", "+", "binaryVersion", "+", "\">\"", ")", ";", "}", "}" ]

[ "Deserialisiert", "ein", "FileItem", "aus", "einem", "übergebenen", "InputStream", "." ]

[ "void", "ensureSingleLocale", "(", "CmsXmlContainerPage", "containerPage", ",", "CmsResource", "localeRes", ")", "throws", "CmsException", "{", "CmsObject", "cms", "=", "getCmsObject", "(", ")", ";", "Locale", "mainLocale", "=", "CmsLocaleManager", ".", "getMainLocale", "(", "cms", ",", "localeRes", ")", ";", "OpenCms", ".", "getLocaleManager", "(", ")", ";", "Locale", "defaultLocale", "=", "CmsLocaleManager", ".", "getDefaultLocale", "(", ")", ";", "if", "(", "containerPage", ".", "hasLocale", "(", "mainLocale", ")", ")", "{", "removeAllLocalesExcept", "(", "containerPage", ",", "mainLocale", ")", ";", "// remove other locales", "}", "else", "if", "(", "containerPage", ".", "hasLocale", "(", "defaultLocale", ")", ")", "{", "containerPage", ".", "copyLocale", "(", "defaultLocale", ",", "mainLocale", ")", ";", "removeAllLocalesExcept", "(", "containerPage", ",", "mainLocale", ")", ";", "}", "else", "if", "(", "containerPage", ".", "getLocales", "(", ")", ".", "size", "(", ")", ">", "0", ")", "{", "containerPage", ".", "copyLocale", "(", "containerPage", ".", "getLocales", "(", ")", ".", "get", "(", "0", ")", ",", "mainLocale", ")", ";", "removeAllLocalesExcept", "(", "containerPage", ",", "mainLocale", ")", ";", "}", "else", "{", "containerPage", ".", "addLocale", "(", "cms", ",", "mainLocale", ")", ";", "}", "}" ]

[ "Removes", "unnecessary", "locales", "from", "a", "container", "page", ".", "<p", ">" ]

[ "private", "VariantResolver", "registerResolver", "(", "VariantResolver", "defaultResolver", ",", "String", "configPropertyName", ")", "{", "VariantResolver", "resolver", "=", "null", ";", "if", "(", "configProperties", ".", "getProperty", "(", "configPropertyName", ")", "==", "null", ")", "{", "resolver", "=", "defaultResolver", ";", "}", "else", "{", "resolver", "=", "(", "VariantResolver", ")", "ClassLoaderResourceUtils", ".", "buildObjectInstance", "(", "configProperties", ".", "getProperty", "(", "configPropertyName", ")", ")", ";", "}", "this", ".", "generatorRegistry", ".", "registerVariantResolver", "(", "resolver", ")", ";", "return", "resolver", ";", "}" ]

[ "Register", "a", "resolver", "in", "the", "generator", "registry" ]

[ "public", "void", "printDot", "(", "PrintStream", "os", ",", "int", "maxLevelsToPrintPerEdge", ",", "boolean", "detail", ",", "String", "optionalTitle", ",", "PrintMojo", ".", "PrintTreeOptions", "treeOptions", ")", "{", "os", ".", "println", "(", "\"/*\"", ")", ";", "os", ".", "println", "(", "\"Generated by:\"", ")", ";", "os", ".", "println", "(", "\" http://https://github.com/h2oai/h2o-3/tree/master/h2o-genmodel/src/main/java/hex/genmodel/tools/PrintMojo.java\"", ")", ";", "os", ".", "println", "(", "\"*/\"", ")", ";", "os", ".", "println", "(", "\"\"", ")", ";", "os", ".", "println", "(", "\"/*\"", ")", ";", "os", ".", "println", "(", "\"On a mac:\"", ")", ";", "os", ".", "println", "(", "\"\"", ")", ";", "os", ".", "println", "(", "\"$ brew install graphviz\"", ")", ";", "os", ".", "println", "(", "\"$ dot -Tpng file.gv -o file.png\"", ")", ";", "os", ".", "println", "(", "\"$ open file.png\"", ")", ";", "os", ".", "println", "(", "\"*/\"", ")", ";", "os", ".", "println", "(", "\"\"", ")", ";", "os", ".", "println", "(", "\"digraph G {\"", ")", ";", "for", "(", "SharedTreeSubgraph", "sg", ":", "subgraphArray", ")", "{", "sg", ".", "printDot", "(", "os", ",", "maxLevelsToPrintPerEdge", ",", "detail", ",", "optionalTitle", ",", "treeOptions", ")", ";", "}", "os", ".", "println", "(", "\"\"", ")", ";", "os", ".", "println", "(", "\"}\"", ")", ";", "os", ".", "println", "(", "\"\"", ")", ";", "}" ]

[ "Print", "graph", "output", "in", "a", "format", "readable", "by", "dot", "(", "graphviz", ")", ".", "@param", "os", "Stream", "to", "write", "the", "output", "to", "@param", "maxLevelsToPrintPerEdge", "Limit", "the", "number", "of", "individual", "categorical", "level", "names", "printed", "per", "edge", "@param", "detail", "include", "addtional", "node", "detail", "information", "@param", "optionalTitle", "Optional", "title", "to", "override", "the", "default", "@param", "treeOptions", "object", "of", "PrintTreeOptions", "to", "control", "how", "trees", "are", "printed", "in", "terms", "of", "font", "size", "and", "number", "of", "decimal", "places", "for", "numerical", "values" ]

[ "public", "void", "addTransition", "(", "String", "localName", ",", "ElementSelector", "<", "T", ">", "target", ")", "{", "addTransition", "(", "new", "QName", "(", "localName", ")", ",", "target", ")", ";", "}" ]

[ "Create", "a", "transition", "to", "another", "node", "state", "represented", "by", "its", "{", "@link", "ElementSelector", "}", "." ]