Examples with DistanceUnit org.elasticsearch.common.unit.DistanceUnit used on opensource projects

Example 1 with DistanceUnit

use of org.elasticsearch.common.unit.DistanceUnit in project elasticsearch by elastic.

the class GeoDistanceSortBuilder method fromXContent.

/**
     * Creates a new {@link GeoDistanceSortBuilder} from the query held by the {@link QueryParseContext} in
     * {@link org.elasticsearch.common.xcontent.XContent} format.
     *
     * @param context the input parse context. The state on the parser contained in this context will be changed as a
     *                side effect of this method call
     * @param elementName in some sort syntax variations the field name precedes the xContent object that specifies
     *                    further parameters, e.g. in '{ "foo": { "order" : "asc"} }'. When parsing the inner object,
     *                    the field name can be passed in via this argument
     */
public static GeoDistanceSortBuilder fromXContent(QueryParseContext context, String elementName) throws IOException {
    XContentParser parser = context.parser();
    String fieldName = null;
    List<GeoPoint> geoPoints = new ArrayList<>();
    DistanceUnit unit = DistanceUnit.DEFAULT;
    GeoDistance geoDistance = GeoDistance.ARC;
    SortOrder order = SortOrder.ASC;
    SortMode sortMode = null;
    QueryBuilder nestedFilter = null;
    String nestedPath = null;
    GeoValidationMethod validation = null;
    XContentParser.Token token;
    String currentName = parser.currentName();
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentName = parser.currentName();
        } else if (token == XContentParser.Token.START_ARRAY) {
            parseGeoPoints(parser, geoPoints);
            fieldName = currentName;
        } else if (token == XContentParser.Token.START_OBJECT) {
            if (NESTED_FILTER_FIELD.match(currentName)) {
                nestedFilter = context.parseInnerQueryBuilder();
            } else {
                // the json in the format of -> field : { lat : 30, lon : 12 }
                if (fieldName != null && fieldName.equals(currentName) == false) {
                    throw new ParsingException(parser.getTokenLocation(), "Trying to reset fieldName to [{}], already set to [{}].", currentName, fieldName);
                }
                fieldName = currentName;
                GeoPoint point = new GeoPoint();
                GeoUtils.parseGeoPoint(parser, point);
                geoPoints.add(point);
            }
        } else if (token.isValue()) {
            if (ORDER_FIELD.match(currentName)) {
                order = SortOrder.fromString(parser.text());
            } else if (UNIT_FIELD.match(currentName)) {
                unit = DistanceUnit.fromString(parser.text());
            } else if (DISTANCE_TYPE_FIELD.match(currentName)) {
                geoDistance = GeoDistance.fromString(parser.text());
            } else if (VALIDATION_METHOD_FIELD.match(currentName)) {
                validation = GeoValidationMethod.fromString(parser.text());
            } else if (SORTMODE_FIELD.match(currentName)) {
                sortMode = SortMode.fromString(parser.text());
            } else if (NESTED_PATH_FIELD.match(currentName)) {
                nestedPath = parser.text();
            } else if (token == Token.VALUE_STRING) {
                if (fieldName != null && fieldName.equals(currentName) == false) {
                    throw new ParsingException(parser.getTokenLocation(), "Trying to reset fieldName to [{}], already set to [{}].", currentName, fieldName);
                }
                GeoPoint point = new GeoPoint();
                point.resetFromString(parser.text());
                geoPoints.add(point);
                fieldName = currentName;
            } else if (fieldName.equals(currentName)) {
                throw new ParsingException(parser.getTokenLocation(), "Only geohashes of type string supported for field [{}]", currentName);
            } else {
                throw new ParsingException(parser.getTokenLocation(), "[{}] does not support [{}]", NAME, currentName);
            }
        }
    }
    GeoDistanceSortBuilder result = new GeoDistanceSortBuilder(fieldName, geoPoints.toArray(new GeoPoint[geoPoints.size()]));
    result.geoDistance(geoDistance);
    result.unit(unit);
    result.order(order);
    if (sortMode != null) {
        result.sortMode(sortMode);
    }
    if (nestedFilter != null) {
        result.setNestedFilter(nestedFilter);
    }
    result.setNestedPath(nestedPath);
    if (validation != null) {
        result.validation(validation);
    }
    return result;
}

