Datasets:

google

/

code_x_glue_cc_cloze_testing_maxmin

like 2

Follow

Google 5.12k

[ "SetMaxStructPoolSize", "sets", "the", "struct", "pools", "max", "size", ".", "this", "may", "be", "usefull", "for", "fine", "grained", "performance", "tuning", "towards", "your", "application", "however", "the", "default", "should", "be", "fine", "for", "nearly", "all", "cases", ".", "only", "increase", "if", "you", "have", "a", "deeply", "nested", "struct", "structure", ".", "NOTE", ":", "this", "method", "is", "not", "thread", "-", "safe", "NOTE", ":", "this", "is", "only", "here", "to", "keep", "compatibility", "with", "v5", "in", "v6", "the", "method", "will", "be", "removed" ]

[ "func", "(", "v", "*", "Validate", ")", "SetMaxStructPoolSize", "(", "<mask>", "int", ")", "{", "structPool", "=", "&", "sync", ".", "Pool", "{", "New", ":", "newStructErrors", "}", "\n", "}" ]

[ "NewSimpleBackoff", "creates", "a", "Backoff", "which", "ranges", "from", "min", "to", "max", "increasing", "by", "multiple", "each", "time", ".", "(", "t", "=", "start", "*", "multiple", "*", "n", "for", "the", "nth", "iteration", ")", "It", "also", "adds", "(", "and", "yes", "the", "jitter", "is", "always", "added", "never", "subtracted", ")", "a", "random", "amount", "of", "jitter", "up", "to", "jitterMultiple", "percent", "(", "that", "is", "jitterMultiple", "=", "0", ".", "0", "is", "no", "jitter", "0", ".", "15", "is", "15%", "added", "jitter", ")", ".", "The", "total", "time", "may", "exceed", "max", "when", "accounting", "for", "jitter", "such", "that", "the", "absolute", "max", "is", "max", "+", "max", "*", "jiterMultiple" ]

[ "func", "NewExponentialBackoff", "(", "<mask>", ",", "max", "time", ".", "Duration", ",", "jitterMultiple", ",", "multiple", "float64", ")", "*", "ExponentialBackoff", "{", "return", "&", "ExponentialBackoff", "{", "start", ":", "min", ",", "current", ":", "min", ",", "max", ":", "max", ",", "jitterMultiple", ":", "jitterMultiple", ",", "multiple", ":", "multiple", ",", "}", "\n", "}" ]

[ "ScaleNewWithRange", "is", "a", "wrapper", "around", "gtk_scale_new_with_range", "()", "." ]

[ "func", "ScaleNewWithRange", "(", "orientation", "Orientation", ",", "<mask>", ",", "max", ",", "step", "float64", ")", "(", "*", "Scale", ",", "error", ")", "{", "c", ":=", "C", ".", "gtk_scale_new_with_range", "(", "C", ".", "GtkOrientation", "(", "orientation", ")", ",", "C", ".", "gdouble", "(", "min", ")", ",", "C", ".", "gdouble", "(", "max", ")", ",", "C", ".", "gdouble", "(", "step", ")", ")", "\n\n", "if", "c", "==", "nil", "{", "return", "nil", ",", "nilPtrErr", "\n", "}", "\n", "return", "wrapScale", "(", "glib", ".", "Take", "(", "unsafe", ".", "Pointer", "(", "c", ")", ")", ")", ",", "nil", "\n", "}" ]

[ "Read", "wraps", "csv", ".", "Reader", ".", "Read", "creating", "a", "map", "of", "column", "name", "to", "field", "value", ".", "If", "the", "line", "has", "fewer", "columns", "than", "Reader", ".", "Columns", "the", "map", "will", "not", "contain", "keys", "for", "these", "columns", ";", "thus", "we", "can", "distinguish", "between", "missing", "columns", "and", "columns", "with", "empty", "values", ".", "If", "the", "line", "has", "more", "columns", "than", "Reader", ".", "Columns", "Reader", ".", "Read", "()", "ignores", "them", "." ]

[ "func", "(", "r", "*", "Reader", ")", "Read", "(", ")", "(", "record", "map", "[", "string", "]", "string", ",", "err", "error", ")", "{", "var", "rawRecord", "[", "]", "string", "\n", "rawRecord", ",", "err", "=", "r", ".", "Reader", ".", "Read", "(", ")", "\n", "length", ":=", "<mask>", "(", "len", "(", "rawRecord", ")", ",", "len", "(", "r", ".", "Columns", ")", ")", "\n", "record", "=", "make", "(", "map", "[", "string", "]", "string", ")", "\n", "for", "index", ":=", "0", ";", "index", "<", "length", ";", "index", "++", "{", "column", ":=", "r", ".", "Columns", "[", "index", "]", "\n", "if", "_", ",", "exists", ":=", "record", "[", "column", "]", ";", "exists", "{", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "column", ")", "\n", "}", "\n", "record", "[", "column", "]", "=", "rawRecord", "[", "index", "]", "\n", "}", "\n", "return", "\n", "}" ]

[ "Step", "increases", "ProgressBar", "value", "by", "1", "if", "the", "value", "is", "less", "than", "ProgressBar", "high", "limit" ]

[ "func", "(", "b", "*", "ProgressBar", ")", "Step", "(", ")", "int", "{", "b", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mtx", ".", "Unlock", "(", ")", "\n", "b", ".", "value", "++", "\n\n", "if", "b", ".", "value", ">", "b", ".", "<mask>", "{", "b", ".", "value", "=", "b", ".", "max", "\n", "}", "\n\n", "return", "b", ".", "value", "\n", "}" ]

[ "Read", "presents", "one", "or", "more", "IDAT", "chunks", "as", "one", "continuous", "stream", "(", "minus", "the", "intermediate", "chunk", "headers", "and", "footers", ")", ".", "If", "the", "PNG", "data", "looked", "like", ":", "...", "len0", "IDAT", "xxx", "crc0", "len1", "IDAT", "yy", "crc1", "len2", "IEND", "crc2", "then", "this", "reader", "presents", "xxxyy", ".", "For", "well", "-", "formed", "PNG", "data", "the", "decoder", "state", "immediately", "before", "the", "first", "Read", "call", "is", "that", "d", ".", "r", "is", "positioned", "between", "the", "first", "IDAT", "and", "xxx", "and", "the", "decoder", "state", "immediately", "after", "the", "last", "Read", "call", "is", "that", "d", ".", "r", "is", "positioned", "between", "yy", "and", "crc1", "." ]

[ "func", "(", "d", "*", "decoder", ")", "Read", "(", "p", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "if", "len", "(", "p", ")", "==", "0", "{", "return", "0", ",", "nil", "\n", "}", "\n", "for", "d", ".", "idatLength", "==", "0", "{", "// We have exhausted an IDAT chunk. Verify the checksum of that chunk.", "if", "err", ":=", "d", ".", "verifyChecksum", "(", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "// Read the length and chunk type of the next chunk, and check that", "// it is an IDAT chunk.", "if", "_", ",", "err", ":=", "io", ".", "ReadFull", "(", "d", ".", "r", ",", "d", ".", "tmp", "[", ":", "8", "]", ")", ";", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "d", ".", "idatLength", "=", "binary", ".", "BigEndian", ".", "Uint32", "(", "d", ".", "tmp", "[", ":", "4", "]", ")", "\n", "if", "string", "(", "d", ".", "tmp", "[", "4", ":", "8", "]", ")", "!=", "\"", "\"", "{", "return", "0", ",", "FormatError", "(", "\"", "\"", ")", "\n", "}", "\n", "d", ".", "crc", ".", "Reset", "(", ")", "\n", "d", ".", "crc", ".", "Write", "(", "d", ".", "tmp", "[", "4", ":", "8", "]", ")", "\n", "}", "\n", "if", "int", "(", "d", ".", "idatLength", ")", "<", "0", "{", "return", "0", ",", "UnsupportedError", "(", "\"", "\"", ")", "\n", "}", "\n", "n", ",", "err", ":=", "d", ".", "r", ".", "Read", "(", "p", "[", ":", "<mask>", "(", "len", "(", "p", ")", ",", "int", "(", "d", ".", "idatLength", ")", ")", "]", ")", "\n", "d", ".", "crc", ".", "Write", "(", "p", "[", ":", "n", "]", ")", "\n", "d", ".", "idatLength", "-=", "uint32", "(", "n", ")", "\n", "return", "n", ",", "err", "\n", "}" ]

[ "The", "assumption", "that", "bucket", "counts", "increase", "monotonically", "with", "increasing", "upperBound", "may", "be", "violated", "during", ":", "*", "Recording", "rule", "evaluation", "of", "histogram_quantile", "especially", "when", "rate", "()", "has", "been", "applied", "to", "the", "underlying", "bucket", "timeseries", ".", "*", "Evaluation", "of", "histogram_quantile", "computed", "over", "federated", "bucket", "timeseries", "especially", "when", "rate", "()", "has", "been", "applied", ".", "This", "is", "because", "scraped", "data", "is", "not", "made", "available", "to", "rule", "evaluation", "or", "federation", "atomically", "so", "some", "buckets", "are", "computed", "with", "data", "from", "the", "most", "recent", "scrapes", "but", "the", "other", "buckets", "are", "missing", "data", "from", "the", "most", "recent", "scrape", ".", "Monotonicity", "is", "usually", "guaranteed", "because", "if", "a", "bucket", "with", "upper", "bound", "u1", "has", "count", "c1", "then", "any", "bucket", "with", "a", "higher", "upper", "bound", "u", ">", "u1", "must", "have", "counted", "all", "c1", "observations", "and", "perhaps", "more", "so", "that", "c", ">", "=", "c1", ".", "Randomly", "interspersed", "partial", "sampling", "breaks", "that", "guarantee", "and", "rate", "()", "exacerbates", "it", ".", "Specifically", "suppose", "bucket", "le", "=", "1000", "has", "a", "count", "of", "10", "from", "4", "samples", "but", "the", "bucket", "with", "le", "=", "2000", "has", "a", "count", "of", "7", "from", "3", "samples", ".", "The", "monotonicity", "is", "broken", ".", "It", "is", "exacerbated", "by", "rate", "()", "because", "under", "normal", "operation", "cumulative", "counting", "of", "buckets", "will", "cause", "the", "bucket", "counts", "to", "diverge", "such", "that", "small", "differences", "from", "missing", "samples", "are", "not", "a", "problem", ".", "rate", "()", "removes", "this", "divergence", ".", ")", "bucketQuantile", "depends", "on", "that", "monotonicity", "to", "do", "a", "binary", "search", "for", "the", "bucket", "with", "the", "φ", "-", "quantile", "count", "so", "breaking", "the", "monotonicity", "guarantee", "causes", "bucketQuantile", "()", "to", "return", "undefined", "(", "nonsense", ")", "results", ".", "As", "a", "somewhat", "hacky", "solution", "until", "ingestion", "is", "atomic", "per", "scrape", "we", "calculate", "the", "envelope", "of", "the", "histogram", "buckets", "essentially", "removing", "any", "decreases", "in", "the", "count", "between", "successive", "buckets", "." ]

[ "func", "ensureMonotonic", "(", "buckets", "buckets", ")", "{", "<mask>", ":=", "buckets", "[", "0", "]", ".", "count", "\n", "for", "i", ":=", "range", "buckets", "[", "1", ":", "]", "{", "switch", "{", "case", "buckets", "[", "i", "]", ".", "count", ">", "max", ":", "max", "=", "buckets", "[", "i", "]", ".", "count", "\n", "case", "buckets", "[", "i", "]", ".", "count", "<", "max", ":", "buckets", "[", "i", "]", ".", "count", "=", "max", "\n", "}", "\n", "}", "\n", "}" ]

[ "CanPageDown", "returns", "whether", "a", "list", "can", "still", "PageDown", "()", "." ]

[ "func", "(", "l", "*", "List", ")", "CanPageDown", "(", ")", "bool", "{", "<mask>", ":=", "len", "(", "l", ".", "scope", ")", "\n", "return", "l", ".", "start", "+", "l", ".", "size", "<", "max", "\n", "}" ]

[ "KNearest", "returns", "the", "k", "nearest", "points", "near", "point", "within", "maxDistance", "that", "match", "the", "accept", "criteria", "." ]

