Datasets:

Anonymous2023

/

KGSum

like 0

[ "test", "the", "property", "'", "quantity", "'" ]

[ "public", "void", "quantity", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "quantity", "}" ]

[ "used", "externally", "to", "submit", "simple", "task", "(", "one", "that", "does", "not", "have", "any", "subtasks", ")", "depending", "on", "the", "min", "duration", "attribute", "of", "the", "task", "type", ",", "task", "may", "be", "just", "aggregated", "into", "the", "parent", "task", "and", "not", "stored", "directly" ]

[ "public", "void", "log", "simple", "task", "duration", "(", "long", "start", "time", "nanos", ",", "duration", "duration", ",", "profiler", "task", "type", ",", "string", "description", ")", "{", "if", "(", "should", "profile", "(", "start", "time", "nanos", ",", "type", ")", ")", "{", "log", "task", "(", "start", "time", "nanos", ",", "duration", "to", "nanos", "(", ")", ",", "type", ",", "description", ")", ";", "}", "}" ]

[ "if", "there", "'", "s", "a", "bug", "in", "builder", "growth", ",", "we", "wouldn", "'", "t", "know", "how", "to", "expose", "it", "so", ",", "brute", "force", "the", "hell", "out", "of", "it", "for", "a", "while", "and", "see", "what", "happens" ]

[ "public", "void", "test", "builder", "brute", "force", "(", ")", "{", "for", "(", "int", "i", "=", "0", ";", "i", "<", "reduce", "iterations", "if", "gwt", "(", "100", ")", ";", "i", "+", "+", ")", "{", "immutable", "double", "array", "builder", "builder", "=", "immutable", "double", "array", "builder", "(", "random", "next", "int", "(", "20", ")", ")", ";", "atomic", "integer", "counter", "=", "new", "atomic", "integer", "(", "0", ")", ";", "while", "(", "counter", "get", "(", ")", "<", "1000", ")", "{", "builder", "op", "op", "=", "builder", "op", "random", "op", "(", ")", ";", "op", "do", "it", "(", "builder", ",", "counter", ")", ";", "}", "immutable", "double", "array", "iia", "=", "builder", "build", "(", ")", ";", "for", "(", "int", "j", "=", "0", ";", "j", "<", "iia", "length", "(", ")", ";", "j", "+", "+", ")", "{", "assert", "that", "(", "iia", "get", "(", "j", ")", ")", "is", "equal", "to", "(", "(", "double", ")", "j", ")", ";", "}", "}", "}" ]

[ "returns", "a", "map", "of", "volume", "set", "i", "ds", "and", "volume", "set", "plans" ]

[ "public", "list", "<", "step", ">", "get", "volume", "set", "plans", "(", ")", "{", "return", "volume", "set", "plans", ";", "}" ]

[ "figures", "out", "how", "many", "slices", "the", "request", "handling", "will", "use" ]

[ "protected", "int", "expected", "slices", "(", "int", "request", "slices", ",", "collection", "<", "string", ">", "indices", ")", "{", "if", "(", "request", "slices", "=", "=", "abstract", "bulk", "by", "scroll", "request", "auto", "slices", ")", "{", "int", "least", "num", "shards", "=", "collections", "min", "(", "indices", "stream", "(", ")", "map", "(", "source", "index", "-", ">", "get", "num", "shards", "(", "source", "index", ")", "num", "primaries", ")", "collect", "(", "collectors", "to", "list", "(", ")", ")", ")", ";", "return", "math", "min", "(", "least", "num", "shards", ",", "bulk", "by", "scroll", "parallelization", "helper", "auto", "slice", "ceiling", ")", ";", "}", "else", "{", "return", "request", "slices", ";", "}", "}" ]

[ "multiplies", "the", "vector", "with", "the", "given", "matrix", "the", "matrix", "array", "is", "assumed", "to", "hold", "a", "4x", "4", "column", "major", "matrix", "as", "you", "can", "get", "from", "{", "@", "link", "matrix", "4", "#", "val", "}", "the", "vector", "array", "is", "assumed", "to", "hold", "a", "3", "-", "component", "vector", ",", "with", "x", "being", "the", "first", "element", ",", "y", "being", "the", "second", "and", "z", "being", "the", "last", "component", "the", "result", "is", "stored", "in", "the", "vector", "array", "this", "is", "the", "same", "as", "{", "@", "link", "vector", "3", "#", "mul", "(", "matrix", "4", ")", "}" ]

[ "public", "static", "void", "mul", "vec", "(", "float", "[", "]", "mat", ",", "float", "[", "]", "vec", ")", "{", "matrix", "4", "mul", "vec", "(", "mat", ",", "vec", ",", "0", ")", ";", "}" ]

[ "notify", "listeners", "of", "a", "connection", "state", "change" ]

[ "private", "void", "fire", "state", "changed", "(", ")", "{", "for", "(", "remote", "adapter", "listener", "listener", ":", "listener", "list", ")", "{", "listener", "connection", "state", "changed", "(", "this", ")", ";", "}", "}" ]

[ "returns", "the", "first", "region", "found", "with", "the", "specified", "name", "this", "method", "uses", "string", "comparison", "to", "find", "the", "region", ",", "so", "the", "result", "should", "be", "cached", "rather", "than", "calling", "this", "method", "multiple", "times" ]

[ "public", "@", "null", "atlas", "region", "find", "region", "(", "string", "name", ")", "{", "for", "(", "int", "i", "=", "0", ",", "n", "=", "regions", "size", ";", "i", "<", "n", ";", "i", "+", "+", ")", "if", "(", "regions", "get", "(", "i", ")", "name", "equals", "(", "name", ")", ")", "return", "regions", "get", "(", "i", ")", ";", "return", "null", ";", "}" ]

[ "populates", "{", "@", "code", "fields", "}", "with", "the", "set", "of", "fields", "used", "by", "the", "query", ",", "or", "throws", "unsupported", "operation", "exception", "if", "it", "doesn", "'", "t", "know", "how", "to", "do", "this" ]

[ "static", "void", "extract", "fields", "(", "query", "query", ",", "set", "<", "string", ">", "fields", ")", "throws", "unsupported", "operation", "exception", "{", "/", "/", "note", ":", "we", "expect", "a", "rewritten", "query", ",", "so", "we", "only", "need", "logic", "for", "\"", "atomic", "\"", "queries", "here", ":", "if", "(", "query", "instanceof", "boolean", "query", ")", "{", "/", "/", "extract", "from", "all", "clauses", "boolean", "query", "q", "=", "(", "boolean", "query", ")", "query", ";", "for", "(", "boolean", "clause", "clause", ":", "q", "clauses", "(", ")", ")", "{", "extract", "fields", "(", "clause", "get", "query", "(", ")", ",", "fields", ")", ";", "}", "}", "else", "if", "(", "query", "instanceof", "disjunction", "max", "query", ")", "{", "/", "/", "extract", "from", "all", "clauses", "disjunction", "max", "query", "q", "=", "(", "disjunction", "max", "query", ")", "query", ";", "for", "(", "query", "clause", ":", "q", "get", "disjuncts", "(", ")", ")", "{", "extract", "fields", "(", "clause", ",", "fields", ")", ";", "}", "}", "else", "if", "(", "query", "instanceof", "span", "term", "query", ")", "{", "/", "/", "we", "just", "do", "span", "term", ",", "other", "spans", "are", "trickier", ",", "they", "could", "contain", "/", "/", "the", "evil", "field", "masking", "span", "query", ":", "so", "span", "query", "get", "field", "cannot", "be", "trusted", "fields", "add", "(", "(", "(", "span", "term", "query", ")", "query", ")", "get", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "term", "query", ")", "{", "fields", "add", "(", "(", "(", "term", "query", ")", "query", ")", "get", "term", "(", ")", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "synonym", "query", ")", "{", "synonym", "query", "q", "=", "(", "synonym", "query", ")", "query", ";", "/", "/", "all", "terms", "must", "have", "the", "same", "field", "fields", "add", "(", "q", "get", "terms", "(", ")", "get", "(", "0", ")", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "phrase", "query", ")", "{", "phrase", "query", "q", "=", "(", "phrase", "query", ")", "query", ";", "/", "/", "all", "terms", "must", "have", "the", "same", "field", "fields", "add", "(", "q", "get", "terms", "(", ")", "[", "0", "]", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "multi", "phrase", "query", ")", "{", "multi", "phrase", "query", "q", "=", "(", "multi", "phrase", "query", ")", "query", ";", "/", "/", "all", "terms", "must", "have", "the", "same", "field", "fields", "add", "(", "q", "get", "term", "arrays", "(", ")", "[", "0", "]", "[", "0", "]", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "point", "range", "query", ")", "{", "fields", "add", "(", "(", "(", "point", "range", "query", ")", "query", ")", "get", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "point", "in", "set", "query", ")", "{", "fields", "add", "(", "(", "(", "point", "in", "set", "query", ")", "query", ")", "get", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "doc", "values", "field", "exists", "query", ")", "{", "fields", "add", "(", "(", "(", "doc", "values", "field", "exists", "query", ")", "query", ")", "get", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "doc", "values", "numbers", "query", ")", "{", "fields", "add", "(", "(", "(", "doc", "values", "numbers", "query", ")", "query", ")", "get", "field", "(", ")", ")", ";", "}", "else", "if", "(", "query", "instanceof", "index", "or", "doc", "values", "query", ")", "{", "/", "/", "both", "queries", "are", "supposed", "to", "be", "equivalent", ",", "so", "if", "any", "of", "them", "can", "be", "extracted", ",", "we", "are", "good", "try", "{", "set", "<", "string", ">", "dv", "query", "fields", "=", "new", "hash", "set", "<", ">", "(", "1", ")", ";", "extract", "fields", "(", "(", "(", "index", "or", "doc", "values", "query", ")", "query", ")", "get", "random", "access", "query", "(", ")", ",", "dv", "query", "fields", ")", ";", "fields", "add", "all", "(", "dv", "query", "fields", ")", ";", "}", "catch", "(", "unsupported", "operation", "exception", "e", ")", "{", "extract", "fields", "(", "(", "(", "index", "or", "doc", "values", "query", ")", "query", ")", "get", "index", "query", "(", ")", ",", "fields", ")", ";", "}", "}", "else", "if", "(", "query", "instanceof", "term", "in", "set", "query", ")", "{", "/", "/", "term", "in", "set", "query", "#", "field", "is", "inaccessible", "term", "in", "set", "query", "term", "in", "set", "query", "=", "(", "term", "in", "set", "query", ")", "query", ";", "term", "iterator", "term", "iterator", "=", "term", "in", "set", "query", "get", "term", "data", "(", ")", "iterator", "(", ")", ";", "/", "/", "there", "should", "only", "be", "one", "field", "if", "(", "term", "iterator", "next", "(", ")", "!", "=", "null", ")", "{", "fields", "add", "(", "term", "iterator", "field", "(", ")", ")", ";", "}", "}", "else", "if", "(", "query", "instanceof", "match", "all", "docs", "query", ")", "{", "/", "/", "no", "field", "}", "else", "if", "(", "query", "instanceof", "match", "no", "docs", "query", ")", "{", "/", "/", "no", "field", "}", "else", "{", "throw", "new", "unsupported", "operation", "exception", "(", ")", ";", "/", "/", "we", "don", "'", "t", "know", "how", "to", "get", "the", "fields", "from", "it", "}", "}" ]

[ "add", "a", "default", "cookie" ]

[ "public", "api", "client", "add", "default", "cookie", "(", "string", "key", ",", "string", "value", ")", "{", "default", "cookie", "map", "put", "(", "key", ",", "value", ")", ";", "return", "this", ";", "}" ]

[ "returns", "a", "contiguous", "set", "containing", "all", "{", "@", "code", "int", "}", "values", "from", "{", "@", "code", "lower", "}", "(", "inclusive", ")", "to", "{", "@", "code", "upper", "}", "(", "exclusive", ")", "if", "the", "endpoints", "are", "equal", ",", "an", "empty", "set", "is", "returned", "(", "these", "are", "the", "same", "values", "contained", "in", "{", "@", "code", "range", "closed", "open", "(", "lower", ",", "upper", ")", "}", ")" ]

[ "public", "static", "contiguous", "set", "<", "integer", ">", "closed", "open", "(", "int", "lower", ",", "int", "upper", ")", "{", "return", "create", "(", "range", "closed", "open", "(", "lower", ",", "upper", ")", ",", "discrete", "domain", "integers", "(", ")", ")", ";", "}" ]

