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",
".",
"Listen",
"(",
"\"",
"\"",
",",
"auds",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"execPath",
",",
"err",
":=",
"os",
".",
"Readlink",
"(",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"!",
"shared",
".",
"PathExists",
"(",
"execPath",
")",
"{",
"execPath",
"=",
"os",
".",
"Args",
"[",
"0",
"]",
"\n",
"}",
"\n\n",
"rsyncCmd",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\\\"",
"\\\"",
"\"",
",",
"execPath",
",",
"auds",
")",
"\n\n",
"args",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"}",
"\n\n",
"// Ignore deletions (requires 3.1 or higher)",
"rsyncCheckVersion",
":=",
"func",
"(",
"<mask>",
"string",
")",
"bool",
"{",
"out",
",",
"err",
":=",
"shared",
".",
"RunCommand",
"(",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"fields",
":=",
"strings",
".",
"Split",
"(",
"out",
",",
"\"",
"\"",
")",
"\n",
"curVer",
",",
"err",
":=",
"version",
".",
"Parse",
"(",
"fields",
"[",
"3",
"]",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"minVer",
",",
"err",
":=",
"version",
".",
"Parse",
"(",
"min",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"return",
"curVer",
".",
"Compare",
"(",
"minVer",
")",
">=",
"0",
"\n",
"}",
"\n\n",
"if",
"rsyncCheckVersion",
"(",
"\"",
"\"",
")",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"rsyncArgs",
"!=",
"\"",
"\"",
"{",
"args",
"=",
"append",
"(",
"args",
",",
"strings",
".",
"Split",
"(",
"rsyncArgs",
",",
"\"",
"\"",
")",
"...",
")",
"\n",
"}",
"\n\n",
"args",
"=",
"append",
"(",
"args",
",",
"[",
"]",
"string",
"{",
"path",
",",
"\"",
"\"",
"}",
"...",
")",
"\n",
"args",
"=",
"append",
"(",
"args",
",",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"rsyncCmd",
"}",
"...",
")",
"\n\n",
"cmd",
":=",
"exec",
".",
"Command",
"(",
"\"",
"\"",
",",
"args",
"...",
")",
"\n",
"cmd",
".",
"Stdout",
"=",
"os",
".",
"Stderr",
"\n\n",
"stderr",
",",
"err",
":=",
"cmd",
".",
"StderrPipe",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"cmd",
".",
"Start",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"conn",
",",
"err",
":=",
"l",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"cmd",
".",
"Process",
".",
"Kill",
"(",
")",
"\n",
"cmd",
".",
"Wait",
"(",
")",
"\n",
"return",
"nil",
",",
"nil",
",",
"nil",
",",
"err",
"\n",
"}",
"\n",
"l",
".",
"Close",
"(",
")",
"\n\n",
"return",
"cmd",
",",
"conn",
",",
"stderr",
",",
"nil",
"\n",
"}"
] |
65 | maxmin-66 | [
"match",
"recursively",
"traverses",
"the",
"provided",
"type",
"and",
"outputs",
"a",
"matcher",
"string",
"for",
"it",
"that",
"is",
"compatible",
"with",
"the",
"Pact",
"dsl",
"."
] | [
"func",
"match",
"(",
"srcType",
"reflect",
".",
"Type",
",",
"params",
"params",
")",
"Matcher",
"{",
"switch",
"kind",
":=",
"srcType",
".",
"Kind",
"(",
")",
";",
"kind",
"{",
"case",
"reflect",
".",
"Ptr",
":",
"return",
"match",
"(",
"srcType",
".",
"Elem",
"(",
")",
",",
"params",
")",
"\n",
"case",
"reflect",
".",
"Slice",
",",
"reflect",
".",
"Array",
":",
"return",
"EachLike",
"(",
"match",
"(",
"srcType",
".",
"Elem",
"(",
")",
",",
"getDefaults",
"(",
")",
")",
",",
"params",
".",
"slice",
".",
"<mask>",
")",
"\n",
"case",
"reflect",
".",
"Struct",
":",
"result",
":=",
"StructMatcher",
"{",
"}",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"srcType",
".",
"NumField",
"(",
")",
";",
"i",
"++",
"{",
"field",
":=",
"srcType",
".",
"Field",
"(",
"i",
")",
"\n",
"result",
"[",
"field",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
"]",
"=",
"match",
"(",
"field",
".",
"Type",
",",
"pluckParams",
"(",
"field",
".",
"Type",
",",
"field",
".",
"Tag",
".",
"Get",
"(",
"\"",
"\"",
")",
")",
")",
"\n",
"}",
"\n",
"return",
"result",
"\n",
"case",
"reflect",
".",
"String",
":",
"if",
"params",
".",
"str",
".",
"regEx",
"!=",
"\"",
"\"",
"{",
"return",
"Term",
"(",
"params",
".",
"str",
".",
"example",
",",
"params",
".",
"str",
".",
"regEx",
")",
"\n",
"}",
"\n",
"if",
"params",
".",
"str",
".",
"example",
"!=",
"\"",
"\"",
"{",
"return",
"Like",
"(",
"params",
".",
"str",
".",
"example",
")",
"\n",
"}",
"\n\n",
"return",
"Like",
"(",
"\"",
"\"",
")",
"\n",
"case",
"reflect",
".",
"Bool",
":",
"return",
"Like",
"(",
"true",
")",
"\n",
"case",
"reflect",
".",
"Int",
",",
"reflect",
".",
"Int8",
",",
"reflect",
".",
"Int16",
",",
"reflect",
".",
"Int32",
",",
"reflect",
".",
"Int64",
",",
"reflect",
".",
"Uint",
",",
"reflect",
".",
"Uint8",
",",
"reflect",
".",
"Uint16",
",",
"reflect",
".",
"Uint32",
",",
"reflect",
".",
"Uint64",
":",
"return",
"Like",
"(",
"1",
")",
"\n",
"case",
"reflect",
".",
"Float32",
",",
"reflect",
".",
"Float64",
":",
"return",
"Like",
"(",
"1.1",
")",
"\n",
"default",
":",
"panic",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"srcType",
")",
")",
"\n",
"}",
"\n",
"}"
] |
66 | maxmin-67 | [
"NormalizeMax",
"sets",
"the",
"max",
"value",
"to",
"1",
"and",
"normalize",
"the",
"rest",
"of",
"the",
"data",
"."
] | [
"func",
"NormalizeMax",
"(",
"buf",
"*",
"audio",
".",
"FloatBuffer",
")",
"{",
"if",
"buf",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"<mask>",
":=",
"0.0",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"buf",
".",
"Data",
")",
";",
"i",
"++",
"{",
"if",
"math",
".",
"Abs",
"(",
"buf",
".",
"Data",
"[",
"i",
"]",
")",
">",
"max",
"{",
"max",
"=",
"math",
".",
"Abs",
"(",
"buf",
".",
"Data",
"[",
"i",
"]",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"max",
"!=",
"0.0",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"buf",
".",
"Data",
")",
";",
"i",
"++",
"{",
"buf",
".",
"Data",
"[",
"i",
"]",
"/=",
"max",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
67 | maxmin-68 | [
"ParseRange",
"returns",
"a",
"new",
"range",
"object",
"and",
"nil",
"if",
"the",
"given",
"range",
"definition",
"was",
"valid",
"or",
"nil",
"and",
"an",
"error",
"if",
"it",
"was",
"invalid",
"."
] | [
"func",
"ParseRange",
"(",
"rangeStr",
"string",
")",
"(",
"*",
"Range",
",",
"error",
")",
"{",
"// Set defaults",
"t",
":=",
"&",
"Range",
"{",
"Start",
":",
"0",
",",
"End",
":",
"math",
".",
"Inf",
"(",
"1",
")",
",",
"AlertOnInside",
":",
"false",
",",
"}",
"\n",
"// Remove leading and trailing whitespace",
"rangeStr",
"=",
"strings",
".",
"Trim",
"(",
"rangeStr",
",",
"\"",
"\\n",
"\\r",
"\"",
")",
"\n\n",
"// Check for inverted semantics",
"if",
"rangeStr",
"[",
"0",
"]",
"==",
"'@'",
"{",
"t",
".",
"AlertOnInside",
"=",
"true",
"\n",
"rangeStr",
"=",
"rangeStr",
"[",
"1",
":",
"]",
"\n",
"}",
"\n\n",
"// Parse lower limit",
"endPos",
":=",
"strings",
".",
"Index",
"(",
"rangeStr",
",",
"\"",
"\"",
")",
"\n",
"if",
"endPos",
">",
"-",
"1",
"{",
"if",
"rangeStr",
"[",
"0",
"]",
"==",
"'~'",
"{",
"t",
".",
"Start",
"=",
"math",
".",
"Inf",
"(",
"-",
"1",
")",
"\n",
"}",
"else",
"{",
"<mask>",
",",
"err",
":=",
"strconv",
".",
"ParseFloat",
"(",
"rangeStr",
"[",
"0",
":",
"endPos",
"]",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"t",
".",
"Start",
"=",
"min",
"\n",
"}",
"\n",
"rangeStr",
"=",
"rangeStr",
"[",
"endPos",
"+",
"1",
":",
"]",
"\n",
"}",
"\n\n",
"// Parse upper limit",
"if",
"len",
"(",
"rangeStr",
")",
">",
"0",
"{",
"max",
",",
"err",
":=",
"strconv",
".",
"ParseFloat",
"(",
"rangeStr",
",",
"64",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"t",
".",
"End",
"=",
"max",
"\n",
"}",
"\n\n",
"if",
"t",
".",
"End",
"<",
"t",
".",
"Start",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// OK",
"return",
"t",
",",
"nil",
"\n",
"}"
] |
68 | maxmin-69 | [
"hasNextEnts",
"returns",
"if",
"there",
"is",
"any",
"available",
"entries",
"for",
"execution",
".",
"This",
"is",
"a",
"fast",
"check",
"without",
"heavy",
"raftLog",
".",
"slice",
"()",
"in",
"raftLog",
".",
"nextEnts",
"()",
"."
] | [
"func",
"(",
"l",
"*",
"raftLog",
")",
"hasNextEnts",
"(",
")",
"bool",
"{",
"off",
":=",
"<mask>",
"(",
"l",
".",
"applied",
"+",
"1",
",",
"l",
".",
"firstIndex",
"(",
")",
")",
"\n",
"return",
"l",
".",
"committed",
"+",
"1",
">",
"off",
"\n",
"}"
] |
69 | maxmin-70 | [
"Core",
"takes",
"the",
"name",
"of",
"a",
"core",
"file",
"and",
"returns",
"a",
"Process",
"that",
"represents",
"the",
"state",
"of",
"the",
"inferior",
"that",
"generated",
"the",
"core",
"file",
"."
] | [
"func",
"Core",
"(",
"coreFile",
",",
"base",
",",
"exePath",
"string",
")",
"(",
"*",
"Process",
",",
"error",
")",
"{",
"core",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"coreFile",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"p",
":=",
"&",
"Process",
"{",
"base",
":",
"base",
",",
"files",
":",
"make",
"(",
"map",
"[",
"string",
"]",
"*",
"file",
")",
"}",
"\n",
"if",
"exePath",
"!=",
"\"",
"\"",
"{",
"bin",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"exePath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"p",
".",
"exe",
"=",
"bin",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"readExec",
"(",
"p",
".",
"exe",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"readCore",
"(",
"core",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"if",
"err",
":=",
"p",
".",
"readDebugInfo",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n\n",
"// Sort then merge mappings, just to clean up a bit.",
"mappings",
":=",
"p",
".",
"memory",
".",
"mappings",
"\n",
"sort",
".",
"Slice",
"(",
"mappings",
",",
"func",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"mappings",
"[",
"i",
"]",
".",
"<mask>",
"<",
"mappings",
"[",
"j",
"]",
".",
"min",
"\n",
"}",
")",
"\n",
"ms",
":=",
"mappings",
"[",
"1",
":",
"]",
"\n",
"mappings",
"=",
"mappings",
"[",
":",
"1",
"]",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"ms",
"{",
"k",
":=",
"mappings",
"[",
"len",
"(",
"mappings",
")",
"-",
"1",
"]",
"\n",
"if",
"m",
".",
"min",
"==",
"k",
".",
"max",
"&&",
"m",
".",
"perm",
"==",
"k",
".",
"perm",
"&&",
"m",
".",
"f",
"==",
"k",
".",
"f",
"&&",
"m",
".",
"off",
"==",
"k",
".",
"off",
"+",
"k",
".",
"Size",
"(",
")",
"{",
"k",
".",
"max",
"=",
"m",
".",
"max",
"\n",
"// TODO: also check origF?",
"}",
"else",
"{",
"mappings",
"=",
"append",
"(",
"mappings",
",",
"m",
")",
"\n",
"}",
"\n",
"}",
"\n",
"p",
".",
"memory",
".",
"mappings",
"=",
"mappings",
"\n\n",
"// Memory map all the mappings.",
"hostPageSize",
":=",
"int64",
"(",
"syscall",
".",
"Getpagesize",
"(",
")",
")",
"\n",
"for",
"_",
",",
"m",
":=",
"range",
"p",
".",
"memory",
".",
"mappings",
"{",
"size",
":=",
"m",
".",
"max",
".",
"Sub",
"(",
"m",
".",
"min",
")",
"\n",
"if",
"m",
".",
"f",
"==",
"nil",
"{",
"// We don't have any source for this data.",
"// Could be a mapped file that we couldn't find.",
"// Could be a mapping madvised as MADV_DONTDUMP.",
"// Pretend this is read-as-zero.",
"// The other option is to just throw away",
"// the mapping (and thus make Read*s of this",
"// mapping fail).",
"p",
".",
"warnings",
"=",
"append",
"(",
"p",
".",
"warnings",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"min",
",",
"m",
".",
"max",
")",
")",
"\n",
"// TODO: this allocation could be large.",
"// Use mmap to avoid real backing store for all those zeros, or",
"// perhaps split the mapping up into chunks and share the zero contents among them.",
"m",
".",
"contents",
"=",
"make",
"(",
"[",
"]",
"byte",
",",
"size",
")",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"m",
".",
"perm",
"&",
"Write",
"!=",
"0",
"&&",
"m",
".",
"f",
"!=",
"core",
"{",
"p",
".",
"warnings",
"=",
"append",
"(",
"p",
".",
"warnings",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"m",
".",
"min",
",",
"m",
".",
"max",
",",
"m",
".",
"f",
".",
"Name",
"(",
")",
")",
")",
"\n",
"}",
"\n",
"// Data in core file might not be aligned enough for the host.",
"// Expand memory range so we can map full pages.",
"minOff",
":=",
"m",
".",
"off",
"\n",
"maxOff",
":=",
"m",
".",
"off",
"+",
"size",
"\n",
"minOff",
"-=",
"minOff",
"%",
"hostPageSize",
"\n",
"if",
"maxOff",
"%",
"hostPageSize",
"!=",
"0",
"{",
"maxOff",
"+=",
"hostPageSize",
"-",
"maxOff",
"%",
"hostPageSize",
"\n",
"}",
"\n\n",
"// Read data from file.",
"data",
",",
"err",
":=",
"mapFile",
"(",
"int",
"(",
"m",
".",
"f",
".",
"Fd",
"(",
")",
")",
",",
"minOff",
",",
"int",
"(",
"maxOff",
"-",
"minOff",
")",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\\n",
"\"",
",",
"m",
".",
"f",
".",
"Name",
"(",
")",
",",
"minOff",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Trim any data we mapped but don't need.",
"data",
"=",
"data",
"[",
"m",
".",
"off",
"-",
"minOff",
":",
"]",
"\n",
"data",
"=",
"data",
"[",
":",
"size",
"]",
"\n\n",
"m",
".",
"contents",
"=",
"data",
"\n",
"}",
"\n\n",
"// Build page table for mapping lookup.",
"for",
"_",
",",
"m",
":=",
"range",
"p",
".",
"memory",
".",
"mappings",
"{",
"err",
":=",
"p",
".",
"addMapping",
"(",
"m",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"p",
",",
"nil",
"\n",
"}"
] |
70 | maxmin-71 | [
"Generate",
"random",
"number",
"in",
"[",
"0",
"n",
")"
] | [
"func",
"GenerateRandomInt64",
"(",
"<mask>",
",",
"max",
"int64",
")",
"int64",
"{",
"upper",
":=",
"max",
"-",
"min",
"\n\n",
"nBig",
",",
"err",
":=",
"rand",
".",
"Int",
"(",
"rand",
".",
"Reader",
",",
"big",
".",
"NewInt",
"(",
"upper",
")",
")",
"\n\n",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"\n",
"}",
"\n\n",
"return",
"nBig",
".",
"Int64",
"(",
")",
"+",
"min",
"\n",
"}"
] |
71 | maxmin-72 | [
"compactLogs",
"takes",
"the",
"last",
"inclusive",
"index",
"of",
"a",
"snapshot",
"and",
"trims",
"the",
"logs",
"that",
"are",
"no",
"longer",
"needed",
"."
] | [
"func",
"(",
"r",
"*",
"Raft",
")",
"compactLogs",
"(",
"snapIdx",
"uint64",
")",
"error",
"{",
"defer",
"metrics",
".",
"MeasureSince",
"(",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
",",
"time",
".",
"Now",
"(",
")",
")",
"\n",
"// Determine log ranges to compact",
"minLog",
",",
"err",
":=",
"r",
".",
"logs",
".",
"FirstIndex",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n\n",
"// Check if we have enough logs to truncate",
"lastLogIdx",
",",
"_",
":=",
"r",
".",
"getLastLog",
"(",
")",
"\n",
"if",
"lastLogIdx",
"<=",
"r",
".",
"conf",
".",
"TrailingLogs",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Truncate up to the end of the snapshot, or `TrailingLogs`",
"// back from the head, which ever is further back. This ensures",
"// at least `TrailingLogs` entries, but does not allow logs",
"// after the snapshot to be removed.",
"maxLog",
":=",
"<mask>",
"(",
"snapIdx",
",",
"lastLogIdx",
"-",
"r",
".",
"conf",
".",
"TrailingLogs",
")",
"\n\n",
"// Log this",
"r",
".",
"logger",
".",
"Info",
"(",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"minLog",
",",
"maxLog",
")",
")",
"\n\n",
"// Compact the logs",
"if",
"err",
":=",
"r",
".",
"logs",
".",
"DeleteRange",
"(",
"minLog",
",",
"maxLog",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"return",
"nil",
"\n",
"}"
] |
72 | maxmin-73 | [
"Generate",
"random",
"number",
"in",
"[",
"0",
"n",
")"
] | [
"func",
"GenerateRandomInt",
"(",
"<mask>",
",",
"max",
"int",
")",
"int",
"{",
"return",
"int",
"(",
"GenerateRandomInt64",
"(",
"int64",
"(",
"min",
")",
",",
"int64",
"(",
"max",
")",
")",
")",
"\n",
"}"
] |
73 | maxmin-74 | [
"CreateRandom",
"returns",
"a",
"random",
"byte",
"string",
"of",
"given",
"length",
"from",
"given",
"byte",
"string"
] | [
"func",
"CreateRandom",
"(",
"bs",
"[",
"]",
"byte",
",",
"length",
"int",
")",
"[",
"]",
"byte",
"{",
"filled",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"length",
")",
"\n",
"<mask>",
":=",
"len",
"(",
"bs",
")",
"\n\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"length",
";",
"i",
"++",
"{",
"Shuffle",
"(",
"bs",
")",
"\n",
"filled",
"[",
"i",
"]",
"=",
"bs",
"[",
"random",
"(",
"0",
",",
"max",
")",
"]",
"\n",
"}",
"\n\n",
"return",
"filled",
"\n",
"}"
] |
74 | maxmin-75 | [
"Decodes",
"the",
"next",
"value",
"from",
"the",
"stream",
"into",
"v",
"."
] | [
"func",
"(",
"d",
"*",
"StreamDecoder",
")",
"Decode",
"(",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"if",
"d",
".",
"err",
"!=",
"nil",
"{",
"return",
"d",
".",
"err",
"\n",
"}",
"\n\n",
"err",
":=",
"error",
"(",
"nil",
")",
"\n",
"cnt",
":=",
"d",
".",
"cnt",
"\n",
"<mask>",
":=",
"d",
".",
"max",
"\n",
"dec",
":=",
"Decoder",
"{",
"Parser",
":",
"d",
".",
"Parser",
",",
"MapType",
":",
"d",
".",
"MapType",
",",
"}",
"\n\n",
"switch",
"d",
".",
"typ",
"{",
"case",
"Unknown",
":",
"err",
"=",
"d",
".",
"init",
"(",
")",
"\n",
"max",
"=",
"d",
".",
"max",
"\n",
"case",
"Array",
":",
"if",
"cnt",
"==",
"max",
"{",
"err",
"=",
"dec",
".",
"Parser",
".",
"ParseArrayEnd",
"(",
"cnt",
")",
"\n",
"}",
"else",
"if",
"cnt",
"!=",
"0",
"{",
"err",
"=",
"dec",
".",
"Parser",
".",
"ParseArrayNext",
"(",
"cnt",
")",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"err",
"==",
"nil",
"{",
"if",
"cnt",
"==",
"max",
"{",
"err",
"=",
"End",
"\n",
"}",
"else",
"{",
"switch",
"err",
"=",
"dec",
".",
"Decode",
"(",
"v",
")",
";",
"err",
"{",
"case",
"nil",
":",
"cnt",
"++",
"\n",
"case",
"End",
":",
"cnt",
"++",
"\n",
"max",
"=",
"cnt",
"\n",
"default",
":",
"if",
"max",
"<",
"0",
"&&",
"dec",
".",
"Parser",
".",
"ParseArrayEnd",
"(",
"cnt",
")",
"==",
"nil",
"{",
"err",
"=",
"End",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"d",
".",
"err",
"=",
"err",
"\n",
"d",
".",
"cnt",
"=",
"cnt",
"\n",
"d",
".",
"max",
"=",
"max",
"\n",
"return",
"err",
"\n",
"}"
] |
75 | maxmin-76 | [
"Len",
"returns",
"the",
"number",
"of",
"values",
"remaining",
"to",
"be",
"read",
"from",
"the",
"stream",
"which",
"may",
"be",
"-",
"1",
"if",
"the",
"underlying",
"format",
"doesn",
"t",
"provide",
"this",
"information",
".",
"If",
"an",
"error",
"occurred",
"while",
"decoding",
"the",
"stream",
"the",
"method",
"returns",
"zero",
"because",
"no",
"more",
"values",
"can",
"be",
"read",
"."
] | [
"func",
"(",
"d",
"*",
"StreamDecoder",
")",
"Len",
"(",
")",
"int",
"{",
"if",
"d",
".",
"err",
"!=",
"nil",
"{",
"return",
"0",
"\n",
"}",
"\n\n",
"if",
"d",
".",
"typ",
"==",
"Unknown",
"{",
"if",
"d",
".",
"init",
"(",
")",
"!=",
"nil",
"{",
"return",
"0",
"\n",
"}",
"\n",
"}",
"\n\n",
"return",
"d",
".",
"<mask>",
"-",
"d",
".",
"cnt",
"\n",
"}"
] |
76 | maxmin-77 | [
"slice",
"returns",
"a",
"slice",
"of",
"log",
"entries",
"from",
"lo",
"through",
"hi",
"-",
"1",
"inclusive",
"."
] | [
"func",
"(",
"l",
"*",
"raftLog",
")",
"slice",
"(",
"lo",
",",
"hi",
",",
"maxSize",
"uint64",
")",
"(",
"[",
"]",
"pb",
".",
"Entry",
",",
"error",
")",
"{",
"err",
":=",
"l",
".",
"mustCheckOutOfBounds",
"(",
"lo",
",",
"hi",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"if",
"lo",
"==",
"hi",
"{",
"return",
"nil",
",",
"nil",
"\n",
"}",
"\n",
"var",
"ents",
"[",
"]",
"pb",
".",
"Entry",
"\n",
"if",
"lo",
"<",
"l",
".",
"unstable",
".",
"offset",
"{",
"storedEnts",
",",
"err",
":=",
"l",
".",
"storage",
".",
"Entries",
"(",
"lo",
",",
"<mask>",
"(",
"hi",
",",
"l",
".",
"unstable",
".",
"offset",
")",
",",
"maxSize",
")",
"\n",
"if",
"err",
"==",
"ErrCompacted",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"else",
"if",
"err",
"==",
"ErrUnavailable",
"{",
"l",
".",
"logger",
".",
"Panicf",
"(",
"\"",
"\"",
",",
"lo",
",",
"min",
"(",
"hi",
",",
"l",
".",
"unstable",
".",
"offset",
")",
")",
"\n",
"}",
"else",
"if",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"err",
")",
"// TODO(bdarnell)",
"\n",
"}",
"\n\n",
"// check if ents has reached the size limitation",
"if",
"uint64",
"(",
"len",
"(",
"storedEnts",
")",
")",
"<",
"min",
"(",
"hi",
",",
"l",
".",
"unstable",
".",
"offset",
")",
"-",
"lo",
"{",
"return",
"storedEnts",
",",
"nil",
"\n",
"}",
"\n\n",
"ents",
"=",
"storedEnts",
"\n",
"}",
"\n",
"if",
"hi",
">",
"l",
".",
"unstable",
".",
"offset",
"{",
"unstable",
":=",
"l",
".",
"unstable",
".",
"slice",
"(",
"max",
"(",
"lo",
",",
"l",
".",
"unstable",
".",
"offset",
")",
",",
"hi",
")",
"\n",
"if",
"len",
"(",
"ents",
")",
">",
"0",
"{",
"combined",
":=",
"make",
"(",
"[",
"]",
"pb",
".",
"Entry",
",",
"len",
"(",
"ents",
")",
"+",
"len",
"(",
"unstable",
")",
")",
"\n",
"n",
":=",
"copy",
"(",
"combined",
",",
"ents",
")",
"\n",
"copy",
"(",
"combined",
"[",
"n",
":",
"]",
",",
"unstable",
")",
"\n",
"ents",
"=",
"combined",
"\n",
"}",
"else",
"{",
"ents",
"=",
"unstable",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"limitSize",
"(",
"ents",
",",
"maxSize",
")",
",",
"nil",
"\n",
"}"
] |
77 | maxmin-78 | [
"Generate",
"-",
"used",
"to",
"generate",
"a",
"struct",
"for",
"a",
"given",
"job"
] | [
"func",
"Generate",
"(",
"packagename",
"string",
",",
"fileBytes",
"[",
"]",
"byte",
",",
"outputDir",
"string",
")",
"{",
"b",
":=",
"preprocessJobManifest",
"(",
"fileBytes",
")",
"\n",
"objects",
":=",
"make",
"(",
"map",
"[",
"string",
"]",
"map",
"[",
"string",
"]",
"ObjectField",
")",
"\n",
"var",
"properties",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"b",
".",
"recs",
"{",
"properties",
"=",
"append",
"(",
"properties",
",",
"v",
".",
"Orig",
")",
"\n",
"}",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"b",
".",
"<mask>",
";",
"i",
"++",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"b",
".",
"recs",
"{",
"if",
"v",
".",
"Length",
"-",
"1",
">=",
"i",
"{",
"var",
"structname",
"=",
"v",
".",
"StructName",
"(",
"i",
",",
"packagename",
",",
"properties",
")",
"\n",
"var",
"typeName",
"=",
"v",
".",
"TypeName",
"(",
"i",
",",
"properties",
")",
"\n",
"elementName",
":=",
"v",
".",
"Slice",
"[",
"i",
"]",
"\n",
"attributeName",
":=",
"FormatName",
"(",
"elementName",
")",
"\n\n",
"if",
"_",
",",
"ok",
":=",
"objects",
"[",
"structname",
"]",
";",
"!",
"ok",
"{",
"objects",
"[",
"structname",
"]",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"ObjectField",
")",
"\n",
"}",
"\n\n",
"if",
"previousElement",
",",
"ok",
":=",
"objects",
"[",
"structname",
"]",
"[",
"attributeName",
"]",
";",
"!",
"ok",
"{",
"lo",
".",
"G",
".",
"Debug",
"(",
"\"",
"\"",
",",
"attributeName",
",",
"\"",
"\"",
",",
"structname",
",",
"\"",
"\"",
",",
"typeName",
")",
"\n",
"objects",
"[",
"structname",
"]",
"[",
"attributeName",
"]",
"=",
"ObjectField",
"{",
"ElementName",
":",
"attributeName",
",",
"ElementType",
":",
"typeName",
",",
"ElementAnnotation",
":",
"createElementAnnotation",
"(",
"elementName",
")",
",",
"Meta",
":",
"v",
".",
"Yaml",
",",
"}",
"\n",
"}",
"else",
"{",
"if",
"previousElement",
".",
"ElementAnnotation",
"!=",
"createElementAnnotation",
"(",
"elementName",
")",
"{",
"lo",
".",
"G",
".",
"Warning",
"(",
"\"",
"\"",
",",
"structname",
",",
"\"",
"\"",
",",
"attributeName",
",",
"\"",
"\"",
")",
"\n",
"previousElement",
".",
"ElementAnnotation",
"=",
"\"",
"\\\"",
"\\\"",
"\"",
"\n",
"objects",
"[",
"structname",
"]",
"[",
"attributeName",
"]",
"=",
"previousElement",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"structs",
":=",
"generateStructs",
"(",
"objects",
",",
"packagename",
")",
"\n",
"writeStructsToDisk",
"(",
"structs",
",",
"outputDir",
")",
"\n",
"}"
] |
78 | maxmin-79 | [
"printHistogram",
"prints",
"the",
"histogram",
"data",
"in",
"a",
"human",
"-",
"readable",
"format",
"."
] | [
"func",
"(",
"histogram",
"histogramData",
")",
"printHistogram",
"(",
")",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"histogram",
".",
"totalCount",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"histogram",
".",
"<mask>",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"histogram",
".",
"max",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"float64",
"(",
"histogram",
".",
"sum",
")",
"/",
"float64",
"(",
"histogram",
".",
"totalCount",
")",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
")",
"\n\n",
"numBins",
":=",
"len",
"(",
"histogram",
".",
"bins",
")",
"\n",
"for",
"index",
",",
"count",
":=",
"range",
"histogram",
".",
"countPerBin",
"{",
"if",
"count",
"==",
"0",
"{",
"continue",
"\n",
"}",
"\n\n",
"// The last bin represents the bin that contains the range from",
"// the last bin up to infinity so it's processed differently than the",
"// other bins.",
"if",
"index",
"==",
"len",
"(",
"histogram",
".",
"countPerBin",
")",
"-",
"1",
"{",
"lowerBound",
":=",
"int",
"(",
"histogram",
".",
"bins",
"[",
"numBins",
"-",
"1",
"]",
")",
"\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"lowerBound",
",",
"\"",
"\"",
",",
"count",
")",
"\n",
"continue",
"\n",
"}",
"\n\n",
"upperBound",
":=",
"int",
"(",
"histogram",
".",
"bins",
"[",
"index",
"]",
")",
"\n",
"lowerBound",
":=",
"0",
"\n",
"if",
"index",
">",
"0",
"{",
"lowerBound",
"=",
"int",
"(",
"histogram",
".",
"bins",
"[",
"index",
"-",
"1",
"]",
")",
"\n",
"}",
"\n\n",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\"",
",",
"lowerBound",
",",
"upperBound",
",",
"count",
")",
"\n",
"}",
"\n",
"fmt",
".",
"Println",
"(",
")",
"\n",
"}"
] |
79 | maxmin-80 | [
"parseDosTime",
"converts",
"a",
"32bit",
"DOS",
"time",
"value",
"to",
"time",
".",
"Time"
] | [
"func",
"parseDosTime",
"(",
"t",
"uint32",
")",
"time",
".",
"Time",
"{",
"n",
":=",
"int",
"(",
"t",
")",
"\n",
"sec",
":=",
"n",
"&",
"0x1f",
"<<",
"1",
"\n",
"<mask>",
":=",
"n",
">>",
"5",
"&",
"0x3f",
"\n",
"hr",
":=",
"n",
">>",
"11",
"&",
"0x1f",
"\n",
"day",
":=",
"n",
">>",
"16",
"&",
"0x1f",
"\n",
"mon",
":=",
"time",
".",
"Month",
"(",
"n",
">>",
"21",
"&",
"0x0f",
")",
"\n",
"yr",
":=",
"n",
">>",
"25",
"&",
"0x7f",
"+",
"1980",
"\n",
"return",
"time",
".",
"Date",
"(",
"yr",
",",
"mon",
",",
"day",
",",
"hr",
",",
"min",
",",
"sec",
",",
"0",
",",
"time",
".",
"Local",
")",
"\n",
"}"
] |
80 | maxmin-81 | [
"String",
"returns",
"the",
"string",
"representation",
"of",
"a",
"PerfDatum",
"suitable",
"for",
"check",
"output",
"."
] | [
"func",
"(",
"p",
"PerfDatum",
")",
"String",
"(",
")",
"string",
"{",
"val",
":=",
"fmtPerfFloat",
"(",
"p",
".",
"value",
")",
"\n",
"value",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"label",
",",
"val",
",",
"p",
".",
"unit",
")",
"\n",
"value",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"fmtThreshold",
"(",
"p",
".",
"warn",
")",
",",
"fmtThreshold",
"(",
"p",
".",
"crit",
")",
")",
"\n",
"value",
"+=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"fmtThreshold",
"(",
"p",
".",
"<mask>",
")",
",",
"fmtThreshold",
"(",
"p",
".",
"max",
")",
")",
"\n",
"return",
"value",
"\n",
"}"
] |
81 | maxmin-82 | [
"AskInt",
"asks",
"the",
"user",
"to",
"enter",
"an",
"integer",
"between",
"a",
"min",
"and",
"max",
"value"
] | [
"func",
"AskInt",
"(",
"question",
"string",
",",
"<mask>",
"int64",
",",
"max",
"int64",
",",
"defaultAnswer",
"string",
")",
"int64",
"{",
"for",
"{",
"answer",
":=",
"askQuestion",
"(",
"question",
",",
"defaultAnswer",
")",
"\n\n",
"result",
",",
"err",
":=",
"strconv",
".",
"ParseInt",
"(",
"answer",
",",
"10",
",",
"64",
")",
"\n\n",
"if",
"err",
"==",
"nil",
"&&",
"(",
"min",
"==",
"-",
"1",
"||",
"result",
">=",
"min",
")",
"&&",
"(",
"max",
"==",
"-",
"1",
"||",
"result",
"<=",
"max",
")",
"{",
"return",
"result",
"\n",
"}",
"\n\n",
"invalidInput",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
82 | maxmin-83 | [
"fetchLoop",
"is",
"run",
"in",
"a",
"goroutine"
] | [
"func",
"(",
"mp",
"*",
"master",
")",
"fetchLoop",
"(",
")",
"{",
"<mask>",
":=",
"mp",
".",
"Config",
".",
"MinFetchInterval",
"\n",
"time",
".",
"Sleep",
"(",
"min",
")",
"\n",
"for",
"{",
"t0",
":=",
"time",
".",
"Now",
"(",
")",
"\n",
"mp",
".",
"fetch",
"(",
")",
"\n",
"//duration fetch of fetch",
"diff",
":=",
"time",
".",
"Now",
"(",
")",
".",
"Sub",
"(",
"t0",
")",
"\n",
"if",
"diff",
"<",
"min",
"{",
"delay",
":=",
"min",
"-",
"diff",
"\n",
"//ensures at least MinFetchInterval delay.",
"//should be throttled by the fetcher!",
"time",
".",
"Sleep",
"(",
"delay",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
83 | maxmin-84 | [
"TODO",
"needs",
"test",
"since",
"it",
"is",
"not",
"quiet",
"right"
] | [
"func",
"getPrec",
"(",
"num",
"float64",
",",
"better",
"bool",
")",
"int",
"{",
"<mask>",
":=",
"3",
"\n",
"eps",
":=",
"0.0005",
"\n",
"if",
"better",
"{",
"max",
"=",
"6",
"\n",
"eps",
"=",
"0.0000005",
"\n",
"}",
"\n",
"prec",
":=",
"0",
"\n",
"for",
"math",
".",
"Mod",
"(",
"num",
",",
"1",
")",
">",
"eps",
"{",
"num",
"*=",
"10",
"\n",
"eps",
"*=",
"10",
"\n",
"prec",
"++",
"\n",
"}",
"\n\n",
"if",
"max",
"<",
"prec",
"{",
"return",
"max",
"\n",
"}",
"\n",
"return",
"prec",
"\n",
"}"
] |
84 | maxmin-85 | [
"Quantize",
"quantizes",
"the",
"audio",
"signal",
"to",
"match",
"the",
"target",
"bitDepth"
] | [
"func",
"Quantize",
"(",
"buf",
"*",
"audio",
".",
"FloatBuffer",
",",
"bitDepth",
"int",
")",
"{",
"if",
"buf",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"<mask>",
":=",
"math",
".",
"Pow",
"(",
"2",
",",
"float64",
"(",
"bitDepth",
")",
")",
"-",
"1",
"\n\n",
"bufLen",
":=",
"len",
"(",
"buf",
".",
"Data",
")",
"\n",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"bufLen",
";",
"i",
"++",
"{",
"buf",
".",
"Data",
"[",
"i",
"]",
"=",
"round",
"(",
"(",
"buf",
".",
"Data",
"[",
"i",
"]",
"+",
"1",
")",
"*",
"max",
")",
"/",
"max",
"-",
"1.0",
"\n",
"}",
"\n",
"}"
] |
85 | maxmin-86 | [
"CleanUrl",
"check",
"the",
"characteres",
"in",
"url",
"and",
"parser",
"it",
"with",
"url",
".",
"Parse",
".",
"If",
"url",
"is",
"ok",
"return",
"one",
"string",
"with",
"it",
"or",
"if",
"the",
"scheme",
"is",
"missing",
"return",
"the",
"url",
"and",
"an",
"error",
"."
] | [
"func",
"CleanUrl",
"(",
"rawurl",
"string",
",",
"<mask>",
",",
"max",
"int",
")",
"(",
"string",
",",
"error",
")",
"{",
"err",
":=",
"CheckUrl",
"(",
"rawurl",
",",
"min",
",",
"max",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"e",
".",
"Forward",
"(",
"err",
")",
"\n",
"}",
"\n",
"u",
",",
"err",
":=",
"url",
".",
"Parse",
"(",
"rawurl",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"\"",
"\"",
",",
"e",
".",
"Push",
"(",
"e",
".",
"New",
"(",
"ErrInvUrl",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"if",
"u",
".",
"Scheme",
"==",
"\"",
"\"",
"{",
"return",
"u",
".",
"String",
"(",
")",
",",
"e",
".",
"New",
"(",
"ErrNoScheme",
")",
"\n",
"}",
"\n",
"return",
"u",
".",
"String",
"(",
")",
",",
"nil",
"\n",
"}"
] |
86 | maxmin-87 | [
"unaryClientInterceptor",
"returns",
"a",
"new",
"retrying",
"unary",
"client",
"interceptor",
".",
"The",
"default",
"configuration",
"of",
"the",
"interceptor",
"is",
"to",
"not",
"retry",
"*",
"at",
"all",
"*",
".",
"This",
"behaviour",
"can",
"be",
"changed",
"through",
"options",
"(",
"e",
".",
"g",
".",
"WithMax",
")",
"on",
"creation",
"of",
"the",
"interceptor",
"or",
"on",
"call",
"(",
"through",
"grpc",
".",
"CallOptions",
")",
"."
] | [
"func",
"(",
"c",
"*",
"Client",
")",
"unaryClientInterceptor",
"(",
"logger",
"*",
"zap",
".",
"Logger",
",",
"optFuncs",
"...",
"retryOption",
")",
"grpc",
".",
"UnaryClientInterceptor",
"{",
"intOpts",
":=",
"reuseOrNewWithCallOptions",
"(",
"defaultOptions",
",",
"optFuncs",
")",
"\n",
"return",
"func",
"(",
"ctx",
"context",
".",
"Context",
",",
"method",
"string",
",",
"req",
",",
"reply",
"interface",
"{",
"}",
",",
"cc",
"*",
"grpc",
".",
"ClientConn",
",",
"invoker",
"grpc",
".",
"UnaryInvoker",
",",
"opts",
"...",
"grpc",
".",
"CallOption",
")",
"error",
"{",
"grpcOpts",
",",
"retryOpts",
":=",
"filterCallOptions",
"(",
"opts",
")",
"\n",
"callOpts",
":=",
"reuseOrNewWithCallOptions",
"(",
"intOpts",
",",
"retryOpts",
")",
"\n",
"// short circuit for simplicity, and avoiding allocations.",
"if",
"callOpts",
".",
"<mask>",
"==",
"0",
"{",
"return",
"invoker",
"(",
"ctx",
",",
"method",
",",
"req",
",",
"reply",
",",
"cc",
",",
"grpcOpts",
"...",
")",
"\n",
"}",
"\n",
"var",
"lastErr",
"error",
"\n",
"for",
"attempt",
":=",
"uint",
"(",
"0",
")",
";",
"attempt",
"<",
"callOpts",
".",
"max",
";",
"attempt",
"++",
"{",
"if",
"err",
":=",
"waitRetryBackoff",
"(",
"ctx",
",",
"attempt",
",",
"callOpts",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n",
"logger",
".",
"Debug",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"cc",
".",
"Target",
"(",
")",
")",
",",
"zap",
".",
"Uint",
"(",
"\"",
"\"",
",",
"attempt",
")",
",",
")",
"\n",
"lastErr",
"=",
"invoker",
"(",
"ctx",
",",
"method",
",",
"req",
",",
"reply",
",",
"cc",
",",
"grpcOpts",
"...",
")",
"\n",
"if",
"lastErr",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"cc",
".",
"Target",
"(",
")",
")",
",",
"zap",
".",
"Uint",
"(",
"\"",
"\"",
",",
"attempt",
")",
",",
"zap",
".",
"Error",
"(",
"lastErr",
")",
",",
")",
"\n",
"if",
"isContextError",
"(",
"lastErr",
")",
"{",
"if",
"ctx",
".",
"Err",
"(",
")",
"!=",
"nil",
"{",
"// its the context deadline or cancellation.",
"return",
"lastErr",
"\n",
"}",
"\n",
"// its the callCtx deadline or cancellation, in which case try again.",
"continue",
"\n",
"}",
"\n",
"if",
"callOpts",
".",
"retryAuth",
"&&",
"rpctypes",
".",
"Error",
"(",
"lastErr",
")",
"==",
"rpctypes",
".",
"ErrInvalidAuthToken",
"{",
"gterr",
":=",
"c",
".",
"getToken",
"(",
"ctx",
")",
"\n",
"if",
"gterr",
"!=",
"nil",
"{",
"logger",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"cc",
".",
"Target",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"gterr",
")",
",",
")",
"\n",
"return",
"lastErr",
"// return the original error for simplicity",
"\n",
"}",
"\n",
"continue",
"\n",
"}",
"\n",
"if",
"!",
"isSafeRetry",
"(",
"c",
".",
"lg",
",",
"lastErr",
",",
"callOpts",
")",
"{",
"return",
"lastErr",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"lastErr",
"\n",
"}",
"\n",
"}"
] |
87 | maxmin-88 | [
"RunBoundedArgs",
"wraps",
"a",
"function",
"in",
"a",
"function",
"that",
"checks",
"its",
"argument",
"count",
"is",
"within",
"a",
"range",
"."
] | [
"func",
"RunBoundedArgs",
"(",
"<mask>",
"int",
",",
"max",
"int",
",",
"run",
"func",
"(",
"[",
"]",
"string",
")",
"error",
")",
"func",
"(",
"*",
"cobra",
".",
"Command",
",",
"[",
"]",
"string",
")",
"{",
"return",
"func",
"(",
"cmd",
"*",
"cobra",
".",
"Command",
",",
"args",
"[",
"]",
"string",
")",
"{",
"if",
"len",
"(",
"args",
")",
"<",
"min",
"||",
"len",
"(",
"args",
")",
">",
"max",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\\n",
"\\n",
"\"",
",",
"min",
",",
"max",
",",
"len",
"(",
"args",
")",
")",
"\n",
"cmd",
".",
"Usage",
"(",
")",
"\n",
"}",
"else",
"{",
"if",
"err",
":=",
"run",
"(",
"args",
")",
";",
"err",
"!=",
"nil",
"{",
"ErrorAndExit",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}"
] |
88 | maxmin-89 | [
"canExecuteConcurrently",
"checks",
"whether",
"the",
"provided",
"ProwJob",
"can",
"be",
"executed",
"concurrently",
"."
] | [
"func",
"(",
"c",
"*",
"Controller",
")",
"canExecuteConcurrently",
"(",
"pj",
"*",
"prowapi",
".",
"ProwJob",
")",
"bool",
"{",
"c",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"c",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"<mask>",
":=",
"c",
".",
"config",
"(",
")",
".",
"MaxConcurrency",
";",
"max",
">",
"0",
"{",
"var",
"running",
"int",
"\n",
"for",
"_",
",",
"num",
":=",
"range",
"c",
".",
"pendingJobs",
"{",
"running",
"+=",
"num",
"\n",
"}",
"\n",
"if",
"running",
">=",
"max",
"{",
"c",
".",
"log",
".",
"WithFields",
"(",
"pjutil",
".",
"ProwJobFields",
"(",
"pj",
")",
")",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"running",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"}",
"\n\n",
"if",
"pj",
".",
"Spec",
".",
"MaxConcurrency",
"==",
"0",
"{",
"c",
".",
"pendingJobs",
"[",
"pj",
".",
"Spec",
".",
"Job",
"]",
"++",
"\n",
"return",
"true",
"\n",
"}",
"\n\n",
"numPending",
":=",
"c",
".",
"pendingJobs",
"[",
"pj",
".",
"Spec",
".",
"Job",
"]",
"\n",
"if",
"numPending",
">=",
"pj",
".",
"Spec",
".",
"MaxConcurrency",
"{",
"c",
".",
"log",
".",
"WithFields",
"(",
"pjutil",
".",
"ProwJobFields",
"(",
"pj",
")",
")",
".",
"Debugf",
"(",
"\"",
"\"",
",",
"pj",
".",
"Spec",
".",
"Job",
",",
"numPending",
")",
"\n",
"return",
"false",
"\n",
"}",
"\n",
"c",
".",
"pendingJobs",
"[",
"pj",
".",
"Spec",
".",
"Job",
"]",
"++",
"\n",
"return",
"true",
"\n",
"}"
] |
89 | maxmin-90 | [
"CheckInt64Bounds",
"verifies",
"that",
"v",
"is",
"within",
"min",
"and",
"max",
"t",
"represents",
"the",
"original",
"type",
"of",
"v",
"."
] | [
"func",
"CheckInt64Bounds",
"(",
"v",
"int64",
",",
"<mask>",
"int64",
",",
"max",
"uint64",
",",
"t",
"reflect",
".",
"Type",
")",
"(",
"err",
"error",
")",
"{",
"if",
"v",
"<",
"min",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
",",
"min",
",",
"t",
")",
"\n",
"}",
"\n",
"if",
"v",
">",
"0",
"&&",
"uint64",
"(",
"v",
")",
">",
"max",
"{",
"err",
"=",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"v",
",",
"max",
",",
"t",
")",
"\n",
"}",
"\n",
"return",
"\n",
"}"
] |
90 | maxmin-91 | [
"projects",
"returns",
"the",
"list",
"of",
"accessible",
"gcp",
"projects"
] | [
"func",
"projects",
"(",
"<mask>",
"int",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"out",
",",
"err",
":=",
"output",
"(",
"\"",
"\"",
",",
"\"",
"\"",
",",
"\"",
"\"",
",",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"max",
")",
",",
"\"",
"\"",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"err",
"\n",
"}",
"\n",
"return",
"strings",
".",
"Split",
"(",
"out",
",",
"\"",
"\\n",
"\"",
")",
",",
"nil",
"\n",
"}"
] |
91 | maxmin-92 | [
"backoff",
"computes",
"a",
"random",
"exponential",
"backoff",
"value",
"for",
"a",
"given",
"number",
"of",
"attempts",
"and",
"boundaries",
"of",
"min",
"and",
"max",
"backoff",
"durations",
"."
] | [
"func",
"backoff",
"(",
"rand",
"*",
"rand",
".",
"Rand",
",",
"attempt",
"int",
",",
"<mask>",
",",
"max",
"time",
".",
"Duration",
")",
"time",
".",
"Duration",
"{",
"if",
"attempt",
"<=",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"if",
"min",
">",
"max",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Hardcoded backoff coefficient, maybe we'll make it configuration in the",
"// future?",
"const",
"coeff",
"=",
"2.0",
"\n",
"return",
"jitteredBackoff",
"(",
"rand",
",",
"attempt",
",",
"min",
",",
"max",
",",
"coeff",
")",
"\n",
"}"
] |
92 | maxmin-93 | [
"assumes",
"a",
"to",
"be",
"sorted",
"in",
"descending",
"order",
"returns",
"a",
"subslice",
"of",
"a",
"along",
"with",
"its",
"indices",
"(",
"inclusive",
")"
] | [
"func",
"cropResults",
"(",
"a",
"[",
"]",
"int64",
",",
"<mask>",
"int64",
")",
"(",
"[",
"]",
"int64",
",",
"int",
",",
"int",
")",
"{",
"res",
":=",
"[",
"]",
"int64",
"{",
"}",
"\n",
"firstIndex",
":=",
"-",
"1",
"\n",
"lastIndex",
":=",
"0",
"\n",
"for",
"i",
",",
"v",
":=",
"range",
"a",
"{",
"if",
"v",
"<=",
"max",
"{",
"res",
"=",
"append",
"(",
"res",
",",
"v",
")",
"\n",
"if",
"firstIndex",
"==",
"-",
"1",
"{",
"firstIndex",
"=",
"i",
"\n",
"}",
"\n",
"lastIndex",
"=",
"i",
"\n",
"if",
"len",
"(",
"res",
")",
">=",
"resultsPerPage",
"{",
"break",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"return",
"res",
",",
"firstIndex",
",",
"lastIndex",
"\n",
"}"
] |
93 | maxmin-94 | [
"sendHeartbeat",
"sends",
"a",
"heartbeat",
"RPC",
"to",
"the",
"given",
"peer",
"."
] | [
"func",
"(",
"r",
"*",
"raft",
")",
"sendHeartbeat",
"(",
"to",
"uint64",
",",
"ctx",
"[",
"]",
"byte",
")",
"{",
"// Attach the commit as min(to.matched, r.committed).",
"// When the leader sends out heartbeat message,",
"// the receiver(follower) might not be matched with the leader",
"// or it might not have all the committed entries.",
"// The leader MUST NOT forward the follower's commit to",
"// an unmatched index.",
"commit",
":=",
"<mask>",
"(",
"r",
".",
"getProgress",
"(",
"to",
")",
".",
"Match",
",",
"r",
".",
"raftLog",
".",
"committed",
")",
"\n",
"m",
":=",
"pb",
".",
"Message",
"{",
"To",
":",
"to",
",",
"Type",
":",
"pb",
".",
"MsgHeartbeat",
",",
"Commit",
":",
"commit",
",",
"Context",
":",
"ctx",
",",
"}",
"\n\n",
"r",
".",
"send",
"(",
"m",
")",
"\n",
"}"
] |
94 | maxmin-95 | [
"purgeFile",
"is",
"the",
"internal",
"implementation",
"for",
"PurgeFile",
"which",
"can",
"post",
"purged",
"files",
"to",
"purgec",
"if",
"non",
"-",
"nil",
"."
] | [
"func",
"purgeFile",
"(",
"lg",
"*",
"zap",
".",
"Logger",
",",
"dirname",
"string",
",",
"suffix",
"string",
",",
"<mask>",
"uint",
",",
"interval",
"time",
".",
"Duration",
",",
"stop",
"<-",
"chan",
"struct",
"{",
"}",
",",
"purgec",
"chan",
"<-",
"string",
")",
"<-",
"chan",
"error",
"{",
"errC",
":=",
"make",
"(",
"chan",
"error",
",",
"1",
")",
"\n",
"go",
"func",
"(",
")",
"{",
"for",
"{",
"fnames",
",",
"err",
":=",
"ReadDir",
"(",
"dirname",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"errC",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"newfnames",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
")",
"\n",
"for",
"_",
",",
"fname",
":=",
"range",
"fnames",
"{",
"if",
"strings",
".",
"HasSuffix",
"(",
"fname",
",",
"suffix",
")",
"{",
"newfnames",
"=",
"append",
"(",
"newfnames",
",",
"fname",
")",
"\n",
"}",
"\n",
"}",
"\n",
"sort",
".",
"Strings",
"(",
"newfnames",
")",
"\n",
"fnames",
"=",
"newfnames",
"\n",
"for",
"len",
"(",
"newfnames",
")",
">",
"int",
"(",
"max",
")",
"{",
"f",
":=",
"filepath",
".",
"Join",
"(",
"dirname",
",",
"newfnames",
"[",
"0",
"]",
")",
"\n",
"l",
",",
"err",
":=",
"TryLockFile",
"(",
"f",
",",
"os",
".",
"O_WRONLY",
",",
"PrivateFileMode",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"break",
"\n",
"}",
"\n",
"if",
"err",
"=",
"os",
".",
"Remove",
"(",
"f",
")",
";",
"err",
"!=",
"nil",
"{",
"errC",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"err",
"=",
"l",
".",
"Close",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Warn",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"l",
".",
"Name",
"(",
")",
")",
",",
"zap",
".",
"Error",
"(",
"err",
")",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Errorf",
"(",
"\"",
"\"",
",",
"l",
".",
"Name",
"(",
")",
",",
"err",
")",
"\n",
"}",
"\n",
"errC",
"<-",
"err",
"\n",
"return",
"\n",
"}",
"\n",
"if",
"lg",
"!=",
"nil",
"{",
"lg",
".",
"Info",
"(",
"\"",
"\"",
",",
"zap",
".",
"String",
"(",
"\"",
"\"",
",",
"f",
")",
")",
"\n",
"}",
"else",
"{",
"plog",
".",
"Infof",
"(",
"\"",
"\"",
",",
"f",
")",
"\n",
"}",
"\n",
"newfnames",
"=",
"newfnames",
"[",
"1",
":",
"]",
"\n",
"}",
"\n",
"if",
"purgec",
"!=",
"nil",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"fnames",
")",
"-",
"len",
"(",
"newfnames",
")",
";",
"i",
"++",
"{",
"purgec",
"<-",
"fnames",
"[",
"i",
"]",
"\n",
"}",
"\n",
"}",
"\n",
"select",
"{",
"case",
"<-",
"time",
".",
"After",
"(",
"interval",
")",
":",
"case",
"<-",
"stop",
":",
"return",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"return",
"errC",
"\n",
"}"
] |
95 | maxmin-96 | [
"backoff",
"is",
"used",
"to",
"compute",
"an",
"exponential",
"backoff",
"duration",
".",
"Base",
"time",
"is",
"scaled",
"by",
"the",
"current",
"round",
"up",
"to",
"some",
"maximum",
"scale",
"factor",
"."
] | [
"func",
"backoff",
"(",
"base",
"time",
".",
"Duration",
",",
"round",
",",
"limit",
"uint64",
")",
"time",
".",
"Duration",
"{",
"power",
":=",
"<mask>",
"(",
"round",
",",
"limit",
")",
"\n",
"for",
"power",
">",
"2",
"{",
"base",
"*=",
"2",
"\n",
"power",
"--",
"\n",
"}",
"\n",
"return",
"base",
"\n",
"}"
] |
96 | maxmin-97 | [
"splitMappingsAt",
"ensures",
"that",
"a",
"is",
"not",
"in",
"the",
"middle",
"of",
"any",
"mapping",
".",
"Splits",
"mappings",
"as",
"necessary",
"."
] | [
"func",
"(",
"p",
"*",
"Process",
")",
"splitMappingsAt",
"(",
"a",
"Address",
")",
"{",
"for",
"_",
",",
"m",
":=",
"range",
"p",
".",
"memory",
".",
"mappings",
"{",
"if",
"a",
"<",
"m",
".",
"<mask>",
"||",
"a",
">",
"m",
".",
"max",
"{",
"continue",
"\n",
"}",
"\n",
"if",
"a",
"==",
"m",
".",
"min",
"||",
"a",
"==",
"m",
".",
"max",
"{",
"return",
"\n",
"}",
"\n",
"// Split this mapping at a.",
"m2",
":=",
"new",
"(",
"Mapping",
")",
"\n",
"*",
"m2",
"=",
"*",
"m",
"\n",
"m",
".",
"max",
"=",
"a",
"\n",
"m2",
".",
"min",
"=",
"a",
"\n",
"if",
"m2",
".",
"f",
"!=",
"nil",
"{",
"m2",
".",
"off",
"+=",
"m",
".",
"Size",
"(",
")",
"\n",
"}",
"\n",
"if",
"m2",
".",
"origF",
"!=",
"nil",
"{",
"m2",
".",
"origOff",
"+=",
"m",
".",
"Size",
"(",
")",
"\n",
"}",
"\n",
"p",
".",
"memory",
".",
"mappings",
"=",
"append",
"(",
"p",
".",
"memory",
".",
"mappings",
",",
"m2",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}"
] |
97 | maxmin-98 | [
"markObjects",
"finds",
"all",
"the",
"live",
"objects",
"in",
"the",
"heap",
"and",
"marks",
"them",
"in",
"the",
"p",
".",
"heapInfo",
"mark",
"fields",
"."
] | [
"func",
"(",
"p",
"*",
"Process",
")",
"markObjects",
"(",
")",
"{",
"ptrSize",
":=",
"p",
".",
"proc",
".",
"PtrSize",
"(",
")",
"\n\n",
"// number of live objects found so far",
"n",
":=",
"0",
"\n",
"// total size of live objects",
"var",
"live",
"int64",
"\n\n",
"var",
"q",
"[",
"]",
"Object",
"\n\n",
"// Function to call when we find a new pointer.",
"add",
":=",
"func",
"(",
"x",
"core",
".",
"Address",
")",
"{",
"h",
":=",
"p",
".",
"findHeapInfo",
"(",
"x",
")",
"\n",
"if",
"h",
"==",
"nil",
"{",
"// not in heap or not in a valid span",
"// Invalid spans can happen with intra-stack pointers.",
"return",
"\n",
"}",
"\n",
"// Round down to object start.",
"x",
"=",
"h",
".",
"base",
".",
"Add",
"(",
"x",
".",
"Sub",
"(",
"h",
".",
"base",
")",
"/",
"h",
".",
"size",
"*",
"h",
".",
"size",
")",
"\n",
"// Object start may map to a different info. Reload heap info.",
"h",
"=",
"p",
".",
"findHeapInfo",
"(",
"x",
")",
"\n",
"// Find mark bit",
"b",
":=",
"uint64",
"(",
"x",
")",
"%",
"heapInfoSize",
"/",
"8",
"\n",
"if",
"h",
".",
"mark",
"&",
"(",
"uint64",
"(",
"1",
")",
"<<",
"b",
")",
"!=",
"0",
"{",
"// already found",
"return",
"\n",
"}",
"\n",
"h",
".",
"mark",
"|=",
"uint64",
"(",
"1",
")",
"<<",
"b",
"\n",
"n",
"++",
"\n",
"live",
"+=",
"h",
".",
"size",
"\n",
"q",
"=",
"append",
"(",
"q",
",",
"Object",
"(",
"x",
")",
")",
"\n",
"}",
"\n\n",
"// Start with scanning all the roots.",
"// Note that we don't just use the DWARF roots, just in case DWARF isn't complete.",
"// Instead we use exactly what the runtime uses.",
"// Goroutine roots",
"for",
"_",
",",
"g",
":=",
"range",
"p",
".",
"goroutines",
"{",
"for",
"_",
",",
"f",
":=",
"range",
"g",
".",
"frames",
"{",
"for",
"a",
":=",
"range",
"f",
".",
"Live",
"{",
"add",
"(",
"p",
".",
"proc",
".",
"ReadPtr",
"(",
"a",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Global roots",
"for",
"_",
",",
"m",
":=",
"range",
"p",
".",
"modules",
"{",
"for",
"_",
",",
"s",
":=",
"range",
"[",
"2",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"",
"\"",
"}",
"{",
"<mask>",
":=",
"core",
".",
"Address",
"(",
"m",
".",
"r",
".",
"Field",
"(",
"s",
")",
".",
"Uintptr",
"(",
")",
")",
"\n",
"max",
":=",
"core",
".",
"Address",
"(",
"m",
".",
"r",
".",
"Field",
"(",
"\"",
"\"",
"+",
"s",
")",
".",
"Uintptr",
"(",
")",
")",
"\n",
"gc",
":=",
"m",
".",
"r",
".",
"Field",
"(",
"\"",
"\"",
"+",
"s",
"+",
"\"",
"\"",
")",
".",
"Field",
"(",
"\"",
"\"",
")",
".",
"Address",
"(",
")",
"\n",
"num",
":=",
"max",
".",
"Sub",
"(",
"min",
")",
"/",
"ptrSize",
"\n",
"for",
"i",
":=",
"int64",
"(",
"0",
")",
";",
"i",
"<",
"num",
";",
"i",
"++",
"{",
"if",
"p",
".",
"proc",
".",
"ReadUint8",
"(",
"gc",
".",
"Add",
"(",
"i",
"/",
"8",
")",
")",
">>",
"uint",
"(",
"i",
"%",
"8",
")",
"&",
"1",
"!=",
"0",
"{",
"add",
"(",
"p",
".",
"proc",
".",
"ReadPtr",
"(",
"min",
".",
"Add",
"(",
"i",
"*",
"ptrSize",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Finalizers",
"for",
"_",
",",
"r",
":=",
"range",
"p",
".",
"globals",
"{",
"if",
"!",
"strings",
".",
"HasPrefix",
"(",
"r",
".",
"Name",
",",
"\"",
"\"",
")",
"{",
"continue",
"\n",
"}",
"\n",
"for",
"_",
",",
"f",
":=",
"range",
"r",
".",
"Type",
".",
"Fields",
"{",
"if",
"f",
".",
"Type",
".",
"Kind",
"==",
"KindPtr",
"{",
"add",
"(",
"p",
".",
"proc",
".",
"ReadPtr",
"(",
"r",
".",
"Addr",
".",
"Add",
"(",
"f",
".",
"Off",
")",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"// Expand root set to all reachable objects.",
"for",
"len",
"(",
"q",
")",
">",
"0",
"{",
"x",
":=",
"q",
"[",
"len",
"(",
"q",
")",
"-",
"1",
"]",
"\n",
"q",
"=",
"q",
"[",
":",
"len",
"(",
"q",
")",
"-",
"1",
"]",
"\n\n",
"// Scan object for pointers.",
"size",
":=",
"p",
".",
"Size",
"(",
"x",
")",
"\n",
"for",
"i",
":=",
"int64",
"(",
"0",
")",
";",
"i",
"<",
"size",
";",
"i",
"+=",
"ptrSize",
"{",
"a",
":=",
"core",
".",
"Address",
"(",
"x",
")",
".",
"Add",
"(",
"i",
")",
"\n",
"if",
"p",
".",
"isPtrFromHeap",
"(",
"a",
")",
"{",
"add",
"(",
"p",
".",
"proc",
".",
"ReadPtr",
"(",
"a",
")",
")",
"\n",
"}",
"\n",
"}",
"\n",
"}",
"\n\n",
"p",
".",
"nObj",
"=",
"n",
"\n\n",
"// Initialize firstIdx fields in the heapInfo, for fast object index lookups.",
"n",
"=",
"0",
"\n",
"p",
".",
"ForEachObject",
"(",
"func",
"(",
"x",
"Object",
")",
"bool",
"{",
"h",
":=",
"p",
".",
"findHeapInfo",
"(",
"p",
".",
"Addr",
"(",
"x",
")",
")",
"\n",
"if",
"h",
".",
"firstIdx",
"==",
"-",
"1",
"{",
"h",
".",
"firstIdx",
"=",
"n",
"\n",
"}",
"\n",
"n",
"++",
"\n",
"return",
"true",
"\n",
"}",
")",
"\n",
"if",
"n",
"!=",
"p",
".",
"nObj",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"// Update stats to include the live/garbage distinction.",
"alloc",
":=",
"p",
".",
"Stats",
"(",
")",
".",
"Child",
"(",
"\"",
"\"",
")",
".",
"Child",
"(",
"\"",
"\"",
")",
".",
"Child",
"(",
"\"",
"\"",
")",
"\n",
"alloc",
".",
"Children",
"=",
"[",
"]",
"*",
"Stats",
"{",
"&",
"Stats",
"{",
"\"",
"\"",
",",
"live",
",",
"nil",
"}",
",",
"&",
"Stats",
"{",
"\"",
"\"",
",",
"alloc",
".",
"Size",
"-",
"live",
",",
"nil",
"}",
",",
"}",
"\n",
"}"
] |
98 | maxmin-99 | [
"serve",
"runs",
"the",
"listener",
"to",
"accept",
"and",
"manage",
"new",
"incoming",
"connections",
"blocking",
"until",
"the",
"channel",
"is",
"closed",
"."
] | [
"func",
"(",
"ch",
"*",
"Channel",
")",
"serve",
"(",
")",
"{",
"acceptBackoff",
":=",
"0",
"*",
"time",
".",
"Millisecond",
"\n\n",
"for",
"{",
"netConn",
",",
"err",
":=",
"ch",
".",
"mutable",
".",
"l",
".",
"Accept",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"// Backoff from new accepts if this is a temporary error",
"if",
"ne",
",",
"ok",
":=",
"err",
".",
"(",
"net",
".",
"Error",
")",
";",
"ok",
"&&",
"ne",
".",
"Temporary",
"(",
")",
"{",
"if",
"acceptBackoff",
"==",
"0",
"{",
"acceptBackoff",
"=",
"5",
"*",
"time",
".",
"Millisecond",
"\n",
"}",
"else",
"{",
"acceptBackoff",
"*=",
"2",
"\n",
"}",
"\n",
"if",
"<mask>",
":=",
"1",
"*",
"time",
".",
"Second",
";",
"acceptBackoff",
">",
"max",
"{",
"acceptBackoff",
"=",
"max",
"\n",
"}",
"\n",
"ch",
".",
"log",
".",
"WithFields",
"(",
"ErrField",
"(",
"err",
")",
",",
"LogField",
"{",
"\"",
"\"",
",",
"acceptBackoff",
"}",
",",
")",
".",
"Warn",
"(",
"\"",
"\"",
")",
"\n",
"time",
".",
"Sleep",
"(",
"acceptBackoff",
")",
"\n",
"continue",
"\n",
"}",
"else",
"{",
"// Only log an error if this didn't happen due to a Close.",
"if",
"ch",
".",
"State",
"(",
")",
">=",
"ChannelStartClose",
"{",
"return",
"\n",
"}",
"\n",
"ch",
".",
"log",
".",
"WithFields",
"(",
"ErrField",
"(",
"err",
")",
")",
".",
"Fatal",
"(",
"\"",
"\"",
")",
"\n",
"return",
"\n",
"}",
"\n",
"}",
"\n\n",
"acceptBackoff",
"=",
"0",
"\n\n",
"// Perform the connection handshake in a background goroutine.",
"go",
"func",
"(",
")",
"{",
"// Register the connection in the peer once the channel is set up.",
"events",
":=",
"connectionEvents",
"{",
"OnActive",
":",
"ch",
".",
"inboundConnectionActive",
",",
"OnCloseStateChange",
":",
"ch",
".",
"connectionCloseStateChange",
",",
"OnExchangeUpdated",
":",
"ch",
".",
"exchangeUpdated",
",",
"}",
"\n",
"if",
"_",
",",
"err",
":=",
"ch",
".",
"inboundHandshake",
"(",
"context",
".",
"Background",
"(",
")",
",",
"netConn",
",",
"events",
")",
";",
"err",
"!=",
"nil",
"{",
"netConn",
".",
"Close",
"(",
")",
"\n",
"}",
"\n",
"}",
"(",
")",
"\n",
"}",
"\n",
"}"
] |
99 | maxmin-100 | [
"ParseUintHex",
"parses",
"a",
"hexadecimanl",
"representation",
"of",
"a",
"uint64",
"from",
"b",
".",
"The",
"function",
"is",
"equivalent",
"to",
"calling",
"strconv",
".",
"ParseUint",
"(",
"string",
"(",
"b",
")",
"16",
"64",
")",
"but",
"it",
"prevents",
"Go",
"from",
"making",
"a",
"memory",
"allocation",
"for",
"converting",
"a",
"byte",
"slice",
"to",
"a",
"string",
"(",
"escape",
"analysis",
"fails",
"due",
"to",
"the",
"error",
"returned",
"by",
"strconv",
".",
"ParseUint",
")",
".",
"Because",
"it",
"only",
"works",
"with",
"base",
"16",
"the",
"function",
"is",
"also",
"significantly",
"faster",
"than",
"strconv",
".",
"ParseUint",
"."
] | [
"func",
"ParseUintHex",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"const",
"<mask>",
"=",
"Uint64Max",
"\n",
"const",
"lim",
"=",
"max",
"/",
"0x10",
"\n",
"var",
"val",
"uint64",
"\n\n",
"if",
"len",
"(",
"b",
")",
"==",
"0",
"{",
"return",
"0",
",",
"errorInvalidUint64",
"(",
"b",
")",
"\n",
"}",
"\n\n",
"for",
"_",
",",
"d",
":=",
"range",
"b",
"{",
"var",
"x",
"uint64",
"\n\n",
"switch",
"{",
"case",
"d",
">=",
"'0'",
"&&",
"d",
"<=",
"'9'",
":",
"x",
"=",
"uint64",
"(",
"d",
"-",
"'0'",
")",
"\n\n",
"case",
"d",
">=",
"'A'",
"&&",
"d",
"<=",
"'F'",
":",
"x",
"=",
"uint64",
"(",
"d",
"-",
"'A'",
")",
"+",
"0xA",
"\n\n",
"case",
"d",
">=",
"'a'",
"&&",
"d",
"<=",
"'f'",
":",
"x",
"=",
"uint64",
"(",
"d",
"-",
"'a'",
")",
"+",
"0xA",
"\n\n",
"default",
":",
"return",
"0",
",",
"errorInvalidUint64",
"(",
"b",
")",
"\n",
"}",
"\n\n",
"if",
"val",
">",
"lim",
"{",
"return",
"0",
",",
"errorOverflowUint64",
"(",
"b",
")",
"\n",
"}",
"\n\n",
"if",
"val",
"*=",
"0x10",
";",
"val",
">",
"(",
"max",
"-",
"x",
")",
"{",
"return",
"0",
",",
"errorOverflowUint64",
"(",
"b",
")",
"\n",
"}",
"\n\n",
"val",
"+=",
"x",
"\n",
"}",
"\n\n",
"return",
"val",
",",
"nil",
"\n",
"}"
] |
Dataset Card for "code_x_glue_cc_cloze_testing_maxmin"
Dataset Summary
CodeXGLUE ClozeTesting-maxmin dataset, available at https://github.com/microsoft/CodeXGLUE/tree/main/Code-Code/ClozeTesting-maxmin
Cloze tests are widely adopted in Natural Languages Processing to evaluate the performance of the trained language models. The task is aimed to predict the answers for the blank with the context of the blank, which can be formulated as a multi-choice classification problem. Here we present the two cloze testing datasets in code domain with six different programming languages: ClozeTest-maxmin and ClozeTest-all. Each instance in the dataset contains a masked code function, its docstring and the target word. The only difference between ClozeTest-maxmin and ClozeTest-all is their selected words sets, where ClozeTest-maxmin only contains two words while ClozeTest-all contains 930 words.
Supported Tasks and Leaderboards
slot-filling
: The dataset can be used to train a model for predicting the missing token from a piece of code, similar to the Cloze test.
Languages
- Go programming language
- Java programming language
- Javascript programming language
- PHP programming language
- Python programming language
- Ruby programming language
Dataset Structure
Data Instances
go
An example of 'train' looks as follows.
{
"id": 0,
"idx": "maxmin-1",
"nl_tokens": ["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"],
"pl_tokens": ["func", "(", "v", "*", "Validate", ")", "SetMaxStructPoolSize", "(", "<mask>", "int", ")", "{", "structPool", "=", "&", "sync", ".", "Pool", "{", "New", ":", "newStructErrors", "}", "\n", "}"]
}
java
An example of 'train' looks as follows.
{
"id": 0,
"idx": "maxmin-1",
"nl_tokens": ["Test", "whether", "find", "can", "be", "found", "at", "position", "startPos", "in", "the", "string", "src", "."],
"pl_tokens": ["public", "static", "boolean", "startsWith", "(", "char", "[", "]", "src", ",", "char", "[", "]", "find", ",", "int", "startAt", ")", "{", "int", "startPos", "=", "startAt", ";", "boolean", "result", "=", "true", ";", "// Check ranges", "if", "(", "src", ".", "length", "<", "startPos", "+", "find", ".", "length", ")", "{", "result", "=", "false", ";", "}", "else", "{", "final", "int", "<mask>", "=", "find", ".", "length", ";", "for", "(", "int", "a", "=", "0", ";", "a", "<", "max", "&&", "result", ";", "a", "++", ")", "{", "if", "(", "src", "[", "startPos", "]", "!=", "find", "[", "a", "]", ")", "{", "result", "=", "false", ";", "}", "startPos", "++", ";", "}", "}", "return", "result", ";", "}"]
}
javascript
An example of 'train' looks as follows.
{
"id": 0,
"idx": "maxmin-1",
"nl_tokens": ["string", ".", "max", "Maximum", "length", "of", "the", "string"],
"pl_tokens": ["function", "(", "string", ")", "{", "// string.check check sting type and size", "return", "(", "(", "typeof", "string", "===", "'string'", "||", "string", "instanceof", "String", ")", "&&", "string", ".", "length", ">=", "this", ".", "<mask>", "&&", "string", ".", "length", "<=", "this", ".", "max", "&&", "(", "!", "this", ".", "match", "||", "string", ".", "match", "(", "this", ".", "match", ")", ")", ")", ";", "}"]
}
php
An example of 'train' looks as follows.
{
"id": 0,
"idx": "maxmin-1",
"nl_tokens": ["Read", "the", "next", "character", "from", "the", "supplied", "string", ".", "Return", "null", "when", "we", "have", "run", "out", "of", "characters", "."],
"pl_tokens": ["public", "function", "readOne", "(", ")", "{", "if", "(", "$", "this", "->", "pos", "<=", "$", "this", "->", "<mask>", ")", "{", "$", "value", "=", "$", "this", "->", "string", "[", "$", "this", "->", "pos", "]", ";", "$", "this", "->", "pos", "+=", "1", ";", "}", "else", "{", "$", "value", "=", "null", ";", "}", "return", "$", "value", ";", "}"]
}
python
An example of 'train' looks as follows.
{
"id": 0,
"idx": "maxmin-1",
"nl_tokens": ["Returns", "intermediary", "colors", "for", "given", "list", "of", "colors", "."],
"pl_tokens": ["def", "_interpolate", "(", "self", ",", "colors", ",", "n", "=", "100", ")", ":", "gradient", "=", "[", "]", "for", "i", "in", "_range", "(", "n", ")", ":", "l", "=", "len", "(", "colors", ")", "-", "1", "x", "=", "int", "(", "1.0", "*", "i", "/", "n", "*", "l", ")", "x", "=", "<mask>", "(", "x", "+", "0", ",", "l", ")", "y", "=", "min", "(", "x", "+", "1", ",", "l", ")", "base", "=", "1.0", "*", "n", "/", "l", "*", "x", "d", "=", "(", "i", "-", "base", ")", "/", "(", "1.0", "*", "n", "/", "l", ")", "r", "=", "colors", "[", "x", "]", ".", "r", "*", "(", "1", "-", "d", ")", "+", "colors", "[", "y", "]", ".", "r", "*", "d", "g", "=", "colors", "[", "x", "]", ".", "g", "*", "(", "1", "-", "d", ")", "+", "colors", "[", "y", "]", ".", "g", "*", "d", "b", "=", "colors", "[", "x", "]", ".", "b", "*", "(", "1", "-", "d", ")", "+", "colors", "[", "y", "]", ".", "b", "*", "d", "a", "=", "colors", "[", "x", "]", ".", "a", "*", "(", "1", "-", "d", ")", "+", "colors", "[", "y", "]", ".", "a", "*", "d", "gradient", ".", "append", "(", "color", "(", "r", ",", "g", ",", "b", ",", "a", ",", "mode", "=", "\"rgb\"", ")", ")", "gradient", ".", "append", "(", "colors", "[", "-", "1", "]", ")", "return", "gradient"]
}
ruby
An example of 'train' looks as follows.
{
"id": 0,
"idx": "maxmin-1",
"nl_tokens": ["Delete", "all", "copies", "that", "are", "older", "than", "the", "max", "age", "provided", "in", "seconds", "."],
"pl_tokens": ["def", "clean", "(", "<mask>", ":", "24", "*", "60", "*", "60", ")", "Futex", ".", "new", "(", "file", ",", "log", ":", "@log", ")", ".", "open", "do", "list", "=", "load", "list", ".", "reject!", "do", "|", "s", "|", "if", "s", "[", ":time", "]", ">=", "Time", ".", "now", "-", "max", "false", "else", "@log", ".", "debug", "(", "\"Copy ##{s[:name]}/#{s[:host]}:#{s[:port]} is too old, over #{Age.new(s[:time])}\"", ")", "true", "end", "end", "save", "(", "list", ")", "deleted", "=", "0", "files", ".", "each", "do", "|", "f", "|", "next", "unless", "list", ".", "find", "{", "|", "s", "|", "s", "[", ":name", "]", "==", "File", ".", "basename", "(", "f", ",", "Copies", "::", "EXT", ")", "}", ".", "nil?", "file", "=", "File", ".", "join", "(", "@dir", ",", "f", ")", "size", "=", "File", ".", "size", "(", "file", ")", "File", ".", "delete", "(", "file", ")", "@log", ".", "debug", "(", "\"Copy at #{f} deleted: #{Size.new(size)}\"", ")", "deleted", "+=", "1", "end", "list", ".", "select!", "do", "|", "s", "|", "cp", "=", "File", ".", "join", "(", "@dir", ",", "\"#{s[:name]}#{Copies::EXT}\"", ")", "wallet", "=", "Wallet", ".", "new", "(", "cp", ")", "begin", "wallet", ".", "refurbish", "raise", "\"Invalid protocol #{wallet.protocol} in #{cp}\"", "unless", "wallet", ".", "protocol", "==", "Zold", "::", "PROTOCOL", "true", "rescue", "StandardError", "=>", "e", "FileUtils", ".", "rm_rf", "(", "cp", ")", "@log", ".", "debug", "(", "\"Copy at #{cp} deleted: #{Backtrace.new(e)}\"", ")", "deleted", "+=", "1", "false", "end", "end", "save", "(", "list", ")", "deleted", "end", "end"]
}
Data Fields
In the following each data field in go is explained for each config. The data fields are the same among all splits.
go, java, javascript, php, python, ruby
field name | type | description |
---|---|---|
id | int32 | Index of the sample |
idx | string | Original index in the dataset |
nl_tokens | Sequence[string] | Natural language tokens |
pl_tokens | Sequence[string] | Programming language tokens |
Data Splits
name | train |
---|---|
go | 152 |
java | 482 |
javascript | 272 |
php | 407 |
python | 1264 |
ruby | 38 |
Dataset Creation
Curation Rationale
[More Information Needed]
Source Data
Initial Data Collection and Normalization
Data from CodeSearchNet Challenge dataset. [More Information Needed]
Who are the source language producers?
Software Engineering developers.
Annotations
Annotation process
[More Information Needed]
Who are the annotators?
[More Information Needed]
Personal and Sensitive Information
[More Information Needed]
Considerations for Using the Data
Social Impact of Dataset
[More Information Needed]
Discussion of Biases
[More Information Needed]
Other Known Limitations
[More Information Needed]
Additional Information
Dataset Curators
https://github.com/microsoft, https://github.com/madlag
Licensing Information
Computational Use of Data Agreement (C-UDA) License.
Citation Information
@article{CodeXGLUE,
title={CodeXGLUE: An Open Challenge for Code Intelligence},
journal={arXiv},
year={2020},
}
@article{feng2020codebert,
title={CodeBERT: A Pre-Trained Model for Programming and Natural Languages},
author={Feng, Zhangyin and Guo, Daya and Tang, Duyu and Duan, Nan and Feng, Xiaocheng and Gong, Ming and Shou, Linjun and Qin, Bing and Liu, Ting and Jiang, Daxin and others},
journal={arXiv preprint arXiv:2002.08155},
year={2020}
}
@article{husain2019codesearchnet,
title={CodeSearchNet Challenge: Evaluating the State of Semantic Code Search},
author={Husain, Hamel and Wu, Ho-Hsiang and Gazit, Tiferet and Allamanis, Miltiadis and Brockschmidt, Marc},
journal={arXiv preprint arXiv:1909.09436},
year={2019}
}
Contributions
Thanks to @madlag (and partly also @ncoop57) for adding this dataset.
- Downloads last month
- 111