Datasets:

---

stojchet

/

base_prediction_dataset

like 0

[ "public", "void", "consumeUntil", "(", "Parser", "recognizer", ",", "IntervalSet", "follow", ",", "CSSLexerState", ".", "RecoveryMode", "mode", ",", "CSSLexerState", "ls", ")", "{", "CSSToken", "t", ";", "boolean", "finish", ";", "TokenStream", "input", "=", "recognizer", ".", "getInputStream", "(", ")", ";", "do", "{", "Token", "next", "=", "input", ".", "LT", "(", "1", ")", ";", "if", "(", "next", "instanceof", "CSSToken", ")", "{", "t", "=", "(", "CSSToken", ")", "input", ".", "LT", "(", "1", ")", ";", "if", "(", "t", ".", "getType", "(", ")", "==", "Token", ".", "EOF", ")", "{", "logger", ".", "trace", "(", "\"token eof \"", ")", ";", "break", ";", "}", "}", "else", "break", ";", "/* not a CSSToken, probably EOF */", "// consume token if does not match", "finish", "=", "(", "t", ".", "getLexerState", "(", ")", ".", "isBalanced", "(", "mode", ",", "ls", ",", "t", ")", "&&", "follow", ".", "contains", "(", "t", ".", "getType", "(", ")", ")", ")", ";", "if", "(", "!", "finish", ")", "{", "logger", ".", "trace", "(", "\"Skipped: {}\"", ",", "t", ")", ";", "input", ".", "consume", "(", ")", ";", "}", "}", "while", "(", "!", "finish", ")", ";", "}" ]

[ "Consumes", "token", "until", "lexer", "state", "is", "function", "-", "balanced", "and", "token", "from", "follow", "is", "matched", "." ]

[ "public", "static", "QueryFactory", "getQueryFactory", "(", "Cache", "<", "?", ",", "?", ">", "cache", ")", "{", "if", "(", "cache", "==", "null", "||", "cache", ".", "getAdvancedCache", "(", ")", "==", "null", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"cache parameter shall not be null\"", ")", ";", "}", "AdvancedCache", "<", "?", ",", "?", ">", "advancedCache", "=", "cache", ".", "getAdvancedCache", "(", ")", ";", "ensureAccessPermissions", "(", "advancedCache", ")", ";", "EmbeddedQueryEngine", "queryEngine", "=", "SecurityActions", ".", "getCacheComponentRegistry", "(", "advancedCache", ")", ".", "getComponent", "(", "EmbeddedQueryEngine", ".", "class", ")", ";", "if", "(", "queryEngine", "==", "null", ")", "{", "throw", "log", ".", "queryModuleNotInitialised", "(", ")", ";", "}", "return", "new", "EmbeddedQueryFactory", "(", "queryEngine", ")", ";", "}" ]

[ "Obtain", "the", "query", "factory", "for", "building", "DSL", "based", "Ickle", "queries", "." ]

[ "private", "boolean", "containsAnnotation", "(", "List", "<", "AnnotationExpr", ">", "annos", ",", "String", "annotationName", ")", "{", "for", "(", "AnnotationExpr", "anno", ":", "annos", ")", "{", "if", "(", "anno", ".", "getName", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "annotationName", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "if", "the", "list", "of", "annotation", "contains", "the", "annotation", "of", "given", "name", "." ]

[ "public", "ObjectTypeNodeMemory", "createMemory", "(", "final", "RuleBaseConfiguration", "config", ",", "InternalWorkingMemory", "wm", ")", "{", "Class", "<", "?", ">", "classType", "=", "(", "(", "ClassObjectType", ")", "getObjectType", "(", ")", ")", ".", "getClassType", "(", ")", ";", "if", "(", "InitialFact", ".", "class", ".", "isAssignableFrom", "(", "classType", ")", ")", "{", "return", "new", "InitialFactObjectTypeNodeMemory", "(", "classType", ")", ";", "}", "return", "new", "ObjectTypeNodeMemory", "(", "classType", ",", "wm", ")", ";", "}" ]

[ "Creates", "memory", "for", "the", "node", "using", "PrimitiveLongMap", "as", "its", "optimised", "for", "storage", "and", "reteivals", "of", "Longs", ".", "However", "PrimitiveLongMap", "is", "not", "ideal", "for", "spase", "data", ".", "So", "it", "should", "be", "monitored", "incase", "its", "more", "optimal", "to", "switch", "back", "to", "a", "standard", "HashMap", "." ]

[ "public", "void", "putToFront", "(", "QueueData", "queueData", ",", "short", "msgBatch", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "entry", "(", "this", ",", "tc", ",", "\"putToFront\"", ",", "new", "Object", "[", "]", "{", "queueData", ",", "msgBatch", "}", ")", ";", "_put", "(", "queueData", ",", "msgBatch", ",", "false", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "SibTr", ".", "exit", "(", "this", ",", "tc", ",", "\"putToFront\"", ")", ";", "}" ]

[ "Places", "a", "message", "on", "to", "the", "front", "of", "the", "proxy", "queue", "so", "that", "the", "next", "get", "operation", "will", "consume", "it", "." ]

[ "public", "static", "Drawable", "inflateCompatOnly", "(", "Resources", "resources", ",", "@", "DrawableRes", "int", "resId", ")", "{", "return", "VectorDrawable", ".", "create", "(", "resources", ",", "resId", ")", ";", "}" ]

[ "Inflates", "a", "<vector", ">", "drawable", "using", "{", "@link", "com", ".", "telly", ".", "mrvector", ".", "VectorDrawable", "}", "implementation", "always", ".", "@param", "resources", "Resources", "to", "use", "for", "inflation", "@param", "resId", "<vector", ">", "drawable", "resource", "@return", "<p", ">", "Inflated", "instance", "of", "{", "@link", "com", ".", "telly", ".", "mrvector", ".", "VectorDrawable", "}", ".", "<", "/", "p", ">" ]

[ "public", "void", "setProperty", "(", "final", "Object", "object", ",", "Object", "newValue", ")", "{", "AccessPermissionChecker", ".", "checkAccessPermission", "(", "field", ")", ";", "final", "Object", "goalValue", "=", "DefaultTypeTransformation", ".", "castToType", "(", "newValue", ",", "field", ".", "getType", "(", ")", ")", ";", "if", "(", "isFinal", "(", ")", ")", "{", "throw", "new", "GroovyRuntimeException", "(", "\"Cannot set the property '\"", "+", "name", "+", "\"' because the backing field is final.\"", ")", ";", "}", "try", "{", "field", ".", "set", "(", "object", ",", "goalValue", ")", ";", "}", "catch", "(", "IllegalAccessException", "ex", ")", "{", "throw", "new", "GroovyRuntimeException", "(", "\"Cannot set the property '\"", "+", "name", "+", "\"'.\"", ",", "ex", ")", ";", "}", "}" ]

[ "Sets", "the", "property", "on", "the", "given", "object", "to", "the", "new", "value" ]

[ "public", "XML", "fillMappedField", "(", "Class", "<", "?", ">", "configuredClass", ",", "MappedField", "configuredField", ")", "{", "Attribute", "attribute", "=", "getGlobalAttribute", "(", "configuredField", ",", "configuredClass", ")", ";", "if", "(", "isNull", "(", "attribute", ")", ")", "attribute", "=", "getAttribute", "(", "configuredField", ",", "configuredClass", ")", ";", "if", "(", "!", "isNull", "(", "attribute", ")", ")", "{", "if", "(", "isEmpty", "(", "configuredField", ".", "getMethod", "(", ")", ")", ")", "configuredField", ".", "getMethod", "(", "attribute", ".", "getGet", "(", ")", ")", ";", "if", "(", "isEmpty", "(", "configuredField", ".", "setMethod", "(", ")", ")", ")", "configuredField", ".", "setMethod", "(", "attribute", ".", "getSet", "(", ")", ")", ";", "}", "return", "this", ";", "}" ]

[ "Enrich", "configuredField", "with", "get", "and", "set", "define", "in", "xml", "configuration", "." ]

[ "public", "static", "Iterable", "<", "MatchResult", ">", "findMatches", "(", "Pattern", "pattern", ",", "CharSequence", "s", ")", "{", "List", "<", "MatchResult", ">", "results", "=", "new", "ArrayList", "<", "MatchResult", ">", "(", ")", ";", "for", "(", "Matcher", "m", "=", "pattern", ".", "matcher", "(", "s", ")", ";", "m", ".", "find", "(", ")", ";", ")", "results", ".", "(", "m", ".", "toMatchResult", "(", ")", ")", ";", "return", "results", ";", "}", "/**\n\t * Sorts a given HashMap using a custom function\n\t * @param m Map of items to sort\n\t * @return sorted List of items\n\t */", "public", "static", "List", "<", "Pattern", ">", "sortByValue", "(", "final", "HashMap", "<", "Pattern", ",", "String", ">", "m", ")", "{", "List", "<", "Pattern", ">", "keys", "=", "new", "ArrayList", "<", "Pattern", ">", "(", ")", ";", "keys", ".", "addAll", "(", "m", ".", "keySet", "(", ")", ")", ";", "Collections", ".", "sort", "(", "keys", ",", "new", "Comparator", "<", "Object", ">", "(", ")", "{", "@", "SuppressWarnings", "(", "{", "\"unchecked\"", ",", "\"rawtypes\"", "}", ")", "public", "int", "compare", "(", "Object", "o1", ",", "Object", "o2", ")", "{", "Object", "v1", "=", "m", ".", "get", "(", "o1", ")", ";", "Object", "v2", "=", "m", ".", "get", "(", "o2", ")", ";", "if", "(", "v1", "==", "null", ")", "{", "return", "(", "v2", "==", "null", ")", "?", "0", ":", "1", ";", "}", "else", "if", "(", "v1", "instanceof", "Comparable", ")", "{", "return", "(", "(", "Comparable", ")", "v1", ")", ".", "compareTo", "(", "v2", ")", ";", "}", "else", "{", "return", "0", ";", "}", "}", "}", ")", ";", "return", "keys", ";", "}", "}" ]

[ "Find", "all", "the", "matches", "of", "a", "pattern", "in", "a", "charSequence", "and", "return", "the", "results", "as", "list", "." ]

[ "public", "static", "void", "insertValue", "(", "HashMap", "m", ",", "String", "var", ",", "String", "val", ",", "String", "path", ")", "{", "insertValue", "(", "m", ",", "var", ",", "val", ",", "path", ",", "false", ")", ";", "}" ]

[ "Inserts", "the", "variable", "in", "the", "appropriate", "place", "in", "a", "{", "@link", "HashMap", "}", "according", "to", "the", "AcePathfinder", "." ]

[ "private", "static", "byte", "unescape", "(", "String", "s", ",", "int", "i", ")", "{", "return", "(", "byte", ")", "Integer", ".", "parseInt", "(", "s", ".", "substring", "(", "i", "+", "1", ",", "i", "+", "3", ")", ",", "16", ")", ";", "}" ]

[ "Un", "-", "escape", "and", "return", "the", "character", "at", "position", "i", "in", "string", "s", "." ]

[ "public", "static", "<", "Key", ",", "Value", ">", "Aggregation", "<", "Key", ",", "Long", ",", "Long", ">", "longMax", "(", ")", "{", "return", "new", "AggregationAdapter", "(", "new", "LongMaxAggregation", "<", "Key", ",", "Value", ">", "(", ")", ")", ";", "}" ]

[ "Returns", "an", "aggregation", "to", "find", "the", "long", "maximum", "of", "all", "supplied", "values", ".", "<br", "/", ">", "This", "aggregation", "is", "similar", "to", ":", "<pre", ">", "SELECT", "MAX", "(", "value", ")", "FROM", "x<", "/", "pre", ">" ]