[ "factory", "for", "\"", "32", "\"", "version", "of", "{", "@", "link", "data", "high", "level", "shader", "language", "symbol", "internals", "}" ]

[ "public", "static", "data", "high", "level", "shader", "language", "symbol", "internals", "parse", "3", "2", "(", "abstract", "pdb", "pdb", ",", "pdb", "byte", "reader", "reader", ")", "throws", "pdb", "exception", "{", "data", "high", "level", "shader", "language", "symbol", "internals", "3", "2", "result", "=", "new", "data", "high", "level", "shader", "language", "symbol", "internals", "3", "2", "(", "pdb", ")", ";", "result", "type", "record", "number", "=", "record", "number", "parse", "(", "pdb", ",", "reader", ",", "record", "category", "type", ",", "32", ")", ";", "result", "data", "slot", "=", "reader", "parse", "unsigned", "int", "val", "(", ")", ";", "result", "data", "offset", "=", "reader", "parse", "unsigned", "int", "val", "(", ")", ";", "result", "texture", "slot", "start", "=", "reader", "parse", "unsigned", "int", "val", "(", ")", ";", "result", "sampler", "slot", "start", "=", "reader", "parse", "unsigned", "int", "val", "(", ")", ";", "result", "uav", "slot", "start", "=", "reader", "parse", "unsigned", "int", "val", "(", ")", ";", "result", "register", "type", "=", "h", "l", "s", "l", "register", "type", "from", "value", "(", "reader", "parse", "unsigned", "short", "val", "(", ")", ")", ";", "result", "name", "=", "reader", "parse", "string", "(", "pdb", ",", "string", "parse", "type", "string", "utf", "8", "nt", ")", ";", "return", "result", ";", "}" ]

[ "json", "string", "deserialize", "to", "object" ]

[ "public", "static", "<", "t", ">", "t", "to", "obj", "(", "input", "stream", "input", "stream", ",", "class", "<", "t", ">", "cls", ")", "{", "try", "{", "return", "mapper", "read", "value", "(", "input", "stream", ",", "cls", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "throw", "new", "nacos", "deserialization", "exception", "(", "e", ")", ";", "}", "}" ]

[ "takes", "input", "as", "a", "comma", "separated", "list", "of", "files", "and", "verifies", "if", "they", "exist", "it", "defaults", "for", "file", ":", "if", "the", "files", "specified", "do", "not", "have", "a", "scheme", "it", "returns", "the", "paths", "uri", "converted", "defaulting", "to", "file", ":", "so", "an", "input", "of", "homeuserfile", "1", ",", "homeuserfile", "2", "would", "return", "file", ":", "homeuserfile", "1", ",", "file", ":", "homeuserfile", "2", "this", "method", "does", "not", "recognize", "wildcards" ]

[ "private", "string", "validate", "files", "(", "string", "files", ")", "throws", "i", "o", "exception", "{", "return", "validate", "files", "(", "files", ",", "false", ")", ";", "}" ]

[ "tests", "that", "the", "zoo", "keeper", "state", "handle", "store", "can", "handle", "corrupted", "data", "by", "releasing", "and", "trying", "to", "remove", "the", "respective", "zoo", "keeper", "z", "nodes" ]

[ "public", "void", "test", "corrupted", "data", "(", ")", "throws", "exception", "{", "final", "testing", "long", "state", "handle", "helper", "state", "storage", "=", "new", "testing", "long", "state", "handle", "helper", "(", ")", ";", "zoo", "keeper", "state", "handle", "store", "<", "long", ">", "store", "=", "new", "zoo", "keeper", "state", "handle", "store", "<", ">", "(", "zookeeper", "get", "client", "(", ")", ",", "state", "storage", ")", ";", "final", "collection", "<", "long", ">", "input", "=", "new", "hash", "set", "<", ">", "(", ")", ";", "input", "add", "(", "1l", ")", ";", "input", "add", "(", "2l", ")", ";", "input", "add", "(", "3l", ")", ";", "for", "(", "long", "a", "long", ":", "input", ")", "{", "store", "add", "and", "lock", "(", "\"", "/", "\"", "+", "a", "long", ",", "a", "long", ")", ";", "}", "/", "/", "corrupt", "one", "of", "the", "entries", "zookeeper", "get", "client", "(", ")", "set", "data", "(", ")", "for", "path", "(", "\"", "/", "\"", "+", "2", ",", "new", "byte", "[", "2", "]", ")", ";", "list", "<", "tuple", "2", "<", "retrievable", "state", "handle", "<", "long", ">", ",", "string", ">", ">", "all", "entries", "=", "store", "get", "all", "and", "lock", "(", ")", ";", "collection", "<", "long", ">", "expected", "=", "new", "hash", "set", "<", ">", "(", "input", ")", ";", "expected", "remove", "(", "2l", ")", ";", "collection", "<", "long", ">", "actual", "=", "new", "hash", "set", "<", ">", "(", "expected", "size", "(", ")", ")", ";", "for", "(", "tuple", "2", "<", "retrievable", "state", "handle", "<", "long", ">", ",", "string", ">", "entry", ":", "all", "entries", ")", "{", "actual", "add", "(", "entry", "f", "0", "retrieve", "state", "(", ")", ")", ";", "}", "assert", "equals", "(", "expected", ",", "actual", ")", ";", "}" ]

[ "creates", "a", "new", "dewey", "number", "from", "this", "such", "that", "its", "last", "digit", "is", "increased", "by", "the", "supplied", "number" ]

[ "public", "dewey", "number", "increase", "(", "int", "times", ")", "{", "int", "[", "]", "new", "dewey", "number", "=", "arrays", "copy", "of", "(", "dewey", "number", ",", "dewey", "number", "length", ")", ";", "new", "dewey", "number", "[", "dewey", "number", "length", "-", "1", "]", "+", "=", "times", ";", "return", "new", "dewey", "number", "(", "new", "dewey", "number", ")", ";", "}" ]

[ "put", "j", "s", "o", "n", "array", "in", "cache" ]

[ "public", "void", "put", "(", "@", "non", "null", "final", "string", "key", ",", "final", "j", "s", "o", "n", "array", "value", ",", "final", "int", "save", "time", ")", "{", "real", "put", "bytes", "(", "type", "json", "array", "+", "key", ",", "utils", "bridge", "json", "array", "2", "bytes", "(", "value", ")", ",", "save", "time", ")", ";", "}" ]

[ "creates", "a", "{", "@", "code", "data", "descriptor", "}", "view", "over", "a", "writable", "buffer", "the", "given", "buffers", "position", "is", "advanced", "by", "the", "number", "of", "bytes", "consumed", "by", "the", "view" ]

[ "public", "static", "data", "descriptor", "view", "(", "byte", "buffer", "buffer", ")", "{", "data", "descriptor", "view", "=", "new", "data", "descriptor", "(", "buffer", "slice", "(", ")", ")", "init", "(", ")", ";", "buffer", "position", "(", "buffer", "position", "(", ")", "+", "size", ")", ";", "return", "view", ";", "}" ]

[ "plus", "equal", "operation", "(", "+", "=", ")" ]

[ "long", "long", "plus", "equal", "(", "long", "long", "that", ")", "{", "this", "d", "0", "+", "=", "that", "d", "0", ";", "this", "d", "1", "+", "=", "that", "d", "1", ";", "return", "this", ";", "}" ]

[ "a", "list", "of", "namespaces", "to", "which", "this", "service", "is", "exported", "exporting", "a", "service", "allows", "it", "to", "be", "used", "by", "sidecars", ",", "gateways", "and", "virtual", "services", "defined", "in", "other", "namespaces", "this", "feature", "provides", "a", "mechanism", "for", "service", "owners", "and", "mesh", "administrators", "to", "control", "the", "visibility", "of", "services", "across", "namespace", "boundaries", "if", "no", "namespaces", "are", "specified", "then", "the", "service", "is", "exported", "to", "all", "namespaces", "by", "default", "the", "value", "\"", "\"", "is", "reserved", "and", "defines", "an", "export", "to", "the", "same", "namespace", "that", "the", "service", "is", "declared", "in", "similarly", "the", "value", "\"", "\"", "is", "reserved", "and", "defines", "an", "export", "to", "all", "namespaces", "for", "a", "kubernetes", "service", ",", "the", "equivalent", "effect", "can", "be", "achieved", "by", "setting", "the", "annotation", "\"", "networking", "istio", "ioexport", "to", "\"", "to", "a", "comma", "-", "separated", "list", "of", "namespace", "names", "note", ":", "in", "the", "current", "release", ",", "the", "`", "export", "to", "`", "value", "is", "restricted", "to", "\"", "\"", "or", "\"", "\"", "(", "i", "e", ",", "the", "current", "namespace", "or", "all", "namespaces", ")", "<", "code", ">", "repeated", "string", "export", "to", "=", "7", ";", "<", "code", ">" ]

[ "public", "com", "google", "protobuf", "protocol", "string", "list", "get", "export", "to", "list", "(", ")", "{", "return", "export", "to", "get", "unmodifiable", "view", "(", ")", ";", "}" ]

[ "post", "usercreate", "with", "array", ":", "creates", "list", "of", "users", "with", "given", "input", "array" ]

[ "com", "netflix", "hystrix", "hystrix", "command", "<", "response", "entity", "<", "void", ">", ">", "create", "users", "with", "array", "input", "(", "@", "api", "param", "(", "value", "=", "\"", "list", "of", "user", "object", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "body", "list", "<", "user", ">", "body", ")", ";" ]

[ "builds", "a", "program", "with", "1", "function" ]

[ "private", "program", "builder", "build", "test", "program", "2", "(", ")", "throws", "exception", "{", "program", "builder", "builder", "=", "new", "program", "builder", "(", "\"", "test", "pgm", "1", "\"", ",", "program", "builder", "toy", "be", ")", ";", "builder", "create", "memory", "(", "\"", "text", "\"", ",", "\"", "0x", "1", "0", "0", "1", "0", "0", "0", "\"", ",", "0x", "6", "6", "0", "0", ")", ";", "builder", "set", "property", "(", "program", "date", "created", ",", "new", "date", "(", "100000000", ")", ")", ";", "/", "/", "arbitrary", ",", "but", "consistent", "/", "/", "functions", "data", "type", "dt", "=", "new", "byte", "data", "type", "(", ")", ";", "parameter", "p", "=", "new", "parameter", "impl", "(", "null", ",", "dt", ",", "builder", "get", "program", "(", ")", ")", ";", "bar", "=", "builder", "create", "empty", "function", "(", "\"", "bar", "\"", ",", "\"", "1", "0", "0", "1", "8cf", "\"", ",", "10", ",", "null", ",", "p", ")", ";", "program", "2", "=", "builder", "get", "program", "(", ")", ";", "return", "builder", ";", "}" ]

[ "set", "a", "new", "set", "of", "configurations", "to", "the", "{", "@", "link", "target", "}", "only", "those", "allowed", "to", "be", "modified", "will", "be", "included", "in", "{", "@", "link", "target", "dynamic", "config", "}" ]

[ "public", "void", "set", "target", "config", "(", "target", "dynamic", "config", "dynamic", "config", ")", "{", "if", "(", "m", "use", "background", "change", "sets", ")", "{", "synchronized", "(", "this", ")", "{", "/", "/", "apply", "change", "sets", "to", "target", "unchecked", "(", ")", "in", "background", "will", "be", "computed", "in", "a", "synchronized", "/", "/", "block", ",", "and", "the", "config", "is", "only", "updated", "after", "the", "ongoing", "computation", "is", "completed", "m", "target", "change", "config", "(", "dynamic", "config", ")", ";", "}", "}", "}" ]

[ "gets", "a", "future", "that", "completes", "once", "the", "task", "execution", "reaches", "a", "terminal", "state", "the", "future", "will", "be", "completed", "with", "specific", "state", "that", "the", "execution", "reached", "this", "future", "is", "always", "completed", "from", "the", "job", "master", "'", "s", "main", "thread" ]

[ "public", "completable", "future", "<", "execution", "state", ">", "get", "terminal", "state", "future", "(", ")", "{", "return", "terminal", "state", "future", ";", "}" ]

[ "returns", "a", "hash", "function", "implementing", "the", "message", "authentication", "code", "(", "mac", ")", "algorithm", ",", "using", "the", "sha", "-", "256", "(", "256", "hash", "bits", ")", "hash", "function", "and", "the", "given", "secret", "key" ]

[ "public", "static", "hash", "function", "hmac", "sha", "2", "5", "6", "(", "key", "key", ")", "{", "return", "new", "mac", "hash", "function", "(", "\"", "hmac", "s", "h", "a", "2", "5", "6", "\"", ",", "key", ",", "hmac", "to", "string", "(", "\"", "hmac", "sha", "2", "5", "6", "\"", ",", "key", ")", ")", ";", "}" ]

