anchor.diff:   
   ## Geographical Queries
   
  -Geographical queries are specified by means of the `geometry` and `coords` parameters.
  -
  -**geometry** defines a geografical area so that only those entities located in such area match the query.
  -It is composed of a token list separated by ';'. The first token is the shape of the geometry,
  -the rest of tokens (if any) depends on the shape. 
  -
  -In particular, the following geometries are supported:
  -
  -+ `geometry=circle;radius:4000`, inside a circle (radius is in meters).
  -+ `geometry=circle;radius:4000;external`, outside a circle (radius is in meters).
  -+ `geometry=polygon`, inside a polygon.
  -+ `geometry=polygon;external`, outside a polygon.
  -
  -**coords** represents a a list of pairs of geographical coordinates (latitude, longitude) separated by ','.
  -Every pair of coordinates represent a geographical point. The list length and its semantics depend on the shape
  -specified by the **geometry** parameter:
  -
  -+ In the case of `circle` geometry, the parameter includes just one element, which
  -  is the center of the circle.
  -+ In the case of `polygon` includes a list of elements, which are the vertices of the polygon.
  -
  +Geographical queries are specified by means of the following parameters:
  +
  +``georel`` is intended to specify a spatial relationship (a predicate)
  +between matching entities and a reference shape (`geometry`).
  +It is composed of a token list separated by ';'.
  +The first token is the relationship name, the rest of tokens (if any) are modifiers which
  +provide more information about such a relationship. The following values are allowed:
  +
  ++ `georel=near`. The ``near`` relationship means that matching entities must be located at certain threshold
  +distance to the reference geometry. It supports the following modifiers:
  +  + `maxDistance`.  Express, in meters, the maximum distance at which matching entities must be located.
  +  + `minDistance`.  Express, in meters, the minimum distance at which matching entities must be located.
  ++ `georel=coveredBy`. Denotes that matching entities are those which exist entirely within the reference geometry.
  +When resolving this query the border of a shape must be considered to be part of the shape. 
  ++ `georel=intersects`. Denotes that matching entities will be those intersecting with the reference geometry.
  ++ `georel=equals`. The geometry associated to the position of matching entities
  +and the reference geometry must be exactly the same.
  ++ `georel=disjoint`. Denotes that matching entities will be those NOT intersecting with the reference geometry. 
  +
  +`geometry` allows to define the reference shape to be used when resolving the query.
  + The following geometries (see Simple Location Format) must be supported:
  +
  ++ `geometry=point`, defines a point on the Earth surface.
  ++ `geometry=line`, defines a polygonal line.
  ++ `geometry=polygon`, defines a polygon.
  ++ `geometry=box`, defines a bounding box.
  +
  +**coords** must be a string containing a comma separated list of pairs of geographical coordinates
  +in accordance with the geometry specified and the rules mandated by the Simple Location Format:
  +
  +* `geometry=point`.   `coords` will contain a pair of WGS-84 geo-coordinates.
  +* `geometry=line`.    `coords` will contain a list of pairs of WGS-84 geo-coordinates.
  +* `geometry=polygon`. `coords` will be composed by at least four pairs of WGS-84 geo-coordinates.
  +* `geometry=box`.     `coords` will be composed by two pairs of WGS-84 geo-coordinates.
  +
  +Examples:
  +
  +`georel=near;maxDistance=1000&geometry=point&coords=-40.4,-3.5`.
  +Matching entities will be located, at a maximum, 1000 meters far away from the reference point.
  +
  +`georel=near;minDistance=5000&geometry=point&coords=-40.4,-3.5`.
  +Matching entities will be at least 5000 meters far away from the reference point. 
  +
  +`georel=coveredBy&geometry=polygon&coords=25.774,-80.190,18.466,-66.118,32.321,-64.757,25.774,-80.190`
  +Matching entities will be those located within the referred polygon.
  +
  +### Query Resolution
  +
  +If an implementation is not able to resolve a geographical query, the HTTP Status code of the response
  +must be ```422```, *Unprocessable Entity*. The error name present in the error payload must be
  +``NotSupportedQuery``. 
  +
  +When resolving geographical queries, through the Simple Query Language,
  +the API implementation is responsible for determining which entity attribute
  +contains the geographical location to be used for matching purposes.
  +To this aim, the following rules must be followed:
  +
  +* If an entity has no attribute which corresponds to a location (encoded as GeoJSON or the
  +Simple Location Format), then such an entity has not declared any geospatial property and will not match any
  +geographical query.
  +
  +* If an entity only exposes one attribute corresponding to a location, then such an attribute will be used when
  +resolving geographical queries.
  +
  +* If an entity exposes more than one location, then the attribute which contains a metadata property
  +named ``defaultLocation``, with boolean value ``true``
  +will be taken as the reference location used for resolving geographical queries.
  +
  +* If there is more than one attribute exposing location but none of them has been labeled as being the
  +default location, then the query will be declared as ambigous and an HTTP error response with code ``409``
  +must be sent.
  +
  +* If there is more than one attribute exposing location which has been labeled as being the
  +*default location*, then the query will be declared as ambigous and an HTTP error response with code ``409``
  +must be sent. 
   
   ## Group API Entry Point
   
  
