Datasets:

---

google

/

code_x_glue_cc_cloze_testing_all

like 5

Follow

Google 12.6k

[ "GetSentStatus", "safely", "returns", "the", "SentStatusUnsafe", "of", "the", "container" ]

[ "func", "(", "c", "*", "<mask>", ")", "GetSentStatus", "(", ")", "apicontainerstatus", ".", "ContainerStatus", "{", "c", ".", "lock", ".", "RLock", "(", ")", "\n", "defer", "c", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "return", "c", ".", "SentStatusUnsafe", "\n", "}" ]

[ "NewContext", "returns", "a", "new", "root", "context", "used", "to", "make", "TChannel", "requests", "." ]

[ "func", "NewContext", "(", "timeout", "time", ".", "Duration", ")", "(", "context", ".", "Context", ",", "<mask>", ".", "CancelFunc", ")", "{", "return", "NewContextBuilder", "(", "timeout", ")", ".", "Build", "(", ")", "\n", "}" ]

[ "StopAt", "stops", "mock", "server", "at", "given", "index", "." ]

[ "func", "(", "ms", "*", "MockServers", ")", "StopAt", "(", "idx", "int", ")", "{", "ms", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "ms", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "if", "<mask>", ".", "Servers", "[", "idx", "]", ".", "ln", "==", "nil", "{", "return", "\n", "}", "\n\n", "ms", ".", "Servers", "[", "idx", "]", ".", "GrpcServer", ".", "Stop", "(", ")", "\n", "ms", ".", "Servers", "[", "idx", "]", ".", "GrpcServer", "=", "nil", "\n", "ms", ".", "Servers", "[", "idx", "]", ".", "ln", "=", "nil", "\n", "ms", ".", "wg", ".", "Done", "(", ")", "\n", "}" ]

[ "Schema1FromManifest", "creates", "a", "Schema1", "manifest", "instance", "from", "a", "manifest", "blob", ".", "(", "NOTE", ":", "The", "instance", "is", "not", "necessary", "a", "literal", "representation", "of", "the", "original", "blob", "layers", "with", "duplicate", "IDs", "are", "eliminated", ".", ")" ]

[ "func", "Schema1FromManifest", "(", "manifest", "[", "]", "<mask>", ")", "(", "*", "Schema1", ",", "error", ")", "{", "s1", ":=", "Schema1", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "manifest", ",", "&", "s1", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "s1", ".", "SchemaVersion", "!=", "1", "{", "return", "nil", ",", "errors", ".", "Errorf", "(", "\"", "\"", ",", "s1", ".", "SchemaVersion", ")", "\n", "}", "\n", "if", "err", ":=", "s1", ".", "initialize", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "err", ":=", "s1", ".", "fixManifestLayers", "(", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "return", "&", "s1", ",", "nil", "\n", "}" ]

[ "ClientAfterOfferingPopUp", "updates", "offering", "in", "db", "or", "retrieves", "from", "somc", "if", "new", "." ]