[ "public", "static", "KeySnapshot", "localSnapshot", "(", "boolean", "homeOnly", ")", "{", "Object", "[", "]", "kvs", "=", "H2O", ".", "STORE", ".", "raw_array", "(", ")", ";", "ArrayList", "<", "KeyInfo", ">", "res", "=", "new", "ArrayList", "<>", "(", ")", ";", "for", "(", "int", "i", "=", "2", ";", "i", "<", "kvs", ".", "length", ";", "i", "+=", "2", ")", "{", "Object", "ok", "=", "kvs", "[", "i", "]", ";", "if", "(", "!", "(", "ok", "instanceof", "Key", ")", ")", "continue", ";", "// Ignore tombstones and Primes and null's", "Key", "key", "=", "(", "Key", ")", "ok", ";", "if", "(", "!", "key", ".", "user_allowed", "(", ")", ")", "continue", ";", "if", "(", "homeOnly", "&&", "!", "key", ".", "home", "(", ")", ")", "continue", ";", "// Raw array can contain regular and also wrapped values into Prime marker class:", "// - if we see Value object, create instance of KeyInfo", "// - if we do not see Value object directly (it can be wrapped in Prime marker class),", "// try to unwrap it via calling STORE.get (~H2O.get) and then", "// look at wrapped value again.", "Value", "val", "=", "Value", ".", "STORE_get", "(", "key", ")", ";", "if", "(", "val", "==", "null", ")", "continue", ";", "res", ".", "add", "(", "new", "KeyInfo", "(", "key", ",", "val", ")", ")", ";", "}", "final", "KeyInfo", "[", "]", "arr", "=", "res", ".", "toArray", "(", "new", "KeyInfo", "[", "res", ".", "size", "(", ")", "]", ")", ";", "Arrays", ".", "sort", "(", "arr", ")", ";", "return", "new", "KeySnapshot", "(", "arr", ")", ";", "}" ]

[ "Get", "the", "user", "keys", "from", "this", "node", "only", "." ]

[ "void", "gc", "(", ")", "{", "if", "(", "stopped", ")", "{", "return", ";", "}", "long", "expirationTime", "=", "System", ".", "currentTimeMillis", "(", ")", "-", "timeout", ";", "for", "(", "Iterator", "<", "Map", ".", "Entry", "<", "InputStreamKey", ",", "TimedStreamEntry", ">", ">", "iter", "=", "streamMap", ".", "entrySet", "(", ")", ".", "iterator", "(", ")", ";", "iter", ".", "hasNext", "(", ")", ";", ")", "{", "if", "(", "stopped", ")", "{", "return", ";", "}", "Map", ".", "Entry", "<", "InputStreamKey", ",", "TimedStreamEntry", ">", "entry", "=", "iter", ".", "next", "(", ")", ";", "TimedStreamEntry", "timedStreamEntry", "=", "entry", ".", "getValue", "(", ")", ";", "if", "(", "timedStreamEntry", ".", "timestamp", ".", "get", "(", ")", "<=", "expirationTime", ")", "{", "iter", ".", "remove", "(", ")", ";", "InputStreamKey", "key", "=", "entry", ".", "getKey", "(", ")", ";", "//noinspection SynchronizationOnLocalVariableOrMethodParameter", "synchronized", "(", "timedStreamEntry", ")", "{", "// ensure there's no race with a request that got a ref before we removed it", "closeStreamEntry", "(", "timedStreamEntry", ",", "key", ".", "requestId", ",", "key", ".", "index", ")", ";", "}", "}", "}", "}" ]

[ "Close", "and", "remove", "expired", "streams", ".", "Package", "protected", "to", "allow", "unit", "tests", "to", "invoke", "it", "." ]

[ "public", "static", "void", "copyToArray", "(", "Collection", "<", "Object", ">", "collection", ",", "Object", "[", "]", "objects", ")", "{", "System", ".", "arraycopy", "(", "collection", ".", "toArray", "(", ")", ",", "0", ",", "objects", ",", "0", ",", "objects", ".", "length", ")", ";", "}" ]

[ "Copy", "collection", "objects", "to", "a", "given", "array" ]

[ "public", "static", "Object", "callGetter", "(", "Object", "o", ",", "String", "prop", ")", "throws", "SecurityException", ",", "NoSuchMethodException", ",", "IllegalArgumentException", ",", "IllegalAccessException", ",", "InvocationTargetException", "{", "prop", "=", "\"get\"", "+", "prop", ";", "Class", "c", "=", "o", ".", "getClass", "(", ")", ";", "Method", "m", "=", "getMethodParameterPairIgnoreCase", "(", "c", ",", "prop", ",", "null", ")", ".", "getMethod", "(", ")", ";", "// Method m=getMethodIgnoreCase(c,prop,null);", "if", "(", "m", ".", "getReturnType", "(", ")", ".", "getName", "(", ")", ".", "equals", "(", "\"void\"", ")", ")", "throw", "new", "NoSuchMethodException", "(", "\"invalid return Type, method [\"", "+", "m", ".", "getName", "(", ")", "+", "\"] can't have return type void\"", ")", ";", "return", "m", ".", "invoke", "(", "o", ",", "null", ")", ";", "}" ]

[ "to", "invoke", "a", "getter", "Method", "of", "a", "Object" ]

[ "private", "void", "updateDeltaFieldConfig", "(", "String", "srcColumnName", ",", "String", "tgtColumnName", ")", "{", "if", "(", "this", ".", "workUnitState", ".", "contains", "(", "ConfigurationKeys", ".", "EXTRACT_DELTA_FIELDS_KEY", ")", ")", "{", "String", "watermarkCol", "=", "this", ".", "workUnitState", ".", "getProp", "(", "ConfigurationKeys", ".", "EXTRACT_DELTA_FIELDS_KEY", ")", ";", "this", ".", "workUnitState", ".", "setProp", "(", "ConfigurationKeys", ".", "EXTRACT_DELTA_FIELDS_KEY", ",", "watermarkCol", ".", "replaceAll", "(", "srcColumnName", ",", "tgtColumnName", ")", ")", ";", "}", "}" ]

[ "Update", "water", "mark", "column", "property", "if", "there", "is", "an", "alias", "defined", "in", "query" ]

[ "public", "static", "HdfsUnderFileSystem", "createInstance", "(", "AlluxioURI", "ufsUri", ",", "UnderFileSystemConfiguration", "conf", ",", "AlluxioConfiguration", "alluxioConf", ")", "{", "Configuration", "hdfsConf", "=", "createConfiguration", "(", "conf", ")", ";", "return", "new", "HdfsUnderFileSystem", "(", "ufsUri", ",", "conf", ",", "hdfsConf", ",", "alluxioConf", ")", ";", "}" ]

[ "Factory", "method", "to", "constructs", "a", "new", "HDFS", "{", "@link", "UnderFileSystem", "}", "instance", "." ]

[ "public", "synchronized", "long", "readFromEnd", "(", "final", "long", "datalen", ",", "final", "ByteBuffer", "buf", ")", "{", "if", "(", "!", "validState", ")", "{", "throw", "new", "InvalidStateException", "(", ")", ";", "}", "final", "long", "size", "=", "size", "(", ")", ";", "final", "long", "offset", "=", "(", "size", "-", "HEADER_LEN", "-", "datalen", "-", "FOOTER_LEN", ")", ";", "return", "read", "(", "offset", ",", "buf", ")", ";", "}" ]

[ "Read", "desired", "block", "of", "datalen", "from", "end", "of", "file" ]

[ "static", "NovaApi", "novaApi", "(", "Map", "<", "String", ",", "String", ">", "targetProperties", ")", "throws", "TargetException", "{", "validate", "(", "targetProperties", ")", ";", "return", "ContextBuilder", ".", "newBuilder", "(", "PROVIDER_NOVA", ")", ".", "endpoint", "(", "targetProperties", ".", "get", "(", "API_URL", ")", ")", ".", "credentials", "(", "identity", "(", "targetProperties", ")", ",", "targetProperties", ".", "get", "(", "PASSWORD", ")", ")", ".", "buildApi", "(", "NovaApi", ".", "class", ")", ";", "}" ]

[ "Creates", "a", "JCloud", "context", "for", "Nova", "." ]

[ "public", "static", "Flux", "<", "ByteBuf", ">", "byteBufStreamFromFile", "(", "AsynchronousFileChannel", "fileChannel", ",", "long", "offset", ",", "long", "length", ")", "{", "return", "byteBufStreamFromFile", "(", "fileChannel", ",", "DEFAULT_CHUNK_SIZE", ",", "offset", ",", "length", ")", ";", "}" ]

[ "Creates", "a", "{", "@link", "Flux", "}", "from", "an", "{", "@link", "AsynchronousFileChannel", "}", "which", "reads", "part", "of", "a", "file", "." ]

[ "protected", "void", "genIrStatus", "(", "List", "<", "IRStatus", "<", "PIR", ">", ">", "statuses", ",", "INode", "node", ")", "throws", "AnalysisException", "{", "IRStatus", "<", "PIR", ">", "status", "=", "generator", ".", "generateFrom", "(", "node", ")", ";", "if", "(", "status", "!=", "null", ")", "{", "statuses", ".", "add", "(", "status", ")", ";", "}", "}" ]

[ "This", "method", "translates", "a", "VDM", "node", "into", "an", "IR", "status", "." ]

[ "public", "static", "void", "setPushNotificationIntegration", "(", "final", "int", "pushProvider", ",", "final", "String", "token", ")", "{", "dispatchConversationTask", "(", "new", "ConversationDispatchTask", "(", ")", "{", "@", "Override", "protected", "boolean", "execute", "(", "Conversation", "conversation", ")", "{", "// Store the push stuff globally", "SharedPreferences", "prefs", "=", "ApptentiveInternal", ".", "getInstance", "(", ")", ".", "getGlobalSharedPrefs", "(", ")", ";", "prefs", ".", "edit", "(", ")", ".", "putInt", "(", "Constants", ".", "PREF_KEY_PUSH_PROVIDER", ",", "pushProvider", ")", ".", "putString", "(", "Constants", ".", "PREF_KEY_PUSH_TOKEN", ",", "token", ")", ".", "apply", "(", ")", ";", "// Also set it on the active Conversation, if there is one.", "conversation", ".", "setPushIntegration", "(", "pushProvider", ",", "token", ")", ";", "return", "true", ";", "}", "}", ",", "\"set push notification integration\"", ")", ";", "}" ]

[ "Sends", "push", "provider", "information", "to", "our", "server", "to", "allow", "us", "to", "send", "pushes", "to", "this", "device", "when", "you", "reply", "to", "your", "customers", ".", "Only", "one", "push", "provider", "is", "allowed", "to", "be", "active", "at", "a", "time", "so", "you", "should", "only", "call", "this", "method", "once", ".", "Please", "see", "our", "<a", "href", "=", "http", ":", "//", "www", ".", "apptentive", ".", "com", "/", "docs", "/", "android", "/", "integration", "/", "#push", "-", "notifications", ">", "integration", "guide<", "/", "a", ">", "for", "instructions", "." ]

[ "public", "MailAccount", "reserveMailAccount", "(", "final", "String", "accountReservationKey", ",", "final", "String", "pool", ")", "{", "if", "(", "pool", "==", "null", "&&", "emailAddressPools", ".", "keySet", "(", ")", ".", "size", "(", ")", ">", "1", ")", "{", "throw", "new", "IllegalStateException", "(", "\"No pool specified but multiple pools available.\"", ")", ";", "}", "String", "poolKey", "=", "pool", "==", "null", "?", "defaultPool", ":", "pool", ";", "List", "<", "MailAccount", ">", "addressPool", "=", "newArrayList", "(", "emailAddressPools", ".", "get", "(", "poolKey", ")", ")", ";", "Collections", ".", "shuffle", "(", "addressPool", ",", "random", ".", "getRandom", "(", ")", ")", ";", "return", "reserveAvailableMailAccount", "(", "accountReservationKey", ",", "addressPool", ")", ";", "}" ]

[ "Reserves", "an", "available", "mail", "account", "from", "the", "specified", "pool", "under", "the", "specified", "reservation", "key", ".", "The", "method", "blocks", "until", "an", "account", "is", "available", "." ]

[ "public", "static", "<", "T1", ",", "T2", ",", "T3", ">", "Func3", "<", "T1", ",", "T2", ",", "T3", ",", "Observable", "<", "Void", ">", ">", "toAsync", "(", "Action3", "<", "?", "super", "T1", ",", "?", "super", "T2", ",", "?", "super", "T3", ">", "action", ")", "{", "return", "toAsync", "(", "action", ",", "Schedulers", ".", "computation", "(", ")", ")", ";", "}" ]

[ "Convert", "a", "synchronous", "action", "call", "into", "an", "asynchronous", "function", "call", "through", "an", "Observable", ".", "<p", ">", "<img", "width", "=", "640", "src", "=", "https", ":", "//", "raw", ".", "github", ".", "com", "/", "wiki", "/", "ReactiveX", "/", "RxJava", "/", "images", "/", "rx", "-", "operators", "/", "toAsync", ".", "an", ".", "png", "alt", "=", ">" ]

[ "protected", "boolean", "isBoolean", "(", "Exchange", "exchange", ",", "Message", "message", ",", "String", "name", ")", "{", "Boolean", "b", "=", "getBoolean", "(", "exchange", ",", "message", ",", "name", ")", ";", "return", "b", "!=", "null", "&&", "b", ".", "booleanValue", "(", ")", ";", "}" ]