positive.code: }
  ```
  
  * `geo:point`: identifies the location of the entity in geo-location queries. If an entity have several attributes
    of this type all them define a possible location for the entity from a geo-location query point of view. (TBD:
    check feasibility). An example can be found below (only the referred entity attribute is shown). 
  
  ```
  {
    "location": {
      "value": "41.3763726, 2.1864475,14",
      "type": "geo:point"
    }
  }
  ```
  
  ## Error responses
  
  In the case of being present, the error payload is JSON object including the following fields:
  
  + `error` (required, string): a textual description of the error.
  + `description` (optional, string): additional information about the error.
  + `affectedItems` (optional, array[string]): a list of elements affected by the error. Depending on the operation, it may
    refer to entities, registrations or subscriptions.
  
  Error list (HTTP response code in paranthesis):
  
  * ParseError (400). The incoming JSON payload is incorrect.
  * BadRequest (400). The incoming request is somehow invalid.
  * NotFound (404). The context element referred in the request has not been found.
  * TooManyResults (409). There are several results that match with the resource identification used
    in the request. This typically the case of requesting an entity with not enough information and the
    solution is to enhance entity identification adding more information, e.g. adding entity type
    and/or service path.
  * LengthRequired (411). Zero/No Content-Length in PUT/POST/PATCH request
  * RequestEntityTooLarge (413). Payload too large
  * UnsupportedMediaType (415). Request content type is not supported.
  * InvalidModification (422). Some piece of information is missing in payload.
  
  ## Simple Query Language
  
  
negative.code:       be used with attributes which contain dates or numbers. E.g. `temperature!=10..20` matches if
        the temperature is lower than 10 or greater than 20 (it will not match if the tempeature is 10 or the
        temperature is 20).
  + **Greater than**: `>`. The value is a single element, e.g. `temperature>40`. It
    matches entities which attribute value is strictly greater than that value. It only makes sense when
    used with attributes which contain dates or numbers (using with attributes of other type might lead to
    unexpected results).
  + **Lesser than**: `<`. The value is a single element, e.g. `temperature<40`. It
    matches entities which attribute value is strictly lesser than that value. It only makes sense when
    used with attributes which contain dates or numbers (using with attributes of other type might lead to
    unexpected results).
  + **Greater or equal than**: `>=`. The value is a single element, e.g. `temperature>=40`.
    It matches entities which attribute value is greater than or equal to that value. It only makes sense when
    used with attributes which contain dates or numbers (using with attributes of other type might lead to
    unexpected results).
  + **Lesser or equal than**: `<=`. The value is a single element, e.g. `temperature<=40`. It
    matches entities which attribute value is lesser than or equal to that value. It only makes sense when
    used with attributes which contain dates or numbers (using with attributes of other type might lead to
    unexpected results).
  
  In the case of equal or unequal, if the value to match include a `,`, you can use simple quote
  (`'`), e.g: `color=='light,green','deep,blue'`.
  
  Unary statements are composed of a unary operator (either `+`or `-`) and are used in two situations:
  