Datasets:

---

CM

/

codexglue_code2text_go

like 1

[ "func", "(", "b", "*", "Bound", ")", "ToMysqlIntersectsCondition", "(", "column", "string", ")", "string", "{", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "column", ",", "b", ".", "String", "(", ")", ")", "\n", "}" ]

[ "ToMysqlIntersectsCondition", "returns", "a", "condition", "defining", "the", "intersection", "of", "the", "column", "and", "the", "bound", ".", "To", "be", "used", "in", "a", "MySQL", "query", "." ]

[ "func", "(", "s", "*", "Surface", ")", "GradientAt", "(", "point", "*", "Point", ")", "*", "Point", "{", "if", "!", "s", ".", "bound", ".", "Contains", "(", "point", ")", "{", "return", "NewPoint", "(", "0", ",", "0", ")", "\n", "}", "\n\n", "xi", ",", "yi", ",", "deltaX", ",", "deltaY", ":=", "s", ".", "gridCoordinate", "(", "point", ")", "\n\n", "xi1", ":=", "xi", "+", "1", "\n", "if", "limit", ":=", "s", ".", "Width", "-", "1", ";", "xi1", ">", "limit", "{", "xi", "=", "limit", "-", "1", "\n", "xi1", "=", "limit", "\n", "deltaX", "=", "1.0", "\n", "}", "\n\n", "yi1", ":=", "yi", "+", "1", "\n", "if", "limit", ":=", "s", ".", "Height", "-", "1", ";", "yi1", ">", "limit", "{", "yi", "=", "limit", "-", "1", "\n", "yi1", "=", "limit", "\n", "deltaY", "=", "1.0", "\n", "}", "\n\n", "u1", ":=", "s", ".", "Grid", "[", "xi", "]", "[", "yi", "]", "*", "(", "1", "-", "deltaX", ")", "+", "s", ".", "Grid", "[", "xi1", "]", "[", "yi", "]", "*", "deltaX", "\n", "u2", ":=", "s", ".", "Grid", "[", "xi", "]", "[", "yi1", "]", "*", "(", "1", "-", "deltaX", ")", "+", "s", ".", "Grid", "[", "xi1", "]", "[", "yi1", "]", "*", "deltaX", "\n\n", "w1", ":=", "(", "1", "-", "deltaY", ")", "*", "(", "s", ".", "Grid", "[", "xi1", "]", "[", "yi", "]", "-", "s", ".", "Grid", "[", "xi", "]", "[", "yi", "]", ")", "\n", "w2", ":=", "deltaY", "*", "(", "s", ".", "Grid", "[", "xi1", "]", "[", "yi1", "]", "-", "s", ".", "Grid", "[", "xi", "]", "[", "yi1", "]", ")", "\n\n", "return", "NewPoint", "(", "(", "w1", "+", "w2", ")", "/", "s", ".", "gridBoxWidth", "(", ")", ",", "(", "u2", "-", "u1", ")", "/", "s", ".", "gridBoxHeight", "(", ")", ")", "\n", "}" ]

[ "GradientAt", "returns", "the", "surface", "gradient", "at", "the", "given", "point", ".", "Bilinearlly", "interpolates", "the", "grid", "cell", "to", "find", "the", "gradient", "." ]

[ "func", "(", "s", "Surface", ")", "gridBoxWidth", "(", ")", "float64", "{", "return", "s", ".", "bound", ".", "Width", "(", ")", "/", "float64", "(", "s", ".", "Width", "-", "1", ")", "\n", "}" ]

[ "gridBoxWidth", "returns", "the", "width", "of", "a", "grid", "element", "in", "the", "units", "of", "s", ".", "Bound", "." ]

[ "func", "(", "s", "Surface", ")", "gridBoxHeight", "(", ")", "float64", "{", "return", "s", ".", "bound", ".", "Height", "(", ")", "/", "float64", "(", "s", ".", "Height", "-", "1", ")", "\n", "}" ]

[ "gridBoxHeight", "returns", "the", "height", "of", "a", "grid", "element", "in", "the", "units", "of", "s", ".", "Bound", "." ]

[ "func", "ClusterCombiners", "(", "combiners", "[", "]", "Combiner", ",", "threshold", "float64", ")", "[", "]", "Combiner", "{", "if", "len", "(", "combiners", ")", "<", "2", "{", "return", "combiners", "\n", "}", "\n\n", "s", ":=", "&", "state", "{", "Distances", ":", "initializeCombinerDistances", "(", "combiners", ",", "threshold", ")", ",", "DistanceFunc", ":", "func", "(", "a", ",", "b", "int", ")", "float64", "{", "return", "combiners", "[", "a", "]", ".", "DistanceFromCombiner", "(", "combiners", "[", "b", "]", ")", "\n", "}", ",", "}", "\n\n", "// successively merge", "for", "i", ":=", "1", ";", "i", "<", "len", "(", "combiners", ")", ";", "i", "++", "{", "lower", ",", "higher", ",", "dist", ":=", "s", ".", "MinDistance", "(", ")", "\n", "if", "dist", ">", "threshold", "{", "break", "\n", "}", "\n\n", "// merge these two", "combiners", "[", "lower", "]", "=", "combiners", "[", "lower", "]", ".", "Combine", "(", "combiners", "[", "higher", "]", ")", "\n", "s", ".", "ResetDistances", "(", "lower", ",", "higher", ")", "\n", "combiners", "[", "higher", "]", "=", "nil", "\n", "}", "\n\n", "last", ":=", "len", "(", "combiners", ")", "-", "1", "\n", "for", "i", ":=", "range", "combiners", "{", "if", "combiners", "[", "i", "]", "==", "nil", "{", "combiners", "[", "i", "]", "=", "combiners", "[", "last", "]", "\n", "last", "--", "\n", "}", "\n", "}", "\n\n", "return", "combiners", "[", ":", "last", "+", "1", "]", "\n", "}" ]

[ "ClusterCombiners", "will", "do", "a", "simple", "hierarchical", "of", "the", "combiners", ".", "It", "will", "modify", "the", "input", "slice", "as", "things", "will", "be", "combined", "into", "each", "other", "." ]

[ "func", "newDistanceSet", "(", ")", "*", "distanceSet", "{", "return", "&", "distanceSet", "{", "MinDistance", ":", "math", ".", "MaxFloat64", ",", "Distances", ":", "make", "(", "map", "[", "int", "]", "float64", ",", "500", ")", ",", "// adding 500 was a 20% performance win", "}", "\n", "}" ]

[ "newDistanceSet", "creates", "a", "new", "distance", "set", "." ]

[ "func", "(", "ds", "*", "distanceSet", ")", "Set", "(", "index", "int", ",", "distance", "float64", ")", "bool", "{", "if", "d", ",", "ok", ":=", "ds", ".", "Distances", "[", "index", "]", ";", "ok", "&&", "index", "==", "ds", ".", "MinIndex", "&&", "distance", ">", "d", "{", "// minimum index is being made greater, need to reset", "ds", ".", "Distances", "[", "index", "]", "=", "distance", "\n", "ds", ".", "reset", "(", ")", "\n", "return", "true", "\n", "}", "\n\n", "ds", ".", "Distances", "[", "index", "]", "=", "distance", "\n", "if", "distance", "<", "ds", ".", "MinDistance", "{", "ds", ".", "MinDistance", "=", "distance", "\n", "ds", ".", "MinIndex", "=", "index", "\n", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "Set", "sets", "the", "distance", "for", "a", "given", "index", "and", "updates", "the", "denormalized", "min", "distance", "if", "necessary", ".", "Returns", "true", "if", "the", "minimum", "has", "been", "updated", "." ]

[ "func", "(", "ds", "*", "distanceSet", ")", "Delete", "(", "index", "int", ")", "bool", "{", "delete", "(", "ds", ".", "Distances", ",", "index", ")", "\n", "if", "index", "==", "ds", ".", "MinIndex", "{", "ds", ".", "reset", "(", ")", "\n", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "Delete", "removes", "a", "values", "for", "an", "index", "and", "resets", "denormalized", "minimum", ".", "Returns", "true", "if", "the", "minimum", "has", "been", "updated", "." ]

[ "func", "(", "ds", "*", "distanceSet", ")", "reset", "(", ")", "{", "minDist", ":=", "math", ".", "MaxFloat64", "\n", "minIndex", ":=", "0", "\n", "for", "i", ",", "d", ":=", "range", "ds", ".", "Distances", "{", "if", "d", "<", "minDist", "{", "minDist", "=", "d", "\n", "minIndex", "=", "i", "\n", "}", "\n", "}", "\n\n", "ds", ".", "MinIndex", "=", "minIndex", "\n", "ds", ".", "MinDistance", "=", "minDist", "\n", "}" ]

[ "reset", "refinds", "the", "denormalized", "minimum", ".", "Can", "be", "used", "if", "manually", "updating", "values", ".", "not", "part", "of", "the", "official", "api", "." ]

[ "func", "NewLine", "(", "a", ",", "b", "*", "Point", ")", "*", "Line", "{", "return", "&", "Line", "{", "*", "a", ".", "Clone", "(", ")", ",", "*", "b", ".", "Clone", "(", ")", "}", "\n", "}" ]

[ "NewLine", "creates", "a", "new", "line", "by", "cloning", "the", "provided", "points", "." ]

[ "func", "(", "l", "*", "Line", ")", "Transform", "(", "projector", "Projector", ")", "*", "Line", "{", "projector", "(", "&", "l", ".", "a", ")", "\n", "projector", "(", "&", "l", ".", "b", ")", "\n\n", "return", "l", "\n", "}" ]

[ "Transform", "applies", "a", "given", "projection", "or", "inverse", "projection", "to", "the", "current", "line", ".", "Modifies", "the", "line", "." ]

[ "func", "(", "l", "*", "Line", ")", "DistanceFrom", "(", "point", "*", "Point", ")", "float64", "{", "// yes duplicate code, but saw a 15% performance increase by removing the function call", "// return math.Sqrt(l.SquaredDistanceFrom(point))", "x", ":=", "l", ".", "a", "[", "0", "]", "\n", "y", ":=", "l", ".", "a", "[", "1", "]", "\n", "dx", ":=", "l", ".", "b", "[", "0", "]", "-", "x", "\n", "dy", ":=", "l", ".", "b", "[", "1", "]", "-", "y", "\n\n", "if", "dx", "!=", "0", "||", "dy", "!=", "0", "{", "t", ":=", "(", "(", "point", "[", "0", "]", "-", "x", ")", "*", "dx", "+", "(", "point", "[", "1", "]", "-", "y", ")", "*", "dy", ")", "/", "(", "dx", "*", "dx", "+", "dy", "*", "dy", ")", "\n\n", "if", "t", ">", "1", "{", "x", "=", "l", ".", "b", "[", "0", "]", "\n", "y", "=", "l", ".", "b", "[", "1", "]", "\n", "}", "else", "if", "t", ">", "0", "{", "x", "+=", "dx", "*", "t", "\n", "y", "+=", "dy", "*", "t", "\n", "}", "\n", "}", "\n\n", "dx", "=", "point", "[", "0", "]", "-", "x", "\n", "dy", "=", "point", "[", "1", "]", "-", "y", "\n\n", "return", "math", ".", "Sqrt", "(", "dx", "*", "dx", "+", "dy", "*", "dy", ")", "\n", "}" ]

[ "DistanceFrom", "does", "NOT", "use", "spherical", "geometry", ".", "It", "finds", "the", "distance", "from", "the", "line", "using", "standard", "Euclidean", "geometry", "using", "the", "units", "the", "points", "are", "in", "." ]

[ "func", "(", "l", "*", "Line", ")", "SquaredDistanceFrom", "(", "point", "*", "Point", ")", "float64", "{", "x", ":=", "l", ".", "a", "[", "0", "]", "\n", "y", ":=", "l", ".", "a", "[", "1", "]", "\n", "dx", ":=", "l", ".", "b", "[", "0", "]", "-", "x", "\n", "dy", ":=", "l", ".", "b", "[", "1", "]", "-", "y", "\n\n", "if", "dx", "!=", "0", "||", "dy", "!=", "0", "{", "t", ":=", "(", "(", "point", "[", "0", "]", "-", "x", ")", "*", "dx", "+", "(", "point", "[", "1", "]", "-", "y", ")", "*", "dy", ")", "/", "(", "dx", "*", "dx", "+", "dy", "*", "dy", ")", "\n\n", "if", "t", ">", "1", "{", "x", "=", "l", ".", "b", "[", "0", "]", "\n", "y", "=", "l", ".", "b", "[", "1", "]", "\n", "}", "else", "if", "t", ">", "0", "{", "x", "+=", "dx", "*", "t", "\n", "y", "+=", "dy", "*", "t", "\n", "}", "\n", "}", "\n\n", "dx", "=", "point", "[", "0", "]", "-", "x", "\n", "dy", "=", "point", "[", "1", "]", "-", "y", "\n\n", "return", "dx", "*", "dx", "+", "dy", "*", "dy", "\n", "}" ]

