id
int32 0
151
| idx
stringlengths 8
10
| nl_tokens
sequencelengths 2
286
| pl_tokens
sequencelengths 25
758
|
---|---|---|---|
0 | maxmin-1 | [
"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",
"}"
] |
1 | maxmin-2 | [
"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",
"}"
] |
2 | maxmin-3 | [
"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",
"}"
] |
3 | maxmin-4 | [
"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",
"}"
] |
4 | maxmin-5 | [
"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",
"}"
] |
5 | maxmin-6 | [
"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",
"}"
] |
6 | maxmin-7 | [
"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",
"}"
] |
7 | maxmin-8 | [
"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",
"}"
] |
8 | maxmin-9 | [
"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",
"}"
] |
9 | maxmin-10 | [
"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",
"}"
] |
10 | maxmin-11 | [
"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",
"}"
] |
11 | maxmin-12 | [
"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",
"}"
] |
12 | maxmin-13 | [
"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",
"}"
] |
13 | maxmin-14 | [
"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",
"}"
] |
14 | maxmin-15 | [
"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",
"}"
] |
15 | maxmin-16 | [
"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",
"}"
] |
16 | maxmin-17 | [
"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",
"}"
] |
17 | maxmin-18 | [
"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",
"}"
] |
18 | maxmin-19 | [
"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",
"}"
] |
19 | maxmin-20 | [
"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",
"}"
] |
20 | maxmin-21 | [
"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",
"}"
] |
21 | maxmin-22 | [
"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",
"}"
] |
22 | maxmin-23 | [
"/",
"*",
"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",
"}"
] |
23 | maxmin-24 | [
"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",
"}"
] |
24 | maxmin-25 | [
"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",
"}"
] |
25 | maxmin-26 | [
"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",
"}"
] |
26 | maxmin-27 | [
"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",
"}"
] |
27 | maxmin-28 | [
"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",
"}"
] |
28 | maxmin-29 | [
"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",
"}"
] |
29 | maxmin-30 | [
"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",
"}"
] |
30 | maxmin-31 | [
"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",
"}"
] |
31 | maxmin-32 | [
"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",
"}"
] |
32 | maxmin-33 | [
"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",
"}"
] |
33 | maxmin-34 | [
"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",
"}"
] |
34 | maxmin-35 | [
"-----------------",
"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",
"}"
] |
35 | maxmin-36 | [
"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",
"}"
] |
36 | maxmin-37 | [
"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",
"}"
] |
37 | maxmin-38 | [
"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",
"}"
] |
38 | maxmin-39 | [
"===",
"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",
"}"
] |
39 | maxmin-40 | [
"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",
"}"
] |
40 | maxmin-41 | [
"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",
"}"
] |
41 | maxmin-42 | [
"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",
"}"
] |
42 | maxmin-43 | [
"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",
"}"
] |
43 | maxmin-44 | [
"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",
"}"
] |
44 | maxmin-45 | [
"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",
"}"
] |
45 | maxmin-46 | [
"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",
"}"
] |
46 | maxmin-47 | [
"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",
"}"
] |
47 | maxmin-48 | [
"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",
"}"
] |
48 | maxmin-49 | [
"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",
"}"
] |
49 | maxmin-50 | [
"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",
"}"
] |
50 | maxmin-51 | [
"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",
"}"
] |
51 | maxmin-52 | [
"===",
"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",
"}"
] |
52 | maxmin-53 | [
"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",
"}"
] |
53 | maxmin-54 | [
"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",
"}"
] |
54 | maxmin-55 | [
"===",
"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",
"}"
] |
55 | maxmin-56 | [
"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",
"}"
] |
56 | maxmin-57 | [
"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",
"}"
] |
57 | maxmin-58 | [
"===",
"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",
"}"
] |
58 | maxmin-59 | [
"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",
"}"
] |
59 | maxmin-60 | [
"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",
"}"
] |
60 | maxmin-61 | [
"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",
"}"
] |
61 | maxmin-62 | [
"/",
"*",
"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",
"}"
] |
62 | maxmin-63 | [
"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",
"}"
] |
63 | maxmin-64 | [
"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",
"}"
] |
64 | maxmin-65 | [
"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 |