Protocols

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`.

Defines publishable and subscribable action.

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.

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 registered observers.

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

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()
}

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).