[ "SquaredDistanceFrom", "does", "NOT", "use", "spherical", "geometry", ".", "It", "finds", "the", "squared", "distance", "from", "the", "line", "using", "standard", "Euclidean", "geometry", "using", "the", "units", "the", "points", "are", "in", "." ]

[ "func", "(", "l", "*", "Line", ")", "GeoDistance", "(", "haversine", "...", "bool", ")", "float64", "{", "return", "l", ".", "a", ".", "GeoDistanceFrom", "(", "&", "l", ".", "b", ",", "yesHaversine", "(", "haversine", ")", ")", "\n", "}" ]

[ "GeoDistance", "computes", "the", "distance", "of", "the", "line", "ie", ".", "its", "length", "using", "spherical", "geometry", "." ]

[ "func", "(", "l", "*", "Line", ")", "Measure", "(", "point", "*", "Point", ")", "float64", "{", "projFactor", ":=", "l", ".", "Project", "(", "point", ")", "\n", "if", "projFactor", "<=", "0.0", "{", "return", "0.0", "\n", "}", "\n", "if", "projFactor", "<=", "1.0", "{", "return", "projFactor", "*", "l", ".", "Distance", "(", ")", "\n", "}", "\n", "// projFactor is > 1", "return", "l", ".", "Distance", "(", ")", "\n", "}" ]

[ "Measure", "returns", "the", "distance", "along", "the", "line", "to", "the", "point", "nearest", "the", "given", "point", ".", "Treats", "the", "line", "as", "a", "line", "segment", "such", "that", "if", "the", "nearest", "point", "is", "an", "endpoint", "of", "the", "line", "the", "function", "will", "return", "0", "or", "1", "as", "appropriate", "." ]

[ "func", "(", "l", "*", "Line", ")", "Interpolate", "(", "percent", "float64", ")", "*", "Point", "{", "return", "&", "Point", "{", "l", ".", "a", "[", "0", "]", "+", "percent", "*", "(", "l", ".", "b", "[", "0", "]", "-", "l", ".", "a", "[", "0", "]", ")", ",", "l", ".", "a", "[", "1", "]", "+", "percent", "*", "(", "l", ".", "b", "[", "1", "]", "-", "l", ".", "a", "[", "1", "]", ")", ",", "}", "\n", "}" ]

[ "Interpolate", "performs", "a", "simple", "linear", "interpolation", "from", "A", "to", "B", ".", "This", "function", "is", "the", "opposite", "of", "Project", "." ]

[ "func", "(", "l", "*", "Line", ")", "Side", "(", "p", "*", "Point", ")", "int", "{", "val", ":=", "(", "l", ".", "b", "[", "0", "]", "-", "l", ".", "a", "[", "0", "]", ")", "*", "(", "p", "[", "1", "]", "-", "l", ".", "b", "[", "1", "]", ")", "-", "(", "l", ".", "b", "[", "1", "]", "-", "l", ".", "a", "[", "1", "]", ")", "*", "(", "p", "[", "0", "]", "-", "l", ".", "b", "[", "0", "]", ")", "\n\n", "if", "val", "<", "0", "{", "return", "1", "// right", "\n", "}", "else", "if", "val", ">", "0", "{", "return", "-", "1", "// left", "\n", "}", "\n\n", "return", "0", "// collinear", "\n", "}" ]

[ "Side", "returns", "1", "if", "the", "point", "is", "on", "the", "right", "side", "-", "1", "if", "on", "the", "left", "side", "and", "0", "if", "collinear", "." ]

[ "func", "(", "l", "*", "Line", ")", "Midpoint", "(", ")", "*", "Point", "{", "return", "&", "Point", "{", "(", "l", ".", "a", "[", "0", "]", "+", "l", ".", "b", "[", "0", "]", ")", "/", "2", ",", "(", "l", ".", "a", "[", "1", "]", "+", "l", ".", "b", "[", "1", "]", ")", "/", "2", "}", "\n", "}" ]

[ "Midpoint", "returns", "the", "Euclidean", "midpoint", "of", "the", "line", "." ]

[ "func", "(", "l", "*", "Line", ")", "GeoMidpoint", "(", ")", "*", "Point", "{", "p", ":=", "&", "Point", "{", "}", "\n\n", "dLng", ":=", "deg2rad", "(", "l", ".", "b", ".", "Lng", "(", ")", "-", "l", ".", "a", ".", "Lng", "(", ")", ")", "\n\n", "aLatRad", ":=", "deg2rad", "(", "l", ".", "a", ".", "Lat", "(", ")", ")", "\n", "bLatRad", ":=", "deg2rad", "(", "l", ".", "b", ".", "Lat", "(", ")", ")", "\n\n", "x", ":=", "math", ".", "Cos", "(", "bLatRad", ")", "*", "math", ".", "Cos", "(", "dLng", ")", "\n", "y", ":=", "math", ".", "Cos", "(", "bLatRad", ")", "*", "math", ".", "Sin", "(", "dLng", ")", "\n\n", "p", ".", "SetLat", "(", "math", ".", "Atan2", "(", "math", ".", "Sin", "(", "aLatRad", ")", "+", "math", ".", "Sin", "(", "bLatRad", ")", ",", "math", ".", "Sqrt", "(", "(", "math", ".", "Cos", "(", "aLatRad", ")", "+", "x", ")", "*", "(", "math", ".", "Cos", "(", "aLatRad", ")", "+", "x", ")", "+", "y", "*", "y", ")", ")", ")", "\n", "p", ".", "SetLng", "(", "deg2rad", "(", "l", ".", "a", ".", "Lng", "(", ")", ")", "+", "math", ".", "Atan2", "(", "y", ",", "math", ".", "Cos", "(", "aLatRad", ")", "+", "x", ")", ")", "\n\n", "// convert back to degrees", "p", ".", "SetLat", "(", "rad2deg", "(", "p", ".", "Lat", "(", ")", ")", ")", "\n", "p", ".", "SetLng", "(", "rad2deg", "(", "p", ".", "Lng", "(", ")", ")", ")", "\n\n", "return", "p", "\n", "}" ]

[ "GeoMidpoint", "returns", "the", "half", "-", "way", "point", "along", "a", "great", "circle", "path", "between", "the", "two", "points", "." ]

[ "func", "(", "l", "*", "Line", ")", "Bound", "(", ")", "*", "Bound", "{", "return", "NewBound", "(", "math", ".", "Max", "(", "l", ".", "a", "[", "0", "]", ",", "l", ".", "b", "[", "0", "]", ")", ",", "math", ".", "Min", "(", "l", ".", "a", "[", "0", "]", ",", "l", ".", "b", "[", "0", "]", ")", ",", "math", ".", "Max", "(", "l", ".", "a", "[", "1", "]", ",", "l", ".", "b", "[", "1", "]", ")", ",", "math", ".", "Min", "(", "l", ".", "a", "[", "1", "]", ",", "l", ".", "b", "[", "1", "]", ")", ")", "\n", "}" ]

[ "Bound", "returns", "a", "bound", "around", "the", "line", ".", "Simply", "uses", "rectangular", "coordinates", "." ]

[ "func", "(", "l", "*", "Line", ")", "Reverse", "(", ")", "*", "Line", "{", "l", ".", "a", ",", "l", ".", "b", "=", "l", ".", "b", ",", "l", ".", "a", "\n", "return", "l", "\n", "}" ]

[ "Reverse", "swaps", "the", "start", "and", "end", "of", "the", "line", "." ]

[ "func", "(", "l", "*", "Line", ")", "Equals", "(", "line", "*", "Line", ")", "bool", "{", "return", "(", "l", ".", "a", ".", "Equals", "(", "&", "line", ".", "a", ")", "&&", "l", ".", "b", ".", "Equals", "(", "&", "line", ".", "b", ")", ")", "||", "(", "l", ".", "a", ".", "Equals", "(", "&", "line", ".", "b", ")", "&&", "l", ".", "b", ".", "Equals", "(", "&", "line", ".", "a", ")", ")", "\n", "}" ]

[ "Equals", "returns", "the", "line", "equality", "and", "is", "irrespective", "of", "direction", "i", ".", "e", ".", "true", "if", "one", "is", "the", "reverse", "of", "the", "other", "." ]

[ "func", "(", "l", "*", "Line", ")", "ToGeoJSON", "(", ")", "*", "geojson", ".", "Feature", "{", "return", "geojson", ".", "NewLineStringFeature", "(", "[", "]", "[", "]", "float64", "{", "{", "l", ".", "a", "[", "0", "]", ",", "l", ".", "a", "[", "1", "]", "}", ",", "{", "l", ".", "b", "[", "0", "]", ",", "l", ".", "b", "[", "1", "]", "}", ",", "}", ")", "\n", "}" ]

[ "ToGeoJSON", "creates", "a", "new", "geojson", "feature", "with", "a", "linestring", "geometry", "containing", "the", "two", "points", "." ]

[ "func", "(", "r", "DouglasPeuckerReducer", ")", "Reduce", "(", "path", "*", "geo", ".", "Path", ")", "*", "geo", ".", "Path", "{", "return", "DouglasPeucker", "(", "path", ",", "r", ".", "Threshold", ")", "\n", "}" ]

[ "Reduce", "runs", "the", "DouglasPeucker", "using", "the", "threshold", "of", "the", "DouglasPeuckerReducer", "." ]

[ "func", "DouglasPeucker", "(", "path", "*", "geo", ".", "Path", ",", "threshold", "float64", ")", "*", "geo", ".", "Path", "{", "if", "path", ".", "Length", "(", ")", "<=", "2", "{", "return", "path", ".", "Clone", "(", ")", "\n", "}", "\n\n", "mask", ":=", "make", "(", "[", "]", "byte", ",", "path", ".", "Length", "(", ")", ")", "\n", "mask", "[", "0", "]", "=", "1", "\n", "mask", "[", "path", ".", "Length", "(", ")", "-", "1", "]", "=", "1", "\n\n", "points", ":=", "path", ".", "Points", "(", ")", "\n\n", "found", ":=", "dpWorker", "(", "points", ",", "threshold", ",", "mask", ")", "\n", "newPoints", ":=", "make", "(", "[", "]", "geo", ".", "Point", ",", "0", ",", "found", ")", "\n\n", "for", "i", ",", "v", ":=", "range", "mask", "{", "if", "v", "==", "1", "{", "newPoints", "=", "append", "(", "newPoints", ",", "points", "[", "i", "]", ")", "\n", "}", "\n", "}", "\n\n", "return", "(", "&", "geo", ".", "Path", "{", "}", ")", ".", "SetPoints", "(", "newPoints", ")", "\n", "}" ]

[ "DouglasPeucker", "simplifies", "the", "path", "using", "the", "Douglas", "Peucker", "method", ".", "Returns", "a", "new", "path", "and", "DOES", "NOT", "modify", "the", "original", "." ]

[ "func", "DouglasPeuckerIndexMap", "(", "path", "*", "geo", ".", "Path", ",", "threshold", "float64", ")", "(", "reduced", "*", "geo", ".", "Path", ",", "indexMap", "[", "]", "int", ")", "{", "if", "path", ".", "Length", "(", ")", "==", "0", "{", "return", "path", ".", "Clone", "(", ")", ",", "[", "]", "int", "{", "}", "\n", "}", "\n\n", "if", "path", ".", "Length", "(", ")", "==", "1", "{", "return", "path", ".", "Clone", "(", ")", ",", "[", "]", "int", "{", "0", "}", "\n", "}", "\n\n", "if", "path", ".", "Length", "(", ")", "==", "2", "{", "return", "path", ".", "Clone", "(", ")", ",", "[", "]", "int", "{", "0", ",", "1", "}", "\n", "}", "\n\n", "mask", ":=", "make", "(", "[", "]", "byte", ",", "path", ".", "Length", "(", ")", ")", "\n", "mask", "[", "0", "]", "=", "1", "\n", "mask", "[", "path", ".", "Length", "(", ")", "-", "1", "]", "=", "1", "\n\n", "originalPoints", ":=", "path", ".", "Points", "(", ")", "\n\n", "found", ":=", "dpWorker", "(", "originalPoints", ",", "threshold", ",", "mask", ")", "\n\n", "points", ":=", "make", "(", "[", "]", "geo", ".", "Point", ",", "0", ",", "found", ")", "\n", "for", "i", ",", "v", ":=", "range", "mask", "{", "if", "v", "==", "1", "{", "points", "=", "append", "(", "points", ",", "originalPoints", "[", "i", "]", ")", "\n", "indexMap", "=", "append", "(", "indexMap", ",", "i", ")", "\n", "}", "\n", "}", "\n\n", "reduced", "=", "&", "geo", ".", "Path", "{", "}", "\n", "return", "reduced", ".", "SetPoints", "(", "points", ")", ",", "indexMap", "\n", "}" ]

