Datasets:
Anonymous2023
/
KGSum

Dataset card Data Studio Files Community
docstring_tokens
list
code_tokens
list
[ "tests", "that", "the", "zoo", "keeper", "leader", "election", "retrieval", "service", "return", "both", "the", "correct", "url" ]
[ "public", "void", "test", "zoo", "keeper", "leader", "election", "retrieval", "(", ")", "throws", "exception", "{", "final", "testing", "leader", "election", "event", "handler", "election", "event", "handler", "=", "new", "testing", "leader", "election", "event", "handler", "(", "test", "leader", ")", ";", "final", "testing", "leader", "retrieval", "event", "handler", "retrieval", "event", "handler", "=", "new", "testing", "leader", "retrieval", "event", "handler", "(", ")", ";", "leader", "election", "driver", "leader", "election", "driver", "=", "null", ";", "leader", "retrieval", "driver", "leader", "retrieval", "driver", "=", "null", ";", "try", "{", "leader", "election", "driver", "=", "create", "and", "init", "leader", "election", "driver", "(", "client", ",", "election", "event", "handler", ")", ";", "leader", "retrieval", "driver", "=", "zoo", "keeper", "utils", "create", "leader", "retrieval", "driver", "factory", "(", "client", ",", "configuration", ")", "create", "leader", "retrieval", "driver", "(", "retrieval", "event", "handler", ",", "retrieval", "event", "handler", ":", ":", "handle", "error", ")", ";", "election", "event", "handler", "wait", "for", "leader", "(", "timeout", ")", ";", "assert", "that", "(", "election", "event", "handler", "get", "confirmed", "leader", "information", "(", ")", ",", "is", "(", "test", "leader", ")", ")", ";", "retrieval", "event", "handler", "wait", "for", "new", "leader", "(", "timeout", ")", ";", "assert", "that", "(", "retrieval", "event", "handler", "get", "leader", "session", "i", "d", "(", ")", ",", "is", "(", "test", "leader", "get", "leader", "session", "i", "d", "(", ")", ")", ")", ";", "assert", "that", "(", "retrieval", "event", "handler", "get", "address", "(", ")", ",", "is", "(", "test", "leader", "get", "leader", "address", "(", ")", ")", ")", ";", "}", "finally", "{", "if", "(", "leader", "election", "driver", "!", "=", "null", ")", "{", "leader", "election", "driver", "close", "(", ")", ";", "}", "if", "(", "leader", "retrieval", "driver", "!", "=", "null", ")", "{", "leader", "retrieval", "driver", "close", "(", ")", ";", "}", "}", "}" ]
[ "get", "tickets", "collection" ]
[ "public", "mongo", "collection", "<", "document", ">", "get", "tickets", "collection", "(", ")", "{", "return", "tickets", "collection", ";", "}" ]
[ "select", "all", "descendants", "for", "the", "first", "selected", "node", ";", "called", "from", "an", "action", "listener", "on", "a", "menu" ]
[ "private", "void", "select", "all", "children", "(", "data", "tree", "tree", ",", "g", "tree", "node", "node", ")", "{", "list", "<", "tree", "path", ">", "paths", "=", "new", "array", "list", "<", "tree", "path", ">", "(", ")", ";", "get", "all", "tree", "paths", "(", "node", ",", "paths", ")", ";", "tree", "set", "selection", "paths", "(", "paths", "to", "array", "(", "new", "tree", "path", "[", "paths", "size", "(", ")", "]", ")", ")", ";", "}" ]
[ "helper", "function", "to", "print", "out", "usage" ]
[ "private", "static", "void", "print", "usage", "(", ")", "{", "new", "help", "formatter", "(", ")", "print", "help", "(", "\"", "timeline", "client", "\"", ",", "opts", ")", ";", "}" ]
[ "return", "the", "content", "type", "to", "use", "for", "the", "response" ]
[ "public", "string", "get", "content", "type", "(", ")", "{", "return", "this", "content", "type", ";", "}" ]
[ "returns", "a", "random", "string", "with", "numbers" ]
[ "public", "static", "string", "random", "string", "num", "(", "int", "len", ")", "{", "string", "builder", "sb", "=", "new", "string", "builder", "(", "len", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "len", ";", "i", "+", "+", ")", "sb", "append", "(", "an", "char", "at", "(", "rnd", "next", "int", "(", "an", "length", "(", ")", ")", ")", ")", ";", "return", "sb", "to", "string", "(", ")", ";", "}" ]
[ "get", "string", "item" ]
[ "public", "string", "get", "string", "item", "(", ")", "{", "return", "string", "item", ";", "}" ]
[ "creates", "a", "{", "@", "link", "launcher", "}", "for", "starting", "processes", "on", "the", "node", "that", "has", "this", "file" ]
[ "public", "launcher", "create", "launcher", "(", "task", "listener", "listener", ")", "throws", "i", "o", "exception", ",", "interrupted", "exception", "{", "if", "(", "channel", "=", "=", "null", ")", "return", "new", "local", "launcher", "(", "listener", ")", ";", "else", "return", "new", "remote", "launcher", "(", "listener", ",", "channel", ",", "channel", "call", "(", "new", "is", "unix", "(", ")", ")", ")", ";", "}" ]
[ "overwrite", "in", "tests", "that", "need", "it" ]
[ "protected", "script", "service", "mock", "script", "service", "(", ")", "{", "return", "null", ";", "}" ]
[ "gets", "the", "actions" ]
[ "public", "docking", "action", "[", "]", "get", "actions", "(", ")", "{", "return", "new", "docking", "action", "[", "]", "{", "toggle", "ignore", "byte", "diffs", "action", ",", "toggle", "ignore", "constants", "action", ",", "toggle", "ignore", "register", "names", "action", "}", ";", "}" ]
[ "gets", "the", "http", "user", "agent", "to", "be", "used", "by", "client", "generators", "which", "support", "setting", "this", "value", "e", "g", "codegen", "csharp", "api", "client", ",", "defaults", "to", "'", "open", "a", "p", "i", "-", "generator", "{", "package", "version", "}", "{", "language", "}", "'" ]
[ "public", "string", "get", "http", "user", "agent", "(", ")", "{", "return", "http", "user", "agent", ";", "}" ]
[ "return", "the", "value", "of", "the", "specified", "user", "attribute" ]
[ "object", "get", "user", "attribute", "(", "string", "key", ")", ";" ]
[ "frees", "the", "given", "memory", "segment" ]
[ "public", "void", "recycle", "(", "memory", "segment", "memory", "segment", ")", "{", "memory", "segment", "free", "(", ")", ";", "}" ]
[ "get", "the", "topic", "descriptions", "of", "the", "named", "topics", "the", "value", "of", "the", "map", "entry", "will", "be", "empty", "if", "the", "topic", "does", "not", "exist" ]
[ "public", "map", "<", "string", ",", "optional", "<", "topic", "description", ">", ">", "describe", "topics", "(", "set", "<", "string", ">", "topic", "names", ")", "{", "map", "<", "string", ",", "optional", "<", "topic", "description", ">", ">", "results", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "log", "info", "(", "\"", "describing", "topics", "{", "}", "\"", ",", "topic", "names", ")", ";", "try", "(", "admin", "admin", "=", "create", "admin", "client", "(", ")", ")", "{", "describe", "topics", "result", "result", "=", "admin", "describe", "topics", "(", "topic", "names", ")", ";", "map", "<", "string", ",", "kafka", "future", "<", "topic", "description", ">", ">", "by", "name", "=", "result", "values", "(", ")", ";", "for", "(", "map", "entry", "<", "string", ",", "kafka", "future", "<", "topic", "description", ">", ">", "entry", ":", "by", "name", "entry", "set", "(", ")", ")", "{", "string", "topic", "name", "=", "entry", "get", "key", "(", ")", ";", "try", "{", "topic", "description", "desc", "=", "entry", "get", "value", "(", ")", "get", "(", ")", ";", "results", "put", "(", "topic", "name", ",", "optional", "of", "(", "desc", ")", ")", ";", "log", "info", "(", "\"", "found", "topic", "{", "}", ":", "{", "}", "\"", ",", "topic", "name", ",", "desc", ")", ";", "}", "catch", "(", "execution", "exception", "e", ")", "{", "throwable", "cause", "=", "e", "get", "cause", "(", ")", ";", "if", "(", "cause", "instanceof", "unknown", "topic", "or", "partition", "exception", ")", "{", "results", "put", "(", "topic", "name", ",", "optional", "empty", "(", ")", ")", ";", "log", "info", "(", "\"", "found", "non", "-", "existant", "topic", "{", "}", "\"", ",", "topic", "name", ")", ";", "continue", ";", "}", "throw", "new", "assertion", "error", "(", "\"", "could", "not", "describe", "topic", "(", "s", ")", "\"", "+", "topic", "names", ",", "e", ")", ";", "}", "}", "}", "catch", "(", "exception", "e", ")", "{", "throw", "new", "assertion", "error", "(", "\"", "could", "not", "describe", "topic", "(", "s", ")", "\"", "+", "topic", "names", ",", "e", ")", ";", "}", "log", "info", "(", "\"", "found", "topics", "{", "}", "\"", ",", "results", ")", ";", "return", "results", ";", "}" ]
[ "applies", "an", "aggregation", "that", "gives", "the", "current", "element", "with", "the", "maximum", "value", "at", "the", "given", "position", "by", "the", "given", "key", "an", "independent", "aggregate", "is", "kept", "per", "key", "if", "more", "elements", "have", "the", "maximum", "value", "at", "the", "given", "position", ",", "the", "operator", "returns", "the", "first", "one", "by", "default" ]
[ "public", "single", "output", "stream", "operator", "<", "t", ">", "max", "by", "(", "int", "position", "to", "max", "by", ")", "{", "return", "this", "max", "by", "(", "position", "to", "max", "by", ",", "true", ")", ";", "}" ]
[ "returns", "<", "code", ">", "true", "<", "code", ">", "if", "this", "result", "has", "any", "suggest", "score", "docs" ]
[ "public", "boolean", "has", "suggest", "hits", "(", ")", "{", "return", "(", "suggest", "!", "=", "null", "&", "&", "suggest", "has", "score", "docs", "(", ")", ")", ";", "}" ]
[ "the", "maximum", "number", "of", "concurrent", "calls", "permitted", "for", "each", "incoming", "connection", "defaults", "to", "no", "limit" ]
[ "public", "netty", "server", "builder", "max", "concurrent", "calls", "per", "connection", "(", "int", "max", "calls", ")", "{", "check", "argument", "(", "max", "calls", ">", "0", ",", "\"", "max", "must", "be", "positive", ":", "%", "s", "\"", ",", "max", "calls", ")", ";", "this", "max", "concurrent", "calls", "per", "connection", "=", "max", "calls", ";", "return", "this", ";", "}" ]
[ "returns", "the", "unique", "identifier", "{", "@", "link", "reservation", "id", "}", "that", "represents", "the", "reservation" ]
[ "reservation", "id", "get", "reservation", "id", "(", ")", ";" ]
[ "a", "query", "that", "matches", "documents", "matching", "boolean", "combinations", "of", "other", "queries" ]
[ "public", "static", "bool", "query", "builder", "bool", "query", "(", ")", "{", "return", "new", "bool", "query", "builder", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "string", "item", "'" ]
[ "public", "void", "string", "item", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "string", "item", "}" ]
[ "an", "expectation", "for", "checking", "that", "an", "element", "is", "present", "on", "the", "dom", "of", "a", "page", "and", "visible", "visibility", "means", "that", "the", "element", "is", "not", "only", "displayed", "but", "also", "has", "a", "height", "and", "width", "that", "is", "greater", "than", "0" ]
[ "public", "static", "expected", "condition", "<", "web", "element", ">", "visibility", "of", "element", "located", "(", "final", "by", "locator", ")", "{", "return", "new", "expected", "condition", "<", "web", "element", ">", "(", ")", "{", "@", "override", "public", "web", "element", "apply", "(", "web", "driver", "driver", ")", "{", "try", "{", "return", "element", "if", "visible", "(", "driver", "find", "element", "(", "locator", ")", ")", ";", "}", "catch", "(", "stale", "element", "reference", "exception", "|", "no", "such", "element", "exception", "e", ")", "{", "/", "/", "returns", "null", "because", "the", "element", "is", "no", "longer", "or", "not", "present", "in", "dom", "return", "null", ";", "}", "}", "@", "override", "public", "string", "to", "string", "(", ")", "{", "return", "\"", "visibility", "of", "element", "located", "by", "\"", "+", "locator", ";", "}", "}", ";", "}" ]
[ "resets", "the", "buffer", "to", "empty" ]
[ "public", "data", "output", "buffer", "reset", "(", ")", "{", "this", "written", "=", "0", ";", "buffer", "reset", "(", ")", ";", "return", "this", ";", "}" ]
[ "if", "<", "code", ">", "true", "<", "code", ">", "an", "explicit", "<", "code", ">", "null", "<", "code", ">", "bucket", "will", "represent", "documents", "with", "missing", "values" ]
[ "public", "ab", "missing", "bucket", "(", "boolean", "missing", "bucket", ")", "{", "this", "missing", "bucket", "=", "missing", "bucket", ";", "return", "(", "ab", ")", "this", ";", "}" ]
[ "test", "json", "serialization", "of", "form", "data" ]
[ "public", "void", "test", "json", "form", "data", "test", "(", ")", "{", "string", "param", "=", "null", ";", "string", "param", "2", "=", "null", ";", "api", "test", "json", "form", "data", "(", "param", ",", "param", "2", ")", ";", "/", "/", "todo", ":", "test", "validations", "}" ]
[ "true", "iff", "job", "completed", "successfully" ]
[ "public", "synchronized", "boolean", "is", "successful", "(", ")", "throws", "i", "o", "exception", "{", "return", "job", "is", "successful", "(", ")", ";", "}" ]
[ "returns", "an", "iterator", "that", "can", "be", "used", "to", "iterate", "over", "all", "the", "elements", "in", "the", "table", "warning", ":", "doing", "any", "other", "operation", "on", "the", "table", "invalidates", "the", "iterator", "!", "(", "even", "using", "get", "match", "for", "of", "a", "prober", "!", ")" ]
[ "public", "entry", "iterator", "get", "entry", "iterator", "(", ")", "{", "return", "new", "entry", "iterator", "(", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "int", "hash", "code", "(", ")", "{", "return", "(", "handler", "*", "31", ")", "+", "exception", "type", "hash", "code", "(", ")", ";", "}" ]
[ "disabling", "the", "field", "names", "should", "still", "work", "for", "indices", "before", "8", "0" ]
[ "public", "void", "test", "using", "enabled", "before", "8", "(", ")", "throws", "exception", "{", "document", "mapper", "doc", "mapper", "=", "create", "document", "mapper", "(", "version", "utils", "random", "previous", "compatible", "version", "(", "random", "(", ")", ",", "version", "v", "8", "0", "0", ")", ",", "top", "mapping", "(", "b", "-", ">", "b", "start", "object", "(", "\"", "field", "names", "\"", ")", "field", "(", "\"", "enabled", "\"", ",", "false", ")", "end", "object", "(", ")", ")", ")", ";", "assert", "warnings", "(", "field", "names", "field", "mapper", "enabled", "deprecation", "message", ")", ";", "field", "names", "field", "mapper", "field", "names", "mapper", "=", "doc", "mapper", "metadata", "mapper", "(", "field", "names", "field", "mapper", "class", ")", ";", "assert", "false", "(", "field", "names", "mapper", "field", "type", "(", ")", "is", "enabled", "(", ")", ")", ";", "parsed", "document", "doc", "=", "doc", "mapper", "parse", "(", "source", "(", "b", "-", ">", "b", "field", "(", "\"", "field", "\"", ",", "\"", "value", "\"", ")", ")", ")", ";", "assert", "null", "(", "doc", "root", "doc", "(", ")", "get", "(", "\"", "field", "names", "\"", ")", ")", ";", "}" ]
[ "override", "this", "method", "to", "add", "your", "own", "bit", "-", "viewer", "panel", "below", "the", "component", "table", "<", "p", ">", "creates", "a", "panel", "that", "appears", "below", "the", "component", "table", "this", "panel", "contains", "a", "bit", "-", "level", "view", "of", "a", "selected", "component", "by", "default", ",", "there", "is", "no", "panel", "below", "the", "component", "table" ]
[ "protected", "j", "panel", "create", "bit", "viewer", "panel", "(", ")", "{", "return", "null", ";", "}" ]
[ "associates", "the", "value", "{", "@", "code", "null", "}", "with", "the", "specified", "keys", ",", "assuming", "both", "keys", "are", "valid", "if", "either", "key", "is", "null", "or", "isn", "'", "t", "among", "the", "keys", "provided", "during", "construction", ",", "this", "method", "has", "no", "effect", "this", "method", "is", "equivalent", "to", "{", "@", "code", "put", "(", "row", "key", ",", "column", "key", ",", "null", ")", "}", "when", "both", "provided", "keys", "are", "valid" ]
[ "public", "v", "erase", "(", "@", "nullable", "decl", "object", "row", "key", ",", "@", "nullable", "decl", "object", "column", "key", ")", "{", "integer", "row", "index", "=", "row", "key", "to", "index", "get", "(", "row", "key", ")", ";", "integer", "column", "index", "=", "column", "key", "to", "index", "get", "(", "column", "key", ")", ";", "if", "(", "row", "index", "=", "=", "null", "|", "|", "column", "index", "=", "=", "null", ")", "{", "return", "null", ";", "}", "return", "set", "(", "row", "index", ",", "column", "index", ",", "null", ")", ";", "}" ]
[ "this", "is", "actually", "the", "opencl", "platform", "type" ]
[ "public", "string", "get", "fpga", "type", "(", ")", "{", "return", "\"", "intel", "open", "c", "l", "\"", ";", "}" ]
[ "notepad", "pdb", "is", "here", ":", "<", "teexe", "notepad", "pdb", "xml", "does", "not", "exist", "repo", "location", "set", "to", "<", "tepdb", "xml", "special", "case", ":", "even", "if", "repo", "location", "is", "set", "to", "a", "location", "that", "doesn", "'", "t", "contain", "a", "pdb", "or", "pdb", "xml", "file", ",", "it", "will", "still", "be", "found", "if", "there", "is", "a", "file", "in", "the", "same", "folder", "as", "the", "binary", "on", "windows", ",", "pdb", "file", "should", "be", "found", "on", "non", "-", "windows", ",", "pdb", "file", "should", "be", "found" ]
[ "public", "void", "test", "find", "pdb", "1", "8", "(", ")", "throws", "exception", "{", "created", "files", "=", "create", "files", "(", "pdb", "location", "same", "as", "exe", "no", "subdir", ",", "pdb", "xml", "location", "none", ")", ";", "file", "pdb", "=", "pdb", "parser", "find", "p", "d", "b", "(", "test", "program", ",", "false", ",", "pdb", "xml", "dir", ")", ";", "assert", "not", "null", "(", "pdb", ")", ";", "assert", "equals", "(", "pdb", "file", ",", "pdb", ")", ";", "}" ]
[ "tests", "{", "@", "link", "result", "partition", "#", "emit", "record", "}", "on", "a", "partition", "which", "has", "already", "been", "released" ]
[ "private", "void", "test", "add", "on", "released", "partition", "(", "result", "partition", "type", "partition", "type", ")", "throws", "exception", "{", "test", "result", "partition", "consumable", "notifier", "notifier", "=", "new", "test", "result", "partition", "consumable", "notifier", "(", ")", ";", "buffer", "writing", "result", "partition", "buffer", "writing", "result", "partition", "=", "create", "result", "partition", "(", "partition", "type", ")", ";", "result", "partition", "writer", "partition", "writer", "=", "consumable", "notifying", "result", "partition", "writer", "decorator", "decorate", "(", "collections", "singleton", "(", "partition", "test", "utils", "create", "partition", "deployment", "descriptor", "(", "partition", "type", ")", ")", ",", "new", "result", "partition", "writer", "[", "]", "{", "buffer", "writing", "result", "partition", "}", ",", "new", "no", "op", "task", "actions", "(", ")", ",", "new", "job", "i", "d", "(", ")", ",", "notifier", ")", "[", "0", "]", ";", "try", "{", "partition", "writer", "release", "(", "null", ")", ";", "/", "/", "partition", "writer", "emit", "record", "(", ")", "should", "silently", "drop", "the", "given", "record", "partition", "writer", "emit", "record", "(", "byte", "buffer", "allocate", "(", "buffer", "size", ")", ",", "0", ")", ";", "}", "finally", "{", "assert", "equals", "(", "1", ",", "buffer", "writing", "result", "partition", "num", "buffers", "out", "get", "count", "(", ")", ")", ";", "assert", "equals", "(", "buffer", "size", ",", "buffer", "writing", "result", "partition", "num", "bytes", "out", "get", "count", "(", ")", ")", ";", "/", "/", "the", "buffer", "should", "be", "recycled", "for", "the", "result", "partition", "has", "already", "been", "released", "assert", "equals", "(", "0", ",", "buffer", "writing", "result", "partition", "get", "buffer", "pool", "(", ")", "best", "effort", "get", "num", "of", "used", "buffers", "(", ")", ")", ";", "/", "/", "should", "not", "have", "notified", "either", "notifier", "check", "(", "null", ",", "null", ",", "null", ",", "0", ")", ";", "}", "}" ]
[ "exit", "a", "parse", "tree", "produced", "by", "the", "{", "@", "code", "logical", "not", "}", "labeled", "alternative", "in", "{", "@", "link", "sql", "base", "parser", "#", "boolean", "expression", "}" ]
[ "void", "exit", "logical", "not", "(", "sql", "base", "parser", "logical", "not", "context", "ctx", ")", ";" ]
[ "same", "as", "{", "@", "link", "#", "remove", "(", "object", ")", "}", "but", "typed", "using", "generics" ]
[ "boolean", "remove", "typed", "(", "t", "node", ")", ";" ]
[ "merges", "this", "set", "with", "another", "{", "@", "code", "locals", "array", "set", "}", "instance" ]
[ "private", "locals", "array", "set", "merge", "with", "set", "(", "locals", "array", "set", "other", ")", "{", "one", "locals", "array", "new", "primary", ";", "array", "list", "<", "locals", "array", ">", "new", "secondaries", ";", "boolean", "secondaries", "changed", "=", "false", ";", "new", "primary", "=", "primary", "merge", "(", "other", "get", "primary", "(", ")", ")", ";", "int", "sz", "1", "=", "secondaries", "size", "(", ")", ";", "int", "sz", "2", "=", "other", "secondaries", "size", "(", ")", ";", "int", "sz", "=", "math", "max", "(", "sz", "1", ",", "sz", "2", ")", ";", "new", "secondaries", "=", "new", "array", "list", "(", "sz", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "sz", ";", "i", "+", "+", ")", "{", "locals", "array", "la", "1", "=", "(", "i", "<", "sz", "1", "?", "secondaries", "get", "(", "i", ")", ":", "null", ")", ";", "locals", "array", "la", "2", "=", "(", "i", "<", "sz", "2", "?", "other", "secondaries", "get", "(", "i", ")", ":", "null", ")", ";", "locals", "array", "resultla", "=", "null", ";", "if", "(", "la", "1", "=", "=", "la", "2", ")", "{", "resultla", "=", "la", "1", ";", "}", "else", "if", "(", "la", "1", "=", "=", "null", ")", "{", "resultla", "=", "la", "2", ";", "}", "else", "if", "(", "la", "2", "=", "=", "null", ")", "{", "resultla", "=", "la", "1", ";", "}", "else", "{", "try", "{", "resultla", "=", "la", "1", "merge", "(", "la", "2", ")", ";", "}", "catch", "(", "sim", "exception", "ex", ")", "{", "ex", "add", "context", "(", "\"", "merging", "locals", "set", "for", "caller", "block", "\"", "+", "hex", "u", "2", "(", "i", ")", ")", ";", "}", "}", "secondaries", "changed", "=", "secondaries", "changed", "|", "|", "(", "la", "1", "!", "=", "resultla", ")", ";", "new", "secondaries", "add", "(", "resultla", ")", ";", "}", "if", "(", "(", "primary", "=", "=", "new", "primary", ")", "&", "&", "!", "secondaries", "changed", ")", "{", "return", "this", ";", "}", "return", "new", "locals", "array", "set", "(", "new", "primary", ",", "new", "secondaries", ")", ";", "}" ]
[ "if", "{", "@", "link", "#", "pending", "}", "is", "non", "-", "null", "(", "meaning", "someone", "requested", "the", "task", "to", "be", "kicked", ")", ",", "but", "{", "@", "link", "#", "inprogress", "}", "is", "null", "(", "meaning", "none", "is", "executing", "right", "now", ")", ",", "get", "one", "going" ]
[ "private", "synchronized", "void", "maybe", "run", "(", ")", "{", "if", "(", "inprogress", "=", "=", "null", "&", "&", "pending", "!", "=", "null", ")", "{", "base", "submit", "(", "new", "callable", "<", "void", ">", "(", ")", "{", "@", "override", "public", "void", "call", "(", ")", "throws", "exception", "{", "synchronized", "(", "atmost", "one", "task", "executor", "this", ")", "{", "/", "/", "everyone", "who", "submits", "after", "this", "should", "form", "a", "next", "batch", "inprogress", "=", "pending", ";", "pending", "=", "null", ";", "}", "try", "{", "inprogress", "set", "(", "task", "call", "(", ")", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "logger", "log", "(", "level", "warning", ",", "null", ",", "t", ")", ";", "inprogress", "set", "exception", "(", "t", ")", ";", "}", "finally", "{", "synchronized", "(", "atmost", "one", "task", "executor", "this", ")", "{", "/", "/", "if", "next", "one", "is", "pending", ",", "get", "that", "scheduled", "inprogress", "=", "null", ";", "maybe", "run", "(", ")", ";", "}", "}", "return", "null", ";", "}", "}", ")", ";", "}", "}" ]
[ "makes", "the", "given", "visitor", "visit", "the", "jvms", "class", "file", "structure", "passed", "to", "the", "constructor", "of", "this", "{", "@", "link", "class", "reader", "}" ]
[ "public", "void", "accept", "(", "final", "class", "visitor", "class", "visitor", ",", "final", "int", "parsing", "options", ")", "{", "accept", "(", "class", "visitor", ",", "new", "attribute", "[", "0", "]", ",", "parsing", "options", ")", ";", "}" ]
[ "drops", "pages", "up", "to", "the", "specified", "sequence", "id" ]
[ "public", "void", "acknowledge", "pages", "(", "long", "sequence", "id", ")", "{", "check", "argument", "(", "sequence", "id", ">", "=", "0", ",", "\"", "invalid", "sequence", "id", "\"", ")", ";", "/", "/", "fast", "path", "early", "-", "return", "without", "synchronizing", "if", "(", "destroyed", "get", "(", ")", "|", "|", "sequence", "id", "<", "current", "sequence", "id", "get", "(", ")", ")", "{", "return", ";", "}", "immutable", "list", "builder", "<", "serialized", "page", "reference", ">", "removed", "pages", ";", "synchronized", "(", "this", ")", "{", "if", "(", "destroyed", "get", "(", ")", ")", "{", "return", ";", "}", "/", "/", "if", "pages", "have", "already", "been", "acknowledged", ",", "just", "ignore", "this", "long", "old", "current", "sequence", "id", "=", "current", "sequence", "id", "get", "(", ")", ";", "if", "(", "sequence", "id", "<", "old", "current", "sequence", "id", ")", "{", "return", ";", "}", "int", "pages", "to", "remove", "=", "to", "int", "exact", "(", "sequence", "id", "-", "old", "current", "sequence", "id", ")", ";", "check", "argument", "(", "pages", "to", "remove", "<", "=", "pages", "size", "(", ")", ",", "\"", "invalid", "sequence", "id", "\"", ")", ";", "removed", "pages", "=", "immutable", "list", "builder", "with", "expected", "size", "(", "pages", "to", "remove", ")", ";", "long", "bytes", "removed", "=", "0", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "pages", "to", "remove", ";", "i", "+", "+", ")", "{", "serialized", "page", "reference", "removed", "page", "=", "pages", "remove", "first", "(", ")", ";", "removed", "pages", "add", "(", "removed", "page", ")", ";", "bytes", "removed", "+", "=", "removed", "page", "get", "retained", "size", "in", "bytes", "(", ")", ";", "}", "/", "/", "update", "current", "sequence", "id", "verify", "(", "current", "sequence", "id", "compare", "and", "set", "(", "old", "current", "sequence", "id", ",", "old", "current", "sequence", "id", "+", "pages", "to", "remove", ")", ")", ";", "/", "/", "update", "memory", "tracking", "verify", "(", "buffered", "bytes", "add", "and", "get", "(", "-", "bytes", "removed", ")", ">", "=", "0", ")", ";", "}", "/", "/", "dereference", "outside", "of", "synchronized", "to", "avoid", "making", "a", "callback", "while", "holding", "a", "lock", "dereference", "pages", "(", "removed", "pages", "build", "(", ")", ",", "on", "pages", "released", ")", ";", "}" ]
[ "the", "series", "of", "types", "defined", "by", "the", "package", "<", "code", ">", "repeated", "aapt", "pb", "type", "type", "=", "3", ";", "<", "code", ">" ]
[ "public", "com", "android", "aapt", "resources", "type", "get", "type", "(", "int", "index", ")", "{", "return", "instance", "get", "type", "(", "index", ")", ";", "}" ]
[ "get", "an", "optional", "j", "s", "o", "n", "array", "associated", "with", "a", "key", "it", "returns", "null", "if", "there", "is", "no", "such", "key", ",", "or", "if", "its", "value", "is", "not", "a", "j", "s", "o", "n", "array" ]
[ "public", "j", "s", "o", "n", "array", "opt", "j", "s", "o", "n", "array", "(", "string", "key", ")", "{", "object", "o", "=", "opt", "(", "key", ")", ";", "return", "o", "instanceof", "j", "s", "o", "n", "array", "?", "(", "j", "s", "o", "n", "array", ")", "o", ":", "null", ";", "}" ]
[ "the", "response", "resources", "wrapped", "in", "the", "common", "mcp", "resource", "message", "these", "are", "typed", "resources", "that", "match", "the", "type", "url", "in", "the", "incremental", "mesh", "config", "request", "<", "code", ">", "repeated", "istio", "mcp", "v", "1alpha", "1", "resource", "resources", "=", "2", ";", "<", "code", ">" ]
[ "public", "com", "alibaba", "nacos", "istio", "model", "mcp", "resource", "builder", "get", "resources", "builder", "(", "int", "index", ")", "{", "return", "get", "resources", "field", "builder", "(", ")", "get", "builder", "(", "index", ")", ";", "}" ]
[ "helper", "method", "to", "create", "a", "{", "@", "link", "cache", "handle", "}", "from", "a", "successful", "{", "@", "link", "spawn", "result", "}", "instance" ]
[ "public", "static", "cache", "handle", "success", "(", "final", "spawn", "result", "result", ")", "{", "return", "new", "cache", "handle", "(", ")", "{", "@", "override", "public", "boolean", "has", "result", "(", ")", "{", "return", "true", ";", "}", "@", "override", "public", "spawn", "result", "get", "result", "(", ")", "{", "return", "result", ";", "}", "@", "override", "public", "boolean", "will", "store", "(", ")", "{", "return", "false", ";", "}", "@", "override", "public", "void", "store", "(", "spawn", "result", "result", ")", "throws", "interrupted", "exception", ",", "i", "o", "exception", "{", "throw", "new", "illegal", "state", "exception", "(", ")", ";", "}", "@", "override", "public", "void", "close", "(", ")", "{", "}", "}", ";", "}" ]
[ "returns", "true", "if", "this", "decision", "set", "has", "no", "results" ]
[ "public", "boolean", "is", "empty", "(", ")", "{", "return", "decision", "list", "is", "empty", "(", ")", ";", "}" ]
[ "return", "whether", "to", "ignore", "unknown", "fields", "when", "binding" ]
[ "public", "boolean", "is", "ignore", "unknown", "fields", "(", ")", "{", "return", "this", "ignore", "unknown", "fields", ";", "}" ]
[ "create", "a", "history", "file", "info", "instance", "that", "hangs", "on", "parsing", "job", "files" ]
[ "protected", "history", "file", "manager", "history", "file", "info", "create", "history", "file", "info", "(", "path", "history", "file", ",", "path", "conf", "file", ",", "path", "summary", "file", ",", "job", "index", "info", "job", "index", "info", ",", "boolean", "is", "in", "done", ")", "{", "return", "new", "history", "file", "info", "(", "history", "file", ",", "conf", "file", ",", "summary", "file", ",", "job", "index", "info", ",", "is", "in", "done", ",", "scanning", "done", "signals", "get", "(", "job", "index", "info", "get", "job", "id", "(", ")", ")", ")", ";", "}" ]
[ "retrieves", "cause", "exception", "and", "wraps", "to", "{", "@", "link", "command", "action", "execution", "exception", "}" ]
[ "public", "static", "void", "propagate", "cause", "(", "throwable", "throwable", ")", "throws", "command", "action", "execution", "exception", "{", "throw", "new", "command", "action", "execution", "exception", "(", "throwable", "get", "cause", "(", ")", ")", ";", "}" ]
[ "call", "before", "a", "job", "is", "copied", "into", "a", "new", "parent", ",", "to", "allow", "the", "{", "@", "link", "item", "listener", "}", "implementations", "the", "ability", "to", "veto", "the", "copy", "operation", "before", "it", "starts" ]
[ "public", "static", "void", "check", "before", "copy", "(", "final", "item", "src", ",", "final", "item", "group", "parent", ")", "throws", "failure", "{", "for", "(", "item", "listener", "l", ":", "all", "(", ")", ")", "{", "try", "{", "l", "on", "check", "copy", "(", "src", ",", "parent", ")", ";", "}", "catch", "(", "failure", "e", ")", "{", "throw", "e", ";", "}", "catch", "(", "runtime", "exception", "x", ")", "{", "logger", "log", "(", "level", "warning", ",", "\"", "failed", "to", "send", "event", "to", "listener", "of", "\"", "+", "l", "get", "class", "(", ")", ",", "x", ")", ";", "}", "}", "}" ]
[ "allows", "to", "call", "{", "@", "link", "metadata", "index", "state", "service", "#", "add", "index", "closed", "blocks", "(", "index", "[", "]", ",", "map", ",", "cluster", "state", ")", "}", "which", "is", "a", "protected", "method" ]
[ "public", "static", "cluster", "state", "add", "index", "closed", "blocks", "(", "final", "index", "[", "]", "indices", ",", "final", "map", "<", "index", ",", "cluster", "block", ">", "blocked", "indices", ",", "final", "cluster", "state", "state", ")", "{", "return", "metadata", "index", "state", "service", "add", "index", "closed", "blocks", "(", "indices", ",", "blocked", "indices", ",", "state", ")", ";", "}" ]
[ "returns", "the", "name", "of", "the", "lookup", "service", "as", "a", "g", "r", "p", "c", "uri", "typically", ",", "this", "will", "be", "a", "subdomain", "of", "the", "target", ",", "such", "as", "\"", "lookup", "datastore", "googleapis", "com", "\"" ]
[ "string", "get", "lookup", "service", "(", ")", "{", "return", "lookup", "service", ";", "}" ]
[ "the", "value", "of", "the", "number", "of", "classes", "item", "indicates", "the", "number", "of", "entries", "in", "the", "classes", "array" ]
[ "public", "int", "get", "number", "of", "inner", "classes", "(", ")", "{", "return", "number", "of", "inner", "classes", "&", "0xffff", ";", "}" ]
[ "sets", "the", "partitioning", "of", "the", "{", "@", "link", "data", "stream", "}", "so", "that", "the", "output", "elements", "are", "broadcasted", "to", "every", "parallel", "instance", "of", "the", "next", "operation" ]
[ "public", "data", "stream", "<", "t", ">", "broadcast", "(", ")", "{", "return", "set", "connection", "type", "(", "new", "broadcast", "partitioner", "<", "t", ">", "(", ")", ")", ";", "}" ]
[ "calculate", "the", "geohash", "of", "a", "neighbor", "of", "a", "geohash" ]
[ "public", "static", "final", "string", "get", "neighbor", "(", "string", "geohash", ",", "int", "level", ",", "int", "dx", ",", "int", "dy", ")", "{", "int", "cell", "=", "base", "32", "string", "index", "of", "(", "geohash", "char", "at", "(", "level", "-", "1", ")", ")", ";", "/", "/", "decoding", "the", "geohash", "bit", "pattern", "to", "determine", "grid", "coordinates", "int", "x", "0", "=", "cell", "&", "1", ";", "/", "/", "first", "bit", "of", "x", "int", "y", "0", "=", "cell", "&", "2", ";", "/", "/", "first", "bit", "of", "y", "int", "x", "1", "=", "cell", "&", "4", ";", "/", "/", "second", "bit", "of", "x", "int", "y", "1", "=", "cell", "&", "8", ";", "/", "/", "second", "bit", "of", "y", "int", "x", "2", "=", "cell", "&", "16", ";", "/", "/", "third", "bit", "of", "x", "/", "/", "combine", "the", "bitpattern", "to", "grid", "coordinates", "/", "/", "note", "that", "the", "semantics", "of", "x", "and", "y", "are", "swapping", "/", "/", "on", "each", "level", "int", "x", "=", "x", "0", "+", "(", "x", "1", "/", "2", ")", "+", "(", "x", "2", "/", "4", ")", ";", "int", "y", "=", "(", "y", "0", "/", "2", ")", "+", "(", "y", "1", "/", "4", ")", ";", "if", "(", "level", "=", "=", "1", ")", "{", "/", "/", "root", "cells", "at", "north", "(", "namely", "\"", "bcfguvyz", "\"", ")", "or", "at", "/", "/", "south", "(", "namely", "\"", "0", "1", "4", "5hjnp", "\"", ")", "do", "not", "have", "neighbors", "/", "/", "in", "north", "/", "south", "direction", "if", "(", "(", "dy", "<", "0", "&", "&", "y", "=", "=", "0", ")", "|", "|", "(", "dy", ">", "0", "&", "&", "y", "=", "=", "3", ")", ")", "{", "return", "null", ";", "}", "else", "{", "return", "character", "to", "string", "(", "encode", "base", "3", "2", "(", "x", "+", "dx", ",", "y", "+", "dy", ")", ")", ";", "}", "}", "else", "{", "/", "/", "define", "grid", "coordinates", "for", "next", "level", "final", "int", "nx", "=", "(", "(", "level", "%", "2", ")", "=", "=", "1", ")", "?", "(", "x", "+", "dx", ")", ":", "(", "x", "+", "dy", ")", ";", "final", "int", "ny", "=", "(", "(", "level", "%", "2", ")", "=", "=", "1", ")", "?", "(", "y", "+", "dy", ")", ":", "(", "y", "+", "dx", ")", ";", "/", "/", "if", "the", "defined", "neighbor", "has", "the", "same", "parent", "a", "the", "current", "cell", "/", "/", "encode", "the", "cell", "directly", "otherwise", "find", "the", "cell", "next", "to", "this", "/", "/", "cell", "recursively", "since", "encoding", "wraps", "around", "within", "a", "cell", "/", "/", "it", "can", "be", "encoded", "here", "/", "/", "x", "limit", "and", "y", "limit", "must", "always", "be", "respectively", "7", "and", "3", "/", "/", "since", "x", "and", "y", "semantics", "are", "swapping", "on", "each", "level", "if", "(", "nx", ">", "=", "0", "&", "&", "nx", "<", "=", "7", "&", "&", "ny", ">", "=", "0", "&", "&", "ny", "<", "=", "3", ")", "{", "return", "geohash", "substring", "(", "0", ",", "level", "-", "1", ")", "+", "encode", "base", "3", "2", "(", "nx", ",", "ny", ")", ";", "}", "else", "{", "string", "neighbor", "=", "get", "neighbor", "(", "geohash", ",", "level", "-", "1", ",", "dx", ",", "dy", ")", ";", "return", "(", "neighbor", "!", "=", "null", ")", "?", "neighbor", "+", "encode", "base", "3", "2", "(", "nx", ",", "ny", ")", ":", "neighbor", ";", "}", "}", "}" ]
[ "this", "bounds", "suppressions", ",", "useful", "because", "contexts", "can", "be", "accidentally", "unlimited", "cardinality" ]
[ "public", "builder", "cardinality", "(", "int", "cardinality", ")", "{", "this", "cardinality", "=", "cardinality", ";", "return", "this", ";", "}" ]
[ "get", "the", "actual", "instance", "of", "`", "apple", "`", "if", "the", "actual", "instanct", "is", "not", "`", "apple", "`", ",", "the", "class", "cast", "exception", "will", "be", "thrown" ]
[ "public", "apple", "get", "apple", "(", ")", "throws", "class", "cast", "exception", "{", "return", "(", "apple", ")", "super", "get", "actual", "instance", "(", ")", ";", "}" ]
[ "test", "the", "property", "'", "email", "'" ]
[ "public", "void", "email", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "email", "}" ]
[ "update", "file", "listcache", "based", "upon", "rename", "of", "file", "if", "this", "folder", "has", "been", "visited", "listener", "will", "be", "notified", "with", "rename" ]
[ "void", "file", "renamed", "(", "string", "old", "file", "name", ",", "string", "new", "file", "name", ")", "{", "ghidra", "file", "data", "file", "data", ";", "synchronized", "(", "file", "system", ")", "{", "file", "data", "=", "file", "data", "cache", "remove", "(", "old", "file", "name", ")", ";", "if", "(", "file", "data", "=", "=", "null", "|", "|", "this", "!", "=", "file", "data", "get", "parent", "(", ")", "|", "|", "!", "new", "file", "name", "equals", "(", "file", "data", "get", "name", "(", ")", ")", ")", "{", "throw", "new", "assert", "exception", "(", ")", ";", "}", "if", "(", "visited", ")", "{", "file", "list", "remove", "(", "old", "file", "name", ")", ";", "}", "if", "(", "visited", ")", "{", "file", "list", "add", "(", "new", "file", "name", ")", ";", "}", "file", "data", "cache", "put", "(", "new", "file", "name", ",", "file", "data", ")", ";", "if", "(", "visited", ")", "{", "listener", "domain", "file", "renamed", "(", "get", "domain", "file", "(", "new", "file", "name", ")", ",", "old", "file", "name", ")", ";", "}", "}", "}" ]
[ "model", "tests", "for", "category" ]
[ "public", "void", "test", "category", "(", ")", "{", "/", "/", "todo", ":", "test", "category", "}" ]
[ "updates", "book", "in", "collection", "only", "if", "client", "has", "modified", "the", "latest", "version", "of", "the", "book" ]
[ "public", "void", "update", "(", "book", "book", ")", "throws", "book", "not", "found", "exception", ",", "version", "mismatch", "exception", "{", "if", "(", "!", "collection", "contains", "key", "(", "book", "get", "id", "(", ")", ")", ")", "{", "throw", "new", "book", "not", "found", "exception", "(", "\"", "not", "found", "book", "with", "id", ":", "\"", "+", "book", "get", "id", "(", ")", ")", ";", "}", "var", "latest", "book", "=", "collection", "get", "(", "book", "get", "id", "(", ")", ")", ";", "if", "(", "book", "get", "version", "(", ")", "!", "=", "latest", "book", "get", "version", "(", ")", ")", "{", "throw", "new", "version", "mismatch", "exception", "(", "\"", "tried", "to", "update", "stale", "version", "\"", "+", "book", "get", "version", "(", ")", "+", "\"", "while", "actual", "version", "is", "\"", "+", "latest", "book", "get", "version", "(", ")", ")", ";", "}", "/", "/", "update", "version", ",", "including", "client", "representation", "-", "modify", "by", "reference", "here", "book", "set", "version", "(", "book", "get", "version", "(", ")", "+", "1", ")", ";", "/", "/", "save", "book", "copy", "to", "repository", "collection", "put", "(", "book", "get", "id", "(", ")", ",", "new", "book", "(", "book", ")", ")", ";", "}" ]
[ "convert", "strings", "with", "both", "quotes", "and", "ticks", "into", "a", "valid", "xpath", "component", "for", "example", ",", "{", "@", "code", "foo", "}", "will", "be", "converted", "to", "{", "@", "code", "\"", "foo", "\"", "}", ",", "{", "@", "code", "f", "\"", "oo", "}", "will", "be", "converted", "to", "{", "@", "code", "'", "f", "\"", "oo", "'", "}", ",", "{", "@", "code", "foo", "'", "\"", "bar", "}", "will", "be", "converted", "to", "{", "@", "code", "concat", "(", "\"", "foo", "'", "\"", ",", "'", "\"", "'", ",", "\"", "bar", "\"", ")", "}" ]
[ "public", "static", "string", "escape", "(", "string", "to", "escape", ")", "{", "if", "(", "to", "escape", "contains", "(", "\"", "\\", "\"", "\"", ")", "&", "&", "to", "escape", "contains", "(", "\"", "'", "\"", ")", ")", "{", "boolean", "quote", "is", "last", "=", "false", ";", "if", "(", "to", "escape", "last", "index", "of", "(", "\"", "\\", "\"", "\"", ")", "=", "=", "to", "escape", "length", "(", ")", "-", "1", ")", "{", "quote", "is", "last", "=", "true", ";", "}", "string", "[", "]", "substrings", "without", "quotes", "=", "to", "escape", "split", "(", "\"", "\\", "\"", "\"", ")", ";", "string", "builder", "quoted", "=", "new", "string", "builder", "(", "\"", "concat", "(", "\"", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "substrings", "without", "quotes", "length", ";", "i", "+", "+", ")", "{", "quoted", "append", "(", "\"", "\\", "\"", "\"", ")", "append", "(", "substrings", "without", "quotes", "[", "i", "]", ")", "append", "(", "\"", "\\", "\"", "\"", ")", ";", "quoted", "append", "(", "(", "(", "i", "=", "=", "substrings", "without", "quotes", "length", "-", "1", ")", "?", "(", "quote", "is", "last", "?", "\"", ",", "'", "\\", "\"", "'", ")", "\"", ":", "\"", ")", "\"", ")", ":", "\"", ",", "'", "\\", "\"", "'", ",", "\"", ")", ")", ";", "}", "return", "quoted", "to", "string", "(", ")", ";", "}", "/", "/", "escape", "string", "with", "just", "a", "quote", "into", "being", "single", "quoted", ":", "f", "\"", "oo", "-", ">", "'", "f", "\"", "oo", "'", "if", "(", "to", "escape", "contains", "(", "\"", "\\", "\"", "\"", ")", ")", "{", "return", "string", "format", "(", "\"", "'", "%", "s", "'", "\"", ",", "to", "escape", ")", ";", "}", "/", "/", "otherwise", "return", "the", "quoted", "string", "return", "string", "format", "(", "\"", "\\", "\"", "%", "s", "\\", "\"", "\"", ",", "to", "escape", ")", ";", "}" ]
[ "create", "random", "highlight", "builder", "that", "is", "put", "under", "test" ]
[ "public", "static", "highlight", "builder", "random", "highlighter", "builder", "(", ")", "{", "highlight", "builder", "test", "highlighter", "=", "new", "highlight", "builder", "(", ")", ";", "set", "random", "common", "options", "(", "test", "highlighter", ")", ";", "test", "highlighter", "use", "explicit", "field", "order", "(", "random", "boolean", "(", ")", ")", ";", "if", "(", "random", "boolean", "(", ")", ")", "{", "test", "highlighter", "encoder", "(", "random", "from", "(", "arrays", "as", "list", "(", "new", "string", "[", "]", "{", "\"", "default", "\"", ",", "\"", "html", "\"", "}", ")", ")", ")", ";", "}", "int", "number", "of", "fields", "=", "random", "int", "between", "(", "1", ",", "5", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "number", "of", "fields", ";", "i", "+", "+", ")", "{", "field", "field", "=", "new", "field", "(", "i", "+", "\"", "\"", "+", "random", "alpha", "of", "length", "between", "(", "1", ",", "10", ")", ")", ";", "set", "random", "common", "options", "(", "field", ")", ";", "if", "(", "random", "boolean", "(", ")", ")", "{", "field", "fragment", "offset", "(", "random", "int", "between", "(", "1", ",", "100", ")", ")", ";", "}", "if", "(", "random", "boolean", "(", ")", ")", "{", "field", "matched", "fields", "(", "random", "string", "array", "(", "0", ",", "4", ")", ")", ";", "}", "test", "highlighter", "field", "(", "field", ")", ";", "}", "return", "test", "highlighter", ";", "}", "@", "suppress", "warnings", "(", "{", "\"", "rawtypes", "\"", "}" ]
[ "wraps", "the", "given", "{", "@", "link", "bytes", "stream", "}", "in", "a", "{", "@", "link", "stream", "output", "}", "that", "simply", "flushes", "when", "close", "is", "called" ]
[ "public", "static", "bytes", "stream", "flush", "on", "close", "stream", "(", "bytes", "stream", "os", ")", "{", "return", "new", "flush", "on", "close", "output", "stream", "(", "os", ")", ";", "}" ]
[ "return", "{", "@", "code", "true", "}", "if", "this", "node", "in", "the", "tree", "has", "any", "subtrees" ]
[ "public", "boolean", "has", "sub", "trees", "(", ")", "{", "return", "false", "=", "=", "sub", "trees", "is", "empty", "(", ")", ";", "}" ]
[ "{", "@", "inherit", "doc", "}" ]
[ "public", "int", "get", "minimum", "idle", "(", ")", "{", "return", "min", "idle", ";", "}" ]
[ "returns", "the", "data", "input", "from", "which", "the", "client", "output", "is", "read" ]
[ "public", "data", "input", "get", "client", "input", "(", ")", "{", "return", "client", "in", ";", "}" ]
[ "appends", "an", "account", "name", "to", "a", "configuration", "key", "yielding", "the", "account", "-", "specific", "form" ]
[ "public", "string", "account", "conf", "(", "string", "key", ")", "{", "return", "key", "+", "\"", "\"", "+", "account", "name", ";", "}" ]
[ "builder", "method", "for", "activity", "id", "parameter" ]
[ "public", "builder", "with", "activity", "id", "(", "string", "activity", "id", ")", "{", "this", "activity", "id", "=", "activity", "id", ";", "return", "this", ";", "}" ]
[ "{", "@", "inherit", "doc", "}", "<", "br", ">", "implementation", "notes", ":", "<", "br", ">", "queue", "is", "empty", "when", "producer", "node", "is", "the", "same", "as", "consumer", "node", "an", "alternative", "implementation", "would", "be", "to", "observe", "the", "producer", "node", "value", "is", "null", ",", "which", "also", "means", "an", "empty", "queue", "because", "only", "the", "consumer", "node", "value", "is", "allowed", "to", "be", "null" ]
[ "public", "boolean", "is", "empty", "(", ")", "{", "return", "lv", "consumer", "node", "(", ")", "=", "=", "lv", "producer", "node", "(", ")", ";", "}" ]
[ "sets", "the", "value", "of", "the", "given", "{", "@", "code", "entry", "}" ]
[ "void", "set", "value", "(", "e", "entry", ",", "v", "value", ")", "{", "this", "map", "entry", "helper", "set", "value", "(", "self", "(", ")", ",", "entry", ",", "value", ")", ";", "}" ]
[ "source", "-", "code", "based", "on", "http", ":", "groups", "google", "comgroupgoogle", "-", "gsonbrowse", "threadthread", "5", "6", "3bb", "5", "1ee", "2", "4", "9", "5", "0", "8", "1" ]
[ "public", "void", "test", "multi", "thread", "serialization", "(", ")", "throws", "interrupted", "exception", "{", "final", "count", "down", "latch", "start", "latch", "=", "new", "count", "down", "latch", "(", "1", ")", ";", "final", "count", "down", "latch", "finished", "latch", "=", "new", "count", "down", "latch", "(", "10", ")", ";", "final", "atomic", "boolean", "failed", "=", "new", "atomic", "boolean", "(", "false", ")", ";", "executor", "service", "executor", "=", "executors", "new", "fixed", "thread", "pool", "(", "10", ")", ";", "for", "(", "int", "task", "count", "=", "0", ";", "task", "count", "<", "10", ";", "task", "count", "+", "+", ")", "{", "executor", "execute", "(", "new", "runnable", "(", ")", "{", "public", "void", "run", "(", ")", "{", "my", "object", "my", "obj", "=", "new", "my", "object", "(", ")", ";", "try", "{", "start", "latch", "await", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "10", ";", "i", "+", "+", ")", "{", "gson", "to", "json", "(", "my", "obj", ")", ";", "}", "}", "catch", "(", "throwable", "t", ")", "{", "failed", "set", "(", "true", ")", ";", "}", "finally", "{", "finished", "latch", "count", "down", "(", ")", ";", "}", "}", "}", ")", ";", "}", "start", "latch", "count", "down", "(", ")", ";", "finished", "latch", "await", "(", ")", ";", "assert", "false", "(", "failed", "get", "(", ")", ")", ";", "}" ]
[ "render", "this", "{", "@", "link", "node", "}", "as", "a", "tree", "like", "{", "@", "code", "project", "[", "[", "i", "{", "f", "}", "#", "0", "]", "]", "\\", "filter", "[", "i", "{", "f", "}", "#", "1", "]", "\\", "sub", "query", "alias", "[", "test", "]", "\\", "es", "relation", "[", "test", "]", "[", "i", "{", "f", "}", "#", "2", "]", "}" ]
[ "final", "string", "builder", "tree", "string", "(", "string", "builder", "sb", ",", "int", "depth", ",", "bit", "set", "has", "parent", "per", "depth", ")", "{", "if", "(", "depth", ">", "0", ")", "{", "/", "/", "draw", "children", "for", "(", "int", "column", "=", "0", ";", "column", "<", "depth", ";", "column", "+", "+", ")", "{", "if", "(", "has", "parent", "per", "depth", "get", "(", "column", ")", ")", "{", "sb", "append", "(", "\"", "|", "\"", ")", ";", "/", "/", "if", "not", "the", "last", "elder", ",", "adding", "padding", "(", "since", "each", "column", "has", "two", "chars", "(", "\"", "|", "\"", "or", "\"", "\\", "\"", ")", "if", "(", "column", "<", "depth", "-", "1", ")", "{", "sb", "append", "(", "\"", "\"", ")", ";", "}", "}", "else", "{", "/", "/", "if", "the", "child", "has", "no", "parent", "(", "elder", "on", "the", "previous", "level", ")", ",", "it", "means", "its", "the", "last", "sibling", "sb", "append", "(", "(", "column", "=", "=", "depth", "-", "1", ")", "?", "\"", "\\", "\\", "\"", ":", "\"", "\"", ")", ";", "}", "}", "sb", "append", "(", "\"", "\"", ")", ";", "}", "sb", "append", "(", "node", "string", "(", ")", ")", ";", "list", "<", "t", ">", "children", "=", "children", "(", ")", ";", "if", "(", "!", "children", "is", "empty", "(", ")", ")", "{", "sb", "append", "(", "\"", "\\", "n", "\"", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "children", "size", "(", ")", ";", "i", "+", "+", ")", "{", "t", "t", "=", "children", "get", "(", "i", ")", ";", "has", "parent", "per", "depth", "set", "(", "depth", ",", "i", "<", "children", "size", "(", ")", "-", "1", ")", ";", "t", "tree", "string", "(", "sb", ",", "depth", "+", "1", ",", "has", "parent", "per", "depth", ")", ";", "if", "(", "i", "<", "children", "size", "(", ")", "-", "1", ")", "{", "sb", "append", "(", "\"", "\\", "n", "\"", ")", ";", "}", "}", "return", "sb", ";", "}" ]
[ "returns", "the", "home", "{", "@", "link", "sub", "cluster", "id", "}", "for", "the", "specified", "{", "@", "link", "application", "id", "}" ]
[ "public", "sub", "cluster", "id", "get", "application", "home", "sub", "cluster", "(", "application", "id", "app", "id", ")", "throws", "yarn", "exception", "{", "get", "application", "home", "sub", "cluster", "response", "response", "=", "state", "store", "get", "application", "home", "sub", "cluster", "(", "get", "application", "home", "sub", "cluster", "request", "new", "instance", "(", "app", "id", ")", ")", ";", "return", "response", "get", "application", "home", "sub", "cluster", "(", ")", "get", "home", "sub", "cluster", "(", ")", ";", "}" ]
[ "remove", "{", "@", "code", "node", "}", "from", "the", "set", "of", "successors", "returns", "the", "value", "previously", "associated", "with", "the", "edge", "connecting", "the", "two", "nodes" ]
[ "v", "remove", "successor", "(", "n", "node", ")", ";" ]
[ "the", "set", "of", "values", "defined", "for", "this", "entry", ",", "each", "corresponding", "to", "a", "different", "configurationvariant", "<", "code", ">", "repeated", "aapt", "pb", "config", "value", "config", "value", "=", "4", ";", "<", "code", ">" ]
[ "public", "int", "get", "config", "value", "count", "(", ")", "{", "return", "config", "value", "size", "(", ")", ";", "}" ]
[ "create", "a", "new", "parseable", "execution", "requirement", "definition", "if", "a", "tag", "doesn", "'", "t", "match", "the", "detection", "pattern", ",", "it", "will", "be", "ignored", "if", "a", "tag", "matches", "the", "detection", "pattern", ",", "but", "not", "the", "validation", "pattern", ",", "it", "is", "assumed", "that", "the", "value", "is", "somehow", "wrong", "(", "e", "g", "the", "user", "put", "a", "float", "or", "random", "string", "where", "we", "expected", "an", "integer", ")" ]
[ "static", "parseable", "requirement", "create", "(", "string", "user", "friendly", "name", ",", "pattern", "detection", "pattern", ",", "function", "<", "string", ",", "string", ">", "validator", ")", "{", "return", "new", "auto", "value", "execution", "requirements", "parseable", "requirement", "(", "user", "friendly", "name", ",", "detection", "pattern", ",", "validator", ")", ";", "}" ]
[ "poll", "(", ")", "provides", "no", "strict", "consistency", ":", "it", "is", "possible", "for", "poll", "to", "return", "null", "even", "though", "an", "element", "is", "in", "the", "queue" ]
[ "public", "e", "poll", "(", ")", "{", "return", "semaphore", "try", "acquire", "(", ")", "?", "remove", "next", "element", "(", ")", ":", "null", ";", "}" ]
[ "extracts", "element", "at", "current", "take", "position", ",", "advances", ",", "and", "signals", "call", "only", "when", "occupying", "monitor" ]
[ "private", "e", "extract", "(", ")", "{", "final", "e", "[", "]", "items", "=", "this", "items", ";", "e", "x", "=", "items", "[", "take", "index", "]", ";", "items", "[", "take", "index", "]", "=", "null", ";", "take", "index", "=", "inc", "(", "take", "index", ")", ";", "-", "-", "count", ";", "return", "x", ";", "}" ]
[ "returns", "whether", "the", "decoder", "is", "known", "to", "behave", "incorrectly", "if", "flushed", "prior", "to", "having", "output", "a", "{", "@", "link", "media", "format", "}", "if", "true", "is", "returned", ",", "the", "renderer", "will", "work", "around", "the", "issue", "by", "instantiating", "a", "new", "decoder", "when", "this", "case", "occurs", "see", "[", "internal", ":", "b", "1", "4", "1", "0", "9", "7", "3", "6", "7", "]" ]
[ "private", "static", "boolean", "codec", "needs", "sos", "flush", "workaround", "(", "string", "name", ")", "{", "return", "util", "sdk", "int", "=", "=", "29", "&", "&", "\"", "c", "2", "android", "aac", "decoder", "\"", "equals", "(", "name", ")", ";", "}" ]
[ "a", "safety", "wrapper", "around", "{", "@", "link", "#", "external", "(", "context", ",", "string", ")", "}", "for", "when", "you", "know", "you", "'", "re", "using", "an", "identifier", "for", "a", "system", "contact", ",", "and", "therefore", "always", "want", "to", "prevent", "interpreting", "it", "as", "a", "uuid", "this", "will", "crash", "if", "given", "a", "uuid", "(", "this", "may", "seem", "strange", ",", "but", "apparently", "some", "devices", "are", "returning", "valid", "u", "u", "i", "ds", "for", "contacts", ")" ]
[ "public", "static", "@", "non", "null", "recipient", "external", "contact", "(", "@", "non", "null", "context", "context", ",", "@", "non", "null", "string", "identifier", ")", "{", "recipient", "database", "db", "=", "database", "factory", "get", "recipient", "database", "(", "context", ")", ";", "recipient", "id", "id", "=", "null", ";", "if", "(", "uuid", "util", "is", "uuid", "(", "identifier", ")", ")", "{", "throw", "new", "assertion", "error", "(", "\"", "u", "u", "i", "ds", "are", "not", "valid", "system", "contact", "identifiers", "!", "\"", ")", ";", "}", "else", "if", "(", "number", "util", "is", "valid", "email", "(", "identifier", ")", ")", "{", "id", "=", "db", "get", "or", "insert", "from", "email", "(", "identifier", ")", ";", "}", "else", "{", "id", "=", "db", "get", "or", "insert", "from", "e", "1", "6", "4", "(", "identifier", ")", ";", "}", "return", "recipient", "resolved", "(", "id", ")", ";", "}" ]
[ "remove", "x", "attr", "from", "the", "inode" ]
[ "void", "remove", "xattr", "(", "long", "id", ",", "string", "xattr", "name", ")", "throws", "i", "o", "exception", ";" ]
[ "used", "to", "url", "-", "bind", "{", "@", "link", "annotated", "large", "text", "}" ]
[ "public", "@", "non", "null", "annotated", "large", "text", "get", "log", "text", "(", ")", "{", "return", "new", "annotated", "large", "text", "(", "get", "log", "file", "(", ")", ",", "get", "charset", "(", ")", ",", "!", "is", "log", "updated", "(", ")", ",", "this", ")", ";", "}" ]
[ "returns", "the", "configuration", "an", "aspect", "should", "be", "evaluated", "with" ]
[ "public", "build", "configuration", "get", "aspect", "configuration", "(", "aspect", "descriptor", "aspect", ")", "{", "return", "get", "configuration", "(", ")", ";", "}" ]
[ "gets", "the", "decoded", "locals", "list", ",", "in", "ascending", "start", "-", "address", "order", "valid", "after", "calling", "{", "@", "code", "decode", "}" ]
[ "public", "list", "<", "local", "entry", ">", "get", "locals", "(", ")", "{", "return", "locals", ";", "}" ]
[ "returns", "whether", "the", "method", "contains", "subroutines", ",", "in", "the", "code", "attribute", "that", "was", "visited", "most", "recently" ]
[ "public", "boolean", "contains", "subroutines", "(", ")", "{", "return", "contains", "subroutines", ";", "}" ]
[ "name", "of", "the", "property", "this", "must", "be", "a", "valid", "identifier" ]
[ "public", "string", "get", "name", "(", ")", "{", "return", "name", ";", "}" ]
[ "add", "the", "data", "type", "as", "the", "first", "in", "the", "list" ]
[ "public", "void", "add", "first", "(", "data", "type", "dt", ")", "{", "if", "(", "dt", "=", "=", "null", ")", "{", "return", ";", "}", "if", "(", "!", "exists", "(", "dt", ")", ")", "{", "data", "list", "add", "(", "0", ",", "dt", ")", ";", "}", "}" ]
[ "returns", "a", "{", "@", "link", "required", "shuffle", "}", "which", "does", "not", "require", "any", "specific", "shuffle", "type" ]
[ "public", "static", "required", "shuffle", "any", "(", ")", "{", "return", "new", "required", "shuffle", "(", "shuffle", "type", "any", ")", ";", "}" ]
[ "write", "i", "pv", "4", "packet", "for", "tcp", "packet" ]
[ "static", "void", "write", "t", "c", "pv", "4", "(", "byte", "buf", "byte", "buf", ",", "byte", "buf", "payload", ",", "int", "src", "address", ",", "int", "dst", "address", ")", "{", "write", "packetv", "4", "(", "byte", "buf", ",", "payload", ",", "tcp", ",", "src", "address", ",", "dst", "address", ")", ";", "}" ]
[ "true", "if", "the", "current", "set", "of", "files", "is", "in", "the", "active", "project", "(", "false", "implies", "a", "non", "-", "active", ",", "read", "-", "only", "project", ")" ]
[ "public", "boolean", "is", "in", "active", "project", "(", ")", ";" ]
[ "schedules", "{", "@", "code", "callable", "}", "on", "the", "specified", "{", "@", "code", "executor", "}", ",", "returning", "a", "{", "@", "code", "future", "}" ]
[ "public", "static", "<", "o", ">", "listenable", "future", "<", "o", ">", "schedule", "async", "(", "async", "callable", "<", "o", ">", "callable", ",", "long", "delay", ",", "time", "unit", "time", "unit", ",", "scheduled", "executor", "service", "executor", "service", ")", "{", "trusted", "listenable", "future", "task", "<", "o", ">", "task", "=", "trusted", "listenable", "future", "task", "create", "(", "callable", ")", ";", "final", "future", "<", "?", ">", "scheduled", "=", "executor", "service", "schedule", "(", "task", ",", "delay", ",", "time", "unit", ")", ";", "task", "add", "listener", "(", "new", "runnable", "(", ")", "{", "@", "override", "public", "void", "run", "(", ")", "{", "/", "/", "don", "'", "t", "want", "to", "interrupt", "twice", "scheduled", "cancel", "(", "false", ")", ";", "}", "}", ",", "direct", "executor", "(", ")", ")", ";", "return", "task", ";", "}" ]
[ "controls", "the", "shard", "routing", "of", "the", "request", "using", "this", "value", "to", "hash", "the", "shard", "and", "not", "the", "id" ]
[ "public", "index", "request", "routing", "(", "string", "routing", ")", "{", "if", "(", "routing", "!", "=", "null", "&", "&", "routing", "length", "(", ")", "=", "=", "0", ")", "{", "this", "routing", "=", "null", ";", "}", "else", "{", "this", "routing", "=", "routing", ";", "}", "return", "this", ";", "}" ]
[ "mark", "specified", "page", "region", "as", "uninitialized" ]
[ "public", "void", "set", "uninitialized", "(", "int", "page", "offset", ",", "int", "size", ")", "{", "if", "(", "initialized", "mask", "=", "=", "null", ")", "{", "initialized", "mask", "=", "get", "initialized", "mask", "(", "data", "length", ",", "true", ")", ";", "}", "set", "uninitialized", "(", "initialized", "mask", ",", "page", "offset", ",", "size", ")", ";", "}" ]
[ "adds", "an", "entry", "to", "the", "output", "jar", ",", "and", "write", "its", "content", "from", "the", "{", "@", "link", "input", "stream", "}" ]
[ "private", "void", "write", "entry", "(", "input", "stream", "input", ",", "jar", "entry", "entry", ")", "throws", "i", "o", "exception", "{", "/", "/", "add", "the", "entry", "to", "the", "jar", "archive", "m", "output", "jar", "put", "next", "entry", "(", "entry", ")", ";", "/", "/", "read", "the", "content", "of", "the", "entry", "from", "the", "input", "stream", ",", "and", "write", "it", "into", "the", "archive", "int", "count", ";", "while", "(", "(", "count", "=", "input", "read", "(", "m", "buffer", ")", ")", "!", "=", "-", "1", ")", "{", "m", "output", "jar", "write", "(", "m", "buffer", ",", "0", ",", "count", ")", ";", "/", "/", "update", "the", "digest", "if", "(", "m", "message", "digest", "!", "=", "null", ")", "{", "m", "message", "digest", "update", "(", "m", "buffer", ",", "0", ",", "count", ")", ";", "}", "}", "/", "/", "close", "the", "entry", "for", "this", "file", "m", "output", "jar", "close", "entry", "(", ")", ";", "if", "(", "m", "manifest", "!", "=", "null", ")", "{", "/", "/", "update", "the", "manifest", "for", "this", "entry", "attributes", "attr", "=", "m", "manifest", "get", "attributes", "(", "entry", "get", "name", "(", ")", ")", ";", "if", "(", "attr", "=", "=", "null", ")", "{", "attr", "=", "new", "attributes", "(", ")", ";", "m", "manifest", "get", "entries", "(", ")", "put", "(", "entry", "get", "name", "(", ")", ",", "attr", ")", ";", "}", "attr", "put", "value", "(", "digest", "attr", ",", "new", "string", "(", "base", "6", "4", "encode", "(", "m", "message", "digest", "digest", "(", ")", ")", ",", "\"", "ascii", "\"", ")", ")", ";", "}", "}" ]
[ "generate", "some", "post", "-", "processing", "metrics", "and", "write", "to", "log" ]
[ "void", "log", "report", "(", ")", "{", "string", "builder", "builder", "=", "new", "string", "builder", "(", ")", ";", "builder", "append", "(", "report", "nonappliable", "types", "(", ")", ")", ";", "builder", "append", "(", "report", "ununsual", "this", "pointer", "types", "(", ")", ")", ";", "builder", "append", "(", "report", "ununsual", "this", "pointer", "underlying", "types", "(", ")", ")", ";", "builder", "append", "(", "report", "ununsual", "member", "function", "container", "types", "(", ")", ")", ";", "builder", "append", "(", "report", "nonappliable", "symbols", "(", ")", ")", ";", "builder", "append", "(", "report", "unexpected", "public", "symbols", "(", ")", ")", ";", "builder", "append", "(", "report", "unexpected", "global", "symbols", "(", ")", ")", ";", "builder", "append", "(", "report", "enumerate", "narrowing", "(", ")", ")", ";", "if", "(", "builder", "length", "(", ")", "=", "=", "0", ")", "{", "return", ";", "/", "/", "nothing", "reported", "}", "builder", "insert", "(", "0", ",", "\"", "=", "=", "=", "begin", "pdb", "applicator", "metrics", "report", "=", "=", "=", "\\", "n", "\"", ")", ";", "builder", "append", "(", "\"", "=", "=", "=", "=", "end", "pdb", "applicator", "metrics", "report", "=", "=", "=", "=", "\\", "n", "\"", ")", ";", "string", "text", "=", "builder", "to", "string", "(", ")", ";", "msg", "info", "(", "this", ",", "text", ")", ";", "pdb", "log", "message", "(", "text", ")", ";", "}" ]
[ "each", "primitive", "type", "has", "a", "corresponding", "object", "type", "for", "example", "int", "and", "integer", ",", "boolean", "and", "boolean", "this", "method", "gives", "a", "way", "to", "turn", "primitive", "type", "into", "object", "type" ]
[ "private", "class", "<", "?", ">", "get", "object", "type", "(", "class", "<", "?", ">", "primitive", "type", ")", "{", "if", "(", "primitive", "type", "!", "=", "null", ")", "{", "if", "(", "primitive", "type", "is", "primitive", "(", ")", ")", "{", "string", "basic", "type", "name", "=", "primitive", "type", "get", "name", "(", ")", ";", "switch", "(", "basic", "type", "name", ")", "{", "case", "\"", "int", "\"", ":", "return", "integer", "class", ";", "case", "\"", "short", "\"", ":", "return", "short", "class", ";", "case", "\"", "long", "\"", ":", "return", "long", "class", ";", "case", "\"", "float", "\"", ":", "return", "float", "class", ";", "case", "\"", "double", "\"", ":", "return", "double", "class", ";", "case", "\"", "boolean", "\"", ":", "return", "boolean", "class", ";", "case", "\"", "char", "\"", ":", "return", "character", "class", ";", "}", "}", "}", "return", "null", ";", "}" ]
[ "get", "the", "id", "of", "the", "associated", "{", "@", "link", "resource", "request", "}" ]
[ "public", "long", "get", "allocation", "request", "id", "(", ")", "{", "return", "allocation", "request", "id", ";", "}" ]
[ "return", "a", "{", "@", "link", "list", "}", "of", "all", "direct", "{", "@", "link", "pool", "arena", "metric", "}", "s", "that", "are", "provided", "by", "this", "pool" ]
[ "public", "list", "<", "pool", "arena", "metric", ">", "direct", "arenas", "(", ")", "{", "return", "direct", "arena", "metrics", ";", "}" ]
[ "signals", "some", "other", "thread", "waiting", "on", "a", "satisfied", "guard", ",", "if", "one", "exists", "we", "manage", "calls", "to", "this", "method", "carefully", ",", "to", "signal", "only", "when", "necessary", ",", "but", "never", "losing", "a", "signal", ",", "which", "is", "the", "classic", "problem", "of", "this", "kind", "of", "concurrency", "construct", "we", "must", "signal", "if", "the", "current", "thread", "is", "about", "to", "relinquish", "the", "lock", "and", "may", "have", "changed", "the", "state", "protected", "by", "the", "monitor", ",", "thereby", "causing", "some", "guard", "to", "be", "satisfied", "in", "addition", ",", "any", "thread", "that", "has", "been", "signalled", "when", "its", "guard", "was", "satisfied", "acquires", "the", "responsibility", "of", "signalling", "the", "next", "thread", "when", "it", "again", "relinquishes", "the", "lock", "unlike", "a", "normal", "condition", ",", "there", "is", "no", "guarantee", "that", "an", "interrupted", "thread", "has", "not", "been", "signalled", ",", "since", "the", "concurrency", "control", "must", "manage", "multiple", "conditions", "so", "this", "method", "must", "generally", "be", "called", "when", "waits", "are", "interrupted", "on", "the", "other", "hand", ",", "if", "a", "signalled", "thread", "wakes", "up", "to", "discover", "that", "its", "guard", "is", "still", "not", "satisfied", ",", "it", "does", "not", "need", "to", "call", "this", "method", "before", "returning", "to", "wait", "this", "can", "only", "happen", "due", "to", "spurious", "wakeup", "(", "ignorable", ")", "or", "another", "thread", "acquiring", "the", "lock", "before", "the", "current", "thread", "can", "and", "returning", "the", "guard", "to", "the", "unsatisfied", "state", "in", "the", "latter", "case", "the", "other", "thread", "(", "last", "thread", "modifying", "the", "state", "protected", "by", "the", "monitor", ")", "takes", "over", "the", "responsibility", "of", "signalling", "the", "next", "waiter", "this", "method", "must", "not", "be", "called", "from", "within", "a", "begin", "waiting", "forend", "waiting", "for", "block", ",", "or", "else", "the", "current", "thread", "'", "s", "guard", "might", "be", "mistakenly", "signalled", ",", "leading", "to", "a", "lost", "signal" ]
[ "private", "void", "signal", "next", "waiter", "(", ")", "{", "for", "(", "guard", "guard", "=", "active", "guards", ";", "guard", "!", "=", "null", ";", "guard", "=", "guard", "next", ")", "{", "if", "(", "is", "satisfied", "(", "guard", ")", ")", "{", "guard", "condition", "signal", "(", ")", ";", "break", ";", "}", "}", "}" ]
[ "returns", "a", "formatter", "for", "a", "four", "digit", "weekyear", "and", "two", "digit", "week", "of", "weekyear", "(", "xxxx", "-", "'", "w", "'", "ww", ")" ]
[ "public", "static", "date", "time", "formatter", "weekyear", "week", "(", ")", "{", "return", "constants", "ww", ";", "}" ]
[ "returns", "the", "acl", "entries", "to", "use", "in", "the", "api", "call", "for", "the", "given", "path", "for", "a", "recursive", "operation", ",", "returns", "all", "specified", "acl", "entries", "if", "the", "item", "is", "a", "directory", "or", "just", "the", "access", "acl", "entries", "if", "the", "item", "is", "a", "file", "for", "a", "non", "-", "recursive", "operation", ",", "returns", "all", "specified", "acl", "entries" ]
[ "private", "list", "<", "acl", "entry", ">", "get", "acl", "entries", "(", "path", "data", "item", ")", "{", "if", "(", "is", "recursive", "(", ")", ")", "{", "return", "item", "stat", "is", "directory", "(", ")", "?", "acl", "entries", ":", "access", "acl", "entries", ";", "}", "else", "{", "return", "acl", "entries", ";", "}", "}" ]