[ "return", "the", "wrapped", "values" ]

[ "public", "numeric", "doc", "values", "get", "long", "values", "(", ")", "{", "return", "values", ";", "}" ]

[ "saves", "data", "in", "all", "nested", "editors" ]

[ "public", "void", "do", "save", "(", "i", "progress", "monitor", "monitor", ")", "{", "if", "(", "!", "is", "dirty", "(", ")", ")", "{", "return", ";", "}", "if", "(", "editor", "utils", "is", "in", "auto", "save", "job", "(", ")", ")", "{", "/", "/", "do", "not", "save", "entity", "editors", "in", "auto", "-", "save", "job", "(", "#", "2408", ")", "return", ";", "}", "if", "(", "d", "b", "utils", "is", "read", "only", "(", "get", "database", "object", "(", ")", ")", ")", "{", "d", "b", "workbench", "get", "platform", "u", "i", "(", ")", "show", "message", "box", "(", "\"", "read", "-", "only", "\"", ",", "\"", "object", "[", "\"", "+", "d", "b", "utils", "get", "object", "full", "name", "(", "get", "database", "object", "(", ")", ",", "d", "b", "p", "evaluation", "context", "ui", ")", "+", "\"", "]", "is", "read", "-", "only", "\"", ",", "true", ")", ";", "return", ";", "}", "/", "/", "flush", "all", "nested", "object", "editors", "and", "result", "containers", "for", "(", "i", "editor", "part", "editor", ":", "editor", "map", "values", "(", ")", ")", "{", "if", "(", "editor", "instanceof", "i", "entity", "structure", "editor", "|", "|", "editor", "instanceof", "i", "entity", "data", "editor", ")", "{", "if", "(", "editor", "is", "dirty", "(", ")", ")", "{", "editor", "do", "save", "(", "monitor", ")", ";", "}", "}", "if", "(", "monitor", "is", "canceled", "(", ")", ")", "{", "return", ";", "}", "}", "/", "/", "check", "read", "-", "only", "/", "/", "show", "preview", "int", "preview", "result", "=", "i", "dialog", "constants", "proceed", "id", ";", "if", "(", "d", "b", "workbench", "get", "platform", "(", ")", "get", "preference", "store", "(", ")", "get", "boolean", "(", "navigator", "preferences", "navigator", "show", "sql", "preview", ")", ")", "{", "monitor", "begin", "task", "(", "u", "i", "navigator", "messages", "editors", "entity", "monitor", "preview", "changes", ",", "1", ")", ";", "preview", "result", "=", "show", "changes", "(", "true", ")", ";", "}", "if", "(", "preview", "result", "=", "=", "i", "dialog", "constants", "ignore", "id", ")", "{", "/", "/", "there", "are", "no", "changes", "to", "save", "/", "/", "let", "'", "s", "just", "refresh", "dirty", "status", "fire", "property", "change", "(", "i", "editor", "part", "prop", "dirty", ")", ";", "return", ";", "}", "if", "(", "preview", "result", "!", "=", "i", "dialog", "constants", "proceed", "id", ")", "{", "monitor", "set", "canceled", "(", "true", ")", ";", "return", ";", "}", "try", "{", "save", "in", "progress", "=", "true", ";", "monitor", "begin", "task", "(", "\"", "save", "changes", "\"", ",", "1", ")", ";", "try", "{", "monitor", "sub", "task", "(", "\"", "save", "'", "\"", "+", "get", "part", "name", "(", ")", "+", "\"", "'", "changes", "\"", ")", ";", "save", "job", "save", "job", "=", "new", "save", "job", "(", ")", ";", "save", "job", "schedule", "(", ")", ";", "/", "/", "wait", "until", "job", "finished", "u", "i", "utils", "wait", "job", "completion", "(", "save", "job", ")", ";", "if", "(", "!", "save", "job", "success", ")", "{", "monitor", "set", "canceled", "(", "true", ")", ";", "return", ";", "}", "}", "finally", "{", "monitor", "done", "(", ")", ";", "}", "fire", "property", "change", "(", "i", "editor", "part", "prop", "dirty", ")", ";", "}", "finally", "{", "save", "in", "progress", "=", "false", ";", "}", "/", "/", "run", "post", "-", "save", "commands", "(", "e", "g", "compile", ")", "map", "<", "string", ",", "object", ">", "context", "=", "new", "linked", "hash", "map", "<", ">", "(", ")", ";", "for", "(", "i", "editor", "part", "editor", ":", "editor", "map", "values", "(", ")", ")", "{", "if", "(", "editor", "instanceof", "i", "database", "post", "save", "processor", ")", "{", "(", "(", "i", "database", "post", "save", "processor", ")", "editor", ")", "run", "post", "save", "commands", "(", "context", ")", ";", "}", "if", "(", "monitor", "is", "canceled", "(", ")", ")", "{", "return", ";", "}", "}", "}" ]

[ "check", "and", "ensure", "the", "buffers", "are", "of", "the", "desired", "length", "and", "type", ",", "direct", "buffers", "or", "not" ]

[ "void", "check", "output", "buffers", "(", "byte", "buffer", "[", "]", "buffers", ")", "{", "for", "(", "byte", "buffer", "buffer", ":", "buffers", ")", "{", "if", "(", "buffer", "=", "=", "null", ")", "{", "throw", "new", "hadoop", "illegal", "argument", "exception", "(", "\"", "invalid", "buffer", "found", ",", "not", "allowing", "null", "\"", ")", ";", "}", "if", "(", "buffer", "remaining", "(", ")", "!", "=", "decode", "length", ")", "{", "throw", "new", "hadoop", "illegal", "argument", "exception", "(", "\"", "invalid", "buffer", ",", "not", "of", "length", "\"", "+", "decode", "length", ")", ";", "}", "if", "(", "buffer", "is", "direct", "(", ")", "!", "=", "using", "direct", "buffer", ")", "{", "throw", "new", "hadoop", "illegal", "argument", "exception", "(", "\"", "invalid", "buffer", ",", "is", "direct", "should", "be", "\"", "+", "using", "direct", "buffer", ")", ";", "}", "}", "}" ]

[ "determine", "if", "a", "class", "was", "generated", "using", "<", "code", ">", "enhancer", "<", "code", ">" ]

[ "public", "static", "boolean", "is", "enhanced", "(", "class", "type", ")", "{", "try", "{", "get", "callbacks", "setter", "(", "type", ",", "set", "thread", "callbacks", "name", ")", ";", "return", "true", ";", "}", "catch", "(", "no", "such", "method", "exception", "e", ")", "{", "return", "false", ";", "}", "}" ]

[ "test", "of", "contains", "all", "method", ",", "of", "class", "tree", "set" ]

[ "public", "void", "test", "contains", "all", "(", ")", "{", "collection", "<", "string", ">", "list", "=", "arrays", "as", "list", "(", "new", "string", "[", "]", "{", "\"", "apa", "\"", ",", "\"", "apa", "2", "\"", ",", "\"", "apa", "\"", "}", ")", ";", "folded", "tree", "set", "<", "string", ">", "instance", "=", "new", "folded", "tree", "set", "<", ">", "(", ")", ";", "assert", "equals", "(", "false", ",", "instance", "contains", "all", "(", "list", ")", ")", ";", "instance", "add", "all", "(", "list", ")", ";", "assert", "equals", "(", "true", ",", "instance", "contains", "all", "(", "list", ")", ")", ";", "}" ]

[ "return", "the", "database", "-", "specific", "query", "to", "use", "for", "retrieving", "a", "sequence", "value", "the", "provided", "sql", "is", "supposed", "to", "result", "in", "a", "single", "row", "with", "a", "single", "column", "that", "allows", "for", "extracting", "a", "{", "@", "code", "long", "}", "value" ]

[ "protected", "abstract", "string", "get", "sequence", "query", "(", ")", ";" ]

[ "return", "the", "country", "by", "sim", "card" ]

[ "public", "static", "string", "get", "country", "by", "sim", "(", ")", "{", "telephony", "manager", "manager", "=", "(", "telephony", "manager", ")", "utils", "get", "app", "(", ")", "get", "system", "service", "(", "context", "telephony", "service", ")", ";", "if", "(", "manager", "!", "=", "null", ")", "{", "return", "manager", "get", "sim", "country", "iso", "(", ")", "to", "upper", "case", "(", ")", ";", "}", "return", "\"", "\"", ";", "}" ]

[ "returns", "the", "value", "by", "getting", "the", "serialized", "value", "and", "deserializing", "it", "if", "it", "is", "not", "null" ]

[ "protected", "static", "<", "v", ",", "k", ",", "n", ">", "v", "get", "serialized", "value", "(", "internal", "kv", "state", "<", "k", ",", "n", ",", "v", ">", "kv", "state", ",", "k", "key", ",", "type", "serializer", "<", "k", ">", "key", "serializer", ",", "n", "namespace", ",", "type", "serializer", "<", "n", ">", "namespace", "serializer", ",", "type", "serializer", "<", "v", ">", "value", "serializer", ")", "throws", "exception", "{", "byte", "[", "]", "serialized", "key", "and", "namespace", "=", "kv", "state", "serializer", "serialize", "key", "and", "namespace", "(", "key", ",", "key", "serializer", ",", "namespace", ",", "namespace", "serializer", ")", ";", "byte", "[", "]", "serialized", "value", "=", "kv", "state", "get", "serialized", "value", "(", "serialized", "key", "and", "namespace", ",", "kv", "state", "get", "key", "serializer", "(", ")", ",", "kv", "state", "get", "namespace", "serializer", "(", ")", ",", "kv", "state", "get", "value", "serializer", "(", ")", ")", ";", "if", "(", "serialized", "value", "=", "=", "null", ")", "{", "return", "null", ";", "}", "else", "{", "return", "kv", "state", "serializer", "deserialize", "value", "(", "serialized", "value", ",", "value", "serializer", ")", ";", "}", "}" ]

[ "peeks", "into", "the", "cache", "'", "s", "internals", "to", "verify", "that", "its", "eviction", "queue", "is", "consistent", "verifies", "that", "the", "prevnext", "links", "are", "correct", ",", "and", "that", "all", "items", "in", "each", "segment", "are", "also", "in", "that", "segment", "'", "s", "eviction", "(", "recency", ")", "queue" ]

[ "static", "void", "check", "eviction", "(", "cache", "<", "?", ",", "?", ">", "cache", ")", "{", "if", "(", "has", "local", "cache", "(", "cache", ")", ")", "{", "check", "eviction", "(", "to", "local", "cache", "(", "cache", ")", ")", ";", "}", "}" ]

[ "configure", "a", "{", "@", "code", "task", "scheduler", "}", "for", "scheduling", "a", "connect", "timeout", "task", "where", "the", "timeout", "value", "is", "calculated", "based", "on", "the", "duration", "of", "the", "initial", "sock", "j", "s", "\"", "info", "\"", "request", "the", "connect", "timeout", "task", "ensures", "a", "more", "timely", "fallback", "but", "is", "otherwise", "entirely", "optional", "by", "default", "this", "is", "not", "configured", "in", "which", "case", "a", "fallback", "may", "take", "longer" ]

[ "public", "void", "set", "connect", "timeout", "scheduler", "(", "task", "scheduler", "connect", "timeout", "scheduler", ")", "{", "this", "connect", "timeout", "scheduler", "=", "connect", "timeout", "scheduler", ";", "}" ]

[ "returns", "if", "an", "attribute", "with", "the", "given", "name", "is", "late", "-", "bound", "according", "to", "the", "naming", "policy", "that", "designates", "late", "-", "bound", "attributes" ]

[ "public", "static", "boolean", "is", "late", "bound", "(", "string", "name", ")", "{", "return", "name", "starts", "with", "(", "\"", ":", "\"", ")", ";", "}" ]

[ "create", "test", "table", "with", "one", "row", "of", "data" ]

