Data Reference

DataInput is a protocol used to limit the type of data that can be sent to Tealium to later serialize it into JSON.

Converting a custom object to a DataInput can be done easily by adopting the DataInputConvertible protocol and implementing the DataInputConvertible.toDataInput() method for a safe conversion.

Valid DataInput can only be:

• a String
• a Number: Int, Int64, Double, Float, Decimal, NSNumber
• a Bool

• an Array or Dictionary containing only Strings, Numbers or Booleans or other nested Arrays and Dictionaries containing other valid DataInput

Use this protocol to convert custom types to a valid DataInput.

This is particularly useful for types like enums or objects that can be safely represented with a Dictionary or an Array or a combination of nested Dictionaries and Arrays. Everything that is not a Dictionary or an Array, including the elements contained in those collections, need to be one of the supported DataInput.

For cases in which you have only nested Arrays and Dictionaries that only contain valid DataInput, implementing this protocol is not necessary and you can just wrap them with the prebuilt DataItem wrapper.

Although not preferable, you can make any Encodable type a DataInputConvertible by wrapping it with DataItem(serializing:). Note that this method can fail, so you must handle the eventual EncodingError that can be thrown in case of failure.

A wrapper class that contains a generic JSON value.

You can use the utility getters to obtain the value in the correct type:

• You can read any number as Int/Float/Double/NSNumber intercheangebly since it’s backed by an NSNumber on disk.

• Arrays and Dictionaries will always contain DataItem as values and you can use specific getter to get the correct types from them too.

Mistake example:

  let numbers: [Int?]? = DataItem(value: [1, 2, 3]).getDataArray() as? [Int?] // Cast will fail and numbers will be nil
  let numbers: [Int?]? = DataItem(value: [1, 2, 3]).getArray() // This will succeed
  let numbers: [Int?]? = DataItem(value: [1, 2, 3]).getDataArray().map { $0.getInt() } // This will also succeed
  let numbers: [Int]? = DataItem(value: [1, 2, 3]).getArray().compactMap { $0 } // This will also succeed and remove potentially nil values from the array

Classes that implement this protocol should be able to reconstruct an object of type Convertible from a given DataItem, on the assumption that the DataItem accurately describes all components required to create a new instance of type Convertible.

A container of key-value pairs that can return a DataItem for a given String key.

A custom wrapper around a common Dictionary used to limit the DataInput types into the Dictionary.

Only valid DataInput types will be stored in the inner Dictionary and only DataInputConvertible types can be used to initialize this wrapper object.

Use this protocol to convert custom types to their DataObject representation.

Generic data storage for storing DataInput and retrieving DataItem objects.

Implementations are not guaranteed to be persistent. For instance, in cases where there may be insufficient storage space on the device, or other reasons such as write permissions etc.

Stored data requires an Expiry to be provided when storing, and expired data will not be included in any retrieval operations; that is, expired data won’t be returned by get or getAll but it will also not be included in any aggregate methods such as keys or count.

A data store edit for a specific key

Enables editing multiple entries in the module storage in a transactional way.

Errors that can occur during database operations.

The expiration type of some persisted value.

Represents a tracking event or view to be dispatched.

Context with information around the track that generated the Dispatch request.

The type of dispatch being sent.

A JSONPath that can be applied to a JSON array to represent the path to a potentially nested value. Nested items can be in both JSON objects and JSON arrays.

To create a path like [0].container.array[0].property you can use a subscript for each path component:

 JSONPath[0]["container"]["array"][0]["property"]

A JSONPath that can be applied to a JSON object to represent the path to a potentially nested value. Nested items can be in both JSON objects and JSON arrays.

To create a path like container.array[0].property you can use a subscript for each path component:

 JSONPath["container"]["array"][0]["property"]

A structure representing the location of an item in a JSON object or JSON array, potentially nested in other JSON objects and JSON arrays.

To create a basic JSONPath you can call the JSONPath subscript with a String or an Int depending on where you want to start the path from: the first one would start from a JSON object, the second would start from a JSON array.

 let objectPath = JSONPath["container"]
 let arrayPath = JSONPath[0]

To create a path like container.array[0].property you can use a subscript for each path component:

 JSONPath["container"]["array"][0]["property"]

A generic container of items that can return a DataItem for a given JSONPath.

An error occurred while trying to parse a String into a JSONPath

A Phantom Type used to specify a type of JSONPath that can be applied to a JSON array.

A Phantom Type used to specify a type of JSONPath that can be applied to a JSON object.

An internal protocol used to differentiate between ObjectRoot and ArrayRoot. Do not adopt this protocol in other types.

A container for a reference to a variable in the data layer.

A container for a string value

A container for a value that is stored as a DataItem.

A type-erased Codable value.

The AnyCodable type forwards encoding and decoding responsibilities to an underlying value, hiding its specific underlying type.

You can encode or decode mixed-type values in dictionaries and other collections that require Encodable or Decodable conformance by declaring their contained type to be AnyCodable.

A type-erased Decodable value.

The AnyDecodable type forwards decoding responsibilities to an underlying value, hiding its specific underlying type.

You can decode mixed-type values in dictionaries and other collections that require Decodable conformance by declaring their contained type to be AnyDecodable:

let json = “”“ { "boolean”: true, “integer”: 1, “double”: 3.14159265358979323846, “string”: “string”, “array”: [1, 2, 3], “nested”: { “a”: “alpha”, “b”: “bravo”, “c”: “charlie” } } “”“.data(using: .utf8)!

let decoder = JSONDecoder() let dictionary = try! decoder.decode([String: AnyCodable].self, from: json)

A type-erased encodable value that forwards encoding responsibilities to an underlying value.