[ "DouglasPeuckerIndexMap", "is", "similar", "to", "DouglasPeucker", "but", "returns", "an", "array", "that", "maps", "each", "new", "path", "index", "to", "its", "original", "path", "index", ".", "Returns", "a", "new", "path", "and", "DOES", "NOT", "modify", "the", "original", "." ]

[ "func", "DouglasPeuckerGeoIndexMap", "(", "path", "*", "geo", ".", "Path", ",", "meters", "float64", ")", "(", "reduced", "*", "geo", ".", "Path", ",", "indexMap", "[", "]", "int", ")", "{", "if", "path", ".", "Length", "(", ")", "==", "0", "{", "return", "path", ".", "Clone", "(", ")", ",", "[", "]", "int", "{", "}", "\n", "}", "\n\n", "if", "path", ".", "Length", "(", ")", "==", "1", "{", "return", "path", ".", "Clone", "(", ")", ",", "[", "]", "int", "{", "0", "}", "\n", "}", "\n\n", "if", "path", ".", "Length", "(", ")", "==", "2", "{", "return", "path", ".", "Clone", "(", ")", ",", "[", "]", "int", "{", "0", ",", "1", "}", "\n", "}", "\n\n", "mask", ":=", "make", "(", "[", "]", "byte", ",", "path", ".", "Length", "(", ")", ")", "\n", "mask", "[", "0", "]", "=", "1", "\n", "mask", "[", "path", ".", "Length", "(", ")", "-", "1", "]", "=", "1", "\n\n", "factor", ":=", "geo", ".", "MercatorScaleFactor", "(", "path", ".", "Bound", "(", ")", ".", "Center", "(", ")", ".", "Lat", "(", ")", ")", "\n", "originalPoints", ":=", "path", ".", "Clone", "(", ")", ".", "Transform", "(", "geo", ".", "Mercator", ".", "Project", ")", ".", "Points", "(", ")", "\n", "found", ":=", "dpWorker", "(", "originalPoints", ",", "meters", "*", "factor", ",", "mask", ")", "\n\n", "points", ":=", "make", "(", "[", "]", "geo", ".", "Point", ",", "0", ",", "found", ")", "\n", "for", "i", ",", "v", ":=", "range", "mask", "{", "if", "v", "==", "1", "{", "points", "=", "append", "(", "points", ",", "originalPoints", "[", "i", "]", ")", "\n", "indexMap", "=", "append", "(", "indexMap", ",", "i", ")", "\n", "}", "\n", "}", "\n\n", "reduced", "=", "&", "geo", ".", "Path", "{", "}", "\n", "reduced", ".", "SetPoints", "(", "points", ")", "\n", "reduced", ".", "Transform", "(", "geo", ".", "Mercator", ".", "Inverse", ")", "\n", "return", "reduced", ",", "indexMap", "\n", "}" ]

[ "DouglasPeuckerGeoIndexMap", "is", "similar", "to", "GeoReduce", "but", "returns", "an", "array", "that", "maps", "each", "new", "path", "index", "to", "its", "original", "path", "index", ".", "Returns", "a", "new", "path", "and", "DOES", "NOT", "modify", "the", "original", "." ]

[ "func", "(", "p", "*", "Path", ")", "Resample", "(", "totalPoints", "int", ")", "*", "Path", "{", "if", "totalPoints", "<=", "0", "{", "p", ".", "PointSet", "=", "make", "(", "[", "]", "Point", ",", "0", ")", "\n", "return", "p", "\n", "}", "\n\n", "if", "p", ".", "resampleEdgeCases", "(", "totalPoints", ")", "{", "return", "p", "\n", "}", "\n\n", "// precomputes the total distance and intermediate distances", "total", ",", "dists", ":=", "precomputeDistances", "(", "p", ".", "PointSet", ")", "\n", "p", ".", "resample", "(", "dists", ",", "total", ",", "totalPoints", ")", "\n", "return", "p", "\n", "}" ]

[ "Resample", "converts", "the", "path", "into", "totalPoints", "-", "1", "evenly", "spaced", "segments", ".", "Assumes", "euclidean", "geometry", "." ]

[ "func", "(", "p", "*", "Path", ")", "ResampleWithInterval", "(", "dist", "float64", ")", "*", "Path", "{", "if", "dist", "<=", "0", "{", "p", ".", "PointSet", "=", "make", "(", "[", "]", "Point", ",", "0", ")", "\n", "return", "p", "\n", "}", "\n\n", "// precomputes the total distance and intermediate distances", "total", ",", "dists", ":=", "precomputeDistances", "(", "p", ".", "PointSet", ")", "\n\n", "totalPoints", ":=", "int", "(", "total", "/", "dist", ")", "+", "1", "\n", "if", "p", ".", "resampleEdgeCases", "(", "totalPoints", ")", "{", "return", "p", "\n", "}", "\n\n", "p", ".", "resample", "(", "dists", ",", "total", ",", "totalPoints", ")", "\n", "return", "p", "\n", "}" ]

[ "ResampleWithInterval", "coverts", "the", "path", "into", "evenly", "spaced", "points", "of", "about", "the", "given", "distance", ".", "The", "total", "distance", "is", "computed", "using", "euclidean", "geometry", "and", "then", "divided", "by", "the", "given", "distance", "to", "get", "the", "number", "of", "segments", "." ]

[ "func", "(", "p", "*", "Path", ")", "resampleEdgeCases", "(", "totalPoints", "int", ")", "bool", "{", "// degenerate case", "if", "len", "(", "p", ".", "PointSet", ")", "<=", "1", "{", "return", "true", "\n", "}", "\n\n", "// if all the points are the same, treat as special case.", "equal", ":=", "true", "\n", "for", "_", ",", "point", ":=", "range", "p", ".", "PointSet", "{", "if", "!", "p", ".", "PointSet", "[", "0", "]", ".", "Equals", "(", "&", "point", ")", "{", "equal", "=", "false", "\n", "break", "\n", "}", "\n", "}", "\n\n", "if", "equal", "{", "if", "totalPoints", ">", "p", ".", "Length", "(", ")", "{", "// extend to be requested length", "for", "p", ".", "Length", "(", ")", "!=", "totalPoints", "{", "p", ".", "PointSet", "=", "append", "(", "p", ".", "PointSet", ",", "p", ".", "PointSet", "[", "0", "]", ")", "\n", "}", "\n\n", "return", "true", "\n", "}", "\n\n", "// contract to be requested length", "p", ".", "PointSet", "=", "p", ".", "PointSet", "[", ":", "totalPoints", "]", "\n", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "resampleEdgeCases", "is", "used", "to", "handle", "edge", "case", "for", "resampling", "like", "not", "enough", "points", "and", "the", "path", "is", "all", "the", "same", "point", ".", "will", "return", "nil", "if", "there", "are", "no", "edge", "cases", ".", "If", "return", "true", "if", "one", "of", "these", "edge", "cases", "was", "found", "and", "handled", "." ]

[ "func", "(", "s", "Sortable", ")", "Less", "(", "i", ",", "j", "int", ")", "bool", "{", "return", "len", "(", "s", "[", "i", "]", ".", "Pointers", ")", ">", "len", "(", "s", "[", "j", "]", ".", "Pointers", ")", "\n\n", "}" ]

[ "Less", "returns", "truee", "if", "i", ">", "j", "so", "bigger", "will", "be", "first", ".", "This", "is", "to", "implement", "the", "sort", "interface", "." ]

[ "func", "(", "s", "Sortable", ")", "Swap", "(", "i", ",", "j", "int", ")", "{", "s", "[", "i", "]", ",", "s", "[", "j", "]", "=", "s", "[", "j", "]", ",", "s", "[", "i", "]", "\n", "}" ]

[ "Swap", "interchanges", "two", "elements", ".", "This", "is", "to", "implement", "the", "sort", "interface", "." ]

[ "func", "(", "r", "RadialReducer", ")", "Reduce", "(", "path", "*", "geo", ".", "Path", ")", "*", "geo", ".", "Path", "{", "return", "Radial", "(", "path", ",", "r", ".", "Threshold", ")", "\n", "}" ]

[ "Reduce", "runs", "the", "Radial", "reduction", "using", "the", "threshold", "of", "the", "RadialReducer", "." ]

[ "func", "(", "r", "RadialGeoReducer", ")", "Reduce", "(", "path", "*", "geo", ".", "Path", ")", "*", "geo", ".", "Path", "{", "return", "RadialGeo", "(", "path", ",", "r", ".", "Threshold", ")", "\n", "}" ]

[ "Reduce", "runs", "the", "RadialGeo", "reduction", "using", "the", "threshold", "of", "the", "RadialGeoReducer", ".", "The", "threshold", "is", "expected", "to", "be", "in", "meters", "." ]

[ "func", "Radial", "(", "path", "*", "geo", ".", "Path", ",", "meters", "float64", ")", "*", "geo", ".", "Path", "{", "p", ",", "_", ":=", "radialCore", "(", "path", ",", "meters", "*", "meters", ",", "squaredDistance", ",", "false", ")", "\n", "return", "p", "\n", "}" ]

[ "Radial", "peforms", "a", "radial", "distance", "polyline", "simplification", "using", "a", "standard", "euclidean", "distance", ".", "Returns", "a", "new", "path", "and", "DOES", "NOT", "modify", "the", "original", "." ]

[ "func", "RadialIndexMap", "(", "path", "*", "geo", ".", "Path", ",", "meters", "float64", ")", "(", "*", "geo", ".", "Path", ",", "[", "]", "int", ")", "{", "return", "radialCore", "(", "path", ",", "meters", "*", "meters", ",", "squaredDistance", ",", "true", ")", "\n", "}" ]

[ "RadialIndexMap", "is", "similar", "to", "Radial", "but", "returns", "an", "array", "that", "maps", "each", "new", "path", "index", "to", "its", "original", "path", "index", ".", "Returns", "a", "new", "path", "and", "DOES", "NOT", "modify", "the", "original", "." ]

[ "func", "RadialGeoIndexMap", "(", "path", "*", "geo", ".", "Path", ",", "meters", "float64", ")", "(", "*", "geo", ".", "Path", ",", "[", "]", "int", ")", "{", "return", "radialCore", "(", "path", ",", "meters", ",", "geoDistance", ",", "true", ")", "\n", "}" ]

[ "RadialGeoIndexMap", "is", "similar", "to", "RadialGeo", "but", "returns", "an", "array", "that", "maps", "each", "new", "path", "index", "to", "its", "original", "path", "index", ".", "Returns", "a", "new", "path", "and", "DOES", "NOT", "modify", "the", "original", "." ]

[ "func", "(", "s", "*", "state", ")", "ResetDistances", "(", "into", ",", "from", "int", ")", "{", "// since the center of into changed, need to update the distance to anything linked to this one.", "for", "k", ":=", "range", "s", ".", "Distances", "[", "into", "]", ".", "Distances", "{", "if", "k", "==", "into", "{", "continue", "\n", "}", "\n\n", "dist", ":=", "s", ".", "DistanceFunc", "(", "into", ",", "k", ")", "\n\n", "s", ".", "Distances", "[", "into", "]", ".", "Set", "(", "k", ",", "dist", ")", "\n", "s", ".", "Distances", "[", "k", "]", ".", "Set", "(", "into", ",", "dist", ")", "\n", "}", "\n\n", "// we are merging from into into.", "// so any links with from need to be links with into.", "// any links into from need to be deleted", "// we no longer need the distance info of from", "for", "k", ":=", "range", "s", ".", "Distances", "[", "from", "]", ".", "Distances", "{", "if", "k", "==", "from", "||", "k", "==", "into", "{", "continue", "\n", "}", "\n\n", "dist", ":=", "s", ".", "DistanceFunc", "(", "into", ",", "k", ")", "\n\n", "s", ".", "Distances", "[", "into", "]", ".", "Set", "(", "k", ",", "dist", ")", "\n", "s", ".", "Distances", "[", "k", "]", ".", "Set", "(", "into", ",", "dist", ")", "\n\n", "s", ".", "Distances", "[", "k", "]", ".", "Delete", "(", "from", ")", "\n", "}", "\n\n", "s", ".", "Distances", "[", "from", "]", "=", "nil", "\n", "s", ".", "Distances", "[", "into", "]", ".", "Delete", "(", "from", ")", "\n", "}" ]

[ "ResetDistances", "makes", "sure", "the", "distance", "map", "is", "up", "to", "date", "given", "the", "recent", "merge", "of", "clusters", "." ]

[ "func", "(", "s", "*", "state", ")", "MinDistance", "(", ")", "(", "a", ",", "b", "int", ",", "dist", "float64", ")", "{", "dist", "=", "math", ".", "MaxFloat64", "\n\n", "for", "i", ",", "ds", ":=", "range", "s", ".", "Distances", "{", "if", "ds", "==", "nil", "{", "continue", "\n", "}", "\n\n", "if", "ds", ".", "MinDistance", "<", "dist", "{", "dist", "=", "ds", ".", "MinDistance", "\n\n", "a", "=", "i", "\n", "b", "=", "ds", ".", "MinIndex", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "MinDistance", "returns", "the", "link", "with", "minimum", "distance", ".", "a", "is", "the", "index", "stored", "on", "the", "DistanceSet", "b", "is", "the", "index", "of", "the", "smallest", "values", "." ]