[ "public", "static", "void", "init", "test", "data", "(", "database", "configuration", "db", "config", ",", "string", "table", "name", ")", "throws", "database", "service", "exception", ",", "s", "q", "l", "exception", "{", "statement", "stmt", "=", "null", ";", "connection", "conn", "=", "null", ";", "try", "{", "database", "service", "db", "service", "=", "database", "service", "get", "(", "db", "config", "get", "database", "type", "(", ")", ")", ";", "conn", "=", "db", "service", "get", "connection", "(", "db", "config", ")", ";", "stmt", "=", "conn", "create", "statement", "(", ")", ";", "database", "meta", "data", "dbm", "=", "conn", "get", "meta", "data", "(", ")", ";", "/", "/", "check", "if", "\"", "employee", "\"", "table", "is", "there", "result", "set", "tables", "=", "dbm", "get", "tables", "(", "null", ",", "null", ",", "table", "name", ",", "null", ")", ";", "boolean", "drop", "table", "=", "false", ";", "if", "(", "tables", "next", "(", ")", ")", "{", "drop", "table", "=", "true", ";", "/", "/", "system", "out", "println", "(", "\"", "drop", "table", "result", ":", ":", "\"", "+", "drop", "result", ")", ";", "}", "tables", "close", "(", ")", ";", "if", "(", "drop", "table", ")", "{", "stmt", "execute", "update", "(", "\"", "drop", "table", "\"", "+", "table", "name", ")", ";", "}", "string", "create", "s", "q", "l", "=", "\"", "create", "table", "\"", "+", "table", "name", "+", "\"", "(", "\"", "+", "\"", "id", "int", "not", "null", ",", "\"", "+", "\"", "name", "varchar", "(", "20", ")", "not", "null", ",", "\"", "+", "\"", "city", "varchar", "(", "20", ")", "not", "null", ",", "\"", "+", "\"", "primary", "key", "(", "id", ")", ")", ";", "\"", ";", "stmt", "execute", "update", "(", "create", "s", "q", "l", ")", ";", "/", "/", "system", "out", "println", "(", "\"", "create", "table", "result", ":", ":", "\"", "+", "create", "result", ")", ";", "string", "insert", "table", "s", "q", "l", "=", "\"", "insert", "into", "\"", "+", "table", "name", "+", "\"", "(", "id", ",", "name", ",", "city", ")", "\"", "+", "\"", "values", "\"", "+", "\"", "(", "1", ",", "'", "frank", "lens", "'", ",", "'", "dallas", "'", ")", "\"", ";", "stmt", "execute", "update", "(", "insert", "table", "s", "q", "l", ")", ";", "/", "/", "system", "out", "println", "(", "\"", "insert", "data", "result", ":", ":", "\"", "+", "insert", "result", ")", ";", "logger", "info", "(", "\"", "database", "test", "init", "data", "created", "!", "!", "!", "\"", ")", ";", "}", "finally", "{", "if", "(", "stmt", "!", "=", "null", ")", "{", "try", "{", "stmt", "close", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "}", "}", "if", "(", "conn", "!", "=", "null", ")", "{", "try", "{", "conn", "close", "(", ")", ";", "}", "catch", "(", "s", "q", "l", "exception", "e", ")", "{", "e", "print", "stack", "trace", "(", ")", ";", "}", "}", "}", "}" ]

[ "creates", "a", "new", "runtime", "type", "adapter", "using", "for", "{", "@", "code", "base", "type", "}", "using", "{", "@", "code", "type", "field", "name", "}", "as", "the", "type", "field", "name", "type", "field", "names", "are", "case", "sensitive" ]

[ "public", "static", "<", "t", ">", "runtime", "type", "adapter", "factory", "<", "t", ">", "of", "(", "class", "<", "t", ">", "base", "type", ",", "string", "type", "field", "name", ")", "{", "return", "new", "runtime", "type", "adapter", "factory", "<", "t", ">", "(", "base", "type", ",", "type", "field", "name", ")", ";", "}" ]

[ "convert", "the", "given", "object", "to", "string", "with", "each", "line", "indented", "by", "4", "spaces", "(", "except", "the", "first", "line", ")" ]

[ "private", "string", "to", "indented", "string", "(", "object", "o", ")", "{", "if", "(", "o", "=", "=", "null", ")", "{", "return", "\"", "null", "\"", ";", "}", "return", "o", "to", "string", "(", ")", "replace", "(", "\"", "\\", "n", "\"", ",", "\"", "\\", "n", "\"", ")", ";", "}" ]

[ "test", "validate", "and", "create", "resource", "request", "fails", "on", "recovery", ",", "app", "should", "ignore", "this", "exception", "and", "continue" ]

[ "public", "void", "test", "app", "fail", "to", "validate", "resource", "request", "on", "recovery", "(", ")", "throws", "exception", "{", "rm", "1", "=", "new", "mock", "r", "m", "(", "conf", ")", ";", "rm", "1", "start", "(", ")", ";", "mock", "n", "m", "nm", "1", "=", "new", "mock", "n", "m", "(", "\"", "127", "0", "0", "1", ":", "1234", "\"", ",", "8192", ",", "rm", "1", "get", "resource", "tracker", "service", "(", ")", ")", ";", "nm", "1", "register", "node", "(", ")", ";", "r", "m", "app", "app", "1", "=", "mock", "r", "m", "app", "submitter", "submit", "with", "memory", "(", "200", ",", "rm", "1", ")", ";", "mock", "a", "m", "am", "1", "=", "mock", "r", "m", "launch", "and", "register", "a", "m", "(", "app", "1", ",", "rm", "1", ",", "nm", "1", ")", ";", "/", "/", "change", "the", "config", "so", "that", "validate", "and", "create", "resource", "request", "throws", "/", "/", "exception", "on", "recovery", "conf", "set", "int", "(", "yarn", "configuration", "rm", "scheduler", "minimum", "allocation", "mb", ",", "50", ")", ";", "conf", "set", "int", "(", "yarn", "configuration", "rm", "scheduler", "maximum", "allocation", "mb", ",", "100", ")", ";", "rm", "2", "=", "new", "mock", "r", "m", "(", "conf", ",", "rm", "1", "get", "r", "m", "state", "store", "(", ")", ")", ";", "nm", "1", "set", "resource", "tracker", "service", "(", "rm", "2", "get", "resource", "tracker", "service", "(", ")", ")", ";", "rm", "2", "start", "(", ")", ";", "}" ]

[ "finds", "the", "child", "with", "the", "specified", "name", "and", "returns", "it", "as", "a", "short" ]

[ "public", "short", "get", "short", "(", "string", "name", ")", "{", "json", "value", "child", "=", "get", "(", "name", ")", ";", "if", "(", "child", "=", "=", "null", ")", "throw", "new", "illegal", "argument", "exception", "(", "\"", "named", "value", "not", "found", ":", "\"", "+", "name", ")", ";", "return", "child", "as", "short", "(", ")", ";", "}" ]

[ "test", "that", "{", "@", "link", "netty", "4", "http", "server", "transport", "}", "supports", "the", "\"", "expect", ":", "100", "-", "continue", "\"", "http", "header" ]

[ "public", "void", "test", "expect", "continue", "header", "(", ")", "throws", "interrupted", "exception", "{", "final", "settings", "settings", "=", "create", "settings", "(", ")", ";", "final", "int", "content", "length", "=", "random", "int", "between", "(", "1", ",", "http", "transport", "settings", "setting", "http", "max", "content", "length", "get", "(", "settings", ")", "bytes", "as", "int", "(", ")", ")", ";", "run", "expect", "header", "test", "(", "settings", ",", "http", "header", "values", "continue", "to", "string", "(", ")", ",", "content", "length", ",", "http", "response", "status", "continue", ")", ";", "}" ]

[ "buildscreates", "a", "new", "{", "@", "link", "inbound", "http", "2", "to", "http", "adapter", "}", "instance", "using", "this", "builder", "'", "s", "current", "settings" ]

[ "protected", "t", "build", "(", ")", "{", "final", "t", "instance", ";", "try", "{", "instance", "=", "build", "(", "connection", "(", ")", ",", "max", "content", "length", "(", ")", ",", "is", "validate", "http", "headers", "(", ")", ",", "is", "propagate", "settings", "(", ")", ")", ";", "}", "catch", "(", "throwable", "t", ")", "{", "throw", "new", "illegal", "state", "exception", "(", "\"", "failed", "to", "create", "a", "new", "inbound", "http", "2", "to", "http", "adapter", "\"", ",", "t", ")", ";", "}", "connection", "add", "listener", "(", "instance", ")", ";", "return", "instance", ";", "}" ]

[ "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", "com", "android", "aapt", "resources", "config", "value", "or", "builder", "get", "config", "value", "or", "builder", "(", "int", "index", ")", "{", "return", "config", "value", "get", "(", "index", ")", ";", "}" ]

[ "place", "new", "accepted", "connection", "onto", "a", "queue", "for", "adding", "do", "this", "so", "only", "the", "selector", "thread", "modifies", "what", "keys", "are", "registered", "with", "the", "selector" ]

[ "public", "boolean", "add", "accepted", "connection", "(", "socket", "channel", "accepted", ")", "{", "if", "(", "stopped", "|", "|", "!", "accepted", "queue", "offer", "(", "accepted", ")", ")", "{", "return", "false", ";", "}", "wakeup", "selector", "(", ")", ";", "return", "true", ";", "}" ]

[ "get", "capital", "snake" ]

[ "public", "string", "get", "capital", "snake", "(", ")", "{", "return", "capital", "snake", ";", "}" ]

[ "{", "@", "inherit", "doc", "}", "the", "default", "implementation", "does", "nothing" ]

[ "@", "override", "public", "void", "exit", "event", "query", "(", "eql", "base", "parser", "event", "query", "context", "ctx", ")", "{", "}" ]

[ "verify", "if", "a", "member", "is", "notified", "when", "it", "'", "s", "joining", "a", "party", "generate", "an", "action", "and", "see", "if", "the", "other", "member", "gets", "it", "also", "check", "members", "don", "'", "t", "get", "their", "own", "actions" ]

[ "public", "void", "test", "party", "action", "(", ")", "{", "final", "var", "party", "member", "1", "=", "mock", "(", "party", "member", "class", ")", ";", "final", "var", "party", "member", "2", "=", "mock", "(", "party", "member", "class", ")", ";", "final", "var", "party", "=", "new", "party", "impl", "(", ")", ";", "party", "add", "member", "(", "party", "member", "1", ")", ";", "party", "add", "member", "(", "party", "member", "2", ")", ";", "verify", "(", "party", "member", "1", ")", "joined", "party", "(", "party", ")", ";", "verify", "(", "party", "member", "2", ")", "joined", "party", "(", "party", ")", ";", "party", "act", "(", "party", "member", "1", ",", "action", "gold", ")", ";", "verify", "zero", "interactions", "(", "party", "member", "1", ")", ";", "verify", "(", "party", "member", "2", ")", "party", "action", "(", "action", "gold", ")", ";", "verify", "no", "more", "interactions", "(", "party", "member", "1", ",", "party", "member", "2", ")", ";", "}" ]

[ "get", "the", "record", "offset", "within", "the", "buffer" ]

[ "public", "int", "get", "record", "data", "offset", "(", "int", "index", ")", "{", "return", "buffer", "get", "int", "(", "data", "offset", "base", "offset", "+", "(", "index", "*", "entry", "size", ")", ")", ";", "}" ]

[ "@", "inherit", "doc" ]

[ "public", "int", "read", "int", "(", ")", "throws", "e", "o", "f", "exception", "{", "int", "short", "0", "=", "read", "(", ")", ";", "int", "short", "1", "=", "read", "(", ")", ";", "return", "short", "0", "|", "(", "short", "1", "<", "<", "16", ")", ";", "}" ]

[ "get", "the", "http", "status", "code" ]

[ "public", "int", "get", "code", "(", ")", "{", "return", "code", ";", "}" ]

[ "gets", "the", "location", "string", "(", "for", "stack", "variables", "this", "is", "the", "offset", "as", "a", "string", ")" ]

[ "public", "string", "get", "loc", "(", ")", "{", "return", "loc", ";", "}" ]

[ "attempt", "to", "markup", "any", "or", "all", "scalars", "contained", "within", "the", "representation", "list" ]