[ "func", "(", "w", "*", "Worker", ")", "ClientAfterOfferingPopUp", "(", "job", "*", "data", ".", "Job", ")", "error", "{", "logger", ":=", "w", ".", "logger", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", ",", "job", ")", "\n\n", "ethLog", ",", "err", ":=", "w", ".", "ethLog", "(", "logger", ",", "job", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "logger", "=", "logger", ".", "Add", "(", "\"", "\"", ",", "ethLog", ")", "\n\n", "logOfferingPopUp", ",", "err", ":=", "extractLogOfferingPopUp", "(", "logger", ",", "ethLog", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "offering", ":=", "data", ".", "Offering", "{", "}", "\n", "hash", ":=", "data", ".", "HexFromBytes", "(", "logOfferingPopUp", ".", "offeringHash", ".", "Bytes", "(", ")", ")", "\n", "err", "=", "w", ".", "<mask>", ".", "FindOneTo", "(", "&", "offering", ",", "\"", "\"", ",", "hash", ")", "\n", "if", "err", "==", "sql", ".", "ErrNoRows", "{", "// New offering.", "return", "w", ".", "clientRetrieveAndSaveOffering", "(", "logger", ",", "job", ",", "ethLog", ".", "Block", ",", "logOfferingPopUp", ".", "somcType", ",", "logOfferingPopUp", ".", "somcData", ",", "logOfferingPopUp", ".", "agentAddr", ",", "logOfferingPopUp", ".", "offeringHash", ",", "logOfferingPopUp", ".", "currentSupply", ")", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Error", "(", "err", ".", "Error", "(", ")", ")", "\n", "return", "ErrInternal", "\n", "}", "\n\n", "// Existing offering, just update offering status.", "offering", ".", "BlockNumberUpdated", "=", "ethLog", ".", "Block", "\n", "offering", ".", "Status", "=", "data", ".", "OfferPoppedUp", "\n\n", "return", "w", ".", "saveRecord", "(", "logger", ",", "w", ".", "db", ".", "Querier", ",", "&", "offering", ")", "\n", "}" ]

[ "Exit", "the", "backend", "and", "shutdown", "all", "listeners", ".", "Closes", "the", "ShutdownComplete", "chan", "when", "finsihed", "." ]

[ "func", "(", "o", "*", "<mask>", ")", "Exit", "(", ")", "error", "{", "o", ".", "cmdCtrlLock", ".", "Lock", "(", ")", "\n", "defer", "o", ".", "cmdCtrlLock", ".", "Unlock", "(", ")", "\n", "if", "o", ".", "stopped", "{", "o", ".", "backend", ".", "Stop", "(", ")", "\n", "defer", "o", ".", "shutdownFinished", "(", ")", "\n", "return", "nil", "\n", "}", "\n", "close", "(", "o", ".", "ch", ")", "\n", "o", ".", "backend", ".", "StopListenAndServe", "(", ")", "\n", "o", ".", "backend", ".", "Wait", "(", ")", "\n", "o", ".", "backend", ".", "Stop", "(", ")", "\n", "o", ".", "stopped", "=", "true", "\n", "defer", "o", ".", "shutdownFinished", "(", ")", "\n", "return", "nil", "\n", "}" ]

[ "Specify", "the", "value", "of", "a", "uniform", "variable", "for", "a", "specified", "program", "object" ]

[ "func", "ProgramUniformMatrix2fv", "(", "program", "uint32", ",", "location", "int32", ",", "count", "int32", ",", "transpose", "bool", ",", "value", "*", "float32", ")", "{", "syscall", ".", "Syscall6", "(", "gpProgramUniformMatrix2fv", ",", "5", ",", "uintptr", "(", "program", ")", ",", "uintptr", "(", "location", ")", ",", "uintptr", "(", "<mask>", ")", ",", "boolToUintptr", "(", "transpose", ")", ",", "uintptr", "(", "unsafe", ".", "Pointer", "(", "value", ")", ")", ",", "0", ")", "\n", "}" ]

[ "RuleName", "returns", "a", "name", "for", "a", "proto_library", "derived", "from", "the", "given", "strings", ".", "For", "each", "string", "RuleName", "will", "look", "for", "a", "non", "-", "empty", "suffix", "of", "identifier", "characters", "and", "then", "append", "_proto", "to", "that", "." ]

[ "func", "RuleName", "(", "names", "...", "string", ")", "string", "{", "<mask>", ":=", "\"", "\"", "\n", "for", "_", ",", "name", ":=", "range", "names", "{", "notIdent", ":=", "func", "(", "c", "rune", ")", "bool", "{", "return", "!", "(", "'A'", "<=", "c", "&&", "c", "<=", "'Z'", "||", "'a'", "<=", "c", "&&", "c", "<=", "'z'", "||", "'0'", "<=", "c", "&&", "c", "<=", "'9'", "||", "c", "==", "'_'", ")", "\n", "}", "\n", "if", "i", ":=", "strings", ".", "LastIndexFunc", "(", "name", ",", "notIdent", ")", ";", "i", ">=", "0", "{", "name", "=", "name", "[", "i", "+", "1", ":", "]", "\n", "}", "\n", "if", "name", "!=", "\"", "\"", "{", "base", "=", "name", "\n", "break", "\n", "}", "\n", "}", "\n", "return", "base", "+", "\"", "\"", "\n", "}" ]

[ "Claim", "validator" ]

[ "func", "(", "c", "*", "chainedRule", ")", "Claim", "(", "reqCtx", "*", "fasthttp", ".", "RequestCtx", ")", "bool", "{", "if", "!", "c", ".", "Rule", ".", "Claim", "(", "reqCtx", ")", "{", "return", "false", "\n", "}", "\n", "return", "c", ".", "<mask>", ".", "Claim", "(", "reqCtx", ")", "\n", "}" ]

[ "onlyRelevantFiles", "processes", "only", ".", "go", "files", "excluding", "folders", "like", "node_modules", "and", "vendor", "." ]

[ "func", "onlyRelevantFiles", "(", "p", "string", ",", "fi", "<mask>", ".", "FileInfo", ",", "err", "error", ",", "fn", "func", "(", "p", "string", ")", "error", ")", "error", "{", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "fi", ".", "IsDir", "(", ")", "{", "base", ":=", "filepath", ".", "Base", "(", "p", ")", "\n", "if", "strings", ".", "HasPrefix", "(", "base", ",", "\"", "\"", ")", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n", "for", "_", ",", "n", ":=", "range", "[", "]", "string", "{", "\"", "\"", ",", "\"", "\"", ",", "\"", "\"", "}", "{", "if", "base", "==", "n", "{", "return", "filepath", ".", "SkipDir", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}", "\n\n", "ext", ":=", "filepath", ".", "Ext", "(", "p", ")", "\n", "if", "ext", "!=", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "return", "fn", "(", "p", ")", "\n", "}" ]

[ "Object", "gets", "the", "pfs", "object", "for", "this", "writer", ".", "This", "can", "only", "be", "called", "when", "the", "writer", "is", "closed", "(", "the", "put", "object", "call", "is", "complete", ")" ]

[ "func", "(", "w", "*", "PutObjectWriteCloserAsync", ")", "Object", "(", ")", "(", "*", "pfs", ".", "Object", ",", "error", ")", "{", "<mask>", "{", "case", "err", ":=", "<-", "w", ".", "errChan", ":", "if", "err", "!=", "nil", "{", "return", "nil", ",", "grpcutil", ".", "ScrubGRPC", "(", "err", ")", "\n", "}", "\n", "return", "w", ".", "object", ",", "nil", "\n", "default", ":", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

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

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

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

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

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

[ "func", "(", "d", "*", "DashboardConditionalFormat", ")", "GetPaletteOk", "(", ")", "(", "string", ",", "bool", ")", "{", "if", "d", "==", "nil", "||", "d", ".", "Palette", "==", "nil", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n", "return", "*", "d", ".", "Palette", ",", "<mask>", "\n", "}" ]

[ "UUIDForMOID", "returns", "the", "managed", "object", "reference", "ID", "for", "a", "specific", "virtual", "machine", "MOID", "and", "returns", "a", "MOIDForUUIDResult", "with", "the", "appropriate", "association", "." ]

[ "func", "UUIDForMOID", "(", "client", "*", "govmomi", ".", "Client", ",", "moid", "string", ")", "(", "MOIDForUUIDResult", ",", "error", ")", "{", "vm", ",", "err", ":=", "FromMOID", "(", "<mask>", ",", "moid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "MOIDForUUIDResult", "{", "}", ",", "err", "\n", "}", "\n", "props", ",", "err", ":=", "Properties", "(", "vm", ")", "\n", "if", "err", "!=", "nil", "{", "return", "MOIDForUUIDResult", "{", "}", ",", "err", "\n", "}", "\n", "return", "MOIDForUUIDResult", "{", "UUID", ":", "props", ".", "Config", ".", "Uuid", ",", "MOID", ":", "vm", ".", "Reference", "(", ")", ".", "Value", ",", "}", ",", "nil", "\n", "}" ]

[ "keyFunc", "returns", "or", "accumulates", "key", "dependencies", "." ]

[ "func", "keyFunc", "(", "b", "*", "Brain", ",", "used", ",", "missing", "*", "dep", ".", "Set", ")", "func", "(", "string", ")", "(", "string", ",", "error", ")", "{", "return", "func", "(", "s", "string", ")", "(", "string", ",", "error", ")", "{", "if", "len", "(", "s", ")", "==", "0", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n\n", "d", ",", "err", ":=", "dep", ".", "NewKVGetQuery", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "\"", "\"", ",", "err", "\n", "}", "\n", "d", ".", "EnableBlocking", "(", ")", "\n\n", "used", ".", "Add", "(", "d", ")", "\n\n", "if", "<mask>", ",", "ok", ":=", "b", ".", "Recall", "(", "d", ")", ";", "ok", "{", "if", "value", "==", "nil", "{", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "return", "value", ".", "(", "string", ")", ",", "nil", "\n", "}", "\n\n", "missing", ".", "Add", "(", "d", ")", "\n\n", "return", "\"", "\"", ",", "nil", "\n", "}", "\n", "}" ]

[ "SliceContainsString", "returns", "if", "slice", "contains", "substring" ]

[ "func", "SliceContainsString", "(", "a", "string", ",", "list", "[", "]", "string", ")", "bool", "{", "for", "_", ",", "b", ":=", "range", "list", "{", "if", "strings", ".", "Contains", "(", "b", ",", "a", ")", "{", "return", "<mask>", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "Run", "uploads", "artifacts", "with", "the", "specified", "options", "forever", ".", "Sends", "a", "stop", "message", "to", "the", "artifact", "uploader", "when", "it", "is", "interrupted", "." ]

[ "func", "(", "o", "*", "<mask>", ")", "Run", "(", ")", "error", "{", "clusterConfig", ",", "err", ":=", "loadClusterConfig", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "client", ",", "err", ":=", "kubernetes", ".", "NewForConfig", "(", "clusterConfig", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "prowJobClient", ",", "err", ":=", "kube", ".", "NewClientInCluster", "(", "o", ".", "ProwJobNamespace", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "controller", ":=", "artifact_uploader", ".", "NewController", "(", "client", ".", "CoreV1", "(", ")", ",", "prowJobClient", ",", "o", ".", "Options", ")", "\n\n", "stop", ":=", "make", "(", "chan", "struct", "{", "}", ")", "\n", "defer", "close", "(", "stop", ")", "\n", "go", "controller", ".", "Run", "(", "o", ".", "NumWorkers", ",", "stop", ")", "\n\n", "// Wait forever", "select", "{", "}", "\n", "}" ]

[ "String", "returns", "a", "human", "-", "readable", "representation", "of", "the", "node", "info", "." ]

[ "func", "(", "info", "NodeInfo2", ")", "String", "(", ")", "string", "{", "if", "len", "(", "info", ".", "Hostname", ")", "!=", "0", "{", "return", "info", ".", "Hostname", "\n", "}", "\n", "return", "makeBroadcastAddress", "(", "info", ".", "BroadcastAddress", ",", "<mask>", ".", "HttpPort", ")", "\n", "}" ]

[ "NOTE", ":", "secret", "should", "be", "the", "output", "of", "a", "KDF", "like", "bcrypt", "if", "it", "s", "derived", "from", "user", "input", "." ]

[ "func", "GenPrivKeyEd25519FromSecret", "(", "secret", "[", "]", "byte", ")", "PrivKeyEd25519", "{", "privKey32", ":=", "Sha256", "(", "secret", ")", "// Not Ripemd160 because we want 32 bytes.", "\n", "privKeyBytes", ":=", "<mask>", "(", "[", "64", "]", "byte", ")", "\n", "copy", "(", "privKeyBytes", "[", ":", "32", "]", ",", "privKey32", ")", "\n", "ed25519", ".", "MakePublicKey", "(", "privKeyBytes", ")", "\n", "return", "PrivKeyEd25519", "(", "*", "privKeyBytes", ")", "\n", "}" ]

[ "RawString", "returns", "v", "s", "string", "value", ".", "If", "v", ".", "Kind", "()", "!", "=", "String", "RawString", "returns", "the", "empty", "string", "." ]

[ "func", "(", "v", "Value", ")", "RawString", "(", ")", "string", "{", "x", ",", "ok", ":=", "v", ".", "data", ".", "(", "string", ")", "\n", "if", "!", "<mask>", "{", "return", "\"", "\"", "\n", "}", "\n", "return", "x", "\n", "}" ]

[ "func", "recoverMessage", "(", "line", "string", ")", "{", "if", "err", ":", "=", "recover", "()", ";", "err", "!", "=", "nil", "{", "log", ".", "Println", "(", "line", ")", "log", ".", "Println", "(", "err", ")", "log", ".", "Println", "(", "string", "(", "debug", ".", "Stack", "()", "))", "}", "}", "parseMessageType", "parses", "a", "message", "type", "from", "an", "irc", "COMMAND", "string" ]

[ "func", "parseMessageType", "(", "messageType", "string", ")", "MessageType", "{", "if", "mt", ",", "ok", ":=", "messageTypeMap", "[", "messageType", "]", ";", "<mask>", "{", "return", "mt", ".", "Type", "\n", "}", "\n\n", "return", "UNSET", "\n", "}" ]

[ "UpdateOrgs", "sets", "the", "default", "isolation", "segment", "for", "each", "org", "as", "specified", "in", "the", "cf", "-", "mgmt", "config", "." ]

[ "func", "(", "u", "*", "Updater", ")", "UpdateOrgs", "(", ")", "error", "{", "ocs", ",", "err", ":=", "u", ".", "Cfg", ".", "GetOrgConfigs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "oc", ":=", "range", "ocs", "{", "org", ",", "err", ":=", "u", ".", "OrgManager", ".", "FindOrg", "(", "oc", ".", "Org", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n", "isolationSegmentMap", ",", "err", ":=", "u", ".", "isolationSegmentMap", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "isolationSegmentGUID", ",", "err", ":=", "u", ".", "getIsolationSegmentGUID", "(", "oc", ".", "DefaultIsoSegment", ",", "isolationSegmentMap", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "org", ".", "DefaultIsolationSegmentGuid", "!=", "isolationSegmentGUID", "{", "if", "u", ".", "Peek", "{", "if", "isolationSegmentGUID", "!=", "\"", "\"", "{", "lo", ".", "G", ".", "Infof", "(", "\"", "\"", ",", "oc", ".", "Org", ",", "oc", ".", "DefaultIsoSegment", ")", "\n", "}", "else", "{", "lo", ".", "G", ".", "Infof", "(", "\"", "\"", ",", "oc", ".", "Org", ")", "\n", "}", "\n", "continue", "\n", "}", "\n\n", "if", "isolationSegmentGUID", "!=", "\"", "\"", "{", "lo", ".", "G", ".", "Infof", "(", "\"", "\"", ",", "oc", ".", "Org", ",", "oc", ".", "DefaultIsoSegment", ")", "\n", "err", "=", "u", ".", "Client", ".", "DefaultIsolationSegmentForOrg", "(", "org", ".", "Guid", ",", "isolationSegmentGUID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "else", "{", "lo", ".", "G", ".", "Infof", "(", "\"", "\"", ",", "oc", ".", "Org", ")", "\n", "err", "=", "u", ".", "<mask>", ".", "ResetDefaultIsolationSegmentForOrg", "(", "org", ".", "Guid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

[ "func", "(", "c", "*", "ChannelSlackRequest", ")", "GetAccountOk", "(", ")", "(", "string", ",", "bool", ")", "{", "if", "c", "==", "nil", "||", "c", ".", "Account", "==", "nil", "{", "return", "\"", "\"", ",", "<mask>", "\n", "}", "\n", "return", "*", "c", ".", "Account", ",", "true", "\n", "}" ]

[ "Copy", "copies", "file", "in", "source", "to", "file", "in", "dest", "preserving", "the", "mode", "attributes", "." ]

[ "func", "Copy", "(", "source", ",", "dest", "string", ")", "(", "err", "error", ")", "{", "// Don't backup files of backup.", "if", "dest", "[", "len", "(", "dest", ")", "-", "1", "]", "!=", "'~'", "{", "if", "err", "=", "Backup", "(", "dest", ")", ";", "err", "!=", "nil", "{", "return", "\n", "}", "\n", "}", "\n\n", "srcFile", ",", "err", ":=", "os", ".", "Open", "(", "source", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "defer", "func", "(", ")", "{", "err2", ":=", "srcFile", ".", "Close", "(", ")", "\n", "if", "err2", "!=", "nil", "&&", "err", "==", "nil", "{", "err", "=", "err2", "\n", "}", "\n", "}", "(", ")", "\n\n", "srcInfo", ",", "err", ":=", "os", ".", "Stat", "(", "source", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "dstFile", ",", "err", ":=", "os", ".", "OpenFile", "(", "dest", ",", "os", ".", "O_WRONLY", "|", "os", ".", "O_CREATE", "|", "<mask>", ".", "O_TRUNC", ",", "srcInfo", ".", "Mode", "(", ")", ".", "Perm", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "_", ",", "err", "=", "io", ".", "Copy", "(", "dstFile", ",", "srcFile", ")", "\n", "err2", ":=", "dstFile", ".", "Close", "(", ")", "\n", "if", "err2", "!=", "nil", "&&", "err", "==", "nil", "{", "err", "=", "err2", "\n", "}", "\n", "return", "\n", "}" ]

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

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

[ "ContainsAll", "returns", "whether", "the", "set", "contains", "all", "given", "values" ]

[ "func", "(", "us", "*", "unsafeSet", ")", "ContainsAll", "(", "values", "[", "]", "string", ")", "bool", "{", "for", "_", ",", "s", ":=", "range", "values", "{", "if", "!", "us", ".", "Contains", "(", "s", ")", "{", "return", "<mask>", "\n", "}", "\n", "}", "\n", "return", "true", "\n", "}" ]

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

[ "func", "(", "s", "*", "SyntheticsTest", ")", "GetModifiedAtOk", "(", ")", "(", "string", ",", "bool", ")", "{", "if", "s", "==", "nil", "||", "s", ".", "ModifiedAt", "==", "nil", "{", "return", "\"", "\"", ",", "false", "\n", "}", "\n", "return", "*", "s", ".", "ModifiedAt", ",", "<mask>", "\n", "}" ]

[ "NewSimpleWithContext", "creates", "a", "basic", "implementation", "of", "the", "Worker", "interface", "that", "is", "backed", "using", "just", "the", "standard", "library", "and", "goroutines", "." ]

[ "func", "NewSimpleWithContext", "(", "ctx", "context", ".", "Context", ")", "*", "Simple", "{", "ctx", ",", "cancel", ":=", "context", ".", "WithCancel", "(", "ctx", ")", "\n\n", "l", ":=", "logrus", ".", "New", "(", ")", "\n", "l", ".", "Level", "=", "logrus", ".", "InfoLevel", "\n", "l", ".", "Formatter", "=", "&", "logrus", ".", "TextFormatter", "{", "}", "\n\n", "return", "&", "Simple", "{", "Logger", ":", "l", ",", "ctx", ":", "ctx", ",", "cancel", ":", "cancel", ",", "handlers", ":", "map", "[", "string", "]", "<mask>", "{", "}", ",", "moot", ":", "&", "sync", ".", "Mutex", "{", "}", ",", "}", "\n", "}" ]

[ "DeleteGraphByCID", "deletes", "graph", "with", "passed", "cid", "." ]

[ "func", "(", "a", "*", "API", ")", "DeleteGraphByCID", "(", "cid", "CIDType", ")", "(", "bool", ",", "error", ")", "{", "if", "cid", "==", "nil", "||", "*", "cid", "==", "\"", "\"", "{", "return", "false", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "graphCID", ":=", "string", "(", "*", "cid", ")", "\n\n", "matched", ",", "err", ":=", "regexp", ".", "MatchString", "(", "config", ".", "GraphCIDRegex", ",", "graphCID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n", "if", "!", "matched", "{", "return", "<mask>", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "graphCID", ")", "\n", "}", "\n\n", "_", ",", "err", "=", "a", ".", "Delete", "(", "graphCID", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "Delete", "implements", "ClientInterface" ]

[ "func", "(", "c", "*", "Client", ")", "Delete", "(", "name", "string", ",", "options", "*", "v1", ".", "DeleteOptions", ")", "error", "{", "return", "c", ".", "cl", ".", "Delete", "(", ")", ".", "Namespace", "(", "c", ".", "<mask>", ")", ".", "Resource", "(", "c", ".", "t", ".", "Plural", ")", ".", "Name", "(", "name", ")", ".", "Body", "(", "options", ")", ".", "Do", "(", ")", ".", "Error", "(", ")", "\n", "}" ]

[ "CreateRuleSetGroup", "creates", "a", "new", "rule", "set", "group", "." ]

[ "func", "(", "a", "*", "API", ")", "CreateRuleSetGroup", "(", "cfg", "*", "RuleSetGroup", ")", "(", "*", "RuleSetGroup", ",", "error", ")", "{", "if", "cfg", "==", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "jsonCfg", ",", "err", ":=", "json", ".", "Marshal", "(", "cfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "a", ".", "Debug", "{", "a", ".", "Log", ".", "Printf", "(", "\"", "\"", ",", "string", "(", "jsonCfg", ")", ")", "\n", "}", "\n\n", "result", ",", "err", ":=", "a", ".", "Post", "(", "config", ".", "RuleSetGroupPrefix", ",", "jsonCfg", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "group", ":=", "&", "RuleSetGroup", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "result", ",", "group", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "<mask>", ",", "nil", "\n", "}" ]

[ "MustHash", "retrieves", "the", "Hash", "value", "from", "the", "union", "panicing", "if", "the", "value", "is", "not", "set", "." ]

[ "func", "(", "u", "Memo", ")", "MustHash", "(", ")", "Hash", "{", "val", ",", "ok", ":=", "u", ".", "GetHash", "(", ")", "\n\n", "if", "!", "<mask>", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n\n", "return", "val", "\n", "}" ]

[ "labels", "parses", "a", "list", "of", "labelnames", ".", "(", "<label_name", ">", "...", ")" ]

[ "func", "(", "p", "*", "parser", ")", "labels", "(", ")", "[", "]", "string", "{", "const", "ctx", "=", "\"", "\"", "\n\n", "p", ".", "expect", "(", "ItemLeftParen", ",", "ctx", ")", "\n\n", "labels", ":=", "[", "]", "string", "{", "}", "\n", "if", "p", ".", "peek", "(", ")", ".", "typ", "!=", "ItemRightParen", "{", "for", "{", "<mask>", ":=", "p", ".", "next", "(", ")", "\n", "if", "!", "isLabel", "(", "id", ".", "val", ")", "{", "p", ".", "errorf", "(", "\"", "\"", ",", "id", ".", "desc", "(", ")", ",", "ctx", ")", "\n", "}", "\n", "labels", "=", "append", "(", "labels", ",", "id", ".", "val", ")", "\n\n", "if", "p", ".", "peek", "(", ")", ".", "typ", "!=", "ItemComma", "{", "break", "\n", "}", "\n", "p", ".", "next", "(", ")", "\n", "}", "\n", "}", "\n", "p", ".", "expect", "(", "ItemRightParen", ",", "ctx", ")", "\n\n", "return", "labels", "\n", "}" ]

[ "Make", "sure", "all", "the", "required", "information", "is", "there" ]

[ "func", "validateCommandLine", "(", "cmdLine", "*", "cmd", ".", "CommandLine", ")", "{", "if", "cmdLine", ".", "Command", "==", "\"", "\"", "||", "cmdLine", ".", "Command", "==", "\"", "\"", "||", "cmdLine", ".", "Command", "==", "\"", "\"", "||", "cmdLine", ".", "ShowHelp", "||", "cmdLine", ".", "RL10", "{", "<mask>", "\n", "}", "\n", "if", "cmdLine", ".", "Account", "==", "0", "&&", "cmdLine", ".", "OAuthToken", "==", "\"", "\"", "&&", "cmdLine", ".", "OAuthAccessToken", "==", "\"", "\"", "&&", "cmdLine", ".", "APIToken", "==", "\"", "\"", "&&", "!", "cmdLine", ".", "NoAuth", "{", "kingpin", ".", "Fatalf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cmdLine", ".", "Host", "==", "\"", "\"", "{", "kingpin", ".", "Fatalf", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "cmdLine", ".", "Password", "==", "\"", "\"", "&&", "cmdLine", ".", "OAuthToken", "==", "\"", "\"", "&&", "cmdLine", ".", "OAuthAccessToken", "==", "\"", "\"", "&&", "cmdLine", ".", "APIToken", "==", "\"", "\"", "&&", "!", "cmdLine", ".", "NoAuth", "{", "kingpin", ".", "Fatalf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "retrieve", "the", "location", "of", "a", "sample" ]

[ "func", "GetMultisamplefv", "(", "pname", "uint32", ",", "index", "uint32", ",", "val", "*", "float32", ")", "{", "C", ".", "glowGetMultisamplefv", "(", "gpGetMultisamplefv", ",", "(", "C", ".", "GLenum", ")", "(", "pname", ")", ",", "(", "C", ".", "GLuint", ")", "(", "<mask>", ")", ",", "(", "*", "C", ".", "GLfloat", ")", "(", "unsafe", ".", "Pointer", "(", "val", ")", ")", ")", "\n", "}" ]

[ "Type", "is", "a", "wrapper", "around", "the", "G_VALUE_HOLDS_GTYPE", "()", "macro", "and", "the", "g_value_get_gtype", "()", "function", ".", "GetType", "()", "returns", "TYPE_INVALID", "if", "v", "does", "not", "hold", "a", "Type", "or", "otherwise", "returns", "the", "Type", "of", "v", "." ]

[ "func", "(", "v", "*", "Value", ")", "Type", "(", ")", "(", "actual", "Type", ",", "fundamental", "<mask>", ",", "err", "error", ")", "{", "if", "!", "gobool", "(", "C", ".", "_g_is_value", "(", "v", ".", "native", "(", ")", ")", ")", "{", "return", "actual", ",", "fundamental", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "cActual", ":=", "C", ".", "_g_value_type", "(", "v", ".", "native", "(", ")", ")", "\n", "cFundamental", ":=", "C", ".", "_g_value_fundamental", "(", "cActual", ")", "\n", "return", "Type", "(", "cActual", ")", ",", "Type", "(", "cFundamental", ")", ",", "nil", "\n", "}" ]

[ "GenFirebird", "generates", "a", "firebirdsql", "DSN", "from", "the", "passed", "URL", "." ]

[ "func", "GenFirebird", "(", "u", "*", "URL", ")", "(", "string", ",", "error", ")", "{", "z", ":=", "&", "url", ".", "URL", "{", "User", ":", "u", ".", "User", ",", "Host", ":", "u", ".", "Host", ",", "Path", ":", "u", ".", "Path", ",", "RawPath", ":", "u", ".", "RawPath", ",", "RawQuery", ":", "u", ".", "RawQuery", ",", "Fragment", ":", "u", ".", "Fragment", ",", "}", "\n", "return", "strings", ".", "TrimPrefix", "(", "z", ".", "<mask>", "(", ")", ",", "\"", "\"", ")", ",", "nil", "\n", "}" ]

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

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

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

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

[ "injectSource", "adds", "the", "custom", "source", "container", "to", "call", "clonerefs", "correctly", ".", "Returns", "true", "if", "it", "added", "this", "container", "Does", "nothing", "if", "the", "build", "spec", "predefines", "Source" ]

[ "func", "injectSource", "(", "b", "*", "buildv1alpha1", ".", "Build", ",", "pj", "prowjobv1", ".", "ProwJob", ")", "(", "bool", ",", "error", ")", "{", "if", "b", ".", "Spec", ".", "Source", "!=", "nil", "{", "return", "false", ",", "nil", "\n", "}", "\n", "srcContainer", ",", "refs", ",", "cloneVolumes", ",", "err", ":=", "decorate", ".", "CloneRefs", "(", "pj", ",", "codeMount", ",", "logMount", ")", "\n", "if", "err", "!=", "nil", "{", "return", "<mask>", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "srcContainer", "==", "nil", "{", "return", "false", ",", "nil", "\n", "}", "else", "{", "srcContainer", ".", "Name", "=", "\"", "\"", "// knative-build requirement", "\n", "}", "\n\n", "b", ".", "Spec", ".", "Source", "=", "&", "buildv1alpha1", ".", "SourceSpec", "{", "Custom", ":", "srcContainer", ",", "}", "\n", "b", ".", "Spec", ".", "Volumes", "=", "append", "(", "b", ".", "Spec", ".", "Volumes", ",", "cloneVolumes", "...", ")", "\n\n", "wd", ":=", "workDir", "(", "refs", "[", "0", "]", ")", "\n", "// Inject correct working directory", "for", "i", ":=", "range", "b", ".", "Spec", ".", "Steps", "{", "if", "b", ".", "Spec", ".", "Steps", "[", "i", "]", ".", "WorkingDir", "!=", "\"", "\"", "{", "continue", "\n", "}", "\n", "b", ".", "Spec", ".", "Steps", "[", "i", "]", ".", "WorkingDir", "=", "wd", ".", "Value", "\n", "}", "\n", "if", "b", ".", "Spec", ".", "Template", "!=", "nil", "{", "// Best we can do for a template is to set WORKDIR", "b", ".", "Spec", ".", "Template", ".", "Arguments", "=", "append", "(", "b", ".", "Spec", ".", "Template", ".", "Arguments", ",", "wd", ")", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "CreateSpaceQuotas", "-" ]

[ "func", "(", "m", "*", "Manager", ")", "CreateSpaceQuotas", "(", ")", "error", "{", "spaceConfigs", ",", "err", ":=", "m", ".", "Cfg", ".", "GetSpaceConfigs", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "for", "_", ",", "input", ":=", "range", "spaceConfigs", "{", "spaceQuotas", ",", "err", ":=", "m", ".", "Cfg", ".", "GetSpaceQuotas", "(", "input", ".", "Org", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "space", ",", "err", ":=", "m", ".", "SpaceMgr", ".", "FindSpace", "(", "input", ".", "Org", ",", "input", ".", "Space", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "quotas", ",", "err", ":=", "m", ".", "ListAllSpaceQuotasForOrg", "(", "space", ".", "OrganizationGuid", ")", "\n", "if", "err", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err", ",", "\"", "\"", ")", "\n", "}", "\n\n", "orgQuotas", ",", "err", ":=", "m", ".", "Client", ".", "ListOrgQuotas", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "for", "_", ",", "spaceQuotaConfig", ":=", "range", "spaceQuotas", "{", "err", "=", "m", ".", "createSpaceQuota", "(", "spaceQuotaConfig", ",", "space", ",", "quotas", ",", "orgQuotas", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n\n", "if", "input", ".", "NamedQuota", "!=", "\"", "\"", "&&", "input", ".", "EnableSpaceQuota", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "input", ".", "NamedQuota", ",", "input", ".", "Org", ",", "<mask>", ".", "Space", ")", "\n", "}", "\n", "if", "input", ".", "EnableSpaceQuota", "||", "input", ".", "NamedQuota", "!=", "\"", "\"", "{", "if", "input", ".", "EnableSpaceQuota", "{", "quotaDef", ":=", "input", ".", "GetQuota", "(", ")", "\n", "err", "=", "m", ".", "createSpaceQuota", "(", "quotaDef", ",", "space", ",", "quotas", ",", "orgQuotas", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "input", ".", "NamedQuota", "=", "input", ".", "Space", "\n", "}", "\n", "spaceQuota", ":=", "quotas", "[", "input", ".", "NamedQuota", "]", "\n", "if", "space", ".", "QuotaDefinitionGuid", "!=", "spaceQuota", ".", "Guid", "{", "if", "err", "=", "m", ".", "AssignQuotaToSpace", "(", "space", ",", "spaceQuota", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

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

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

[ "StatsTags", "returns", "the", "stats", "tags", "for", "this", "subchannel", "." ]

[ "func", "(", "c", "*", "SubChannel", ")", "StatsTags", "(", ")", "<mask>", "[", "string", "]", "string", "{", "tags", ":=", "c", ".", "topChannel", ".", "StatsTags", "(", ")", "\n", "tags", "[", "\"", "\"", "]", "=", "c", ".", "serviceName", "\n", "return", "tags", "\n", "}" ]

[ "WriteTo", "writes", "the", "TupleHeader", "into", "the", "given", "writer", "." ]

[ "func", "(", "t", "*", "TupleHeader", ")", "WriteTo", "(", "w", "io", ".", "Writer", ")", "(", "int64", ",", "error", ")", "{", "if", "len", "(", "t", ".", "Offsets", ")", "!=", "int", "(", "t", ".", "FieldCount", ")", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "// Encode Header", "dst", ":=", "make", "(", "[", "]", "byte", ",", "t", ".", "Size", "(", ")", ")", "\n", "dst", "[", "0", "]", "=", "byte", "(", "t", ".", "TupleVersion", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "dst", "[", "1", ":", "]", ",", "t", ".", "NamespaceHash", ")", "\n", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "dst", "[", "5", ":", "]", ",", "t", ".", "Hash", ")", "\n", "<mask>", ".", "LittleEndian", ".", "PutUint32", "(", "dst", "[", "9", ":", "]", ",", "t", ".", "FieldCount", ")", "\n\n", "pos", ":=", "int64", "(", "13", ")", "\n", "switch", "t", ".", "FieldSize", "{", "case", "1", ":", "// Write field offsets", "for", "_", ",", "offset", ":=", "range", "t", ".", "Offsets", "{", "dst", "[", "pos", "]", "=", "byte", "(", "offset", ")", "\n", "pos", "++", "\n", "}", "\n", "case", "2", ":", "// Set size enum", "dst", "[", "0", "]", "|=", "64", "\n\n", "// Write field offsets", "for", "_", ",", "offset", ":=", "range", "t", ".", "Offsets", "{", "binary", ".", "LittleEndian", ".", "PutUint16", "(", "dst", "[", "pos", ":", "]", ",", "uint16", "(", "offset", ")", ")", "\n", "pos", "+=", "2", "\n", "}", "\n", "case", "4", ":", "// Set size enum", "dst", "[", "0", "]", "|=", "128", "\n\n", "// Write field offsets", "for", "_", ",", "offset", ":=", "range", "t", ".", "Offsets", "{", "binary", ".", "LittleEndian", ".", "PutUint32", "(", "dst", "[", "pos", ":", "]", ",", "uint32", "(", "offset", ")", ")", "\n", "pos", "+=", "4", "\n", "}", "\n", "case", "8", ":", "// Set size enum", "dst", "[", "0", "]", "|=", "192", "\n\n", "// Write field offsets", "for", "_", ",", "offset", ":=", "range", "t", ".", "Offsets", "{", "binary", ".", "LittleEndian", ".", "PutUint64", "(", "dst", "[", "pos", ":", "]", ",", "offset", ")", "\n", "pos", "+=", "8", "\n", "}", "\n", "default", ":", "return", "pos", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "n", ",", "err", ":=", "w", ".", "Write", "(", "dst", ")", "\n", "return", "int64", "(", "n", ")", ",", "err", "\n", "}" ]

[ "NewClusteringIndex", "creates", "index", "that", "clusters", "the", "points", "at", "three", "levels", "with", "cell", "size", "0", ".", "5", "5", "and", "500km", ".", "Useful", "for", "creating", "maps", "." ]

[ "func", "NewClusteringIndex", "(", ")", "*", "ClusteringIndex", "{", "index", ":=", "&", "ClusteringIndex", "{", "}", "\n", "index", ".", "streetLevel", "=", "NewPointsIndex", "(", "Km", "(", "0.5", ")", ")", "\n", "index", ".", "cityLevel", "=", "NewCountIndex", "(", "Km", "(", "10", ")", ")", "\n", "index", ".", "worldLevel", "=", "NewCountIndex", "(", "Km", "(", "500", ")", ")", "\n\n", "return", "<mask>", "\n", "}" ]

[ "opengdpr_callbacks" ]

[ "func", "postCallback", "(", "opts", "*", "ServerOptions", ")", "Handler", "{", "return", "func", "(", "_", "io", ".", "Writer", ",", "r", "io", ".", "Reader", ",", "_", "httprouter", ".", "Params", ")", "error", "{", "req", ":=", "&", "CallbackRequest", "{", "}", "\n", "err", ":=", "json", ".", "NewDecoder", "(", "r", ")", ".", "Decode", "(", "req", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "return", "opts", ".", "<mask>", ".", "Callback", "(", "req", ")", "\n", "}", "\n", "}" ]

[ "This", "seems", "a", "little", "excessive", "." ]

[ "func", "(", "c", "*", "cmdList", ")", "dotPrefixMatch", "(", "<mask>", "string", ",", "full", "string", ")", "bool", "{", "fullMembs", ":=", "strings", ".", "Split", "(", "full", ",", "\"", "\"", ")", "\n", "shortMembs", ":=", "strings", ".", "Split", "(", "short", ",", "\"", "\"", ")", "\n\n", "if", "len", "(", "fullMembs", ")", "!=", "len", "(", "shortMembs", ")", "{", "return", "false", "\n", "}", "\n\n", "for", "i", ":=", "range", "fullMembs", "{", "if", "!", "strings", ".", "HasPrefix", "(", "fullMembs", "[", "i", "]", ",", "shortMembs", "[", "i", "]", ")", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "go", ":", "generate", "stringer", "-", "type", "=", "reqResReaderState" ]

[ "func", "(", "w", "*", "reqResWriter", ")", "argWriter", "(", "last", "bool", ",", "inState", "reqResWriterState", ",", "outState", "reqResWriterState", ")", "(", "ArgWriter", ",", "error", ")", "{", "if", "w", ".", "err", "!=", "nil", "{", "return", "nil", ",", "w", ".", "err", "\n", "}", "\n\n", "if", "w", ".", "state", "!=", "inState", "{", "return", "nil", ",", "w", ".", "failed", "(", "errReqResWriterStateMismatch", "{", "state", ":", "w", ".", "state", ",", "expectedState", ":", "inState", "}", ")", "\n", "}", "\n\n", "argWriter", ",", "err", ":=", "w", ".", "contents", ".", "ArgWriter", "(", "last", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "w", ".", "<mask>", "(", "err", ")", "\n", "}", "\n\n", "w", ".", "state", "=", "outState", "\n", "return", "argWriter", ",", "nil", "\n", "}" ]

[ "NewV3", "returns", "a", "new", "snapshot", "Manager", "for", "v3", ".", "x", "snapshot", "." ]

[ "func", "NewV3", "(", "lg", "*", "zap", ".", "Logger", ")", "<mask>", "{", "if", "lg", "==", "nil", "{", "lg", "=", "zap", ".", "NewExample", "(", ")", "\n", "}", "\n", "return", "&", "v3Manager", "{", "lg", ":", "lg", "}", "\n", "}" ]

[ "WithContext", "adds", "the", "context", "to", "the", "delete", "apps", "app", "routes", "route", "params" ]

[ "func", "(", "o", "*", "DeleteAppsAppRoutesRouteParams", ")", "WithContext", "(", "ctx", "context", ".", "<mask>", ")", "*", "DeleteAppsAppRoutesRouteParams", "{", "o", ".", "SetContext", "(", "ctx", ")", "\n", "return", "o", "\n", "}" ]

[ "We", "could", "use", "Fallocate", "but", "some", "test", "CI", "systems", "do", "not", "support", "it", "like", "Travis", "-", "ci", ".", "org", "." ]

[ "func", "CreateFile", "(", "<mask>", "string", ",", "size", "int64", ")", "error", "{", "buf", ":=", "make", "(", "[", "]", "byte", ",", "size", ")", "\n\n", "// Create the file store some data", "fp", ",", "err", ":=", "os", ".", "Create", "(", "filename", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// Write the buffer", "_", ",", "err", "=", "fp", ".", "Write", "(", "buf", ")", "\n\n", "// Cleanup", "fp", ".", "Close", "(", ")", "\n\n", "return", "err", "\n", "}" ]

[ "String", "returns", "a", "copy", "of", "this", "VariantType", "s", "type", "string", "." ]

[ "func", "(", "v", "*", "VariantType", ")", "String", "(", ")", "string", "{", "ch", ":=", "C", ".", "g_variant_type_dup_string", "(", "v", ".", "native", "(", ")", ")", "\n", "defer", "C", ".", "g_free", "(", "C", ".", "gpointer", "(", "ch", ")", ")", "\n", "return", "C", ".", "GoString", "(", "(", "*", "C", ".", "<mask>", ")", "(", "ch", ")", ")", "\n", "}" ]

[ "Sub", "returns", "the", "rectangle", "r", "translated", "by", "-", "v", "." ]

[ "func", "(", "r", "Rectangle", ")", "Sub", "(", "v", "Vec2", ")", "Rectangle", "{", "<mask>", "Rectangle", "{", "Vec2", "{", "r", ".", "Min", "[", "0", "]", "-", "v", "[", "0", "]", ",", "r", ".", "Min", "[", "1", "]", "-", "v", "[", "1", "]", "}", ",", "Vec2", "{", "r", ".", "Max", "[", "0", "]", "-", "v", "[", "0", "]", ",", "r", ".", "Max", "[", "1", "]", "-", "v", "[", "1", "]", "}", ",", "}", "\n", "}" ]

[ "Collect", "implements", "prometheus", ".", "Collector", "." ]

[ "func", "(", "m", "*", "<mask>", ")", "Collect", "(", "ch", "chan", "<-", "prometheus", ".", "Metric", ")", "{", "for", "_", ",", "g", ":=", "range", "m", ".", "RuleGroups", "(", ")", "{", "ch", "<-", "prometheus", ".", "MustNewConstMetric", "(", "groupInterval", ",", "prometheus", ".", "GaugeValue", ",", "g", ".", "interval", ".", "Seconds", "(", ")", ",", "groupKey", "(", "g", ".", "file", ",", "g", ".", "name", ")", ")", "\n", "}", "\n", "}" ]

[ "WithProtocol", "marshal", "options", "to", "toml", "unmarshal", "to", "map", "[", "string", "]", "interface", "{}", "and", "add", "protocol", "key", "to", "them" ]

[ "func", "WithProtocol", "(", "options", "interface", "{", "}", ",", "protocol", "string", ")", "(", "<mask>", "[", "string", "]", "interface", "{", "}", ",", "error", ")", "{", "buf", ":=", "new", "(", "bytes", ".", "Buffer", ")", "\n", "encoder", ":=", "toml", ".", "NewEncoder", "(", "buf", ")", "\n", "encoder", ".", "Indent", "=", "\"", "\"", "\n", "if", "err", ":=", "encoder", ".", "Encode", "(", "options", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", ":=", "make", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n\n", "if", "_", ",", "err", ":=", "toml", ".", "Decode", "(", "buf", ".", "String", "(", ")", ",", "&", "res", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "res", "[", "\"", "\"", "]", "=", "protocol", "\n\n", "return", "res", ",", "nil", "\n", "}" ]

[ "AdminOnly", "middleware", "restricts", "access", "to", "just", "administrators", "." ]

[ "func", "AdminOnly", "(", "next", "http", ".", "Handler", ")", "http", ".", "Handler", "{", "return", "http", ".", "HandlerFunc", "(", "func", "(", "w", "http", ".", "ResponseWriter", ",", "r", "*", "http", ".", "Request", ")", "{", "isAdmin", ",", "ok", ":=", "r", ".", "Context", "(", ")", ".", "Value", "(", "\"", "\"", ")", ".", "(", "bool", ")", "\n", "if", "!", "<mask>", "||", "!", "isAdmin", "{", "http", ".", "Error", "(", "w", ",", "http", ".", "StatusText", "(", "http", ".", "StatusForbidden", ")", ",", "http", ".", "StatusForbidden", ")", "\n", "return", "\n", "}", "\n", "next", ".", "ServeHTTP", "(", "w", ",", "r", ")", "\n", "}", ")", "\n", "}" ]

[ "Find", "paths", "that", "match", "given", "href" ]

[ "func", "(", "r", "*", "Resource", ")", "findMatches", "(", "href", "string", ")", "[", "]", "*", "PathPattern", "{", "var", "matches", "[", "]", "*", "PathPattern", "\n", "for", "_", ",", "<mask>", ":=", "range", "r", ".", "Actions", "{", "for", "_", ",", "pattern", ":=", "range", "action", ".", "PathPatterns", "{", "if", "pattern", ".", "Regexp", ".", "MatchString", "(", "href", ")", "||", "pattern", ".", "Regexp", ".", "MatchString", "(", "href", "+", "\"", "\"", ")", "{", "matches", "=", "append", "(", "matches", ",", "pattern", ")", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "matches", "\n", "}" ]

[ "DockerClient", "creates", "a", "docker", "client", "for", "a", "given", "host", "." ]

[ "func", "DockerClient", "(", "dockerHost", "DockerHost", ")", "(", "*", "dockerclient", ".", "DockerClient", ",", "error", ")", "{", "url", ",", "err", ":=", "dockerHost", ".", "URL", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "tlsConfig", ",", "err", ":=", "cert", ".", "ReadTLSConfig", "(", "url", ",", "dockerHost", ".", "AuthOptions", "(", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n\n", "return", "dockerclient", ".", "NewDockerClient", "(", "<mask>", ",", "tlsConfig", ")", "\n", "}" ]

[ "RelocateVM", "migrates", "a", "virtual", "machine", "to", "a", "datastore", "cluster", "via", "the", "StorageResourceManager", "API", ".", "It", "mimics", "our", "helper", "in", "the", "virtualmachine", "package", "in", "functionality", "." ]

[ "func", "RelocateVM", "(", "client", "*", "govmomi", ".", "Client", ",", "vm", "*", "object", ".", "VirtualMachine", ",", "spec", "types", ".", "VirtualMachineRelocateSpec", ",", "timeout", "int", ",", "pod", "*", "object", ".", "StoragePod", ",", ")", "error", "{", "sdrsEnabled", ",", "err", ":=", "StorageDRSEnabled", "(", "pod", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "sdrsEnabled", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "pod", ".", "Name", "(", ")", ")", "\n", "}", "\n", "log", ".", "Printf", "(", "\"", "\"", ",", "vm", ".", "InventoryPath", ",", "pod", ".", "Name", "(", ")", ",", ")", "\n\n", "sps", ":=", "types", ".", "StoragePlacementSpec", "{", "Vm", ":", "types", ".", "NewReference", "(", "vm", ".", "Reference", "(", ")", ")", ",", "PodSelectionSpec", ":", "<mask>", ".", "StorageDrsPodSelectionSpec", "{", "StoragePod", ":", "types", ".", "NewReference", "(", "pod", ".", "Reference", "(", ")", ")", ",", "}", ",", "Priority", ":", "types", ".", "VirtualMachineMovePriorityDefaultPriority", ",", "RelocateSpec", ":", "&", "spec", ",", "Type", ":", "string", "(", "types", ".", "StoragePlacementSpecPlacementTypeRelocate", ")", ",", "}", "\n\n", "_", ",", "err", "=", "recommendAndApplySDRS", "(", "client", ",", "sps", ",", "time", ".", "Minute", "*", "time", ".", "Duration", "(", "timeout", ")", ")", "\n", "return", "err", "\n", "}" ]

[ "cleanupSnapshot", "cleans", "up", "snapshot", "internal", "C", "handle", "." ]

[ "func", "cleanupSnapshot", "(", "s", "*", "Snapshot", ")", "{", "if", "s", ".", "handle", "!=", "C", ".", "VIX_INVALID_HANDLE", "{", "C", ".", "Vix_ReleaseHandle", "(", "s", ".", "handle", ")", "\n", "s", ".", "<mask>", "=", "C", ".", "VIX_INVALID_HANDLE", "\n", "}", "\n", "}" ]

[ "Session", "returns", "the", "session", "for", "the", "current", "request" ]

[ "func", "(", "c", "*", "Controller", ")", "Session", "(", ")", "Session", "{", "if", "c", ".", "Request", ".", "session", "==", "nil", "{", "c", ".", "Request", ".", "session", "=", "c", ".", "sessionFinder", "(", "c", ".", "<mask>", ")", "\n", "}", "\n", "return", "c", ".", "Request", ".", "session", "\n", "}" ]

[ "RemoveLabel", "removes", "label", "from", "org", "/", "repo#number", "returning", "an", "error", "on", "any", "failure", ".", "See", "https", ":", "//", "developer", ".", "github", ".", "com", "/", "v3", "/", "issues", "/", "labels", "/", "#remove", "-", "a", "-", "label", "-", "from", "-", "an", "-", "issue" ]

[ "func", "(", "c", "*", "Client", ")", "RemoveLabel", "(", "org", ",", "repo", "string", ",", "<mask>", "int", ",", "label", "string", ")", "error", "{", "c", ".", "log", "(", "\"", "\"", ",", "org", ",", "repo", ",", "number", ",", "label", ")", "\n", "code", ",", "body", ",", "err", ":=", "c", ".", "requestRaw", "(", "&", "request", "{", "method", ":", "http", ".", "MethodDelete", ",", "path", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "org", ",", "repo", ",", "number", ",", "label", ")", ",", "// GitHub sometimes returns 200 for this call, which is a bug on their end.", "// Do not expect a 404 exit code and handle it separately because we need", "// to introspect the request's response body.", "exitCodes", ":", "[", "]", "int", "{", "200", ",", "204", "}", ",", "}", ")", "\n\n", "switch", "{", "case", "code", "==", "200", "||", "code", "==", "204", ":", "// If our code was 200 or 204, no error info.", "return", "nil", "\n", "case", "code", "==", "404", ":", "// continue", "case", "err", "!=", "nil", ":", "return", "err", "\n", "default", ":", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "code", ")", "\n", "}", "\n\n", "ge", ":=", "&", "githubError", "{", "}", "\n", "if", "err", ":=", "json", ".", "Unmarshal", "(", "body", ",", "ge", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "// If the error was because the label was not found, we don't really", "// care since the label won't exist anyway.", "if", "ge", ".", "Message", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n\n", "// Otherwise we got some other 404 error.", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "ge", ".", "Message", ")", "\n", "}" ]

[ "DeleteNotification", "deletes", "a", "created", "notification" ]

[ "func", "(", "p", "*", "Pushy", ")", "DeleteNotification", "(", "pushID", "string", ")", "(", "*", "SimpleSuccess", ",", "*", "Error", ",", "error", ")", "{", "url", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "p", ".", "APIEndpoint", ",", "pushID", ",", "p", ".", "APIToken", ")", "\n", "var", "<mask>", "*", "SimpleSuccess", "\n", "var", "pushyErr", "*", "Error", "\n", "err", ":=", "del", "(", "p", ".", "httpClient", ",", "url", ",", "&", "success", ",", "&", "pushyErr", ")", "\n", "return", "success", ",", "pushyErr", ",", "err", "\n", "}" ]

[ "ImContextFilterKeypress", "is", "a", "wrapper", "around", "gtk_text_view_im_context_filter_keypress", "()", "." ]

[ "func", "(", "v", "*", "TextView", ")", "ImContextFilterKeypress", "(", "event", "*", "gdk", ".", "EventKey", ")", "bool", "{", "return", "gobool", "(", "C", ".", "gtk_text_view_im_context_filter_keypress", "(", "v", ".", "native", "(", ")", ",", "(", "*", "C", ".", "GdkEventKey", ")", "(", "unsafe", ".", "Pointer", "(", "<mask>", ".", "Native", "(", ")", ")", ")", ")", ")", "\n", "}" ]

[ "ListGroupUsers", "lists", "Users", "in", "a", "group" ]

[ "func", "(", "c", "*", "Client", ")", "ListGroupUsers", "(", "groupid", "string", ")", "(", "*", "Users", ",", "error", ")", "{", "url", ":=", "umGroupUsers", "(", "groupid", ")", "+", "`?depth=`", "+", "c", ".", "client", ".", "depth", "+", "`&pretty=`", "+", "strconv", ".", "FormatBool", "(", "c", ".", "client", ".", "pretty", ")", "\n", "<mask>", ":=", "&", "Users", "{", "}", "\n", "err", ":=", "c", ".", "client", ".", "Get", "(", "url", ",", "ret", ",", "http", ".", "StatusOK", ")", "\n", "return", "ret", ",", "err", "\n", "}" ]

[ "broadcast", "calls", "all", "handler", "s", "handler", "function" ]

[ "func", "(", "eventStream", "*", "EventStream", ")", "broadcast", "(", "event", "interface", "{", "}", ")", "{", "eventStream", ".", "handlersLock", ".", "RLock", "(", ")", "\n", "defer", "eventStream", ".", "handlersLock", ".", "RUnlock", "(", ")", "\n\n", "seelog", ".", "Debugf", "(", "\"", "\"", ",", "eventStream", ".", "<mask>", ")", "\n\n", "for", "_", ",", "handlerFunc", ":=", "range", "eventStream", ".", "handlers", "{", "go", "handlerFunc", "(", "event", ")", "\n", "}", "\n", "}" ]

[ "Returns", "a", "CvBox2D" ]

[ "func", "(", "box", "*", "Box2D", ")", "CVBox", "(", ")", "C", ".", "CvBox2D", "{", "var", "cvBox", "C", ".", "CvBox2D", "\n", "cvBox", ".", "angle", "=", "C", ".", "float", "(", "box", ".", "angle", ")", "\n", "cvBox", ".", "center", ".", "x", "=", "C", ".", "float", "(", "box", ".", "center", ".", "X", ")", "\n", "cvBox", ".", "center", ".", "y", "=", "C", ".", "float", "(", "box", ".", "center", ".", "Y", ")", "\n", "cvBox", ".", "size", ".", "width", "=", "C", ".", "float", "(", "box", ".", "size", ".", "Width", ")", "\n", "cvBox", ".", "<mask>", ".", "height", "=", "C", ".", "float", "(", "box", ".", "size", ".", "Height", ")", "\n", "return", "cvBox", "\n", "}" ]

[ "RemoveMember", "removes", "a", "member", "from", "the", "store", ".", "The", "given", "id", "MUST", "exist", "or", "the", "function", "panics", "." ]

[ "func", "(", "c", "*", "RaftCluster", ")", "RemoveMember", "(", "id", "types", ".", "ID", ")", "{", "c", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "Unlock", "(", ")", "\n", "if", "c", ".", "v2store", "!=", "nil", "{", "mustDeleteMemberFromStore", "(", "c", ".", "v2store", ",", "id", ")", "\n", "}", "\n", "if", "c", ".", "be", "!=", "nil", "{", "mustDeleteMemberFromBackend", "(", "c", ".", "be", ",", "id", ")", "\n", "}", "\n\n", "m", ",", "ok", ":=", "c", ".", "members", "[", "id", "]", "\n", "delete", "(", "c", ".", "members", ",", "id", ")", "\n", "c", ".", "removed", "[", "id", "]", "=", "true", "\n\n", "if", "c", ".", "lg", "!=", "nil", "{", "if", "ok", "{", "c", ".", "lg", ".", "Info", "(", "\"", "\"", ",", "zap", ".", "String", "(", "\"", "\"", ",", "c", ".", "cid", ".", "String", "(", ")", ")", ",", "zap", ".", "String", "(", "\"", "\"", ",", "c", ".", "localID", ".", "String", "(", ")", ")", ",", "zap", ".", "String", "(", "\"", "\"", ",", "id", ".", "String", "(", ")", ")", ",", "zap", ".", "Strings", "(", "\"", "\"", ",", "m", ".", "PeerURLs", ")", ",", ")", "\n", "}", "else", "{", "c", ".", "lg", ".", "Warn", "(", "\"", "\"", ",", "zap", ".", "String", "(", "\"", "\"", ",", "c", ".", "cid", ".", "String", "(", ")", ")", ",", "zap", ".", "<mask>", "(", "\"", "\"", ",", "c", ".", "localID", ".", "String", "(", ")", ")", ",", "zap", ".", "String", "(", "\"", "\"", ",", "id", ".", "String", "(", ")", ")", ",", ")", "\n", "}", "\n", "}", "else", "{", "plog", ".", "Infof", "(", "\"", "\"", ",", "id", ",", "c", ".", "cid", ")", "\n", "}", "\n", "}" ]

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

[ "func", "(", "r", "*", "Recurrence", ")", "HasUntilOccurrences", "(", ")", "bool", "{", "if", "r", "!=", "nil", "&&", "r", ".", "UntilOccurrences", "!=", "nil", "{", "return", "true", "\n", "}", "\n\n", "return", "<mask>", "\n", "}" ]

[ "PrintRepoInfo", "pretty", "-", "prints", "repo", "info", "." ]

[ "func", "PrintRepoInfo", "(", "w", "<mask>", ".", "Writer", ",", "repoInfo", "*", "pfs", ".", "RepoInfo", ",", "fullTimestamps", "bool", ")", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\"", ",", "repoInfo", ".", "Repo", ".", "Name", ")", "\n", "if", "fullTimestamps", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\"", ",", "repoInfo", ".", "Created", ".", "String", "(", ")", ")", "\n", "}", "else", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\"", ",", "pretty", ".", "Ago", "(", "repoInfo", ".", "Created", ")", ")", "\n", "}", "\n", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\"", ",", "units", ".", "BytesSize", "(", "float64", "(", "repoInfo", ".", "SizeBytes", ")", ")", ")", "\n", "if", "repoInfo", ".", "AuthInfo", "!=", "nil", "{", "fmt", ".", "Fprintf", "(", "w", ",", "\"", "\\t", "\"", ",", "repoInfo", ".", "AuthInfo", ".", "AccessLevel", ".", "String", "(", ")", ")", "\n", "}", "\n", "fmt", ".", "Fprintln", "(", "w", ")", "\n", "}" ]

[ "UnaryServerInterceptor", "logs", "unary", "RPCs", "on", "the", "server", "side" ]

[ "func", "UnaryServerInterceptor", "(", "log", "ttnlog", ".", "Interface", ")", "grpc", ".", "UnaryServerInterceptor", "{", "return", "func", "(", "ctx", "context", ".", "Context", ",", "req", "interface", "{", "}", ",", "<mask>", "*", "grpc", ".", "UnaryServerInfo", ",", "handler", "grpc", ".", "UnaryHandler", ")", "(", "resp", "interface", "{", "}", ",", "err", "error", ")", "{", "log", ":=", "getLog", "(", "log", ")", ".", "WithField", "(", "\"", "\"", ",", "info", ".", "FullMethod", ")", "\n", "log", "=", "log", ".", "WithFields", "(", "FieldsFromIncomingContext", "(", "ctx", ")", ")", "\n", "start", ":=", "time", ".", "Now", "(", ")", "\n", "resp", ",", "err", "=", "handler", "(", "ctx", ",", "req", ")", "\n", "log", "=", "log", ".", "WithField", "(", "\"", "\"", ",", "time", ".", "Since", "(", "start", ")", ")", "\n", "if", "err", "!=", "nil", "{", "log", ".", "WithError", "(", "err", ")", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "log", ".", "Debug", "(", "\"", "\"", ")", "\n", "return", "\n", "}", "\n", "}" ]

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

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

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

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

[ "ClearData", "removes", "a", "key", "/", "value", "pair", "associated", "with", "the", "source", "account" ]

[ "func", "ClearData", "(", "name", "string", ",", "muts", "...", "interface", "{", "}", ")", "(", "result", "ManageDataBuilder", ")", "{", "result", ".", "MD", ".", "DataName", "=", "xdr", ".", "String64", "(", "name", ")", "\n", "<mask>", ".", "MD", ".", "DataValue", "=", "nil", "\n", "result", ".", "validateName", "(", ")", "\n", "result", ".", "Mutate", "(", "muts", "...", ")", "\n", "return", "\n", "}" ]

[ "The", "following", "function", "is", "needed", "because", "the", "CLI", "acrobatics", "that", "we", "re", "doing", "(", "with", "having", "an", "outer", "and", "inner", "function", "each", "with", "their", "own", "custom", "settings", "and", "flag", "parsing", "needs", ")", "are", "not", "well", "supported", "by", "codegangsta", "/", "cli", ".", "Instead", "of", "trying", "to", "make", "a", "convoluted", "series", "of", "flag", "parsing", "and", "relying", "on", "codegangsta", "/", "cli", "internals", "work", "well", "we", "simply", "read", "the", "flags", "we", "re", "interested", "in", "from", "the", "outer", "function", "into", "module", "-", "level", "variables", "and", "then", "use", "them", "from", "the", "inner", "function", ".", "I", "m", "not", "very", "pleased", "about", "this", "but", "it", "seems", "to", "be", "the", "only", "decent", "compromise", "without", "drastically", "modifying", "codegangsta", "/", "cli", "internals", "or", "our", "own", "CLI", "." ]

[ "func", "flagHackLookup", "(", "flagName", "string", ")", "string", "{", "// e.g. \"-d\" for \"--driver\"", "flagPrefix", ":=", "flagName", "[", "1", ":", "3", "]", "\n\n", "// TODO: Should we support -flag-name (single hyphen) syntax as well?", "for", "i", ",", "arg", ":=", "<mask>", "os", ".", "Args", "{", "if", "strings", ".", "Contains", "(", "arg", ",", "flagPrefix", ")", "{", "// format '--driver foo' or '-d foo'", "if", "arg", "==", "flagPrefix", "||", "arg", "==", "flagName", "{", "if", "i", "+", "1", "<", "len", "(", "os", ".", "Args", ")", "{", "return", "os", ".", "Args", "[", "i", "+", "1", "]", "\n", "}", "\n", "}", "\n\n", "// format '--driver=foo' or '-d=foo'", "if", "strings", ".", "HasPrefix", "(", "arg", ",", "flagPrefix", "+", "\"", "\"", ")", "||", "strings", ".", "HasPrefix", "(", "arg", ",", "flagName", "+", "\"", "\"", ")", "{", "return", "strings", ".", "Split", "(", "arg", ",", "\"", "\"", ")", "[", "1", "]", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "\"", "\"", "\n", "}" ]

[ "Returns", "a", "signed", "URL", "for", "Get", "valid", "for", "the", "specified", "duration", ".", "Required", "scopes", ":", "secrets", ":", "get", ":", "<name", ">", "See", "Get", "for", "more", "details", "." ]

[ "func", "(", "secrets", "*", "Secrets", ")", "Get_SignedURL", "(", "name", "string", ",", "duration", "time", ".", "Duration", ")", "(", "*", "url", ".", "URL", ",", "error", ")", "{", "cd", ":=", "tcclient", ".", "Client", "(", "*", "secrets", ")", "\n", "return", "(", "&", "<mask>", ")", ".", "SignedURL", "(", "\"", "\"", "+", "url", ".", "QueryEscape", "(", "name", ")", ",", "nil", ",", "duration", ")", "\n", "}" ]

[ "UpdateRepo", "updates", "all", "branches", "in", "the", "repo", "with", "the", "specified", "defaults" ]

[ "func", "(", "p", "*", "protector", ")", "UpdateRepo", "(", "orgName", "string", ",", "repoName", "string", ",", "repo", "config", ".", "Repo", ")", "error", "{", "p", ".", "completedRepos", "[", "orgName", "+", "\"", "\"", "+", "repoName", "]", "=", "true", "\n\n", "githubRepo", ",", "err", ":=", "p", ".", "client", ".", "GetRepo", "(", "orgName", ",", "repoName", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "if", "githubRepo", ".", "Archived", "{", "// nothing to do", "return", "nil", "\n", "}", "\n\n", "branches", ":=", "map", "[", "string", "]", "github", ".", "Branch", "{", "}", "\n", "for", "_", ",", "onlyProtected", ":=", "range", "[", "]", "bool", "{", "false", ",", "<mask>", "}", "{", "// put true second so b.Protected is set correctly", "bs", ",", "err", ":=", "p", ".", "client", ".", "GetBranches", "(", "orgName", ",", "repoName", ",", "onlyProtected", ")", "\n", "if", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "for", "_", ",", "b", ":=", "range", "bs", "{", "branches", "[", "b", ".", "Name", "]", "=", "b", "\n", "}", "\n", "}", "\n\n", "for", "bn", ",", "githubBranch", ":=", "range", "branches", "{", "if", "branch", ",", "err", ":=", "repo", ".", "GetBranch", "(", "bn", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "bn", ",", "err", ")", "\n", "}", "else", "if", "err", "=", "p", ".", "UpdateBranch", "(", "orgName", ",", "repoName", ",", "bn", ",", "*", "branch", ",", "githubBranch", ".", "Protected", ")", ";", "err", "!=", "nil", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "bn", ",", "githubBranch", ".", "Protected", ",", "err", ")", "\n", "}", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "GetRangeSplitItems", "returns", "nways", "split", "range", "pivots", "of", "the", "skiplist", "items", "Explicit", "barrier", "and", "release", "should", "be", "used", "by", "the", "caller", "before", "and", "after", "this", "function", "call" ]

[ "func", "(", "s", "*", "Skiplist", ")", "GetRangeSplitItems", "(", "nways", "int", ")", "[", "]", "unsafe", ".", "Pointer", "{", "var", "deleted", "bool", "\n", "repeat", ":", "var", "itms", "[", "]", "unsafe", ".", "Pointer", "\n", "var", "finished", "bool", "\n\n", "l", ":=", "int", "(", "atomic", ".", "LoadInt32", "(", "&", "s", ".", "level", ")", ")", "\n", "for", ";", "l", ">=", "0", ";", "l", "--", "{", "c", ":=", "int", "(", "atomic", ".", "LoadInt64", "(", "&", "s", ".", "Stats", ".", "levelNodesCount", "[", "l", "]", ")", "+", "1", ")", "\n", "if", "c", ">=", "nways", "{", "perSplit", ":=", "c", "/", "nways", "\n", "node", ":=", "s", ".", "head", "\n", "for", "j", ":=", "0", ";", "node", "!=", "s", ".", "tail", "&&", "!", "finished", ";", "j", "++", "{", "if", "j", "==", "perSplit", "{", "j", "=", "-", "1", "\n", "itms", "=", "append", "(", "itms", ",", "node", ".", "Item", "(", ")", ")", "\n", "<mask>", "=", "len", "(", "itms", ")", "==", "nways", "-", "1", "\n", "}", "\n\n", "node", ",", "deleted", "=", "node", ".", "getNext", "(", "l", ")", "\n", "if", "deleted", "{", "goto", "repeat", "\n", "}", "\n", "}", "\n\n", "break", "\n", "}", "\n", "}", "\n\n", "return", "itms", "\n", "}" ]

[ "DeleteUser", "removes", "a", "user", ".", "ErrNotFound", "is", "returned", "if", "the", "user", "isn", "t", "found", "." ]

[ "func", "(", "m", "MongoDb", ")", "DeleteUser", "(", "username", "string", ")", "error", "{", "c", ":=", "m", ".", "Connect", "(", "<mask>", ".", "COLL_NAME_USER", ")", "\n", "defer", "m", ".", "Close", "(", "c", ")", "\n\n", "// raises error if \"username\" doesn't exist", "err", ":=", "c", ".", "Remove", "(", "bson", ".", "M", "{", "\"", "\"", ":", "username", "}", ")", "\n", "if", "err", "!=", "nil", "{", "logger", ".", "Get", "(", ")", ".", "Error", "(", "\"", "\"", ",", "username", ",", "err", ")", "\n", "return", "mkmgoerror", "(", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "OnKeyPress", "sets", "the", "callback", "that", "is", "called", "when", "a", "user", "presses", "a", "Key", "while", "the", "controls", "is", "active", ".", "If", "a", "handler", "processes", "the", "key", "it", "should", "return", "true", ".", "If", "handler", "returns", "false", "it", "means", "that", "the", "default", "handler", "will", "process", "the", "key" ]

[ "func", "(", "l", "*", "ListBox", ")", "OnKeyPress", "(", "fn", "func", "(", "term", ".", "<mask>", ")", "bool", ")", "{", "l", ".", "onKeyPress", "=", "fn", "\n", "}" ]

[ "Do", "executes", "Tracing", ".", "recordClockSyncMarker", "against", "the", "provided", "context", "." ]

[ "func", "(", "p", "*", "RecordClockSyncMarkerParams", ")", "Do", "(", "ctx", "<mask>", ".", "Context", ")", "(", "err", "error", ")", "{", "return", "cdp", ".", "Execute", "(", "ctx", ",", "CommandRecordClockSyncMarker", ",", "p", ",", "nil", ")", "\n", "}" ]

[ "Setv", "copies", "values", "between", "two", "tables", "in", "the", "same", "Lua", "state", ".", "It", "overwrites", "existing", "values", "." ]

[ "func", "(", "lo", "*", "LuaObject", ")", "Setv", "(", "src", "*", "LuaObject", ",", "keys", "...", "string", ")", "error", "{", "// TODO: Rename? This function seems to be too specialized, is it worth", "// keeping at all?", "L", ":=", "lo", ".", "l", "\n", "if", "L", "!=", "src", ".", "l", "{", "return", "ErrLuaObjectUnsharedState", "\n", "}", "\n", "lo", ".", "Push", "(", ")", "\n", "defer", "L", ".", "Pop", "(", "1", ")", "\n", "loIdx", ":=", "L", ".", "GetTop", "(", ")", "\n\n", "var", "set", "func", "(", "int", ",", "string", ")", "\n", "if", "L", ".", "IsTable", "(", "loIdx", ")", "{", "set", "=", "L", ".", "SetField", "\n", "}", "else", "if", "L", ".", "GetMetaField", "(", "loIdx", ",", "\"", "\"", ")", "{", "L", ".", "Pop", "(", "1", ")", "\n", "set", "=", "func", "(", "idx", "int", ",", "key", "string", ")", "{", "resultIdx", ":=", "L", ".", "GetTop", "(", ")", "\n", "L", ".", "GetMetaField", "(", "loIdx", ",", "\"", "\"", ")", "\n", "L", ".", "PushValue", "(", "loIdx", ")", "\n", "L", ".", "PushString", "(", "key", ")", "\n", "L", ".", "PushValue", "(", "resultIdx", ")", "\n", "L", ".", "Remove", "(", "resultIdx", ")", "\n", "L", ".", "Call", "(", "3", ",", "0", ")", "\n", "}", "\n", "}", "else", "{", "return", "ErrLuaObjectIndexable", "\n", "}", "\n\n", "src", ".", "Push", "(", ")", "\n", "defer", "src", ".", "l", ".", "Pop", "(", "1", ")", "\n", "srcIdx", ":=", "L", ".", "GetTop", "(", ")", "\n", "var", "get", "func", "(", "int", ",", "string", ")", "\n", "if", "L", ".", "IsTable", "(", "srcIdx", ")", "{", "get", "=", "L", ".", "GetField", "\n", "}", "else", "if", "L", ".", "GetMetaField", "(", "srcIdx", ",", "\"", "\"", ")", "{", "L", ".", "Pop", "(", "1", ")", "\n", "get", "=", "func", "(", "idx", "int", ",", "key", "string", ")", "{", "L", ".", "GetMetaField", "(", "srcIdx", ",", "\"", "\"", ")", "\n", "L", ".", "PushValue", "(", "srcIdx", ")", "\n", "L", ".", "PushString", "(", "key", ")", "\n", "L", ".", "Call", "(", "2", ",", "1", ")", "\n", "}", "\n", "}", "else", "{", "return", "ErrLuaObjectIndexable", "\n", "}", "\n\n", "for", "_", ",", "key", ":=", "range", "keys", "{", "<mask>", "(", "srcIdx", ",", "key", ")", "\n", "set", "(", "loIdx", ",", "key", ")", "\n", "}", "\n\n", "return", "nil", "\n", "}" ]

[ "DeviceToUserDistance", "is", "a", "wrapper", "around", "cairo_device_to_user_distance", "." ]

[ "func", "(", "v", "*", "<mask>", ")", "DeviceToUserDistance", "(", "x", ",", "y", "float64", ")", "(", "float64", ",", "float64", ")", "{", "C", ".", "cairo_device_to_user_distance", "(", "v", ".", "native", "(", ")", ",", "(", "*", "C", ".", "double", ")", "(", "&", "x", ")", ",", "(", "*", "C", ".", "double", ")", "(", "&", "y", ")", ")", "\n", "return", "x", ",", "y", "\n", "}" ]

[ "Parse", "the", "template", "this", "can", "be", "called", "many", "times", "as", "a", "successful", "result", "is", "cached", "and", "is", "used", "on", "subsequent", "uses", "." ]

[ "func", "(", "t", "*", "Template", ")", "Parse", "(", ")", "error", "{", "if", "t", ".", "program", "!=", "nil", "{", "return", "nil", "\n", "}", "\n", "program", ",", "err", ":=", "parser", ".", "Parse", "(", "t", ".", "<mask>", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "t", ".", "program", "=", "program", "\n", "return", "nil", "\n", "}" ]

[ "Handles", "server", "errors", "." ]

[ "func", "(", "ga", "*", "Agent", ")", "serverError", "(", "w", "http", ".", "ResponseWriter", ",", "action", "string", ",", "err", "error", ")", "{", "ga", ".", "logger", ".", "WithError", "(", "err", ")", ".", "Errorf", "(", "\"", "\"", ",", "action", ")", "\n", "msg", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "action", ",", "err", ")", "\n", "<mask>", ".", "Error", "(", "w", ",", "msg", ",", "http", ".", "StatusInternalServerError", ")", "\n", "}" ]

[ "FindAndStallTaskForCaller", "--" ]

[ "func", "(", "s", "*", "FakeTaskManager", ")", "FindAndStallTaskForCaller", "(", "callerName", "string", ")", "(", "t", "*", "taskmanager", ".", "<mask>", ",", "err", "error", ")", "{", "return", "s", ".", "ReturnedTask", ",", "s", ".", "ReturnedErr", "\n", "}" ]

[ "Json", "is", "middleware", "to", "deserialize", "a", "JSON", "payload", "from", "the", "request", "into", "the", "struct", "that", "is", "passed", "in", ".", "The", "resulting", "struct", "is", "then", "validated", "but", "no", "error", "handling", "is", "actually", "performed", "here", ".", "An", "interface", "pointer", "can", "be", "added", "as", "a", "second", "argument", "in", "order", "to", "map", "the", "struct", "to", "a", "specific", "interface", "." ]

[ "func", "Json", "(", "jsonStruct", "interface", "{", "}", ",", "ifacePtr", "...", "interface", "{", "}", ")", "martini", ".", "Handler", "{", "return", "func", "(", "context", "martini", ".", "Context", ",", "req", "*", "http", ".", "Request", ")", "{", "var", "errors", "Errors", "\n\n", "ensureNotPointer", "(", "jsonStruct", ")", "\n\n", "jsonStruct", ":=", "reflect", ".", "New", "(", "reflect", ".", "TypeOf", "(", "jsonStruct", ")", ")", "\n\n", "if", "req", ".", "Body", "!=", "nil", "{", "defer", "req", ".", "Body", ".", "Close", "(", ")", "\n", "err", ":=", "json", ".", "NewDecoder", "(", "req", ".", "Body", ")", ".", "Decode", "(", "jsonStruct", ".", "Interface", "(", ")", ")", "\n", "if", "err", "!=", "nil", "&&", "err", "!=", "io", ".", "EOF", "{", "errors", ".", "Add", "(", "[", "]", "string", "{", "}", ",", "DeserializationError", ",", "err", ".", "Error", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "validateAndMap", "(", "jsonStruct", ",", "context", ",", "<mask>", ",", "ifacePtr", "...", ")", "\n", "}", "\n", "}" ]

[ "NewRGBAPainter", "creates", "a", "new", "RGBAPainter", "for", "the", "given", "image", "." ]

[ "func", "NewPainter", "(", ")", "*", "Painter", "{", "p", ":=", "new", "(", "Painter", ")", "\n", "p", ".", "vertices", "=", "make", "(", "[", "]", "int32", ",", "0", ",", "1024", ")", "\n", "p", ".", "colors", "=", "<mask>", "(", "[", "]", "uint8", ",", "0", ",", "1024", ")", "\n", "return", "p", "\n", "}" ]

[ "NewVaultReadQuery", "creates", "a", "new", "datacenter", "dependency", "." ]

[ "func", "NewVaultReadQuery", "(", "s", "string", ")", "(", "*", "VaultReadQuery", ",", "error", ")", "{", "s", "=", "strings", ".", "TrimSpace", "(", "s", ")", "\n", "s", "=", "strings", ".", "Trim", "(", "s", ",", "\"", "\"", ")", "\n", "if", "s", "==", "\"", "\"", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "s", ")", "\n", "}", "\n\n", "secretURL", ",", "err", ":=", "url", ".", "Parse", "(", "s", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "VaultReadQuery", "{", "stopCh", ":", "make", "(", "chan", "struct", "{", "}", ",", "1", ")", ",", "rawPath", ":", "secretURL", ".", "Path", ",", "queryValues", ":", "secretURL", ".", "<mask>", "(", ")", ",", "}", ",", "nil", "\n", "}" ]

[ "PullRequestHandlers", "returns", "a", "map", "of", "plugin", "names", "to", "handlers", "for", "the", "repo", "." ]

[ "func", "(", "pa", "*", "ConfigAgent", ")", "PullRequestHandlers", "(", "owner", ",", "repo", "string", ")", "map", "[", "string", "]", "PullRequestHandler", "{", "pa", ".", "mut", ".", "Lock", "(", ")", "\n", "defer", "pa", ".", "mut", ".", "Unlock", "(", ")", "\n\n", "hs", ":=", "map", "[", "string", "]", "PullRequestHandler", "{", "}", "\n", "for", "_", ",", "p", ":=", "range", "<mask>", ".", "getPlugins", "(", "owner", ",", "repo", ")", "{", "if", "h", ",", "ok", ":=", "pullRequestHandlers", "[", "p", "]", ";", "ok", "{", "hs", "[", "p", "]", "=", "h", "\n", "}", "\n", "}", "\n\n", "return", "hs", "\n", "}" ]

[ "RunForS3Gateway", "creates", "a", "port", "forwarder", "for", "the", "s3gateway", "." ]

[ "func", "(", "f", "*", "PortForwarder", ")", "RunForS3Gateway", "(", "localPort", "uint16", ")", "error", "{", "if", "localPort", "==", "0", "{", "localPort", "=", "s3gatewayLocalPort", "\n", "}", "\n", "<mask>", "f", ".", "Run", "(", "\"", "\"", ",", "localPort", ",", "600", ")", "\n", "}" ]

[ "doSubscribe", "handles", "the", "subscription", "logic", "and", "is", "utilized", "by", "the", "public", "Subscribe", "functions" ]

[ "func", "(", "bus", "*", "EventBus", ")", "doSubscribe", "(", "topic", "string", ",", "fn", "interface", "{", "}", ",", "handler", "*", "eventHandler", ")", "error", "{", "bus", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "bus", ".", "lock", ".", "Unlock", "(", ")", "\n", "if", "!", "(", "reflect", ".", "TypeOf", "(", "fn", ")", ".", "Kind", "(", ")", "==", "reflect", ".", "Func", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "reflect", ".", "TypeOf", "(", "fn", ")", ".", "Kind", "(", ")", ")", "\n", "}", "\n", "bus", ".", "handlers", "[", "topic", "]", "=", "append", "(", "bus", ".", "handlers", "[", "<mask>", "]", ",", "handler", ")", "\n", "return", "nil", "\n", "}" ]

[ "CovList", "constructs", "new", "(", "file", ")", "Group", "Coverage" ]

[ "func", "newCoverageList", "(", "name", "string", ")", "*", "CoverageList", "{", "return", "&", "CoverageList", "{", "Coverage", ":", "&", "Coverage", "{", "<mask>", ":", "name", "}", ",", "Group", ":", "[", "]", "Coverage", "{", "}", ",", "}", "\n", "}" ]

[ "HandshakeTimeout", "performs", "a", "handshake", "between", "a", "given", "node", "and", "the", "peer", ".", "NOTE", ":", "blocking" ]

[ "func", "(", "p", "*", "Peer", ")", "HandshakeTimeout", "(", "ourNodeInfo", "*", "NodeInfo", ",", "timeout", "time", ".", "Duration", ")", "error", "{", "// Set deadline for handshake so we don't block forever on conn.ReadFull", "p", ".", "conn", ".", "SetDeadline", "(", "time", ".", "Now", "(", ")", ".", "Add", "(", "timeout", ")", ")", "\n\n", "var", "peerNodeInfo", "=", "new", "(", "NodeInfo", ")", "\n", "var", "err1", "error", "\n", "var", "err2", "error", "\n", "cmn", ".", "Parallel", "(", "func", "(", ")", "{", "var", "n", "int", "\n", "wire", ".", "WriteBinary", "(", "ourNodeInfo", ",", "p", ".", "conn", ",", "&", "n", ",", "&", "err1", ")", "\n", "}", ",", "func", "(", ")", "{", "var", "n", "int", "\n", "wire", ".", "ReadBinary", "(", "peerNodeInfo", ",", "p", ".", "conn", ",", "maxNodeInfoSize", ",", "&", "n", ",", "&", "err2", ")", "\n", "log", ".", "Notice", "(", "\"", "\"", ",", "\"", "\"", ",", "peerNodeInfo", ")", "\n", "}", ")", "\n", "if", "err1", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err1", ",", "\"", "\"", ")", "\n", "}", "\n", "if", "err2", "!=", "nil", "{", "return", "errors", ".", "Wrap", "(", "err2", ",", "\"", "\"", ")", "\n", "}", "\n\n", "if", "p", ".", "config", ".", "AuthEnc", "{", "// Check that the professed PubKey matches the sconn's.", "if", "!", "peerNodeInfo", ".", "PubKey", ".", "Equals", "(", "p", ".", "PubKey", "(", ")", ")", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "peerNodeInfo", ".", "PubKey", ",", "p", ".", "PubKey", "(", ")", ")", "\n", "}", "\n", "}", "\n\n", "// Remove deadline", "p", ".", "<mask>", ".", "SetDeadline", "(", "time", ".", "Time", "{", "}", ")", "\n\n", "peerNodeInfo", ".", "RemoteAddr", "=", "p", ".", "Addr", "(", ")", ".", "String", "(", ")", "\n\n", "p", ".", "NodeInfo", "=", "peerNodeInfo", "\n", "p", ".", "Key", "=", "peerNodeInfo", ".", "PubKey", ".", "KeyString", "(", ")", "\n\n", "return", "nil", "\n", "}" ]

[ "GetKnownStatus", "safely", "returns", "the", "currently", "known", "status", "of", "the", "task" ]

[ "func", "(", "vol", "*", "VolumeResource", ")", "GetKnownStatus", "(", ")", "resourcestatus", ".", "ResourceStatus", "{", "vol", ".", "<mask>", ".", "RLock", "(", ")", "\n", "defer", "vol", ".", "lock", ".", "RUnlock", "(", ")", "\n\n", "return", "vol", ".", "knownStatusUnsafe", "\n", "}" ]

[ "Do", "executes", "HeapProfiler", ".", "getObjectByHeapObjectId", "against", "the", "provided", "context", ".", "returns", ":", "result", "-", "Evaluation", "result", "." ]

[ "func", "(", "p", "*", "GetObjectByHeapObjectIDParams", ")", "Do", "(", "ctx", "context", ".", "Context", ")", "(", "result", "*", "runtime", ".", "RemoteObject", ",", "err", "error", ")", "{", "// execute", "var", "res", "GetObjectByHeapObjectIDReturns", "\n", "err", "=", "cdp", ".", "Execute", "(", "ctx", ",", "CommandGetObjectByHeapObjectID", ",", "p", ",", "&", "res", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "res", ".", "<mask>", ",", "nil", "\n", "}" ]

[ "split", "is", "like", "path", ".", "Split", "but", "uses", "this", "library", "s", "defaults", "for", "canonical", "paths" ]

[ "func", "split", "(", "p", "string", ")", "(", "string", ",", "string", ")", "{", "return", "<mask>", "(", "path", ".", "Dir", "(", "p", ")", ")", ",", "base", "(", "p", ")", "\n", "}" ]

[ "Vec2Scale", "scales", "a", "vector", "by", "value", "t", ".", "dest", "=", "v", "*", "t", "dest", "[", "out", "]", "The", "result", "vector", ".", "v", "[", "in", "]", "The", "vector", "to", "scale", ".", "t", "[", "in", "]", "The", "scaling", "factor", "." ]

[ "func", "Vec2Scale", "(", "<mask>", ",", "v", "Vec2", ",", "t", "float32", ")", "{", "dest", "[", "0", "]", "=", "v", "[", "0", "]", "*", "t", "\n", "dest", "[", "1", "]", "=", "v", "[", "1", "]", "*", "t", "\n", "}" ]

[ "CanAuthenticate", "makes", "a", "test", "request", "to", "CM", "1", ".", "5", "and", "returns", "nil", "if", "it", "is", "successful", "." ]

[ "func", "(", "s", "*", "oAuthSigner", ")", "CanAuthenticate", "(", "host", "string", ")", "error", "{", "return", "testAuth", "(", "s", ",", "s", ".", "client", ",", "host", ",", "<mask>", ")", "\n", "}" ]