Struct elastic_types::geo::point::GeoPoint

pub struct GeoPoint<F, M = DefaultGeoPointMapping<F>> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>,  { /* fields omitted */ }

An Elasticsearch geo_point type with a format.

The format is provided as a generic parameter. This struct wraps up a geo::Point struct, which have an x and y floating point value.

Examples

Defining a geo point using the default format:

let point: GeoPoint<DefaultGeoPointFormat> = GeoPoint::build(1.0, 1.0);

Defining a geo point using a named format:

let point: GeoPoint<GeoPointString> = GeoPoint::build(1.0, 1.0);

Defining a geo point using a custom mapping:

let point: GeoPoint<GeoPointString, DefaultGeoPointMapping<_>> = GeoPoint::build(1.0, 1.0);

Accessing the values of a geo point:

let point: GeoPoint<DefaultGeoPointFormat> = GeoPoint::build(1.0, 1.0);

//eg: (1.0,1.0)
println!("({},{})",
        point.x(),
    point.y()
);

Links

• Elasticsearch Doc

Methods

impl<F, M> GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn new<I>(point: I) -> GeoPoint<F, M> where
    I: Into<P<f64>>, 

Creates a new GeoPoint from the given coordinate.

This function will consume the provided Coordinate.

Examples

use geo::{ Point, Coordinate };
use elastic_types::geo::point::{ GeoPoint, DefaultGeoPointFormat };

//Create a geo Coordinate struct
let coord = Coordinate { x: 1.0, y: 1.0 };

//Give it to the GeoPoint struct
let point: GeoPoint<DefaultGeoPointFormat> = GeoPoint::new(Point(coord));

fn build(x: f64, y: f64) -> GeoPoint<F, M>

Creates an GeoPoint from the given x and y primitives:

let point: GeoPoint<DefaultGeoPointFormat> = GeoPoint::build(1.0, 1.0);

fn remap<FInto, MInto>(self) -> GeoPoint<FInto, MInto> where
    FInto: GeoPointFormat,
    MInto: GeoPointMapping<Format = FInto>, 

Change the format/mapping of this geo point.

Examples

//Get a point formatted as a string
let point: GeoPoint<GeoPointString> = GeoPoint::build(1.0, 1.0);

//Change the format to an object
let otherpoint: GeoPoint<GeoPointObject> = point.remap();

Methods from Deref<Target = P<f64>>

fn x(&self) -> T

Returns the x/horizontal component of the point.

use geo::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.x(), 1.234);

fn y(&self) -> T

Returns the y/vertical component of the point.

use geo::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.y(), 2.345);

fn lng(&self) -> T

Returns the longitude/horizontal component of the point.

use geo::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.lng(), 1.234);

fn lat(&self) -> T

Returns the latitude/vertical component of the point.

use geo::Point;

let p = Point::new(1.234, 2.345);

assert_eq!(p.lat(), 2.345);

fn dot(&self, point: &Point<T>) -> T

Returns the dot product of the two points: dot = x1 * x2 + y1 * y2

use geo::Point;

let p = Point::new(1.5, 0.5);
let dot = p.dot(&Point::new(2.0, 4.5));

assert_eq!(dot, 5.25);

Trait Implementations

impl<F: Debug, M: Debug> Debug for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<F: Clone, M: Clone> Clone for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn clone(&self) -> GeoPoint<F, M>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: PartialEq, M: PartialEq> PartialEq for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn eq(&self, __arg_0: &GeoPoint<F, M>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &GeoPoint<F, M>) -> bool

This method tests for !=.

impl<F, M> GeoPointFieldType<M, F> for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

impl<M, F> From<P<f64>> for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn from(value: P<f64>) -> Self

Performs the conversion.

impl<M, F> AsRef<P<f64>> for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn as_ref(&self) -> &P<f64>

Performs the conversion.

impl<M, F> PartialEq<P<f64>> for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn eq(&self, other: &P<f64>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &P<f64>) -> bool

This method tests for !=.

impl<M, F> Deref for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

type Target = P<f64>

The resulting type after dereferencing

fn deref(&self) -> &P<f64>

The method called to dereference a value

impl<F, M> From<C<f64>> for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn from(point: C<f64>) -> GeoPoint<F, M>

Performs the conversion.

impl<F, M> ToGeo<f64> for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn to_geo(&self) -> G<f64>

impl<F, M> Serialize for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> where
    S: Serializer, 

Serialize this value into the given Serde serializer.

impl<'de, F, M> Deserialize<'de> for GeoPoint<F, M> where
    F: GeoPointFormat,
    M: GeoPointMapping<Format = F>, 

fn deserialize<D>(deserializer: D) -> Result<GeoPoint<F, M>, D::Error> where
    D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.