Example 2 with DistanceUnit

use of org.elasticsearch.common.unit.DistanceUnit in project elasticsearch by elastic.

the class GeoDistanceQueryBuilder method fromXContent.

public static GeoDistanceQueryBuilder fromXContent(QueryParseContext parseContext) throws IOException {
    XContentParser parser = parseContext.parser();
    XContentParser.Token token;
    float boost = AbstractQueryBuilder.DEFAULT_BOOST;
    String queryName = null;
    String currentFieldName = null;
    GeoPoint point = new GeoPoint(Double.NaN, Double.NaN);
    String fieldName = null;
    Object vDistance = null;
    DistanceUnit unit = GeoDistanceQueryBuilder.DEFAULT_DISTANCE_UNIT;
    GeoDistance geoDistance = GeoDistanceQueryBuilder.DEFAULT_GEO_DISTANCE;
    GeoValidationMethod validationMethod = null;
    boolean ignoreUnmapped = DEFAULT_IGNORE_UNMAPPED;
    while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
        if (token == XContentParser.Token.FIELD_NAME) {
            currentFieldName = parser.currentName();
        } else if (parseContext.isDeprecatedSetting(currentFieldName)) {
        // skip
        } else if (token == XContentParser.Token.START_ARRAY) {
            fieldName = currentFieldName;
            GeoUtils.parseGeoPoint(parser, point);
        } else if (token == XContentParser.Token.START_OBJECT) {
            throwParsingExceptionOnMultipleFields(NAME, parser.getTokenLocation(), fieldName, currentFieldName);
            // the json in the format of -> field : { lat : 30, lon : 12 }
            String currentName = parser.currentName();
            fieldName = currentFieldName;
            while ((token = parser.nextToken()) != XContentParser.Token.END_OBJECT) {
                if (token == XContentParser.Token.FIELD_NAME) {
                    currentName = parser.currentName();
                } else if (token.isValue()) {
                    if (currentName.equals("lat")) {
                        point.resetLat(parser.doubleValue());
                    } else if (currentName.equals("lon")) {
                        point.resetLon(parser.doubleValue());
                    } else if (currentName.equals("geohash")) {
                        point.resetFromGeoHash(parser.text());
                    } else {
                        throw new ParsingException(parser.getTokenLocation(), "[geo_distance] query does not support [" + currentFieldName + "]");
                    }
                }
            }
        } else if (token.isValue()) {
            if (DISTANCE_FIELD.match(currentFieldName)) {
                if (token == XContentParser.Token.VALUE_STRING) {
                    // a String
                    vDistance = parser.text();
                } else {
                    // a Number
                    vDistance = parser.numberValue();
                }
            } else if (UNIT_FIELD.match(currentFieldName)) {
                unit = DistanceUnit.fromString(parser.text());
            } else if (DISTANCE_TYPE_FIELD.match(currentFieldName)) {
                geoDistance = GeoDistance.fromString(parser.text());
            } else if (currentFieldName.endsWith(".lat")) {
                point.resetLat(parser.doubleValue());
                fieldName = currentFieldName.substring(0, currentFieldName.length() - ".lat".length());
            } else if (currentFieldName.endsWith(".lon")) {
                point.resetLon(parser.doubleValue());
                fieldName = currentFieldName.substring(0, currentFieldName.length() - ".lon".length());
            } else if (AbstractQueryBuilder.NAME_FIELD.match(currentFieldName)) {
                queryName = parser.text();
            } else if (AbstractQueryBuilder.BOOST_FIELD.match(currentFieldName)) {
                boost = parser.floatValue();
            } else if (IGNORE_UNMAPPED_FIELD.match(currentFieldName)) {
                ignoreUnmapped = parser.booleanValue();
            } else if (VALIDATION_METHOD_FIELD.match(currentFieldName)) {
                validationMethod = GeoValidationMethod.fromString(parser.text());
            } else {
                if (fieldName == null) {
                    point.resetFromString(parser.text());
                    fieldName = currentFieldName;
                } else {
                    throw new ParsingException(parser.getTokenLocation(), "failed to parse [{}] query. unexpected field [{}]", NAME, currentFieldName);
                }
            }
        }
    }
    if (vDistance == null) {
        throw new ParsingException(parser.getTokenLocation(), "geo_distance requires 'distance' to be specified");
    }
    GeoDistanceQueryBuilder qb = new GeoDistanceQueryBuilder(fieldName);
    if (vDistance instanceof Number) {
        qb.distance(((Number) vDistance).doubleValue(), unit);
    } else {
        qb.distance((String) vDistance, unit);
    }
    qb.point(point);
    if (validationMethod != null) {
        qb.setValidationMethod(validationMethod);
    }
    qb.geoDistance(geoDistance);
    qb.boost(boost);
    qb.queryName(queryName);
    qb.ignoreUnmapped(ignoreUnmapped);
    return qb;
}