[ "Gets", "a", "primitive", "boolean", "context", "property", "." ]

[ "@", "Nullable", "public", "static", "String", "optString", "(", "@", "Nullable", "Bundle", "bundle", ",", "@", "Nullable", "String", "key", ")", "{", "return", "optString", "(", "bundle", ",", "key", ",", "null", ")", ";", "}" ]

[ "Returns", "a", "optional", "{" ]

[ "@", "Given", "(", "\"^services '(.+?)' are splitted correctly in datacenters '(.+?)'$\"", ")", "public", "void", "checkServicesDistributionMultiDataCenterPram", "(", "String", "serviceList", ",", "String", "dataCentersIps", ")", "throws", "Exception", "{", "checkDataCentersDistribution", "(", "serviceList", ".", "split", "(", "\",\"", ")", ",", "dataCentersIps", ".", "split", "(", "\";\"", ")", ")", ";", "}" ]

[ "Check", "if", "all", "task", "of", "a", "service", "are", "correctly", "distributed", "in", "all", "datacenters", "of", "the", "cluster" ]

[ "public", "static", "Builder", "newBuilder", "(", "String", "bucket", ",", "String", "name", ")", "{", "return", "newBuilder", "(", "BlobId", ".", "of", "(", "bucket", ",", "name", ")", ")", ";", "}" ]

[ "Returns", "a", "{" ]

[ "public", "static", "String", "getCellAddressA1Format", "(", "int", "rowNum", ",", "int", "columnNum", ")", "{", "CellAddress", "cellAddr", "=", "new", "CellAddress", "(", "rowNum", ",", "columnNum", ")", ";", "return", "cellAddr", ".", "formatAsString", "(", ")", ";", "}" ]

[ "Generate", "a", "cell", "address", "in", "A1", "format", "from", "a", "row", "and", "column", "number" ]

[ "public", "synchronized", "void", "setOption", "(", "String", "key", ",", "String", "value", ")", "{", "if", "(", "key", "==", "null", "||", "value", "==", "null", ")", "{", "return", ";", "}", "config", ".", "put", "(", "key", ",", "value", ")", ";", "}" ]

[ "Set", "a", "value", "to", "the", "backed", "properties", "in", "this", "module", "config", "." ]

[ "public", "int", "bindValues", "(", "PreparedStatement", "stmt", ",", "ValueContainer", "[", "]", "values", ",", "int", "index", ")", "throws", "SQLException", "{", "if", "(", "values", "!=", "null", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "values", ".", "length", ";", "i", "++", ")", "{", "setObjectForStatement", "(", "stmt", ",", "index", ",", "values", "[", "i", "]", ".", "getValue", "(", ")", ",", "values", "[", "i", "]", ".", "getJdbcType", "(", ")", ".", "getType", "(", ")", ")", ";", "index", "++", ";", "}", "}", "return", "index", ";", "}" ]

[ "binds", "the", "given", "array", "of", "values", "(", "if", "not", "null", ")", "starting", "from", "the", "given", "parameter", "index" ]

[ "public", "static", "void", "assertValidNode", "(", "MetadataStore", "metadataStore", ",", "Integer", "nodeId", ")", "{", "if", "(", "!", "metadataStore", ".", "getCluster", "(", ")", ".", "hasNodeWithId", "(", "nodeId", ")", ")", "{", "throw", "new", "InvalidMetadataException", "(", "\"NodeId \"", "+", "nodeId", "+", "\" is not or no longer in this cluster\"", ")", ";", "}", "}" ]

[ "Check", "if", "the", "the", "nodeId", "is", "present", "in", "the", "cluster", "managed", "by", "the", "metadata", "store", "or", "throw", "an", "exception", "." ]

[ "public", "Response", "setSafetyLevel", "(", "String", "photoId", ",", "JinxConstants", ".", "SafetyLevel", "safetyLevel", ",", "boolean", "hidden", ")", "throws", "JinxException", "{", "JinxUtils", ".", "validateParams", "(", "photoId", ")", ";", "Map", "<", "String", ",", "String", ">", "params", "=", "new", "TreeMap", "<>", "(", ")", ";", "params", ".", "put", "(", "\"method\"", ",", "\"flickr.photos.setSafetyLevel\"", ")", ";", "params", ".", "put", "(", "\"photo_id\"", ",", "photoId", ")", ";", "if", "(", "safetyLevel", "!=", "null", ")", "{", "params", ".", "put", "(", "\"safety_level\"", ",", "Integer", ".", "toString", "(", "JinxUtils", ".", "safetyLevelToFlickrSafteyLevelId", "(", "safetyLevel", ")", ")", ")", ";", "}", "params", ".", "put", "(", "\"hidden\"", ",", "hidden", "?", "\"1\"", ":", "\"0\"", ")", ";", "return", "jinx", ".", "flickrPost", "(", "params", ",", "Response", ".", "class", ")", ";", "}" ]

[ "Set", "the", "safety", "level", "of", "a", "photo", ".", "<br", ">", "This", "method", "requires", "authentication", "with", "write", "permission", "." ]

[ "public", "final", "void", "changeEndDate", "(", "LocalDate", "date", ",", "boolean", "keepDuration", ")", "{", "requireNonNull", "(", "date", ")", ";", "Interval", "interval", "=", "getInterval", "(", ")", ";", "LocalDateTime", "newEndDateTime", "=", "getEndAsLocalDateTime", "(", ")", ".", "with", "(", "date", ")", ";", "LocalDateTime", "startDateTime", "=", "getStartAsLocalDateTime", "(", ")", ";", "if", "(", "keepDuration", ")", "{", "startDateTime", "=", "newEndDateTime", ".", "minus", "(", "getDuration", "(", ")", ")", ";", "setInterval", "(", "startDateTime", ",", "newEndDateTime", ",", "getZoneId", "(", ")", ")", ";", "}", "else", "{", "/*\n * We might have a problem if the new end time is BEFORE the current start time.\n */", "if", "(", "newEndDateTime", ".", "isBefore", "(", "startDateTime", ")", ")", "{", "interval", "=", "interval", ".", "withStartDateTime", "(", "newEndDateTime", ".", "minus", "(", "interval", ".", "getDuration", "(", ")", ")", ")", ";", "}", "setInterval", "(", "interval", ".", "withEndDate", "(", "date", ")", ")", ";", "}", "}" ]

[ "Changes", "the", "end", "date", "of", "the", "entry", "interval", "." ]

[ "protected", "void", "setSslSupport", "(", "SSLSupport", "service", ",", "Map", "<", "String", ",", "Object", ">", "props", ")", "{", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "entry", "(", "tc", ",", "\"setSslSupport\"", ",", "service", ")", ";", "}", "sslSupport", "=", "service", ";", "defaultId", "=", "(", "String", ")", "props", ".", "get", "(", "SSL_CFG_REF", ")", ";", "if", "(", "TraceComponent", ".", "isAnyTracingEnabled", "(", ")", "&&", "tc", ".", "isEntryEnabled", "(", ")", ")", "{", "Tr", ".", "exit", "(", "tc", ",", "\"setSslSupport\"", ",", "\"defaultConfigId=\"", "+", "defaultId", ")", ";", "}", "}" ]

[ "Required", "service", ":", "this", "is", "not", "dynamic", "and", "so", "is", "called", "before", "activate" ]

[ "public", "Iterator", "getReportQueryIteratorByQuery", "(", "Query", "query", ")", "throws", "PersistenceBrokerException", "{", "ClassDescriptor", "cld", "=", "getClassDescriptor", "(", "query", ".", "getSearchClass", "(", ")", ")", ";", "return", "getReportQueryIteratorFromQuery", "(", "query", ",", "cld", ")", ";", "}" ]

[ "Get", "an", "Iterator", "based", "on", "the", "ReportQuery" ]

[ "private", "IRing", "prepareRing", "(", "List", "vec", ",", "IAtomContainer", "mol", ")", "{", "// add the atoms in vec to the new ring", "int", "atomCount", "=", "vec", ".", "size", "(", ")", ";", "IRing", "ring", "=", "mol", ".", "getBuilder", "(", ")", ".", "newInstance", "(", "IRing", ".", "class", ",", "atomCount", ")", ";", "IAtom", "[", "]", "atoms", "=", "new", "IAtom", "[", "atomCount", "]", ";", "vec", ".", "toArray", "(", "atoms", ")", ";", "ring", ".", "setAtoms", "(", "atoms", ")", ";", "// add the bonds in mol to the new ring", "try", "{", "IBond", "b", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "atomCount", "-", "1", ";", "i", "++", ")", "{", "b", "=", "mol", ".", "getBond", "(", "atoms", "[", "i", "]", ",", "atoms", "[", "i", "+", "1", "]", ")", ";", "if", "(", "b", "!=", "null", ")", "{", "ring", ".", "addBond", "(", "b", ")", ";", "}", "else", "{", "logger", ".", "error", "(", "\"This should not happen.\"", ")", ";", "}", "}", "b", "=", "mol", ".", "getBond", "(", "atoms", "[", "0", "]", ",", "atoms", "[", "atomCount", "-", "1", "]", ")", ";", "if", "(", "b", "!=", "null", ")", "{", "ring", ".", "addBond", "(", "b", ")", ";", "}", "else", "{", "logger", ".", "error", "(", "\"This should not happen either.\"", ")", ";", "}", "}", "catch", "(", "Exception", "exc", ")", "{", "logger", ".", "debug", "(", "exc", ")", ";", "}", "logger", ".", "debug", "(", "\"found Ring \"", ",", "ring", ")", ";", "return", "ring", ";", "}" ]

[ "Returns", "the", "ring", "that", "is", "formed", "by", "the", "atoms", "in", "the", "given", "vector", "." ]

[ "public", "final", "String", "collapseFrom", "(", "String", "s", ",", "char", "replacementCharacter", ")", "{", "final", "StringBuilder", "sb", "=", "new", "StringBuilder", "(", ")", ";", "boolean", "follows", "=", "false", ";", "for", "(", "int", "offset", "=", "0", ";", "offset", "<", "s", ".", "length", "(", ")", ";", ")", "{", "final", "int", "codePoint", "=", "s", ".", "codePointAt", "(", "offset", ")", ";", "if", "(", "matches", "(", "codePoint", ")", ")", "{", "if", "(", "!", "follows", ")", "{", "sb", ".", "append", "(", "replacementCharacter", ")", ";", "}", "follows", "=", "true", ";", "}", "else", "{", "sb", ".", "appendCodePoint", "(", "codePoint", ")", ";", "follows", "=", "false", ";", "}", "offset", "+=", "Character", ".", "charCount", "(", "codePoint", ")", ";", "}", "return", "sb", ".", "toString", "(", ")", ";", "}" ]

[ "Returns", "a", "copy", "of", "the", "input", "string", "with", "all", "groups", "of", "1", "or", "more", "successive", "matching", "characters", "are", "replaced", "with", "{" ]

[ "public", "URBridgeEntity", "createObject", "(", "Entity", "entity", ",", "URBridge", "urBridge", ",", "Map", "<", "String", ",", "String", ">", "attrMap", ",", "String", "baseEntryName", ",", "Map", "<", "String", ",", "String", ">", "entityConfigMap", ")", "throws", "WIMException", "{", "String", "entityType", "=", "entity", ".", "getTypeName", "(", ")", ";", "URBridgeEntity", "obj", "=", "null", ";", "if", "(", "Service", ".", "DO_GROUP", ".", "equals", "(", "entityType", ")", "||", "Entity", ".", "getSubEntityTypes", "(", "Service", ".", "DO_GROUP", ")", ".", "contains", "(", "entityType", ")", ")", "{", "obj", "=", "new", "URBridgeGroup", "(", "entity", ",", "urBridge", ",", "attrMap", ",", "baseEntryName", ",", "entityConfigMap", ")", ";", "}", "else", "if", "(", "Service", ".", "DO_LOGIN_ACCOUNT", ".", "equals", "(", "entityType", ")", "||", "Entity", ".", "getSubEntityTypes", "(", "Service", ".", "DO_LOGIN_ACCOUNT", ")", ".", "contains", "(", "entityType", ")", ")", "{", "obj", "=", "new", "URBridgePerson", "(", "entity", ",", "urBridge", ",", "attrMap", ",", "baseEntryName", ",", "entityConfigMap", ")", ";", "}", "else", "{", "throw", "new", "WIMApplicationException", "(", "WIMMessageKey", ".", "ENTITY_TYPE_NOT_SUPPORTED", ",", "Tr", ".", "formatMessage", "(", "tc", ",", "WIMMessageKey", ".", "ENTITY_TYPE_NOT_SUPPORTED", ",", "WIMMessageHelper", ".", "generateMsgParms", "(", "entityType", ")", ")", ")", ";", "}", "return", "obj", ";", "}" ]