[ "func", "MergeIndexMaps", "(", "map1", ",", "map2", "[", "]", "int", ")", "[", "]", "int", "{", "result", ":=", "make", "(", "[", "]", "int", ",", "len", "(", "map2", ")", ")", "\n", "for", "i", ",", "v", ":=", "range", "map2", "{", "result", "[", "i", "]", "=", "map1", "[", "v", "]", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "MergeIndexMaps", "merges", "two", "index", "maps", "for", "use", "when", "chaining", "reducers", ".", "For", "example", "to", "radially", "reduce", "and", "then", "DP", "merge", "the", "index", "maps", "with", "this", "function", "to", "get", "a", "map", "from", "the", "original", "to", "the", "final", "path", "." ]

[ "func", "ClusterPointers", "(", "pointers", "[", "]", "geo", ".", "Pointer", ",", "distancer", "ClusterDistancer", ",", "threshold", "float64", ")", "[", "]", "*", "Cluster", "{", "clusters", ":=", "make", "(", "[", "]", "*", "Cluster", ",", "0", ",", "len", "(", "pointers", ")", ")", "\n", "for", "_", ",", "p", ":=", "range", "pointers", "{", "clusters", "=", "append", "(", "clusters", ",", "NewCluster", "(", "p", ")", ")", "\n", "}", "\n\n", "return", "cluster", "(", "clusters", ",", "distancer", ",", "threshold", ")", "\n", "}" ]

[ "ClusterPointers", "will", "take", "a", "set", "of", "Pointers", "and", "cluster", "them", "using", "the", "distancer", "and", "threshold", "." ]

[ "func", "ClusterClusters", "(", "clusters", "[", "]", "*", "Cluster", ",", "distancer", "ClusterDistancer", ",", "threshold", "float64", ")", "[", "]", "*", "Cluster", "{", "copiedClusters", ":=", "make", "(", "[", "]", "*", "Cluster", ",", "len", "(", "clusters", ")", ",", "len", "(", "clusters", ")", ")", "\n", "copy", "(", "copiedClusters", ",", "clusters", ")", "\n\n", "return", "cluster", "(", "copiedClusters", ",", "distancer", ",", "threshold", ")", "\n", "}" ]

[ "ClusterClusters", "can", "be", "used", "if", "you", "ve", "already", "created", "cluster", "objects", "using", "a", "prefilterer", "of", "something", "else", ".", "Original", "clusters", "will", "be", "copied", "so", "the", "original", "set", "will", "be", "unchanged", "." ]

[ "func", "cluster", "(", "clusters", "[", "]", "*", "Cluster", ",", "distancer", "ClusterDistancer", ",", "threshold", "float64", ")", "[", "]", "*", "Cluster", "{", "if", "len", "(", "clusters", ")", "<", "2", "{", "return", "clusters", "\n", "}", "\n\n", "count", ":=", "0", "\n", "for", "_", ",", "cluster", ":=", "range", "clusters", "{", "count", "+=", "len", "(", "cluster", ".", "Pointers", ")", "\n", "}", "\n\n", "clusters", ",", "found", ":=", "clusterClusters", "(", "clusters", ",", "// Default initialization, TODO: better bucketing/prefiltering will greatly increase performance.", "initClusterDistances", "(", "clusters", ",", "distancer", ",", "threshold", ")", ",", "distancer", ",", "threshold", ",", ")", "\n\n", "result", ":=", "make", "(", "[", "]", "*", "Cluster", ",", "0", ",", "found", ")", "\n", "for", "_", ",", "cluster", ":=", "range", "clusters", "{", "if", "cluster", "!=", "nil", "{", "result", "=", "append", "(", "result", ",", "cluster", ")", "\n", "}", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "cluster", "will", "modify", "the", "passed", "in", "clusters", "centroid", "and", "list", "of", "pointers", "so", "a", "copy", "must", "have", "been", "made", "before", "reaching", "this", "function", "." ]

[ "func", "ClusterGeoPointers", "(", "pointers", "[", "]", "geo", ".", "Pointer", ",", "threshold", "float64", ")", "[", "]", "*", "Cluster", "{", "clusters", ":=", "make", "(", "[", "]", "*", "Cluster", ",", "0", ",", "len", "(", "pointers", ")", ")", "\n", "for", "_", ",", "p", ":=", "range", "pointers", "{", "clusters", "=", "append", "(", "clusters", ",", "NewCluster", "(", "p", ")", ")", "\n", "}", "\n\n", "if", "len", "(", "clusters", ")", "<", "2", "{", "return", "clusters", "\n", "}", "\n\n", "// performs the actual clustering", "return", "geocluster", "(", "clusters", ",", "threshold", ")", "\n", "}" ]

[ "ClusterGeoPointers", "will", "take", "a", "set", "of", "Pointers", "and", "cluster", "them", ".", "It", "will", "project", "the", "points", "using", "mercator", "scale", "the", "threshold", "cluster", "and", "project", "back", ".", "Performace", "is", "about", "40%", "than", "simply", "using", "a", "geo", "distancer", ".", "This", "may", "not", "make", "sense", "for", "all", "geo", "datasets", "." ]

[ "func", "ClusterGeoClusters", "(", "clusters", "[", "]", "*", "Cluster", ",", "threshold", "float64", ")", "[", "]", "*", "Cluster", "{", "if", "len", "(", "clusters", ")", "<", "2", "{", "return", "clusters", "\n", "}", "\n\n", "copiedClusters", ":=", "make", "(", "[", "]", "*", "Cluster", ",", "len", "(", "clusters", ")", ",", "len", "(", "clusters", ")", ")", "\n", "for", "i", ",", "cluster", ":=", "range", "clusters", "{", "copiedClusters", "[", "i", "]", "=", "NewClusterWithCentroid", "(", "cluster", ".", "Centroid", ",", "cluster", ".", "Pointers", "...", ")", "\n", "}", "\n\n", "return", "geocluster", "(", "copiedClusters", ",", "threshold", ")", "\n", "}" ]

[ "ClusterGeoClusters", "can", "be", "used", "if", "you", "ve", "already", "created", "clusters", "objects", "using", "a", "prefilterer", "of", "something", "else", "." ]

[ "func", "geocluster", "(", "clusters", "[", "]", "*", "Cluster", ",", "threshold", "float64", ")", "[", "]", "*", "Cluster", "{", "if", "len", "(", "clusters", ")", "<", "2", "{", "return", "clusters", "\n", "}", "\n\n", "bound", ":=", "geo", ".", "NewBoundFromPoints", "(", "clusters", "[", "0", "]", ".", "Centroid", ",", "clusters", "[", "0", "]", ".", "Centroid", ")", "\n", "for", "_", ",", "cluster", ":=", "range", "clusters", "{", "bound", ".", "Extend", "(", "cluster", ".", "Centroid", ")", "\n", "geo", ".", "Mercator", ".", "Project", "(", "cluster", ".", "Centroid", ")", "\n", "}", "\n\n", "factor", ":=", "geo", ".", "MercatorScaleFactor", "(", "bound", ".", "Center", "(", ")", ".", "Lat", "(", ")", ")", "\n", "scaledThreshold", ":=", "threshold", "*", "threshold", "*", "factor", "*", "factor", "\n\n", "clusteredClusters", ",", "found", ":=", "clusterClusters", "(", "clusters", ",", "// Default initialization, TODO: better bucketing/prefiltering will greatly increase performance.", "// can use the bound above to help with this.", "initClusterDistances", "(", "clusters", ",", "CentroidSquaredDistance", "{", "}", ",", "scaledThreshold", ")", ",", "CentroidSquaredDistance", "{", "}", ",", "scaledThreshold", ",", ")", "\n\n", "result", ":=", "make", "(", "[", "]", "*", "Cluster", ",", "0", ",", "found", ")", "\n", "for", "_", ",", "cluster", ":=", "range", "clusteredClusters", "{", "if", "cluster", "!=", "nil", "{", "geo", ".", "Mercator", ".", "Inverse", "(", "cluster", ".", "Centroid", ")", "\n", "result", "=", "append", "(", "result", ",", "cluster", ")", "\n", "}", "\n", "}", "\n\n", "return", "result", "\n", "}" ]

[ "will", "modify", "the", "passed", "in", "clusters", "centroid", "and", "list", "of", "pathers", "so", "a", "copy", "must", "have", "been", "made", "before", "reaching", "this", "function", "." ]

[ "func", "NewPointFromQuadkeyString", "(", "key", "string", ")", "*", "Point", "{", "i", ",", "_", ":=", "strconv", ".", "ParseInt", "(", "key", ",", "4", ",", "64", ")", "\n", "return", "NewPointFromQuadkey", "(", "i", ",", "len", "(", "key", ")", ")", "\n", "}" ]

[ "NewPointFromQuadkeyString", "creates", "a", "new", "point", "from", "a", "quadkey", "string", "." ]

[ "func", "NewPointFromGeoHash", "(", "hash", "string", ")", "*", "Point", "{", "west", ",", "east", ",", "south", ",", "north", ":=", "geoHash2ranges", "(", "hash", ")", "\n", "return", "NewPoint", "(", "(", "west", "+", "east", ")", "/", "2.0", ",", "(", "north", "+", "south", ")", "/", "2.0", ")", "\n", "}" ]

[ "NewPointFromGeoHash", "creates", "a", "new", "point", "at", "the", "center", "of", "the", "geohash", "range", "." ]

[ "func", "NewPointFromGeoHashInt64", "(", "hash", "int64", ",", "bits", "int", ")", "*", "Point", "{", "west", ",", "east", ",", "south", ",", "north", ":=", "geoHashInt2ranges", "(", "hash", ",", "bits", ")", "\n", "return", "NewPoint", "(", "(", "west", "+", "east", ")", "/", "2.0", ",", "(", "north", "+", "south", ")", "/", "2.0", ")", "\n", "}" ]

[ "NewPointFromGeoHashInt64", "creates", "a", "new", "point", "at", "the", "center", "of", "the", "integer", "version", "of", "a", "geohash", "range", ".", "bits", "indicates", "the", "precision", "of", "the", "hash", "." ]

[ "func", "(", "p", "*", "Point", ")", "DistanceFrom", "(", "point", "*", "Point", ")", "float64", "{", "d0", ":=", "(", "point", "[", "0", "]", "-", "p", "[", "0", "]", ")", "\n", "d1", ":=", "(", "point", "[", "1", "]", "-", "p", "[", "1", "]", ")", "\n", "return", "math", ".", "Sqrt", "(", "d0", "*", "d0", "+", "d1", "*", "d1", ")", "\n", "}" ]

[ "DistanceFrom", "returns", "the", "Euclidean", "distance", "between", "the", "points", "." ]

[ "func", "(", "p", "*", "Point", ")", "SquaredDistanceFrom", "(", "point", "*", "Point", ")", "float64", "{", "d0", ":=", "(", "point", "[", "0", "]", "-", "p", "[", "0", "]", ")", "\n", "d1", ":=", "(", "point", "[", "1", "]", "-", "p", "[", "1", "]", ")", "\n", "return", "d0", "*", "d0", "+", "d1", "*", "d1", "\n", "}" ]

[ "SquaredDistanceFrom", "returns", "the", "squared", "Euclidean", "distance", "between", "the", "points", ".", "This", "avoids", "a", "sqrt", "computation", "." ]

[ "func", "(", "p", "*", "Point", ")", "GeoDistanceFrom", "(", "point", "*", "Point", ",", "haversine", "...", "bool", ")", "float64", "{", "dLat", ":=", "deg2rad", "(", "point", ".", "Lat", "(", ")", "-", "p", ".", "Lat", "(", ")", ")", "\n", "dLng", ":=", "math", ".", "Abs", "(", "deg2rad", "(", "point", ".", "Lng", "(", ")", "-", "p", ".", "Lng", "(", ")", ")", ")", "\n\n", "if", "yesHaversine", "(", "haversine", ")", "{", "// yes trig functions", "dLat2Sin", ":=", "math", ".", "Sin", "(", "dLat", "/", "2", ")", "\n", "dLng2Sin", ":=", "math", ".", "Sin", "(", "dLng", "/", "2", ")", "\n", "a", ":=", "dLat2Sin", "*", "dLat2Sin", "+", "math", ".", "Cos", "(", "deg2rad", "(", "p", ".", "Lat", "(", ")", ")", ")", "*", "math", ".", "Cos", "(", "deg2rad", "(", "point", ".", "Lat", "(", ")", ")", ")", "*", "dLng2Sin", "*", "dLng2Sin", "\n\n", "return", "2.0", "*", "EarthRadius", "*", "math", ".", "Atan2", "(", "math", ".", "Sqrt", "(", "a", ")", ",", "math", ".", "Sqrt", "(", "1", "-", "a", ")", ")", "\n", "}", "\n\n", "if", "dLng", ">", "math", ".", "Pi", "{", "dLng", "=", "2", "*", "math", ".", "Pi", "-", "dLng", "\n", "}", "\n\n", "// fast way using pythagorean theorem on an equirectangular projection", "x", ":=", "dLng", "*", "math", ".", "Cos", "(", "deg2rad", "(", "(", "p", ".", "Lat", "(", ")", "+", "point", ".", "Lat", "(", ")", ")", "/", "2.0", ")", ")", "\n", "return", "math", ".", "Sqrt", "(", "dLat", "*", "dLat", "+", "x", "*", "x", ")", "*", "EarthRadius", "\n", "}" ]

