Other Classes

Undocumented

Encapsulates the definitions from a parsed Open Data Protocol (OData) service metadata (CSDL) document.

Exception thrown when an error occurs during the parsing of an Open Data Protocol (OData) service metadata (CSDL) document.

Callback which can locate and fetch the text of an Open Data Protocol (OData) service metadata (CSDL) document.

Bitmask flags for CsdlParser.csdlOptions.

Parser for Open Data Protocol (OData) service metadata documents (CSDL). A new parser should be created for each parse call. A parser should not be shared by multiple threads.

OData CSDL compatibility checker.

Encapsulates an Open Data Protocol (OData) metadata reference.

A list of item type CsdlReference.

Encapsulates an OData aggregate expression item.

A list of item type AggregateExpression.

Represents the ‘from’ clause in an aggregate transformation.

A list of “aggregate from” transformations.

Represents the method of the aggregate transformation.

Encapsulates an OData aggregate transformation.

A list of aggregate transformations.

Abstract base class for top and bottom transformations.

Represents an OData annotation.

Encapsulates an OData term definition.

Predefined basic types.

DataValue subclass that wraps a value of type binary.

DataValue subclass that wraps a value of type boolean.

Represents the bottom* transformations.

Abstract base class for byte streams.

DataValue subclass that wraps a value of type byte.

A token for requesting the cancellation of asynchronous requests.

Listener for notification of request cancellation.

A list of item type CancellationListener.

Encapsulates an OData changed link.

Abstract base class for char streams, using UTF-16 code units.

DataValue subclass that wraps a value of type char.

Encapsulates the metadata of an OData complex type.

A list of item type ComplexType.

A map from key type string to value type ComplexType.

Encapsulates an OData complex value.

A list of item type ComplexValue.

A map from key type string to value type ComplexValue.

Represents the ‘concat’ transformation.

Abstract base class for data exceptions.

Format constants for use with data protocols.

Exception thrown when data does not match the expected format.

Encapsulates the metadata of an OData function or action.

Encapsulates the application of an OData method (function or action) to a list of parameters. This is used to represent calls to actions and functions defined within an entity model, as opposed to QueryFunction which is used to represent calls to builtin functions.

A map from key type string to value type DataMethod.

Exception thrown when a request fails due to a data network issue.

Used together with DataQuery to represent a select, expand or sort item which is a single-part or multi-part path expression. For example, a path whose OData URL representation is “Address/City” might be used to access the “City” property in a complex-typed “Address” property. Also used to represent paths in OData CSDL.

Exception thrown when a query cannot be parsed or evaluated.

Represents an OData data schema.

Exception thrown when a problem is detected with a data schema.

Exception thrown when a DataService request fails due to a data service issue.

Exception thrown when a DataService request fails due to a data storage issue.

Represents a data type defined by XML Schema Part 2: Datatypes or OData. String, binary, boolean, numeric and calendar types use XML Schema nomenclature. Geography, geometry, complex and entity types use OData nomenclature.

A list of item type DataType.

A map from key type string to value type DataType.

Abstract base class for wrapper classes that wrap basic data values as objects, as well as calendar values, geography values, geometry values, ComplexValue, EntityValue and ListBase.

A list of item type DataValue.

A map from key type string to value type DataValue?.

Constant codes to represent OData versions.

Utility functions for date numbering.

Constants to represent days of the week (Monday = 1 to Sunday = 7, using ISO 8601 conventions).

Represents the XML Schema dayTimeDuration type.

A list of item type DayTimeDuration.

DataValue subclass that wraps a value of type decimal.

A stream of delta items, each of which is either an EntityValue or a ChangedLink. While processing a stream, a delta link may be encountered, but it will not be immediately available to the caller. The deltaLink can be obtained only after the stream is closed.

Example

let deltaStream = ...
while (deltaStream.next())
{
    if (deltaStream.hasEntity())
    {
        let entity = deltaStream.getEntity()
        // Process entity value.
    }
    else
    {
        let link = deltaStream.getLink()
        // Process changed link.
    }
}
deltaStream.close()
var deltaLink = deltaStream.deltaLink
// Save delta link for later use.