[ "Create", "a", "URBridgeEntity", "from", "input", "parameters", ".", "With", "inheritance", "this", "allows", "Users", "and", "Groups", "to", "be", "treated", "identically", "." ]

[ "public", "int", "drainTo", "(", "@", "NotNull", "ByteBufQueue", "dest", ",", "int", "maxSize", ")", "{", "int", "s", "=", "maxSize", ";", "while", "(", "s", "!=", "0", "&&", "hasRemaining", "(", ")", ")", "{", "ByteBuf", "buf", "=", "takeAtMost", "(", "s", ")", ";", "dest", ".", "add", "(", "buf", ")", ";", "s", "-=", "buf", ".", "readRemaining", "(", ")", ";", "}", "return", "maxSize", "-", "s", ";", "}" ]

[ "Adds", "to", "ByteBufQueue", "{", "@code", "dest", "}", "{", "@code", "maxSize", "}", "bytes", "from", "this", "queue", ".", "If", "this", "queue", "doesn", "t", "contain", "enough", "bytes", "adds", "all", "bytes", "from", "this", "queue", "." ]

[ "public", "static", "<", "T", ",", "R", ">", "R", "firstNonNull", "(", "Function", "<", "T", ",", "R", ">", "function", ",", "Collection", "<", "T", ">", "values", ")", "{", "return", "values", "==", "null", "?", "null", ":", "firstNonNull", "(", "function", ",", "values", ".", "stream", "(", ")", ")", ";", "}" ]

[ "Gets", "first", "result", "of", "function", "which", "is", "not", "null", "." ]

[ "@", "Override", "public", "R", "visitIntersection", "(", "IntersectionType", "t", ",", "P", "p", ")", "{", "return", "defaultAction", "(", "t", ",", "p", ")", ";", "}" ]

[ "This", "implementation", "visits", "an", "{", "@code", "IntersectionType", "}", "by", "calling", "{", "@code", "defaultAction", "}", "." ]

[ "public", "void", "setPatternMatrix", "(", "float", "a", ",", "float", "b", ",", "float", "c", ",", "float", "d", ",", "float", "e", ",", "float", "f", ")", "{", "setMatrix", "(", "a", ",", "b", ",", "c", ",", "d", ",", "e", ",", "f", ")", ";", "}" ]

[ "Sets", "the", "transformation", "matrix", "for", "the", "pattern", "." ]

[ "private", "JvmAnnotationReference", "addAnnotationSafe", "(", "JvmAnnotationTarget", "target", ",", "Class", "<", "?", ">", "annotationType", ",", "String", "...", "values", ")", "{", "assert", "target", "!=", "null", ";", "assert", "annotationType", "!=", "null", ";", "try", "{", "final", "JvmAnnotationReference", "annotationRef", "=", "this", ".", "_annotationTypesBuilder", ".", "annotationRef", "(", "annotationType", ",", "values", ")", ";", "if", "(", "annotationRef", "!=", "null", ")", "{", "if", "(", "target", ".", "getAnnotations", "(", ")", ".", "add", "(", "annotationRef", ")", ")", "{", "return", "annotationRef", ";", "}", "}", "}", "catch", "(", "IllegalArgumentException", "exception", ")", "{", "// Ignore", "}", "return", "null", ";", "}" ]

[ "Add", "annotation", "safely", "." ]

[ "public", "<", "F", "extends", "android", ".", "support", ".", "v4", ".", "app", ".", "Fragment", ">", "void", "supportSetTypeface", "(", "F", "fragment", ",", "@", "StringRes", "int", "strResId", ",", "int", "style", ")", "{", "supportSetTypeface", "(", "fragment", ",", "mApplication", ".", "getString", "(", "strResId", ")", ",", "style", ")", ";", "}" ]

[ "Set", "the", "typeface", "to", "the", "all", "text", "views", "belong", "to", "the", "fragment", ".", "Make", "sure", "to", "call", "this", "method", "after", "fragment", "view", "creation", ".", "And", "this", "is", "a", "support", "package", "fragments", "only", "." ]

[ "public", "Set", "<", "String", ">", "getIdAttributes", "(", "final", "BuildData", "buildData", ")", "{", "final", "Set", "<", "String", ">", "ids", "=", "new", "HashSet", "<", "String", ">", "(", ")", ";", "// Add all the level id attributes", "for", "(", "final", "Level", "level", ":", "levels", ")", "{", "ids", ".", "add", "(", "level", ".", "getUniqueLinkId", "(", "buildData", ".", "isUseFixedUrls", "(", ")", ")", ")", ";", "}", "// Add all the topic id attributes", "for", "(", "final", "Entry", "<", "Integer", ",", "List", "<", "ITopicNode", ">", ">", "topicEntry", ":", "topics", ".", "entrySet", "(", ")", ")", "{", "final", "List", "<", "ITopicNode", ">", "topics", "=", "topicEntry", ".", "getValue", "(", ")", ";", "for", "(", "final", "ITopicNode", "topic", ":", "topics", ")", "{", "if", "(", "topic", "instanceof", "SpecTopic", ")", "{", "final", "SpecTopic", "specTopic", "=", "(", "SpecTopic", ")", "topic", ";", "ids", ".", "add", "(", "specTopic", ".", "getUniqueLinkId", "(", "buildData", ".", "isUseFixedUrls", "(", ")", ")", ")", ";", "}", "}", "}", "return", "ids", ";", "}" ]

[ "Get", "a", "list", "of", "all", "the", "ID", "Attributes", "of", "all", "the", "topics", "and", "levels", "held", "in", "the", "database", "." ]

[ "public", "static", "SslContextBuilder", "forServer", "(", "InputStream", "keyCertChain", ",", "InputStream", "key", ")", "{", "return", "configure", "(", "SslContextBuilder", ".", "forServer", "(", "keyCertChain", ",", "key", ")", ")", ";", "}" ]

[ "Creates", "a", "SslContextBuilder", "with", "ciphers", "and", "APN", "appropriate", "for", "gRPC", "." ]

[ "public", "Object", "putNodeMetaData", "(", "Object", "key", ",", "Object", "value", ")", "{", "if", "(", "key", "==", "null", ")", "throw", "new", "GroovyBugError", "(", "\"Tried to set meta data with null key on \"", "+", "this", "+", "\".\"", ")", ";", "if", "(", "metaDataMap", "==", "null", ")", "{", "metaDataMap", "=", "new", "ListHashMap", "(", ")", ";", "}", "return", "metaDataMap", ".", "put", "(", "key", ",", "value", ")", ";", "}" ]

[ "Sets", "the", "node", "meta", "data", "but", "allows", "overwriting", "values", "." ]

[ "@", "Deprecated", "public", "static", "int", "indexOf", "(", "CharSequence", "s", ",", "int", "codePoint", ")", "{", "int", "cp", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "s", ".", "length", "(", ")", ";", "i", "+=", "Character", ".", "charCount", "(", "cp", ")", ")", "{", "cp", "=", "Character", ".", "codePointAt", "(", "s", ",", "i", ")", ";", "if", "(", "cp", "==", "codePoint", ")", "{", "return", "i", ";", "}", "}", "return", "-", "1", ";", "}" ]

[ "Find", "code", "point", "in", "string", "." ]

[ "@", "OnOpen", "public", "void", "onOpen", "(", "Session", "session", ",", "EndpointConfig", "config", ")", "throws", "IOException", "{", "this", ".", "session", "=", "session", ";", "session", ".", "getBasicRemote", "(", ")", ".", "sendText", "(", "\"websocket client ready\"", ")", ";", "}" ]

[ "On", "handshake", "completed", "get", "the", "WebSocket", "Session", "and", "send", "a", "message", "to", "ServerEndpoint", "that", "WebSocket", "is", "ready", ".", "http", ":", "//", "docs", ".", "saltstack", ".", "com", "/", "en", "/", "latest", "/", "ref", "/", "netapi", "/", "all", "/", "salt", ".", "netapi", ".", "rest_cherrypy", ".", "html#ws" ]

[ "private", "VarSymbol", "makeSyntheticVar", "(", "long", "flags", ",", "String", "name", ",", "Type", "type", ",", "Symbol", "owner", ")", "{", "return", "makeSyntheticVar", "(", "flags", ",", "names", ".", "fromString", "(", "name", ")", ",", "type", ",", "owner", ")", ";", "}" ]

[ "Create", "new", "synthetic", "variable", "with", "given", "flags", "name", "type", "owner" ]

[ "public", "void", "update", "(", "long", "id", ",", "GpsTraceDetails", ".", "Visibility", "visibility", ",", "String", "description", ",", "List", "<", "String", ">", "tags", ")", "{", "checkFieldLength", "(", "\"Description\"", ",", "description", ")", ";", "checkTagsLength", "(", "tags", ")", ";", "GpsTraceWriter", "writer", "=", "new", "GpsTraceWriter", "(", "id", ",", "visibility", ",", "description", ",", "tags", ")", ";", "osm", ".", "makeAuthenticatedRequest", "(", "GPX", "+", "\"/\"", "+", "id", ",", "\"PUT\"", ",", "writer", ")", ";", "}" ]

[ "Change", "the", "visibility", "description", "and", "tags", "of", "a", "GPS", "trace", ".", "description", "and", "tags", "may", "be", "null", "if", "there", "should", "be", "none", "." ]

[ "public", "static", "String", "readFile", "(", "InputStream", "file", ")", "{", "try", "(", "BufferedInputStream", "stream", "=", "new", "BufferedInputStream", "(", "file", ")", ")", "{", "byte", "[", "]", "buff", "=", "new", "byte", "[", "1024", "]", ";", "StringBuilder", "builder", "=", "new", "StringBuilder", "(", ")", ";", "int", "read", ";", "while", "(", "(", "read", "=", "stream", ".", "read", "(", "buff", ")", ")", "!=", "-", "1", ")", "{", "builder", ".", "append", "(", "new", "String", "(", "buff", ",", "0", ",", "read", ",", "StandardCharsets", ".", "UTF_8", ")", ")", ";", "}", "return", "builder", ".", "toString", "(", ")", ";", "}", "catch", "(", "IOException", "e", ")", "{", "throw", "new", "RuntimeException", "(", "e", ")", ";", "}", "}" ]

[ "Reads", "the", "{" ]

[ "protected", "static", "int", "readInt", "(", "InputStream", "input", ",", "int", "bytesNumber", ",", "boolean", "bigEndian", ")", "throws", "IOException", "{", "final", "int", "oneByte", "=", "8", ";", "int", "ret", "=", "0", ";", "int", "sv", ";", "if", "(", "bigEndian", ")", "{", "sv", "=", "(", "bytesNumber", "-", "1", ")", "*", "oneByte", ";", "}", "else", "{", "sv", "=", "0", ";", "}", "final", "int", "cnt", ";", "if", "(", "bigEndian", ")", "{", "cnt", "=", "-", "oneByte", ";", "}", "else", "{", "cnt", "=", "oneByte", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "bytesNumber", ";", "i", "++", ")", "{", "ret", "|=", "input", ".", "read", "(", ")", "<<", "sv", ";", "sv", "+=", "cnt", ";", "}", "return", "ret", ";", "}" ]

[ "Read", "integer", "in", "image", "data", "." ]

[ "public", "void", "writeBinaryString", "(", "byte", "[", "]", "data", ")", "throws", "IOException", "{", "if", "(", "data", "==", "null", ")", "writeInt", "(", "0", ")", ";", "else", "writeBinaryString", "(", "data", ",", "0", ",", "data", ".", "length", ")", ";", "}" ]

[ "Write", "a", "binary", "string", "to", "the", "array", "." ]

[ "private", "void", "setAndValidateProperties", "(", "String", "systemDomain", ",", "String", "defaultAppDomain", ")", "{", "if", "(", "isConfigurationDefinedInFile", "(", ")", ")", "{", "if", "(", "(", "systemDomain", "==", "null", ")", "||", "systemDomain", ".", "isEmpty", "(", ")", ")", "{", "Tr", ".", "error", "(", "tc", ",", "\"SECURITY_SERVICE_ERROR_MISSING_ATTRIBUTE\"", ",", "CFG_KEY_SYSTEM_DOMAIN", ")", ";", "throw", "new", "IllegalArgumentException", "(", "Tr", ".", "formatMessage", "(", "tc", ",", "\"SECURITY_SERVICE_ERROR_MISSING_ATTRIBUTE\"", ",", "CFG_KEY_SYSTEM_DOMAIN", ")", ")", ";", "}", "this", ".", "cfgSystemDomain", "=", "systemDomain", ";", "if", "(", "(", "defaultAppDomain", "==", "null", ")", "||", "defaultAppDomain", ".", "isEmpty", "(", ")", ")", "{", "this", ".", "cfgDefaultAppDomain", "=", "systemDomain", ";", "}", "else", "{", "this", ".", "cfgDefaultAppDomain", "=", "defaultAppDomain", ";", "}", "}", "}" ]

