TomTomSDKCommon

A class for restricting protocol conformance to TomTomSDK components.

Protocols that inherit this protocol are considered locked and can be conformed to and implemented only inside the TomTomSDK.

// An example of protocol that provides necessary functionality in the TomTomSDK.
public protocol Planner: ConformanceLocked {
    func plan()
}

// An abstraction from the client side that provides the same interface but is not locked.
// Every TomTomSDK protocol might need this protocol clone.
// Use this type to pass it in the application and in tests.
protocol ClientPlanner {
   // The method should have the same signature
   func plan()
}

// Wrapper implementation on the client side that will contain TomTomSDK dependency
// but conform to the non-locked protocol
class ClientWrapperPlanner: ClientPlanner {
    let planner: Planner
    init(_ planner: Planner) {
        self.planner = planner
    }

    func plan() {
        planner.plan()
    }
}

// An example of the production code that needs to be tested.
// Use `ClientPlanner` in your production code, so you can mock it.
struct PlannerViewModel {
   init(_ planner: ClientPlanner) { }
   //
   // ...
}

// In production code
let planner: Planner = ... // getting real planner
PlannerViewModel(ClientWrapperPlanner(planner))

By depending on `ClientPlanner` a `PlannerViewModel` instance can be tested
by mocking all its dependencies. To mock its dependencies, replace `ClientWrapperPlanner` with a
mocked implementation of `ClientPlanner`.

Information about one of the connectors available in the ChargingPark.

The connector type.

This list is based on the supported connector types by online search, documented at the following link: https://developer.tomtom.com/search-api/documentation/product-information/supported-connector-types

Describes the type of electric current

A charging point corresponds to an EVSE (Electric Vehicle Supply Equipment). This can be thought of as the charging facility capable of accomodating one car.

A charging station has several charging points, of which only several points can be used at the same time.

Specifies the minimum (inclusive) and maximum (exclusive) voltage values. The lower bound value should be a non-negative number (positive or zero). The upper bound value should be greater than the lower bound, or if set to zero, it will be treated as infinity. If not specified, a range of [0, infinity] is assumed.

Defines publishable and subscribable action.

Units system

Generic container for GeoJSON geometry types.

GeoJSON is a geospatial data interchange format based on JavaScript Object Notation (JSON). It defines several types of JSON objects and the manner in which they are combined to represent data about geographic features, their properties, and their spatial extents. For more info on the GeoJSON format see the following document.

A single GeoJSON position.

An array of GeoJSON positions.

An array of two or more GeoJSON positions.

An array of line string geometries. Each line string is represented by a one-dimensional GeoJSON position array.

An array of linear ring geometries. Each linear ring is represented by a one-dimensional GeoJSON position array. For polygons with multiple rings, the first must be the exterior ring and any others must be interior rings or holes.

An array of polygon geometries.

The Feature structure encapsulates a GeoJSON Feature - a geospatial object with associated properties. GeoJSON supports the following geometry types: Point, LineString, Polygon, MultiPoint, MultiLineString, MultiPolygon, and GeometryCollection. Features in GeoJSON contain a Geometry object and additional properties.

GeoJSONGeometry is an enumeration representing the seven geometry types defined in the GeoJSON format. Each case of the enum wraps a corresponding structure that provides detailed geometric data.

Fundamental geometry construct. All other GeoJSON geometry types are built based on it.

The smallest rectangular area within which all the coordinates lie.

The Geometry struct represents a single geometric entity according to the GeoJSON specification.

The GeometryCollection struct represents a collection of Geometry objects as defined by the GeoJSON specification. It provides a way to group multiple geometries together, regardless of their types.

GeoJSON represented by GeometryData.

Identifies a hazard.

A hazard.

A collection of information that describes geographical location

Information on how much to charge at a charging station.

Defines fuel types supported in the fuzzy search.

Defines the OpeningHours of a POI.

An option that defines for what days opening hours would be requested.

Point of Interest information for a search result.

Defines the source of the produced search result.

Defines the POI identifier (POIID) required to fetch POI details.

Contains information about an EV charging park.

Defines a POI brand.

POI category ID.

Defines standard the POI category identifiers. The enum value provides the semantic of the POI category. Multiple POICategoryID can have the same StandardCategoryID value.

A representation of an entry point for a POI.

Represents information about specific place.

Protocol that defines log destination, such as file, console, etc.

For more information on log configurator see LogConfigurator.

For more information on log configuration see LogConfiguration.

Identifier of the map.

Position of the map.

A reference of a map ID and arc information.

Region ID for a region inside a map.

Extending standard structures like Measurement with properties like var meters is convenient:

• it avoids extracting value without explicit conversion to a certain unit
• it simplifies getting value from an optional Measurement

But it is also risky because these extensions might conflict with extensions from other libraries or Apple. This decorator mitigates the risk of conflicts while providing a short, readable code.