[ "GeoDistanceFrom", "returns", "the", "geodesic", "distance", "in", "meters", "." ]

[ "func", "(", "p", "*", "Point", ")", "BearingTo", "(", "point", "*", "Point", ")", "float64", "{", "dLng", ":=", "deg2rad", "(", "point", ".", "Lng", "(", ")", "-", "p", ".", "Lng", "(", ")", ")", "\n\n", "pLatRad", ":=", "deg2rad", "(", "p", ".", "Lat", "(", ")", ")", "\n", "pointLatRad", ":=", "deg2rad", "(", "point", ".", "Lat", "(", ")", ")", "\n\n", "y", ":=", "math", ".", "Sin", "(", "dLng", ")", "*", "math", ".", "Cos", "(", "pointLatRad", ")", "\n", "x", ":=", "math", ".", "Cos", "(", "pLatRad", ")", "*", "math", ".", "Sin", "(", "pointLatRad", ")", "-", "math", ".", "Sin", "(", "pLatRad", ")", "*", "math", ".", "Cos", "(", "pointLatRad", ")", "*", "math", ".", "Cos", "(", "dLng", ")", "\n\n", "return", "rad2deg", "(", "math", ".", "Atan2", "(", "y", ",", "x", ")", ")", "\n", "}" ]

[ "BearingTo", "computes", "the", "direction", "one", "must", "start", "traveling", "on", "earth", "to", "be", "heading", "to", "the", "given", "point", "." ]

[ "func", "(", "p", "*", "Point", ")", "GeoHashInt64", "(", "bits", "int", ")", "(", "hash", "int64", ")", "{", "// This code was inspired by https://github.com/broady/gogeohash", "latMin", ",", "latMax", ":=", "-", "90.0", ",", "90.0", "\n", "lngMin", ",", "lngMax", ":=", "-", "180.0", ",", "180.0", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "bits", ";", "i", "++", "{", "hash", "<<=", "1", "\n\n", "// interleave bits", "if", "i", "%", "2", "==", "0", "{", "mid", ":=", "(", "lngMin", "+", "lngMax", ")", "/", "2.0", "\n", "if", "p", "[", "0", "]", ">", "mid", "{", "lngMin", "=", "mid", "\n", "hash", "|=", "1", "\n", "}", "else", "{", "lngMax", "=", "mid", "\n", "}", "\n", "}", "else", "{", "mid", ":=", "(", "latMin", "+", "latMax", ")", "/", "2.0", "\n", "if", "p", "[", "1", "]", ">", "mid", "{", "latMin", "=", "mid", "\n", "hash", "|=", "1", "\n", "}", "else", "{", "latMax", "=", "mid", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "\n", "}" ]

[ "GeoHashInt64", "returns", "the", "integer", "version", "of", "the", "geohash", "down", "to", "the", "given", "number", "of", "bits", ".", "The", "main", "usecase", "for", "this", "function", "is", "to", "be", "able", "to", "do", "integer", "based", "ordering", "of", "points", ".", "In", "that", "case", "the", "number", "of", "bits", "should", "be", "the", "same", "for", "all", "encodings", "." ]

[ "func", "(", "p", "*", "Point", ")", "Add", "(", "point", "*", "Point", ")", "*", "Point", "{", "p", "[", "0", "]", "+=", "point", "[", "0", "]", "\n", "p", "[", "1", "]", "+=", "point", "[", "1", "]", "\n\n", "return", "p", "\n", "}" ]

[ "Add", "a", "point", "to", "the", "given", "point", "." ]

[ "func", "(", "p", "*", "Point", ")", "Subtract", "(", "point", "*", "Point", ")", "*", "Point", "{", "p", "[", "0", "]", "-=", "point", "[", "0", "]", "\n", "p", "[", "1", "]", "-=", "point", "[", "1", "]", "\n\n", "return", "p", "\n", "}" ]

[ "Subtract", "a", "point", "from", "the", "given", "point", "." ]

[ "func", "(", "p", "*", "Point", ")", "Scale", "(", "factor", "float64", ")", "*", "Point", "{", "p", "[", "0", "]", "*=", "factor", "\n", "p", "[", "1", "]", "*=", "factor", "\n\n", "return", "p", "\n", "}" ]

[ "Scale", "each", "component", "of", "the", "point", "." ]

[ "func", "(", "p", "*", "Point", ")", "Equals", "(", "point", "*", "Point", ")", "bool", "{", "if", "p", "[", "0", "]", "==", "point", "[", "0", "]", "&&", "p", "[", "1", "]", "==", "point", "[", "1", "]", "{", "return", "true", "\n", "}", "\n\n", "return", "false", "\n", "}" ]

[ "Equals", "checks", "if", "the", "point", "represents", "the", "same", "point", "or", "vector", "." ]

[ "func", "(", "p", "Point", ")", "ToGeoJSON", "(", ")", "*", "geojson", ".", "Feature", "{", "return", "geojson", ".", "NewPointFeature", "(", "[", "]", "float64", "{", "p", "[", "0", "]", ",", "p", "[", "1", "]", "}", ")", "\n", "}" ]

[ "ToGeoJSON", "creates", "a", "new", "geojson", "feature", "with", "a", "point", "geometry", "." ]

[ "func", "(", "p", "*", "Point", ")", "Round", "(", "factor", "...", "int", ")", "*", "Point", "{", "f", ":=", "1.0e5", "\n", "if", "len", "(", "factor", ")", "!=", "0", "{", "f", "=", "float64", "(", "factor", "[", "0", "]", ")", "\n", "}", "\n\n", "for", "idx", ",", "val", ":=", "range", "p", "{", "x", ":=", "val", "*", "f", "\n", "p", "[", "idx", "]", "=", "math", ".", "Floor", "(", "x", "+", "0.5", ")", "/", "f", "\n", "}", "\n\n", "return", "p", "\n", "}" ]

[ "Round", "returns", "a", "point", "which", "coordinates", "are", "rounded", "Factor", "defaults", "to", "1", ".", "0e5" ]

[ "func", "NewPointFromWKB", "(", "wkb", "[", "]", "byte", ")", "*", "Point", "{", "p", ":=", "&", "Point", "{", "}", "\n", "if", "err", ":=", "p", ".", "unmarshalWKB", "(", "wkb", ")", ";", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "p", "\n", "}" ]

[ "NewPointFromWKB", "will", "take", "raw", "WKB", "and", "set", "the", "data", "for", "a", "new", "point", ".", "The", "WKB", "data", "must", "be", "of", "type", "Point", ".", "Will", "return", "nil", "if", "invalid", "WKB", "point", "." ]

[ "func", "NewLineFromWKB", "(", "wkb", "[", "]", "byte", ")", "*", "Line", "{", "l", ":=", "&", "Line", "{", "}", "\n", "if", "err", ":=", "l", ".", "unmarshalWKB", "(", "wkb", ")", ";", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "l", "\n", "}" ]

[ "NewLineFromWKB", "will", "take", "raw", "WKB", "and", "set", "the", "data", "for", "a", "new", "line", ".", "The", "WKB", "data", "must", "of", "type", "LineString", "and", "only", "contain", "2", "points", ".", "Will", "return", "nil", "if", "invalid", "WKB", "." ]

[ "func", "NewPointSetFromWKB", "(", "wkb", "[", "]", "byte", ")", "*", "PointSet", "{", "ps", ":=", "&", "PointSet", "{", "}", "\n", "if", "err", ":=", "ps", ".", "unmarshalWKB", "(", "wkb", ")", ";", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "ps", "\n", "}" ]

[ "NewPointSetFromWKB", "will", "take", "raw", "WKB", "and", "set", "the", "data", "for", "a", "new", "point", "set", ".", "The", "WKB", "data", "must", "be", "of", "type", "LineString", "Polygon", "or", "MultiPoint", ".", "Will", "return", "nil", "if", "invalid", "WKB", "." ]

[ "func", "NewPathFromWKB", "(", "wkb", "[", "]", "byte", ")", "*", "Path", "{", "p", ":=", "NewPath", "(", ")", "\n", "if", "err", ":=", "p", ".", "PointSet", ".", "unmarshalWKB", "(", "wkb", ")", ";", "err", "!=", "nil", "{", "return", "nil", "\n", "}", "\n\n", "return", "p", "\n", "}" ]

[ "NewPathFromWKB", "will", "take", "raw", "WKB", "and", "set", "the", "data", "for", "a", "new", "path", ".", "The", "WKB", "data", "must", "be", "of", "type", "LineString", "Polygon", "or", "MultiPoint", ".", "Will", "return", "nil", "if", "invalid", "WKB", "." ]

[ "func", "(", "p", "*", "portAllocator", ")", "ClaimPorts", "(", "numPorts", "int", ")", "(", "uint16", ",", "error", ")", "{", "port", ":=", "p", ".", "nextPort", "\n", "if", "p", ".", "endingPort", "<", "port", "+", "uint16", "(", "numPorts", "-", "1", ")", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "p", ".", "nextPort", "=", "p", ".", "nextPort", "+", "uint16", "(", "numPorts", ")", "\n", "return", "uint16", "(", "port", ")", ",", "nil", "\n", "}" ]

[ "ClaimPorts", "returns", "a", "new", "uint16", "port", "to", "be", "used", "for", "testing", "processes", ".", "No", "guarantees", "are", "made", "that", "something", "is", "not", "already", "listening", "on", "that", "port", ".", "If", "running", "multiple", "processes", "you", "should", "initialize", "the", "portAllocator", "with", "different", "ranges", ".", "If", "ports", "are", "also", "allocated", "by", "another", "method", "the", "portAllocator", "should", "be", "provided", "with", "a", "range", "that", "skips", "those", "other", "ports", ".", "numPorts", "indicates", "the", "number", "of", "ports", "that", "will", "be", "claimed", ".", "The", "first", "claimed", "port", "is", "returned", "and", "the", "next", "numPorts", "-", "1", "ports", "sequentially", "after", "that", "are", "yours", "to", "use", ".", "returns", "a", "non", "-", "nil", "error", "if", "there", "are", "not", "enough", "ports", "in", "the", "range", "compared", "to", "the", "number", "requested", "." ]

[ "func", "(", "v", "*", "Volume", ")", "InspectTemplate", "(", "ctx", "context", ".", "Context", ")", "(", "*", "client", ".", "VolumeTemplate", ",", "error", ")", "{", "volumes", ",", "err", ":=", "v", ".", "context", ".", "Client", ".", "VolumeTemplate", ".", "List", "(", "&", "client", ".", "ListOpts", "{", "Filters", ":", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "v", ".", "name", ",", "\"", "\"", ":", "v", ".", "context", ".", "Stack", ".", "Id", ",", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "volumes", ".", "Data", ")", ">", "0", "{", "return", "&", "volumes", ".", "Data", "[", "0", "]", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "InspectTemplate", "looks", "up", "a", "volume", "template" ]

[ "func", "(", "v", "*", "Volume", ")", "InspectExternal", "(", "ctx", "context", ".", "Context", ")", "(", "*", "client", ".", "Volume", ",", "error", ")", "{", "volumes", ",", "err", ":=", "v", ".", "context", ".", "Client", ".", "Volume", ".", "List", "(", "&", "client", ".", "ListOpts", "{", "Filters", ":", "map", "[", "string", "]", "interface", "{", "}", "{", "\"", "\"", ":", "v", ".", "name", ",", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n\n", "if", "len", "(", "volumes", ".", "Data", ")", ">", "0", "{", "return", "&", "volumes", ".", "Data", "[", "0", "]", ",", "nil", "\n", "}", "\n\n", "return", "nil", ",", "nil", "\n", "}" ]

[ "InspectExternal", "looks", "up", "a", "volume" ]

