Datasets:

google

/

code_x_glue_cc_cloze_testing_all

like 5

Follow

Google 4,439

[ "native", "returns", "a", "pointer", "to", "the", "underlying", "GtkContainer", "." ]

[ "func", "(", "v", "*", "<mask>", ")", "native", "(", ")", "*", "C", ".", "GtkContainer", "{", "if", "v", "==", "nil", "||", "v", ".", "GObject", "==", "nil", "{", "return", "nil", "\n", "}", "\n", "p", ":=", "unsafe", ".", "Pointer", "(", "v", ".", "GObject", ")", "\n", "return", "C", ".", "toGtkContainer", "(", "p", ")", "\n", "}" ]

[ "Request", "implements", "the", "http", ".", "Handler", "interface", "to", "provide", "a", "drop", "-", "in", "Loginshare", "request", "/", "response", "handler" ]

[ "func", "(", "l", "*", "LoginShare", ")", "Request", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "lsr", ",", "err", ":=", "l", ".", "validateRequest", "(", "r", ")", "\n", "if", "err", "!=", "nil", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusBadRequest", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "r", ".", "RemoteAddr", ")", "\n", "return", "\n", "}", "\n\n", "if", "l", ".", "interfaceAllowed", "(", "lsr", ".", "Interface", ")", "==", "false", "{", "w", ".", "WriteHeader", "(", "<mask>", ".", "StatusForbidden", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "r", ".", "RemoteAddr", ")", "\n", "return", "\n", "}", "\n\n", "w", ".", "Header", "(", ")", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "xw", ":=", "xml", ".", "NewEncoder", "(", "w", ")", "\n", "resp", ",", "err", ":=", "l", ".", "OnNewAuth", "(", "lsr", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "r", ".", "RemoteAddr", ",", "err", ")", "\n", "resp", ".", "StaffRecord", "=", "Staff", "{", "}", "// make sure we don't give up any info if partially populated", "\n", "resp", ".", "Result", "=", "0", "\n", "resp", ".", "Message", "=", "err", ".", "Error", "(", ")", "\n", "xw", ".", "Encode", "(", "resp", ")", "\n", "return", "\n", "}", "\n\n", "xw", ".", "Encode", "(", "resp", ")", "\n", "return", "\n", "}" ]

[ "WithLocation", "whether", "the", "event", "was", "from", "the", "left", "or", "right", "side", "of", "the", "keyboard", ".", "1", "=", "Left", "2", "=", "Right", "(", "default", ":", "0", ")", "." ]

[ "func", "(", "p", "DispatchKeyEventParams", ")", "WithLocation", "(", "location", "int64", ")", "*", "DispatchKeyEventParams", "{", "p", ".", "<mask>", "=", "location", "\n", "return", "&", "p", "\n", "}" ]

[ "deleteTables", "remove", "tables", "idx0", "...", "idx1", "-", "1", "." ]

[ "func", "(", "s", "*", "levelHandler", ")", "deleteTables", "(", "toDel", "[", "]", "*", "table", ".", "Table", ")", "error", "{", "s", ".", "Lock", "(", ")", "// s.Unlock() below", "\n\n", "toDelMap", ":=", "make", "(", "map", "[", "uint64", "]", "struct", "{", "}", ")", "\n", "for", "_", ",", "t", ":=", "range", "toDel", "{", "toDelMap", "[", "t", ".", "ID", "(", ")", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "// Make a copy as iterators might be keeping a slice of tables.", "var", "newTables", "[", "]", "*", "table", ".", "Table", "\n", "for", "_", ",", "t", ":=", "<mask>", "s", ".", "tables", "{", "_", ",", "found", ":=", "toDelMap", "[", "t", ".", "ID", "(", ")", "]", "\n", "if", "!", "found", "{", "newTables", "=", "append", "(", "newTables", ",", "t", ")", "\n", "continue", "\n", "}", "\n", "s", ".", "totalSize", "-=", "t", ".", "Size", "(", ")", "\n", "}", "\n", "s", ".", "tables", "=", "newTables", "\n\n", "s", ".", "Unlock", "(", ")", "// Unlock s _before_ we DecrRef our tables, which can be slow.", "\n\n", "return", "decrRefs", "(", "toDel", ")", "\n", "}" ]

[ "GetDescription", "returns", "the", "Description", "field", "if", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "d", "*", "DashboardLite", ")", "GetDescription", "(", ")", "string", "{", "if", "d", "==", "nil", "||", "d", ".", "<mask>", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "d", ".", "Description", "\n", "}" ]

[ "===", "changes", "(", "Matrix", "ValueTypeMatrix", ")", "Vector", "===" ]

[ "func", "funcChanges", "(", "vals", "[", "]", "Value", ",", "args", "Expressions", ",", "enh", "*", "EvalNodeHelper", ")", "Vector", "{", "in", ":=", "vals", "[", "0", "]", ".", "(", "Matrix", ")", "\n\n", "for", "_", ",", "samples", ":=", "range", "in", "{", "changes", ":=", "0", "\n", "prev", ":=", "samples", ".", "Points", "[", "0", "]", ".", "V", "\n", "for", "_", ",", "sample", ":=", "range", "samples", ".", "Points", "[", "1", ":", "]", "{", "current", ":=", "sample", ".", "V", "\n", "if", "current", "!=", "prev", "&&", "!", "(", "math", ".", "IsNaN", "(", "<mask>", ")", "&&", "math", ".", "IsNaN", "(", "prev", ")", ")", "{", "changes", "++", "\n", "}", "\n", "prev", "=", "current", "\n", "}", "\n\n", "enh", ".", "out", "=", "append", "(", "enh", ".", "out", ",", "Sample", "{", "Point", ":", "Point", "{", "V", ":", "float64", "(", "changes", ")", "}", ",", "}", ")", "\n", "}", "\n", "return", "enh", ".", "out", "\n", "}" ]

[ "Color", "will", "set", "the", "struct", "field", "for", "the", "given", "color", "to", "be", "used" ]