[ "Sets", "and", "validates", "the", "configuration", "properties", ".", "If", "the", "{", "@link", "#CFG_KEY_DEFAULT_APP_DOMAIN", "}", "property", "is", "not", "set", "then", "it", "will", "use", "the", "value", "of", "{", "@link", "#CFG_KEY_SYSTEM_DOMAIN", "}", "." ]

[ "private", "void", "addRecentExample", "(", "final", "String", "text", ",", "final", "ExampleData", "data", ",", "final", "boolean", "select", ")", "{", "WMenuItem", "item", "=", "new", "WMenuItem", "(", "text", ",", "new", "SelectExampleAction", "(", ")", ")", ";", "item", ".", "setCancel", "(", "true", ")", ";", "menu", ".", "add", "(", "item", ")", ";", "item", ".", "setActionObject", "(", "data", ")", ";", "if", "(", "select", ")", "{", "menu", ".", "setSelectedMenuItem", "(", "item", ")", ";", "}", "}" ]

[ "Adds", "an", "example", "to", "the", "recent", "subMenu", "." ]

[ "public", "static", "double", "klDivergence", "(", "double", "[", "]", "a", ",", "double", "[", "]", "b", ")", "{", "check", "(", "a", ",", "b", ")", ";", "double", "divergence", "=", "0", ";", "// Iterate over all values and ignore any that are zero.", "for", "(", "int", "i", "=", "0", ";", "i", "<", "a", ".", "length", ";", "++", "i", ")", "{", "// Ignore values from a that are zero, since they would cause a", "// divide by zero error.", "if", "(", "b", "[", "i", "]", "==", "0d", ")", "throw", "new", "IllegalArgumentException", "(", "\"The KL-divergence is not defined when a[i] > 0 and \"", "+", "\"b[i] == 0.\"", ")", ";", "else", "if", "(", "a", "[", "i", "]", "!=", "0d", ")", "divergence", "+=", "a", "[", "i", "]", "*", "Math", ".", "log", "(", "a", "[", "i", "]", "/", "b", "[", "i", "]", ")", ";", "}", "return", "divergence", ";", "}" ]

[ "Computes", "the", "K", "-", "L", "Divergence", "of", "two", "probability", "distributions", "{", "@code", "A", "}", "and", "{", "@code", "B", "}", "where", "the", "vectors", "{", "@code", "a", "}", "and", "{", "@code", "b", "}", "correspond", "to", "{", "@code", "n", "}", "samples", "from", "each", "respective", "distribution", ".", "The", "divergence", "between", "two", "samples", "is", "non", "-", "symmetric", "and", "is", "frequently", "used", "as", "a", "distance", "metric", "between", "vectors", "from", "a", "semantic", "space", ".", "This", "metric", "is", "described", "in", "more", "detail", "in", "the", "following", "paper", ":" ]

[ "@", "SuppressWarnings", "(", "{", "\"WeakerAccess\"", ",", "\"unused\"", "}", ")", "// For library users", "public", "Styler", "setInput", "(", "@", "NonNull", "JSONObject", "result", ",", "@", "NonNull", "String", "attribute", ",", "boolean", "inverted", ")", "{", "final", "String", "highlightedAttribute", "=", "getHighlightedAttribute", "(", "result", ",", "attribute", ",", "inverted", ",", "false", ")", ";", "return", "setInput", "(", "highlightedAttribute", ")", ";", "}" ]

[ "Sets", "the", "input", "to", "highlight", "." ]

[ "public", "RetrievableStateHandle", "<", "T", ">", "addAndLock", "(", "String", "pathInZooKeeper", ",", "T", "state", ")", "throws", "Exception", "{", "checkNotNull", "(", "pathInZooKeeper", ",", "\"Path in ZooKeeper\"", ")", ";", "checkNotNull", "(", "state", ",", "\"State\"", ")", ";", "final", "String", "path", "=", "normalizePath", "(", "pathInZooKeeper", ")", ";", "RetrievableStateHandle", "<", "T", ">", "storeHandle", "=", "storage", ".", "store", "(", "state", ")", ";", "boolean", "success", "=", "false", ";", "try", "{", "// Serialize the state handle. This writes the state to the backend.", "byte", "[", "]", "serializedStoreHandle", "=", "InstantiationUtil", ".", "serializeObject", "(", "storeHandle", ")", ";", "// Write state handle (not the actual state) to ZooKeeper. This is expected to be", "// smaller than the state itself. This level of indirection makes sure that data in", "// ZooKeeper is small, because ZooKeeper is designed for data in the KB range, but", "// the state can be larger.", "// Create the lock node in a transaction with the actual state node. That way we can prevent", "// race conditions with a concurrent delete operation.", "client", ".", "inTransaction", "(", ")", ".", "create", "(", ")", ".", "withMode", "(", "CreateMode", ".", "PERSISTENT", ")", ".", "forPath", "(", "path", ",", "serializedStoreHandle", ")", ".", "and", "(", ")", ".", "create", "(", ")", ".", "withMode", "(", "CreateMode", ".", "EPHEMERAL", ")", ".", "forPath", "(", "getLockPath", "(", "path", ")", ")", ".", "and", "(", ")", ".", "commit", "(", ")", ";", "success", "=", "true", ";", "return", "storeHandle", ";", "}", "catch", "(", "KeeperException", ".", "NodeExistsException", "e", ")", "{", "throw", "new", "ConcurrentModificationException", "(", "\"ZooKeeper unexpectedly modified\"", ",", "e", ")", ";", "}", "finally", "{", "if", "(", "!", "success", ")", "{", "// Cleanup the state handle if it was not written to ZooKeeper.", "if", "(", "storeHandle", "!=", "null", ")", "{", "storeHandle", ".", "discardState", "(", ")", ";", "}", "}", "}", "}" ]

[ "Creates", "a", "state", "handle", "stores", "it", "in", "ZooKeeper", "and", "locks", "it", ".", "A", "locked", "node", "cannot", "be", "removed", "by", "another", "{", "@link", "ZooKeeperStateHandleStore", "}", "instance", "as", "long", "as", "this", "instance", "remains", "connected", "to", "ZooKeeper", "." ]

[ "void", "parseHeader", "(", "String", "header", ",", "Set", "<", "String", ">", "packages", ")", "{", "if", "(", "header", "!=", "null", "&&", "header", ".", "length", "(", ")", ">", "0", ")", "{", "List", "<", "String", ">", "splitPackages", "=", "new", "ArrayList", "<", "String", ">", "(", ")", ";", "// We can't just split() on commas, because there may be things in quotes, like uses clauses", "int", "lastIndex", "=", "0", ";", "boolean", "inQuotedSection", "=", "false", ";", "int", "i", "=", "0", ";", "for", "(", "i", "=", "0", ";", "i", "<", "header", ".", "length", "(", ")", ";", "i", "++", ")", "{", "if", "(", "(", "header", ".", "charAt", "(", "i", ")", "==", "'", "'", ")", "&&", "!", "(", "inQuotedSection", ")", ")", "{", "String", "packagePlusAttributesAndDirectives", "=", "header", ".", "substring", "(", "lastIndex", ",", "i", ")", ";", "lastIndex", "=", "i", "+", "1", ";", "splitPackages", ".", "add", "(", "packagePlusAttributesAndDirectives", ")", ";", "}", "else", "if", "(", "header", ".", "charAt", "(", "i", ")", "==", "'", "'", ")", "{", "inQuotedSection", "=", "!", "inQuotedSection", ";", "}", "}", "// Add the last string", "splitPackages", ".", "add", "(", "header", ".", "substring", "(", "lastIndex", ",", "i", ")", ")", ";", "// Now go through and handle the attributes", "for", "(", "String", "packagePlusAttributesAndDirectives", ":", "splitPackages", ")", "{", "String", "[", "]", "bits", "=", "packagePlusAttributesAndDirectives", ".", "split", "(", "\";\"", ")", ";", "// We could also process ibm-api-type and other declarations here to get better information if we need it", "packages", ".", "add", "(", "bits", "[", "0", "]", ")", ";", "}", "}", "}" ]

[ "This", "algorithm", "is", "nuts", ".", "Bnd", "has", "a", "nice", "on", "in", "OSGIHeader", "." ]

[ "private", "void", "addSubjectAlternativeNameInternal", "(", "int", "type", ",", "Object", "name", ")", "throws", "IOException", "{", "// First, ensure that the name parses", "GeneralNameInterface", "tempName", "=", "makeGeneralNameInterface", "(", "type", ",", "name", ")", ";", "if", "(", "subjectAlternativeNames", "==", "null", ")", "{", "subjectAlternativeNames", "=", "new", "HashSet", "<", "List", "<", "?", ">", ">", "(", ")", ";", "}", "if", "(", "subjectAlternativeGeneralNames", "==", "null", ")", "{", "subjectAlternativeGeneralNames", "=", "new", "HashSet", "<", "GeneralNameInterface", ">", "(", ")", ";", "}", "List", "<", "Object", ">", "list", "=", "new", "ArrayList", "<", "Object", ">", "(", "2", ")", ";", "list", ".", "add", "(", "Integer", ".", "valueOf", "(", "type", ")", ")", ";", "list", ".", "add", "(", "name", ")", ";", "subjectAlternativeNames", ".", "add", "(", "list", ")", ";", "subjectAlternativeGeneralNames", ".", "add", "(", "tempName", ")", ";", "}" ]

[ "A", "private", "method", "that", "adds", "a", "name", "(", "String", "or", "byte", "array", ")", "to", "the", "subjectAlternativeNames", "criterion", ".", "The", "{", "@code", "X509Certificate", "}", "must", "contain", "the", "specified", "subjectAlternativeName", "." ]

[ "public", "final", "String", "getDisplayName", "(", "String", "tzID", ",", "NameType", "type", ",", "long", "date", ")", "{", "String", "name", "=", "getTimeZoneDisplayName", "(", "tzID", ",", "type", ")", ";", "if", "(", "name", "==", "null", ")", "{", "String", "mzID", "=", "getMetaZoneID", "(", "tzID", ",", "date", ")", ";", "name", "=", "getMetaZoneDisplayName", "(", "mzID", ",", "type", ")", ";", "}", "return", "name", ";", "}" ]

[ "Returns", "the", "display", "name", "of", "the", "time", "zone", "at", "the", "given", "date", "." ]

[ "static", "File", "getLogDirectory", "(", "Object", "newValue", ",", "File", "defaultDirectory", ")", "{", "File", "newDirectory", "=", "defaultDirectory", ";", "// If a value was specified, try creating a file with it", "if", "(", "newValue", "!=", "null", "&&", "newValue", "instanceof", "String", ")", "{", "newDirectory", "=", "new", "File", "(", "(", "String", ")", "newValue", ")", ";", "}", "if", "(", "newDirectory", "==", "null", ")", "{", "String", "value", "=", "\".\"", ";", "try", "{", "value", "=", "AccessController", ".", "doPrivileged", "(", "new", "java", ".", "security", ".", "PrivilegedExceptionAction", "<", "String", ">", "(", ")", "{", "@", "Override", "public", "String", "run", "(", ")", "throws", "Exception", "{", "return", "System", ".", "getProperty", "(", "\"user.dir\"", ")", ";", "}", "}", ")", ";", "}", "catch", "(", "Exception", "ex", ")", "{", "// do nothing", "}", "newDirectory", "=", "new", "File", "(", "value", ")", ";", "}", "return", "LoggingFileUtils", ".", "validateDirectory", "(", "newDirectory", ")", ";", "}" ]

[ "Find", "create", "and", "validate", "the", "log", "directory", "." ]

[ "public", "static", "int", "executeToFile", "(", "final", "String", "[", "]", "command", ",", "final", "File", "file", ")", "throws", "IOException", ",", "InterruptedException", "{", "return", "executeToFile", "(", "command", ",", "file", ",", "System", ".", "err", ")", ";", "}" ]

[ "Executes", "the", "given", "command", "redirecting", "stdout", "to", "the", "given", "file", "and", "stderr", "to", "actual", "stderr" ]