Example 3 with DistanceUnit

use of org.elasticsearch.common.unit.DistanceUnit in project elasticsearch by elastic.

the class GeoDistanceQueryBuilderTests method doCreateTestQueryBuilder.

@Override
protected GeoDistanceQueryBuilder doCreateTestQueryBuilder() {
    GeoDistanceQueryBuilder qb = new GeoDistanceQueryBuilder(GEO_POINT_FIELD_NAME);
    String distance = "" + randomDouble();
    if (randomBoolean()) {
        DistanceUnit unit = randomFrom(DistanceUnit.values());
        distance = distance + unit.toString();
    }
    int selector = randomIntBetween(0, 2);
    switch(selector) {
        case 0:
            qb.distance(randomDouble(), randomFrom(DistanceUnit.values()));
            break;
        case 1:
            qb.distance(distance, randomFrom(DistanceUnit.values()));
            break;
        case 2:
            qb.distance(distance);
            break;
    }
    Point p = RandomShapeGenerator.xRandomPoint(random());
    qb.point(new GeoPoint(p.getY(), p.getX()));
    if (randomBoolean()) {
        qb.setValidationMethod(randomFrom(GeoValidationMethod.values()));
    }
    if (randomBoolean()) {
        qb.geoDistance(randomFrom(GeoDistance.values()));
    }
    if (randomBoolean()) {
        qb.ignoreUnmapped(randomBoolean());
    }
    return qb;
}

Example 4 with DistanceUnit

use of org.elasticsearch.common.unit.DistanceUnit in project elasticsearch by elastic.

the class CircleBuilderTests method mutate.

static CircleBuilder mutate(CircleBuilder original) throws IOException {
    CircleBuilder mutation = copyShape(original);
    double radius = original.radius();
    DistanceUnit unit = original.unit();
    if (randomBoolean()) {
        if (original.center().x > 0.0 || original.center().y > 0.0) {
            mutation.center(new Coordinate(original.center().x / 2, original.center().y / 2));
        } else {
            // original center was 0.0, 0.0
            mutation.center(randomDouble() + 0.1, randomDouble() + 0.1);
        }
    } else if (randomBoolean()) {
        if (radius > 0) {
            radius = radius / 2;
        } else {
            radius = randomDouble() + 0.1;
        }
    } else {
        DistanceUnit newRandom = unit;
        while (newRandom == unit) {
            newRandom = randomFrom(DistanceUnit.values());
        }
        ;
        unit = newRandom;
    }
    return mutation.radius(radius, unit);
}