Typical use cases are:

• extracting value from a value representing a unit of measure: let optionalDistanceInMeters = distance?.tt.meters
• performing computations on values representing units of measure: cumulativeDistance += anotherDistance.tt
• comparing values representing units of measure: if delay < .tt.seconds(5) {}
• combining value extraction and typecast: let intValue = distance.tt.intValue(in: .meters)

Unit specifying the electric efficiency, e.g., in kilowatt hours per kilometer.

Unit specifying the energy density (of fuel). For example, energy density is 34.2 MJ/l for gasoline and 35.8 MJ/l for diesel fuel.

Unit specifying the fuel usage (of a vehicle) over time.

A quantity describing a ratio, also commonly used for probabilities. (For example, 10%.)

MetadataProvider stores during app lifecycle additional metadata for HTTP requests to TomTom Network APIs and implements adding this additional metadata to HTTP request’s headers

Any concrete observer should conform to this protocol so we can create a weak reference to it.

Observable is an interface for a container of observers. It allows sending notifications on certain events to all of the added observers.

We provide the implementation of this protocol: TomTomSDKCommon/ObservableHandler.

A thread-safe implementation of the Observable container.

Any method can be called from any queue. The notification of observers, completions, and other closures will be executed on a dispatch queue provided in the init method.

Indicates the driving side on the road.

Total number of lanes on the road in both directions.

A coarse-grained classification of roads according to road purpose and capacity. In general, it is associated with specific horizon data.

Indicates the class of a road.

Road pavement condition types.

Provides information about the properties of the road at the current location.

Represents a road shield, a sign used to indicate the route number and the road’s classification.

Indicates the subclass of a road.

Classifies roads according to their purpose and function. The road-type classification can be used for efficient traffic flow management, avoidance of specific routes based on selected criteria, and visual differentiation of road segments on the map.

Speed limit consisting of a speed limit type and a speed limit value.

Identifies a safety location.

Define a common safety location.

Indicates the category to which a traffic event belongs.

Indicates the cause of a traffic event.

Indicates the cause of the traffic event. Codes are chosen according to the TPEG-TEC standard.

Representation of a traffic event. Traffic events represent unusual situations on the road, like traffic congestion, accidents or road works.

Indicates the severity of the traffic event. Values are chosen according to the TPEG-TEC standard.

Represents a cancellation handler over an asynchronous operation. Cancellation may be immediate or simply requested to happen sometime in the future.

A typical usage for Cancellable is to return it from the asynchronous completion-based API.

let cancellable = asynchronousFunction(completion: completion)
if shouldCancel {
   cancellable.cancel()
}

Wrapper to provide equatable conformance to Apple objects inside of the SDK.

Specifies if the vehicle should be subjected to ADR tunnel restrictions.

Specifies the ratio by which energy is converted for altitude changes.

Specifies the energy that is gained or lost by altitude changes.

Describes connector information of an electric engine.

Specifies the efficiency of the vehicle. Refer to the original type CombustionEngine.Efficiency for more information.

Describes parameters used to determine the vehicle power and consumption. Refer to the original type CombustionEngine.Consumption for more information.

A combustion vehicle engine for route planning and consumption estimation.

Specifies the efficiency of the vehicle. Refer to the original type ElectricEngine.Efficiency for more information.

Describes capacity and the consumption of the EV. Refer to the original type ElectricEngine.Consumption for more information.

Describes capacity and current charge of the EV. Refer to the original type ElectricEngine.ChargeLevel for more information.

Describes connector information of an electric engine. Refer to the original type ElectricEngine.ChargingParameters for more information.

A electric vehicle engine for route planning and consumption estimation.

Represents the types of the vehicle engine (e.g., electric).

Represents types of cargo that may be classified as hazardous materials and restricted from some roads. Available values are UN Hazmat classes 1 through 9, plus generic classifications for use in other countries. For more information about the Hazmat classes, refer to: https://www.iafc.org/topics-and-tools/hazmat/fusion-center/transportation-commodities/dot-hazard-classification-system

Trait interface for vehicles that may have electric and/or combustion engines. These vehicles may also be subject to restrictions based on their size or weight.

Both engines should be set for a hybrid vehicle. Setting no engine is also fine if consumption is irrelevant for a calculation, such as when requesting a range based on time or distance budgets.

Trait interface for vehicles that may have restrictions due to load.

Specifies the vehicle (or lack of one).

A pedestrian.

A vehicle of type bicycle.

A vehicle of type car.

A vehicle of type motorcycle.

A vehicle of type van.

A vehicle of type taxi.

A vehicle of type bus.

A vehicle of type truck.

Describes dimensions of the vehicle.

VehicleError used for exceptions indicating vehicle errors.

Describes vehicle model identifier.

Represents the “vehicle type” parameter in a request to the Routing API.

Specifies the ratio by which energy is converted during velocity changes.