[ "func", "(", "points", "*", "PointsIndex", ")", "KNearest", "(", "point", "Point", ",", "k", "int", ",", "maxDistance", "Meters", ",", "accept", "func", "(", "p", "Point", ")", "bool", ")", "[", "]", "Point", "{", "nearbyPoints", ":=", "make", "(", "[", "]", "Point", ",", "0", ")", "\n", "pointEntry", ":=", "points", ".", "index", ".", "GetEntryAt", "(", "point", ")", ".", "(", "set", ")", "\n", "nearbyPoints", "=", "append", "(", "nearbyPoints", ",", "getPoints", "(", "[", "]", "interface", "{", "}", "{", "pointEntry", "}", ",", "accept", ")", "...", ")", "\n\n", "totalCount", ":=", "0", "\n", "idx", ":=", "cellOf", "(", "point", ",", "points", ".", "index", ".", "resolution", ")", "\n", "// Explicitely assign a greater max distance so that we definitely return enough points", "// and make sure it searches at least one square away.", "coarseMaxDistance", ":=", "math", ".", "Max", "(", "float64", "(", "maxDistance", ")", "*", "2.0", ",", "float64", "(", "points", ".", "index", ".", "resolution", ")", "*", "2.0", "+", "0.01", ")", "\n\n", "for", "d", ":=", "1", ";", "float64", "(", "d", ")", "*", "float64", "(", "points", ".", "index", ".", "resolution", ")", "<=", "coarseMaxDistance", ";", "d", "++", "{", "oldCount", ":=", "len", "(", "nearbyPoints", ")", "\n\n", "nearbyPoints", "=", "getPointsAppend", "(", "nearbyPoints", ",", "points", ".", "index", ".", "get", "(", "idx", ".", "x", "-", "d", ",", "idx", ".", "x", "+", "d", ",", "idx", ".", "y", "+", "d", ",", "idx", ".", "y", "+", "d", ")", ",", "accept", ")", "\n", "nearbyPoints", "=", "getPointsAppend", "(", "nearbyPoints", ",", "points", ".", "index", ".", "get", "(", "idx", ".", "x", "-", "d", ",", "idx", ".", "x", "+", "d", ",", "idx", ".", "y", "-", "d", ",", "idx", ".", "y", "-", "d", ")", ",", "accept", ")", "\n", "nearbyPoints", "=", "getPointsAppend", "(", "nearbyPoints", ",", "points", ".", "index", ".", "get", "(", "idx", ".", "x", "-", "d", ",", "idx", ".", "x", "-", "d", ",", "idx", ".", "y", "-", "d", "+", "1", ",", "idx", ".", "y", "+", "d", "-", "1", ")", ",", "accept", ")", "\n", "nearbyPoints", "=", "getPointsAppend", "(", "nearbyPoints", ",", "points", ".", "index", ".", "get", "(", "idx", ".", "x", "+", "d", ",", "idx", ".", "x", "+", "d", ",", "idx", ".", "y", "-", "d", "+", "1", ",", "idx", ".", "y", "+", "d", "-", "1", ")", ",", "accept", ")", "\n\n", "totalCount", "+=", "len", "(", "nearbyPoints", ")", "-", "oldCount", "\n\n", "if", "totalCount", ">", "k", "{", "break", "\n", "}", "\n", "}", "\n\n", "sortedPoints", ":=", "&", "sortedPoints", "{", "nearbyPoints", ",", "point", "}", "\n", "sort", ".", "Sort", "(", "sortedPoints", ")", "\n\n", "k", "=", "<mask>", "(", "k", ",", "len", "(", "sortedPoints", ".", "points", ")", ")", "\n\n", "// filter points which longer than maxDistance away from point.", "for", "i", ",", "nearbyPoint", ":=", "range", "sortedPoints", ".", "points", "{", "if", "Distance", "(", "point", ",", "nearbyPoint", ")", ">", "maxDistance", "||", "i", "==", "k", "{", "k", "=", "i", "\n", "break", "\n", "}", "\n", "}", "\n\n", "return", "sortedPoints", ".", "points", "[", "0", ":", "k", "]", "\n", "}" ]

[ "GetClientOfferingsFilterParams", "returns", "offerings", "filter", "parameters", "for", "client", "." ]