DataValue subclass that wraps a value of type double.

Represents an OData entity container.

Encapsulates an OData entity key.

Encapsulates the metadata of an OData entity set. Also used for OData isSingleton entities.

A list of item type EntitySet.

A map from key type string to value type EntitySet.

A stream of entity values.

Encapsulates the metadata of an OData entity type.

Encapsulates an OData entity value.

A list of item type EntityValue.

A map from key type string to value type EntityValue.

Encapsulates the metadata of an OData enum type.

A map from key type string to value type EnumType.

Encapsulates an OData enum value.

A list of item type EnumValue.

A map from key type string to value type EnumValue.

Encapsulates an OData error response.

Encapsulates an OData expand item. An expand item indicates a property (or expression) that is used in the $expand system query option.

Represents the ‘expand’ transformation.

Convenience class for the abbreviated creation of expand queries with nested select/expand/filter.

Represents the ‘filter’ transformation.

DataValue subclass that wraps a value of type float.

A collection of geography values.

A sequence of geography points which represents a joined string of lines.

A sequence of geography line strings.

A sequence of geography points.

A sequence of geography polygons.

A geography point.

A sequence of geography multi-points which represents a polygon. The first multi-point coordinate is the exterior ring, any others are interior rings.

Abstract base class for geography data values.

A list of item type GeographyValue.

A collection of geometry values.

A sequence of geometry points which represents a joined string of lines.

A sequence of geometry line strings.

A sequence of geometry points.

A sequence of geometry polygons.

A geometry point.

A sequence of geometry multi-points which represents a polygon.

Abstract base class for geometry data values.

A list of item type GeometryValue.

Abstract base class for geospatial (geography/geometry) data values.

Represents the XML Schema dateTime type with zone offset.

A list of item type GlobalDateTime.

Represents the ‘groupby’ transformation.

Encapsulates an OData GUID value.

A list of item type GuidValue.

Represents the ‘identity’ transformation.

DataValue subclass that wraps a value of type int.

DataValue subclass that wraps a value of type integer.

Object to discover server-only navigation properties between a source entity type, a target entity type and a join entity type. The source is the entity containing the navigation property which owns this JoinSetRelations instance. The target is the entity which is connected to the sorce entity with the navigation property. JoinSet is an entity between the source and the target. This exists only on the server side, and connects the source and the target entities.

Represents the ‘join’ transformation.

A list of item type PointCoordinates.

Base class for strongly-typed lists.

Exception thrown when a data value literal is invalid.

Represents the XML Schema date type without zone offset.

A list of item type LocalDate.

Represents the XML Schema dateTime type without zone offset.

A list of item type LocalDateTime.

Represents the XML Schema time type without zone offset.

A list of item type LocalTime.

DataValue subclass that wraps a value of type long.

Base class for strongly-typed maps.

A lock for ensuring thread-safe access to mutable service metadata. See ReadWriteLock for notes regarding lock reentrancy for writers.

Constants to represent months of the year.

A list of item type LineStringCoordinates.

A list of item type PointCoordinates.

A list of item type PolygonCoordinates.

Represents an OData navigation property.

Represents the ‘orderby’ transformation.

Encapsulates an OData parameter.

A list of item type Parameter.

Annotations that are associated with a CSDL target path that is a child of a CSDL model element.

Represents an N-dimensional point. Note that some coordinate reference systems will support only x and y dimensions.

A list of item type LineStringCoordinates.

Encapsulates the metadata of an OData structural or navigation property. Used for properties of complex and entity types.

A fixed-length mutable array of item type Property.

A list of item type Property.

Abstract base class for Property and DataPath. Values of type PropertyPath are typically used in query construction.

A list of item type PropertyPath.

A map from key type string to value type PropertyPath.

An alias reference for a data value.

Evaluator for DataQuery expressions.

Encapsulates the boolean value of an OData logical operator. Used to wrap the results of logical QueryOperator in a type-safe manner.

Example using proxy classes