[ "private", "boolean", "perform", "scalar", "markup", "(", "instruction", "inst", ",", "int", "op", "index", ",", "function", "function", ",", "reference", "primary", "ref", ",", "variable", "referenced", "variable", ",", "map", "<", "register", ",", "integer", ">", "reg", "index", "map", ",", "list", "<", "object", ">", "representations", ")", "{", "instruction", "scalar", "info", "info", "=", "new", "instruction", "scalar", "info", "(", "representations", ",", "primary", "ref", ")", ";", "if", "(", "info", "has", "single", "address", "with", "no", "scalars", "(", ")", ")", "{", "int", "address", "index", "=", "info", "get", "address", "index", "(", ")", ";", "return", "markup", "address", "as", "scalar", "(", "inst", ",", "primary", "ref", ",", "representations", ",", "address", "index", ")", ";", "}", "if", "(", "info", "has", "no", "scalars", "(", ")", ")", "{", "return", "false", ";", "}", "program", "program", "=", "inst", "get", "program", "(", ")", ";", "list", "<", "equate", ">", "equates", "=", "null", ";", "pcode", "op", "[", "]", "pcode", "=", "null", ";", "int", "size", "=", "representations", "size", "(", ")", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "size", ";", "i", "+", "+", ")", "{", "scalar", "scalar", "=", "info", "get", "scalar", "(", "i", ")", ";", "if", "(", "scalar", "=", "=", "null", ")", "{", "continue", ";", "}", "if", "(", "pcode", "=", "=", "null", ")", "{", "pcode", "=", "inst", "get", "pcode", "(", "op", "index", ")", ";", "}", "register", "operand", "register", "=", "find", "associated", "operand", "register", "(", "scalar", ",", "reg", "index", "map", ",", "pcode", ")", ";", "if", "(", "operand", "register", "=", "=", "null", ")", "{", "if", "(", "markup", "scalar", "with", "memory", "reference", "(", "inst", ",", "scalar", ",", "i", ",", "primary", "ref", ",", "representations", ")", ")", "{", "primary", "ref", "=", "null", ";", "/", "/", "reference", "consumed", "-", "continue", "handling", "other", "scalars", "referenced", "variable", "=", "null", ";", "/", "/", "we", "may", "accidentally", "consume", "referenced", "variable", "continue", ";", "}", "}", "else", "if", "(", "primary", "ref", "!", "=", "null", "&", "&", "primary", "ref", "is", "stack", "reference", "(", ")", ")", "{", "/", "/", "handle", "explicit", "stack", "reference", "/", "/", "triggered", "only", "if", "scalar", "is", "associated", "with", "a", "register", "in", "the", "same", "operand", "if", "(", "markup", "scalar", "with", "stack", "reference", "(", "scalar", ",", "i", ",", "primary", "ref", ",", "referenced", "variable", ",", "representations", ")", ")", "{", "reg", "index", "map", "remove", "(", "operand", "register", ")", ";", "return", "true", ";", "}", "return", "false", ";", "/", "/", "no", "other", "mark", "-", "up", "to", "operand", "when", "stack", "reference", "applied", "}", "else", "if", "(", "is", "register", "associated", "with", "referenced", "variable", "(", "referenced", "variable", ",", "operand", "register", ")", ")", "{", "if", "(", "markup", "scalar", "with", "referenced", "register", "variable", "(", "scalar", ",", "i", ",", "primary", "ref", ",", "referenced", "variable", ",", "representations", ")", ")", "{", "primary", "ref", "=", "null", ";", "/", "/", "reference", "consumed", "-", "continue", "handling", "other", "scalars", "referenced", "variable", "=", "null", ";", "/", "/", "referenced", "variable", "consumed", "reg", "index", "map", "remove", "(", "operand", "register", ")", ";", "continue", ";", "}", "}", "else", "if", "(", "markup", "scalar", "with", "memory", "reference", "(", "inst", ",", "scalar", ",", "i", ",", "primary", "ref", ",", "representations", ")", ")", "{", "primary", "ref", "=", "null", ";", "/", "/", "reference", "consumed", "-", "continue", "handling", "other", "scalars", "referenced", "variable", "=", "null", ";", "/", "/", "signal", "not", "to", "consume", "referenced", "variable", "continue", ";", "}", "else", "if", "(", "markup", "scalar", "with", "implied", "register", "variable", "(", "inst", ",", "function", ",", "scalar", ",", "i", ",", "operand", "register", ",", "representations", ")", ")", "{", "reg", "index", "map", "remove", "(", "operand", "register", ")", ";", "continue", ";", "}", "if", "(", "equates", "=", "=", "null", ")", "{", "equates", "=", "program", "get", "equate", "table", "(", ")", "get", "equates", "(", "inst", "get", "min", "address", "(", ")", ",", "op", "index", ")", ";", "}", "markup", "scalar", "with", "equate", "(", "scalar", ",", "i", ",", "equates", ",", "representations", ")", ";", "}", "return", "primary", "ref", "=", "=", "null", ";", "}" ]

[ "stores", "a", "boolean", "value", "in", "the", "table", "at", "the", "given", "row", "and", "column", "note", "-", "all", "values", "in", "a", "given", "column", "must", "be", "of", "the", "same", "type" ]

[ "public", "void", "put", "boolean", "(", "int", "row", ",", "int", "col", ",", "boolean", "value", ")", "{", "max", "row", "=", "math", "max", "(", "max", "row", ",", "row", ")", ";", "occupied", "put", "(", "row", ",", "true", ")", ";", "super", "put", "boolean", "(", "row", ",", "col", ",", "value", ")", ";", "}" ]

[ "returns", "byte", "length", "of", "the", "optimized", "dex", "file" ]

[ "public", "int", "get", "dex", "length", "(", ")", "{", "return", "dex", "length", ";", "}" ]

[ "configures", "the", "passed", "in", "{", "@", "link", "https", "u", "r", "l", "connection", "}", "to", "allow", "all", "ssl", "certificates", "also", "presents", "a", "client", "certificate" ]

[ "public", "static", "void", "set", "allow", "all", "s", "s", "l", "(", "https", "u", "r", "l", "connection", "https", "conn", ",", "x", "5", "0", "9", "certificate", "client", "cert", ",", "key", "pair", "client", "key", "pair", ")", "throws", "key", "management", "exception", ",", "no", "such", "algorithm", "exception", "{", "x", "5", "0", "9", "key", "manager", "km", "=", "new", "x", "5", "0", "9", "key", "manager", "(", ")", "{", "@", "override", "public", "string", "[", "]", "get", "client", "aliases", "(", "string", "s", ",", "principal", "[", "]", "principals", ")", "{", "return", "new", "string", "[", "]", "{", "\"", "client", "\"", "}", ";", "}", "@", "override", "public", "string", "choose", "client", "alias", "(", "string", "[", "]", "strings", ",", "principal", "[", "]", "principals", ",", "socket", "socket", ")", "{", "return", "\"", "client", "\"", ";", "}", "@", "override", "public", "string", "[", "]", "get", "server", "aliases", "(", "string", "s", ",", "principal", "[", "]", "principals", ")", "{", "return", "null", ";", "}", "@", "override", "public", "string", "choose", "server", "alias", "(", "string", "s", ",", "principal", "[", "]", "principals", ",", "socket", "socket", ")", "{", "return", "null", ";", "}", "@", "override", "public", "x", "5", "0", "9", "certificate", "[", "]", "get", "certificate", "chain", "(", "string", "s", ")", "{", "return", "new", "x", "5", "0", "9", "certificate", "[", "]", "{", "client", "cert", "}", ";", "}", "@", "override", "public", "private", "key", "get", "private", "key", "(", "string", "s", ")", "{", "return", "client", "key", "pair", "get", "private", "(", ")", ";", "}", "}", ";", "set", "allow", "all", "s", "s", "l", "(", "https", "conn", ",", "km", ")", ";", "}" ]

[ "rounds", "the", "given", "utc", "milliseconds", "sicne", "the", "epoch", "down", "to", "the", "next", "unit", "millis", "note", ":", "this", "does", "not", "check", "for", "correctness", "of", "the", "result", ",", "as", "this", "only", "works", "with", "units", "smaller", "or", "equal", "than", "a", "day", "in", "order", "to", "ensure", "the", "performance", "of", "this", "methods", ",", "there", "are", "no", "guards", "or", "checks", "in", "it" ]

[ "public", "static", "long", "round", "floor", "(", "long", "utc", "millis", ",", "final", "long", "unit", "millis", ")", "{", "if", "(", "utc", "millis", ">", "=", "0", ")", "{", "return", "utc", "millis", "-", "utc", "millis", "%", "unit", "millis", ";", "}", "else", "{", "utc", "millis", "+", "=", "1", ";", "return", "utc", "millis", "-", "utc", "millis", "%", "unit", "millis", "-", "unit", "millis", ";", "}", "}" ]

[ "gets", "original", "exception" ]

[ "public", "throwable", "get", "original", "exception", "(", ")", "{", "return", "original", "exception", ";", "}" ]

[ "appends", "{", "@", "code", "values", "}", ",", "in", "order", ",", "to", "the", "end", "of", "the", "values", "the", "built", "{", "@", "link", "immutable", "long", "array", "}", "will", "contain" ]

[ "public", "builder", "add", "all", "(", "long", "[", "]", "values", ")", "{", "ensure", "room", "for", "(", "values", "length", ")", ";", "system", "arraycopy", "(", "values", ",", "0", ",", "array", ",", "count", ",", "values", "length", ")", ";", "count", "+", "=", "values", "length", ";", "return", "this", ";", "}" ]

[ "post", "storeorder", ":", "place", "an", "order", "for", "a", "pet" ]

[ "default", "response", "entity", "<", "order", ">", "place", "order", "(", "@", "api", "param", "(", "value", "=", "\"", "order", "placed", "for", "purchasing", "the", "pet", "\"", ",", "required", "=", "true", ")", "@", "valid", "@", "request", "body", "order", "body", ")", "{", "return", "get", "delegate", "(", ")", "place", "order", "(", "body", ")", ";", "}" ]

[ "template", "method", "for", "customizing", "the", "expression", "evaluation", "context", "the", "default", "implementation", "is", "empty" ]

[ "protected", "void", "customize", "evaluation", "context", "(", "standard", "evaluation", "context", "eval", "context", ")", "{", "}" ]

[ "checks", "if", "the", "symbol", "is", "a", "function", "variable" ]

[ "public", "boolean", "is", "variable", "symbol", "(", "symbol", "s", ")", "{", "symbol", "parent", "=", "s", "get", "parent", "symbol", "(", ")", ";", "if", "(", "parent", "=", "=", "null", "|", "|", "!", "is", "function", "symbol", "(", "parent", ")", ")", "{", "return", "false", ";", "}", "symbol", "type", "type", "=", "s", "get", "symbol", "type", "(", ")", ";", "return", "type", "=", "=", "symbol", "type", "parameter", "|", "|", "type", "=", "=", "symbol", "type", "local", "var", "|", "|", "type", "=", "=", "symbol", "type", "global", "var", ";", "}" ]

[ "https", ":", "jira", "spring", "iobrowse", "s", "p", "r", "-", "2788" ]

[ "public", "void", "as", "body", "tag", "with", "no", "errors", "and", "existing", "messages", "attribute", "in", "session", "scope", "are", "not", "clobbered", "(", ")", "throws", "exception", "{", "assert", "when", "no", "errors", "existing", "messages", "in", "scope", "are", "not", "clobbered", "(", "page", "context", "session", "scope", ")", ";", "}" ]

[ "collects", "all", "attribute", "labels", "from", "the", "specified", "aspect", "definition" ]

[ "public", "static", "void", "add", "all", "attributes", "of", "aspect", "(", "final", "rule", "from", ",", "final", "multimap", "<", "attribute", ",", "label", ">", "label", "builder", ",", "aspect", "aspect", ",", "dependency", "filter", "dependency", "filter", ")", "{", "for", "each", "label", "dep", "from", "all", "attributes", "of", "aspect", "(", "from", ",", "aspect", ",", "dependency", "filter", ",", "label", "builder", ":", ":", "put", ")", ";", "}" ]

[ "test", "the", "property", "'", "ship", "date", "'" ]

[ "public", "void", "ship", "date", "test", "(", ")", "{", "/", "/", "todo", ":", "test", "ship", "date", "}" ]

[ "register", "a", "watcher", "to", "the", "target", "value" ]

[ "void", "register", "config", "change", "watcher", "(", "config", "change", "watcher", "watcher", ")", ";" ]

[ "sets", "the", "default", "{", "@", "link", "transition", "options", "}", "to", "use", "when", "starting", "a", "request", "that", "will", "load", "a", "resource", "with", "the", "given", "{", "@", "link", "class", "}", "it", "'", "s", "preferable", "but", "not", "required", "for", "the", "requested", "resource", "class", "to", "match", "the", "resource", "class", "applied", "here", "as", "long", "as", "the", "resource", "class", "applied", "here", "is", "assignable", "from", "the", "requested", "resource", "class", "for", "example", "you", "can", "set", "a", "default", "transition", "for", "{", "@", "link", "android", "graphics", "drawable", "drawable", "}", "and", "that", "default", "transition", "will", "be", "used", "if", "you", "subsequently", "start", "requests", "for", "specific", "{", "@", "link", "android", "graphics", "drawable", "drawable", "}", "types", "like", "{", "@", "link", "com", "bumptech", "glide", "load", "resource", "gif", "gif", "drawable", "}", "or", "{", "@", "link", "android", "graphics", "drawable", "bitmap", "drawable", "}", "specific", "types", "are", "always", "preferred", "so", "if", "you", "register", "a", "default", "transition", "for", "both", "{", "@", "link", "android", "graphics", "drawable", "drawable", "}", "and", "{", "@", "link", "android", "graphics", "drawable", "bitmap", "drawable", "}", "and", "then", "start", "a", "request", "for", "{", "@", "link", "android", "graphics", "drawable", "bitmap", "drawable", "}", "s", ",", "the", "transition", "you", "registered", "for", "{", "@", "link", "android", "graphics", "drawable", "bitmap", "drawable", "}", "s", "will", "be", "used" ]