[ "func", "(", "h", "*", "Handler", ")", "GetClientOfferingsFilterParams", "(", "tkn", "string", ")", "(", "*", "GetClientOfferingsFilterParamsResult", ",", "error", ")", "{", "logger", ":=", "h", ".", "logger", ".", "Add", "(", "\"", "\"", ",", "\"", "\"", ")", "\n\n", "if", "!", "h", ".", "token", ".", "Check", "(", "tkn", ")", "{", "logger", ".", "Warn", "(", "\"", "\"", ")", "\n", "return", "nil", ",", "ErrAccessDenied", "\n", "}", "\n\n", "countries", ",", "err", ":=", "h", ".", "offeringCountries", "(", "logger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "<mask>", ",", "max", ",", "err", ":=", "h", ".", "offeringsMinMaxPrice", "(", "logger", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "GetClientOfferingsFilterParamsResult", "{", "countries", ",", "min", ",", "max", "}", ",", "nil", "\n", "}" ]

[ "Any", "returns", "the", "position", "of", "the", "end", "of", "the", "current", "element", "that", "begins", "at", "pos", ";", "handles", "any", "valid", "json", "element" ]

[ "func", "Any", "(", "in", "[", "]", "byte", ",", "pos", "int", ")", "(", "int", ",", "error", ")", "{", "pos", ",", "err", ":=", "skipSpace", "(", "in", ",", "pos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "switch", "in", "[", "pos", "]", "{", "case", "'\"'", ":", "return", "String", "(", "in", ",", "pos", ")", "\n", "case", "'{'", ":", "return", "Object", "(", "in", ",", "pos", ")", "\n", "case", "'.'", ",", "'-'", ",", "'1'", ",", "'2'", ",", "'3'", ",", "'4'", ",", "'5'", ",", "'6'", ",", "'7'", ",", "'8'", ",", "'9'", ",", "'0'", ":", "return", "Number", "(", "in", ",", "pos", ")", "\n", "case", "'['", ":", "return", "Array", "(", "in", ",", "pos", ")", "\n", "case", "'t'", ",", "'f'", ":", "return", "Boolean", "(", "in", ",", "pos", ")", "\n", "case", "'n'", ":", "return", "Null", "(", "in", ",", "pos", ")", "\n", "default", ":", "<mask>", ":=", "len", "(", "in", ")", "-", "pos", "\n", "if", "max", ">", "20", "{", "max", "=", "20", "\n", "}", "\n\n", "return", "0", ",", "opErr", "{", "pos", ":", "pos", ",", "msg", ":", "\"", "\"", ",", "content", ":", "string", "(", "in", "[", "pos", ":", "pos", "+", "max", "]", ")", ",", "}", "\n", "}", "\n", "}" ]

[ "lexEscape", "scans", "a", "string", "escape", "sequence", ".", "The", "initial", "escaping", "character", "(", "\\", ")", "has", "already", "been", "seen", ".", "NOTE", ":", "This", "function", "as", "well", "as", "the", "helper", "function", "digitVal", "()", "and", "associated", "tests", "have", "been", "adapted", "from", "the", "corresponding", "functions", "in", "the", "go", "/", "scanner", "package", "of", "the", "Go", "standard", "library", "to", "work", "for", "Prometheus", "-", "style", "strings", ".", "None", "of", "the", "actual", "escaping", "/", "quoting", "logic", "was", "changed", "in", "this", "function", "-", "it", "was", "only", "modified", "to", "integrate", "with", "our", "lexer", "." ]

[ "func", "lexEscape", "(", "l", "*", "lexer", ")", "{", "var", "n", "int", "\n", "var", "base", ",", "<mask>", "uint32", "\n\n", "ch", ":=", "l", ".", "next", "(", ")", "\n", "switch", "ch", "{", "case", "'a'", ",", "'b'", ",", "'f'", ",", "'n'", ",", "'r'", ",", "'t'", ",", "'v'", ",", "'\\\\'", ",", "l", ".", "stringOpen", ":", "return", "\n", "case", "'0'", ",", "'1'", ",", "'2'", ",", "'3'", ",", "'4'", ",", "'5'", ",", "'6'", ",", "'7'", ":", "n", ",", "base", ",", "max", "=", "3", ",", "8", ",", "255", "\n", "case", "'x'", ":", "ch", "=", "l", ".", "next", "(", ")", "\n", "n", ",", "base", ",", "max", "=", "2", ",", "16", ",", "255", "\n", "case", "'u'", ":", "ch", "=", "l", ".", "next", "(", ")", "\n", "n", ",", "base", ",", "max", "=", "4", ",", "16", ",", "unicode", ".", "MaxRune", "\n", "case", "'U'", ":", "ch", "=", "l", ".", "next", "(", ")", "\n", "n", ",", "base", ",", "max", "=", "8", ",", "16", ",", "unicode", ".", "MaxRune", "\n", "case", "eof", ":", "l", ".", "errorf", "(", "\"", "\"", ")", "\n", "default", ":", "l", ".", "errorf", "(", "\"", "\"", ",", "ch", ")", "\n", "}", "\n\n", "var", "x", "uint32", "\n", "for", "n", ">", "0", "{", "d", ":=", "uint32", "(", "digitVal", "(", "ch", ")", ")", "\n", "if", "d", ">=", "base", "{", "if", "ch", "==", "eof", "{", "l", ".", "errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "l", ".", "errorf", "(", "\"", "\"", ",", "ch", ")", "\n", "}", "\n", "x", "=", "x", "*", "base", "+", "d", "\n", "ch", "=", "l", ".", "next", "(", ")", "\n", "n", "--", "\n", "}", "\n\n", "if", "x", ">", "max", "||", "0xD800", "<=", "x", "&&", "x", "<", "0xE000", "{", "l", ".", "errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "}" ]

[ "Read", "is", "io", ".", "Reader", "s", "Read", ".", "Read", "fills", "the", "data", "with", "sine", "wave", "samples", "." ]

[ "func", "(", "s", "*", "stream", ")", "Read", "(", "buf", "[", "]", "byte", ")", "(", "int", ",", "error", ")", "{", "if", "len", "(", "s", ".", "remaining", ")", ">", "0", "{", "n", ":=", "copy", "(", "buf", ",", "s", ".", "remaining", ")", "\n", "s", ".", "remaining", "=", "s", ".", "remaining", "[", "n", ":", "]", "\n", "return", "n", ",", "nil", "\n", "}", "\n\n", "var", "origBuf", "[", "]", "byte", "\n", "if", "len", "(", "buf", ")", "%", "4", ">", "0", "{", "origBuf", "=", "buf", "\n", "buf", "=", "make", "(", "[", "]", "byte", ",", "len", "(", "origBuf", ")", "+", "4", "-", "len", "(", "origBuf", ")", "%", "4", ")", "\n", "}", "\n\n", "const", "length", "=", "int64", "(", "sampleRate", "/", "frequency", ")", "\n", "p", ":=", "s", ".", "position", "/", "4", "\n", "for", "i", ":=", "0", ";", "i", "<", "len", "(", "buf", ")", "/", "4", ";", "i", "++", "{", "const", "<mask>", "=", "32767", "\n", "b", ":=", "int16", "(", "math", ".", "Sin", "(", "2", "*", "math", ".", "Pi", "*", "float64", "(", "p", ")", "/", "float64", "(", "length", ")", ")", "*", "max", ")", "\n", "buf", "[", "4", "*", "i", "]", "=", "byte", "(", "b", ")", "\n", "buf", "[", "4", "*", "i", "+", "1", "]", "=", "byte", "(", "b", ">>", "8", ")", "\n", "buf", "[", "4", "*", "i", "+", "2", "]", "=", "byte", "(", "b", ")", "\n", "buf", "[", "4", "*", "i", "+", "3", "]", "=", "byte", "(", "b", ">>", "8", ")", "\n", "p", "++", "\n", "}", "\n\n", "s", ".", "position", "+=", "int64", "(", "len", "(", "buf", ")", ")", "\n", "s", ".", "position", "%=", "length", "*", "4", "\n\n", "if", "origBuf", "!=", "nil", "{", "n", ":=", "copy", "(", "origBuf", ",", "buf", ")", "\n", "s", ".", "remaining", "=", "buf", "[", "n", ":", "]", "\n", "return", "n", ",", "nil", "\n", "}", "\n", "return", "len", "(", "buf", ")", ",", "nil", "\n", "}" ]

[ "getCWStatsSet", "gets", "the", "stats", "set", "for", "either", "CPU", "or", "Memory", "based", "on", "the", "function", "pointer", "." ]

[ "func", "(", "queue", "*", "Queue", ")", "getCWStatsSet", "(", "f", "getUsageFunc", ")", "(", "*", "ecstcs", ".", "CWStatsSet", ",", "error", ")", "{", "queue", ".", "lock", ".", "Lock", "(", ")", "\n", "defer", "queue", ".", "lock", ".", "Unlock", "(", ")", "\n\n", "queueLength", ":=", "len", "(", "queue", ".", "buffer", ")", "\n", "if", "queueLength", "<", "2", "{", "// Need at least 2 data points to calculate this.", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n\n", "var", "<mask>", ",", "max", ",", "sum", "float64", "\n", "var", "sampleCount", "int64", "\n", "min", "=", "math", ".", "MaxFloat64", "\n", "max", "=", "-", "math", ".", "MaxFloat64", "\n", "sum", "=", "0", "\n", "sampleCount", "=", "0", "\n\n", "for", "_", ",", "stat", ":=", "range", "queue", ".", "buffer", "{", "perc", ":=", "f", "(", "&", "stat", ")", "\n", "if", "math", ".", "IsNaN", "(", "perc", ")", "{", "continue", "\n", "}", "\n\n", "min", "=", "math", ".", "Min", "(", "min", ",", "perc", ")", "\n", "max", "=", "math", ".", "Max", "(", "max", ",", "perc", ")", "\n", "sampleCount", "++", "\n", "sum", "+=", "perc", "\n", "}", "\n\n", "return", "&", "ecstcs", ".", "CWStatsSet", "{", "Max", ":", "&", "max", ",", "Min", ":", "&", "min", ",", "SampleCount", ":", "&", "sampleCount", ",", "Sum", ":", "&", "sum", ",", "}", ",", "nil", "\n", "}" ]

[ "RateLimit", "is", "a", "Gin", "middleware", "for", "rate", "limitting", "incoming", "requests", "based", "on", "the", "client", "s", "IP", "address", ".", "The", "resulting", "middleware", "will", "use", "the", "client", "to", "talk", "to", "the", "Redis", "server", ".", "The", "hasher", "is", "used", "to", "keep", "track", "of", "counters", "and", "to", "provide", "an", "estimate", "of", "when", "the", "client", "should", "be", "able", "to", "do", "requests", "again", ".", "The", "limit", "per", "period", "is", "defined", "by", "the", "max", ".", "Response", "format", "Once", "a", "client", "reaches", "the", "imposed", "limit", "they", "will", "receive", "a", "JSON", "response", "similar", "to", "the", "following", ":", "{", "messages", ":", "[", "Rate", "limit", "exceeded", ".", "Try", "again", "in", "1", "minute", "from", "now", "]", "status", ":", "error", "}" ]

[ "func", "RateLimit", "(", "client", "*", "redis", ".", "Client", ",", "hasher", "speedbump", ".", "RateHasher", ",", "<mask>", "int64", ")", "gin", ".", "HandlerFunc", "{", "limiter", ":=", "speedbump", ".", "NewLimiter", "(", "client", ",", "hasher", ",", "max", ")", "\n\n", "return", "func", "(", "c", "*", "gin", ".", "Context", ")", "{", "// Attempt to perform the request", "ip", ",", "_", ",", "_", ":=", "net", ".", "SplitHostPort", "(", "c", ".", "Request", ".", "RemoteAddr", ")", "\n", "ok", ",", "err", ":=", "limiter", ".", "Attempt", "(", "ip", ")", "\n\n", "if", "err", "!=", "nil", "{", "panic", "(", "err", ")", "\n", "}", "\n\n", "if", "!", "ok", "{", "nextTime", ":=", "time", ".", "Now", "(", ")", ".", "Add", "(", "hasher", ".", "Duration", "(", ")", ")", "\n\n", "c", ".", "JSON", "(", "429", ",", "gin", ".", "H", "{", "\"", "\"", ":", "\"", "\"", ",", "\"", "\"", ":", "[", "]", "string", "{", "\"", "\"", "+", "humanize", ".", "Time", "(", "nextTime", ")", "}", ",", "}", ")", "\n", "c", ".", "Abort", "(", ")", "\n", "}", "\n\n", "c", ".", "Next", "(", ")", "\n\n", "// After the request", "// log.Print(ip + \" was limited because it exceeded the max rate\")", "}", "\n", "}" ]

[ "returns", "true", "if", "the", "next", "n", "values", "in", "in", "can", "be", "packed", "using", "bits", "bits", "per", "value", "." ]

[ "func", "canPack", "(", "src", "[", "]", "uint32", ",", "bits", ",", "n", "int", ")", "bool", "{", "if", "len", "(", "src", ")", "<", "n", "{", "return", "false", "\n", "}", "\n\n", "end", ":=", "len", "(", "src", ")", "\n", "if", "n", "<", "end", "{", "end", "=", "n", "\n", "}", "\n\n", "<mask>", ":=", "uint32", "(", "(", "2", "<<", "uint32", "(", "bits", "-", "1", ")", ")", "-", "1", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "end", ";", "i", "++", "{", "if", "src", "[", "i", "]", ">", "max", "{", "return", "false", "\n", "}", "\n", "}", "\n\n", "return", "true", "\n", "}" ]

[ "tick", "updates", "the", "minimum", "quiescence", "timer", "." ]

[ "func", "(", "q", "*", "quiescence", ")", "tick", "(", ")", "{", "now", ":=", "time", ".", "Now", "(", ")", "\n\n", "// If this is the first tick, set up the timer and calculate the max", "// deadline.", "if", "q", ".", "timer", "==", "nil", "{", "q", ".", "timer", "=", "time", ".", "NewTimer", "(", "q", ".", "<mask>", ")", "\n", "go", "func", "(", ")", "{", "select", "{", "case", "<-", "q", ".", "timer", ".", "C", ":", "q", ".", "ch", "<-", "q", ".", "template", "\n", "}", "\n", "}", "(", ")", "\n\n", "q", ".", "deadline", "=", "now", ".", "Add", "(", "q", ".", "max", ")", "\n", "return", "\n", "}", "\n\n", "// Snooze the timer for the min time, or snooze less if we are coming", "// up against the max time. If the timer has already fired and the reset", "// doesn't work that's ok because we guarantee that the channel gets our", "// template which means that we are obsolete and a fresh quiescence will", "// be set up.", "if", "now", ".", "Add", "(", "q", ".", "min", ")", ".", "Before", "(", "q", ".", "deadline", ")", "{", "q", ".", "timer", ".", "Reset", "(", "q", ".", "min", ")", "\n", "}", "else", "if", "dur", ":=", "q", ".", "deadline", ".", "Sub", "(", "now", ")", ";", "dur", ">", "0", "{", "q", ".", "timer", ".", "Reset", "(", "dur", ")", "\n", "}", "\n", "}" ]

[ "integer", "types" ]

[ "func", "convertNvInteger", "(", "v", "interface", "{", "}", ",", "<mask>", ",", "max", "int64", ")", "(", "driver", ".", "Value", ",", "error", ")", "{", "if", "v", "==", "nil", "{", "return", "v", ",", "nil", "\n", "}", "\n\n", "rv", ":=", "reflect", ".", "ValueOf", "(", "v", ")", "\n", "switch", "rv", ".", "Kind", "(", ")", "{", "// bool is represented in HDB as tinyint", "case", "reflect", ".", "Bool", ":", "return", "rv", ".", "Bool", "(", ")", ",", "nil", "\n", "case", "reflect", ".", "Int", ",", "reflect", ".", "Int8", ",", "reflect", ".", "Int16", ",", "reflect", ".", "Int32", ",", "reflect", ".", "Int64", ":", "i64", ":=", "rv", ".", "Int", "(", ")", "\n", "if", "i64", ">", "max", "||", "i64", "<", "min", "{", "return", "nil", ",", "ErrIntegerOutOfRange", "\n", "}", "\n", "return", "i64", ",", "nil", "\n", "case", "reflect", ".", "Uint", ",", "reflect", ".", "Uint8", ",", "reflect", ".", "Uint16", ",", "reflect", ".", "Uint32", ",", "reflect", ".", "Uint64", ":", "u64", ":=", "rv", ".", "Uint", "(", ")", "\n", "if", "u64", ">", "uint64", "(", "max", ")", "{", "return", "nil", ",", "ErrIntegerOutOfRange", "\n", "}", "\n", "return", "int64", "(", "u64", ")", ",", "nil", "\n", "case", "reflect", ".", "Ptr", ":", "// indirect pointers", "if", "rv", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "convertNvInteger", "(", "rv", ".", "Elem", "(", ")", ".", "Interface", "(", ")", ",", "min", ",", "max", ")", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}" ]

[ "OptFieldTypeInt", "adds", "an", "integer", "field", "." ]

[ "func", "OptFieldTypeInt", "(", "<mask>", "int64", ",", "max", "int64", ")", "FieldOption", "{", "return", "func", "(", "options", "*", "FieldOptions", ")", "{", "options", ".", "fieldType", "=", "FieldTypeInt", "\n", "options", ".", "min", "=", "min", "\n", "options", ".", "max", "=", "max", "\n", "}", "\n", "}" ]

[ "rayCasting", "returns", "a", "slice", "of", "line", "originating", "from", "point", "cx", "cy", "and", "intersecting", "with", "objects" ]

[ "func", "rayCasting", "(", "cx", ",", "cy", "float64", ",", "objects", "[", "]", "object", ")", "[", "]", "line", "{", "const", "rayLength", "=", "1000", "// something large enough to reach all objects", "\n\n", "var", "rays", "[", "]", "line", "\n", "for", "_", ",", "obj", ":=", "range", "objects", "{", "// Cast two rays per point", "for", "_", ",", "p", ":=", "range", "obj", ".", "points", "(", ")", "{", "l", ":=", "line", "{", "cx", ",", "cy", ",", "p", "[", "0", "]", ",", "p", "[", "1", "]", "}", "\n", "angle", ":=", "l", ".", "angle", "(", ")", "\n\n", "for", "_", ",", "offset", ":=", "range", "[", "]", "float64", "{", "-", "0.005", ",", "0.005", "}", "{", "points", ":=", "[", "]", "[", "2", "]", "float64", "{", "}", "\n", "ray", ":=", "newRay", "(", "cx", ",", "cy", ",", "rayLength", ",", "angle", "+", "offset", ")", "\n\n", "// Unpack all objects", "for", "_", ",", "o", ":=", "range", "objects", "{", "for", "_", ",", "wall", ":=", "range", "o", ".", "walls", "{", "if", "px", ",", "py", ",", "ok", ":=", "intersection", "(", "ray", ",", "wall", ")", ";", "ok", "{", "points", "=", "append", "(", "points", ",", "[", "2", "]", "float64", "{", "px", ",", "py", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Find the point closest to start of ray", "<mask>", ":=", "math", ".", "Inf", "(", "1", ")", "\n", "minI", ":=", "-", "1", "\n", "for", "i", ",", "p", ":=", "range", "points", "{", "d2", ":=", "(", "cx", "-", "p", "[", "0", "]", ")", "*", "(", "cx", "-", "p", "[", "0", "]", ")", "+", "(", "cy", "-", "p", "[", "1", "]", ")", "*", "(", "cy", "-", "p", "[", "1", "]", ")", "\n", "if", "d2", "<", "min", "{", "min", "=", "d2", "\n", "minI", "=", "i", "\n", "}", "\n", "}", "\n", "rays", "=", "append", "(", "rays", ",", "line", "{", "cx", ",", "cy", ",", "points", "[", "minI", "]", "[", "0", "]", ",", "points", "[", "minI", "]", "[", "1", "]", "}", ")", "\n", "}", "\n", "}", "\n", "}", "\n\n", "// Sort rays based on angle, otherwise light triangles will not come out right", "sort", ".", "Slice", "(", "rays", ",", "func", "(", "i", "int", ",", "j", "int", ")", "bool", "{", "return", "rays", "[", "i", "]", ".", "angle", "(", ")", "<", "rays", "[", "j", "]", ".", "angle", "(", ")", "\n", "}", ")", "\n", "return", "rays", "\n", "}" ]

[ "float", "types" ]

[ "func", "convertNvFloat", "(", "v", "interface", "{", "}", ",", "<mask>", "float64", ")", "(", "driver", ".", "Value", ",", "error", ")", "{", "if", "v", "==", "nil", "{", "return", "v", ",", "nil", "\n", "}", "\n\n", "rv", ":=", "reflect", ".", "ValueOf", "(", "v", ")", "\n", "switch", "rv", ".", "Kind", "(", ")", "{", "case", "reflect", ".", "Float32", ",", "reflect", ".", "Float64", ":", "f64", ":=", "rv", ".", "Float", "(", ")", "\n", "if", "math", ".", "Abs", "(", "f64", ")", ">", "max", "{", "return", "nil", ",", "ErrFloatOutOfRange", "\n", "}", "\n", "return", "f64", ",", "nil", "\n", "case", "reflect", ".", "Ptr", ":", "// indirect pointers", "if", "rv", ".", "IsNil", "(", ")", "{", "return", "nil", ",", "nil", "\n", "}", "\n", "return", "convertNvFloat", "(", "rv", ".", "Elem", "(", ")", ".", "Interface", "(", ")", ",", "max", ")", "\n", "}", "\n\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "v", ")", "\n", "}" ]

[ "clamp", "clamps", "v", "to", "the", "range", "[", "min", "max", "]", "." ]

[ "func", "clamp", "(", "v", ",", "<mask>", ",", "max", "int", ")", "int", "{", "if", "min", ">", "max", "{", "panic", "(", "\"", "\"", ")", "\n", "}", "\n", "if", "v", "<", "min", "{", "return", "min", "\n", "}", "\n", "if", "max", "<", "v", "{", "return", "max", "\n", "}", "\n", "return", "v", "\n", "}" ]

[ "/", "*", "NewProgressBar", "creates", "a", "new", "ProgressBar", ".", "parent", "-", "is", "container", "that", "keeps", "the", "control", ".", "width", "and", "heigth", "-", "are", "minimal", "size", "of", "the", "control", ".", "scale", "-", "the", "way", "of", "scaling", "the", "control", "when", "the", "parent", "is", "resized", ".", "Use", "DoNotScale", "constant", "if", "the", "control", "should", "keep", "its", "original", "size", "." ]

[ "func", "CreateProgressBar", "(", "parent", "Control", ",", "width", ",", "height", "int", ",", "scale", "int", ")", "*", "ProgressBar", "{", "b", ":=", "new", "(", "ProgressBar", ")", "\n", "b", ".", "BaseControl", "=", "NewBaseControl", "(", ")", "\n\n", "if", "height", "==", "AutoSize", "{", "height", "=", "1", "\n", "}", "\n", "if", "width", "==", "AutoSize", "{", "width", "=", "10", "\n", "}", "\n\n", "b", ".", "SetSize", "(", "width", ",", "height", ")", "\n", "b", ".", "SetConstraints", "(", "width", ",", "height", ")", "\n", "b", ".", "SetTabStop", "(", "false", ")", "\n", "b", ".", "SetScale", "(", "scale", ")", "\n", "b", ".", "<mask>", "=", "0", "\n", "b", ".", "max", "=", "10", "\n", "b", ".", "direction", "=", "Horizontal", "\n", "b", ".", "parent", "=", "parent", "\n", "b", ".", "align", "=", "AlignCenter", "\n\n", "if", "parent", "!=", "nil", "{", "parent", ".", "AddChild", "(", "b", ")", "\n", "}", "\n\n", "return", "b", "\n", "}" ]

[ "PageDown", "moves", "the", "visible", "list", "forward", "by", "x", "items", ".", "Where", "x", "is", "the", "size", "of", "the", "visible", "items", "on", "the", "list", ".", "The", "selected", "item", "becomes", "the", "first", "visible", "item", "." ]

[ "func", "(", "l", "*", "List", ")", "PageDown", "(", ")", "{", "start", ":=", "l", ".", "start", "+", "l", ".", "size", "\n", "<mask>", ":=", "len", "(", "l", ".", "scope", ")", "-", "l", ".", "size", "\n\n", "switch", "{", "case", "len", "(", "l", ".", "scope", ")", "<", "l", ".", "size", ":", "l", ".", "start", "=", "0", "\n", "case", "start", ">", "max", ":", "l", ".", "start", "=", "max", "\n", "default", ":", "l", ".", "start", "=", "start", "\n", "}", "\n\n", "cursor", ":=", "l", ".", "start", "\n\n", "if", "cursor", "==", "l", ".", "cursor", "{", "l", ".", "cursor", "=", "len", "(", "l", ".", "scope", ")", "-", "1", "\n", "}", "else", "if", "cursor", ">", "l", ".", "cursor", "{", "l", ".", "cursor", "=", "cursor", "\n", "}", "\n", "}" ]

[ "merge", "merges", "two", "similar", "Signature", "zapping", "out", "differences", "." ]

[ "func", "(", "s", "*", "Signature", ")", "merge", "(", "r", "*", "Signature", ")", "*", "Signature", "{", "<mask>", ":=", "s", ".", "SleepMin", "\n", "if", "r", ".", "SleepMin", "<", "min", "{", "min", "=", "r", ".", "SleepMin", "\n", "}", "\n", "max", ":=", "s", ".", "SleepMax", "\n", "if", "r", ".", "SleepMax", ">", "max", "{", "max", "=", "r", ".", "SleepMax", "\n", "}", "\n", "return", "&", "Signature", "{", "State", ":", "s", ".", "State", ",", "// Drop right side.", "CreatedBy", ":", "s", ".", "CreatedBy", ",", "// Drop right side.", "SleepMin", ":", "min", ",", "SleepMax", ":", "max", ",", "Stack", ":", "*", "s", ".", "Stack", ".", "merge", "(", "&", "r", ".", "Stack", ")", ",", "Locked", ":", "s", ".", "Locked", "||", "r", ".", "Locked", ",", "// TODO(maruel): This is weirdo.", "}", "\n", "}" ]

[ "parseShadow", "parses", "the", "row", "of", "a", "shadowed", "password", "." ]

[ "func", "parseShadow", "(", "row", "string", ")", "(", "*", "Shadow", ",", "error", ")", "{", "fields", ":=", "strings", ".", "Split", "(", "row", ",", "\"", "\"", ")", "\n", "if", "len", "(", "fields", ")", "!=", "9", "{", "return", "nil", ",", "rowError", "{", "_SHADOW_FILE", ",", "row", "}", "\n", "}", "\n\n", "var", "inactive", ",", "expire", ",", "flag", "int", "\n\n", "changed", ",", "err", ":=", "parseChange", "(", "fields", "[", "2", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "atoiError", "{", "_SHADOW_FILE", ",", "row", ",", "\"", "\"", "}", "\n", "}", "\n", "<mask>", ",", "err", ":=", "strconv", ".", "Atoi", "(", "fields", "[", "3", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "atoiError", "{", "_SHADOW_FILE", ",", "row", ",", "\"", "\"", "}", "\n", "}", "\n", "max", ",", "err", ":=", "strconv", ".", "Atoi", "(", "fields", "[", "4", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "atoiError", "{", "_SHADOW_FILE", ",", "row", ",", "\"", "\"", "}", "\n", "}", "\n", "warn", ",", "err", ":=", "strconv", ".", "Atoi", "(", "fields", "[", "5", "]", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "atoiError", "{", "_SHADOW_FILE", ",", "row", ",", "\"", "\"", "}", "\n", "}", "\n\n", "// Optional fields", "if", "fields", "[", "6", "]", "!=", "\"", "\"", "{", "if", "inactive", ",", "err", "=", "strconv", ".", "Atoi", "(", "fields", "[", "6", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "atoiError", "{", "_SHADOW_FILE", ",", "row", ",", "\"", "\"", "}", "\n", "}", "\n", "}", "\n", "if", "fields", "[", "7", "]", "!=", "\"", "\"", "{", "if", "expire", ",", "err", "=", "strconv", ".", "Atoi", "(", "fields", "[", "7", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "atoiError", "{", "_SHADOW_FILE", ",", "row", ",", "\"", "\"", "}", "\n", "}", "\n", "}", "\n", "if", "fields", "[", "8", "]", "!=", "\"", "\"", "{", "if", "flag", ",", "err", "=", "strconv", ".", "Atoi", "(", "fields", "[", "8", "]", ")", ";", "err", "!=", "nil", "{", "return", "nil", ",", "atoiError", "{", "_SHADOW_FILE", ",", "row", ",", "\"", "\"", "}", "\n", "}", "\n", "}", "\n\n", "return", "&", "Shadow", "{", "fields", "[", "0", "]", ",", "fields", "[", "1", "]", ",", "changed", ",", "min", ",", "max", ",", "warn", ",", "inactive", ",", "expire", ",", "flag", ",", "}", ",", "nil", "\n", "}" ]

[ "String", "returns", "the", "position", "of", "the", "string", "that", "begins", "at", "the", "specified", "pos" ]

[ "func", "String", "(", "in", "[", "]", "byte", ",", "pos", "int", ")", "(", "int", ",", "error", ")", "{", "pos", ",", "err", ":=", "skipSpace", "(", "in", ",", "pos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "<mask>", ":=", "len", "(", "in", ")", "\n\n", "if", "v", ":=", "in", "[", "pos", "]", ";", "v", "!=", "'\"'", "{", "return", "0", ",", "newError", "(", "pos", ",", "v", ")", "\n", "}", "\n", "pos", "++", "\n\n", "for", "{", "switch", "in", "[", "pos", "]", "{", "case", "'\\\\'", ":", "if", "in", "[", "pos", "+", "1", "]", "==", "'\"'", "{", "pos", "++", "\n", "}", "\n", "case", "'\"'", ":", "return", "pos", "+", "1", ",", "nil", "\n", "}", "\n", "pos", "++", "\n\n", "if", "pos", ">=", "max", "{", "break", "\n", "}", "\n", "}", "\n\n", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "Left", "returns", "the", "number", "of", "remaining", "requests", "for", "id", "during", "a", "current", "period", "." ]

[ "func", "(", "r", "*", "RateLimiter", ")", "Left", "(", "id", "string", ")", "(", "int64", ",", "error", ")", "{", "// Retrieve attempted count.", "attempted", ",", "err", ":=", "r", ".", "Attempted", "(", "id", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "// Left is max minus attempted.", "left", ":=", "r", ".", "<mask>", "-", "attempted", "\n", "if", "left", "<", "0", "{", "return", "0", ",", "nil", "\n", "}", "\n\n", "return", "left", ",", "nil", "\n", "}" ]

[ "Next", "moves", "the", "visible", "list", "forward", "one", "item", ".", "If", "the", "selected", "item", "is", "out", "of", "view", "the", "new", "select", "item", "becomes", "the", "first", "visible", "item", ".", "If", "the", "list", "is", "already", "at", "the", "bottom", "nothing", "happens", "." ]

[ "func", "(", "l", "*", "List", ")", "Next", "(", ")", "{", "<mask>", ":=", "len", "(", "l", ".", "scope", ")", "-", "1", "\n\n", "if", "l", ".", "cursor", "<", "max", "{", "l", ".", "cursor", "++", "\n", "}", "\n\n", "if", "l", ".", "start", "+", "l", ".", "size", "<=", "l", ".", "cursor", "{", "l", ".", "start", "=", "l", ".", "cursor", "-", "l", ".", "size", "+", "1", "\n", "}", "\n", "}" ]

[ "stacks", "is", "a", "wrapper", "for", "runtime", ".", "Stack", "that", "attempts", "to", "recover", "the", "data", "for", "all", "goroutines", "." ]

[ "func", "stacks", "(", "all", "bool", ",", "<mask>", "int", ")", "[", "]", "byte", "{", "// We don't know how big the traces are, so grow a few times if they don't fit. Start large, though.", "n", ":=", "initialMaxStackBufSize", "\n", "var", "trace", "[", "]", "byte", "\n", "for", "n", "<=", "max", "{", "trace", "=", "make", "(", "[", "]", "byte", ",", "n", ")", "\n", "nbytes", ":=", "runtime", ".", "Stack", "(", "trace", ",", "all", ")", "\n", "if", "nbytes", "<", "len", "(", "trace", ")", "{", "return", "trace", "[", ":", "nbytes", "]", "\n", "}", "\n", "n", "*=", "2", "\n", "}", "\n", "return", "trace", "\n", "}" ]

[ "ScaleButtonNew", "()", "is", "a", "wrapper", "around", "gtk_scale_button_new", "()", "." ]

[ "func", "ScaleButtonNew", "(", "size", "IconSize", ",", "<mask>", ",", "max", ",", "step", "float64", ",", "icons", "[", "]", "string", ")", "(", "*", "ScaleButton", ",", "error", ")", "{", "cicons", ":=", "make", "(", "[", "]", "*", "C", ".", "gchar", ",", "len", "(", "icons", ")", ")", "\n", "for", "i", ",", "icon", ":=", "range", "icons", "{", "cicons", "[", "i", "]", "=", "(", "*", "C", ".", "gchar", ")", "(", "C", ".", "CString", "(", "icon", ")", ")", "\n", "defer", "C", ".", "free", "(", "unsafe", ".", "Pointer", "(", "cicons", "[", "i", "]", ")", ")", "\n", "}", "\n", "cicons", "=", "append", "(", "cicons", ",", "nil", ")", "\n\n", "c", ":=", "C", ".", "gtk_scale_button_new", "(", "C", ".", "GtkIconSize", "(", "size", ")", ",", "C", ".", "gdouble", "(", "min", ")", ",", "C", ".", "gdouble", "(", "max", ")", ",", "C", ".", "gdouble", "(", "step", ")", ",", "&", "cicons", "[", "0", "]", ")", "\n", "if", "c", "==", "nil", "{", "return", "nil", ",", "nilPtrErr", "\n", "}", "\n", "return", "wrapScaleButton", "(", "glib", ".", "Take", "(", "unsafe", ".", "Pointer", "(", "c", ")", ")", ")", ",", "nil", "\n", "}" ]

[ "ParseWaitConfig", "parses", "a", "string", "of", "the", "format", "minimum", "(", ":", "maximum", ")", "into", "a", "WaitConfig", "." ]

[ "func", "ParseWaitConfig", "(", "s", "string", ")", "(", "*", "WaitConfig", ",", "error", ")", "{", "s", "=", "strings", ".", "TrimSpace", "(", "s", ")", "\n", "if", "len", "(", "s", ")", "<", "1", "{", "return", "nil", ",", "ErrWaitStringEmpty", "\n", "}", "\n\n", "parts", ":=", "strings", ".", "Split", "(", "s", ",", "\"", "\"", ")", "\n\n", "var", "<mask>", ",", "max", "time", ".", "Duration", "\n", "var", "err", "error", "\n\n", "switch", "len", "(", "parts", ")", "{", "case", "1", ":", "min", ",", "err", "=", "time", ".", "ParseDuration", "(", "strings", ".", "TrimSpace", "(", "parts", "[", "0", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "max", "=", "4", "*", "min", "\n", "case", "2", ":", "min", ",", "err", "=", "time", ".", "ParseDuration", "(", "strings", ".", "TrimSpace", "(", "parts", "[", "0", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "max", ",", "err", "=", "time", ".", "ParseDuration", "(", "strings", ".", "TrimSpace", "(", "parts", "[", "1", "]", ")", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "default", ":", "return", "nil", ",", "ErrWaitInvalidFormat", "\n", "}", "\n\n", "if", "min", "<", "0", "||", "max", "<", "0", "{", "return", "nil", ",", "ErrWaitNegative", "\n", "}", "\n\n", "if", "max", "<", "min", "{", "return", "nil", ",", "ErrWaitMinLTMax", "\n", "}", "\n\n", "var", "c", "WaitConfig", "\n", "c", ".", "Min", "=", "TimeDuration", "(", "min", ")", "\n", "c", ".", "Max", "=", "TimeDuration", "(", "max", ")", "\n\n", "return", "&", "c", ",", "nil", "\n", "}" ]

[ "arrayLen", "returns", "the", "length", "of", "the", "array", "whose", "composite", "literal", "elements", "are", "elts", "." ]

[ "func", "(", "b", "*", "builder", ")", "arrayLen", "(", "fn", "*", "Function", ",", "elts", "[", "]", "ast", ".", "Expr", ")", "int64", "{", "var", "<mask>", "int64", "=", "-", "1", "\n", "var", "i", "int64", "=", "-", "1", "\n", "for", "_", ",", "e", ":=", "range", "elts", "{", "if", "kv", ",", "ok", ":=", "e", ".", "(", "*", "ast", ".", "KeyValueExpr", ")", ";", "ok", "{", "i", "=", "b", ".", "expr", "(", "fn", ",", "kv", ".", "Key", ")", ".", "(", "*", "Const", ")", ".", "Int64", "(", ")", "\n", "}", "else", "{", "i", "++", "\n", "}", "\n", "if", "i", ">", "max", "{", "max", "=", "i", "\n", "}", "\n", "}", "\n", "return", "max", "+", "1", "\n", "}" ]

[ "Number", "returns", "the", "end", "position", "of", "the", "number", "that", "begins", "at", "the", "specified", "pos" ]

[ "func", "Number", "(", "in", "[", "]", "byte", ",", "pos", "int", ")", "(", "int", ",", "error", ")", "{", "pos", ",", "err", ":=", "skipSpace", "(", "in", ",", "pos", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "<mask>", ":=", "len", "(", "in", ")", "\n", "for", "{", "v", ":=", "in", "[", "pos", "]", "\n", "switch", "v", "{", "case", "'-'", ",", "'+'", ",", "'.'", ",", "'e'", ",", "'E'", ",", "'1'", ",", "'2'", ",", "'3'", ",", "'4'", ",", "'5'", ",", "'6'", ",", "'7'", ",", "'8'", ",", "'9'", ",", "'0'", ":", "pos", "++", "\n", "default", ":", "return", "pos", ",", "nil", "\n", "}", "\n\n", "if", "pos", ">=", "max", "{", "return", "pos", ",", "nil", "\n", "}", "\n", "}", "\n\n", "return", "pos", ",", "nil", "\n", "}" ]

[ "-----------------", "own", "methods", "-------------------------", "SetValue", "sets", "new", "progress", "value", ".", "If", "value", "exceeds", "ProgressBar", "limits", "then", "the", "limit", "value", "is", "used" ]

[ "func", "(", "b", "*", "ProgressBar", ")", "SetValue", "(", "pos", "int", ")", "{", "b", ".", "mtx", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mtx", ".", "Unlock", "(", ")", "\n", "if", "pos", "<", "b", ".", "<mask>", "{", "b", ".", "value", "=", "b", ".", "min", "\n", "}", "else", "if", "pos", ">", "b", ".", "max", "{", "b", ".", "value", "=", "b", ".", "max", "\n", "}", "else", "{", "b", ".", "value", "=", "pos", "\n", "}", "\n", "}" ]

[ "Items", "returns", "a", "slice", "equal", "to", "the", "size", "of", "the", "list", "with", "the", "current", "visible", "items", "and", "the", "index", "of", "the", "active", "item", "in", "this", "list", "." ]

[ "func", "(", "l", "*", "List", ")", "Items", "(", ")", "(", "[", "]", "interface", "{", "}", ",", "int", ")", "{", "var", "result", "[", "]", "interface", "{", "}", "\n", "<mask>", ":=", "len", "(", "l", ".", "scope", ")", "\n", "end", ":=", "l", ".", "start", "+", "l", ".", "size", "\n\n", "if", "end", ">", "max", "{", "end", "=", "max", "\n", "}", "\n\n", "active", ":=", "NotFound", "\n\n", "for", "i", ",", "j", ":=", "l", ".", "start", ",", "0", ";", "i", "<", "end", ";", "i", ",", "j", "=", "i", "+", "1", ",", "j", "+", "1", "{", "if", "l", ".", "cursor", "==", "i", "{", "active", "=", "j", "\n", "}", "\n\n", "result", "=", "append", "(", "result", ",", "*", "l", ".", "scope", "[", "i", "]", ")", "\n", "}", "\n\n", "return", "result", ",", "active", "\n", "}" ]

[ "Find", "the", "price", "in", "the", "given", "package", "with", "the", "specified", "size", "and", "iops" ]

[ "func", "FindPerformanceIOPSPrice", "(", "productPackage", "datatypes", ".", "Product_Package", ",", "size", "int", ",", "iops", "int", ")", "(", "datatypes", ".", "Product_Item_Price", ",", "error", ")", "{", "for", "_", ",", "item", ":=", "range", "productPackage", ".", "Items", "{", "if", "int", "(", "*", "item", ".", "Capacity", ")", "!=", "int", "(", "iops", ")", "{", "continue", "\n", "}", "\n", "for", "_", ",", "price", ":=", "range", "item", ".", "Prices", "{", "// Only collect prices from valid location groups.", "if", "price", ".", "LocationGroupId", "!=", "nil", "{", "continue", "\n", "}", "\n", "if", "!", "hasCategory", "(", "price", ".", "Categories", ",", "\"", "\"", ")", "{", "continue", "\n", "}", "\n", "<mask>", ",", "err", ":=", "strconv", ".", "Atoi", "(", "*", "price", ".", "CapacityRestrictionMinimum", ")", "\n", "if", "err", "!=", "nil", "{", "return", "datatypes", ".", "Product_Item_Price", "{", "}", ",", "bosherr", ".", "Errorf", "(", "\"", "\"", ",", "iops", ")", "\n", "}", "\n", "if", "size", "<", "int", "(", "min", ")", "{", "continue", "\n", "}", "\n", "max", ",", "err", ":=", "strconv", ".", "Atoi", "(", "*", "price", ".", "CapacityRestrictionMaximum", ")", "\n", "if", "err", "!=", "nil", "{", "return", "datatypes", ".", "Product_Item_Price", "{", "}", ",", "bosherr", ".", "Errorf", "(", "\"", "\"", ",", "iops", ")", "\n", "}", "\n", "if", "size", ">", "int", "(", "max", ")", "{", "continue", "\n", "}", "\n", "return", "price", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "datatypes", ".", "Product_Item_Price", "{", "}", ",", "bosherr", ".", "Errorf", "(", "\"", "\"", ",", "iops", ")", "\n", "}" ]

[ "Attempt", "attempts", "to", "perform", "a", "request", "for", "an", "id", "and", "returns", "whether", "it", "was", "successful", "or", "not", "." ]

[ "func", "(", "r", "*", "RateLimiter", ")", "Attempt", "(", "id", "string", ")", "(", "bool", ",", "error", ")", "{", "// Create hash from id", "hash", ":=", "r", ".", "hasher", ".", "Hash", "(", "id", ")", "\n\n", "// Get value for hash in Redis. If redis.Nil is returned, key does not", "// exist.", "exists", ":=", "true", "\n\n", "val", ",", "err", ":=", "r", ".", "redisClient", ".", "Get", "(", "hash", ")", ".", "Result", "(", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "redis", ".", "Nil", "{", "// Key does not exist. See: http://redis.io/commands/GET", "exists", "=", "false", "\n", "}", "else", "{", "return", "false", ",", "err", "\n", "}", "\n", "}", "\n\n", "// If key exists and is >= max requests, return false.", "if", "exists", "{", "intVal", ",", "err", ":=", "strconv", ".", "ParseInt", "(", "val", ",", "10", ",", "64", ")", "\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "if", "intVal", ">=", "r", ".", "<mask>", "{", "return", "false", ",", "nil", "\n", "}", "\n", "}", "\n\n", "// Otherwise, increment and expire key for hasher.Duration(). Note, we call", "// Expire even when key already exists to avoid race condition where key", "// expires between prior existence check and this Incr call.", "//", "// See: http://redis.io/commands/INCR", "// See: http://redis.io/commands/INCR#pattern-rate-limiter-1", "err", "=", "r", ".", "redisClient", ".", "Watch", "(", "func", "(", "rx", "*", "redis", ".", "Tx", ")", "error", "{", "_", ",", "err", ":=", "rx", ".", "Pipelined", "(", "func", "(", "pipe", "*", "redis", ".", "Pipeline", ")", "error", "{", "if", "err", ":=", "pipe", ".", "Incr", "(", "hash", ")", ".", "Err", "(", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "return", "pipe", ".", "Expire", "(", "hash", ",", "r", ".", "hasher", ".", "Duration", "(", ")", ")", ".", "Err", "(", ")", "\n", "}", ")", "\n\n", "return", "err", "\n", "}", ")", "\n\n", "if", "err", "!=", "nil", "{", "return", "false", ",", "err", "\n", "}", "\n\n", "return", "true", ",", "nil", "\n", "}" ]

[ "===", "floor", "(", "Vector", "ValueTypeVector", ")", "Vector", "===", "===", "max_over_time", "(", "Matrix", "ValueTypeMatrix", ")", "Vector", "===" ]

[ "func", "funcMaxOverTime", "(", "vals", "[", "]", "Value", ",", "args", "Expressions", ",", "enh", "*", "EvalNodeHelper", ")", "Vector", "{", "return", "aggrOverTime", "(", "vals", ",", "enh", ",", "func", "(", "values", "[", "]", "Point", ")", "float64", "{", "<mask>", ":=", "values", "[", "0", "]", ".", "V", "\n", "for", "_", ",", "v", ":=", "range", "values", "{", "if", "v", ".", "V", ">", "max", "||", "math", ".", "IsNaN", "(", "max", ")", "{", "max", "=", "v", ".", "V", "\n", "}", "\n", "}", "\n", "return", "max", "\n", "}", ")", "\n", "}" ]

[ "expandVmwareDistributedVirtualSwitchTrunkVlanSpec", "reads", "certain", "ResourceData", "keys", "and", "returns", "a", "VmwareDistributedVirtualSwitchTrunkVlanSpec", "." ]

[ "func", "expandVmwareDistributedVirtualSwitchTrunkVlanSpec", "(", "d", "*", "schema", ".", "ResourceData", ")", "*", "types", ".", "VmwareDistributedVirtualSwitchTrunkVlanSpec", "{", "var", "ranges", "[", "]", "types", ".", "NumericRange", "\n", "data", ":=", "d", ".", "Get", "(", "\"", "\"", ")", ".", "(", "*", "schema", ".", "Set", ")", ".", "List", "(", ")", "\n", "for", "_", ",", "v", ":=", "range", "data", "{", "log", ".", "Printf", "(", "\"", "\"", ",", "v", ")", "\n", "r", ":=", "v", ".", "(", "map", "[", "string", "]", "interface", "{", "}", ")", "\n", "<mask>", ":=", "r", "[", "\"", "\"", "]", ".", "(", "int", ")", "\n", "max", ":=", "r", "[", "\"", "\"", "]", ".", "(", "int", ")", "\n", "rng", ":=", "types", ".", "NumericRange", "{", "Start", ":", "int32", "(", "min", ")", ",", "End", ":", "int32", "(", "max", ")", ",", "}", "\n", "ranges", "=", "append", "(", "ranges", ",", "rng", ")", "\n", "}", "\n\n", "if", "len", "(", "ranges", ")", "<", "1", "{", "return", "nil", "\n", "}", "\n\n", "obj", ":=", "&", "types", ".", "VmwareDistributedVirtualSwitchTrunkVlanSpec", "{", "VlanId", ":", "ranges", ",", "}", "\n", "return", "obj", "\n", "}" ]

[ "SetCursor", "sets", "the", "position", "of", "the", "cursor", "in", "the", "list", ".", "Values", "out", "of", "bounds", "will", "be", "clamped", "." ]

[ "func", "(", "l", "*", "List", ")", "SetCursor", "(", "i", "int", ")", "{", "<mask>", ":=", "len", "(", "l", ".", "scope", ")", "-", "1", "\n", "if", "i", ">=", "max", "{", "i", "=", "max", "\n", "}", "\n", "if", "i", "<", "0", "{", "i", "=", "0", "\n", "}", "\n", "l", ".", "cursor", "=", "i", "\n\n", "if", "l", ".", "start", ">", "l", ".", "cursor", "{", "l", ".", "start", "=", "l", ".", "cursor", "\n", "}", "else", "if", "l", ".", "start", "+", "l", ".", "size", "<=", "l", ".", "cursor", "{", "l", ".", "start", "=", "l", ".", "cursor", "-", "l", ".", "size", "+", "1", "\n", "}", "\n", "}" ]

[ "newQuiescence", "creates", "a", "new", "quiescence", "timer", "for", "the", "given", "template", "." ]

[ "func", "newQuiescence", "(", "ch", "chan", "*", "template", ".", "Template", ",", "<mask>", ",", "max", "time", ".", "Duration", ",", "t", "*", "template", ".", "Template", ")", "*", "quiescence", "{", "return", "&", "quiescence", "{", "template", ":", "t", ",", "min", ":", "min", ",", "max", ":", "max", ",", "ch", ":", "ch", ",", "}", "\n", "}" ]

[ "SetLimits", "set", "new", "ProgressBar", "limits", ".", "The", "current", "value", "is", "adjusted", "if", "it", "exceeds", "new", "limits" ]

[ "func", "(", "b", "*", "ProgressBar", ")", "SetLimits", "(", "<mask>", ",", "max", "int", ")", "{", "b", ".", "min", "=", "min", "\n", "b", ".", "max", "=", "max", "\n\n", "if", "b", ".", "value", "<", "b", ".", "min", "{", "b", ".", "value", "=", "min", "\n", "}", "\n", "if", "b", ".", "value", ">", "b", ".", "max", "{", "b", ".", "value", "=", "max", "\n", "}", "\n", "}" ]

[ "AddInRange", "increments", "a", "value", "by", "the", "passed", "quantity", "while", "ensuring", "the", "values", "always", "remain", "within", "the", "supplied", "min", "/", "max", "range", "." ]

[ "func", "addInRange", "(", "n", "int16", ",", "increment", "int16", ",", "<mask>", "int16", ",", "max", "int16", ")", "int16", "{", "return", "ensureInRange", "(", "n", "+", "increment", ",", "min", ",", "max", ")", "\n", "}" ]

[ "Check", "the", "virtual", "server", "instance", "is", "ready", "for", "use" ]

[ "func", "(", "c", "*", "ClientManager", ")", "WaitInstanceUntilReady", "(", "id", "int", ",", "until", "time", ".", "Time", ")", "error", "{", "for", "{", "virtualGuest", ",", "found", ",", "err", ":=", "c", ".", "GetInstance", "(", "id", ",", "\"", "\"", ")", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "if", "!", "found", "{", "return", "bosherr", ".", "WrapErrorf", "(", "err", ",", "\"", "\"", ",", "id", ")", "\n", "}", "\n\n", "lastReload", ":=", "virtualGuest", ".", "LastOperatingSystemReload", "\n", "activeTxn", ":=", "virtualGuest", ".", "ActiveTransaction", "\n", "provisionDate", ":=", "virtualGuest", ".", "ProvisionDate", "\n\n", "// if lastReload != nil && lastReload.ModifyDate != nil {", "// \tfmt.Println(\"lastReload: \", (*lastReload.ModifyDate).Format(time.RFC3339))", "// }", "// if activeTxn != nil && activeTxn.TransactionStatus != nil && activeTxn.TransactionStatus.Name != nil {", "// \tfmt.Println(\"activeTxn: \", *activeTxn.TransactionStatus.Name)", "// }", "// if provisionDate != nil {", "// \tfmt.Println(\"provisionDate: \", (*provisionDate).Format(time.RFC3339))", "// }", "reloading", ":=", "activeTxn", "!=", "nil", "&&", "lastReload", "!=", "nil", "&&", "*", "activeTxn", ".", "Id", "==", "*", "lastReload", ".", "Id", "\n", "if", "provisionDate", "!=", "nil", "&&", "!", "reloading", "{", "// fmt.Println(\"power state:\", *virtualGuest.PowerState.KeyName)", "if", "*", "virtualGuest", ".", "PowerState", ".", "KeyName", "==", "\"", "\"", "{", "return", "nil", "\n", "}", "\n", "}", "\n\n", "now", ":=", "time", ".", "Now", "(", ")", "\n", "if", "now", ".", "After", "(", "until", ")", "{", "return", "bosherr", ".", "Errorf", "(", "\"", "\"", ",", "*", "virtualGuest", ".", "Id", ")", "\n", "}", "\n\n", "<mask>", ":=", "math", ".", "Min", "(", "float64", "(", "10.0", ")", ",", "float64", "(", "until", ".", "Sub", "(", "now", ")", ")", ")", "\n", "time", ".", "Sleep", "(", "time", ".", "Duration", "(", "min", ")", "*", "time", ".", "Second", ")", "\n", "}", "\n", "}" ]

[ "Repaint", "draws", "the", "control", "on", "its", "View", "surface", ".", "Horizontal", "ProgressBar", "supports", "custom", "title", "over", "the", "bar", ".", "One", "can", "set", "title", "using", "method", "SetTitle", ".", "There", "are", "a", "few", "predefined", "variables", "that", "can", "be", "used", "inside", "title", "to", "show", "value", "or", "total", "progress", ".", "Variable", "must", "be", "enclosed", "with", "double", "curly", "brackets", ".", "Available", "variables", ":", "percent", "-", "the", "current", "percentage", "rounded", "to", "closest", "integer", "value", "-", "raw", "ProgressBar", "value", "min", "-", "lower", "ProgressBar", "limit", "max", "-", "upper", "ProgressBar", "limit", "Examples", ":", "pb", ".", "SetTitle", "(", "{{", "value", "}}", "of", "{{", "max", "}}", ")", "pb", ".", "SetTitle", "(", "{{", "percent", "}}", "%", ")" ]

[ "func", "(", "b", "*", "ProgressBar", ")", "Draw", "(", ")", "{", "if", "b", ".", "hidden", "{", "return", "\n", "}", "\n\n", "b", ".", "mtx", ".", "RLock", "(", ")", "\n", "defer", "b", ".", "mtx", ".", "RUnlock", "(", ")", "\n", "if", "b", ".", "<mask>", "<=", "b", ".", "min", "{", "return", "\n", "}", "\n\n", "PushAttributes", "(", ")", "\n", "defer", "PopAttributes", "(", ")", "\n\n", "fgOff", ",", "fgOn", ":=", "RealColor", "(", "b", ".", "fg", ",", "b", ".", "Style", "(", ")", ",", "ColorProgressText", ")", ",", "RealColor", "(", "b", ".", "fgActive", ",", "b", ".", "Style", "(", ")", ",", "ColorProgressActiveText", ")", "\n", "bgOff", ",", "bgOn", ":=", "RealColor", "(", "b", ".", "bg", ",", "b", ".", "Style", "(", ")", ",", "ColorProgressBack", ")", ",", "RealColor", "(", "b", ".", "bgActive", ",", "b", ".", "Style", "(", ")", ",", "ColorProgressActiveBack", ")", "\n\n", "parts", ":=", "[", "]", "rune", "(", "SysObject", "(", "ObjProgressBar", ")", ")", "\n", "cFilled", ",", "cEmpty", ":=", "parts", "[", "0", "]", ",", "parts", "[", "1", "]", "\n\n", "prc", ":=", "0", "\n", "if", "b", ".", "value", ">=", "b", ".", "max", "{", "prc", "=", "100", "\n", "}", "else", "if", "b", ".", "value", "<", "b", ".", "max", "&&", "b", ".", "value", ">", "b", ".", "min", "{", "prc", "=", "(", "100", "*", "(", "b", ".", "value", "-", "b", ".", "min", ")", ")", "/", "(", "b", ".", "max", "-", "b", ".", "min", ")", "\n", "}", "\n\n", "var", "title", "string", "\n", "if", "b", ".", "direction", "==", "Horizontal", "&&", "b", ".", "Title", "(", ")", "!=", "\"", "\"", "{", "title", "=", "b", ".", "Title", "(", ")", "\n", "title", "=", "strings", ".", "Replace", "(", "title", ",", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "prc", ")", ",", "-", "1", ")", "\n", "title", "=", "strings", ".", "Replace", "(", "title", ",", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "b", ".", "value", ")", ",", "-", "1", ")", "\n", "title", "=", "strings", ".", "Replace", "(", "title", ",", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "b", ".", "min", ")", ",", "-", "1", ")", "\n", "title", "=", "strings", ".", "Replace", "(", "title", ",", "\"", "\"", ",", "strconv", ".", "Itoa", "(", "b", ".", "max", ")", ",", "-", "1", ")", "\n", "}", "\n\n", "x", ",", "y", ":=", "b", ".", "Pos", "(", ")", "\n", "w", ",", "h", ":=", "b", ".", "Size", "(", ")", "\n\n", "if", "b", ".", "direction", "==", "Horizontal", "{", "filled", ":=", "prc", "*", "w", "/", "100", "\n", "sFilled", ":=", "strings", ".", "Repeat", "(", "string", "(", "cFilled", ")", ",", "filled", ")", "\n", "sEmpty", ":=", "strings", ".", "Repeat", "(", "string", "(", "cEmpty", ")", ",", "w", "-", "filled", ")", "\n\n", "for", "yy", ":=", "y", ";", "yy", "<", "y", "+", "h", ";", "yy", "++", "{", "SetTextColor", "(", "fgOn", ")", "\n", "SetBackColor", "(", "bgOn", ")", "\n", "DrawRawText", "(", "x", ",", "yy", ",", "sFilled", ")", "\n", "SetTextColor", "(", "fgOff", ")", "\n", "SetBackColor", "(", "bgOff", ")", "\n", "DrawRawText", "(", "x", "+", "filled", ",", "yy", ",", "sEmpty", ")", "\n", "}", "\n\n", "if", "title", "!=", "\"", "\"", "{", "shift", ",", "str", ":=", "AlignText", "(", "title", ",", "w", ",", "b", ".", "align", ")", "\n", "titleClr", ":=", "RealColor", "(", "b", ".", "titleFg", ",", "b", ".", "Style", "(", ")", ",", "ColorProgressTitleText", ")", "\n", "var", "sOn", ",", "sOff", "string", "\n", "if", "filled", "==", "0", "||", "shift", ">=", "filled", "{", "sOff", "=", "str", "\n", "}", "else", "if", "w", "==", "filled", "||", "shift", "+", "xs", ".", "Len", "(", "str", ")", "<", "filled", "{", "sOn", "=", "str", "\n", "}", "else", "{", "r", ":=", "filled", "-", "shift", "\n", "sOn", "=", "xs", ".", "Slice", "(", "str", ",", "0", ",", "r", ")", "\n", "sOff", "=", "xs", ".", "Slice", "(", "str", ",", "r", ",", "-", "1", ")", "\n", "}", "\n", "SetTextColor", "(", "titleClr", ")", "\n", "if", "sOn", "!=", "\"", "\"", "{", "SetBackColor", "(", "bgOn", ")", "\n", "DrawRawText", "(", "x", "+", "shift", ",", "y", ",", "sOn", ")", "\n", "}", "\n", "if", "sOff", "!=", "\"", "\"", "{", "SetBackColor", "(", "bgOff", ")", "\n", "DrawRawText", "(", "x", "+", "shift", "+", "xs", ".", "Len", "(", "sOn", ")", ",", "y", ",", "sOff", ")", "\n", "}", "\n", "}", "\n", "}", "else", "{", "filled", ":=", "prc", "*", "h", "/", "100", "\n", "sFilled", ":=", "strings", ".", "Repeat", "(", "string", "(", "cFilled", ")", ",", "w", ")", "\n", "sEmpty", ":=", "strings", ".", "Repeat", "(", "string", "(", "cEmpty", ")", ",", "w", ")", "\n", "for", "yy", ":=", "y", ";", "yy", "<", "y", "+", "h", "-", "filled", ";", "yy", "++", "{", "SetTextColor", "(", "fgOff", ")", "\n", "SetBackColor", "(", "bgOff", ")", "\n", "DrawRawText", "(", "x", ",", "yy", ",", "sEmpty", ")", "\n", "}", "\n", "for", "yy", ":=", "y", "+", "h", "-", "filled", ";", "yy", "<", "y", "+", "h", ";", "yy", "++", "{", "SetTextColor", "(", "fgOff", ")", "\n", "SetBackColor", "(", "bgOff", ")", "\n", "DrawRawText", "(", "x", ",", "yy", ",", "sFilled", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "computedCropArea", "retrieve", "the", "theorical", "crop", "area", ".", "It", "is", "defined", "by", "Height", "Width", "Mode", "and" ]

[ "func", "(", "c", "Config", ")", "computedCropArea", "(", "bounds", "image", ".", "Rectangle", ",", "size", "image", ".", "Point", ")", "(", "r", "image", ".", "Rectangle", ")", "{", "<mask>", ":=", "bounds", ".", "Min", "\n", "switch", "c", ".", "Mode", "{", "case", "Centered", ":", "rMin", ":=", "c", ".", "centeredMin", "(", "bounds", ")", "\n", "r", "=", "image", ".", "Rect", "(", "rMin", ".", "X", "-", "size", ".", "X", "/", "2", ",", "rMin", ".", "Y", "-", "size", ".", "Y", "/", "2", ",", "rMin", ".", "X", "-", "size", ".", "X", "/", "2", "+", "size", ".", "X", ",", "rMin", ".", "Y", "-", "size", ".", "Y", "/", "2", "+", "size", ".", "Y", ")", "\n", "default", ":", "// TopLeft", "rMin", ":=", "image", ".", "Point", "{", "min", ".", "X", "+", "c", ".", "Anchor", ".", "X", ",", "min", ".", "Y", "+", "c", ".", "Anchor", ".", "Y", "}", "\n", "r", "=", "image", ".", "Rect", "(", "rMin", ".", "X", ",", "rMin", ".", "Y", ",", "rMin", ".", "X", "+", "size", ".", "X", ",", "rMin", ".", "Y", "+", "size", ".", "Y", ")", "\n", "}", "\n", "return", "\n", "}" ]

[ "SetRange", "()", "is", "a", "wrapper", "around", "gtk_range_set_range", "()", "." ]

[ "func", "(", "v", "*", "Range", ")", "SetRange", "(", "<mask>", ",", "max", "float64", ")", "{", "C", ".", "gtk_range_set_range", "(", "v", ".", "native", "(", ")", ",", "C", ".", "gdouble", "(", "min", ")", ",", "C", ".", "gdouble", "(", "max", ")", ")", "\n", "}" ]

[ "ResolveCreate", "is", "invoked", "when", "dns", "name", "is", "not", "owned", "by", "any", "resource", "ResolveCreate", "takes", "minimal", "(", "string", "comparison", "of", "Target", ")", "endpoint", "to", "acquire", "the", "DNS", "record" ]

[ "func", "(", "s", "PerResource", ")", "ResolveCreate", "(", "candidates", "[", "]", "*", "endpoint", ".", "Endpoint", ")", "*", "endpoint", ".", "Endpoint", "{", "var", "<mask>", "*", "endpoint", ".", "Endpoint", "\n", "for", "_", ",", "ep", ":=", "range", "candidates", "{", "if", "min", "==", "nil", "||", "s", ".", "less", "(", "ep", ",", "min", ")", "{", "min", "=", "ep", "\n", "}", "\n", "}", "\n", "return", "min", "\n", "}" ]

[ "readAtLeast", "is", "an", "optimized", "version", "of", "io", ".", "ReadAtLeast", "which", "omits", "some", "checks", "that", "don", "t", "need", "to", "be", "performed", "when", "called", "from", "Read", "()", "in", "this", "package", "." ]

[ "func", "readAtLeast", "(", "r", "io", ".", "Reader", ",", "buf", "[", "]", "byte", ",", "<mask>", "int", ")", "error", "{", "var", "n", "int", "\n", "var", "err", "error", "\n", "// Most common case, we get all the bytes in one read", "if", "n", ",", "err", "=", "r", ".", "Read", "(", "buf", ")", ";", "n", "==", "min", "{", "return", "nil", "\n", "}", "\n", "if", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n", "// Fall back to looping", "var", "nn", "int", "\n", "for", "n", "<", "min", "{", "nn", ",", "err", "=", "r", ".", "Read", "(", "buf", "[", "n", ":", "]", ")", "\n", "if", "err", "!=", "nil", "{", "if", "err", "==", "io", ".", "EOF", "&&", "n", ">", "0", "{", "err", "=", "io", ".", "ErrUnexpectedEOF", "\n", "}", "\n", "return", "err", "\n", "}", "\n", "n", "+=", "nn", "\n", "}", "\n", "return", "nil", "\n", "}" ]

[ "SpinButtonNewWithRange", "()", "is", "a", "wrapper", "around", "gtk_spin_button_new_with_range", "()", "." ]

[ "func", "SpinButtonNewWithRange", "(", "<mask>", ",", "max", ",", "step", "float64", ")", "(", "*", "SpinButton", ",", "error", ")", "{", "c", ":=", "C", ".", "gtk_spin_button_new_with_range", "(", "C", ".", "gdouble", "(", "min", ")", ",", "C", ".", "gdouble", "(", "max", ")", ",", "C", ".", "gdouble", "(", "step", ")", ")", "\n", "if", "c", "==", "nil", "{", "return", "nil", ",", "nilPtrErr", "\n", "}", "\n", "return", "wrapSpinButton", "(", "glib", ".", "Take", "(", "unsafe", ".", "Pointer", "(", "c", ")", ")", ")", ",", "nil", "\n", "}" ]

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

[ "func", "funcMinOverTime", "(", "vals", "[", "]", "Value", ",", "args", "Expressions", ",", "enh", "*", "EvalNodeHelper", ")", "Vector", "{", "return", "aggrOverTime", "(", "vals", ",", "enh", ",", "func", "(", "values", "[", "]", "Point", ")", "float64", "{", "<mask>", ":=", "values", "[", "0", "]", ".", "V", "\n", "for", "_", ",", "v", ":=", "range", "values", "{", "if", "v", ".", "V", "<", "min", "||", "math", ".", "IsNaN", "(", "min", ")", "{", "min", "=", "v", ".", "V", "\n", "}", "\n", "}", "\n", "return", "min", "\n", "}", ")", "\n", "}" ]

[ "extractTimeRange", "returns", "minimum", "and", "maximum", "timestamp", "in", "milliseconds", "as", "provided", "by", "the", "time", "range", ".", "It", "defaults", "either", "boundary", "to", "the", "minimum", "and", "maximum", "possible", "value", "." ]

[ "func", "extractTimeRange", "(", "<mask>", ",", "max", "*", "time", ".", "Time", ")", "(", "mint", ",", "maxt", "time", ".", "Time", ",", "err", "error", ")", "{", "if", "min", "==", "nil", "{", "mint", "=", "minTime", "\n", "}", "else", "{", "mint", "=", "*", "min", "\n", "}", "\n", "if", "max", "==", "nil", "{", "maxt", "=", "maxTime", "\n", "}", "else", "{", "maxt", "=", "*", "max", "\n", "}", "\n", "if", "mint", ".", "After", "(", "maxt", ")", "{", "return", "mint", ",", "maxt", ",", "errors", ".", "Errorf", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "mint", ",", "maxt", ",", "nil", "\n", "}" ]

[ "NewLimiter", "creates", "a", "new", "instance", "of", "a", "rate", "limiter", "." ]

[ "func", "NewLimiter", "(", "client", "*", "redis", ".", "Client", ",", "hasher", "RateHasher", ",", "<mask>", "int64", ",", ")", "*", "RateLimiter", "{", "return", "&", "RateLimiter", "{", "redisClient", ":", "client", ",", "hasher", ":", "hasher", ",", "max", ":", "max", ",", "}", "\n", "}" ]

[ "===", "clamp_max", "(", "Vector", "ValueTypeVector", "max", "Scalar", ")", "Vector", "===" ]

[ "func", "funcClampMax", "(", "vals", "[", "]", "Value", ",", "args", "Expressions", ",", "enh", "*", "EvalNodeHelper", ")", "Vector", "{", "vec", ":=", "vals", "[", "0", "]", ".", "(", "Vector", ")", "\n", "<mask>", ":=", "vals", "[", "1", "]", ".", "(", "Vector", ")", "[", "0", "]", ".", "Point", ".", "V", "\n", "for", "_", ",", "el", ":=", "range", "vec", "{", "enh", ".", "out", "=", "append", "(", "enh", ".", "out", ",", "Sample", "{", "Metric", ":", "enh", ".", "dropMetricName", "(", "el", ".", "Metric", ")", ",", "Point", ":", "Point", "{", "V", ":", "math", ".", "Min", "(", "max", ",", "el", ".", "V", ")", "}", ",", "}", ")", "\n", "}", "\n", "return", "enh", ".", "out", "\n", "}" ]

[ "ValidateLevelFilter", "verifies", "that", "the", "log", "levels", "within", "the", "filter", "are", "valid", "." ]

[ "func", "ValidateLevelFilter", "(", "<mask>", "logutils", ".", "LogLevel", ",", "filter", "*", "logutils", ".", "LevelFilter", ")", "bool", "{", "for", "_", ",", "level", ":=", "range", "filter", ".", "Levels", "{", "if", "level", "==", "min", "{", "return", "true", "\n", "}", "\n", "}", "\n", "return", "false", "\n", "}" ]

[ "generates", "round", "robin", "indexes", "for", "a", "slice", "of", "length", "max", "starting", "from", "index", "start" ]

[ "func", "roundIndex", "(", "start", ",", "<mask>", "int", ")", "[", "]", "int", "{", "if", "start", "<", "0", "{", "start", "=", "0", "\n", "}", "\n", "result", ":=", "make", "(", "[", "]", "int", ",", "max", ")", "\n", "for", "i", ":=", "0", ";", "i", "<", "max", ";", "i", "++", "{", "if", "start", "+", "i", "<", "max", "{", "result", "[", "i", "]", "=", "start", "+", "i", "\n", "}", "else", "{", "result", "[", "i", "]", "=", "int", "(", "math", ".", "Abs", "(", "float64", "(", "max", "-", "(", "start", "+", "i", ")", ")", ")", ")", "\n", "}", "\n", "}", "\n", "return", "result", "\n", "}" ]

[ "===", "clamp_min", "(", "Vector", "ValueTypeVector", "min", "Scalar", ")", "Vector", "===" ]

[ "func", "funcClampMin", "(", "vals", "[", "]", "Value", ",", "args", "Expressions", ",", "enh", "*", "EvalNodeHelper", ")", "Vector", "{", "vec", ":=", "vals", "[", "0", "]", ".", "(", "Vector", ")", "\n", "<mask>", ":=", "vals", "[", "1", "]", ".", "(", "Vector", ")", "[", "0", "]", ".", "Point", ".", "V", "\n", "for", "_", ",", "el", ":=", "range", "vec", "{", "enh", ".", "out", "=", "append", "(", "enh", ".", "out", ",", "Sample", "{", "Metric", ":", "enh", ".", "dropMetricName", "(", "el", ".", "Metric", ")", ",", "Point", ":", "Point", "{", "V", ":", "math", ".", "Max", "(", "min", ",", "el", ".", "V", ")", "}", ",", "}", ")", "\n", "}", "\n", "return", "enh", ".", "out", "\n", "}" ]

[ "SetRange", "is", "a", "wrapper", "around", "gtk_spin_button_set_range", "()", "." ]

[ "func", "(", "v", "*", "SpinButton", ")", "SetRange", "(", "<mask>", ",", "max", "float64", ")", "{", "C", ".", "gtk_spin_button_set_range", "(", "v", ".", "native", "(", ")", ",", "C", ".", "gdouble", "(", "min", ")", ",", "C", ".", "gdouble", "(", "max", ")", ")", "\n", "}" ]

[ "ensureInRange", "adjusts", "the", "passed", "value", "if", "necessary", "to", "ensure", "it", "is", "within", "the", "passed", "min", "/", "max", "range", "." ]

[ "func", "ensureInRange", "(", "n", "int16", ",", "<mask>", "int16", ",", "max", "int16", ")", "int16", "{", "if", "n", "<", "min", "{", "return", "min", "\n", "}", "else", "if", "n", ">", "max", "{", "return", "max", "\n", "}", "else", "{", "return", "n", "\n", "}", "\n", "}" ]

[ "NewLargeObject", "provides", "a", "io", ".", "writer", "to", "upload", "data", "as", "a", "segmented", "upload", "It", "will", "upload", "all", "the", "segments", "into", "a", "second", "container", "named", "<container", ">", ".", "These", "segments", "will", "have", "names", "like", "large_file", "/", "1290206778", ".", "25", "/", "00000000", "large_file", "/", "1290206778", ".", "25", "/", "00000001", "etc", ".", "The", "main", "benefit", "for", "using", "a", "separate", "container", "is", "that", "the", "main", "container", "listings", "will", "not", "be", "polluted", "with", "all", "the", "segment", "names", ".", "The", "reason", "for", "using", "the", "segment", "name", "format", "of", "<name", ">", "/", "<timestamp", ">", "/", "<segment", ">", "is", "so", "that", "an", "upload", "of", "a", "new", "file", "with", "the", "same", "name", "won’t", "overwrite", "the", "contents", "of", "the", "first", "until", "the", "last", "moment", "when", "the", "manifest", "file", "is", "updated", ".", "swift", "will", "manage", "these", "segment", "files", "for", "you", "deleting", "old", "segments", "on", "deletes", "and", "overwrites", "etc", ".", "You", "can", "override", "this", "behavior", "with", "the", "--", "leave", "-", "segments", "option", "if", "desired", ";", "this", "is", "useful", "if", "you", "want", "to", "have", "multiple", "versions", "of", "the", "same", "large", "object", "available", "." ]

[ "func", "NewLargeObject", "(", "c", "*", "swift", ".", "Connection", ",", "path", "string", ",", "concurrency", "int", ",", "partSize", "int64", ",", "expireAfter", "int64", ",", "logger", "cpiLogger", ".", "Logger", ")", "(", "*", "largeObject", ",", "error", ")", "{", "pathParts", ":=", "strings", ".", "SplitN", "(", "path", ",", "\"", "\"", ",", "2", ")", "\n", "objectName", ":=", "\"", "\"", "\n", "if", "len", "(", "pathParts", ")", ">", "1", "{", "objectName", "=", "pathParts", "[", "1", "]", "\n", "}", "\n", "// #nosec G401", "lo", ":=", "largeObject", "{", "c", ":", "c", ",", "container", ":", "pathParts", "[", "0", "]", ",", "objectName", ":", "objectName", ",", "timestamp", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "time", ".", "Now", "(", ")", ".", "UnixNano", "(", ")", ")", ",", "expire", ":", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "expireAfter", ")", ",", "bufsz", ":", "max64", "(", "minPartSize", ",", "partSize", ")", ",", "ch", ":", "make", "(", "chan", "*", "part", ")", ",", "md5OfParts", ":", "md5", ".", "New", "(", ")", ",", "md5", ":", "md5", ".", "New", "(", ")", ",", "bp", ":", "newBufferPool", "(", "minPartSize", ")", ",", "logger", ":", "logger", ",", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "<mask>", "(", "concurrency", ",", "1", ")", ";", "i", "++", "{", "go", "lo", ".", "worker", "(", ")", "\n", "}", "\n\n", "// Create segment container if it doesn't already exist", "err", ":=", "c", ".", "ContainerCreate", "(", "lo", ".", "container", ",", "nil", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "return", "&", "lo", ",", "nil", "\n", "}" ]

[ "/", "*", "Set", "the", "maximum", "number", "of", "trace", "segments", "allowed", "in", "a", "transaction", "trace", ".", "By", "default", "the", "maximum", "is", "set", "to", "2000", "which", "means", "the", "first", "2000", "segments", "in", "a", "transaction", "will", "create", "trace", "segments", "if", "the", "transaction", "exceeds", "the", "trace", "threshold", "(", "4", "x", "apdex_t", ")", "." ]

[ "func", "TransactionSetMaxTraceSegments", "(", "id", "int64", ",", "<mask>", "int", ")", "(", "int", ",", "error", ")", "{", "return", "errNo", "(", "C", ".", "newrelic_transaction_set_max_trace_segments", "(", "C", ".", "long", "(", "id", ")", ",", "C", ".", "int", "(", "max", ")", ")", ")", "\n", "}" ]

[ "Encode", "writes", "v", "to", "the", "stream", "encoding", "it", "based", "on", "the", "emitter", "configured", "on", "e", "." ]

[ "func", "(", "e", "*", "StreamEncoder", ")", "Encode", "(", "v", "interface", "{", "}", ")", "error", "{", "if", "err", ":=", "e", ".", "Open", "(", "-", "1", ")", ";", "err", "!=", "nil", "{", "return", "err", "\n", "}", "\n\n", "if", "e", ".", "<mask>", ">=", "0", "&&", "e", ".", "cnt", ">=", "e", ".", "max", "{", "return", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "e", ".", "max", ")", "\n", "}", "\n\n", "if", "!", "e", ".", "oneshot", "&&", "e", ".", "cnt", "!=", "0", "{", "e", ".", "err", "=", "e", ".", "Emitter", ".", "EmitArrayNext", "(", ")", "\n", "}", "\n\n", "if", "e", ".", "err", "==", "nil", "{", "e", ".", "err", "=", "(", "Encoder", "{", "Emitter", ":", "e", ".", "Emitter", ",", "SortMapKeys", ":", "e", ".", "SortMapKeys", ",", "}", ")", ".", "Encode", "(", "v", ")", "\n\n", "if", "e", ".", "cnt", "++", ";", "e", ".", "max", ">=", "0", "&&", "e", ".", "cnt", ">=", "e", ".", "max", "{", "e", ".", "Close", "(", ")", "\n", "}", "\n", "}", "\n\n", "return", "e", ".", "err", "\n", "}" ]

[ "DistanceForStrings", "returns", "the", "edit", "distance", "between", "source", "and", "target", ".", "It", "has", "a", "runtime", "proportional", "to", "len", "(", "source", ")", "*", "len", "(", "target", ")", "and", "memory", "use", "proportional", "to", "len", "(", "target", ")", "." ]

[ "func", "DistanceForStrings", "(", "source", "[", "]", "rune", ",", "target", "[", "]", "rune", ",", "op", "Options", ")", "int", "{", "// Note: This algorithm is a specialization of MatrixForStrings.", "// MatrixForStrings returns the full edit matrix. However, we only need a", "// single value (see DistanceForMatrix) and the main loop of the algorithm", "// only uses the current and previous row. As such we create a 2D matrix,", "// but with height 2 (enough to store current and previous row).", "height", ":=", "len", "(", "source", ")", "+", "1", "\n", "width", ":=", "len", "(", "target", ")", "+", "1", "\n", "matrix", ":=", "make", "(", "[", "]", "[", "]", "int", ",", "2", ")", "\n\n", "// Initialize trivial distances (from/to empty string). That is, fill", "// the left column and the top row with row/column indices.", "for", "i", ":=", "0", ";", "i", "<", "2", ";", "i", "++", "{", "matrix", "[", "i", "]", "=", "make", "(", "[", "]", "int", ",", "width", ")", "\n", "matrix", "[", "i", "]", "[", "0", "]", "=", "i", "\n", "}", "\n", "for", "j", ":=", "1", ";", "j", "<", "width", ";", "j", "++", "{", "matrix", "[", "0", "]", "[", "j", "]", "=", "j", "\n", "}", "\n\n", "// Fill in the remaining cells: for each prefix pair, choose the", "// (edit history, operation) pair with the lowest cost.", "for", "i", ":=", "1", ";", "i", "<", "height", ";", "i", "++", "{", "cur", ":=", "matrix", "[", "i", "%", "2", "]", "\n", "prev", ":=", "matrix", "[", "(", "i", "-", "1", ")", "%", "2", "]", "\n", "cur", "[", "0", "]", "=", "i", "\n", "for", "j", ":=", "1", ";", "j", "<", "width", ";", "j", "++", "{", "delCost", ":=", "prev", "[", "j", "]", "+", "op", ".", "DelCost", "\n", "matchSubCost", ":=", "prev", "[", "j", "-", "1", "]", "\n", "if", "!", "op", ".", "Matches", "(", "source", "[", "i", "-", "1", "]", ",", "target", "[", "j", "-", "1", "]", ")", "{", "matchSubCost", "+=", "op", ".", "SubCost", "\n", "}", "\n", "insCost", ":=", "cur", "[", "j", "-", "1", "]", "+", "op", ".", "InsCost", "\n", "cur", "[", "j", "]", "=", "<mask>", "(", "delCost", ",", "min", "(", "matchSubCost", ",", "insCost", ")", ")", "\n", "}", "\n", "}", "\n", "return", "matrix", "[", "(", "height", "-", "1", ")", "%", "2", "]", "[", "width", "-", "1", "]", "\n", "}" ]

[ "Spawn", "the", "rsync", "process" ]

[ "func", "rsyncSendSetup", "(", "path", "string", ",", "rsyncArgs", "string", ")", "(", "*", "exec", ".", "Cmd", ",", "net", ".", "Conn", ",", "io", ".", "ReadCloser", ",", "error", ")", "{", "auds", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "uuid", ".", "NewRandom", "(", ")", ".", "String", "(", ")", ")", "\n", "if", "len", "(", "auds", ")", ">", "shared", ".", "ABSTRACT_UNIX_SOCK_LEN", "-", "1", "{", "auds", "=", "auds", "[", ":", "shared", ".", "ABSTRACT_UNIX_SOCK_LEN", "-", "1", "]", "\n", "}", "\n\n", "l", ",", "err", ":=", "net", ".", "Li