[ "func", "StopCommand", "(", "factory", "app", ".", "ProjectFactory", ")", "cli", ".", "Command", "{", "return", "cli", ".", "Command", "{", "Name", ":", "\"", "\"", ",", "ShortName", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Action", ":", "app", ".", "WithProject", "(", "factory", ",", "app", ".", "ProjectStop", ")", ",", "Flags", ":", "[", "]", "cli", ".", "Flag", "{", "cli", ".", "IntFlag", "{", "Name", ":", "\"", "\"", ",", "Usage", ":", "\"", "\"", ",", "Value", ":", "10", ",", "}", ",", "}", ",", "}", "\n", "}" ]

[ "StopCommand", "defines", "the", "libcompose", "stop", "subcommand", "." ]

[ "func", "(", "f", "*", "FileResourceLookup", ")", "ResolvePath", "(", "path", ",", "inFile", "string", ")", "string", "{", "vs", ":=", "strings", ".", "SplitN", "(", "path", ",", "\"", "\"", ",", "2", ")", "\n", "if", "len", "(", "vs", ")", "==", "2", "&&", "!", "filepath", ".", "IsAbs", "(", "vs", "[", "0", "]", ")", "{", "log", ".", "Warnf", "(", "\"", "\"", ",", "vs", "[", "0", "]", ")", "\n", "}", "\n", "return", "path", "\n", "}" ]

[ "Give", "a", "warning", "rather", "than", "resolve", "relative", "paths" ]

[ "func", "NewError", "(", "resource", "interface", "{", "}", ",", "column", ",", "err", "string", ")", "error", "{", "return", "&", "Error", "{", "Resource", ":", "resource", ",", "Column", ":", "column", ",", "Message", ":", "err", "}", "\n", "}" ]

[ "NewError", "generate", "a", "new", "error", "for", "a", "model", "s", "field" ]

[ "func", "(", "err", "Error", ")", "Label", "(", ")", "string", "{", "scope", ":=", "gorm", ".", "Scope", "{", "Value", ":", "err", ".", "Resource", "}", "\n", "return", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "scope", ".", "GetModelStruct", "(", ")", ".", "ModelType", ".", "Name", "(", ")", ",", "scope", ".", "PrimaryKeyValue", "(", ")", ",", "err", ".", "Column", ")", "\n", "}" ]

[ "Label", "is", "a", "label", "including", "model", "type", "primary", "key", "and", "column", "name" ]

[ "func", "NewBrokerConf", "(", "clientID", "string", ")", "BrokerConf", "{", "return", "BrokerConf", "{", "ClientID", ":", "clientID", ",", "DialTimeout", ":", "10", "*", "time", ".", "Second", ",", "DialRetryLimit", ":", "10", ",", "DialRetryWait", ":", "500", "*", "time", ".", "Millisecond", ",", "AllowTopicCreation", ":", "false", ",", "LeaderRetryLimit", ":", "10", ",", "LeaderRetryWait", ":", "500", "*", "time", ".", "Millisecond", ",", "RetryErrLimit", ":", "10", ",", "RetryErrWait", ":", "time", ".", "Millisecond", "*", "500", ",", "ReadTimeout", ":", "30", "*", "time", ".", "Second", ",", "Logger", ":", "&", "nullLogger", "{", "}", ",", "}", "\n", "}" ]

[ "NewBrokerConf", "returns", "the", "default", "broker", "configuration", "." ]

[ "func", "Dial", "(", "nodeAddresses", "[", "]", "string", ",", "conf", "BrokerConf", ")", "(", "*", "Broker", ",", "error", ")", "{", "if", "len", "(", "nodeAddresses", ")", "==", "0", "{", "return", "nil", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n\n", "broker", ":=", "&", "Broker", "{", "conf", ":", "conf", ",", "conns", ":", "make", "(", "map", "[", "int32", "]", "*", "connection", ")", ",", "nodeAddresses", ":", "nodeAddresses", ",", "}", "\n\n", "for", "i", ":=", "0", ";", "i", "<", "conf", ".", "DialRetryLimit", ";", "i", "++", "{", "if", "i", ">", "0", "{", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "i", ",", "\"", "\"", ",", "conf", ".", "DialRetryWait", ")", "\n", "time", ".", "Sleep", "(", "conf", ".", "DialRetryWait", ")", "\n", "}", "\n\n", "err", ":=", "broker", ".", "refreshMetadata", "(", ")", "\n\n", "if", "err", "==", "nil", "{", "return", "broker", ",", "nil", "\n", "}", "\n\n", "conf", ".", "Logger", ".", "Error", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "nil", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "nodeAddresses", ",", "conf", ".", "useTLS", "(", ")", ")", "\n", "}" ]

[ "Dial", "connects", "to", "any", "node", "from", "a", "given", "list", "of", "kafka", "addresses", "and", "after", "successful", "metadata", "fetch", "returns", "broker", ".", "The", "returned", "broker", "is", "not", "initially", "connected", "to", "any", "kafka", "node", "." ]

[ "func", "(", "b", "*", "Broker", ")", "Close", "(", ")", "{", "b", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mu", ".", "Unlock", "(", ")", "\n", "for", "nodeID", ",", "conn", ":=", "range", "b", ".", "conns", "{", "if", "err", ":=", "conn", ".", "Close", "(", ")", ";", "err", "!=", "nil", "{", "b", ".", "conf", ".", "Logger", ".", "Info", "(", "\"", "\"", ",", "\"", "\"", ",", "nodeID", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "}" ]

[ "Close", "closes", "the", "broker", "and", "all", "active", "kafka", "nodes", "connections", "." ]

[ "func", "(", "b", "*", "Broker", ")", "Metadata", "(", ")", "(", "*", "proto", ".", "MetadataResp", ",", "error", ")", "{", "b", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "b", ".", "fetchMetadata", "(", ")", "\n", "}" ]

[ "Metadata", "requests", "metadata", "information", "from", "any", "node", "." ]

[ "func", "(", "b", "*", "Broker", ")", "CreateTopic", "(", "topics", "[", "]", "proto", ".", "TopicInfo", ",", "timeout", "time", ".", "Duration", ",", "validateOnly", "bool", ")", "(", "*", "proto", ".", "CreateTopicsResp", ",", "error", ")", "{", "b", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mu", ".", "Unlock", "(", ")", "\n", "var", "resp", "*", "proto", ".", "CreateTopicsResp", "\n", "err", ":=", "b", ".", "callOnClusterController", "(", "func", "(", "c", "*", "connection", ")", "error", "{", "var", "err", "error", "\n", "req", ":=", "proto", ".", "CreateTopicsReq", "{", "Timeout", ":", "timeout", ",", "CreateTopicsRequests", ":", "topics", ",", "ValidateOnly", ":", "validateOnly", ",", "}", "\n", "resp", ",", "err", "=", "c", ".", "CreateTopic", "(", "&", "req", ")", "\n", "return", "err", "\n", "}", ")", "\n", "return", "resp", ",", "err", "\n", "}" ]

[ "CreateTopic", "request", "topic", "creation" ]

[ "func", "(", "b", "*", "Broker", ")", "refreshMetadata", "(", ")", "error", "{", "meta", ",", "err", ":=", "b", ".", "fetchMetadata", "(", ")", "\n", "if", "err", "==", "nil", "{", "b", ".", "cacheMetadata", "(", "meta", ")", "\n", "}", "\n", "return", "err", "\n", "}" ]

[ "refreshMetadata", "is", "requesting", "metadata", "information", "from", "any", "node", "and", "refresh", "internal", "cached", "representation", ".", "Because", "it", "s", "changing", "internal", "state", "this", "method", "requires", "lock", "protection", "but", "it", "does", "not", "acquire", "nor", "release", "lock", "itself", "." ]

[ "func", "(", "b", "*", "Broker", ")", "muRefreshMetadata", "(", ")", "error", "{", "b", ".", "mu", ".", "Lock", "(", ")", "\n", "err", ":=", "b", ".", "refreshMetadata", "(", ")", "\n", "b", ".", "mu", ".", "Unlock", "(", ")", "\n", "return", "err", "\n", "}" ]

[ "muRefreshMetadata", "calls", "refreshMetadata", "but", "protects", "it", "with", "broker", "s", "lock", "." ]

[ "func", "(", "b", "*", "Broker", ")", "cacheMetadata", "(", "resp", "*", "proto", ".", "MetadataResp", ")", "{", "if", "!", "b", ".", "metadata", ".", "created", ".", "IsZero", "(", ")", "{", "b", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "time", ".", "Now", "(", ")", ".", "Sub", "(", "b", ".", "metadata", ".", "created", ")", ")", "\n", "}", "\n", "b", ".", "metadata", "=", "clusterMetadata", "{", "created", ":", "time", ".", "Now", "(", ")", ",", "nodes", ":", "make", "(", "map", "[", "int32", "]", "string", ")", ",", "endpoints", ":", "make", "(", "map", "[", "topicPartition", "]", "int32", ")", ",", "partitions", ":", "make", "(", "map", "[", "string", "]", "int32", ")", ",", "}", "\n", "b", ".", "metadata", ".", "controllerId", "=", "resp", ".", "ControllerID", "\n", "for", "_", ",", "node", ":=", "range", "resp", ".", "Brokers", "{", "addr", ":=", "fmt", ".", "Sprintf", "(", "\"", "\"", ",", "node", ".", "Host", ",", "node", ".", "Port", ")", "\n", "b", ".", "metadata", ".", "nodes", "[", "node", ".", "NodeID", "]", "=", "addr", "\n", "}", "\n", "for", "_", ",", "topic", ":=", "range", "resp", ".", "Topics", "{", "for", "_", ",", "part", ":=", "range", "topic", ".", "Partitions", "{", "dest", ":=", "topicPartition", "{", "topic", ".", "Name", ",", "part", ".", "ID", "}", "\n", "b", ".", "metadata", ".", "endpoints", "[", "dest", "]", "=", "part", ".", "Leader", "\n", "}", "\n", "b", ".", "metadata", ".", "partitions", "[", "topic", ".", "Name", "]", "=", "int32", "(", "len", "(", "topic", ".", "Partitions", ")", ")", "\n", "}", "\n", "b", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ")", "\n", "}" ]

[ "cacheMetadata", "creates", "new", "internal", "metadata", "representation", "using", "data", "from", "given", "response", ".", "It", "s", "call", "has", "to", "be", "protected", "with", "lock", ".", "Do", "not", "call", "with", "partial", "metadata", "response", "this", "assumes", "we", "have", "the", "full", "set", "of", "metadata", "in", "the", "response" ]

[ "func", "(", "b", "*", "Broker", ")", "PartitionCount", "(", "topic", "string", ")", "(", "int32", ",", "error", ")", "{", "b", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "count", ",", "ok", ":=", "b", ".", "metadata", ".", "partitions", "[", "topic", "]", "\n", "if", "ok", "{", "return", "count", ",", "nil", "\n", "}", "\n\n", "return", "0", ",", "fmt", ".", "Errorf", "(", "\"", "\"", ",", "topic", ")", "\n", "}" ]

[ "PartitionCount", "returns", "how", "many", "partitions", "a", "given", "topic", "has", ".", "If", "a", "topic", "is", "not", "known", "0", "and", "an", "error", "are", "returned", "." ]

[ "func", "(", "b", "*", "Broker", ")", "muCloseDeadConnection", "(", "conn", "*", "connection", ")", "{", "b", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "b", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "for", "nid", ",", "c", ":=", "range", "b", ".", "conns", "{", "if", "c", "==", "conn", "{", "b", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "nid", ")", "\n", "delete", "(", "b", ".", "conns", ",", "nid", ")", "\n", "_", "=", "c", ".", "Close", "(", ")", "\n", "if", "err", ":=", "b", ".", "refreshMetadata", "(", ")", ";", "err", "!=", "nil", "{", "b", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "return", "\n", "}", "\n", "}", "\n", "}" ]

[ "muCloseDeadConnection", "is", "closing", "and", "removing", "any", "reference", "to", "given", "connection", ".", "Because", "we", "remove", "dead", "connection", "additional", "request", "to", "refresh", "metadata", "is", "made", "muCloseDeadConnection", "call", "it", "protected", "with", "broker", "s", "lock", "." ]

[ "func", "(", "b", "*", "Broker", ")", "offset", "(", "topic", "string", ",", "partition", "int32", ",", "timems", "int64", ")", "(", "offset", "int64", ",", "err", "error", ")", "{", "for", "retry", ":=", "0", ";", "retry", "<", "b", ".", "conf", ".", "RetryErrLimit", ";", "retry", "++", "{", "if", "retry", "!=", "0", "{", "time", ".", "Sleep", "(", "b", ".", "conf", ".", "RetryErrWait", ")", "\n", "err", "=", "b", ".", "muRefreshMetadata", "(", ")", "\n", "if", "err", "!=", "nil", "{", "continue", "\n", "}", "\n", "}", "\n", "var", "conn", "*", "connection", "\n", "conn", ",", "err", "=", "b", ".", "muLeaderConnection", "(", "topic", ",", "partition", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n", "var", "resp", "*", "proto", ".", "OffsetResp", "\n", "resp", ",", "err", "=", "conn", ".", "Offset", "(", "&", "proto", ".", "OffsetReq", "{", "RequestHeader", ":", "proto", ".", "RequestHeader", "{", "ClientID", ":", "b", ".", "conf", ".", "ClientID", "}", ",", "ReplicaID", ":", "-", "1", ",", "// any client", "Topics", ":", "[", "]", "proto", ".", "OffsetReqTopic", "{", "{", "Name", ":", "topic", ",", "Partitions", ":", "[", "]", "proto", ".", "OffsetReqPartition", "{", "{", "ID", ":", "partition", ",", "TimeMs", ":", "timems", ",", "MaxOffsets", ":", "2", ",", "}", ",", "}", ",", "}", ",", "}", ",", "}", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "net", ".", "OpError", ")", ";", "ok", "||", "err", "==", "io", ".", "EOF", "||", "err", "==", "syscall", ".", "EPIPE", "{", "// Connection is broken, so should be closed, but the error is", "// still valid and should be returned so that retry mechanism have", "// chance to react.", "b", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "partition", ",", "\"", "\"", ",", "err", ")", "\n", "b", ".", "muCloseDeadConnection", "(", "conn", ")", "\n", "}", "\n", "continue", "\n", "}", "\n", "for", "_", ",", "t", ":=", "range", "resp", ".", "Topics", "{", "if", "t", ".", "Name", "!=", "topic", "{", "b", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "t", ".", "Name", ")", "\n", "continue", "\n", "}", "\n", "for", "_", ",", "part", ":=", "range", "t", ".", "Partitions", "{", "if", "part", ".", "ID", "!=", "partition", "{", "b", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "t", ".", "Name", ",", "\"", "\"", ",", "partition", ",", "\"", "\"", ",", "part", ".", "ID", ")", "\n", "continue", "\n", "}", "\n", "if", "err", "=", "part", ".", "Err", ";", "err", "==", "nil", "{", "if", "len", "(", "part", ".", "Offsets", ")", "==", "0", "{", "return", "0", ",", "nil", "\n", "}", "else", "{", "return", "part", ".", "Offsets", "[", "0", "]", ",", "nil", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "}", "\n", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}" ]

[ "offset", "will", "return", "offset", "value", "for", "given", "partition", ".", "Use", "timems", "to", "specify", "which", "offset", "value", "should", "be", "returned", "." ]

[ "func", "(", "b", "*", "Broker", ")", "OffsetEarliest", "(", "topic", "string", ",", "partition", "int32", ")", "(", "offset", "int64", ",", "err", "error", ")", "{", "return", "b", ".", "offset", "(", "topic", ",", "partition", ",", "-", "2", ")", "\n", "}" ]

[ "OffsetEarliest", "returns", "the", "oldest", "offset", "available", "on", "the", "given", "partition", "." ]

[ "func", "NewProducerConf", "(", ")", "ProducerConf", "{", "return", "ProducerConf", "{", "Compression", ":", "proto", ".", "CompressionNone", ",", "RequiredAcks", ":", "proto", ".", "RequiredAcksAll", ",", "RequestTimeout", ":", "5", "*", "time", ".", "Second", ",", "RetryLimit", ":", "10", ",", "RetryWait", ":", "200", "*", "time", ".", "Millisecond", ",", "Logger", ":", "nil", ",", "}", "\n", "}" ]

[ "NewProducerConf", "returns", "a", "default", "producer", "configuration", "." ]

[ "func", "(", "b", "*", "Broker", ")", "Producer", "(", "conf", "ProducerConf", ")", "Producer", "{", "if", "conf", ".", "Logger", "==", "nil", "{", "conf", ".", "Logger", "=", "b", ".", "conf", ".", "Logger", "\n", "}", "\n", "return", "&", "producer", "{", "conf", ":", "conf", ",", "broker", ":", "b", ",", "}", "\n", "}" ]

[ "Producer", "returns", "new", "producer", "instance", "bound", "to", "the", "broker", "." ]

[ "func", "(", "p", "*", "producer", ")", "Produce", "(", "topic", "string", ",", "partition", "int32", ",", "messages", "...", "*", "proto", ".", "Message", ")", "(", "offset", "int64", ",", "err", "error", ")", "{", "for", "retry", ":=", "0", ";", "retry", "<", "p", ".", "conf", ".", "RetryLimit", ";", "retry", "++", "{", "if", "retry", "!=", "0", "{", "time", ".", "Sleep", "(", "p", ".", "conf", ".", "RetryWait", ")", "\n", "}", "\n\n", "offset", ",", "err", "=", "p", ".", "produce", "(", "topic", ",", "partition", ",", "messages", "...", ")", "\n\n", "switch", "err", "{", "case", "nil", ":", "for", "i", ",", "msg", ":=", "range", "messages", "{", "msg", ".", "Offset", "=", "int64", "(", "i", ")", "+", "offset", "\n", "}", "\n", "if", "retry", "!=", "0", "{", "p", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "retry", ",", "\"", "\"", ",", "topic", ")", "\n", "}", "\n", "return", "offset", ",", "err", "\n", "case", "io", ".", "EOF", ",", "syscall", ".", "EPIPE", ":", "// p.produce call is closing connection when this error shows up,", "// but it's also returning it so that retry loop can count this", "// case", "// we cannot handle this error here, because there is no direct", "// access to connection", "default", ":", "if", "err", ":=", "p", ".", "broker", ".", "muRefreshMetadata", "(", ")", ";", "err", "!=", "nil", "{", "p", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "}", "\n", "p", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "retry", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "err", ")", "\n", "}", "\n", "p", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "p", ".", "conf", ".", "RetryLimit", ",", "\"", "\"", ",", "topic", ")", "\n", "return", "0", ",", "err", "\n\n", "}" ]

[ "Produce", "writes", "messages", "to", "the", "given", "destination", ".", "Writes", "within", "the", "call", "are", "atomic", "meaning", "either", "all", "or", "none", "of", "them", "are", "written", "to", "kafka", ".", "Produce", "has", "a", "configurable", "amount", "of", "retries", "which", "may", "be", "attempted", "when", "common", "errors", "are", "encountered", ".", "This", "behaviour", "can", "be", "configured", "with", "the", "RetryLimit", "and", "RetryWait", "attributes", ".", "Upon", "a", "successful", "call", "the", "message", "s", "Offset", "field", "is", "updated", "." ]

[ "func", "(", "p", "*", "producer", ")", "produce", "(", "topic", "string", ",", "partition", "int32", ",", "messages", "...", "*", "proto", ".", "Message", ")", "(", "offset", "int64", ",", "err", "error", ")", "{", "conn", ",", "err", ":=", "p", ".", "broker", ".", "muLeaderConnection", "(", "topic", ",", "partition", ")", "\n", "if", "err", "!=", "nil", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "req", ":=", "proto", ".", "ProduceReq", "{", "RequestHeader", ":", "proto", ".", "RequestHeader", "{", "ClientID", ":", "p", ".", "broker", ".", "conf", ".", "ClientID", "}", ",", "Compression", ":", "p", ".", "conf", ".", "Compression", ",", "RequiredAcks", ":", "p", ".", "conf", ".", "RequiredAcks", ",", "Timeout", ":", "p", ".", "conf", ".", "RequestTimeout", ",", "Topics", ":", "[", "]", "proto", ".", "ProduceReqTopic", "{", "{", "Name", ":", "topic", ",", "Partitions", ":", "[", "]", "proto", ".", "ProduceReqPartition", "{", "{", "ID", ":", "partition", ",", "Messages", ":", "messages", ",", "}", ",", "}", ",", "}", ",", "}", ",", "}", "\n\n", "resp", ",", "err", ":=", "conn", ".", "Produce", "(", "&", "req", ")", "\n", "if", "err", "!=", "nil", "{", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "net", ".", "OpError", ")", ";", "ok", "||", "err", "==", "io", ".", "EOF", "||", "err", "==", "syscall", ".", "EPIPE", "{", "// Connection is broken, so should be closed, but the error is", "// still valid and should be returned so that retry mechanism have", "// chance to react.", "p", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "partition", ",", "\"", "\"", ",", "err", ")", "\n", "p", ".", "broker", ".", "muCloseDeadConnection", "(", "conn", ")", "\n", "}", "\n", "return", "0", ",", "err", "\n", "}", "\n\n", "if", "req", ".", "RequiredAcks", "==", "proto", ".", "RequiredAcksNone", "{", "return", "0", ",", "err", "\n", "}", "\n\n", "// we expect single partition response", "found", ":=", "false", "\n", "for", "_", ",", "t", ":=", "range", "resp", ".", "Topics", "{", "if", "t", ".", "Name", "!=", "topic", "{", "p", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "t", ".", "Name", ")", "\n", "continue", "\n", "}", "\n", "for", "_", ",", "part", ":=", "range", "t", ".", "Partitions", "{", "if", "part", ".", "ID", "!=", "partition", "{", "p", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "t", ".", "Name", ",", "\"", "\"", ",", "partition", ",", "\"", "\"", ",", "part", ".", "ID", ")", "\n", "continue", "\n", "}", "\n", "found", "=", "true", "\n", "offset", "=", "part", ".", "Offset", "\n", "err", "=", "part", ".", "Err", "\n", "}", "\n", "}", "\n\n", "if", "!", "found", "{", "return", "0", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "return", "offset", ",", "err", "\n", "}" ]

[ "produce", "send", "produce", "request", "to", "leader", "for", "given", "destination", "." ]

[ "func", "NewConsumerConf", "(", "topic", "string", ",", "partition", "int32", ")", "ConsumerConf", "{", "return", "ConsumerConf", "{", "Topic", ":", "topic", ",", "Partition", ":", "partition", ",", "RequestTimeout", ":", "time", ".", "Millisecond", "*", "50", ",", "RetryLimit", ":", "-", "1", ",", "RetryWait", ":", "time", ".", "Millisecond", "*", "50", ",", "RetryErrLimit", ":", "10", ",", "RetryErrWait", ":", "time", ".", "Millisecond", "*", "500", ",", "MinFetchSize", ":", "1", ",", "MaxFetchSize", ":", "2000000", ",", "StartOffset", ":", "StartOffsetOldest", ",", "Logger", ":", "nil", ",", "}", "\n", "}" ]

[ "NewConsumerConf", "returns", "the", "default", "consumer", "configuration", "." ]

[ "func", "(", "b", "*", "Broker", ")", "Consumer", "(", "conf", "ConsumerConf", ")", "(", "Consumer", ",", "error", ")", "{", "return", "b", ".", "consumer", "(", "conf", ")", "\n", "}" ]

[ "Consumer", "creates", "a", "new", "consumer", "instance", "bound", "to", "the", "broker", "." ]

[ "func", "(", "b", "*", "Broker", ")", "BatchConsumer", "(", "conf", "ConsumerConf", ")", "(", "BatchConsumer", ",", "error", ")", "{", "return", "b", ".", "consumer", "(", "conf", ")", "\n", "}" ]

[ "BatchConsumer", "creates", "a", "new", "BatchConsumer", "instance", "bound", "to", "the", "broker", "." ]

[ "func", "(", "c", "*", "consumer", ")", "consume", "(", ")", "(", "[", "]", "*", "proto", ".", "Message", ",", "error", ")", "{", "var", "msgbuf", "[", "]", "*", "proto", ".", "Message", "\n", "var", "retry", "int", "\n", "for", "len", "(", "msgbuf", ")", "==", "0", "{", "var", "err", "error", "\n", "msgbuf", ",", "err", "=", "c", ".", "fetch", "(", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "len", "(", "msgbuf", ")", "==", "0", "{", "if", "c", ".", "conf", ".", "RetryWait", ">", "0", "{", "time", ".", "Sleep", "(", "c", ".", "conf", ".", "RetryWait", ")", "\n", "}", "\n", "retry", "++", "\n", "if", "c", ".", "conf", ".", "RetryLimit", "!=", "-", "1", "&&", "retry", ">", "c", ".", "conf", ".", "RetryLimit", "{", "return", "nil", ",", "ErrNoData", "\n", "}", "\n", "}", "\n", "}", "\n\n", "return", "msgbuf", ",", "nil", "\n", "}" ]

[ "consume", "is", "returning", "a", "batch", "of", "messages", "from", "consumed", "partition", ".", "Consumer", "can", "retry", "fetching", "messages", "even", "if", "responses", "return", "no", "new", "data", ".", "Retry", "behaviour", "can", "be", "configured", "through", "RetryLimit", "and", "RetryWait", "consumer", "parameters", ".", "consume", "can", "retry", "sending", "request", "on", "common", "errors", ".", "This", "behaviour", "can", "be", "configured", "with", "RetryErrLimit", "and", "RetryErrWait", "consumer", "configuration", "attributes", "." ]

[ "func", "NewOffsetCoordinatorConf", "(", "consumerGroup", "string", ")", "OffsetCoordinatorConf", "{", "return", "OffsetCoordinatorConf", "{", "ConsumerGroup", ":", "consumerGroup", ",", "RetryErrLimit", ":", "10", ",", "RetryErrWait", ":", "time", ".", "Millisecond", "*", "500", ",", "Logger", ":", "nil", ",", "}", "\n", "}" ]

[ "NewOffsetCoordinatorConf", "returns", "default", "OffsetCoordinator", "configuration", "." ]

[ "func", "(", "b", "*", "Broker", ")", "OffsetCoordinator", "(", "conf", "OffsetCoordinatorConf", ")", "(", "OffsetCoordinator", ",", "error", ")", "{", "conn", ",", "err", ":=", "b", ".", "muCoordinatorConnection", "(", "conf", ".", "ConsumerGroup", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "if", "conf", ".", "Logger", "==", "nil", "{", "conf", ".", "Logger", "=", "b", ".", "conf", ".", "Logger", "\n", "}", "\n", "c", ":=", "&", "offsetCoordinator", "{", "broker", ":", "b", ",", "conf", ":", "conf", ",", "conn", ":", "conn", ",", "}", "\n", "return", "c", ",", "nil", "\n", "}" ]

[ "OffsetCoordinator", "returns", "offset", "management", "coordinator", "for", "single", "consumer", "group", "bound", "to", "broker", "." ]

[ "func", "(", "c", "*", "offsetCoordinator", ")", "Commit", "(", "topic", "string", ",", "partition", "int32", ",", "offset", "int64", ")", "error", "{", "return", "c", ".", "commit", "(", "topic", ",", "partition", ",", "offset", ",", "\"", "\"", ")", "\n", "}" ]

[ "Commit", "is", "saving", "offset", "information", "for", "given", "topic", "and", "partition", ".", "Commit", "can", "retry", "saving", "offset", "information", "on", "common", "errors", ".", "This", "behaviour", "can", "be", "configured", "with", "with", "RetryErrLimit", "and", "RetryErrWait", "coordinator", "configuration", "attributes", "." ]

[ "func", "(", "c", "*", "offsetCoordinator", ")", "CommitFull", "(", "topic", "string", ",", "partition", "int32", ",", "offset", "int64", ",", "metadata", "string", ")", "error", "{", "return", "c", ".", "commit", "(", "topic", ",", "partition", ",", "offset", ",", "metadata", ")", "\n", "}" ]

[ "Commit", "works", "exactly", "like", "Commit", "method", "but", "store", "extra", "metadata", "string", "together", "with", "offset", "information", "." ]

[ "func", "(", "c", "*", "offsetCoordinator", ")", "commit", "(", "topic", "string", ",", "partition", "int32", ",", "offset", "int64", ",", "metadata", "string", ")", "(", "resErr", "error", ")", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "for", "retry", ":=", "0", ";", "retry", "<", "c", ".", "conf", ".", "RetryErrLimit", ";", "retry", "++", "{", "if", "retry", "!=", "0", "{", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "time", ".", "Sleep", "(", "c", ".", "conf", ".", "RetryErrWait", ")", "\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "}", "\n\n", "// connection can be set to nil if previously reference connection died", "if", "c", ".", "conn", "==", "nil", "{", "conn", ",", "err", ":=", "c", ".", "broker", ".", "muCoordinatorConnection", "(", "c", ".", "conf", ".", "ConsumerGroup", ")", "\n", "if", "err", "!=", "nil", "{", "resErr", "=", "err", "\n", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "c", ".", "conf", ".", "ConsumerGroup", ",", "\"", "\"", ",", "err", ")", "\n", "continue", "\n", "}", "\n", "c", ".", "conn", "=", "conn", "\n", "}", "\n\n", "resp", ",", "err", ":=", "c", ".", "conn", ".", "OffsetCommit", "(", "&", "proto", ".", "OffsetCommitReq", "{", "RequestHeader", ":", "proto", ".", "RequestHeader", "{", "ClientID", ":", "c", ".", "broker", ".", "conf", ".", "ClientID", "}", ",", "ConsumerGroup", ":", "c", ".", "conf", ".", "ConsumerGroup", ",", "Topics", ":", "[", "]", "proto", ".", "OffsetCommitReqTopic", "{", "{", "Name", ":", "topic", ",", "Partitions", ":", "[", "]", "proto", ".", "OffsetCommitReqPartition", "{", "{", "ID", ":", "partition", ",", "Offset", ":", "offset", ",", "TimeStamp", ":", "time", ".", "Now", "(", ")", ",", "Metadata", ":", "metadata", "}", ",", "}", ",", "}", ",", "}", ",", "}", ")", "\n", "resErr", "=", "err", "\n\n", "if", "_", ",", "ok", ":=", "err", ".", "(", "*", "net", ".", "OpError", ")", ";", "ok", "||", "err", "==", "io", ".", "EOF", "||", "err", "==", "syscall", ".", "EPIPE", "{", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "partition", ",", "\"", "\"", ",", "c", ".", "conf", ".", "ConsumerGroup", ")", "\n", "c", ".", "broker", ".", "muCloseDeadConnection", "(", "c", ".", "conn", ")", "\n", "c", ".", "conn", "=", "nil", "\n", "}", "else", "if", "err", "==", "nil", "{", "for", "_", ",", "t", ":=", "range", "resp", ".", "Topics", "{", "if", "t", ".", "Name", "!=", "topic", "{", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "t", ".", "Name", ",", "\"", "\"", ",", "topic", ")", "\n", "continue", "\n\n", "}", "\n", "for", "_", ",", "part", ":=", "range", "t", ".", "Partitions", "{", "if", "part", ".", "ID", "!=", "partition", "{", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "part", ".", "ID", ",", "\"", "\"", ",", "partition", ")", "\n", "continue", "\n", "}", "\n", "return", "part", ".", "Err", "\n", "}", "\n", "}", "\n", "return", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n", "return", "resErr", "\n", "}" ]

[ "commit", "is", "saving", "offset", "and", "metadata", "information", ".", "Provides", "limited", "error", "handling", "configurable", "through", "OffsetCoordinatorConf", "." ]

[ "func", "(", "c", "*", "offsetCoordinator", ")", "Offset", "(", "topic", "string", ",", "partition", "int32", ")", "(", "offset", "int64", ",", "metadata", "string", ",", "resErr", "error", ")", "{", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "defer", "c", ".", "mu", ".", "Unlock", "(", ")", "\n\n", "for", "retry", ":=", "0", ";", "retry", "<", "c", ".", "conf", ".", "RetryErrLimit", ";", "retry", "++", "{", "if", "retry", "!=", "0", "{", "c", ".", "mu", ".", "Unlock", "(", ")", "\n", "time", ".", "Sleep", "(", "c", ".", "conf", ".", "RetryErrWait", ")", "\n", "c", ".", "mu", ".", "Lock", "(", ")", "\n", "}", "\n\n", "// connection can be set to nil if previously reference connection died", "if", "c", ".", "conn", "==", "nil", "{", "conn", ",", "err", ":=", "c", ".", "broker", ".", "muCoordinatorConnection", "(", "c", ".", "conf", ".", "ConsumerGroup", ")", "\n", "if", "err", "!=", "nil", "{", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "c", ".", "conf", ".", "ConsumerGroup", ",", "\"", "\"", ",", "err", ")", "\n", "resErr", "=", "err", "\n", "continue", "\n", "}", "\n", "c", ".", "conn", "=", "conn", "\n", "}", "\n", "resp", ",", "err", ":=", "c", ".", "conn", ".", "OffsetFetch", "(", "&", "proto", ".", "OffsetFetchReq", "{", "ConsumerGroup", ":", "c", ".", "conf", ".", "ConsumerGroup", ",", "Topics", ":", "[", "]", "proto", ".", "OffsetFetchReqTopic", "{", "{", "Name", ":", "topic", ",", "Partitions", ":", "[", "]", "int32", "{", "partition", "}", ",", "}", ",", "}", ",", "}", ")", "\n", "resErr", "=", "err", "\n\n", "switch", "err", "{", "case", "io", ".", "EOF", ",", "syscall", ".", "EPIPE", ":", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "partition", ",", "\"", "\"", ",", "c", ".", "conf", ".", "ConsumerGroup", ")", "\n", "c", ".", "broker", ".", "muCloseDeadConnection", "(", "c", ".", "conn", ")", "\n", "c", ".", "conn", "=", "nil", "\n", "case", "nil", ":", "for", "_", ",", "t", ":=", "range", "resp", ".", "Topics", "{", "if", "t", ".", "Name", "!=", "topic", "{", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "t", ".", "Name", ",", "\"", "\"", ",", "topic", ")", "\n", "continue", "\n", "}", "\n", "for", "_", ",", "part", ":=", "range", "t", ".", "Partitions", "{", "if", "part", ".", "ID", "!=", "partition", "{", "c", ".", "conf", ".", "Logger", ".", "Debug", "(", "\"", "\"", ",", "\"", "\"", ",", "topic", ",", "\"", "\"", ",", "partition", ",", "\"", "\"", ",", "part", ".", "ID", ")", "\n", "continue", "\n", "}", "\n", "if", "part", ".", "Err", "!=", "nil", "{", "return", "0", ",", "\"", "\"", ",", "part", ".", "Err", "\n", "}", "\n", "return", "part", ".", "Offset", ",", "part", ".", "Metadata", ",", "nil", "\n", "}", "\n", "}", "\n", "return", "0", ",", "\"", "\"", ",", "errors", ".", "New", "(", "\"", "\"", ")", "\n", "}", "\n", "}", "\n\n", "return", "0", ",", "\"", "\"", ",", "resErr", "\n", "}" ]

[ "Offset", "is", "returning", "last", "offset", "and", "metadata", "information", "committed", "for", "given", "topic", "and", "partition", ".", "Offset", "can", "retry", "sending", "request", "on", "common", "errors", ".", "This", "behaviour", "can", "be", "configured", "with", "with", "RetryErrLimit", "and", "RetryErrWait", "coordinator", "configuration", "attributes", "." ]

[ "func", "newTCPConnection", "(", "address", "string", ",", "timeout", ",", "readTimeout", "time", ".", "Duration", ")", "(", "*", "connection", ",", "error", ")", "{", "var", "fetchVersions", "=", "true", "\n", "for", "{", "dialer", ":=", "net", ".", "Dialer", "{", "Timeout", ":", "timeout", ",", "KeepAlive", ":", "30", "*", "time", ".", "Second", ",", "}", "\n", "conn", ",", "err", ":=", "dialer", ".", "Dial", "(", "\"", "\"", ",", "address", ")", "\n", "if", "err", "!=", "nil", "{", "return", "nil", ",", "err", "\n", "}", "\n", "c", ":=", "&", "connection", "{", "stop", ":", "make", "(", "chan", "struct", "{", "}", ")", ",", "nextID", ":", "make", "(", "chan", "int32", ")", ",", "rw", ":", "conn", ",", "respc", ":", "make", "(", "map", "[", "int32", "]", "chan", "[", "]", "byte", ")", ",", "logger", ":", "&", "nullLogger", "{", "}", ",", "readTimeout", ":", "readTimeout", ",", "apiVersions", ":", "make", "(", "map", "[", "int16", "]", "proto", ".", "SupportedVersion", ")", ",", "}", "\n", "go", "c", ".", "nextIDLoop", "(", ")", "\n", "go", "c", ".", "readRespLoop", "(", ")", "\n\n", "if", "fetchVersions", "{", "if", "c", ".", "cacheApiVersions", "(", ")", "!=", "nil", "{", "fetchVersions", "=", "false", "\n", "//required for errorchk", "_", "=", "c", ".", "Close", "(", ")", "\n", "continue", "\n", "}", "\n", "}", "\n", "return", "c", ",", "nil", "\n", "}", "\n\n", "}" ]

[ "newConnection", "returns", "new", "initialized", "connection", "or", "error" ]

[ "func", "(", "c", "*", "connection", ")", "getBestVersion", "(", "apiKey", "int16", ")", "int16", "{", "if", "requested", ",", "ok", ":=", "c", ".", "apiVersions", "[", "apiKey", "]", ";", "ok", "{", "supported", ":=", "proto", ".", "SupportedByDriver", "[", "apiKey", "]", "\n", "if", "min", "(", "supported", ".", "MaxVersion", ",", "requested", ".", "MaxVersion", ")", ">=", "max", "(", "supported", ".", "MinVersion", ",", "requested", ".", "MinVersion", ")", "{", "return", "min", "(", "supported", ".", "MaxVersion", ",", "requested", ".", "MaxVersion", ")", "\n", "}", "\n", "}", "\n", "return", "0", "\n", "}" ]

[ "getBestVersion", "returns", "version", "for", "passed", "apiKey", "which", "best", "fit", "server", "and", "client", "requirements" ]

[ "func", "(", "c", "*", "connection", ")", "nextIDLoop", "(", ")", "{", "var", "id", "int32", "=", "1", "\n", "for", "{", "select", "{", "case", "<-", "c", ".", "stop", ":", "close", "(", "c", ".", "nextID", ")", "\n", "return", "\n", "case", "c", ".", "nextID", "<-", "id", ":", "id", "++", "\n", "if", "id", "==", "math", ".", "MaxInt32", "{", "id", "=", "1", "\n", "}", "\n", "}", "\n", "}", "\n", "}" ]

[ "nextIDLoop", "generates", "correlation", "IDs", "making", "sure", "they", "are", "always", "in", "order", "and", "within", "the", "scope", "of", "request", "-", "response", "mapping", "array", "." ]