[ "public", "<", "t", ">", "glide", "builder", "set", "default", "transition", "options", "(", "@", "non", "null", "class", "<", "t", ">", "clazz", ",", "@", "nullable", "transition", "options", "<", "?", ",", "t", ">", "options", ")", "{", "default", "transition", "options", "put", "(", "clazz", ",", "options", ")", ";", "return", "this", ";", "}" ]

[ "update", "an", "existing", "pet" ]

[ "public", "void", "update", "pet", "(", "pet", "body", ")", ";" ]

[ "disable", "erasure", "coding", "policy" ]

[ "public", "void", "disable", "erasure", "coding", "policy", "(", "string", "ec", "policy", "name", ")", "throws", "i", "o", "exception", "{", "statistics", "increment", "write", "ops", "(", "1", ")", ";", "storage", "statistics", "increment", "op", "counter", "(", "op", "type", "disable", "ec", "policy", ")", ";", "dfs", "disable", "erasure", "coding", "policy", "(", "ec", "policy", "name", ")", ";", "}" ]

[ "create", "dummy", "archive", "and", "installation", "folders", "in", "the", "temp", "space", "that", "we", "can", "populate", "with", "extensions" ]

[ "public", "void", "setup", "(", ")", "throws", "i", "o", "exception", "{", "g", "layout", "=", "application", "get", "application", "layout", "(", ")", ";", "/", "/", "verify", "that", "the", "archive", "and", "install", "directories", "are", "empty", "(", "each", "test", "requires", "/", "/", "we", "start", "with", "a", "clean", "slate", ")", "if", "they", "'", "re", "not", "empty", ",", "correct", "the", "situation", "if", "(", "!", "check", "clean", "install", "(", ")", ")", "{", "file", "utilities", "delete", "dir", "(", "g", "layout", "get", "extension", "archive", "dir", "(", ")", "get", "file", "(", "false", ")", ")", ";", "for", "(", "resource", "file", "install", "dir", ":", "g", "layout", "get", "extension", "installation", "dirs", "(", ")", ")", "{", "file", "utilities", "delete", "dir", "(", "install", "dir", "get", "file", "(", "false", ")", ")", ";", "}", "}", "create", "extension", "dirs", "(", ")", ";", "}" ]

[ "gets", "the", "unit", "test", "parameters" ]

[ "public", "static", "stream", "<", "arguments", ">", "get", "test", "parameters", "(", ")", "{", "return", "stream", "of", "(", "/", "*", "test", "with", "cert", "with", "rfc822", "email", "address", "and", "no", "alternate", "*", "/", "arguments", "(", "\"", "/", "x", "5", "0", "9", "-", "san", "-", "upn", "-", "resolver", "crt", "\"", ",", "\"", "test", "@", "somecompany", "com", "\"", ",", "null", ",", "\"", "x", "5", "0", "9", "rfc", "8", "2", "2", "email", "\"", ")", ",", "/", "*", "test", "with", "alternate", "parameter", "and", "cert", "with", "rfc822", "email", "address", "*", "/", "arguments", "(", "\"", "/", "x", "5", "0", "9", "-", "san", "-", "upn", "-", "resolver", "crt", "\"", ",", "\"", "test", "@", "somecompany", "com", "\"", ",", "\"", "subject", "dn", "\"", ",", "\"", "x", "5", "0", "9subject", "u", "p", "n", "\"", ")", ",", "/", "*", "test", "with", "alternate", "parameter", "and", "cert", "without", "rfc822", "email", "address", "*", "/", "arguments", "(", "\"", "/", "user", "-", "valid", "crt", "\"", ",", "\"", "cn", "=", "alice", ",", "ou", "=", "cas", ",", "o", "=", "jasig", ",", "l", "=", "westminster", ",", "st", "=", "colorado", ",", "c", "=", "us", "\"", ",", "\"", "subject", "dn", "\"", ",", "null", ")", ",", "/", "*", "test", "with", "bad", "alternate", "parameter", "and", "cert", "without", "rfc822", "email", "address", "*", "/", "arguments", "(", "\"", "/", "user", "-", "valid", "crt", "\"", ",", "null", ",", "\"", "bad", "attribute", "\"", ",", "null", ")", ")", ";", "}" ]

[ "test", "serialization", "of", "outer", "string", "types" ]

[ "public", "void", "fake", "outer", "string", "serialize", "(", "string", "body", ",", "api", "client", "auth", "info", "auth", "info", ",", "handler", "<", "async", "result", "<", "string", ">", ">", "result", "handler", ")", "{", "object", "local", "var", "body", "=", "body", ";", "/", "/", "create", "path", "and", "map", "variables", "string", "local", "var", "path", "=", "\"", "/", "fake", "/", "outer", "/", "string", "\"", ";", "/", "/", "query", "params", "list", "<", "pair", ">", "local", "var", "query", "params", "=", "new", "array", "list", "<", ">", "(", ")", ";", "/", "/", "header", "params", "multi", "map", "local", "var", "header", "params", "=", "multi", "map", "case", "insensitive", "multi", "map", "(", ")", ";", "/", "/", "cookie", "params", "multi", "map", "local", "var", "cookie", "params", "=", "multi", "map", "case", "insensitive", "multi", "map", "(", ")", ";", "/", "/", "form", "params", "/", "/", "todo", ":", "sending", "files", "within", "multipart", "/", "form", "-", "data", "is", "not", "supported", "yet", "(", "because", "of", "vertx", "web", "-", "client", ")", "map", "<", "string", ",", "object", ">", "local", "var", "form", "params", "=", "new", "hash", "map", "<", ">", "(", ")", ";", "string", "[", "]", "local", "var", "accepts", "=", "{", "\"", "*", "/", "*", "\"", "}", ";", "string", "[", "]", "local", "var", "content", "types", "=", "{", "}", ";", "string", "[", "]", "local", "var", "auth", "names", "=", "new", "string", "[", "]", "{", "}", ";", "type", "reference", "<", "string", ">", "local", "var", "return", "type", "=", "new", "type", "reference", "<", "string", ">", "(", ")", "{", "}", ";", "api", "client", "invoke", "a", "p", "i", "(", "local", "var", "path", ",", "\"", "post", "\"", ",", "local", "var", "query", "params", ",", "local", "var", "body", ",", "local", "var", "header", "params", ",", "local", "var", "cookie", "params", ",", "local", "var", "form", "params", ",", "local", "var", "accepts", ",", "local", "var", "content", "types", ",", "local", "var", "auth", "names", ",", "auth", "info", ",", "local", "var", "return", "type", ",", "result", "handler", ")", ";", "}" ]

[ "the", "open", "interface", "for", "other", "classes", "in", "crud", "package", "to", "update", "multiple", "rows", "using", "table", "name", "to", "decide", "which", "table", "to", "update", ",", "and", "conditions", "representing", "the", "where", "part", "of", "an", "sql", "statement", "the", "value", "that", "need", "to", "update", "is", "stored", "in", "content", "values" ]

[ "public", "int", "on", "update", "all", "(", "string", "table", "name", ",", "content", "values", "values", ",", "string", "conditions", ")", "{", "base", "utility", "check", "conditions", "correct", "(", "conditions", ")", ";", "if", "(", "conditions", "!", "=", "null", "&", "&", "conditions", "length", ">", "0", ")", "{", "conditions", "[", "0", "]", "=", "d", "b", "utility", "convert", "where", "clause", "to", "column", "name", "(", "conditions", "[", "0", "]", ")", ";", "}", "convert", "content", "values", "(", "values", ")", ";", "return", "do", "update", "all", "action", "(", "table", "name", ",", "values", ",", "conditions", ")", ";", "}" ]

[ "works", "like", "{", "@", "link", "#", "surround", "with", "(", "string", ",", "string", ")", "}", "except", "that", "the", "token", "replacement", "is", "not", "performed", "on", "parameters" ]

[ "public", "void", "surround", "with", "literal", "(", "string", "start", "tag", ",", "string", "end", "tag", ")", "{", "add", "markup", "(", "0", ",", "length", "(", ")", ",", "start", "tag", ",", "end", "tag", ")", ";", "}" ]

[ "receives", "the", "elapsed", "time", "of", "the", "lifetime", "of", "an", "{", "@", "link", "auto", "profiler", "}", "instance", "note", "that", "system", "#", "nano", "time", "isn", "'", "t", "guaranteed", "to", "be", "non", "-", "decreasing", ",", "so", "implementations", "should", "check", "for", "non", "-", "positive", "{", "@", "code", "elapsed", "time", "nanos", "}", "if", "they", "care", "about", "this", "sort", "of", "thing" ]

[ "void", "accept", "(", "long", "elapsed", "time", "nanos", ")", ";" ]

[ "get", "the", "{", "@", "link", "configuration", "}", "for", "this", "{", "@", "link", "http", "2", "headers", "decoder", "}" ]

[ "configuration", "configuration", "(", ")", ";" ]

[ "get", "the", "list", "of", "block", "entries", "it", "is", "used", "for", "testing", "purposes", "only" ]

[ "list", "<", "block", "entry", ">", "get", "block", "list", "(", ")", "throws", "storage", "exception", ",", "i", "o", "exception", "{", "return", "blob", "download", "block", "list", "(", "block", "listing", "filter", "committed", ",", "new", "blob", "request", "options", "(", ")", ",", "op", "context", ")", ";", "}" ]

[ "escapes", "all", "strings", "in", "{", "@", "code", "argv", "}", "individually", "and", "joins", "them", "on", "single", "spaces", "into", "{", "@", "code", "out", "}", "the", "result", "is", "appended", "directly", "into", "{", "@", "code", "out", "}", ",", "without", "adding", "a", "separator", "this", "method", "works", "as", "if", "by", "invoking", "{", "@", "link", "#", "escape", "join", "all", "(", "appendable", ",", "iterable", ",", "joiner", ")", "}", "with", "{", "@", "code", "joiner", "on", "(", "'", "'", ")", "}" ]

[ "public", "static", "appendable", "escape", "join", "all", "(", "appendable", "out", ",", "iterable", "<", "?", "extends", "string", ">", "argv", ")", "throws", "i", "o", "exception", "{", "return", "space", "joiner", "append", "to", "(", "out", ",", "escape", "all", "(", "argv", ")", ")", ";", "}" ]

[ "the", "template", "source", "definition" ]

[ "public", "put", "index", "template", "request", "source", "(", "string", "template", "source", ",", "x", "content", "type", "x", "content", "type", ")", "{", "return", "source", "(", "x", "content", "helper", "convert", "to", "map", "(", "x", "content", "type", "x", "content", "(", ")", ",", "template", "source", ",", "true", ")", ")", ";", "}" ]

[ "returns", "a", "translated", "display", "name", "for", "the", "resource", "type" ]

[ "public", "string", "get", "display", "name", "(", ")", "{", "return", "display", "name", ";", "}" ]

[ "invoked", "immediately", "after", "the", "send", "invocation", "the", "boolean", "value", "argument", "represents", "the", "return", "value", "of", "that", "invocation" ]

[ "default", "void", "post", "send", "(", "message", "<", "?", ">", "message", ",", "message", "channel", "channel", ",", "boolean", "sent", ")", "{", "}" ]

[ "returns", "the", "section", "number", "if", "this", "symbol" ]

[ "public", "int", "get", "section", "number", "(", ")", "{", "return", "section", "number", ";", "}" ]

[ "sets", "if", "{", "@", "link", "#", "build", "(", ")", "}", "will", "to", "create", "a", "{", "@", "link", "http", "2", "connection", "}", "in", "server", "mode", "(", "{", "@", "code", "true", "}", ")", "or", "client", "mode", "(", "{", "@", "code", "false", "}", ")" ]