open func queryWithFilterExample() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .select(Customer.customerID, Customer.companyName, Customer.contactName)
        .filter(Customer.country.equal("Germany")
            .and(Customer.contactName.greaterEqual("N")))
    // Alternate syntax using convenience operators:
    // let query = DataQuery()
    //     .select(Customer.customerID, Customer.companyName, Customer.contactName)
    //     .filter(Customer.country == "Germany" && Customer.contactName >= "N")
    let customers = try service.fetchCustomers(matching: query)
    self.showCustomers(customers)
}

Example using dynamic API

open func queryWithFilterExample() throws -> Void {
    let service = self.service
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let companyNameProperty = customerEntityType.property(withName: "CompanyName")
    let contactNameProperty = customerEntityType.property(withName: "ContactName")
    let countryProperty = customerEntityType.property(withName: "Country")
    let query = DataQuery()
        .select(customerIDProperty, companyNameProperty, contactNameProperty)
        .from(customersEntitySet)
        .filter(countryProperty.equal("Germany")
            .and(contactNameProperty.greaterEqual("N")))
    // Alternate syntax using convenience operators:
    // let query = DataQuery()
    //     .select(customerIDProperty, companyNameProperty, contactNameProperty)
    //     .from(customersEntitySet)
    //     .filter(countryProperty == "Germany" && contactNameProperty >= "N")
    let customers = try service.executeQuery(query).entityList()
    self.showCustomers(customers)
}

Represents a OData query function. Query functions are typically used within DataQuery.filter. QueryFunctionCall can be constructed using static calls on QueryFunction or, more conveniently, by chained calls on QueryValue.//! @example example.NorthwindProxyClient.queryFunctionExample

Example using proxy classes (with QueryValue chained calls)

open func queryValueFunctionExample() throws -> Void {
    let service = self.service
    let query = DataQuery().filter(Customer.address.toLower().contains("king"))
    let customers = try service.fetchCustomers(matching: query)
    self.showCustomers(customers)
}

Encapsulates the application of an OData query function to a list of arguments.

Constants for QueryFunction.code.

Represents a OData query operator. Query operators are typically used within DataQuery.filter. QueryOperatorCall can be constructed using static calls on QueryOperator or, more conveniently, by chained calls on QueryValue.

Example using proxy classes (with QueryOperator static calls)

open func queryOperatorExample() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .filter(QueryOperator.greaterEqual(QueryOperator.multiply(OrderDetail.quantity,
            OrderDetail.unitPrice),
            DecimalValue.of(DecimalFunction.fromInt(1000))))
    let details = try service.fetchOrderDetails(matching: query)
    self.showDetails(details)
}

Example using proxy classes (with QueryValue chained calls)

open func queryValueOperatorExample() throws -> Void {
    let service = self.service
    let query = DataQuery()
        .filter(OrderDetail.quantity.multiply(OrderDetail.unitPrice)
            .greaterEqual(BigDecimal(1000)))
    // Alternate syntax using overloaded operators:
    // let query = DataQuery().filter(OrderDetail.quantity * OrderDetail.unitPrice >= 1000)
    let details = try service.fetchOrderDetails(matching: query)
    self.showDetails(details)
}

Encapsulates the application of an OData query operator to a list of arguments.

Constants for QueryOperator.code.

Holds a data query and its result value. Allows conversion of the result to optional/required/list values for basic, complex and entity types.

Exception thrown when a query result cannot be converted to the expected type.

A data type reference for use in a query.

Base class for paths and properties as well as wrapped constant values and query function/operation calls. Intended to allow convenient cascaded application of query functions/operators in fluent query construction.

Exception thrown when an asynchronous request is cancelled.

Options for processing of data requests. If request options are used for repeatable requests, a new request options object should be used for each distinct request (or the repeatability properties should be reset before object re-use). The repeated execution of a failed request should re-use the original request options object without repeatable being reset beforehand.

Holds the path to a data service resource.

Represents a parsed OData search expression.

A list of item type SearchExpression.

Options for SearchExpression.matches. Reserved for future use.

Represents an OData search term (word or phrase).

Encapsulates an OData select item. A select item indicates a property (or expression) that is used in the $select system query option.

Base class for strongly-typed sets.

DataValue subclass that wraps a value of type short.

Represents a type definition for an underlying basic type.

Represents the ‘skip’ transformation.