[ "public", "void", "flushTxLog", "(", ")", "{", "synchronized", "(", "flushCompleteSignal", ")", "{", "BufferName", "enqueueBuffer", ";", "synchronized", "(", "txLogToVEBuf", ".", "getPot", "(", ")", ")", "{", "// Enqueue the backup task", "enqueueBuffer", "=", "txLogToVEBuf", ".", "getEnqueueBuffer", "(", ")", ";", "FlushNowJob", "flushJob", "=", "new", "FlushNowJob", "(", ")", ";", "txLogToVEBuf", ".", "addAndExecuteWork", "(", "flushJob", ")", ";", "}", "try", "{", "do", "{", "log", ".", "debug", "(", "\"Waiting for flush to complete in buffer {}\"", ",", "enqueueBuffer", ")", ";", "flushCompleteSignal", ".", "wait", "(", ")", ";", "log", ".", "debug", "(", "\"Flush complete in buffer {}\"", ",", "lastFlushedBuffer", ")", ";", "}", "while", "(", "lastFlushedBuffer", "!=", "enqueueBuffer", ")", ";", "}", "catch", "(", "InterruptedException", "e", ")", "{", "BitsyException", "toThrow", "=", "new", "BitsyException", "(", "BitsyErrorCodes", ".", "FLUSH_INTERRUPTED", ",", "\"Exception while waiting for a transaction-log flush to be performed\"", ",", "e", ")", ";", "log", ".", "error", "(", "\"Error while flushing the transaction log\"", ",", "toThrow", ")", ";", "throw", "toThrow", ";", "}", "}", "}" ]

[ "This", "method", "flushes", "the", "transaction", "log", "to", "the", "V", "/", "E", "text", "files" ]

[ "public", "static", "String", "getChomp", "(", "String", "str", ",", "String", "sep", ")", "{", "int", "idx", "=", "str", ".", "lastIndexOf", "(", "sep", ")", ";", "if", "(", "idx", "==", "str", ".", "length", "(", ")", "-", "sep", ".", "length", "(", ")", ")", "{", "return", "sep", ";", "}", "else", "if", "(", "idx", "!=", "-", "1", ")", "{", "return", "str", ".", "substring", "(", "idx", ")", ";", "}", "else", "{", "return", "EMPTY", ";", "}", "}" ]

[ "<p", ">", "Remove", "everything", "and", "return", "the", "last", "value", "of", "a", "supplied", "String", "and", "everything", "after", "it", "from", "a", "String", ".", "<", "/", "p", ">" ]

[ "protected", "Specification", "<", "ENTITY", ">", "buildStringSpecification", "(", "StringFilter", "filter", ",", "SingularAttribute", "<", "?", "super", "ENTITY", ",", "String", ">", "field", ")", "{", "if", "(", "filter", ".", "getEquals", "(", ")", "!=", "null", ")", "{", "return", "equalsSpecification", "(", "field", ",", "filter", ".", "getEquals", "(", ")", ")", ";", "}", "else", "if", "(", "filter", ".", "getIn", "(", ")", "!=", "null", ")", "{", "return", "valueIn", "(", "field", ",", "filter", ".", "getIn", "(", ")", ")", ";", "}", "else", "if", "(", "filter", ".", "getContains", "(", ")", "!=", "null", ")", "{", "return", "likeUpperSpecification", "(", "field", ",", "filter", ".", "getContains", "(", ")", ")", ";", "}", "else", "if", "(", "filter", ".", "getSpecified", "(", ")", "!=", "null", ")", "{", "return", "byFieldSpecified", "(", "field", ",", "filter", ".", "getSpecified", "(", ")", ")", ";", "}", "return", "null", ";", "}" ]

[ "Helper", "function", "to", "return", "a", "specification", "for", "filtering", "on", "a", "{", "@link", "String", "}", "field", "where", "equality", "containment", "and", "null", "/", "non", "-", "null", "conditions", "are", "supported", "." ]

[ "public", "Iterator", "mapToResultType", "(", "ControlBeanContext", "context", ",", "Method", "m", ",", "ResultSet", "resultSet", ",", "Calendar", "cal", ")", "{", "return", "new", "ResultSetIterator", "(", "context", ",", "m", ",", "resultSet", ",", "cal", ")", ";", "}" ]

[ "Map", "a", "ResultSet", "to", "an", "object", "type", "Type", "of", "object", "to", "interate", "over", "is", "defined", "in", "the", "SQL", "annotation", "for", "the", "method", "." ]

[ "private", "boolean", "isReadRequired", "(", "ValueGeneration", "valueGeneration", ",", "GenerationTiming", "matchTiming", ")", "{", "return", "valueGeneration", "!=", "null", "&&", "valueGeneration", ".", "getValueGenerator", "(", ")", "==", "null", "&&", "timingsMatch", "(", "valueGeneration", ".", "getGenerationTiming", "(", ")", ",", "matchTiming", ")", ";", "}" ]

[ "Whether", "the", "given", "value", "generation", "strategy", "requires", "to", "read", "the", "value", "from", "the", "database", "or", "not", "." ]

[ "public", "static", "float", "copySign", "(", "float", "magnitude", ",", "float", "sign", ")", "{", "return", "Float", ".", "intBitsToFloat", "(", "(", "Float", ".", "floatToRawIntBits", "(", "sign", ")", "&", "(", "FloatConsts", ".", "SIGN_BIT_MASK", ")", ")", "|", "(", "Float", ".", "floatToRawIntBits", "(", "magnitude", ")", "&", "(", "FloatConsts", ".", "EXP_BIT_MASK", "|", "FloatConsts", ".", "SIGNIF_BIT_MASK", ")", ")", ")", ";", "}" ]

[ "Returns", "the", "first", "floating", "-", "point", "argument", "with", "the", "sign", "of", "the", "second", "floating", "-", "point", "argument", ".", "Note", "that", "unlike", "the", "{", "@link", "StrictMath#copySign", "(", "float", "float", ")", "StrictMath", ".", "copySign", "}", "method", "this", "method", "does", "not", "require", "NaN", "{", "@code", "sign", "}", "arguments", "to", "be", "treated", "as", "positive", "values", ";", "implementations", "are", "permitted", "to", "treat", "some", "NaN", "arguments", "as", "positive", "and", "other", "NaN", "arguments", "as", "negative", "to", "allow", "greater", "performance", "." ]

[ "public", "int", "setString", "(", "String", "strString", ",", "boolean", "bDisplayOption", ",", "int", "iMoveMode", ")", "// init this field override for other value", "{", "int", "iMaxLength", "=", "this", ".", "getMaxLength", "(", ")", ";", "if", "(", "strString", "!=", "null", ")", "if", "(", "strString", ".", "length", "(", ")", ">", "iMaxLength", ")", "strString", "=", "strString", ".", "substring", "(", "0", ",", "iMaxLength", ")", ";", "if", "(", "strString", "==", "null", ")", "strString", "=", "Constants", ".", "BLANK", ";", "// To set a null internally, you must call setData directly", "return", "this", ".", "setData", "(", "strString", ",", "bDisplayOption", ",", "iMoveMode", ")", ";", "}" ]

[ "Convert", "and", "move", "string", "to", "this", "field", ".", "Data", "is", "already", "in", "string", "format", "so", "just", "move", "it!" ]

[ "@", "SuppressWarnings", "(", "\"unchecked\"", ")", "public", "<", "T", "extends", "WebLocatorAbstractBuilder", ">", "T", "setTemplate", "(", "final", "String", "key", ",", "final", "String", "value", ")", "{", "pathBuilder", ".", "setTemplate", "(", "key", ",", "value", ")", ";", "return", "(", "T", ")", "this", ";", "}" ]

[ "For", "customize", "template", "please", "see", "here", ":", "See", "http", ":", "//", "docs", ".", "oracle", ".", "com", "/", "javase", "/", "7", "/", "docs", "/", "api", "/", "java", "/", "util", "/", "Formatter", ".", "html#dpos" ]

[ "public", "double", "[", "]", "getMagnitudes", "(", "double", "[", "]", "amplitudes", ",", "boolean", "complex", ")", "{", "final", "int", "sampleSize", "=", "amplitudes", ".", "length", ";", "final", "int", "nrofFrequencyBins", "=", "sampleSize", "/", "2", ";", "// call the fft and transform the complex numbers", "if", "(", "complex", ")", "{", "DoubleFFT_1D", "fft", "=", "new", "DoubleFFT_1D", "(", "nrofFrequencyBins", ")", ";", "fft", ".", "complexForward", "(", "amplitudes", ")", ";", "}", "else", "{", "DoubleFFT_1D", "fft", "=", "new", "DoubleFFT_1D", "(", "sampleSize", ")", ";", "fft", ".", "realForward", "(", "amplitudes", ")", ";", "// amplitudes[1] contains re[sampleSize/2] or im[(sampleSize-1) / 2] (depending on whether sampleSize is odd or even)", "// Discard it as it is useless without the other part", "// im part dc bin is always 0 for real input", "amplitudes", "[", "1", "]", "=", "0", ";", "}", "// end call the fft and transform the complex numbers", "// even indexes (0,2,4,6,...) are real parts", "// odd indexes (1,3,5,7,...) are img parts", "double", "[", "]", "mag", "=", "new", "double", "[", "nrofFrequencyBins", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "nrofFrequencyBins", ";", "i", "++", ")", "{", "final", "int", "f", "=", "2", "*", "i", ";", "mag", "[", "i", "]", "=", "Math", ".", "sqrt", "(", "amplitudes", "[", "f", "]", "*", "amplitudes", "[", "f", "]", "+", "amplitudes", "[", "f", "+", "1", "]", "*", "amplitudes", "[", "f", "+", "1", "]", ")", ";", "}", "return", "mag", ";", "}" ]

[ "Get", "the", "frequency", "intensities" ]

[ "public", "static", "<", "T", ">", "Connectable", "<", "T", ">", "scheduleFixedRate", "(", "final", "Stream", "<", "T", ">", "stream", ",", "final", "long", "rate", ",", "final", "ScheduledExecutorService", "ex", ")", "{", "return", "new", "NonPausableConnectable", "<>", "(", "stream", ")", ".", "scheduleFixedRate", "(", "rate", ",", "ex", ")", ";", "}" ]

[ "Execute", "this", "Stream", "on", "a", "schedule" ]

[ "public", "synchronized", "void", "runNow", "(", "String", "scheduledJobId", ")", "{", "ScheduledJob", "scheduledJob", "=", "getJob", "(", "scheduledJobId", ")", ";", "try", "{", "JobKey", "jobKey", "=", "new", "JobKey", "(", "scheduledJobId", ",", "SCHEDULED_JOB_GROUP", ")", ";", "if", "(", "quartzScheduler", ".", "checkExists", "(", "jobKey", ")", ")", "{", "// Run job now", "quartzScheduler", ".", "triggerJob", "(", "jobKey", ")", ";", "}", "else", "{", "// Schedule with 'now' trigger", "Trigger", "trigger", "=", "newTrigger", "(", ")", ".", "withIdentity", "(", "scheduledJobId", ",", "SCHEDULED_JOB_GROUP", ")", ".", "startNow", "(", ")", ".", "build", "(", ")", ";", "schedule", "(", "scheduledJob", ",", "trigger", ")", ";", "}", "}", "catch", "(", "SchedulerException", "e", ")", "{", "LOG", ".", "error", "(", "\"Error runNow ScheduledJob\"", ",", "e", ")", ";", "throw", "new", "MolgenisDataException", "(", "\"Error job runNow\"", ",", "e", ")", ";", "}", "}" ]

[ "Executes", "a", "{", "@link", "ScheduledJob", "}", "immediately", "." ]

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

[ "Serializes", "the", "content", "of", "the", "object", "into", "the", "{", "@link", "com", ".", "google", ".", "gwt", ".", "user", ".", "client", ".", "rpc", ".", "SerializationStreamWriter", "}", "." ]

