title
stringclasses 1
value | text
stringlengths 49
954k
| id
stringlengths 27
30
|
|---|---|---|
presto-main/src/main/java/io/prestosql/server/ui/FormWebUiAuthenticationManager.java/FormWebUiAuthenticationManager/getRedirectLocation
class FormWebUiAuthenticationManager: static String getRedirectLocation(HttpServletRequest request, String path, String queryParameter)
{
HttpUriBuilder builder;
if (isNullOrEmpty(request.getHeader(X_FORWARDED_HOST))) {
// not forwarded
builder = uriBuilder()
.scheme(request.getScheme())
.host(request.getServerName())
.port(request.getServerPort());
}
else {
// forwarded
builder = uriBuilder()
.scheme(firstNonNull(emptyToNull(request.getHeader(X_FORWARDED_PROTO)), request.getScheme()))
.host(request.getHeader(X_FORWARDED_HOST));
getForwarderPort(request).ifPresent(builder::port);
}
builder.replacePath(path);
if (queryParameter != null) {
builder.addParameter(queryParameter);
}
return builder.toString();
}
|
apositive_train_query0_00000
|
|
presto-main/src/main/java/io/prestosql/server/ui/FormWebUiAuthenticationManager.java/FormWebUiAuthenticationManager/getForwarderPort
class FormWebUiAuthenticationManager: private static Optional<Integer> getForwarderPort(HttpServletRequest request)
{
if (!isNullOrEmpty(request.getHeader(X_FORWARDED_PORT))) {
try {
return Optional.of(parseInt(request.getHeader(X_FORWARDED_PORT)));
}
catch (ArithmeticException ignore) {
}
}
return Optional.empty();
}
|
apositive_train_query0_00001
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/getXMin
class Rectangle: @JsonProperty
public double getXMin()
{
return xMin;
}
|
negative_train_query0_00000
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/getXMax
class Rectangle: @JsonProperty
public double getXMax()
{
return xMax;
}
|
negative_train_query0_00001
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/getWidth
class Rectangle: public double getWidth()
{
return xMax - xMin;
}
|
negative_train_query0_00002
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/intersects
class Rectangle: public boolean intersects(Rectangle other)
{
requireNonNull(other, "other is null");
return this.xMin <= other.xMax && this.xMax >= other.xMin && this.yMin <= other.yMax && this.yMax >= other.yMin;
}
|
negative_train_query0_00003
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/merge
class Rectangle: public Rectangle merge(Rectangle other)
{
return new Rectangle(min(this.xMin, other.xMin), min(this.yMin, other.yMin), max(this.xMax, other.xMax), max(this.yMax, other.yMax));
}
|
negative_train_query0_00004
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/equals
class Rectangle: @Override
public boolean equals(Object obj)
{
if (obj == null) {
return false;
}
if (!(obj instanceof Rectangle)) {
return false;
}
Rectangle other = (Rectangle) obj;
return other.xMin == this.xMin && other.yMin == this.yMin && other.xMax == this.xMax && other.yMax == this.yMax;
}
|
negative_train_query0_00005
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/Rectangle
class Rectangle: @JsonCreator
public Rectangle(
@JsonProperty("xmin") double xMin,
@JsonProperty("ymin") double yMin,
@JsonProperty("xmax") double xMax,
@JsonProperty("ymax") double yMax)
{
checkArgument(xMin <= xMax, "xMin is greater than xMax");
checkArgument(yMin <= yMax, "yMin is greater than yMax");
this.xMin = xMin;
this.yMin = yMin;
this.xMax = xMax;
this.yMax = yMax;
}
|
negative_train_query0_00006
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/getYMax
class Rectangle: @JsonProperty
public double getYMax()
{
return yMax;
}
|
negative_train_query0_00007
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/getYMin
class Rectangle: @JsonProperty
public double getYMin()
{
return yMin;
}
|
negative_train_query0_00008
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/getHeight
class Rectangle: public double getHeight()
{
return yMax - yMin;
}
|
negative_train_query0_00009
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/intersection
class Rectangle: public Rectangle intersection(Rectangle other)
{
requireNonNull(other, "other is null");
if (!intersects(other)) {
return null;
}
return new Rectangle(max(this.xMin, other.xMin), max(this.yMin, other.yMin), min(this.xMax, other.xMax), min(this.yMax, other.yMax));
}
|
negative_train_query0_00010
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/estimateMemorySize
class Rectangle: public int estimateMemorySize()
{
return INSTANCE_SIZE;
}
|
negative_train_query0_00011
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/hashCode
class Rectangle: @Override
public int hashCode()
{
return Objects.hash(xMin, yMin, xMax, yMax);
}
|
negative_train_query0_00012
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/Rectangle.java/Rectangle/toString
class Rectangle: @Override
public String toString()
{
return toStringHelper(this)
.add("xMin", xMin)
.add("yMin", yMin)
.add("xMax", xMax)
.add("yMax", yMax)
.toString();
}
|
negative_train_query0_00013
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTreeUtils.java/KdbTreeUtils/KdbTreeUtils
class KdbTreeUtils: private KdbTreeUtils() {}
|
negative_train_query0_00014
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTreeUtils.java/KdbTreeUtils/toJson
class KdbTreeUtils: public static String toJson(KdbTree kdbTree)
{
requireNonNull(kdbTree, "kdbTree is null");
return KDB_TREE_CODEC.toJson(kdbTree);
}
|
negative_train_query0_00015
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTreeUtils.java/KdbTreeUtils/fromJson
class KdbTreeUtils: public static KdbTree fromJson(String json)
{
requireNonNull(json, "json is null");
return KDB_TREE_CODEC.fromJson(json);
}
|
negative_train_query0_00016
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryType.java/GeometryType/isMultitype
class GeometryType: public boolean isMultitype()
{
return multitype;
}
|
negative_train_query0_00017
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryType.java/GeometryType/getForEsriGeometryType
class GeometryType: public static GeometryType getForEsriGeometryType(String type)
{
return getForInternalLibraryName(type);
}
|
negative_train_query0_00018
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryType.java/GeometryType/GeometryType
class GeometryType: GeometryType(boolean multitype, Slice standardName)
{
this.multitype = multitype;
this.standardName = standardName;
}
|
negative_train_query0_00019
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryType.java/GeometryType/getForJtsGeometryType
class GeometryType: public static GeometryType getForJtsGeometryType(String type)
{
return getForInternalLibraryName(type);
}
|
negative_train_query0_00020
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryType.java/GeometryType/standardName
class GeometryType: public Slice standardName()
{
return standardName;
}
|
negative_train_query0_00021
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryType.java/GeometryType/getForInternalLibraryName
class GeometryType: private static GeometryType getForInternalLibraryName(String type)
{
requireNonNull(type, "type is null");
switch (type) {
case "Point":
return POINT;
case "MultiPoint":
return MULTI_POINT;
case "LineString":
return LINE_STRING;
case "MultiLineString":
return MULTI_LINE_STRING;
case "Polygon":
return POLYGON;
case "MultiPolygon":
return MULTI_POLYGON;
case "GeometryCollection":
return GEOMETRY_COLLECTION;
default:
throw new IllegalArgumentException("Invalid Geometry Type: " + type);
}
}
|
negative_train_query0_00022
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/translateFromAVNaN
class GeometryUtils: private static double translateFromAVNaN(double n)
{
return n < -1.0E38D ? (0.0D / 0.0) : n;
}
|
negative_train_query0_00023
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/translateToAVNaN
class GeometryUtils: public static double translateToAVNaN(double n)
{
return (Double.isNaN(n)) ? -Double.MAX_VALUE : n;
}
|
negative_train_query0_00024
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/getPointCount
class GeometryUtils: public static int getPointCount(OGCGeometry ogcGeometry)
{
GeometryCursor cursor = ogcGeometry.getEsriGeometryCursor();
int points = 0;
while (true) {
com.esri.core.geometry.Geometry geometry = cursor.next();
if (geometry == null) {
return points;
}
if (geometry.isEmpty()) {
continue;
}
if (geometry instanceof Point) {
points++;
}
else {
points += ((MultiVertexGeometry) geometry).getPointCount();
}
}
}
|
negative_train_query0_00025
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/disjoint
class GeometryUtils: public static boolean disjoint(Envelope envelope, OGCGeometry ogcGeometry)
{
GeometryCursor cursor = ogcGeometry.getEsriGeometryCursor();
while (true) {
Geometry geometry = cursor.next();
if (geometry == null) {
return true;
}
if (!GeometryEngine.disjoint(geometry, envelope, null)) {
return false;
}
}
}
|
negative_train_query0_00026
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/isEsriNaN
class GeometryUtils: public static boolean isEsriNaN(double d)
{
return Double.isNaN(d) || Double.isNaN(translateFromAVNaN(d));
}
|
negative_train_query0_00027
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/getEnvelope
class GeometryUtils: public static Envelope getEnvelope(OGCGeometry ogcGeometry)
{
GeometryCursor cursor = ogcGeometry.getEsriGeometryCursor();
Envelope overallEnvelope = new Envelope();
while (true) {
Geometry geometry = cursor.next();
if (geometry == null) {
return overallEnvelope;
}
Envelope envelope = new Envelope();
geometry.queryEnvelope(envelope);
overallEnvelope.merge(envelope);
}
}
|
negative_train_query0_00028
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/contains
class GeometryUtils: public static boolean contains(OGCGeometry ogcGeometry, Envelope envelope)
{
GeometryCursor cursor = ogcGeometry.getEsriGeometryCursor();
while (true) {
Geometry geometry = cursor.next();
if (geometry == null) {
return false;
}
if (GeometryEngine.contains(geometry, envelope, null)) {
return true;
}
}
}
|
negative_train_query0_00029
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/isPointOrRectangle
class GeometryUtils: public static boolean isPointOrRectangle(OGCGeometry ogcGeometry, Envelope envelope)
{
if (ogcGeometry instanceof OGCPoint) {
return true;
}
if (!(ogcGeometry instanceof OGCPolygon)) {
return false;
}
Polygon polygon = (Polygon) ogcGeometry.getEsriGeometry();
if (polygon.getPathCount() > 1) {
return false;
}
if (polygon.getPointCount() != 4) {
return false;
}
Set<Point> corners = new HashSet<>();
corners.add(new Point(envelope.getXMin(), envelope.getYMin()));
corners.add(new Point(envelope.getXMin(), envelope.getYMax()));
corners.add(new Point(envelope.getXMax(), envelope.getYMin()));
corners.add(new Point(envelope.getXMax(), envelope.getYMax()));
for (int i = 0; i < 4; i++) {
Point point = polygon.getPoint(i);
if (!corners.contains(point)) {
return false;
}
}
return true;
}
|
negative_train_query0_00030
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/GeometryUtils.java/GeometryUtils/GeometryUtils
class GeometryUtils: private GeometryUtils() {}
|
negative_train_query0_00031
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/equals
class KdbTree: @Override
public boolean equals(Object obj)
{
if (obj == null) {
return false;
}
if (!(obj instanceof Node)) {
return false;
}
Node other = (Node) obj;
return this.extent.equals(other.extent)
&& Objects.equals(this.leafId, other.leafId)
&& Objects.equals(this.left, other.left)
&& Objects.equals(this.right, other.right);
}
|
negative_train_query0_00032
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getLeaves
class KdbTree: public Map<Integer, Rectangle> getLeaves()
{
ImmutableMap.Builder<Integer, Rectangle> leaves = ImmutableMap.builder();
addLeaves(root, leaves, node -> true);
return leaves.build();
}
|
negative_train_query0_00033
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/SplitResult
class KdbTree: private SplitResult(T left, T right)
{
this.left = requireNonNull(left, "left is null");
this.right = requireNonNull(right, "right is null");
}
|
negative_train_query0_00034
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/hashCode
class KdbTree: @Override
public int hashCode()
{
return Objects.hash(extent, leafId, left, right);
}
|
negative_train_query0_00035
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/findIntersectingLeaves
class KdbTree: public Map<Integer, Rectangle> findIntersectingLeaves(Rectangle envelope)
{
ImmutableMap.Builder<Integer, Rectangle> leaves = ImmutableMap.builder();
addLeaves(root, leaves, node -> node.extent.intersects(envelope));
return leaves.build();
}
|
negative_train_query0_00036
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getValue
class KdbTree: double getValue(Rectangle rectangle);
|
negative_train_query0_00037
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/buildKdbTree
class KdbTree: public static KdbTree buildKdbTree(int maxItemsPerNode, Rectangle extent, List<Rectangle> items)
{
checkArgument(maxItemsPerNode > 0, "maxItemsPerNode must be > 0");
requireNonNull(extent, "extent is null");
requireNonNull(items, "items is null");
return new KdbTree(buildKdbTreeNode(maxItemsPerNode, 0, extent, items, new LeafIdAllocator()));
}
|
negative_train_query0_00038
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getLeft
class KdbTree: @JsonProperty
public Optional<Node> getLeft()
{
return left;
}
|
negative_train_query0_00039
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/newLeaf
class KdbTree: public static Node newLeaf(Rectangle extent, int leafId)
{
return new Node(extent, OptionalInt.of(leafId), Optional.empty(), Optional.empty());
}
|
negative_train_query0_00040
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/Node
class KdbTree: @JsonCreator
public Node(
@JsonProperty("extent") Rectangle extent,
@JsonProperty("leafId") OptionalInt leafId,
@JsonProperty("left") Optional<Node> left,
@JsonProperty("right") Optional<Node> right)
{
this.extent = requireNonNull(extent, "extent is null");
this.leafId = requireNonNull(leafId, "leafId is null");
this.left = requireNonNull(left, "left is null");
this.right = requireNonNull(right, "right is null");
if (leafId.isPresent()) {
checkArgument(leafId.getAsInt() >= 0, "leafId must be >= 0");
checkArgument(!left.isPresent(), "Leaf node cannot have left child");
checkArgument(!right.isPresent(), "Leaf node cannot have right child");
}
else {
checkArgument(left.isPresent(), "Intermediate node must have left child");
checkArgument(right.isPresent(), "Intermediate node must have right child");
}
}
|
negative_train_query0_00041
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getRight
class KdbTree: public T getRight()
{
return right;
}
|
negative_train_query0_00042
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/KdbTree
class KdbTree: @JsonCreator
public KdbTree(@JsonProperty("root") Node root)
{
this.root = requireNonNull(root, "root is null");
}
|
negative_train_query0_00043
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/addLeaves
class KdbTree: private static void addLeaves(Node node, ImmutableMap.Builder<Integer, Rectangle> leaves, Predicate<Node> predicate)
{
if (!predicate.apply(node)) {
return;
}
if (node.leafId.isPresent()) {
leaves.put(node.leafId.getAsInt(), node.extent);
}
else {
addLeaves(node.left.get(), leaves, predicate);
addLeaves(node.right.get(), leaves, predicate);
}
}
|
negative_train_query0_00044
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/newInternal
class KdbTree: public static Node newInternal(Rectangle extent, Node left, Node right)
{
return new Node(extent, OptionalInt.empty(), Optional.of(left), Optional.of(right));
}
|
negative_train_query0_00045
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getExtent
class KdbTree: @JsonProperty
public Rectangle getExtent()
{
return extent;
}
|
negative_train_query0_00046
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getRoot
class KdbTree: @JsonProperty
public Node getRoot()
{
return root;
}
|
negative_train_query0_00047
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getComparator
class KdbTree: @Override
public Comparator<Rectangle> getComparator()
{
return comparator;
}
|
negative_train_query0_00048
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/split
class KdbTree: @Override
public SplitResult<Rectangle> split(Rectangle rectangle, double x)
{
checkArgument(rectangle.getXMin() < x && x < rectangle.getXMax());
return new SplitResult<>(
new Rectangle(rectangle.getXMin(), rectangle.getYMin(), x, rectangle.getYMax()),
new Rectangle(x, rectangle.getYMin(), rectangle.getXMax(), rectangle.getYMax()));
}
|
negative_train_query0_00049
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/getLeafId
class KdbTree: @JsonProperty
public OptionalInt getLeafId()
{
return leafId;
}
|
negative_train_query0_00050
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/buildKdbTreeNode
class KdbTree: private static Node buildKdbTreeNode(int maxItemsPerNode, int level, Rectangle extent, List<Rectangle> items, LeafIdAllocator leafIdAllocator)
{
checkArgument(maxItemsPerNode > 0, "maxItemsPerNode must be > 0");
checkArgument(level >= 0, "level must be >= 0");
checkArgument(level <= MAX_LEVELS, "level must be <= 10,000");
requireNonNull(extent, "extent is null");
requireNonNull(items, "items is null");
if (items.size() <= maxItemsPerNode || level == MAX_LEVELS) {
return newLeaf(extent, leafIdAllocator.next());
}
// Split over longer side
boolean splitVertically = extent.getWidth() >= extent.getHeight();
Optional<SplitResult<Node>> splitResult = trySplit(splitVertically ? BY_X : BY_Y, maxItemsPerNode, level, extent, items, leafIdAllocator);
if (!splitResult.isPresent()) {
// Try spitting by the other side
splitResult = trySplit(splitVertically ? BY_Y : BY_X, maxItemsPerNode, level, extent, items, leafIdAllocator);
}
if (!splitResult.isPresent()) {
return newLeaf(extent, leafIdAllocator.next());
}
return newInternal(extent, splitResult.get().getLeft(), splitResult.get().getRight());
}
|
negative_train_query0_00051
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/trySplit
class KdbTree: private static Optional<SplitResult<Node>> trySplit(SplitDimension splitDimension, int maxItemsPerNode, int level, Rectangle extent, List<Rectangle> items, LeafIdAllocator leafIdAllocator)
{
checkArgument(items.size() > 1, "Number of items to split must be > 1");
// Sort envelopes by xMin or yMin
List<Rectangle> sortedItems = ImmutableList.sortedCopyOf(splitDimension.getComparator(), items);
// Find a mid-point
int middleIndex = (sortedItems.size() - 1) / 2;
Rectangle middleEnvelope = sortedItems.get(middleIndex);
double splitValue = splitDimension.getValue(middleEnvelope);
int splitIndex = middleIndex;
// skip over duplicate values
while (splitIndex < sortedItems.size() && splitDimension.getValue(sortedItems.get(splitIndex)) == splitValue) {
splitIndex++;
}
// all values between left-of-middle and the end are the same, so can't split
if (splitIndex == sortedItems.size()) {
return Optional.empty();
}
// about half of the objects are <= splitValue, the rest are >= next value
// assuming the input set of objects is a sample from a much larger set,
// let's split in the middle; this way objects from the larger set with values
// between splitValue and next value will get split somewhat evenly into left
// and right partitions
splitValue = (splitValue + splitDimension.getValue(sortedItems.get(splitIndex))) / 2;
SplitResult<Rectangle> childExtents = splitDimension.split(extent, splitValue);
return Optional.of(new SplitResult<>(
buildKdbTreeNode(maxItemsPerNode, level + 1, childExtents.getLeft(), sortedItems.subList(0, splitIndex), leafIdAllocator),
buildKdbTreeNode(maxItemsPerNode, level + 1, childExtents.getRight(), sortedItems.subList(splitIndex, sortedItems.size()), leafIdAllocator)));
}
|
negative_train_query0_00052
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/KdbTree/next
class KdbTree: public int next()
{
return nextId++;
}
|
negative_train_query0_00053
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/LeafIdAllocator/next
class LeafIdAllocator: public int next()
{
return nextId++;
}
|
negative_train_query0_00054
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/SplitDimension/getComparator
class SplitDimension: Comparator<Rectangle> getComparator();
|
negative_train_query0_00055
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/SplitDimension/getValue
class SplitDimension: double getValue(Rectangle rectangle);
|
negative_train_query0_00056
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/SplitDimension/split
class SplitDimension: SplitResult<Rectangle> split(Rectangle rectangle, double value);
|
negative_train_query0_00057
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/newLeaf
class Node: public static Node newLeaf(Rectangle extent, int leafId)
{
return new Node(extent, OptionalInt.of(leafId), Optional.empty(), Optional.empty());
}
|
negative_train_query0_00058
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/getLeafId
class Node: @JsonProperty
public OptionalInt getLeafId()
{
return leafId;
}
|
negative_train_query0_00059
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/Node
class Node: @JsonCreator
public Node(
@JsonProperty("extent") Rectangle extent,
@JsonProperty("leafId") OptionalInt leafId,
@JsonProperty("left") Optional<Node> left,
@JsonProperty("right") Optional<Node> right)
{
this.extent = requireNonNull(extent, "extent is null");
this.leafId = requireNonNull(leafId, "leafId is null");
this.left = requireNonNull(left, "left is null");
this.right = requireNonNull(right, "right is null");
if (leafId.isPresent()) {
checkArgument(leafId.getAsInt() >= 0, "leafId must be >= 0");
checkArgument(!left.isPresent(), "Leaf node cannot have left child");
checkArgument(!right.isPresent(), "Leaf node cannot have right child");
}
else {
checkArgument(left.isPresent(), "Intermediate node must have left child");
checkArgument(right.isPresent(), "Intermediate node must have right child");
}
}
|
negative_train_query0_00060
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/getRight
class Node: @JsonProperty
public Optional<Node> getRight()
{
return right;
}
|
negative_train_query0_00061
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/newInternal
class Node: public static Node newInternal(Rectangle extent, Node left, Node right)
{
return new Node(extent, OptionalInt.empty(), Optional.of(left), Optional.of(right));
}
|
negative_train_query0_00062
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/getExtent
class Node: @JsonProperty
public Rectangle getExtent()
{
return extent;
}
|
negative_train_query0_00063
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/getLeft
class Node: @JsonProperty
public Optional<Node> getLeft()
{
return left;
}
|
negative_train_query0_00064
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/equals
class Node: @Override
public boolean equals(Object obj)
{
if (obj == null) {
return false;
}
if (!(obj instanceof Node)) {
return false;
}
Node other = (Node) obj;
return this.extent.equals(other.extent)
&& Objects.equals(this.leafId, other.leafId)
&& Objects.equals(this.left, other.left)
&& Objects.equals(this.right, other.right);
}
|
negative_train_query0_00065
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/Node/hashCode
class Node: @Override
public int hashCode()
{
return Objects.hash(extent, leafId, left, right);
}
|
negative_train_query0_00066
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/SplitResult/SplitResult
class SplitResult: private SplitResult(T left, T right)
{
this.left = requireNonNull(left, "left is null");
this.right = requireNonNull(right, "right is null");
}
|
negative_train_query0_00067
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/SplitResult/getRight
class SplitResult: public T getRight()
{
return right;
}
|
negative_train_query0_00068
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/KdbTree.java/SplitResult/getLeft
class SplitResult: public T getLeft()
{
return left;
}
|
negative_train_query0_00069
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readGeometry
class JtsGeometrySerde: private static Geometry readGeometry(BasicSliceInput input, GeometrySerializationType type)
{
switch (type) {
case POINT:
return readPoint(input);
case MULTI_POINT:
return readMultiPoint(input);
case LINE_STRING:
return readPolyline(input, false);
case MULTI_LINE_STRING:
return readPolyline(input, true);
case POLYGON:
return readPolygon(input, false);
case MULTI_POLYGON:
return readPolygon(input, true);
case GEOMETRY_COLLECTION:
return readGeometryCollection(input);
case ENVELOPE:
return readEnvelope(input);
default:
throw new UnsupportedOperationException("Unexpected type: " + type);
}
}
|
negative_train_query0_00070
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/skipEnvelope
class JtsGeometrySerde: private static void skipEnvelope(SliceInput input)
{
requireNonNull(input, "input is null");
int skipLength = 4 * SIZE_OF_DOUBLE;
verify(input.skip(skipLength) == skipLength);
}
|
negative_train_query0_00071
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writeMultiPoint
class JtsGeometrySerde: private static void writeMultiPoint(MultiPoint geometry, SliceOutput output)
{
output.writeByte(GeometrySerializationType.MULTI_POINT.code());
output.writeInt(EsriShapeType.MULTI_POINT.code);
writeEnvelope(geometry, output);
output.writeInt(geometry.getNumPoints());
for (Coordinate coordinate : geometry.getCoordinates()) {
writeCoordinate(coordinate, output);
}
}
|
negative_train_query0_00072
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readPoint
class JtsGeometrySerde: private static Point readPoint(SliceInput input)
{
Coordinate coordinates = readCoordinate(input);
if (isNaN(coordinates.x) || isNaN(coordinates.y)) {
return GEOMETRY_FACTORY.createPoint();
}
return GEOMETRY_FACTORY.createPoint(coordinates);
}
|
negative_train_query0_00073
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readCoordinate
class JtsGeometrySerde: private static Coordinate readCoordinate(SliceInput input)
{
requireNonNull(input, "input is null");
return new Coordinate(input.readDouble(), input.readDouble());
}
|
negative_train_query0_00074
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writePolyline
class JtsGeometrySerde: private static void writePolyline(Geometry geometry, SliceOutput output, boolean multitype)
{
int numParts;
int numPoints = geometry.getNumPoints();
if (multitype) {
numParts = geometry.getNumGeometries();
output.writeByte(GeometrySerializationType.MULTI_LINE_STRING.code());
}
else {
numParts = numPoints > 0 ? 1 : 0;
output.writeByte(GeometrySerializationType.LINE_STRING.code());
}
output.writeInt(EsriShapeType.POLYLINE.code);
writeEnvelope(geometry, output);
output.writeInt(numParts);
output.writeInt(numPoints);
int partIndex = 0;
for (int i = 0; i < numParts; i++) {
output.writeInt(partIndex);
partIndex += geometry.getGeometryN(i).getNumPoints();
}
writeCoordinates(geometry.getCoordinates(), output);
}
|
negative_train_query0_00075
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readPolygon
class JtsGeometrySerde: private static Geometry readPolygon(SliceInput input, boolean multitype)
{
skipEsriType(input);
skipEnvelope(input);
int partCount = input.readInt();
if (partCount == 0) {
if (multitype) {
return GEOMETRY_FACTORY.createMultiPolygon();
}
return GEOMETRY_FACTORY.createPolygon();
}
int pointCount = input.readInt();
int[] startIndexes = new int[partCount];
for (int i = 0; i < partCount; i++) {
startIndexes[i] = input.readInt();
}
int[] partLengths = new int[partCount];
if (partCount > 1) {
partLengths[0] = startIndexes[1];
for (int i = 1; i < partCount - 1; i++) {
partLengths[i] = startIndexes[i + 1] - startIndexes[i];
}
}
partLengths[partCount - 1] = pointCount - startIndexes[partCount - 1];
LinearRing shell = null;
List<LinearRing> holes = new ArrayList<>();
List<Polygon> polygons = new ArrayList<>();
for (int i = 0; i < partCount; i++) {
Coordinate[] coordinates = readCoordinates(input, partLengths[i]);
if (isClockwise(coordinates)) {
// next polygon has started
if (shell != null) {
polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));
holes.clear();
}
else {
verify(holes.isEmpty(), "shell is null but holes found");
}
shell = GEOMETRY_FACTORY.createLinearRing(coordinates);
}
else {
verifyNotNull(shell, "shell is null but hole found");
holes.add(GEOMETRY_FACTORY.createLinearRing(coordinates));
}
}
polygons.add(GEOMETRY_FACTORY.createPolygon(shell, holes.toArray(new LinearRing[0])));
if (multitype) {
return GEOMETRY_FACTORY.createMultiPolygon(polygons.toArray(new Polygon[0]));
}
return getOnlyElement(polygons);
}
|
negative_train_query0_00076
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writeEnvelope
class JtsGeometrySerde: private static void writeEnvelope(Geometry geometry, SliceOutput output)
{
if (geometry.isEmpty()) {
for (int i = 0; i < 4; i++) {
output.writeDouble(NaN);
}
return;
}
Envelope envelope = geometry.getEnvelopeInternal();
output.writeDouble(envelope.getMinX());
output.writeDouble(envelope.getMinY());
output.writeDouble(envelope.getMaxX());
output.writeDouble(envelope.getMaxY());
}
|
negative_train_query0_00077
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readGeometryCollection
class JtsGeometrySerde: private static Geometry readGeometryCollection(BasicSliceInput input)
{
List<Geometry> geometries = new ArrayList<>();
while (input.available() > 0) {
// skip length
input.readInt();
GeometrySerializationType type = GeometrySerializationType.getForCode(input.readByte());
geometries.add(readGeometry(input, type));
}
return GEOMETRY_FACTORY.createGeometryCollection(geometries.toArray(new Geometry[0]));
}
|
negative_train_query0_00078
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/canonicalizePolygonCoordinates
class JtsGeometrySerde: private static void canonicalizePolygonCoordinates(Coordinate[] coordinates, int start, int end, boolean isShell)
{
boolean isClockwise = isClockwise(coordinates, start, end);
if ((isShell && !isClockwise) || (!isShell && isClockwise)) {
// shell has to be counter clockwise
reverse(coordinates, start, end);
}
}
|
negative_train_query0_00079
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/EsriShapeType
class JtsGeometrySerde: EsriShapeType(int code)
{
this.code = code;
}
|
negative_train_query0_00080
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readEnvelope
class JtsGeometrySerde: private static Geometry readEnvelope(SliceInput input)
{
verify(input.available() > 0);
double xMin = input.readDouble();
double yMin = input.readDouble();
double xMax = input.readDouble();
double yMax = input.readDouble();
Coordinate[] coordinates = new Coordinate[5];
coordinates[0] = new Coordinate(xMin, yMin);
coordinates[1] = new Coordinate(xMin, yMax);
coordinates[2] = new Coordinate(xMax, yMax);
coordinates[3] = new Coordinate(xMax, yMin);
coordinates[4] = coordinates[0];
return GEOMETRY_FACTORY.createPolygon(coordinates);
}
|
negative_train_query0_00081
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writeGeometry
class JtsGeometrySerde: private static void writeGeometry(Geometry geometry, DynamicSliceOutput output)
{
switch (geometry.getGeometryType()) {
case "Point":
writePoint((Point) geometry, output);
break;
case "MultiPoint":
writeMultiPoint((MultiPoint) geometry, output);
break;
case "LineString":
writePolyline(geometry, output, false);
break;
case "MultiLineString":
writePolyline(geometry, output, true);
break;
case "Polygon":
writePolygon(geometry, output, false);
break;
case "MultiPolygon":
writePolygon(geometry, output, true);
break;
case "GeometryCollection":
writeGeometryCollection(geometry, output);
break;
default:
throw new IllegalArgumentException("Unsupported geometry type : " + geometry.getGeometryType());
}
}
|
negative_train_query0_00082
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writeCoordinate
class JtsGeometrySerde: private static void writeCoordinate(Coordinate coordinate, SliceOutput output)
{
output.writeDouble(translateToAVNaN(coordinate.x));
output.writeDouble(translateToAVNaN(coordinate.y));
}
|
negative_train_query0_00083
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/isClockwise
class JtsGeometrySerde: private static boolean isClockwise(Coordinate[] coordinates)
{
return isClockwise(coordinates, 0, coordinates.length);
}
|
negative_train_query0_00084
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/deserialize
class JtsGeometrySerde: public static Geometry deserialize(Slice shape)
{
requireNonNull(shape, "shape is null");
BasicSliceInput input = shape.getInput();
verify(input.available() > 0);
GeometrySerializationType type = GeometrySerializationType.getForCode(input.readByte());
return readGeometry(input, type);
}
|
negative_train_query0_00085
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/skipEsriType
class JtsGeometrySerde: private static void skipEsriType(SliceInput input)
{
input.readInt();
}
|
negative_train_query0_00086
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writePoint
class JtsGeometrySerde: private static void writePoint(Point point, SliceOutput output)
{
output.writeByte(GeometrySerializationType.POINT.code());
if (!point.isEmpty()) {
writeCoordinate(point.getCoordinate(), output);
}
else {
output.writeDouble(NaN);
output.writeDouble(NaN);
}
}
|
negative_train_query0_00087
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writeCoordinates
class JtsGeometrySerde: private static void writeCoordinates(Coordinate[] coordinates, SliceOutput output)
{
for (Coordinate coordinate : coordinates) {
writeCoordinate(coordinate, output);
}
}
|
negative_train_query0_00088
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/reverse
class JtsGeometrySerde: private static void reverse(Coordinate[] coordinates, int start, int end)
{
verify(start <= end, "start must be less or equal than end");
for (int i = start; i < start + ((end - start) / 2); i++) {
Coordinate buffer = coordinates[i];
coordinates[i] = coordinates[start + end - i - 1];
coordinates[start + end - i - 1] = buffer;
}
}
|
negative_train_query0_00089
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readMultiPoint
class JtsGeometrySerde: private static Geometry readMultiPoint(SliceInput input)
{
skipEsriType(input);
skipEnvelope(input);
int pointCount = input.readInt();
Point[] points = new Point[pointCount];
for (int i = 0; i < pointCount; i++) {
points[i] = readPoint(input);
}
return GEOMETRY_FACTORY.createMultiPoint(points);
}
|
negative_train_query0_00090
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/serialize
class JtsGeometrySerde: public static Slice serialize(Geometry geometry)
{
requireNonNull(geometry, "input is null");
DynamicSliceOutput output = new DynamicSliceOutput(100);
writeGeometry(geometry, output);
return output.slice();
}
|
negative_train_query0_00091
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writePolygon
class JtsGeometrySerde: private static void writePolygon(Geometry geometry, SliceOutput output, boolean multitype)
{
int numGeometries = geometry.getNumGeometries();
int numParts = 0;
int numPoints = geometry.getNumPoints();
for (int i = 0; i < numGeometries; i++) {
Polygon polygon = (Polygon) geometry.getGeometryN(i);
if (polygon.getNumPoints() > 0) {
numParts += polygon.getNumInteriorRing() + 1;
}
}
if (multitype) {
output.writeByte(GeometrySerializationType.MULTI_POLYGON.code());
}
else {
output.writeByte(GeometrySerializationType.POLYGON.code());
}
output.writeInt(EsriShapeType.POLYGON.code);
writeEnvelope(geometry, output);
output.writeInt(numParts);
output.writeInt(numPoints);
if (numParts == 0) {
return;
}
int[] partIndexes = new int[numParts];
boolean[] shellPart = new boolean[numParts];
int currentPart = 0;
int currentPoint = 0;
for (int i = 0; i < numGeometries; i++) {
Polygon polygon = (Polygon) geometry.getGeometryN(i);
partIndexes[currentPart] = currentPoint;
shellPart[currentPart] = true;
currentPart++;
currentPoint += polygon.getExteriorRing().getNumPoints();
int holesCount = polygon.getNumInteriorRing();
for (int holeIndex = 0; holeIndex < holesCount; holeIndex++) {
partIndexes[currentPart] = currentPoint;
shellPart[currentPart] = false;
currentPart++;
currentPoint += polygon.getInteriorRingN(holeIndex).getNumPoints();
}
}
for (int partIndex : partIndexes) {
output.writeInt(partIndex);
}
Coordinate[] coordinates = geometry.getCoordinates();
canonicalizePolygonCoordinates(coordinates, partIndexes, shellPart);
writeCoordinates(coordinates, output);
}
|
negative_train_query0_00092
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/JtsGeometrySerde
class JtsGeometrySerde: private JtsGeometrySerde() {}
|
negative_train_query0_00093
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readPolyline
class JtsGeometrySerde: private static Geometry readPolyline(SliceInput input, boolean multitype)
{
skipEsriType(input);
skipEnvelope(input);
int partCount = input.readInt();
if (partCount == 0) {
if (multitype) {
return GEOMETRY_FACTORY.createMultiLineString();
}
return GEOMETRY_FACTORY.createLineString();
}
int pointCount = input.readInt();
int[] startIndexes = new int[partCount];
for (int i = 0; i < partCount; i++) {
startIndexes[i] = input.readInt();
}
int[] partLengths = new int[partCount];
if (partCount > 1) {
partLengths[0] = startIndexes[1];
for (int i = 1; i < partCount - 1; i++) {
partLengths[i] = startIndexes[i + 1] - startIndexes[i];
}
}
partLengths[partCount - 1] = pointCount - startIndexes[partCount - 1];
LineString[] lineStrings = new LineString[partCount];
for (int i = 0; i < partCount; i++) {
lineStrings[i] = GEOMETRY_FACTORY.createLineString(readCoordinates(input, partLengths[i]));
}
if (multitype) {
return GEOMETRY_FACTORY.createMultiLineString(lineStrings);
}
verify(lineStrings.length == 1);
return lineStrings[0];
}
|
negative_train_query0_00094
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/writeGeometryCollection
class JtsGeometrySerde: private static void writeGeometryCollection(Geometry collection, DynamicSliceOutput output)
{
output.appendByte(GeometrySerializationType.GEOMETRY_COLLECTION.code());
for (int geometryIndex = 0; geometryIndex < collection.getNumGeometries(); geometryIndex++) {
Geometry geometry = collection.getGeometryN(geometryIndex);
int startPosition = output.size();
// leave 4 bytes for the shape length
output.appendInt(0);
writeGeometry(geometry, output);
int endPosition = output.size();
int length = endPosition - startPosition - Integer.BYTES;
output.getUnderlyingSlice().setInt(startPosition, length);
}
}
|
negative_train_query0_00095
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/JtsGeometrySerde/readCoordinates
class JtsGeometrySerde: private static Coordinate[] readCoordinates(SliceInput input, int count)
{
requireNonNull(input, "input is null");
verify(count > 0);
Coordinate[] coordinates = new Coordinate[count];
for (int i = 0; i < count; i++) {
coordinates[i] = readCoordinate(input);
}
return coordinates;
}
|
negative_train_query0_00096
|
|
presto-geospatial-toolkit/src/main/java/io/prestosql/geospatial/serde/JtsGeometrySerde.java/EsriShapeType/EsriShapeType
class EsriShapeType: EsriShapeType(int code)
{
this.code = code;
}
|
negative_train_query0_00097
|