Encapsulates an OData sort item. A sort item indicates a property (or expression) that is used in the $orderby system query option.

Abstract base class for streams.

Represents a link to the value of a media entity resource or a stream-typed property.

Encapsulates the metadata of an OData stream property.

A map from key type string to value type string.

DataValue subclass that wraps a value of type string.

Represents an OData structural property.

Common base class for ComplexValue and EntityValue.

A fixed-length mutable array of item type DataValue?.

Common base class for ComplexType and EntityType.

A list of item type StructureType.

A map from key type string to value type StructureType.

Encapsulates an OData SymbolicName as a DataValue.

Represents the top* transformations.

Encapsulates an OData transformation defined in OData Data Aggregation. A TransformValue indicates an expression that is used in the $apply system query option.

A list of transformations.

Encapsulates the metadata of custom OData type facets.

DataValue subclass that wraps a value of type unsignedByte.

DataValue subclass that wraps a value of type unsignedShort.

Represents the XML Schema yearMonthDuration type.

A list of item type YearMonthDuration.

A data service provider that synchronizes data between a local SQL database on a mobile client device and a remote OData service. Occasional download and upload calls may be used to synchronize data changes when the mobile client device is online. The local SQL database will subsequently be queried and updated via the associated SQLDatabaseProvider when the mobile client device is offline. The remote OData service can be cloud-based or on-premise, but will typically be accessed via a cloud-based intermediary which enables connectivity between the mobile client device and the remote OData service. Connectivity between the mobile client device and the remote OData service can be achieved by the associated OnlineODataProvider via SAP Mobile Services and/or SAP BTP Connectivity. The OData service should be enabled for OData change tracking, so that download calls can efficiently obtain only the changed data. If the OData service does not support change tracking, then Mobile Back-End Tools can be used to enable change tracking, either by using a delta-enabled cache database, or by using a delta-enabled existing database. Mobile Back-end Tools can also be used to provide an OData service with a delta-enabled cache database, wrapping a non-OData backend system which is accessible using HTTPS (for REST APIs or SOAP services), JDBC (for SQL databases), or SAP Java Connector (for ABAP systems). The EntitySet.downloadWithoutDeltaLinks property can be set to true to enable client-side change tracking, however this is only appropriate for application prototyping or for production scenarios with a limited amount of data to be downloaded. Client applications should wrap this provider with a DataService (or OfflineDataService) for convenient consumption, including the use of async methods and proxy classes.

Example using proxy classes

open func setupService() throws -> Void {
    let online = OnlineODataProvider(serviceName: "HealthService", serviceRoot: "http://health.example.com:8080")
    let database = SQLDatabaseProvider(serviceName: "HealthDB", databaseURL: "sqlite:~/health.db")
    let offline = CloudSyncProvider(onlineProvider: online,
        offlineStore: database)
    offline.encryptionKey = self.dbEncryptionKey()
    offline.createIndex(HealthService.patients, Patient.dateOfBirth,
        Patient.lastName)
    let service = HealthService(provider: offline)
    service.downloadInGroup("PatientGroup", HealthService.patients,
        HealthService.appointments)
    service.downloadInGroup("StaffGroup", HealthService.doctors,
        HealthService.nurses)
    self.healthService = service
}

Example using dynamic API

open func setupService() throws -> Void {
    let onlineProvider = OnlineODataProvider(serviceName: "HealthService",
        serviceRoot: "http://health.example.com:8080")
    let localDatabase = SQLDatabaseProvider(serviceName: "HealthDB",
        databaseURL: "sqlite:~/health.db")
    let offlineProvider = CloudSyncProvider(onlineProvider: onlineProvider,
        offlineStore: localDatabase)
    offlineProvider.encryptionKey = self.dbEncryptionKey()
    offlineProvider.createDynamicIndex("Patients", "dateOfBirth")
    self.healthService = OfflineDataService(provider: offlineProvider)
    try self.healthService.open()
}

Encapsulates an OData data service.

Example using proxy classes