[ "func", "(", "s", "*", "Spinner", ")", "Color", "(", "colors", "...", "string", ")", "error", "{", "colorAttributes", ":=", "make", "(", "[", "]", "<mask>", ".", "Attribute", ",", "len", "(", "colors", ")", ")", "\n\n", "// Verify colours are valid and place the appropriate attribute in the array", "for", "index", ",", "c", ":=", "range", "colors", "{", "if", "!", "validColor", "(", "c", ")", "{", "return", "errInvalidColor", "\n", "}", "\n\n", "colorAttributes", "[", "index", "]", "=", "colorAttributeMap", "[", "c", "]", "\n", "}", "\n\n", "s", ".", "lock", ".", "Lock", "(", ")", "\n", "s", ".", "color", "=", "color", ".", "New", "(", "colorAttributes", "...", ")", ".", "SprintFunc", "(", ")", "\n", "s", ".", "lock", ".", "Unlock", "(", ")", "\n", "s", ".", "Restart", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Stability", ":", "***", "EXPERIMENTAL", "***", "For", "a", "given", "Issue", "or", "Pull", "Request", "of", "a", "repository", "this", "will", "write", "a", "new", "message", ".", "Required", "scopes", ":", "github", ":", "create", "-", "comment", ":", "<owner", ">", "/", "<repo", ">", "See", "#createComment" ]

[ "func", "(", "github", "*", "Github", ")", "CreateComment", "(", "owner", ",", "repo", ",", "number", "string", ",", "payload", "*", "CreateCommentRequest", ")", "error", "{", "cd", ":=", "tcclient", ".", "Client", "(", "*", "github", ")", "\n", "_", ",", "_", ",", "err", ":=", "(", "&", "<mask>", ")", ".", "APICall", "(", "payload", ",", "\"", "\"", ",", "\"", "\"", "+", "url", ".", "QueryEscape", "(", "owner", ")", "+", "\"", "\"", "+", "url", ".", "QueryEscape", "(", "repo", ")", "+", "\"", "\"", "+", "url", ".", "QueryEscape", "(", "number", ")", "+", "\"", "\"", ",", "nil", ",", "nil", ")", "\n", "return", "err", "\n", "}" ]

[ "GetVisibility", "()", "is", "a", "wrapper", "around", "gtk_entry_get_visibility", "()", "." ]

[ "func", "(", "v", "*", "<mask>", ")", "GetVisibility", "(", ")", "bool", "{", "c", ":=", "C", ".", "gtk_entry_get_visibility", "(", "v", ".", "native", "(", ")", ")", "\n", "return", "gobool", "(", "c", ")", "\n", "}" ]

[ "init", "filelogger", "split", "by", "fileSize" ]

[ "func", "(", "f", "*", "FileLogger", ")", "initLoggerBySize", "(", ")", "{", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "f", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "logFile", ":=", "joinFilePath", "(", "f", ".", "fileDir", ",", "f", ".", "fileName", ")", "\n", "for", "i", ":=", "1", ";", "i", "<=", "f", ".", "fileCount", ";", "i", "++", "{", "if", "!", "isExist", "(", "logFile", "+", "\"", "\"", "+", "strconv", ".", "Itoa", "(", "i", ")", ")", "{", "break", "\n", "}", "\n\n", "f", ".", "suffix", "=", "i", "\n", "}", "\n\n", "if", "!", "f", ".", "isMustSplit", "(", ")", "{", "if", "!", "isExist", "(", "f", ".", "fileDir", ")", "{", "os", ".", "Mkdir", "(", "f", ".", "fileDir", ",", "0755", ")", "\n", "}", "\n", "f", ".", "logFile", ",", "_", "=", "os", ".", "OpenFile", "(", "logFile", ",", "os", ".", "O_RDWR", "|", "os", ".", "O_APPEND", "|", "os", ".", "O_CREATE", ",", "0666", ")", "\n", "f", ".", "lg", "=", "log", ".", "New", "(", "f", ".", "logFile", ",", "f", ".", "prefix", ",", "log", ".", "LstdFlags", "|", "<mask>", ".", "Lmicroseconds", ")", "\n", "}", "else", "{", "f", ".", "split", "(", ")", "\n", "}", "\n\n", "go", "f", ".", "logWriter", "(", ")", "\n", "go", "f", ".", "fileMonitor", "(", ")", "\n", "}" ]

[ "pointer", ":", "append", "multiLineOptions", "itself" ]

[ "func", "(", "o", "*", "multiLineOptions", ")", "read", "(", "rd", "*", "bufio", ".", "Reader", ",", "lineCnt", "int", ")", "{", "for", "i", ":=", "0", ";", "i", "<", "lineCnt", ";", "i", "++", "{", "m", ":=", "plainOptions", "{", "}", "\n", "cnt", ":=", "rd", ".", "ReadInt16", "(", ")", "\n", "m", ".", "<mask>", "(", "rd", ",", "int", "(", "cnt", ")", ")", "\n", "*", "o", "=", "append", "(", "*", "o", ",", "m", ")", "\n", "}", "\n", "}" ]

[ "New", "creates", "a", "new", "etcdv3", "client", "from", "a", "given", "configuration", "." ]

[ "func", "New", "(", "cfg", "Config", ")", "(", "*", "<mask>", ",", "error", ")", "{", "if", "len", "(", "cfg", ".", "Endpoints", ")", "==", "0", "{", "return", "nil", ",", "ErrNoAvailableEndpoints", "\n", "}", "\n\n", "return", "newClient", "(", "&", "cfg", ")", "\n", "}" ]

[ "CompareKV", "is", "a", "comparator", "for", "KV", "item" ]

[ "func", "CompareKV", "(", "a", "[", "]", "<mask>", ",", "b", "[", "]", "byte", ")", "int", "{", "la", ":=", "int", "(", "binary", ".", "LittleEndian", ".", "Uint16", "(", "a", "[", "0", ":", "2", "]", ")", ")", "\n", "lb", ":=", "int", "(", "binary", ".", "LittleEndian", ".", "Uint16", "(", "b", "[", "0", ":", "2", "]", ")", ")", "\n\n", "return", "bytes", ".", "Compare", "(", "a", "[", "2", ":", "2", "+", "la", "]", ",", "b", "[", "2", ":", "2", "+", "lb", "]", ")", "\n", "}" ]

[ "GetCurrent", "is", "a", "wrapper", "around", "gdk_gl_context_get_current", "()", "." ]

[ "func", "GetCurrent", "(", ")", "(", "*", "GLContext", ",", "<mask>", ")", "{", "c", ":=", "C", ".", "gdk_gl_context_get_current", "(", ")", "\n", "if", "c", "==", "nil", "{", "return", "nil", ",", "nilPtrErr", "\n", "}", "\n\n", "return", "&", "GLContext", "{", "glib", ".", "Take", "(", "unsafe", ".", "Pointer", "(", "c", ")", ")", "}", ",", "nil", "\n", "}" ]

[ "Handle", "calls", "f", "(", "ctx", "call", ")" ]

[ "func", "(", "f", "ErrorHandlerFunc", ")", "Handle", "(", "ctx", "context", ".", "Context", ",", "call", "*", "InboundCall", ")", "{", "if", "err", ":=", "f", "(", "ctx", ",", "call", ")", ";", "err", "!=", "nil", "{", "if", "GetSystemErrorCode", "(", "err", ")", "==", "ErrCodeUnexpected", "{", "call", ".", "log", ".", "WithFields", "(", "f", ".", "getLogFields", "(", ")", "...", ")", ".", "WithFields", "(", "ErrField", "(", "err", ")", ")", ".", "<mask>", "(", "\"", "\"", ")", "\n", "}", "\n", "call", ".", "Response", "(", ")", ".", "SendSystemError", "(", "err", ")", "\n", "}", "\n", "}" ]

[ "String", "returns", "the", "name", "of", "e" ]

[ "func", "(", "e", "ThresholdIndexes", ")", "<mask>", "(", ")", "string", "{", "name", ",", "_", ":=", "thresholdIndexesMap", "[", "int32", "(", "e", ")", "]", "\n", "return", "name", "\n", "}" ]

[ "UnmarshalJSON", "supports", "json", ".", "Unmarshaler", "interface" ]

[ "func", "(", "v", "*", "SetTouchEmulationEnabledParams", ")", "UnmarshalJSON", "(", "data", "[", "]", "byte", ")", "error", "{", "r", ":=", "jlexer", ".", "Lexer", "{", "Data", ":", "<mask>", "}", "\n", "easyjsonC5a4559bDecodeGithubComChromedpCdprotoEmulation3", "(", "&", "r", ",", "v", ")", "\n", "return", "r", ".", "Error", "(", ")", "\n", "}" ]

[ "GetEnableLogsSampleOk", "returns", "a", "tuple", "with", "the", "EnableLogsSample", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "and", "a", "boolean", "to", "check", "if", "the", "value", "has", "been", "set", "." ]

[ "func", "(", "o", "*", "Options", ")", "GetEnableLogsSampleOk", "(", ")", "(", "bool", ",", "bool", ")", "{", "if", "o", "==", "nil", "||", "o", ".", "EnableLogsSample", "==", "nil", "{", "return", "false", ",", "<mask>", "\n", "}", "\n", "return", "*", "o", ".", "EnableLogsSample", ",", "true", "\n", "}" ]

[ "New", "http", ".", "StatusInternalServerError" ]

[ "func", "(", "e", "*", "BusinessError", ")", "New", "(", "errno", "int", ",", "message", "string", ")", "*", "BusinessError", "{", "e", ".", "HTTPCode", "=", "<mask>", ".", "StatusBadRequest", "\n", "e", ".", "Errno", "=", "errno", "\n", "e", ".", "Message", "=", "message", "\n", "return", "e", "\n", "}" ]

[ "Stop", "-", "signal", "for", "the", "service", "to", "stop", "serving" ]

[ "func", "(", "client", "*", "<mask>", ")", "Stop", "(", ")", "{", "service", ":=", "client", ".", "service", "\n", "if", "service", ".", "started", "{", "service", ".", "wg", ".", "Done", "(", ")", "\n", "service", ".", "started", "=", "false", "\n", "}", "\n", "}" ]

[ "Infof", "logs", "a", "message", "using", "INFO", "as", "log", "level", "." ]

[ "func", "(", "l", "*", "Logger", ")", "Infof", "(", "<mask>", "string", ",", "args", "...", "interface", "{", "}", ")", "{", "l", ".", "log", "(", "INFO", ",", "&", "format", ",", "args", "...", ")", "\n", "}" ]

[ "indexExists", "checks", "whether", "the", "index", "location", "specified", "in", "the", "OCI", "reference", "exists", ".", "The", "implementation", "is", "opinionated", "since", "in", "case", "of", "unexpected", "errors", "false", "is", "returned" ]

[ "func", "indexExists", "(", "<mask>", "ociReference", ")", "bool", "{", "_", ",", "err", ":=", "os", ".", "Stat", "(", "ref", ".", "indexPath", "(", ")", ")", "\n", "if", "err", "==", "nil", "{", "return", "true", "\n", "}", "\n", "if", "os", ".", "IsNotExist", "(", "err", ")", "{", "return", "false", "\n", "}", "\n", "return", "true", "\n", "}" ]

[ "SetReview", "writes", "a", "review", "comment", "base", "on", "the", "change", "id", "+", "revision" ]

[ "func", "(", "c", "*", "<mask>", ")", "SetReview", "(", "instance", ",", "id", ",", "revision", ",", "message", "string", ",", "labels", "map", "[", "string", "]", "string", ")", "error", "{", "h", ",", "ok", ":=", "c", ".", "handlers", "[", "instance", "]", "\n", "if", "!", "ok", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "instance", ")", "\n", "}", "\n\n", "if", "_", ",", "_", ",", "err", ":=", "h", ".", "changeService", ".", "SetReview", "(", "id", ",", "revision", ",", "&", "gerrit", ".", "ReviewInput", "{", "Message", ":", "message", ",", "Labels", ":", "labels", ",", "}", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "validate", "performs", "validation", "and", "only", "sends", "the", "message", "if", "all", "validators", "succeed" ]

[ "func", "(", "p", "*", "PubSub", ")", "validate", "(", "vals", "[", "]", "*", "topicVal", ",", "src", "peer", ".", "ID", ",", "msg", "*", "Message", ")", "{", "if", "msg", ".", "Signature", "!=", "nil", "{", "if", "!", "p", ".", "validateSignature", "(", "msg", ")", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "src", ")", "\n", "return", "\n", "}", "\n", "}", "\n\n", "if", "len", "(", "vals", ")", ">", "0", "{", "if", "!", "p", ".", "validateTopic", "(", "vals", ",", "src", ",", "msg", ")", "{", "log", ".", "Warningf", "(", "\"", "\"", ",", "src", ")", "\n", "return", "\n", "}", "\n", "}", "\n\n", "// all validators were successful, send the message", "p", ".", "sendMsg", "<-", "&", "sendReq", "{", "from", ":", "src", ",", "<mask>", ":", "msg", ",", "}", "\n", "}" ]

[ "Description", "tries", "as", "hard", "as", "possible", "to", "give", "you", "a", "one", "sentence", "description", "of", "this", "Alert", "based", "on", "its", "contents", ".", "Description", "does", "not", "include", "a", "trailing", "period", "." ]

[ "func", "(", "a", "*", "Alert", ")", "<mask>", "(", ")", "string", "{", "return", "capitalize", "(", "strings", ".", "TrimSpace", "(", "strings", ".", "TrimSuffix", "(", "a", ".", "description", "(", ")", ",", "\"", "\"", ")", ")", ")", "\n", "}" ]

[ "NewReader", "-", "get", "a", "new", "s3", "reader" ]

[ "func", "(", "s", "*", "S3Bucket", ")", "NewReader", "(", "<mask>", "string", ")", "(", "io", ".", "ReadCloser", ",", "error", ")", "{", "r", ",", "_", ",", "err", ":=", "s", ".", "bucket", ".", "GetReader", "(", "path", ",", "nil", ")", "\n", "return", "r", ",", "err", "\n", "}" ]

[ "findChanges", "compares", "the", "newList", "of", "coverage", "against", "the", "base", "list", "and", "returns", "the", "result" ]

[ "func", "findChanges", "(", "baseList", "*", "calculation", ".", "CoverageList", ",", "newList", "*", "calculation", ".", "CoverageList", ")", "[", "]", "*", "coverageChange", "{", "var", "<mask>", "[", "]", "*", "coverageChange", "\n", "baseFilesMap", ":=", "toMap", "(", "baseList", ")", "\n", "for", "_", ",", "newCov", ":=", "range", "newList", ".", "Group", "{", "baseCov", ",", "ok", ":=", "baseFilesMap", "[", "newCov", ".", "Name", "]", "\n", "var", "baseRatio", "float32", "\n", "if", "!", "ok", "{", "baseRatio", "=", "-", "1", "\n", "}", "else", "{", "baseRatio", "=", "baseCov", ".", "Ratio", "(", ")", "\n", "}", "\n", "newRatio", ":=", "newCov", ".", "Ratio", "(", ")", "\n", "if", "isChangeSignificant", "(", "baseRatio", ",", "newRatio", ")", "{", "changes", "=", "append", "(", "changes", ",", "&", "coverageChange", "{", "name", ":", "newCov", ".", "Name", ",", "baseRatio", ":", "baseRatio", ",", "newRatio", ":", "newRatio", ",", "}", ")", "\n", "}", "\n", "}", "\n", "return", "changes", "\n", "}" ]

[ "RegisterInjector", "registers", "injector", "for", "given", "format" ]

[ "func", "(", "t", "*", "MockTracer", ")", "RegisterInjector", "(", "format", "<mask>", "{", "}", ",", "injector", "Injector", ")", "{", "t", ".", "injectors", "[", "format", "]", "=", "injector", "\n", "}" ]

[ "Options", "registers", "handlers", "with", "the", "given", "pattern", "for", "OPTIONS", "method" ]

[ "func", "(", "r", "*", "<mask>", ")", "Options", "(", "pat", "string", ",", "f", "...", "HandlerFunc", ")", "{", "r", ".", "HandleMethod", "(", "pat", ",", "\"", "\"", ",", "f", "...", ")", "\n", "}" ]

[ "Create", "the", "device", "nodes", "in", "the", "container", "." ]

[ "func", "createDevices", "(", "config", "*", "configs", ".", "Config", ")", "error", "{", "oldMask", ":=", "syscall", ".", "Umask", "(", "0000", ")", "\n", "for", "_", ",", "<mask>", ":=", "range", "config", ".", "Devices", "{", "// containers running in a user namespace are not allowed to mknod", "// devices so we can just bind mount it from the host.", "if", "err", ":=", "createDeviceNode", "(", "config", ".", "Rootfs", ",", "node", ",", "config", ".", "Namespaces", ".", "Contains", "(", "configs", ".", "NEWUSER", ")", ")", ";", "err", "!=", "nil", "{", "syscall", ".", "Umask", "(", "oldMask", ")", "\n", "return", "err", "\n", "}", "\n", "}", "\n", "syscall", ".", "Umask", "(", "oldMask", ")", "\n", "return", "nil", "\n", "}" ]

[ "Issues", "is", "the", "main", "work", "method", "of", "FlakyJobReporter", ".", "It", "fetches", "and", "parses", "flaky", "job", "data", "then", "syncs", "the", "top", "issues", "to", "github", "with", "the", "IssueCreator", "." ]

[ "func", "(", "fjr", "*", "FlakyJobReporter", ")", "Issues", "(", "c", "*", "<mask>", ".", "IssueCreator", ")", "(", "[", "]", "creator", ".", "Issue", ",", "error", ")", "{", "fjr", ".", "creator", "=", "c", "\n", "json", ",", "err", ":=", "ReadHTTP", "(", "fjr", ".", "flakyJobDataURL", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "flakyJobs", ",", "err", ":=", "fjr", ".", "parseFlakyJobs", "(", "json", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "count", ":=", "fjr", ".", "syncCount", "\n", "if", "len", "(", "flakyJobs", ")", "<", "count", "{", "count", "=", "len", "(", "flakyJobs", ")", "\n", "}", "\n", "issues", ":=", "make", "(", "[", "]", "creator", ".", "Issue", ",", "0", ",", "count", ")", "\n", "for", "_", ",", "fj", ":=", "range", "flakyJobs", "[", "0", ":", "count", "]", "{", "issues", "=", "append", "(", "issues", ",", "fj", ")", "\n", "}", "\n\n", "return", "issues", ",", "nil", "\n", "}" ]

[ "ColorToString", "returns", "string", "representation", "of", "the", "attribute" ]

[ "func", "ColorToString", "(", "attr", "term", ".", "Attribute", ")", "string", "{", "var", "out", "string", "\n\n", "rawClr", ":=", "attr", "&", "15", "\n", "if", "rawClr", "<", "8", "{", "for", "k", ",", "v", ":=", "range", "colorMap", "{", "if", "v", "==", "rawClr", "{", "out", "+=", "k", "+", "\"", "\"", "\n", "break", "\n", "}", "\n", "}", "\n", "}", "\n\n", "if", "attr", "&", "term", ".", "AttrBold", "!=", "0", "{", "out", "+=", "\"", "\"", "\n", "}", "\n", "if", "attr", "&", "<mask>", ".", "AttrUnderline", "!=", "0", "{", "out", "+=", "\"", "\"", "\n", "}", "\n", "if", "attr", "&", "term", ".", "AttrReverse", "!=", "0", "{", "out", "+=", "\"", "\"", "\n", "}", "\n\n", "return", "strings", ".", "TrimSpace", "(", "out", ")", "\n", "}" ]

[ "GetName", "returns", "the", "Name", "field", "if", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "l", "*", "LogSet", ")", "GetName", "(", ")", "string", "{", "if", "l", "==", "nil", "||", "l", ".", "<mask>", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "l", ".", "Name", "\n", "}" ]

[ "FormatICResponse", "nicely", "formats", "a", "response", "to", "an", "issue", "comment", "." ]

[ "func", "FormatICResponse", "(", "ic", "github", ".", "IssueComment", ",", "s", "string", ")", "string", "{", "return", "FormatResponseRaw", "(", "<mask>", ".", "Body", ",", "ic", ".", "HTMLURL", ",", "ic", ".", "User", ".", "Login", ",", "s", ")", "\n", "}" ]

[ "copyWithoutSnapshotsFull", "creates", "a", "non", "-", "sparse", "copy", "of", "a", "container", "This", "does", "not", "introduce", "a", "dependency", "relation", "between", "the", "source", "RBD", "storage", "volume", "and", "the", "target", "RBD", "storage", "volume", "." ]

[ "func", "(", "s", "*", "storageCeph", ")", "copyWithoutSnapshotsFull", "(", "target", "container", ",", "source", "container", ")", "error", "{", "logger", ".", "Debugf", "(", "`Creating non-sparse copy of RBD storage volume for container \"%s\" to \"%s\" without snapshots`", ",", "source", ".", "Name", "(", ")", ",", "target", ".", "Name", "(", ")", ")", "\n\n", "sourceIsSnapshot", ":=", "source", ".", "IsSnapshot", "(", ")", "\n", "sourceContainerName", ":=", "projectPrefix", "(", "source", ".", "Project", "(", ")", ",", "source", ".", "Name", "(", ")", ")", "\n", "targetContainerName", ":=", "projectPrefix", "(", "target", ".", "Project", "(", ")", ",", "target", ".", "Name", "(", ")", ")", "\n", "oldVolumeName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "OSDPoolName", ",", "sourceContainerName", ")", "\n", "newVolumeName", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "OSDPoolName", ",", "targetContainerName", ")", "\n", "if", "sourceIsSnapshot", "{", "sourceContainerOnlyName", ",", "sourceSnapshotOnlyName", ",", "_", ":=", "containerGetParentAndSnapshotName", "(", "sourceContainerName", ")", "\n", "oldVolumeName", "=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "s", ".", "OSDPoolName", ",", "sourceContainerOnlyName", ",", "sourceSnapshotOnlyName", ")", "\n", "}", "\n\n", "err", ":=", "cephRBDVolumeCopy", "(", "s", ".", "ClusterName", ",", "oldVolumeName", ",", "newVolumeName", ",", "s", ".", "UserName", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Debugf", "(", "`Failed to create full RBD copy \"%s\" to \"%s\": %s`", ",", "source", ".", "Name", "(", ")", ",", "target", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "cephRBDVolumeMap", "(", "s", ".", "ClusterName", ",", "s", ".", "OSDPoolName", ",", "targetContainerName", ",", "storagePoolVolumeTypeNameContainer", ",", "s", ".", "UserName", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "`Failed to map RBD storage volume for image \"%s\" on storage pool \"%s\": %s`", ",", "targetContainerName", ",", "s", ".", "pool", ".", "Name", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n\n", "targetContainerMountPoint", ":=", "getContainerMountPoint", "(", "<mask>", ".", "Project", "(", ")", ",", "s", ".", "pool", ".", "Name", ",", "target", ".", "Name", "(", ")", ")", "\n", "err", "=", "createContainerMountpoint", "(", "targetContainerMountPoint", ",", "target", ".", "Path", "(", ")", ",", "target", ".", "IsPrivileged", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "ourMount", ",", "err", ":=", "target", ".", "StorageStart", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "ourMount", "{", "defer", "target", ".", "StorageStop", "(", ")", "\n", "}", "\n\n", "err", "=", "target", ".", "TemplateApply", "(", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Errorf", "(", "`Failed to apply copy template for container \"%s\": %s`", ",", "target", ".", "Name", "(", ")", ",", "err", ")", "\n", "return", "err", "\n", "}", "\n", "logger", ".", "Debugf", "(", "`Applied copy template for container \"%s\"`", ",", "target", ".", "Name", "(", ")", ")", "\n\n", "logger", ".", "Debugf", "(", "`Created non-sparse copy of RBD storage volume for container \"%s\" to \"%s\" without snapshots`", ",", "source", ".", "Name", "(", ")", ",", "target", ".", "Name", "(", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "Push", "header", "and", "body", "to", "stack", ".", "Returns", "new", "value", "of", "stack", "depth" ]

[ "func", "(", "s", "*", "Stack", ")", "Push", "(", "header", ",", "data", "[", "]", "byte", ")", "(", "depth", "int", ",", "err", "error", ")", "{", "s", ".", "guard", ".", "Lock", "(", ")", "\n", "defer", "s", ".", "guard", ".", "Unlock", "(", ")", "\n", "s", ".", "lastAccess", "=", "time", ".", "Now", "(", ")", "\n", "file", ",", "err", ":=", "s", ".", "getFile", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n", "// Seek to place for next block", "currentOffset", ",", "err", ":=", "file", ".", "Seek", "(", "s", ".", "currentBlock", ".", "NextBlockPoint", "(", ")", ",", "os", ".", "SEEK_SET", ")", "\n", "if", "err", "!=", "nil", "{", "return", "-", "1", ",", "err", "\n", "}", "\n", "// Get place for payload", "bodyOffset", ":=", "currentOffset", "+", "fileBlockDefineSize", "\n", "block", ":=", "fileBlock", "{", "PrevBlock", ":", "uint64", "(", "s", ".", "currentBlockPos", ")", ",", "HeaderPoint", ":", "uint64", "(", "bodyOffset", ")", ",", "HeaderSize", ":", "uint64", "(", "len", "(", "header", ")", ")", ",", "DataPoint", ":", "uint64", "(", "bodyOffset", ")", "+", "uint64", "(", "len", "(", "header", ")", ")", ",", "DataSize", ":", "uint64", "(", "len", "(", "data", ")", ")", ",", "}", "\n", "// Write block meta-info", "err", "=", "binary", ".", "Write", "(", "<mask>", ",", "binary", ".", "LittleEndian", ",", "block", ")", "\n", "if", "err", "!=", "nil", "{", "file", ".", "Seek", "(", "currentOffset", ",", "os", ".", "SEEK_SET", ")", "\n", "return", "-", "1", ",", "err", "\n", "}", "\n", "// Write header", "_", ",", "err", "=", "file", ".", "Write", "(", "header", ")", "\n", "if", "err", "!=", "nil", "{", "file", ".", "Seek", "(", "currentOffset", ",", "os", ".", "SEEK_SET", ")", "\n", "return", "-", "1", ",", "err", "\n", "}", "\n", "// Write data", "_", ",", "err", "=", "file", ".", "Write", "(", "data", ")", "\n", "if", "err", "!=", "nil", "{", "file", ".", "Seek", "(", "currentOffset", ",", "os", ".", "SEEK_SET", ")", "\n", "return", "-", "1", ",", "err", "\n", "}", "\n", "s", ".", "depth", "++", "\n", "s", ".", "currentBlockPos", "=", "currentOffset", "\n", "s", ".", "currentBlock", "=", "block", "\n", "return", "s", ".", "depth", ",", "nil", "\n", "}" ]

[ "Attempted", "returns", "the", "number", "of", "attempted", "requests", "for", "an", "id", "in", "the", "current", "period", ".", "Attempted", "does", "not", "count", "attempts", "that", "exceed", "the", "max", "requests", "in", "an", "interval", "and", "only", "returns", "the", "max", "count", "after", "this", "is", "reached", "." ]

[ "func", "(", "r", "*", "RateLimiter", ")", "Attempted", "(", "id", "string", ")", "(", "int64", ",", "error", ")", "{", "hash", ":=", "r", ".", "hasher", ".", "Hash", "(", "<mask>", ")", "\n", "val", ",", "err", ":=", "r", ".", "redisClient", ".", "Get", "(", "hash", ")", ".", "Result", "(", ")", "\n\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "redis", ".", "Nil", "{", "// Key does not exist. See: http://redis.io/commands/GET", "return", "0", ",", "nil", "\n", "}", "\n", "return", "0", ",", "err", "\n", "}", "\n\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "return", "strconv", ".", "ParseInt", "(", "val", ",", "10", ",", "64", ")", "\n", "}" ]

[ "newManagedTask", "is", "a", "method", "on", "DockerTaskEngine", "to", "create", "a", "new", "managedTask", ".", "This", "method", "must", "only", "be", "called", "when", "the", "engine", ".", "processTasks", "write", "lock", "is", "already", "held", "." ]

[ "func", "(", "engine", "*", "DockerTaskEngine", ")", "newManagedTask", "(", "task", "*", "apitask", ".", "Task", ")", "*", "managedTask", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "engine", ".", "ctx", ")", "\n", "t", ":=", "&", "managedTask", "{", "ctx", ":", "ctx", ",", "cancel", ":", "cancel", ",", "Task", ":", "task", ",", "acsMessages", ":", "make", "(", "chan", "acsTransition", ")", ",", "dockerMessages", ":", "make", "(", "chan", "dockerContainerChange", ")", ",", "resourceStateChangeEvent", ":", "make", "(", "chan", "resourceStateChange", ")", ",", "engine", ":", "engine", ",", "cfg", ":", "<mask>", ".", "cfg", ",", "stateChangeEvents", ":", "engine", ".", "stateChangeEvents", ",", "containerChangeEventStream", ":", "engine", ".", "containerChangeEventStream", ",", "saver", ":", "engine", ".", "saver", ",", "credentialsManager", ":", "engine", ".", "credentialsManager", ",", "cniClient", ":", "engine", ".", "cniClient", ",", "taskStopWG", ":", "engine", ".", "taskStopGroup", ",", "steadyStatePollInterval", ":", "engine", ".", "taskSteadyStatePollInterval", ",", "}", "\n", "engine", ".", "managedTasks", "[", "task", ".", "Arn", "]", "=", "t", "\n", "return", "t", "\n", "}" ]

[ "Factory", "is", "the", "function", "that", "the", "Pachyderm", "Vault", "plugin", "exports", "to", "let", "Vault", "create", "/", "refresh", "/", "revoke", "Pachyderm", "tokens" ]

[ "func", "Factory", "(", "ctx", "context", ".", "Context", ",", "c", "*", "logical", ".", "BackendConfig", ")", "(", "logical", ".", "Backend", ",", "error", ")", "{", "result", ":=", "&", "backend", "{", "}", "\n", "result", ".", "Backend", "=", "&", "framework", ".", "Backend", "{", "BackendType", ":", "logical", ".", "TypeLogical", ",", "PathsSpecial", ":", "&", "logical", ".", "Paths", "{", "Unauthenticated", ":", "[", "]", "string", "{", "\"", "\"", "}", ",", "}", ",", "Paths", ":", "[", "]", "*", "framework", ".", "Path", "{", "result", ".", "configPath", "(", ")", ",", "result", ".", "loginPath", "(", ")", ",", "result", ".", "versionPath", "(", ")", ",", "}", ",", "Secrets", ":", "[", "]", "*", "framework", ".", "Secret", "{", "{", "Type", ":", "\"", "\"", ",", "Fields", ":", "map", "[", "string", "]", "*", "framework", ".", "FieldSchema", "{", "\"", "\"", ":", "&", "framework", ".", "FieldSchema", "{", "<mask>", ":", "framework", ".", "TypeString", ",", "Description", ":", "\"", "\"", ",", "}", ",", "}", ",", "Renew", ":", "result", ".", "Renew", ",", "Revoke", ":", "result", ".", "Revoke", ",", "}", "}", ",", "}", "\n", "if", "err", ":=", "result", ".", "Setup", "(", "ctx", ",", "c", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "result", ",", "nil", "\n", "}" ]

[ "Update", "update", "rate", "value", "based", "on", "the", "stored", "previous", "value", "." ]

[ "func", "(", "d", "*", "Derive", ")", "Update", "(", "v", "float64", ")", "{", "p", ":=", "atomic", ".", "SwapUint64", "(", "&", "d", ".", "<mask>", ",", "math", ".", "Float64bits", "(", "v", ")", ")", "\n", "d", ".", "rate", ".", "Update", "(", "v", "-", "math", ".", "Float64frombits", "(", "p", ")", ")", "\n", "}" ]

[ "ListNames", "returns", "a", "list", "of", "non", "deprecated", "transport", "names", ".", "Deprecated", "transports", "can", "be", "used", "but", "are", "not", "presented", "to", "users", "." ]

[ "func", "ListNames", "(", ")", "[", "]", "string", "{", "kt", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "kt", ".", "mu", ".", "Unlock", "(", ")", "\n", "deprecated", ":=", "map", "[", "string", "]", "bool", "{", "\"", "\"", ":", "<mask>", ",", "}", "\n", "var", "names", "[", "]", "string", "\n", "for", "_", ",", "transport", ":=", "range", "kt", ".", "transports", "{", "if", "!", "deprecated", "[", "transport", ".", "Name", "(", ")", "]", "{", "names", "=", "append", "(", "names", ",", "transport", ".", "Name", "(", ")", ")", "\n", "}", "\n", "}", "\n", "sort", ".", "Strings", "(", "names", ")", "\n", "return", "names", "\n", "}" ]

[ "increaseUncommittedSize", "computes", "the", "size", "of", "the", "proposed", "entries", "and", "determines", "whether", "they", "would", "push", "leader", "over", "its", "maxUncommittedSize", "limit", ".", "If", "the", "new", "entries", "would", "exceed", "the", "limit", "the", "method", "returns", "false", ".", "If", "not", "the", "increase", "in", "uncommitted", "entry", "size", "is", "recorded", "and", "the", "method", "returns", "true", "." ]

[ "func", "(", "r", "*", "raft", ")", "increaseUncommittedSize", "(", "ents", "[", "]", "pb", ".", "<mask>", ")", "bool", "{", "var", "s", "uint64", "\n", "for", "_", ",", "e", ":=", "range", "ents", "{", "s", "+=", "uint64", "(", "PayloadSize", "(", "e", ")", ")", "\n", "}", "\n\n", "if", "r", ".", "uncommittedSize", ">", "0", "&&", "r", ".", "uncommittedSize", "+", "s", ">", "r", ".", "maxUncommittedSize", "{", "// If the uncommitted tail of the Raft log is empty, allow any size", "// proposal. Otherwise, limit the size of the uncommitted tail of the", "// log and drop any proposal that would push the size over the limit.", "return", "false", "\n", "}", "\n", "r", ".", "uncommittedSize", "+=", "s", "\n", "return", "true", "\n", "}" ]

[ "TypeString", "returns", "the", "g", "variant", "type", "string", "for", "this", "variant", "." ]

[ "func", "(", "v", "*", "Variant", ")", "TypeString", "(", ")", "string", "{", "// the string returned from this belongs to GVariant and must not be freed.", "return", "C", ".", "GoString", "(", "(", "*", "C", ".", "<mask>", ")", "(", "C", ".", "g_variant_get_type_string", "(", "v", ".", "native", "(", ")", ")", ")", ")", "\n", "}" ]

[ "Return", "a", "new", "cache", "with", "a", "given", "default", "expiration", "duration", "and", "cleanup", "interval", ".", "If", "the", "expiration", "duration", "is", "less", "than", "one", "(", "or", "NoExpiration", ")", "the", "items", "in", "the", "cache", "never", "expire", "(", "by", "default", ")", "and", "must", "be", "deleted", "manually", ".", "If", "the", "cleanup", "interval", "is", "less", "than", "one", "expired", "items", "are", "not", "deleted", "from", "the", "cache", "before", "calling", "c", ".", "DeleteExpired", "()", "." ]

[ "func", "New", "(", "defaultExpiration", ",", "cleanupInterval", "time", ".", "Duration", ")", "*", "Cache", "{", "items", ":=", "<mask>", "(", "map", "[", "string", "]", "Item", ")", "\n", "return", "newCacheWithJanitor", "(", "defaultExpiration", ",", "cleanupInterval", ",", "items", ")", "\n", "}" ]

[ "GetStyleProperty", "is", "a", "wrapper", "around", "gtk_style_context_get_style_property", "()", "." ]

[ "func", "(", "v", "*", "StyleContext", ")", "GetStyleProperty", "(", "property", "string", ")", "(", "interface", "{", "}", ",", "error", ")", "{", "cstr", ":=", "(", "*", "C", ".", "gchar", ")", "(", "C", ".", "CString", "(", "property", ")", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cstr", ")", ")", "\n\n", "<mask>", "gval", "C", ".", "GValue", "\n", "C", ".", "gtk_style_context_get_style_property", "(", "v", ".", "native", "(", ")", ",", "cstr", ",", "&", "gval", ")", "\n", "val", ":=", "glib", ".", "ValueFromNative", "(", "unsafe", ".", "Pointer", "(", "&", "gval", ")", ")", "\n", "return", "val", ".", "GoValue", "(", ")", "\n", "}" ]

[ "readFromFS", "reads", "file", "from", "a", "local", "path", "and", "returns", "as", "string" ]

[ "func", "readFromFS", "(", "sourcePath", "string", ")", "(", "string", ",", "error", ")", "{", "// If sourcePath starts with ~ we search for $HOME", "// and preppend it to the absolutePath overwriting the first character", "// TODO: Add Windows support", "if", "strings", ".", "HasPrefix", "(", "sourcePath", ",", "\"", "\"", ")", "{", "homeDir", ":=", "os", ".", "Getenv", "(", "\"", "\"", ")", "\n", "if", "homeDir", "==", "\"", "\"", "{", "return", "\"", "\"", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "sourcePath", "=", "filepath", ".", "Join", "(", "homeDir", ",", "sourcePath", "[", "1", ":", "]", ")", "\n", "}", "\n\n", "<mask>", ",", "err", ":=", "ioutil", ".", "ReadFile", "(", "sourcePath", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "return", "string", "(", "bytes", ")", ",", "nil", "\n", "}" ]

[ "ApplicationIDIsValid", "is", "a", "wrapper", "around", "g_application_id_is_valid", "()", "." ]

[ "func", "ApplicationIDIsValid", "(", "id", "string", ")", "bool", "{", "cstr1", ":=", "(", "*", "C", ".", "gchar", ")", "(", "C", ".", "CString", "(", "<mask>", ")", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cstr1", ")", ")", "\n\n", "return", "gobool", "(", "C", ".", "g_application_id_is_valid", "(", "cstr1", ")", ")", "\n", "}" ]

[ "NewContentNegotiator", "creates", "a", "basic", "ContentNegotiator", "with", "out", "any", "attached", "encoders" ]

[ "func", "NewContentNegotiator", "(", "defaultEncoder", "Encoder", ",", "responseWriter", "http", ".", "ResponseWriter", ")", "*", "ContentNegotiator", "{", "<mask>", ":=", "&", "ContentNegotiator", "{", "}", "\n", "result", ".", "DefaultEncoder", "=", "defaultEncoder", "\n", "result", ".", "ResponseWriter", "=", "responseWriter", "\n", "return", "result", "\n", "}" ]

[ "GetIncludeTagsOk", "returns", "a", "tuple", "with", "the", "IncludeTags", "field", "if", "it", "s", "non", "-", "nil", "zero", "value", "otherwise", "and", "a", "boolean", "to", "check", "if", "the", "value", "has", "been", "set", "." ]

[ "func", "(", "o", "*", "Options", ")", "GetIncludeTagsOk", "(", ")", "(", "bool", ",", "bool", ")", "{", "if", "o", "==", "nil", "||", "o", ".", "IncludeTags", "==", "nil", "{", "return", "<mask>", ",", "false", "\n", "}", "\n", "return", "*", "o", ".", "IncludeTags", ",", "true", "\n", "}" ]

[ "Validate", "that", "options", "are", "usuable" ]

[ "func", "(", "opts", "*", "<mask>", ")", "Validate", "(", ")", "error", "{", "if", "opts", ".", "App", ".", "IsZero", "(", ")", "{", "opts", ".", "App", "=", "meta", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "if", "len", "(", "opts", ".", "Version", ")", "==", "0", "{", "opts", ".", "Version", "=", "runtime", ".", "Version", "\n", "}", "\n\n", "if", "opts", ".", "Pop", "!=", "nil", "{", "if", "opts", ".", "Pop", ".", "App", ".", "IsZero", "(", ")", "{", "opts", ".", "Pop", ".", "App", "=", "opts", ".", "App", "\n", "}", "\n", "if", "err", ":=", "opts", ".", "Pop", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "CI", "!=", "nil", "{", "if", "opts", ".", "CI", ".", "App", ".", "IsZero", "(", ")", "{", "opts", ".", "CI", ".", "App", "=", "opts", ".", "App", "\n", "}", "\n", "if", "err", ":=", "opts", ".", "CI", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "Refresh", "!=", "nil", "{", "if", "opts", ".", "Refresh", ".", "App", ".", "IsZero", "(", ")", "{", "opts", ".", "Refresh", ".", "App", "=", "opts", ".", "App", "\n", "}", "\n", "if", "err", ":=", "opts", ".", "Refresh", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "VCS", "!=", "nil", "{", "if", "opts", ".", "VCS", ".", "App", ".", "IsZero", "(", ")", "{", "opts", ".", "VCS", ".", "App", "=", "opts", ".", "App", "\n", "}", "\n", "if", "err", ":=", "opts", ".", "VCS", ".", "Validate", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "opts", ".", "App", ".", "WithModules", "&&", "opts", ".", "App", ".", "WithDep", "{", "return", "ErrGoModulesWithDep", "\n", "}", "\n\n", "name", ":=", "strings", ".", "ToLower", "(", "opts", ".", "App", ".", "Name", ".", "String", "(", ")", ")", "\n", "fb", ":=", "append", "(", "opts", ".", "ForbiddenNames", ",", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ")", "\n", "for", "_", ",", "n", ":=", "range", "fb", "{", "rx", ",", "err", ":=", "regexp", ".", "Compile", "(", "n", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "rx", ".", "MatchString", "(", "name", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "opts", ".", "App", ".", "Name", ")", "\n", "}", "\n", "}", "\n\n", "if", "!", "nameRX", ".", "MatchString", "(", "name", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "opts", ".", "App", ".", "Name", ")", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Returns", "a", "map", "[", "string", "]", "interface", "at", "the", "key", "and", "whether", "or", "not", "the", "key", "existed", "and", "the", "value", "was", "an", "map", "[", "string", "]", "interface", "{}" ]

[ "func", "(", "t", "Typed", ")", "MapIf", "(", "key", "string", ")", "(", "map", "[", "string", "]", "interface", "{", "}", ",", "bool", ")", "{", "value", ",", "exists", ":=", "t", "[", "key", "]", "\n", "if", "exists", "==", "false", "{", "return", "nil", ",", "false", "\n", "}", "\n", "if", "n", ",", "ok", ":=", "value", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", ";", "ok", "{", "return", "n", ",", "<mask>", "\n", "}", "\n", "return", "nil", ",", "false", "\n", "}" ]

[ "Update", "changes", "the", "passphrase", "with", "which", "an", "already", "stored", "key", "is", "encrypted", ".", "oldpass", "must", "be", "the", "current", "passphrase", "used", "for", "encryption", "newpass", "will", "be", "the", "only", "valid", "passphrase", "from", "this", "time", "forward", "." ]

[ "func", "(", "kb", "dbKeybase", ")", "Update", "(", "name", ",", "oldpass", ",", "newpass", "string", ")", "error", "{", "info", ",", "err", ":=", "kb", ".", "Get", "(", "name", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "switch", "info", ".", "(", "type", ")", "{", "case", "localInfo", ":", "linfo", ":=", "info", ".", "(", "localInfo", ")", "\n", "key", ",", "err", ":=", "unarmorDecryptPrivKey", "(", "linfo", ".", "PrivKeyArmor", ",", "oldpass", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "kb", ".", "writeLocalKey", "(", "<mask>", ",", "name", ",", "newpass", ")", "\n", "return", "nil", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "initFromOpenTracing", "initializes", "injectableSpan", "fields", "from", "an", "OpenTracing", "Span", "assuming", "the", "tracing", "implementation", "supports", "Zipkin", "-", "style", "span", "IDs", "." ]

[ "func", "(", "s", "*", "injectableSpan", ")", "initFromOpenTracing", "(", "span", "opentracing", ".", "Span", ")", "error", "{", "return", "span", ".", "Tracer", "(", ")", ".", "Inject", "(", "<mask>", ".", "Context", "(", ")", ",", "zipkinSpanFormat", ",", "s", ")", "\n", "}" ]

[ "gitCtxForRefs", "creates", "a", "gitCtx", "based", "on", "the", "provide", "refs", "and", "baseDir", "." ]

[ "func", "gitCtxForRefs", "(", "refs", "prowapi", ".", "Refs", ",", "baseDir", "string", ",", "env", "[", "]", "<mask>", ")", "gitCtx", "{", "g", ":=", "gitCtx", "{", "cloneDir", ":", "PathForRefs", "(", "baseDir", ",", "refs", ")", ",", "env", ":", "env", ",", "repositoryURI", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "refs", ".", "Org", ",", "refs", ".", "Repo", ")", ",", "}", "\n", "if", "refs", ".", "CloneURI", "!=", "\"", "\"", "{", "g", ".", "repositoryURI", "=", "refs", ".", "CloneURI", "\n", "}", "\n", "return", "g", "\n", "}" ]

[ "UnmarshalJSON", "supports", "json", ".", "Unmarshaler", "interface" ]

[ "func", "(", "v", "*", "SetBreakpointReturns", ")", "UnmarshalJSON", "(", "<mask>", "[", "]", "byte", ")", "error", "{", "r", ":=", "jlexer", ".", "Lexer", "{", "Data", ":", "data", "}", "\n", "easyjsonC5a4559bDecodeGithubComChromedpCdprotoDebugger10", "(", "&", "r", ",", "v", ")", "\n", "return", "r", ".", "Error", "(", ")", "\n", "}" ]

[ "GetTitleSize", "returns", "the", "TitleSize", "field", "if", "non", "-", "nil", "zero", "value", "otherwise", "." ]

[ "func", "(", "l", "*", "LogStreamDefinition", ")", "GetTitleSize", "(", ")", "<mask>", "{", "if", "l", "==", "nil", "||", "l", ".", "TitleSize", "==", "nil", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "*", "l", ".", "TitleSize", "\n", "}" ]

[ "GetCmd", "returns", "a", "cobra", "command", "that", "gets", "either", "the", "ACL", "for", "a", "Pachyderm", "repo", "or", "another", "user", "s", "scope", "of", "access", "to", "that", "repo" ]

[ "func", "GetCmd", "(", "noMetrics", ",", "noPortForwarding", "*", "bool", ")", "*", "cobra", ".", "Command", "{", "<mask>", ":=", "&", "cobra", ".", "Command", "{", "Use", ":", "\"", "\"", ",", "Short", ":", "\"", "\"", ",", "Long", ":", "\"", "\"", "+", "\"", "\"", "+", "\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\\\"", "\"", "+", "\"", "\\\"", "\\\"", "\\\"", "\\\"", "\"", "+", "\"", "\"", "+", "\"", "\"", ",", "Run", ":", "cmdutil", ".", "RunBoundedArgs", "(", "1", ",", "2", ",", "func", "(", "args", "[", "]", "string", ")", "error", "{", "c", ",", "err", ":=", "client", ".", "NewOnUserMachine", "(", "!", "*", "noMetrics", ",", "!", "*", "noPortForwarding", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "defer", "c", ".", "Close", "(", ")", "\n", "if", "len", "(", "args", ")", "==", "1", "{", "// Get ACL for a repo", "repo", ":=", "args", "[", "0", "]", "\n", "resp", ",", "err", ":=", "c", ".", "GetACL", "(", "c", ".", "Ctx", "(", ")", ",", "&", "auth", ".", "GetACLRequest", "{", "Repo", ":", "repo", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "grpcutil", ".", "ScrubGRPC", "(", "err", ")", "\n", "}", "\n", "t", ":=", "template", ".", "Must", "(", "template", ".", "New", "(", "\"", "\"", ")", ".", "Parse", "(", "\"", "\\n", "\"", ")", ")", "\n", "return", "t", ".", "Execute", "(", "os", ".", "Stdout", ",", "resp", ".", "Entries", ")", "\n", "}", "\n", "// Get User's scope on an acl", "username", ",", "repo", ":=", "args", "[", "0", "]", ",", "args", "[", "1", "]", "\n", "resp", ",", "err", ":=", "c", ".", "GetScope", "(", "c", ".", "Ctx", "(", ")", ",", "&", "auth", ".", "GetScopeRequest", "{", "Repos", ":", "[", "]", "string", "{", "repo", "}", ",", "Username", ":", "username", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "grpcutil", ".", "ScrubGRPC", "(", "err", ")", "\n", "}", "\n", "fmt", ".", "Println", "(", "resp", ".", "Scopes", "[", "0", "]", ".", "String", "(", ")", ")", "\n", "return", "nil", "\n", "}", ")", ",", "}", "\n", "return", "cmdutil", ".", "CreateAlias", "(", "get", ",", "\"", "\"", ")", "\n", "}" ]

[ "Contains", "determines", "is", "a", "field", "exists", "in", "the", "TupleType" ]

[ "func", "(", "t", "*", "TupleType", ")", "Contains", "(", "field", "string", ")", "bool", "{", "_", ",", "exists", ":=", "t", ".", "fields", "[", "<mask>", "]", "\n", "return", "exists", "\n", "}" ]

[ "RowsLimitColumn", "creates", "a", "Row", "query", "with", "the", "given", "limit", "and", "column", "ID", "/", "key" ]

[ "func", "(", "f", "*", "Field", ")", "RowsLimitColumn", "(", "limit", "int64", ",", "columnIDOrKey", "interface", "{", "}", ")", "*", "PQLRowsQuery", "{", "if", "limit", "<", "0", "{", "return", "NewPQLRowsQuery", "(", "\"", "\"", ",", "f", ".", "index", ",", "errors", ".", "New", "(", "\"", "\"", ")", ")", "\n", "}", "\n", "columnIDKey", ",", "err", ":=", "formatIDKey", "(", "columnIDOrKey", ")", "\n", "if", "err", "!=", "nil", "{", "return", "NewPQLRowsQuery", "(", "\"", "\"", ",", "f", ".", "index", ",", "err", ")", "\n", "}", "\n", "text", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "f", ".", "<mask>", ",", "limit", ",", "columnIDKey", ")", "\n", "return", "NewPQLRowsQuery", "(", "text", ",", "f", ".", "index", ",", "nil", ")", "\n", "}" ]

[ "Range", "returns", "the", "counters", "within", "some", "lat", "lng", "range", "." ]

[ "func", "(", "countIndex", "*", "CountIndex", ")", "Range", "(", "topLeft", "Point", ",", "bottomRight", "Point", ")", "[", "]", "Point", "{", "counters", ":=", "countIndex", ".", "index", ".", "Range", "(", "topLeft", ",", "bottomRight", ")", "\n\n", "<mask>", ":=", "make", "(", "[", "]", "Point", ",", "0", ")", "\n\n", "for", "_", ",", "c", ":=", "range", "counters", "{", "if", "c", ".", "(", "counter", ")", ".", "Point", "(", ")", "!=", "nil", "{", "points", "=", "append", "(", "points", ",", "c", ".", "(", "counter", ")", ".", "Point", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "return", "points", "\n", "}" ]

[ "Bind", "the", "interface", "to", "the", "request", ".", "Body", ".", "The", "type", "of", "binding", "is", "dependent", "on", "the", "Content", "-", "Type", "for", "the", "request", ".", "If", "the", "type", "is", "application", "/", "json", "it", "will", "use", "json", ".", "NewDecoder", ".", "If", "the", "type", "is", "application", "/", "xml", "it", "will", "use", "xml", ".", "NewDecoder", ".", "See", "the", "github", ".", "com", "/", "gobuffalo", "/", "buffalo", "/", "binding", "package", "for", "more", "details", "." ]

[ "func", "(", "d", "*", "DefaultContext", ")", "Bind", "(", "<mask>", "interface", "{", "}", ")", "error", "{", "return", "binding", ".", "Exec", "(", "d", ".", "Request", "(", ")", ",", "value", ")", "\n", "}" ]

[ "Error", "writes", "the", "given", "values", "to", "the", "Target", "logger", "." ]

[ "func", "(", "t", "*", "Target", ")", "<mask>", "(", "v", "error", ")", "{", "t", ".", "mut", ".", "RLock", "(", ")", "\n", "defer", "t", ".", "mut", ".", "RUnlock", "(", ")", "\n", "if", "t", ".", "logger", "!=", "nil", "{", "t", ".", "logger", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}", "\n", "}" ]

[ "tagsFromMetric", "translates", "Prometheus", "metric", "into", "OpenTSDB", "tags", "." ]

[ "func", "tagsFromMetric", "(", "m", "<mask>", ".", "Metric", ")", "map", "[", "string", "]", "TagValue", "{", "tags", ":=", "make", "(", "map", "[", "string", "]", "TagValue", ",", "len", "(", "m", ")", "-", "1", ")", "\n", "for", "l", ",", "v", ":=", "range", "m", "{", "if", "l", "==", "model", ".", "MetricNameLabel", "{", "continue", "\n", "}", "\n", "tags", "[", "string", "(", "l", ")", "]", "=", "TagValue", "(", "v", ")", "\n", "}", "\n", "return", "tags", "\n", "}" ]

[ "WithMinDuration", "the", "minimum", "duration", "(", "in", "seconds", ")", "to", "replay", "the", "snapshot", "." ]

[ "func", "(", "p", "ProfileSnapshotParams", ")", "WithMinDuration", "(", "minDuration", "float64", ")", "*", "ProfileSnapshotParams", "{", "p", ".", "MinDuration", "=", "minDuration", "\n", "<mask>", "&", "p", "\n", "}" ]

[ "ForEachRoot", "calls", "fn", "with", "each", "garbage", "collection", "root", ".", "If", "fn", "returns", "false", "ForEachRoot", "returns", "immediately", "." ]

[ "func", "(", "p", "*", "Process", ")", "ForEachRoot", "(", "fn", "func", "(", "r", "*", "<mask>", ")", "bool", ")", "{", "for", "_", ",", "r", ":=", "range", "p", ".", "globals", "{", "if", "!", "fn", "(", "r", ")", "{", "return", "\n", "}", "\n", "}", "\n", "for", "_", ",", "g", ":=", "range", "p", ".", "goroutines", "{", "for", "_", ",", "f", ":=", "range", "g", ".", "frames", "{", "for", "_", ",", "r", ":=", "range", "f", ".", "roots", "{", "if", "!", "fn", "(", "r", ")", "{", "return", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "SubmitContainerStateChange", "indicates", "an", "expected", "call", "of", "SubmitContainerStateChange" ]

[ "func", "(", "mr", "*", "MockECSSubmitStateSDKMockRecorder", ")", "SubmitContainerStateChange", "(", "arg0", "<mask>", "{", "}", ")", "*", "gomock", ".", "Call", "{", "return", "mr", ".", "mock", ".", "ctrl", ".", "RecordCallWithMethodType", "(", "mr", ".", "mock", ",", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "(", "*", "MockECSSubmitStateSDK", ")", "(", "nil", ")", ".", "SubmitContainerStateChange", ")", ",", "arg0", ")", "\n", "}" ]

[ "MarshalJSON", "supports", "json", ".", "Marshaler", "interface" ]

[ "func", "(", "v", "SamplingHeapProfile", ")", "MarshalJSON", "(", ")", "(", "[", "]", "byte", ",", "error", ")", "{", "w", ":=", "jwriter", ".", "Writer", "{", "}", "\n", "easyjsonC5a4559bEncodeGithubComChromedpCdprotoHeapprofiler8", "(", "&", "w", ",", "v", ")", "\n", "return", "w", ".", "<mask>", ".", "BuildBytes", "(", ")", ",", "w", ".", "Error", "\n", "}" ]

[ "NewMux", "returns", "a", "newly", "initialized", "Mux", "object", "that", "implements", "the", "Router", "interface", "." ]

[ "func", "NewMux", "(", ")", "*", "Mux", "{", "mux", ":=", "&", "Mux", "{", "<mask>", ":", "&", "node", "{", "}", ",", "pool", ":", "&", "sync", ".", "Pool", "{", "}", "}", "\n", "mux", ".", "pool", ".", "New", "=", "func", "(", ")", "interface", "{", "}", "{", "return", "NewRouteContext", "(", ")", "\n", "}", "\n", "return", "mux", "\n", "}" ]

[ "ReceiveEvent", "checks", "if", "the", "event", "matches", "the", "entry", "criteria", "Returns", "a", "new", "ActiveState", "or", "self", "and", "true", "if", "it", "changed", "." ]

[ "func", "(", "i", "*", "InactiveState", ")", "ReceiveEvent", "(", "eventName", ",", "label", "string", ",", "t", "<mask>", ".", "Time", ")", "(", "State", ",", "bool", ")", "{", "if", "i", ".", "entry", ".", "Match", "(", "eventName", ",", "label", ")", "{", "return", "&", "ActiveState", "{", "startTime", ":", "t", ",", "exit", ":", "i", ".", "entry", ".", "Opposite", "(", ")", ",", "}", ",", "true", "\n", "}", "\n", "return", "i", ",", "false", "\n", "}" ]

[ "Helper", "to", "bootstrap", "the", "raft", "cluster", "if", "needed", "." ]

[ "func", "raftMaybeBootstrap", "(", "conf", "*", "raft", ".", "Config", ",", "logs", "*", "raftboltdb", ".", "BoltStore", ",", "snaps", "raft", ".", "SnapshotStore", ",", "trans", "raft", ".", "Transport", ")", "error", "{", "// First check if we were already bootstrapped.", "hasExistingState", ",", "err", ":=", "raft", ".", "HasExistingState", "(", "logs", ",", "logs", ",", "snaps", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "hasExistingState", "{", "return", "nil", "\n", "}", "\n", "server", ":=", "raft", ".", "Server", "{", "ID", ":", "conf", ".", "LocalID", ",", "Address", ":", "trans", ".", "LocalAddr", "(", ")", ",", "}", "\n", "configuration", ":=", "raft", ".", "Configuration", "{", "Servers", ":", "[", "]", "raft", ".", "Server", "{", "<mask>", "}", ",", "}", "\n", "return", "raft", ".", "BootstrapCluster", "(", "conf", ",", "logs", ",", "logs", ",", "snaps", ",", "trans", ",", "configuration", ")", "\n", "}" ]

[ "ForEachRecordSet", "calls", "handler", "for", "each", "recordset", "in", "the", "given", "DNS", "zone" ]

[ "func", "(", "c", "designateClient", ")", "ForEachRecordSet", "(", "zoneID", "string", ",", "handler", "func", "(", "recordSet", "*", "recordsets", ".", "RecordSet", ")", "error", ")", "error", "{", "pager", ":=", "recordsets", ".", "ListByZone", "(", "c", ".", "serviceClient", ",", "zoneID", ",", "recordsets", ".", "ListOpts", "{", "}", ")", "\n", "return", "pager", ".", "EachPage", "(", "func", "(", "page", "pagination", ".", "Page", ")", "(", "bool", ",", "error", ")", "{", "list", ",", "err", ":=", "recordsets", ".", "ExtractRecordSets", "(", "page", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "for", "_", ",", "recordSet", ":=", "range", "list", "{", "err", ":=", "handler", "(", "&", "recordSet", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "}", "\n", "return", "<mask>", ",", "nil", "\n", "}", ",", ")", "\n", "}" ]

[ "HasPalette", "returns", "a", "boolean", "if", "a", "field", "has", "been", "set", "." ]

[ "func", "(", "d", "*", "DashboardConditionalFormat", ")", "HasPalette", "(", ")", "bool", "{", "if", "d", "!=", "nil", "&&", "d", ".", "Palette", "!=", "nil", "{", "return", "true", "\n", "}", "\n\n", "return", "<mask>", "\n", "}" ]

[ "ApprovalLocator", "builds", "a", "locator", "from", "the", "given", "href", "." ]

[ "func", "(", "api", "*", "API", ")", "ApprovalLocator", "(", "href", "<mask>", ")", "*", "ApprovalLocator", "{", "return", "&", "ApprovalLocator", "{", "Href", "(", "href", ")", ",", "api", "}", "\n", "}" ]

[ "IsISOCountryCode", "returns", "true", "if", "the", "input", "is", "a", "known", "two", "-", "letter", "country", "code", ".", "TODO", ":", "Document", "where", "the", "list", "of", "known", "countries", "came", "from", "." ]

[ "func", "IsISOCountryCode", "(", "<mask>", "string", ")", "bool", "{", "in", "=", "strings", ".", "ToUpper", "(", "in", ")", "\n", "_", ",", "ok", ":=", "countries", "[", "in", "]", "\n", "return", "ok", "\n", "}" ]

[ "Inspect", "returns", "various", "information", "for", "(", "skopeo", "inspect", ")", "parsed", "from", "the", "manifest", "and", "configuration", "." ]

[ "func", "(", "m", "*", "manifestSchema1", ")", "Inspect", "(", "context", ".", "Context", ")", "(", "*", "<mask>", ".", "ImageInspectInfo", ",", "error", ")", "{", "return", "m", ".", "m", ".", "Inspect", "(", "nil", ")", "\n", "}" ]

[ "TemplateWithDelimiters", "is", "string", "template", "with", "user", "-", "defineable", "opening", "and", "closing", "delimiters", "." ]

[ "func", "TemplateWithDelimiters", "(", "s", "string", ",", "values", "<mask>", "[", "string", "]", "interface", "{", "}", ",", "opening", ",", "closing", "string", ")", "string", "{", "escapeDelimiter", ":=", "func", "(", "delim", "string", ")", "string", "{", "result", ":=", "templateRe", ".", "ReplaceAllString", "(", "delim", ",", "\"", "\\\\", "\"", ")", "\n", "return", "templateRe2", ".", "ReplaceAllString", "(", "result", ",", "\"", "\\\\", "\"", ")", "\n", "}", "\n\n", "openingDelim", ":=", "escapeDelimiter", "(", "opening", ")", "\n", "closingDelim", ":=", "escapeDelimiter", "(", "closing", ")", "\n", "r", ":=", "regexp", ".", "MustCompile", "(", "openingDelim", "+", "`(.+?)`", "+", "closingDelim", ")", "\n", "matches", ":=", "r", ".", "FindAllStringSubmatch", "(", "s", ",", "-", "1", ")", "\n", "for", "_", ",", "submatches", ":=", "range", "matches", "{", "match", ":=", "submatches", "[", "0", "]", "\n", "key", ":=", "submatches", "[", "1", "]", "\n", "//log.Printf(\"match %s key %s\\n\", match, key)", "if", "values", "[", "key", "]", "!=", "nil", "{", "v", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "values", "[", "key", "]", ")", "\n", "s", "=", "strings", ".", "Replace", "(", "s", ",", "match", ",", "v", ",", "-", "1", ")", "\n", "}", "\n", "}", "\n\n", "return", "s", "\n", "}" ]

[ "Delete2", "is", "same", "as", "Delete", "()", ".", "Additionally", "returns", "the", "deleted", "item", "s", "node" ]

[ "func", "(", "w", "*", "<mask>", ")", "Delete2", "(", "bs", "[", "]", "byte", ")", "(", "n", "*", "skiplist", ".", "Node", ",", "success", "bool", ")", "{", "if", "n", ":=", "w", ".", "GetNode", "(", "bs", ")", ";", "n", "!=", "nil", "{", "return", "n", ",", "w", ".", "DeleteNode", "(", "n", ")", "\n", "}", "\n\n", "return", "nil", ",", "false", "\n", "}" ]

[ "Apply", "satisfies", "the", "StartSpanOption", "interface", "." ]

[ "func", "(", "t", "Tag", ")", "Apply", "(", "o", "*", "StartSpanOptions", ")", "{", "if", "o", ".", "Tags", "==", "nil", "{", "o", ".", "Tags", "=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "}", "\n", "o", ".", "Tags", "[", "t", ".", "Key", "]", "=", "t", ".", "<mask>", "\n", "}" ]

[ "helpProvider", "provides", "information", "on", "the", "plugin" ]

[ "func", "helpProvider", "(", "config", "*", "plugins", ".", "<mask>", ",", "enabledRepos", "[", "]", "string", ")", "(", "*", "pluginhelp", ".", "PluginHelp", ",", "error", ")", "{", "// Only the Description field is specified because this plugin is not triggered with commands and is not configurable.", "return", "&", "pluginhelp", ".", "PluginHelp", "{", "Description", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "labels", ".", "MergeCommits", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "Time", "returns", "a", "new", "time", ".", "Time", "object", "from", "a", "millisecond", "timestamp", "." ]

[ "func", "Time", "(", "ts", "int64", ")", "time", ".", "Time", "{", "return", "time", ".", "Unix", "(", "ts", "/", "1000", ",", "(", "ts", "%", "1000", ")", "*", "int64", "(", "<mask>", ".", "Millisecond", ")", ")", "\n", "}" ]

[ "UnmarshalJSON", "supports", "json", ".", "Unmarshaler", "interface" ]

[ "func", "(", "v", "*", "GetFrameTreeParams", ")", "UnmarshalJSON", "(", "<mask>", "[", "]", "byte", ")", "error", "{", "r", ":=", "jlexer", ".", "Lexer", "{", "Data", ":", "data", "}", "\n", "easyjsonC5a4559bDecodeGithubComChromedpCdprotoPage41", "(", "&", "r", ",", "v", ")", "\n", "return", "r", ".", "Error", "(", ")", "\n", "}" ]

[ "GetAsVersion", "mocks", "base", "method" ]

[ "func", "(", "m", "*", "MockResult", ")", "GetAsVersion", "(", "arg0", "string", ")", "(", "types", ".", "Result", ",", "error", ")", "{", "<mask>", ":=", "m", ".", "ctrl", ".", "Call", "(", "m", ",", "\"", "\"", ",", "arg0", ")", "\n", "ret0", ",", "_", ":=", "ret", "[", "0", "]", ".", "(", "types", ".", "Result", ")", "\n", "ret1", ",", "_", ":=", "ret", "[", "1", "]", ".", "(", "error", ")", "\n", "return", "ret0", ",", "ret1", "\n", "}" ]

[ "GeckoDriver", "returns", "an", "instance", "of", "a", "geckodriver", "WebDriver", "which", "supports", "gecko", "based", "brwoser", "like", "Firefox", ".", "Provided", "Options", "will", "apply", "as", "default", "arguments", "for", "new", "pages", ".", "See", "https", ":", "//", "github", ".", "com", "/", "mozilla", "/", "geckodriver", "for", "geckodriver", "details", "." ]

[ "func", "GeckoDriver", "(", "options", "...", "Option", ")", "*", "WebDriver", "{", "var", "binaryName", "string", "\n", "if", "runtime", ".", "GOOS", "==", "\"", "\"", "{", "binaryName", "=", "\"", "\"", "\n", "}", "else", "{", "binaryName", "=", "\"", "\"", "\n", "}", "\n", "command", ":=", "[", "]", "string", "{", "binaryName", ",", "\"", "\"", "}", "\n", "return", "NewWebDriver", "(", "\"", "\"", ",", "command", ",", "<mask>", "...", ")", "\n", "}" ]

[ "Close", "closes", "the", "connection", "." ]

[ "func", "(", "f", "*", "Fluent", ")", "Close", "(", ")", "(", "err", "error", ")", "{", "if", "f", ".", "conn", "!=", "nil", "{", "f", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "f", ".", "mu", ".", "Unlock", "(", ")", "\n", "}", "else", "{", "return", "\n", "}", "\n", "if", "f", ".", "<mask>", "!=", "nil", "{", "f", ".", "conn", ".", "Close", "(", ")", "\n", "f", ".", "conn", "=", "nil", "\n", "}", "\n", "return", "\n", "}" ]

[ "===", "Vector", "(", "s", "Scalar", ")", "Vector", "===" ]

[ "func", "funcVector", "(", "vals", "[", "]", "Value", ",", "args", "Expressions", ",", "enh", "*", "EvalNodeHelper", ")", "Vector", "{", "return", "<mask>", "(", "enh", ".", "out", ",", "Sample", "{", "Metric", ":", "labels", ".", "Labels", "{", "}", ",", "Point", ":", "Point", "{", "V", ":", "vals", "[", "0", "]", ".", "(", "Vector", ")", "[", "0", "]", ".", "V", "}", ",", "}", ")", "\n", "}" ]

[ "------------------------------------------------------------------------------", "Process", "will", "use", "the", "Pool", "to", "process", "a", "payload", "and", "synchronously", "return", "the", "result", ".", "Process", "can", "be", "called", "safely", "by", "any", "goroutines", "but", "will", "panic", "if", "the", "Pool", "has", "been", "stopped", "." ]

[ "func", "(", "p", "*", "Pool", ")", "Process", "(", "payload", "interface", "{", "}", ")", "interface", "{", "}", "{", "atomic", ".", "AddInt64", "(", "&", "p", ".", "queuedJobs", ",", "1", ")", "\n\n", "request", ",", "open", ":=", "<-", "p", ".", "reqChan", "\n", "if", "!", "open", "{", "panic", "(", "ErrPoolNotRunning", ")", "\n", "}", "\n\n", "request", ".", "jobChan", "<-", "payload", "\n\n", "payload", ",", "<mask>", "=", "<-", "request", ".", "retChan", "\n", "if", "!", "open", "{", "panic", "(", "ErrWorkerClosed", ")", "\n", "}", "\n\n", "atomic", ".", "AddInt64", "(", "&", "p", ".", "queuedJobs", ",", "-", "1", ")", "\n", "return", "payload", "\n", "}" ]

[ "ApplyChanges", "applies", "a", "given", "set", "of", "changes", "in", "a", "given", "zone", "." ]

[ "func", "(", "p", "designateProvider", ")", "ApplyChanges", "(", "<mask>", "*", "plan", ".", "Changes", ")", "error", "{", "managedZones", ",", "err", ":=", "p", ".", "getZones", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "recordSets", ":=", "map", "[", "string", "]", "*", "recordSet", "{", "}", "\n", "for", "_", ",", "ep", ":=", "range", "changes", ".", "Create", "{", "addEndpoint", "(", "ep", ",", "recordSets", ",", "false", ")", "\n", "}", "\n", "for", "_", ",", "ep", ":=", "range", "changes", ".", "UpdateNew", "{", "addEndpoint", "(", "ep", ",", "recordSets", ",", "false", ")", "\n", "}", "\n", "for", "_", ",", "ep", ":=", "range", "changes", ".", "UpdateOld", "{", "addEndpoint", "(", "ep", ",", "recordSets", ",", "true", ")", "\n", "}", "\n", "for", "_", ",", "ep", ":=", "range", "changes", ".", "Delete", "{", "addEndpoint", "(", "ep", ",", "recordSets", ",", "true", ")", "\n", "}", "\n", "for", "_", ",", "rs", ":=", "range", "recordSets", "{", "if", "err2", ":=", "p", ".", "upsertRecordSet", "(", "rs", ",", "managedZones", ")", ";", "err", "==", "nil", "{", "err", "=", "err2", "\n", "}", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "HTTP", "returns", "a", "handler", "that", "will", "check", "each", "request", "s", "method", "against", "a", "predefined", "whitelist", ".", "If", "the", "request", "s", "method", "is", "not", "part", "of", "the", "list", "the", "response", "will", "be", "a", "400", "Bad", "Request", "." ]

[ "func", "HTTP", "(", "h", "http", ".", "Handler", ",", "verb", "Verb", ",", "verbs", "...", "Verb", ")", "http", ".", "<mask>", "{", "verbSet", ":=", "map", "[", "Verb", "]", "struct", "{", "}", "{", "verb", ":", "struct", "{", "}", "{", "}", "}", "\n", "for", "_", ",", "v", ":=", "range", "verbs", "{", "verbSet", "[", "v", "]", "=", "struct", "{", "}", "{", "}", "\n", "}", "\n\n", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "if", "_", ",", "ok", ":=", "verbSet", "[", "Verb", "(", "r", ".", "Method", ")", "]", ";", "ok", "{", "h", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "}", "else", "{", "w", ".", "WriteHeader", "(", "http", ".", "StatusBadRequest", ")", "\n", "}", "\n", "}", ")", "\n", "}" ]

[ "NewDedupManager", "creates", "a", "new", "Dedup", "manager" ]

[ "func", "NewDedupManager", "(", "config", "*", "config", ".", "DedupConfig", ",", "clients", "*", "dep", ".", "ClientSet", ",", "brain", "*", "template", ".", "Brain", ",", "templates", "[", "]", "*", "template", ".", "<mask>", ")", "(", "*", "DedupManager", ",", "error", ")", "{", "d", ":=", "&", "DedupManager", "{", "config", ":", "config", ",", "clients", ":", "clients", ",", "brain", ":", "brain", ",", "templates", ":", "templates", ",", "leader", ":", "make", "(", "map", "[", "*", "template", ".", "Template", "]", "<-", "chan", "struct", "{", "}", ")", ",", "lastWrite", ":", "make", "(", "map", "[", "*", "template", ".", "Template", "]", "uint64", ")", ",", "updateCh", ":", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", ",", "stopCh", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "}", "\n", "return", "d", ",", "nil", "\n", "}" ]

[ "Delete", "marks", "the", "current", "iterator", "record", "as", "deleted", "from", "the", "store", "if", "it", "has", "not", "been", "updated", "since", "iterating", "or", "seeking", "to", "it", ".", "If", "the", "record", "has", "been", "updated", "then", "Delete", "positions", "the", "iterator", "on", "the", "most", "current", "value", "and", "returns", "ErrRecordUpdated", ".", "If", "the", "record", "is", "deleted", "then", "Delete", "positions", "the", "iterator", "on", "the", "next", "record", "." ]

[ "func", "(", "it", "*", "Iterator", ")", "Delete", "(", ")", "error", "{", "if", "!", "atomic", ".", "CompareAndSwapUint64", "(", "&", "it", ".", "nd", ".", "value", ",", "it", ".", "value", ",", "deletedVal", ")", "{", "if", "it", ".", "setNode", "(", "it", ".", "<mask>", ",", "false", ")", "{", "return", "ErrRecordUpdated", "\n", "}", "\n\n", "return", "nil", "\n", "}", "\n\n", "// Deletion succeeded, so position iterator on next non-deleted node.", "next", ":=", "it", ".", "list", ".", "getNext", "(", "it", ".", "nd", ",", "0", ")", "\n", "it", ".", "setNode", "(", "next", ",", "false", ")", "\n", "return", "nil", "\n", "}" ]

[ "Root", "creates", "new", "test", "directory" ]

[ "func", "Root", "(", "t", "*", "testing", ".", "T", ",", "callback", "func", "(", "dir", "string", ")", ")", "{", "tmpDir", ",", "err", ":=", "ioutil", ".", "TempDir", "(", "\"", "\"", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "t", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "defer", "func", "(", ")", "{", "if", "err", ":=", "os", ".", "RemoveAll", "(", "tmpDir", ")", ";", "err", "!=", "nil", "{", "t", ".", "Fatal", "(", "err", ")", "\n", "}", "\n", "}", "(", ")", "\n\n", "<mask>", "(", "tmpDir", ")", "\n", "}" ]

[ "setTaskAttachmentSent", "sets", "the", "event", "s", "task", "attachment", "object", "as", "sent" ]

[ "func", "setTaskAttachmentSent", "(", "<mask>", "*", "sendableEvent", ")", "{", "if", "event", ".", "taskChange", ".", "Attachment", "!=", "nil", "{", "event", ".", "taskChange", ".", "Attachment", ".", "SetSentStatus", "(", ")", "\n", "event", ".", "taskChange", ".", "Attachment", ".", "StopAckTimer", "(", ")", "\n", "}", "\n", "}" ]

[ "This", "is", "useful", "with", "kingpin", "option", "parser" ]

[ "func", "(", "o", "*", "BoolOption", ")", "Set", "(", "s", "string", ")", "error", "{", "err", ":=", "convertString", "(", "s", ",", "&", "o", ".", "<mask>", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "o", ".", "Source", "=", "\"", "\"", "\n", "o", ".", "Defined", "=", "true", "\n", "return", "nil", "\n", "}" ]

[ "CreateCommentReaction", "adds", "emoji", "to", "a", "comment", "." ]

[ "func", "(", "f", "*", "FakeClient", ")", "CreateCommentReaction", "(", "org", ",", "repo", "string", ",", "<mask>", "int", ",", "reaction", "string", ")", "error", "{", "f", ".", "CommentReactionsAdded", "=", "append", "(", "f", ".", "CommentReactionsAdded", ",", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "org", ",", "repo", ",", "ID", ",", "reaction", ")", ")", "\n", "return", "nil", "\n", "}" ]

[ "processAttachOperations", "processes", "all", "pending", "attach", "operations", "by", "diffing", "old", "and", "new", "and", "adding", "any", "IDs", "that", "were", "not", "found", "in", "old", "." ]

[ "func", "(", "p", "*", "tagDiffProcessor", ")", "processAttachOperations", "(", ")", "error", "{", "tagIDs", ":=", "p", ".", "diffNewOld", "(", ")", "\n", "if", "len", "(", "tagIDs", ")", "<", "1", "{", "// Nothing to do", "return", "nil", "\n", "}", "\n", "for", "_", ",", "tagID", ":=", "range", "tagIDs", "{", "objID", ":=", "p", ".", "subject", ".", "Reference", "(", ")", ".", "Value", "\n", "objType", ",", "err", ":=", "tagTypeForObject", "(", "p", ".", "subject", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "ctx", ",", "cancel", ":=", "context", ".", "WithTimeout", "(", "<mask>", ".", "Background", "(", ")", ",", "defaultAPITimeout", ")", "\n", "defer", "cancel", "(", ")", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "tagID", ",", "objID", ")", "\n", "if", "err", ":=", "p", ".", "client", ".", "AttachTagToObject", "(", "ctx", ",", "tagID", ",", "objID", ",", "objType", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "Counter", "fetches", "an", "instrument", "from", "the", "registry", "or", "creates", "a", "new", "one", ".", "If", "another", "instrument", "type", "is", "already", "registered", "with", "the", "same", "name", "/", "tags", "a", "blank", "one", "will", "be", "returned", "and", "an", "error", "will", "be", "logged", "to", "the", "Errors", "()", "channel", "." ]

[ "func", "(", "r", "*", "Registry", ")", "Counter", "(", "name", "string", ",", "tags", "[", "]", "string", ")", "*", "Counter", "{", "return", "r", ".", "fetchCounter", "(", "<mask>", ",", "tags", ",", "newCounter", ")", "\n", "}" ]

[ "determine", "if", "a", "name", "corresponds", "to", "a", "framebuffer", "object" ]

[ "func", "IsFramebuffer", "(", "framebuffer", "uint32", ")", "bool", "{", "<mask>", ",", "_", ",", "_", ":=", "syscall", ".", "Syscall", "(", "gpIsFramebuffer", ",", "1", ",", "uintptr", "(", "framebuffer", ")", ",", "0", ",", "0", ")", "\n", "return", "ret", "!=", "0", "\n", "}" ]

[ "SetFocusVAdjustment", "is", "a", "wrapper", "around", "gtk_container_set_focus_vadjustment", "()", "." ]

[ "func", "(", "v", "*", "<mask>", ")", "SetFocusVAdjustment", "(", "adjustment", "*", "Adjustment", ")", "{", "C", ".", "gtk_container_set_focus_vadjustment", "(", "v", ".", "native", "(", ")", ",", "adjustment", ".", "native", "(", ")", ")", "\n", "}" ]

[ "Kill", "terminates", "current", "container", "process", "." ]

[ "func", "(", "s", "*", "Container", ")", "Kill", "(", ")", "error", "{", "err", ":=", "exec", ".", "Command", "(", "s", ".", "docker", ".", "binCmd", ",", "\"", "\"", ",", "s", ".", "id", ")", ".", "Run", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "stopped", ":=", "raiqub", ".", "WaitFunc", "(", "250", "*", "time", ".", "Millisecond", ",", "30", "*", "time", ".", "Second", ",", "func", "(", ")", "bool", "{", "inspect", ",", "err", ":=", "s", ".", "Inspect", "(", ")", "\n", "if", "err", "!=", "nil", "||", "len", "(", "inspect", ")", "==", "0", "{", "return", "true", "\n", "}", "\n", "if", "!", "inspect", "[", "0", "]", ".", "State", ".", "Running", "{", "return", "<mask>", "\n", "}", "\n\n", "return", "false", "\n", "}", ")", "\n", "if", "!", "stopped", "{", "err", "=", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ".", "id", ")", "\n", "}", "\n\n", "return", "err", "\n", "}" ]

[ "clientConfig", ".", "Namespace", "()", "is", "broken", "in", "client", "-", "go", "3", ".", "0", ":", "namespace", "in", "config", "erroneously", "overrides", "explicit", "--", "namespace" ]

[ "func", "defaultNamespace", "(", "c", "clientcmd", ".", "ClientConfig", ")", "(", "string", ",", "error", ")", "{", "if", "overrides", ".", "Context", ".", "Namespace", "!=", "\"", "\"", "{", "return", "overrides", ".", "<mask>", ".", "Namespace", ",", "nil", "\n", "}", "\n", "ns", ",", "_", ",", "err", ":=", "c", ".", "Namespace", "(", ")", "\n", "return", "ns", ",", "err", "\n", "}" ]