[ "public", "void", "initializeMap", "(", "final", "MapPresenter", "mapPresenter", ",", "String", "applicationId", ",", "String", "id", ",", "final", "DefaultMapWidget", "...", "mapWidgets", ")", "{", "GwtCommand", "commandRequest", "=", "new", "GwtCommand", "(", "GetMapConfigurationRequest", ".", "COMMAND", ")", ";", "commandRequest", ".", "setCommandRequest", "(", "new", "GetMapConfigurationRequest", "(", "id", ",", "applicationId", ")", ")", ";", "commandService", ".", "execute", "(", "commandRequest", ",", "new", "AbstractCommandCallback", "<", "GetMapConfigurationResponse", ">", "(", ")", "{", "public", "void", "execute", "(", "GetMapConfigurationResponse", "response", ")", "{", "// Initialize the MapModel and ViewPort:", "ClientMapInfo", "mapInfo", "=", "response", ".", "getMapInfo", "(", ")", ";", "// Create the map configuration", "MapConfiguration", "configuration", "=", "createMapConfiguration", "(", "mapInfo", ",", "mapPresenter", ")", ";", "// We must initialize the map first (without firing the event), as layer constructors may depend on it :", "(", "(", "MapPresenterImpl", ")", "mapPresenter", ")", ".", "initialize", "(", "configuration", ",", "false", ",", "mapWidgets", ")", ";", "// Add all layers:", "for", "(", "ClientLayerInfo", "layerInfo", ":", "mapInfo", ".", "getLayers", "(", ")", ")", "{", "ServerLayer", "<", "?", ">", "layer", "=", "createLayer", "(", "configuration", ",", "layerInfo", ",", "mapPresenter", ".", "getViewPort", "(", ")", ",", "mapPresenter", ".", "getEventBus", "(", ")", ")", ";", "mapPresenter", ".", "getLayersModel", "(", ")", ".", "addLayer", "(", "layer", ")", ";", "}", "// All layers animated", "LayersModelRenderer", "modelRenderer", "=", "mapPresenter", ".", "getLayersModelRenderer", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "mapPresenter", ".", "getLayersModel", "(", ")", ".", "getLayerCount", "(", ")", ";", "i", "++", ")", "{", "modelRenderer", ".", "setAnimated", "(", "mapPresenter", ".", "getLayersModel", "(", ")", ".", "getLayer", "(", "i", ")", ",", "true", ")", ";", "}", "// Also add a renderer for feature selection:", "FeatureSelectionRenderer", "renderer", "=", "new", "FeatureSelectionRenderer", "(", "mapPresenter", ")", ";", "renderer", ".", "initialize", "(", "mapInfo", ")", ";", "mapPresenter", ".", "getEventBus", "(", ")", ".", "addFeatureSelectionHandler", "(", "renderer", ")", ";", "mapPresenter", ".", "getEventBus", "(", ")", ".", "addLayerVisibilityHandler", "(", "renderer", ")", ";", "// now we can fire the initialization event", "mapPresenter", ".", "getEventBus", "(", ")", ".", "fireEvent", "(", "new", "MapInitializationEvent", "(", "mapPresenter", ")", ")", ";", "}", "}", ")", ";", "}" ]

[ "Initialize", "the", "map", "by", "fetching", "a", "configuration", "on", "the", "server", "." ]

[ "private", "static", "String", "highlightToken", "(", "String", "line", ",", "Token", "token", ")", "{", "String", "newLine", "=", "insertChar", "(", "line", ",", "getLastCharPositionInLine", "(", "token", ")", ",", "'", "'", ")", ";", "return", "insertChar", "(", "newLine", ",", "token", ".", "getCharPositionInLine", "(", ")", ",", "'", "'", ")", ";", "}" ]

[ "Puts", "the", "specified", "token", "within", "square", "brackets", "." ]

[ "public", "void", "debugf", "(", "String", "format", ",", "Object", "param1", ")", "{", "if", "(", "isEnabled", "(", "Level", ".", "DEBUG", ")", ")", "{", "doLogf", "(", "Level", ".", "DEBUG", ",", "FQCN", ",", "format", ",", "new", "Object", "[", "]", "{", "param1", "}", ",", "null", ")", ";", "}", "}" ]

[ "Issue", "a", "formatted", "log", "message", "with", "a", "level", "of", "DEBUG", "." ]

[ "void", "fillOutsideAreas", "(", "int", "color", ",", "Rectangle", "insideArea", ")", "{", "this", ".", "canvas", ".", "setClipDifference", "(", "(", "int", ")", "insideArea", ".", "left", ",", "(", "int", ")", "insideArea", ".", "top", ",", "(", "int", ")", "insideArea", ".", "getWidth", "(", ")", ",", "(", "int", ")", "insideArea", ".", "getHeight", "(", ")", ")", ";", "this", ".", "canvas", ".", "fillColor", "(", "color", ")", ";", "this", ".", "canvas", ".", "resetClip", "(", ")", ";", "}" ]

[ "Fills", "the", "area", "outside", "the", "specificed", "rectangle", "with", "color", ".", "This", "method", "is", "used", "to", "blank", "out", "areas", "that", "fall", "outside", "the", "map", "area", "." ]

[ "@", "Override", "public", "RandomVariableInterface", "getValue", "(", "double", "evaluationTime", ",", "AssetModelMonteCarloSimulationInterface", "model", ")", "throws", "CalculationException", "{", "// Calculate average", "RandomVariableInterface", "average", "=", "model", ".", "getRandomVariableForConstant", "(", "0.0", ")", ";", "for", "(", "double", "time", ":", "timesForAveraging", ")", "{", "RandomVariableInterface", "underlying", "=", "model", ".", "getAssetValue", "(", "time", ",", "underlyingIndex", ")", ";", "average", "=", "average", ".", "add", "(", "underlying", ")", ";", "}", "average", "=", "average", ".", "div", "(", "timesForAveraging", ".", "getNumberOfTimes", "(", ")", ")", ";", "// The payoff: values = max(underlying - strike, 0)", "RandomVariableInterface", "values", "=", "average", ".", "sub", "(", "strike", ")", ".", "floor", "(", "0.0", ")", ";", "// Discounting...", "RandomVariableInterface", "numeraireAtMaturity", "=", "model", ".", "getNumeraire", "(", "maturity", ")", ";", "RandomVariableInterface", "monteCarloWeights", "=", "model", ".", "getMonteCarloWeights", "(", "maturity", ")", ";", "values", "=", "values", ".", "div", "(", "numeraireAtMaturity", ")", ".", "mult", "(", "monteCarloWeights", ")", ";", "// ...to evaluation time.", "RandomVariableInterface", "numeraireAtEvalTime", "=", "model", ".", "getNumeraire", "(", "evaluationTime", ")", ";", "RandomVariableInterface", "monteCarloProbabilitiesAtEvalTime", "=", "model", ".", "getMonteCarloWeights", "(", "evaluationTime", ")", ";", "values", "=", "values", ".", "mult", "(", "numeraireAtEvalTime", ")", ".", "div", "(", "monteCarloProbabilitiesAtEvalTime", ")", ";", "return", "values", ";", "}" ]

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

[ "private", "boolean", "satisfies", "(", "EvaluationContext", "ctx", ",", "Object", "param", ",", "UnaryTest", "test", ")", "{", "return", "test", ".", "apply", "(", "ctx", ",", "param", ")", ";", "}" ]

[ "Checks", "that", "a", "given", "parameter", "matches", "a", "single", "cell", "test" ]

[ "public", "static", "<", "T", ">", "void", "arrangeByIndex", "(", "T", "[", "]", "array", ",", "Integer", "[", "]", "indexes", ")", "{", "if", "(", "array", ".", "length", "!=", "indexes", ".", "length", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"The length of the two arrays must match.\"", ")", ";", "}", "//sort the array based on the indexes", "for", "(", "int", "i", "=", "0", ";", "i", "<", "array", ".", "length", ";", "i", "++", ")", "{", "int", "index", "=", "indexes", "[", "i", "]", ";", "//swap", "T", "tmp", "=", "array", "[", "i", "]", ";", "array", "[", "i", "]", "=", "array", "[", "index", "]", ";", "array", "[", "index", "]", "=", "tmp", ";", "}", "}" ]

[ "Rearranges", "the", "array", "based", "on", "the", "order", "of", "the", "provided", "indexes", "." ]

[ "public", "static", "<", "T", ">", "MemcachedClientBuilder", "<", "T", ">", "newMessagePackClient", "(", "final", "MessagePack", "messagePack", ",", "final", "Class", "<", "T", ">", "valueType", ")", "{", "if", "(", "!", "ClassUtils", ".", "isPrimitiveOrWrapper", "(", "valueType", ")", ")", "{", "messagePack", ".", "register", "(", "valueType", ")", ";", "}", "return", "newClient", "(", "new", "MessagePackTranscoder", "<>", "(", "messagePack", ",", "valueType", ")", ")", ";", "}" ]

[ "Create", "a", "client", "builder", "for", "MessagePack", "values", "." ]

[ "public", "Object", "getVariable", "(", "String", "variableName", ",", "boolean", "fetchAllVariables", ")", "{", "Object", "value", "=", "null", ";", "VariableInstance", "variable", "=", "getVariableInstance", "(", "variableName", ",", "fetchAllVariables", ")", ";", "if", "(", "variable", "!=", "null", ")", "{", "value", "=", "variable", ".", "getValue", "(", ")", ";", "}", "return", "value", ";", "}" ]

[ "The", "same", "operation", "as", "{", "@link", "VariableScopeImpl#getVariable", "(", "String", ")", "}", "but", "with", "an", "extra", "parameter", "to", "indicate", "whether", "or", "not", "all", "variables", "need", "to", "be", "fetched", "." ]

[ "public", "String", "responseMessage", "(", ")", "{", "try", "{", "connect", "(", ")", ";", "return", "connection", ".", "getResponseMessage", "(", ")", ";", "}", "catch", "(", "Exception", "e", ")", "{", "throw", "new", "HttpException", "(", "\"Failed URL: \"", "+", "url", ",", "e", ")", ";", "}", "}" ]

[ "Returns", "response", "message", "from", "server", "such", "as", "OK", "or", "Created", "etc", "." ]

[ "@", "Sensitive", "private", "String", "getStoredReq", "(", "HttpServletRequest", "req", ",", "ReferrerURLCookieHandler", "referrerURLHandler", ")", "{", "String", "storedReq", "=", "referrerURLHandler", ".", "getReferrerURLFromCookies", "(", "req", ",", "ReferrerURLCookieHandler", ".", "REFERRER_URL_COOKIENAME", ")", ";", "if", "(", "storedReq", "!=", "null", ")", "{", "if", "(", "storedReq", ".", "equals", "(", "\"/\"", ")", ")", "storedReq", "=", "\"\"", ";", "else", "if", "(", "storedReq", ".", "startsWith", "(", "\"/\"", ")", ")", "storedReq", "=", "storedReq", ".", "substring", "(", "1", ")", ";", "}", "else", "{", "storedReq", "=", "\"\"", ";", "}", "return", "storedReq", ";", "}" ]

[ "Always", "be", "redirecting", "to", "a", "stored", "req", "with", "the", "web", "app", "...", "strip", "any", "initial", "slash" ]

[ "static", "ShapeDrawable", "getRoundedOutlineBackground", "(", "Resources", "resources", ",", "@", "ColorInt", "int", "color", ")", "{", "int", "r", "=", "resources", ".", "getDimensionPixelSize", "(", "R", ".", "dimen", ".", "com_auth0_lock_widget_corner_radius", ")", ";", "int", "t", "=", "resources", ".", "getDimensionPixelSize", "(", "R", ".", "dimen", ".", "com_auth0_lock_input_field_stroke_width", ")", ";", "RoundRectShape", "rr", "=", "new", "RoundRectShape", "(", "new", "float", "[", "]", "{", "r", ",", "r", ",", "r", ",", "r", ",", "r", ",", "r", ",", "r", ",", "r", "}", ",", "new", "RectF", "(", "t", ",", "t", ",", "t", ",", "t", ")", ",", "new", "float", "[", "]", "{", "r", ",", "r", ",", "r", ",", "r", ",", "r", ",", "r", ",", "r", ",", "r", "}", ")", ";", "ShapeDrawable", "drawable", "=", "new", "ShapeDrawable", "(", "rr", ")", ";", "drawable", ".", "getPaint", "(", ")", ".", "setColor", "(", "color", ")", ";", "return", "drawable", ";", "}" ]

[ "Generates", "a", "rounded", "outline", "drawable", "with", "the", "given", "background", "color", "." ]

[ "public", "static", "<", "T", ">", "T", "assertSame", "(", "T", "exp", ",", "T", "was", ",", "String", "message", ")", "{", "assertNotNull", "(", "exp", ",", "message", ")", ";", "assertNotNull", "(", "was", ",", "message", ")", ";", "assertTrue", "(", "exp", "==", "was", ",", "message", ")", ";", "return", "was", ";", "}" ]

[ "Throws", "an", "IllegalStateException", "when", "the", "given", "values", "are", "not", "equal", "." ]