open func dataServiceExample() throws -> Void {
    let provider = OnlineODataProvider(serviceName: "NorthwindService",
        serviceRoot: "http://services.odata.org/V4/Northwind/Northwind.svc/")
    let service = NorthwindService(provider: provider)
    let query = DataQuery()
        .select(Customer.customerID, Customer.companyName, Customer.contactName)
        .orderBy(Customer.companyName)
    let customers = try service.fetchCustomers(matching: query)
    self.showCustomers(customers)
    let customer = customers.first!.copy()
    customer.companyName = "Created Inc."
    try service.createEntity(customer)
    customer.companyName = "Updated Inc."
    try service.updateEntity(customer)
    try service.deleteEntity(customer)
}

Example using dynamic API

open func dataServiceExample() throws -> Void {
    let provider = OnlineODataProvider(serviceName: "NorthwindService",
        serviceRoot: "http://services.odata.org/V4/Northwind/Northwind.svc/")
    let service = DataService(provider: provider)
    try service.loadMetadata()
    let customersEntitySet = service.entitySet(withName: "Customers")
    let customerEntityType = customersEntitySet.entityType
    let customerIDProperty = customerEntityType.property(withName: "CustomerID")
    let companyNameProperty = customerEntityType.property(withName: "CompanyName")
    let contactNameProperty = customerEntityType.property(withName: "ContactName")
    let query = DataQuery()
        .select(customerIDProperty, companyNameProperty, contactNameProperty)
        .from(customersEntitySet).orderBy(companyNameProperty)
    let customers = try service.executeQuery(query).entityList()
    self.showCustomers(customers)
    let customer = customers.first().copyEntity()
    companyNameProperty.setStringValue(in: customer, to: "Created Inc.")
    try service.createEntity(customer)
    companyNameProperty.setStringValue(in: customer, to: "Updated Inc.")
    try service.updateEntity(customer)
    try service.deleteEntity(customer)
}

Represents a named group for offline download. Download groups are used for selecting a subset of data to be downloaded.

Represents a numbered phase for offline download. Download phases are used to break downloads into phases which might have different characteristics.

A query used to limit the downloading of entities with CloudSyncProvider.

A list of item type DownloadQuery.

A data query subclass for queries that obtain a response from caller-supplied JSON text.

Deprecated. Encapsulates an OData data service. Note: this class provides legacy-style async functions. Use DataService, OnlineDataService or OfflineDataService for Swift.Result-style async functions.

Deprecated. Encapsulates an OData data service. Note: this class provides legacy-style async functions. Use DataService, OnlineDataService or OfflineDataService for Swift.Result-style async functions.

Options for interaction with a data network.

A specialization of DataService where the provider is a DataSyncProvider.

An specialization of DataService where the provider is a DataSyncProvider, using the async/await style of asynchronous operations.

A specialization of DataService where the provider is an OnlineODataProvider.

An specialization of DataService where the provider is an OnlineODataProvider, using the async/await style of asynchronous operations.

Generalized operation progress information, e.g. for network download / upload operations.

Represents a pending request from client to server, retained on the client during offline operation until it can be successfully uploaded to the server, or cancelled by the application.

A list of item type PendingRequest.

Exception thrown by SQL functions when an error occurs.

An implementation of DataServiceProvider using a SQL database. A remote OData service is not required in order to use this provider. The underlying database software is SQLite (SQLCipher).

Options for interaction with a data service.

Options for offline storage of data from a DataService.

Contains information about a synchronization event, such as download or upload.

A list of item type SyncEvent.

Request options for OfflineDataService.download and OfflineDataService.upload.

A utility class for formatting OData values as JSON strings.

Exception thrown by DataSyncProvider.upload when one or more pending requests cannot be uploaded due to a backend failure. The message for this exception will not be localized. Please use the properties (failureCount, successCount, notSentCount) for error handling and user notification.

Arbitrary precision decimal value.

Arbitrary precision integer value.

An exception thrown if HttpRequest.send cannot be completed due to a network error, or when one of the HTTP functions is used in an inappropriate manner or with invalid parameters.

Constants for HTTP methods.

Constants for HTTP status code.

Constants for HTTP status text.

Encapsulates a map of HTTP cookies.

Constants for standard and extended HTTP header names.

Encapsulates a map of HTTP headers, allowing case-insensitive lookup.

Utility functions for asserting/converting query result into a single item.