anchor.diff:  + Parameters
       + entityId: Bcn_Welt (required, string) - Entity ID
       + attrName: temperature (required, string) - Attribute to be retrieved.
  -    + options: (optional, string) - Options dictionary
   
   + Response 200 (application/json)
   
  
positive.code:   "location": {
      "value": "41.3763726, 2.1864475,14",
      "type": "geo:point"
    }
  }
  ```
  
  ### Canonical format description
  
  This is a variant of the represention format aimed at clients that need a regular representation of the entities
  and attributes, that can be used in the operations that support the `canonical` option.
  
  * Entity `type` is mandatory. If the entity has no type, JSON `null` is used.
  * Property `attrs` is mandatory and includes a JSON object for the attributes.
  * Each attribute is described always with `value`, `type` and `metadata`. All fields are mandatory (attributes
    without type use JSON `null` for that property).
  * Each metadata is described always with `value` and `type`. Both fields are mandatory (metadata
    without type use JSON `null` for that property).
  
  ```
  {
    "type": "Room",
    "id": "Boe_Idearium",
    "attrs": {
      "speed": {
        "value": 88,
        "type": null,
        "metadata": { }
      },
      "pressure": {
        "value": 12.1,
        "type": null,
        "metadata": { }
      },
      "temperature": {
        "value": 22,
        "type": "urn:phenomenum:temperature",
        "metadata": { }
      },
      "colour": {
        "value": "black",
        "type": "myString",
        "metadata": { }
      }
    }
  }
  ```
  
negative.code: (placeholder to describe roles like context provider, context producer,
  context broker, context registry, context consumer)
  
  ## JSON Entity Representation
  
  An entity is represented by a JSON object with the following syntax:
  
  * The entity id is specified by the object's `id` property, which value is a string containing the entity id.
  
  * The entity type is specified by the object's `type` property, which value is a string containing the entity's type name.
  
  * Entity attributes are specified by additional properties, which name is the `name` of the attribute and which representation
    is described in the JSON Attribute Representation section below. Obviously, `id` and `type` are not allowed as attribute names.
  
  An example of this syntax in shown below:
  
  ```
  {
    "id": "entityID",
    "type": "entityType",
    "attr_1": <val_1>,
    "attr_2": <val_2>,
    ...
    "attr_N": <val_N>
  }
  ```
  
  The normalized representation of entities always include `id`, `type` and the properties which represent attributes. However, simplified
  or partial representations (see below at Partial Representations section), may leave out some of them. The specification of each operation
  includes details about what  representation is expected as input or what representation will be provided (rendered) as output.
  
  ## JSON Attribute Representation
  
  An attribute is represented by a JSON object with the following syntax:
  
  * The attribute value is specified by the `value` property, which value may be any JSON datatype.
  
  * The attribute NGSI type is specified by the `type` property, which value is a string containing the NGSI type.
  
  * The attribute metadata is specified by the `metadata` property. Its value is another JSON object which will contain a
    property per metadata element defined (the name of the property is the `name` of the metadata element). Each metadata element,
    in turn, is represented by a JSON object containing the following properties:
  
    * `value`: Its value will contain the metadata value, which may correspond to any JSON datatype.
  
    * `type`: Its value will contain a string representation of the metadata NGSI type.
  
  An example of this syntax in shown below:
  
  ```
  {
    "value": <...>,
    "type": <...>,
    "metadata": <...>
  }
  ```
  
  ## Simplified Entity Representation
  
  There are two representation modes, which must be supported by implementations, and which allow to generate simplified representations of entities.
  
  * *keyValues* mode. This mode represents each entity attribute only by its value, leaving out the information about type and metadata.
    Thus, when this mode is on, only the attribute value is represented and will correspond to the value of the property which represents the attribute.
    See example below (To be provided).
  
  ```
  {
     "id": "R12345",
     "type": "Room",
     "temperature": 22
  }
  ```
  
  * *values mode*. This mode represents the entity only by a collection of attribute values conveyed by an Array. Id and type information are left out.
    See example below.
  
  ```
  [ 'Ford', 'black', 78.3 ]
  ```
  
  ## Partial Representations
  
  Some operations imply that only a partial representation of an entity will be provided, which are summarized below:
  
  * `id` and `type` are not allowed in update operations, as they are inmutable properties.
  
  * In the requests in which `type` is allowed, it may be omitted. When omitted, the default value `null` is used for the type.
  
  * In some cases, not all the attributes of the entity are shown, e.g. a query which selects a subset of entity attributes.
  
  * Attribute/metadata `value` may be omitted in requests, meaning that the attribute/metadata has `null` value. It is always present in responses.
  
  * Attribute/metadata `type` may be ommitted in requests, meaning that the attribute/metadata doesn't have a NGSI type. In responses, this
    property is set to `null` if the attribute doesn't have a type.
  
  * Attribute `metadata` may be ommitted in requests, meaning that there are not metadata elements associated to the attribute. In responses, this property is set to
    `{}` if the attribute doesn't have metadata.
  
  
  ## Special attribute types
  
  Generally speaking, user-defined attribute types are informative, they are processed by the NGSIv2 server in
  an opaque way. Nonetheless, the types described below are used to convey an special meaning
  