[ "protected", "b", "server", "(", "boolean", "is", "server", ")", "{", "enforce", "constraint", "(", "\"", "server", "\"", ",", "\"", "connection", "\"", ",", "connection", ")", ";", "enforce", "constraint", "(", "\"", "server", "\"", ",", "\"", "codec", "\"", ",", "decoder", ")", ";", "enforce", "constraint", "(", "\"", "server", "\"", ",", "\"", "codec", "\"", ",", "encoder", ")", ";", "this", "is", "server", "=", "is", "server", ";", "return", "self", "(", ")", ";", "}" ]

[ "test", "{", "@", "link", "fs", "dataset", "impl", "#", "init", "replica", "recovery", "(", "string", ",", "replica", "map", ",", "block", ",", "long", ",", "long", ")", "}" ]

[ "public", "void", "test", "init", "replica", "recovery", "(", ")", "throws", "i", "o", "exception", "{", "final", "long", "firstblockid", "=", "10000l", ";", "final", "long", "gs", "=", "7777l", ";", "final", "long", "length", "=", "22l", ";", "final", "replica", "map", "map", "=", "new", "replica", "map", "(", "new", "reentrant", "read", "write", "lock", "(", ")", ")", ";", "string", "bpid", "=", "\"", "bp", "-", "test", "\"", ";", "final", "block", "[", "]", "blocks", "=", "new", "block", "[", "5", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "blocks", "length", ";", "i", "+", "+", ")", "{", "blocks", "[", "i", "]", "=", "new", "block", "(", "firstblockid", "+", "i", ",", "length", ",", "gs", ")", ";", "map", "add", "(", "bpid", ",", "create", "replica", "info", "(", "blocks", "[", "i", "]", ")", ")", ";", "}", "{", "/", "/", "normal", "case", "final", "block", "b", "=", "blocks", "[", "0", "]", ";", "final", "replica", "info", "original", "info", "=", "map", "get", "(", "bpid", ",", "b", ")", ";", "final", "long", "recoveryid", "=", "gs", "+", "1", ";", "final", "replica", "recovery", "info", "recovery", "info", "=", "fs", "dataset", "impl", "init", "replica", "recovery", "(", "bpid", ",", "map", ",", "blocks", "[", "0", "]", ",", "recoveryid", ",", "d", "f", "s", "config", "keys", "dfs", "datanode", "xceiver", "stop", "timeout", "millis", "default", ")", ";", "assert", "equals", "(", "original", "info", ",", "recovery", "info", ")", ";", "final", "replica", "under", "recovery", "updated", "info", "=", "(", "replica", "under", "recovery", ")", "map", "get", "(", "bpid", ",", "b", ")", ";", "assert", "assert", "equals", "(", "original", "info", "get", "block", "id", "(", ")", ",", "updated", "info", "get", "block", "id", "(", ")", ")", ";", "assert", "assert", "equals", "(", "recoveryid", ",", "updated", "info", "get", "recovery", "i", "d", "(", ")", ")", ";", "/", "/", "recover", "one", "more", "time", "final", "long", "recoveryid", "2", "=", "gs", "+", "2", ";", "final", "replica", "recovery", "info", "recovery", "info", "2", "=", "fs", "dataset", "impl", "init", "replica", "recovery", "(", "bpid", ",", "map", ",", "blocks", "[", "0", "]", ",", "recoveryid", "2", ",", "d", "f", "s", "config", "keys", "dfs", "datanode", "xceiver", "stop", "timeout", "millis", "default", ")", ";", "assert", "equals", "(", "original", "info", ",", "recovery", "info", "2", ")", ";", "final", "replica", "under", "recovery", "updated", "info", "2", "=", "(", "replica", "under", "recovery", ")", "map", "get", "(", "bpid", ",", "b", ")", ";", "assert", "assert", "equals", "(", "original", "info", "get", "block", "id", "(", ")", ",", "updated", "info", "2", "get", "block", "id", "(", ")", ")", ";", "assert", "assert", "equals", "(", "recoveryid", "2", ",", "updated", "info", "2", "get", "recovery", "i", "d", "(", ")", ")", ";", "/", "/", "case", "recovery", "in", "progress", "exception", "try", "{", "fs", "dataset", "impl", "init", "replica", "recovery", "(", "bpid", ",", "map", ",", "b", ",", "recoveryid", ",", "d", "f", "s", "config", "keys", "dfs", "datanode", "xceiver", "stop", "timeout", "millis", "default", ")", ";", "assert", "fail", "(", ")", ";", "}", "catch", "(", "recovery", "in", "progress", "exception", "ripe", ")", "{", "system", "out", "println", "(", "\"", "good", ":", "getting", "\"", "+", "ripe", ")", ";", "}", "}", "{", "/", "/", "block", "recovery", "f", "i", "01", ":", "replica", "not", "found", "final", "long", "recoveryid", "=", "gs", "+", "1", ";", "final", "block", "b", "=", "new", "block", "(", "firstblockid", "-", "1", ",", "length", ",", "gs", ")", ";", "replica", "recovery", "info", "r", "=", "fs", "dataset", "impl", "init", "replica", "recovery", "(", "bpid", ",", "map", ",", "b", ",", "recoveryid", ",", "d", "f", "s", "config", "keys", "dfs", "datanode", "xceiver", "stop", "timeout", "millis", "default", ")", ";", "assert", "assert", "null", "(", "\"", "data", "-", "node", "should", "not", "have", "this", "replica", "\"", ",", "r", ")", ";", "}", "{", "/", "/", "block", "recovery", "f", "i", "02", ":", "\"", "this", "is", "not", "supposed", "to", "happen", "\"", "with", "recovery", "id", "<", "gs", "final", "long", "recoveryid", "=", "gs", "-", "1", ";", "final", "block", "b", "=", "new", "block", "(", "firstblockid", "+", "1", ",", "length", ",", "gs", ")", ";", "try", "{", "fs", "dataset", "impl", "init", "replica", "recovery", "(", "bpid", ",", "map", ",", "b", ",", "recoveryid", ",", "d", "f", "s", "config", "keys", "dfs", "datanode", "xceiver", "stop", "timeout", "millis", "default", ")", ";", "assert", "fail", "(", ")", ";", "}", "catch", "(", "i", "o", "exception", "ioe", ")", "{", "system", "out", "println", "(", "\"", "good", ":", "getting", "\"", "+", "ioe", ")", ";", "}", "}", "/", "/", "block", "recovery", "f", "i", "03", ":", "replica", "'", "s", "gs", "is", "less", "than", "the", "block", "'", "s", "gs", "{", "final", "long", "recoveryid", "=", "gs", "+", "1", ";", "final", "block", "b", "=", "new", "block", "(", "firstblockid", ",", "length", ",", "gs", "+", "1", ")", ";", "try", "{", "fs", "dataset", "impl", "init", "replica", "recovery", "(", "bpid", ",", "map", ",", "b", ",", "recoveryid", ",", "d", "f", "s", "config", "keys", "dfs", "datanode", "xceiver", "stop", "timeout", "millis", "default", ")", ";", "fail", "(", "\"", "init", "replica", "recovery", "should", "fail", "because", "replica", "'", "s", "\"", "+", "\"", "gs", "is", "less", "than", "the", "block", "'", "s", "gs", "\"", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "e", "get", "message", "(", ")", "starts", "with", "(", "\"", "replica", "get", "generation", "stamp", "(", ")", "<", "block", "get", "generation", "stamp", "(", ")", ",", "block", "=", "\"", ")", ";", "}", "}", "}" ]

[ "build", "api", "gateway", "response" ]

[ "public", "api", "gateway", "response", "build", "(", ")", "{", "string", "str", "body", "=", "null", ";", "if", "(", "this", "body", "!", "=", "null", ")", "{", "try", "{", "str", "body", "=", "object", "mapper", "write", "value", "as", "string", "(", "body", ")", ";", "}", "catch", "(", "json", "processing", "exception", "e", ")", "{", "throw", "new", "runtime", "exception", "(", "e", ")", ";", "}", "}", "return", "new", "api", "gateway", "response", "(", "this", "status", "code", ",", "str", "body", ",", "this", "headers", ",", "this", "is", "base", "6", "4", "encoded", ")", ";", "}" ]

[ "verify", "that", "the", "client", "is", "cleaning", "up", "properly", "openclose", "a", "large", "number", "of", "sessions", "essentially", "looking", "to", "see", "if", "socketsselectors", "are", "being", "cleaned", "up", "properly", "during", "close" ]

[ "public", "void", "test", "client", "cleanup", "(", ")", "throws", "throwable", "{", "o", "s", "m", "x", "bean", "os", "mbean", "=", "new", "o", "s", "m", "x", "bean", "(", ")", ";", "if", "(", "!", "os", "mbean", "get", "unix", "(", ")", ")", "{", "log", "warn", "(", "\"", "skipping", "test", "client", "cleanup", ",", "only", "available", "on", "unix", "\"", ")", ";", "return", ";", "}", "final", "int", "thread", "count", "=", "3", ";", "final", "int", "client", "count", "=", "10", ";", "/", "*", "log", "the", "number", "of", "fds", "used", "before", "and", "after", "a", "test", "is", "run", "verifies", "*", "we", "are", "freeing", "resources", "correctly", "unfortunately", "this", "only", "works", "*", "on", "unix", "systems", "(", "the", "only", "place", "sun", "has", "implemented", "as", "part", "of", "the", "*", "mgmt", "bean", "api", ")", "*", "/", "long", "initial", "fd", "count", "=", "os", "mbean", "get", "open", "file", "descriptor", "count", "(", ")", ";", "verify", "client", "cleanup", "[", "]", "threads", "=", "new", "verify", "client", "cleanup", "[", "thread", "count", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "threads", "length", ";", "i", "+", "+", ")", "{", "threads", "[", "i", "]", "=", "new", "verify", "client", "cleanup", "(", "\"", "vcc", "\"", "+", "i", ",", "client", "count", ")", ";", "threads", "[", "i", "]", "start", "(", ")", ";", "}", "for", "(", "int", "i", "=", "0", ";", "i", "<", "threads", "length", ";", "i", "+", "+", ")", "{", "threads", "[", "i", "]", "join", "(", "connection", "timeout", ")", ";", "assert", "true", "(", "threads", "[", "i", "]", "current", "=", "=", "threads", "[", "i", "]", "count", ")", ";", "}", "/", "/", "if", "this", "fails", "it", "means", "we", "are", "not", "cleaning", "up", "after", "the", "closed", "/", "/", "sessions", "long", "current", "count", "=", "os", "mbean", "get", "open", "file", "descriptor", "count", "(", ")", ";", "final", "string", "logmsg", "=", "\"", "open", "fds", "after", "test", "(", "{", "}", ")", "are", "not", "significantly", "higher", "than", "before", "(", "{", "}", ")", "\"", ";", "if", "(", "current", "count", ">", "initial", "fd", "count", "+", "10", ")", "{", "/", "/", "consider", "as", "error", "log", "error", "(", "logmsg", ",", "current", "count", ",", "initial", "fd", "count", ")", ";", "}", "else", "{", "log", "info", "(", "logmsg", ",", "current", "count", ",", "initial", "fd", "count", ")", ";", "}", "}" ]

[ "sets", "the", "read", "position", "of", "the", "stream" ]

[ "public", "synchronized", "void", "seek", "(", "long", "pos", ")", "throws", "i", "o", "exception", "{", "check", "state", "(", ")", ";", "if", "(", "pos", "<", "0", ")", "{", "throw", "new", "e", "o", "f", "exception", "(", "f", "s", "exception", "messages", "negative", "seek", "+", "\"", "\"", "+", "pos", ")", ";", "}", "if", "(", "pos", ">", "stream", "length", ")", "{", "throw", "new", "e", "o", "f", "exception", "(", "f", "s", "exception", "messages", "cannot", "seek", "past", "eof", "+", "\"", "\"", "+", "pos", ")", ";", "}", "/", "/", "calculate", "offset", "between", "the", "target", "and", "current", "position", "in", "the", "stream", "long", "offset", "=", "pos", "-", "get", "pos", "(", ")", ";", "if", "(", "offset", "=", "=", "0", ")", "{", "/", "/", "no", "=", "op", ",", "no", "state", "change", "return", ";", "}", "if", "(", "offset", ">", "0", ")", "{", "/", "/", "forward", "seek", ",", "data", "can", "be", "skipped", "as", "an", "optimization", "if", "(", "skip", "(", "offset", ")", "!", "=", "offset", ")", "{", "throw", "new", "e", "o", "f", "exception", "(", "f", "s", "exception", "messages", "eof", "in", "read", "fully", ")", ";", "}", "return", ";", "}", "/", "/", "reverse", "seek", ",", "offset", "is", "negative", "if", "(", "stream", "buffer", "!", "=", "null", ")", "{", "if", "(", "stream", "buffer", "position", "+", "offset", ">", "=", "0", ")", "{", "/", "/", "target", "position", "is", "inside", "the", "stream", "buffer", ",", "/", "/", "only", "need", "to", "move", "backwards", "within", "the", "stream", "buffer", "stream", "buffer", "position", "+", "=", "offset", ";", "}", "else", "{", "/", "/", "target", "position", "is", "outside", "the", "stream", "buffer", ",", "/", "/", "need", "to", "reset", "stream", "buffer", "and", "move", "position", "for", "next", "network", "read", "reset", "stream", "buffer", "(", ")", ";", "stream", "position", "=", "pos", ";", "}", "}", "else", "{", "stream", "position", "=", "pos", ";", "}", "/", "/", "close", "blob", "input", "stream", "after", "seek", "is", "invoked", "because", "blob", "input", "stream", "/", "/", "does", "not", "support", "seek", "close", "blob", "input", "stream", "(", ")", ";", "}" ]