[ "public", "void", "addDestinationActiveParticipant", "(", "String", "userId", ",", "String", "altUserId", ",", "String", "userName", ",", "String", "networkId", ",", "boolean", "isRequestor", ")", "{", "addActiveParticipant", "(", "userId", ",", "altUserId", ",", "userName", ",", "isRequestor", ",", "Collections", ".", "singletonList", "(", "new", "DICOMActiveParticipantRoleIdCodes", ".", "Destination", "(", ")", ")", ",", "networkId", ")", ";", "}" ]

[ "Adds", "an", "Active", "Participant", "block", "representing", "the", "destination", "participant" ]

[ "public", "static", "Enum", "castToEnum", "(", "Object", "object", ",", "Class", "<", "?", "extends", "Enum", ">", "type", ")", "{", "if", "(", "object", "==", "null", ")", "return", "null", ";", "if", "(", "type", ".", "isInstance", "(", "object", ")", ")", "return", "(", "Enum", ")", "object", ";", "if", "(", "object", "instanceof", "String", "||", "object", "instanceof", "GString", ")", "{", "return", "Enum", ".", "valueOf", "(", "type", ",", "object", ".", "toString", "(", ")", ")", ";", "}", "throw", "new", "GroovyCastException", "(", "object", ",", "type", ")", ";", "}" ]

[ "this", "class", "requires", "that", "the", "supplied", "enum", "is", "not", "fitting", "a", "Collection", "case", "for", "casting" ]

[ "protected", "void", "varBumpActivity", "(", "int", "v", ",", "double", "inc", ")", "{", "final", "MSVariable", "var", "=", "this", ".", "vars", ".", "get", "(", "v", ")", ";", "var", ".", "incrementActivity", "(", "inc", ")", ";", "if", "(", "var", ".", "activity", "(", ")", ">", "1e100", ")", "{", "for", "(", "final", "MSVariable", "variable", ":", "this", ".", "vars", ")", "variable", ".", "rescaleActivity", "(", ")", ";", "this", ".", "varInc", "*=", "1e-100", ";", "}", "if", "(", "this", ".", "orderHeap", ".", "inHeap", "(", "v", ")", ")", "this", ".", "orderHeap", ".", "decrease", "(", "v", ")", ";", "}" ]

[ "Bumps", "the", "activity", "of", "the", "variable", "at", "a", "given", "index", "by", "a", "given", "value", "." ]

[ "protected", "base_resource", "[", "]", "get_nitro_bulk_response", "(", "nitro_service", "service", ",", "String", "response", ")", "throws", "Exception", "{", "ns_conf_revision_history_responses", "result", "=", "(", "ns_conf_revision_history_responses", ")", "service", ".", "get_payload_formatter", "(", ")", ".", "string_to_resource", "(", "ns_conf_revision_history_responses", ".", "class", ",", "response", ")", ";", "if", "(", "result", ".", "errorcode", "!=", "0", ")", "{", "if", "(", "result", ".", "errorcode", "==", "SESSION_NOT_EXISTS", ")", "service", ".", "clear_session", "(", ")", ";", "throw", "new", "nitro_exception", "(", "result", ".", "message", ",", "result", ".", "errorcode", ",", "(", "base_response", "[", "]", ")", "result", ".", "ns_conf_revision_history_response_array", ")", ";", "}", "ns_conf_revision_history", "[", "]", "result_ns_conf_revision_history", "=", "new", "ns_conf_revision_history", "[", "result", ".", "ns_conf_revision_history_response_array", ".", "length", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "result", ".", "ns_conf_revision_history_response_array", ".", "length", ";", "i", "++", ")", "{", "result_ns_conf_revision_history", "[", "i", "]", "=", "result", ".", "ns_conf_revision_history_response_array", "[", "i", "]", ".", "ns_conf_revision_history", "[", "0", "]", ";", "}", "return", "result_ns_conf_revision_history", ";", "}" ]

[ "<pre", ">", "Converts", "API", "response", "of", "bulk", "operation", "into", "object", "and", "returns", "the", "object", "array", "in", "case", "of", "get", "request", ".", "<", "/", "pre", ">" ]

[ "@", "Override", "public", "void", "doRender", "(", "final", "WComponent", "component", ",", "final", "WebXmlRenderContext", "renderContext", ")", "{", "WShuffler", "shuffler", "=", "(", "WShuffler", ")", "component", ";", "XmlStringBuilder", "xml", "=", "renderContext", ".", "getWriter", "(", ")", ";", "boolean", "readOnly", "=", "shuffler", ".", "isReadOnly", "(", ")", ";", "// Start tag", "xml", ".", "appendTagOpen", "(", "\"ui:shuffler\"", ")", ";", "xml", ".", "appendAttribute", "(", "\"id\"", ",", "component", ".", "getId", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"class\"", ",", "component", ".", "getHtmlClass", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"track\"", ",", "component", ".", "isTracking", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"hidden\"", ",", "shuffler", ".", "isHidden", "(", ")", ",", "\"true\"", ")", ";", "if", "(", "readOnly", ")", "{", "xml", ".", "appendAttribute", "(", "\"readOnly\"", ",", "\"true\"", ")", ";", "}", "else", "{", "xml", ".", "appendOptionalAttribute", "(", "\"disabled\"", ",", "shuffler", ".", "isDisabled", "(", ")", ",", "\"true\"", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"toolTip\"", ",", "shuffler", ".", "getToolTip", "(", ")", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"accessibleText\"", ",", "shuffler", ".", "getAccessibleText", "(", ")", ")", ";", "int", "rows", "=", "shuffler", ".", "getRows", "(", ")", ";", "xml", ".", "appendOptionalAttribute", "(", "\"rows\"", ",", "rows", ">", "0", ",", "rows", ")", ";", "}", "xml", ".", "appendClose", "(", ")", ";", "// Options", "List", "<", "?", ">", "options", "=", "shuffler", ".", "getOptions", "(", ")", ";", "if", "(", "options", "!=", "null", "&&", "!", "options", ".", "isEmpty", "(", ")", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "options", ".", "size", "(", ")", ";", "i", "++", ")", "{", "String", "stringOption", "=", "String", ".", "valueOf", "(", "options", ".", "get", "(", "i", ")", ")", ";", "xml", ".", "appendTagOpen", "(", "\"ui:option\"", ")", ";", "xml", ".", "appendAttribute", "(", "\"value\"", ",", "stringOption", ")", ";", "xml", ".", "appendClose", "(", ")", ";", "xml", ".", "appendEscaped", "(", "stringOption", ")", ";", "xml", ".", "appendEndTag", "(", "\"ui:option\"", ")", ";", "}", "}", "if", "(", "!", "readOnly", ")", "{", "DiagnosticRenderUtil", ".", "renderDiagnostics", "(", "shuffler", ",", "renderContext", ")", ";", "}", "// End tag", "xml", ".", "appendEndTag", "(", "\"ui:shuffler\"", ")", ";", "}" ]

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

[ "public", "ApnsPayloadBuilder", "setSound", "(", "final", "String", "soundFileName", ",", "final", "boolean", "isCriticalAlert", ",", "final", "double", "soundVolume", ")", "{", "Objects", ".", "requireNonNull", "(", "soundFileName", ",", "\"Sound file name must not be null.\"", ")", ";", "if", "(", "soundVolume", "<", "0", "||", "soundVolume", ">", "1", ")", "{", "throw", "new", "IllegalArgumentException", "(", "\"Sound volume must be between 0.0 and 1.0 (inclusive).\"", ")", ";", "}", "this", ".", "soundFileName", "=", "null", ";", "this", ".", "soundForCriticalAlert", "=", "new", "SoundForCriticalAlert", "(", "soundFileName", ",", "isCriticalAlert", ",", "soundVolume", ")", ";", "return", "this", ";", "}" ]

[ "<p", ">", "Sets", "the", "name", "of", "the", "sound", "file", "to", "play", "when", "the", "push", "notification", "is", "received", "along", "with", "its", "volume", "and", "whether", "it", "should", "be", "presented", "as", "a", "critical", "alert", ".", "According", "to", "Apple", "s", "documentation", "the", "sound", "filename", "should", "be", ":", "<", "/", "p", ">" ]

[ "private", "boolean", "hasSelectedChildren", "(", "List", "<", "CmsCategoryTreeEntry", ">", "children", ",", "Collection", "<", "String", ">", "selectedCategories", ")", "{", "boolean", "result", "=", "false", ";", "if", "(", "children", "==", "null", ")", "{", "return", "false", ";", "}", "for", "(", "CmsCategoryTreeEntry", "child", ":", "children", ")", "{", "result", "=", "selectedCategories", ".", "contains", "(", "child", ".", "getSitePath", "(", ")", ")", ";", "if", "(", "result", "||", "hasSelectedChildren", "(", "child", ".", "getChildren", "(", ")", ",", "selectedCategories", ")", ")", "{", "return", "true", ";", "}", "}", "return", "result", ";", "}" ]

[ "Checks", "if", "it", "has", "selected", "children", ".", "<p", ">" ]

[ "public", "boolean", "process", "(", "List", "<", "AssociatedPair", ">", "observations", ",", "List", "<", "Point3D_F64", ">", "locations", ")", "{", "if", "(", "observations", ".", "size", "(", ")", "!=", "locations", ".", "size", "(", ")", ")", "throw", "new", "IllegalArgumentException", "(", "\"Number of observations and locations must match.\"", ")", ";", "if", "(", "observations", ".", "size", "(", ")", "<", "6", ")", "throw", "new", "IllegalArgumentException", "(", "\"At least (if not more than) six points are required.\"", ")", ";", "setupA", "(", "observations", ",", "locations", ")", ";", "if", "(", "!", "solveNullspace", ".", "process", "(", "A", ",", "1", ",", "P", ")", ")", "return", "false", ";", "P", ".", "numRows", "=", "3", ";", "P", ".", "numCols", "=", "4", ";", "return", "true", ";", "}" ]

[ "Computes", "the", "transformation", "between", "two", "camera", "frames", "using", "a", "linear", "equation", ".", "Both", "the", "observed", "feature", "locations", "in", "each", "camera", "image", "and", "the", "depth", "(", "z", "-", "coordinate", ")", "of", "each", "feature", "must", "be", "known", ".", "Feature", "locations", "are", "in", "calibrated", "image", "coordinates", "." ]

[ "@", "Override", "public", "Partition", "[", "]", "getPartitions", "(", "S", "config", ")", "{", "cassandraJobConfig", "=", "initConfig", "(", "config", ",", "cassandraJobConfig", ")", ";", "List", "<", "DeepTokenRange", ">", "underlyingInputSplits", "=", "null", ";", "if", "(", "isFilterdByKey", "(", "cassandraJobConfig", ".", "getFilters", "(", ")", ",", "cassandraJobConfig", ".", "fetchTableMetadata", "(", ")", ".", "getPartitionKey", "(", ")", ".", "get", "(", "0", ")", ".", "getName", "(", ")", ")", ")", "{", "underlyingInputSplits", "=", "new", "ArrayList", "<>", "(", ")", ";", "underlyingInputSplits", ".", "add", "(", "new", "DeepTokenRange", "(", "Long", ".", "MIN_VALUE", ",", "Long", ".", "MAX_VALUE", ",", "cassandraJobConfig", ".", "getHostList", "(", ")", ")", ")", ";", "}", "else", "{", "if", "(", "cassandraJobConfig", ".", "isBisectModeSet", "(", ")", ")", "{", "underlyingInputSplits", "=", "RangeUtils", ".", "getSplits", "(", "cassandraJobConfig", ")", ";", "}", "else", "{", "underlyingInputSplits", "=", "ThriftRangeUtils", ".", "build", "(", "cassandraJobConfig", ")", ".", "getSplits", "(", ")", ";", "}", "}", "Partition", "[", "]", "partitions", "=", "new", "DeepPartition", "[", "underlyingInputSplits", ".", "size", "(", ")", "]", ";", "int", "i", "=", "0", ";", "for", "(", "DeepTokenRange", "split", ":", "underlyingInputSplits", ")", "{", "partitions", "[", "i", "]", "=", "new", "DeepPartition", "(", "cassandraJobConfig", ".", "getRddId", "(", ")", ",", "i", ",", "split", ")", ";", "// log().debug(\"Detected partition: \" + partitions[i]);", "++", "i", ";", "}", "return", "partitions", ";", "}" ]

[ "Returns", "the", "partitions", "on", "which", "this", "RDD", "depends", "on", ".", "<p", "/", ">", "Uses", "the", "underlying", "CqlPagingInputFormat", "in", "order", "to", "retrieve", "the", "splits", ".", "<p", "/", ">", "The", "number", "of", "splits", "and", "hence", "the", "number", "of", "partitions", "equals", "to", "the", "number", "of", "tokens", "configured", "in", "cassandra", ".", "yaml", "+", "1", "." ]