[ "get", "the", "comma", "delimited", "values", "of", "the", "<", "code", ">", "name", "<", "code", ">", "property", "as", "an", "array", "of", "<", "code", ">", "string", "<", "code", ">", "s", "if", "no", "such", "property", "is", "specified", "then", "<", "code", ">", "null", "<", "code", ">", "is", "returned" ]

[ "public", "string", "[", "]", "get", "strings", "(", "string", "name", ")", "{", "string", "value", "string", "=", "get", "(", "name", ")", ";", "return", "string", "utils", "get", "strings", "(", "value", "string", ")", ";", "}" ]

[ "list", "of", "arguments", "to", "run", "the", "junit", "test" ]

[ "public", "static", "collection", "<", "object", "[", "]", ">", "get", "test", "parameters", "(", ")", "{", "return", "arrays", "as", "list", "(", "new", "object", "[", "]", "[", "]", "{", "{", "\"", "test", "single", "reducer", "\"", ",", "3", ",", "1", ",", "false", "}", ",", "{", "\"", "test", "uber", "mode", "\"", ",", "3", ",", "1", ",", "true", "}", ",", "{", "\"", "test", "multiple", "maps", "per", "node", "\"", ",", "8", ",", "1", ",", "false", "}", ",", "{", "\"", "test", "multiple", "reducers", "\"", ",", "2", ",", "4", ",", "false", "}", "}", ")", ";", "}" ]

[ "<", "code", ">", "optional", "aapt", "pb", "primitive", "prim", "=", "7", ";", "<", "code", ">" ]

[ "public", "builder", "set", "prim", "(", "com", "android", "aapt", "resources", "primitive", "value", ")", "{", "copy", "on", "write", "(", ")", ";", "instance", "set", "prim", "(", "value", ")", ";", "return", "this", ";", "}" ]

[ "sets", "the", "text", "to", "be", "shown", "as", "the", "description", "never", "set", "this", "to", "null", "as", "this", "will", "cause", "nullpointer", "exception", "when", "drawing", "with", "android", "canvas" ]

[ "public", "void", "set", "text", "(", "string", "text", ")", "{", "this", "text", "=", "text", ";", "}" ]

[ "resolve", "the", "given", "resource", "location", "to", "a", "{", "@", "code", "java", "io", "file", "}", ",", "i", "e", "to", "a", "file", "in", "the", "file", "system", "does", "not", "check", "whether", "the", "file", "actually", "exists", ";", "simply", "returns", "the", "file", "that", "the", "given", "location", "would", "correspond", "to" ]

[ "public", "static", "file", "get", "file", "(", "string", "resource", "location", ")", "throws", "file", "not", "found", "exception", "{", "assert", "not", "null", "(", "resource", "location", ",", "\"", "resource", "location", "must", "not", "be", "null", "\"", ")", ";", "if", "(", "resource", "location", "starts", "with", "(", "classpath", "url", "prefix", ")", ")", "{", "string", "path", "=", "resource", "location", "substring", "(", "classpath", "url", "prefix", "length", "(", ")", ")", ";", "string", "description", "=", "\"", "class", "path", "resource", "[", "\"", "+", "path", "+", "\"", "]", "\"", ";", "url", "url", "=", "class", "utils", "get", "default", "class", "loader", "(", ")", "get", "resource", "(", "path", ")", ";", "if", "(", "url", "=", "=", "null", ")", "{", "throw", "new", "file", "not", "found", "exception", "(", "description", "+", "\"", "cannot", "be", "resolved", "to", "absolute", "file", "path", "\"", "+", "\"", "because", "it", "does", "not", "reside", "in", "the", "file", "system", "\"", ")", ";", "}", "return", "get", "file", "(", "url", ",", "description", ")", ";", "}", "try", "{", "/", "/", "try", "url", "return", "get", "file", "(", "new", "url", "(", "resource", "location", ")", ")", ";", "}", "catch", "(", "malformed", "u", "r", "l", "exception", "ex", ")", "{", "/", "/", "no", "url", "-", ">", "treat", "as", "file", "path", "return", "new", "file", "(", "resource", "location", ")", ";", "}", "}" ]

[ "returns", "the", "contents", "of", "a", "container", "'", "s", "log", "file", "in", "plain", "text" ]

[ "public", "response", "get", "container", "log", "file", "(", "@", "context", "http", "servlet", "request", "req", ",", "@", "context", "http", "servlet", "response", "res", ",", "@", "path", "param", "(", "yarn", "web", "service", "params", "container", "id", ")", "string", "container", "id", "str", ",", "@", "path", "param", "(", "yarn", "web", "service", "params", "container", "log", "file", "name", ")", "string", "filename", ",", "@", "query", "param", "(", "yarn", "web", "service", "params", "response", "content", "format", ")", "string", "format", ",", "@", "query", "param", "(", "yarn", "web", "service", "params", "response", "content", "size", ")", "string", "size", ",", "@", "query", "param", "(", "yarn", "web", "service", "params", "nm", "id", ")", "string", "nm", "id", ",", "@", "query", "param", "(", "yarn", "web", "service", "params", "redirected", "from", "node", ")", "boolean", "redirected", "from", "node", ",", "@", "query", "param", "(", "yarn", "web", "service", "params", "manual", "redirection", ")", "@", "default", "value", "(", "\"", "false", "\"", ")", "boolean", "manual", "redirection", ")", "{", "return", "get", "logs", "(", "req", ",", "res", ",", "container", "id", "str", ",", "filename", ",", "format", ",", "size", ",", "nm", "id", ",", "redirected", "from", "node", ",", "manual", "redirection", ")", ";", "}", "/", "/", "todo", ":", "yarn", "-", "4993", ":", "refactory", "containers", "logs", "block", ",", "aggregated", "logs", "block", "and", "/", "/", "container", "log", "webservice", "introduced", "in", "ahs", "to", "minimize", "/", "/", "the", "duplication", "@", "get", "@", "path", "(", "\"", "/", "containerlogs", "/", "{", "containerid", "}", "/", "{", "filename", "}", "\"", ")", "@", "produces", "(", "{", "media", "type", "text", "plain", "+", "\"", ";", "\"", "+", "jetty", "utils", "utf", "8", "}" ]

[ "{", "@", "inherit", "doc", "}" ]

[ "public", "t", "next", "(", ")", "{", "try", "{", "return", "invoker", "retry", "(", "\"", "scan", "dynamo", "\"", ",", "null", ",", "true", ",", "iterator", ":", ":", "next", ")", ";", "}", "catch", "(", "i", "o", "exception", "e", ")", "{", "throw", "new", "unchecked", "i", "o", "exception", "(", "e", ")", ";", "}", "}" ]

[ "return", "whether", "the", "rom", "is", "made", "by", "oppo" ]

[ "public", "static", "boolean", "is", "oppo", "(", ")", "{", "return", "rom", "oppo", "[", "0", "]", "equals", "(", "get", "rom", "info", "(", ")", "name", ")", ";", "}" ]

[ "returns", "the", "given", "callback", "object", "if", "it", "is", "not", "{", "@", "code", "null", "}", "otherwise", ",", "a", "{", "@", "link", "#", "callback", "(", ")", "}", "is", "returned", "this", "is", "useful", "to", "avoid", "using", "{", "@", "code", "null", "}" ]

[ "public", "static", "<", "t", ">", "supplier", "<", "t", ">", "if", "null", "(", "supplier", "<", "t", ">", "s", ")", "{", "return", "s", "=", "=", "null", "?", "supplier", "(", ")", ":", "s", ";", "}" ]

[ "creates", "any", "necessary", "but", "nonexistent", "parent", "directories", "of", "the", "specified", "file", "note", "that", "if", "this", "operation", "fails", "it", "may", "have", "succeeded", "in", "creating", "some", "(", "but", "not", "all", ")", "of", "the", "necessary", "parent", "directories" ]

[ "public", "static", "void", "create", "parent", "dirs", "(", "file", "file", ")", "throws", "i", "o", "exception", "{", "check", "not", "null", "(", "file", ")", ";", "file", "parent", "=", "file", "get", "canonical", "file", "(", ")", "get", "parent", "file", "(", ")", ";", "if", "(", "parent", "=", "=", "null", ")", "{", "/", "*", "*", "the", "given", "directory", "is", "a", "filesystem", "root", "all", "zero", "of", "its", "ancestors", "exist", "this", "doesn", "'", "t", "*", "mean", "that", "the", "root", "itself", "exists", "-", "-", "consider", "x", ":", "\\", "on", "a", "windows", "machine", "without", "such", "a", "drive", "*", "-", "-", "or", "even", "that", "the", "caller", "can", "create", "it", ",", "but", "this", "method", "makes", "no", "such", "guarantees", "even", "for", "*", "non", "-", "root", "files", "*", "/", "return", ";", "}", "parent", "mkdirs", "(", ")", ";", "if", "(", "!", "parent", "is", "directory", "(", ")", ")", "{", "throw", "new", "i", "o", "exception", "(", "\"", "unable", "to", "create", "parent", "directories", "of", "\"", "+", "file", ")", ";", "}", "}" ]

[ "append", "specified", "bytes", "to", "a", "given", "file", ",", "starting", "with", "new", "block" ]

[ "public", "static", "void", "append", "file", "new", "block", "(", "distributed", "file", "system", "fs", ",", "path", "p", ",", "byte", "[", "]", "bytes", ")", "throws", "i", "o", "exception", "{", "assert", "fs", "exists", "(", "p", ")", ";", "try", "(", "f", "s", "data", "output", "stream", "out", "=", "fs", "append", "(", "p", ",", "enum", "set", "of", "(", "create", "flag", "append", ",", "create", "flag", "new", "block", ")", ",", "4096", ",", "null", ")", ")", "{", "out", "write", "(", "bytes", ")", ";", "}", "}" ]

[ "visit", "a", "parse", "tree", "produced", "by", "{", "@", "link", "sql", "base", "parser", "#", "pivot", "args", "}" ]

[ "t", "visit", "pivot", "args", "(", "sql", "base", "parser", "pivot", "args", "context", "ctx", ")", ";" ]

[ "if", "one", "instance", "is", "empty", ",", "return", "the", "other", "if", "both", "instances", "have", "conditions", ",", "combine", "the", "individual", "conditions", "after", "ensuring", "they", "are", "of", "the", "same", "type", "and", "number" ]

[ "public", "composite", "request", "condition", "combine", "(", "composite", "request", "condition", "other", ")", "{", "if", "(", "is", "empty", "(", ")", "&", "&", "other", "is", "empty", "(", ")", ")", "{", "return", "this", ";", "}", "else", "if", "(", "other", "is", "empty", "(", ")", ")", "{", "return", "this", ";", "}", "else", "if", "(", "is", "empty", "(", ")", ")", "{", "return", "other", ";", "}", "else", "{", "assert", "number", "of", "conditions", "(", "other", ")", ";", "request", "condition", "holder", "[", "]", "combined", "conditions", "=", "new", "request", "condition", "holder", "[", "get", "length", "(", ")", "]", ";", "for", "(", "int", "i", "=", "0", ";", "i", "<", "get", "length", "(", ")", ";", "i", "+", "+", ")", "{", "combined", "conditions", "[", "i", "]", "=", "this", "request", "conditions", "[", "i", "]", "combine", "(", "other", "request", "conditions", "[", "i", "]", ")", ";", "}", "return", "new", "composite", "request", "condition", "(", "combined", "conditions", ")", ";", "}", "}" ]