mozilla-mobile/firefox-ios/MozillaRustComponents/Sources/MozillaRustComponentsWrapper/Generated/nimbus.swift

Revision control

Copy as Markdown

// This file was autogenerated by some hot garbage in the `uniffi` crate.
// Trust me, you don't want to mess with it!
// swiftlint:disable all
import Foundation
// Depending on the consumer's build setup, the low-level FFI code
// might be in a separate module, or it might be compiled inline into
// this module. This is a bit of light hackery to work with both.
#if canImport(MozillaRustComponents)
import MozillaRustComponents
#endif
fileprivate extension RustBuffer {
// Allocate a new buffer, copying the contents of a `UInt8` array.
init(bytes: [UInt8]) {
let rbuf = bytes.withUnsafeBufferPointer { ptr in
RustBuffer.from(ptr)
}
self.init(capacity: rbuf.capacity, len: rbuf.len, data: rbuf.data)
}
static func empty() -> RustBuffer {
RustBuffer(capacity: 0, len:0, data: nil)
}
static func from(_ ptr: UnsafeBufferPointer<UInt8>) -> RustBuffer {
try! rustCall { ffi_nimbus_rustbuffer_from_bytes(ForeignBytes(bufferPointer: ptr), $0) }
}
// Frees the buffer in place.
// The buffer must not be used after this is called.
func deallocate() {
try! rustCall { ffi_nimbus_rustbuffer_free(self, $0) }
}
}
fileprivate extension ForeignBytes {
init(bufferPointer: UnsafeBufferPointer<UInt8>) {
self.init(len: Int32(bufferPointer.count), data: bufferPointer.baseAddress)
}
}
// For every type used in the interface, we provide helper methods for conveniently
// lifting and lowering that type from C-compatible data, and for reading and writing
// values of that type in a buffer.
// Helper classes/extensions that don't change.
// Someday, this will be in a library of its own.
fileprivate extension Data {
init(rustBuffer: RustBuffer) {
self.init(
bytesNoCopy: rustBuffer.data!,
count: Int(rustBuffer.len),
deallocator: .none
)
}
}
// Define reader functionality. Normally this would be defined in a class or
// struct, but we use standalone functions instead in order to make external
// types work.
//
// With external types, one swift source file needs to be able to call the read
// method on another source file's FfiConverter, but then what visibility
// should Reader have?
// - If Reader is fileprivate, then this means the read() must also
// be fileprivate, which doesn't work with external types.
// - If Reader is internal/public, we'll get compile errors since both source
// files will try define the same type.
//
// Instead, the read() method and these helper functions input a tuple of data
fileprivate func createReader(data: Data) -> (data: Data, offset: Data.Index) {
(data: data, offset: 0)
}
// Reads an integer at the current offset, in big-endian order, and advances
// the offset on success. Throws if reading the integer would move the
// offset past the end of the buffer.
fileprivate func readInt<T: FixedWidthInteger>(_ reader: inout (data: Data, offset: Data.Index)) throws -> T {
let range = reader.offset..<reader.offset + MemoryLayout<T>.size
guard reader.data.count >= range.upperBound else {
throw UniffiInternalError.bufferOverflow
}
if T.self == UInt8.self {
let value = reader.data[reader.offset]
reader.offset += 1
return value as! T
}
var value: T = 0
let _ = withUnsafeMutableBytes(of: &value, { reader.data.copyBytes(to: $0, from: range)})
reader.offset = range.upperBound
return value.bigEndian
}
// Reads an arbitrary number of bytes, to be used to read
// raw bytes, this is useful when lifting strings
fileprivate func readBytes(_ reader: inout (data: Data, offset: Data.Index), count: Int) throws -> Array<UInt8> {
let range = reader.offset..<(reader.offset+count)
guard reader.data.count >= range.upperBound else {
throw UniffiInternalError.bufferOverflow
}
var value = [UInt8](repeating: 0, count: count)
value.withUnsafeMutableBufferPointer({ buffer in
reader.data.copyBytes(to: buffer, from: range)
})
reader.offset = range.upperBound
return value
}
// Reads a float at the current offset.
fileprivate func readFloat(_ reader: inout (data: Data, offset: Data.Index)) throws -> Float {
return Float(bitPattern: try readInt(&reader))
}
// Reads a float at the current offset.
fileprivate func readDouble(_ reader: inout (data: Data, offset: Data.Index)) throws -> Double {
return Double(bitPattern: try readInt(&reader))
}
// Indicates if the offset has reached the end of the buffer.
fileprivate func hasRemaining(_ reader: (data: Data, offset: Data.Index)) -> Bool {
return reader.offset < reader.data.count
}
// Define writer functionality. Normally this would be defined in a class or
// struct, but we use standalone functions instead in order to make external
// types work. See the above discussion on Readers for details.
fileprivate func createWriter() -> [UInt8] {
return []
}
fileprivate func writeBytes<S>(_ writer: inout [UInt8], _ byteArr: S) where S: Sequence, S.Element == UInt8 {
writer.append(contentsOf: byteArr)
}
// Writes an integer in big-endian order.
//
// Warning: make sure what you are trying to write
// is in the correct type!
fileprivate func writeInt<T: FixedWidthInteger>(_ writer: inout [UInt8], _ value: T) {
var value = value.bigEndian
withUnsafeBytes(of: &value) { writer.append(contentsOf: $0) }
}
fileprivate func writeFloat(_ writer: inout [UInt8], _ value: Float) {
writeInt(&writer, value.bitPattern)
}
fileprivate func writeDouble(_ writer: inout [UInt8], _ value: Double) {
writeInt(&writer, value.bitPattern)
}
// Protocol for types that transfer other types across the FFI. This is
// analogous to the Rust trait of the same name.
fileprivate protocol FfiConverter {
associatedtype FfiType
associatedtype SwiftType
static func lift(_ value: FfiType) throws -> SwiftType
static func lower(_ value: SwiftType) -> FfiType
static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType
static func write(_ value: SwiftType, into buf: inout [UInt8])
}
// Types conforming to `Primitive` pass themselves directly over the FFI.
fileprivate protocol FfiConverterPrimitive: FfiConverter where FfiType == SwiftType { }
extension FfiConverterPrimitive {
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func lift(_ value: FfiType) throws -> SwiftType {
return value
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func lower(_ value: SwiftType) -> FfiType {
return value
}
}
// Types conforming to `FfiConverterRustBuffer` lift and lower into a `RustBuffer`.
// Used for complex types where it's hard to write a custom lift/lower.
fileprivate protocol FfiConverterRustBuffer: FfiConverter where FfiType == RustBuffer {}
extension FfiConverterRustBuffer {
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func lift(_ buf: RustBuffer) throws -> SwiftType {
var reader = createReader(data: Data(rustBuffer: buf))
let value = try read(from: &reader)
if hasRemaining(reader) {
throw UniffiInternalError.incompleteData
}
buf.deallocate()
return value
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func lower(_ value: SwiftType) -> RustBuffer {
var writer = createWriter()
write(value, into: &writer)
return RustBuffer(bytes: writer)
}
}
// An error type for FFI errors. These errors occur at the UniFFI level, not
// the library level.
fileprivate enum UniffiInternalError: LocalizedError {
case bufferOverflow
case incompleteData
case unexpectedOptionalTag
case unexpectedEnumCase
case unexpectedNullPointer
case unexpectedRustCallStatusCode
case unexpectedRustCallError
case unexpectedStaleHandle
case rustPanic(_ message: String)
public var errorDescription: String? {
switch self {
case .bufferOverflow: return "Reading the requested value would read past the end of the buffer"
case .incompleteData: return "The buffer still has data after lifting its containing value"
case .unexpectedOptionalTag: return "Unexpected optional tag; should be 0 or 1"
case .unexpectedEnumCase: return "Raw enum value doesn't match any cases"
case .unexpectedNullPointer: return "Raw pointer value was null"
case .unexpectedRustCallStatusCode: return "Unexpected RustCallStatus code"
case .unexpectedRustCallError: return "CALL_ERROR but no errorClass specified"
case .unexpectedStaleHandle: return "The object in the handle map has been dropped already"
case let .rustPanic(message): return message
}
}
}
fileprivate extension NSLock {
func withLock<T>(f: () throws -> T) rethrows -> T {
self.lock()
defer { self.unlock() }
return try f()
}
}
fileprivate let CALL_SUCCESS: Int8 = 0
fileprivate let CALL_ERROR: Int8 = 1
fileprivate let CALL_UNEXPECTED_ERROR: Int8 = 2
fileprivate let CALL_CANCELLED: Int8 = 3
fileprivate extension RustCallStatus {
init() {
self.init(
code: CALL_SUCCESS,
errorBuf: RustBuffer.init(
capacity: 0,
len: 0,
data: nil
)
)
}
}
private func rustCall<T>(_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
let neverThrow: ((RustBuffer) throws -> Never)? = nil
return try makeRustCall(callback, errorHandler: neverThrow)
}
private func rustCallWithError<T, E: Swift.Error>(
_ errorHandler: @escaping (RustBuffer) throws -> E,
_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T) throws -> T {
try makeRustCall(callback, errorHandler: errorHandler)
}
private func makeRustCall<T, E: Swift.Error>(
_ callback: (UnsafeMutablePointer<RustCallStatus>) -> T,
errorHandler: ((RustBuffer) throws -> E)?
) throws -> T {
uniffiEnsureNimbusInitialized()
var callStatus = RustCallStatus.init()
let returnedVal = callback(&callStatus)
try uniffiCheckCallStatus(callStatus: callStatus, errorHandler: errorHandler)
return returnedVal
}
private func uniffiCheckCallStatus<E: Swift.Error>(
callStatus: RustCallStatus,
errorHandler: ((RustBuffer) throws -> E)?
) throws {
switch callStatus.code {
case CALL_SUCCESS:
return
case CALL_ERROR:
if let errorHandler = errorHandler {
throw try errorHandler(callStatus.errorBuf)
} else {
callStatus.errorBuf.deallocate()
throw UniffiInternalError.unexpectedRustCallError
}
case CALL_UNEXPECTED_ERROR:
// When the rust code sees a panic, it tries to construct a RustBuffer
// with the message. But if that code panics, then it just sends back
// an empty buffer.
if callStatus.errorBuf.len > 0 {
throw UniffiInternalError.rustPanic(try FfiConverterString.lift(callStatus.errorBuf))
} else {
callStatus.errorBuf.deallocate()
throw UniffiInternalError.rustPanic("Rust panic")
}
case CALL_CANCELLED:
fatalError("Cancellation not supported yet")
default:
throw UniffiInternalError.unexpectedRustCallStatusCode
}
}
private func uniffiTraitInterfaceCall<T>(
callStatus: UnsafeMutablePointer<RustCallStatus>,
makeCall: () throws -> T,
writeReturn: (T) -> ()
) {
do {
try writeReturn(makeCall())
} catch let error {
callStatus.pointee.code = CALL_UNEXPECTED_ERROR
callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
}
}
private func uniffiTraitInterfaceCallWithError<T, E>(
callStatus: UnsafeMutablePointer<RustCallStatus>,
makeCall: () throws -> T,
writeReturn: (T) -> (),
lowerError: (E) -> RustBuffer
) {
do {
try writeReturn(makeCall())
} catch let error as E {
callStatus.pointee.code = CALL_ERROR
callStatus.pointee.errorBuf = lowerError(error)
} catch {
callStatus.pointee.code = CALL_UNEXPECTED_ERROR
callStatus.pointee.errorBuf = FfiConverterString.lower(String(describing: error))
}
}
fileprivate final class UniffiHandleMap<T>: @unchecked Sendable {
// All mutation happens with this lock held, which is why we implement @unchecked Sendable.
private let lock = NSLock()
private var map: [UInt64: T] = [:]
private var currentHandle: UInt64 = 1
func insert(obj: T) -> UInt64 {
lock.withLock {
let handle = currentHandle
currentHandle += 1
map[handle] = obj
return handle
}
}
func get(handle: UInt64) throws -> T {
try lock.withLock {
guard let obj = map[handle] else {
throw UniffiInternalError.unexpectedStaleHandle
}
return obj
}
}
@discardableResult
func remove(handle: UInt64) throws -> T {
try lock.withLock {
guard let obj = map.removeValue(forKey: handle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return obj
}
}
var count: Int {
get {
map.count
}
}
}
// Public interface members begin here.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterInt32: FfiConverterPrimitive {
typealias FfiType = Int32
typealias SwiftType = Int32
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int32 {
return try lift(readInt(&buf))
}
public static func write(_ value: Int32, into buf: inout [UInt8]) {
writeInt(&buf, lower(value))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterInt64: FfiConverterPrimitive {
typealias FfiType = Int64
typealias SwiftType = Int64
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Int64 {
return try lift(readInt(&buf))
}
public static func write(_ value: Int64, into buf: inout [UInt8]) {
writeInt(&buf, lower(value))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterDouble: FfiConverterPrimitive {
typealias FfiType = Double
typealias SwiftType = Double
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Double {
return try lift(readDouble(&buf))
}
public static func write(_ value: Double, into buf: inout [UInt8]) {
writeDouble(&buf, lower(value))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterBool : FfiConverter {
typealias FfiType = Int8
typealias SwiftType = Bool
public static func lift(_ value: Int8) throws -> Bool {
return value != 0
}
public static func lower(_ value: Bool) -> Int8 {
return value ? 1 : 0
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> Bool {
return try lift(readInt(&buf))
}
public static func write(_ value: Bool, into buf: inout [UInt8]) {
writeInt(&buf, lower(value))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterString: FfiConverter {
typealias SwiftType = String
typealias FfiType = RustBuffer
public static func lift(_ value: RustBuffer) throws -> String {
defer {
value.deallocate()
}
if value.data == nil {
return String()
}
let bytes = UnsafeBufferPointer<UInt8>(start: value.data!, count: Int(value.len))
return String(bytes: bytes, encoding: String.Encoding.utf8)!
}
public static func lower(_ value: String) -> RustBuffer {
return value.utf8CString.withUnsafeBufferPointer { ptr in
// The swift string gives us int8_t, we want uint8_t.
ptr.withMemoryRebound(to: UInt8.self) { ptr in
// The swift string gives us a trailing null byte, we don't want it.
let buf = UnsafeBufferPointer(rebasing: ptr.prefix(upTo: ptr.count - 1))
return RustBuffer.from(buf)
}
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> String {
let len: Int32 = try readInt(&buf)
return String(bytes: try readBytes(&buf, count: Int(len)), encoding: String.Encoding.utf8)!
}
public static func write(_ value: String, into buf: inout [UInt8]) {
let len = Int32(value.utf8.count)
writeInt(&buf, len)
writeBytes(&buf, value.utf8)
}
}
public protocol NimbusClientProtocol: AnyObject {
/**
* Advances what the event store thinks is now.
* This, and `record_past_event` are useful for testing.
* `by_seconds` must be positive.
*/
func advanceEventTime(bySeconds: Int64) throws
/**
* Apply the updated experiments from the last fetch.
* After calling this, the list of active experiments might change
* (there might be new experiments, or old experiments might have expired).
*/
func applyPendingExperiments() throws -> [EnrollmentChangeEvent]
func clearEvents() throws
/**
* This provides a unified String interpolation library which exposes the application context.
* It's first use is in the messaging helper, to add extra parameters to URLs.
*/
func createStringHelper(additionalContext: JsonObject?) throws -> NimbusStringHelper
/**
* This provides low level access to the targeting machinery for other uses by the application (e.g. messages)
* Additional parameters can be added via the optional JSON object. This allows for many JEXL expressions
* to be run across the same context.
*/
func createTargetingHelper(additionalContext: JsonObject?) throws -> NimbusTargetingHelper
func dumpStateToLog() throws
/**
* Fetches the list of experiments from the server. This does not affect the list
* of active experiments or experiment enrolment.
* Fetched experiments are not applied until `apply_pending_updates()` is called.
*/
func fetchExperiments() throws
/**
* Returns a list of experiments this user is enrolled in.
*/
func getActiveExperiments() throws -> [EnrolledExperiment]
/**
* Returns a list of experiments for this `app_name`, as specified in the `AppContext`.
* It is not intended to be used to be used for user facing applications.
*/
func getAvailableExperiments() throws -> [AvailableExperiment]
/**
* Returns the branch allocated for a given slug or id.
*/
func getExperimentBranch(id: String) throws -> String?
/**
* Returns a list of experiment branches for a given experiment ID.
*/
func getExperimentBranches(experimentSlug: String) throws -> [ExperimentBranch]
func getFeatureConfigVariables(featureId: String) throws -> String?
/**
* Getter and setter for user's participation in all experiments.
* Possible values are:
* * `true`: the user will not enroll in new experiments, and opt out of all existing ones.
* * `false`: experiments proceed as usual.
*/
func getGlobalUserParticipation() throws -> Bool
/**
* Initializes the database and caches enough information so that the
* non-blocking API functions (eg, `get_experiment_branch()`) can
* return accurate results rather than throwing a "not initialized" error.
* It's not strictly necessary to call this function - any function that
* wants to use the database will implicitly initialize too - this exists
* so that the consuming application can have confidence the non-blocking
* functions will return data instead of returning an error, and will do
* the minimum amount of work to achieve that.
*/
func initialize() throws
func isFetchEnabled() throws -> Bool
/**
* Opt in to a specific branch on a specific experiment. Useful for
* developers to test their app's interaction with the experiment.
*/
func optInWithBranch(experimentSlug: String, branch: String) throws -> [EnrollmentChangeEvent]
/**
* Opt out of a specific experiment.
*/
func optOut(experimentSlug: String) throws -> [EnrollmentChangeEvent]
/**
* Records an event for the purposes of behavioral targeting.
* This function is used to record and persist data used for the behavioral
* targeting such as "core-active" user targeting.
*/
func recordEvent(eventId: String, count: Int64) throws
/**
* Records a Glean event that this feature has been exposed.
* If the feature is not involved in an experiment, then the event is suppressed.
* If the feature is only involved in a rollout, then the event is suppressed.
* If the feature is involved in an experiment, then record the experiment slug
* and branch.
* If the feature is involved in an experiment and a rollout, then record only the
* experiment slug and branch.
* If the slug is specified, then use this as the experiment, and use it to look up
* the branch. This is useful for coenrolling features.
*/
func recordFeatureExposure(featureId: String, slug: String?)
/**
* Records a Glean event that this feature configuration is malformed.
* Accepts a part_id to give the experiment owner or feature implementer
* clues where to look.
* The Glean event will always fire, but the content of that event will
* vary depending on whether then feature is part of an experiment or rollout
* or not.
*/
func recordMalformedFeatureConfig(featureId: String, partId: String)
/**
* Records an event as if it were in the past.
* This, and `advance_event_time` are useful for testing.
* `seconds_ago` must be positive.
*/
func recordPastEvent(eventId: String, secondsAgo: Int64, count: Int64) throws
/**
* These are test-only functions and should never be exposed to production
* users, as they mess with the "statistical requirements" of the SDK.
* Reset the enrollments and experiments in the database to an empty state.
*/
func resetEnrollments() throws
/**
* Reset internal state in response to application-level telemetry reset.
*
* Consumers should call this method when the user resets the telemetry state of the
* consuming application, such as by opting out of submitting telemetry. It resets the
* internal state of the Nimbus client to create a clean break between data collected
* before and after the reset, including:
*
* * clearing any unique identifiers used internally, so they will reset to
* new random values on next use.
* * accepting new randomization units, based on application-level ids that
* may have also changed.
* * disqualifying this client out of any active experiments, to avoid submitting
* misleading incomplete data.
*/
func resetTelemetryIdentifiers() throws -> [EnrollmentChangeEvent]
/**
* A convenience method for apps to set the experiments from a local source
* for either testing, or before the first fetch has finished.
*
* Experiments set with this method are not applied until `apply_pending_updates()` is called.
*/
func setExperimentsLocally(experimentsJson: String) throws
/**
* Toggles the enablement of the fetch. If `false`, then calling `fetch_experiments`
* returns immediately, having not done any fetching from remote settings.
* This is only useful for QA, and should not be used in production: use
* `set_global_user_participation` instead.
*/
func setFetchEnabled(flag: Bool) throws
func setGlobalUserParticipation(optIn: Bool) throws -> [EnrollmentChangeEvent]
}
open class NimbusClient: NimbusClientProtocol, @unchecked Sendable {
fileprivate let pointer: UnsafeMutableRawPointer!
/// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct NoPointer {
public init() {}
}
// TODO: We'd like this to be `private` but for Swifty reasons,
// we can't implement `FfiConverter` without making this `required` and we can't
// make it `required` without making it `public`.
required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
self.pointer = pointer
}
// This constructor can be used to instantiate a fake object.
// - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
//
// - Warning:
// Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public init(noPointer: NoPointer) {
self.pointer = nil
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func uniffiClonePointer() -> UnsafeMutableRawPointer {
return try! rustCall { uniffi_nimbus_fn_clone_nimbusclient(self.pointer, $0) }
}
public convenience init(appCtx: AppContext, recordedContext: RecordedContext?, coenrollingFeatureIds: [String], dbpath: String, remoteSettingsConfig: RemoteSettingsConfig?, metricsHandler: MetricsHandler)throws {
let pointer =
try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_constructor_nimbusclient_new(
FfiConverterTypeAppContext_lower(appCtx),
FfiConverterOptionTypeRecordedContext.lower(recordedContext),
FfiConverterSequenceString.lower(coenrollingFeatureIds),
FfiConverterString.lower(dbpath),
FfiConverterOptionTypeRemoteSettingsConfig.lower(remoteSettingsConfig),
FfiConverterCallbackInterfaceMetricsHandler_lower(metricsHandler),$0
)
}
self.init(unsafeFromRawPointer: pointer)
}
deinit {
guard let pointer = pointer else {
return
}
try! rustCall { uniffi_nimbus_fn_free_nimbusclient(pointer, $0) }
}
/**
* Advances what the event store thinks is now.
* This, and `record_past_event` are useful for testing.
* `by_seconds` must be positive.
*/
open func advanceEventTime(bySeconds: Int64)throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_advance_event_time(self.uniffiClonePointer(),
FfiConverterInt64.lower(bySeconds),$0
)
}
}
/**
* Apply the updated experiments from the last fetch.
* After calling this, the list of active experiments might change
* (there might be new experiments, or old experiments might have expired).
*/
open func applyPendingExperiments()throws -> [EnrollmentChangeEvent] {
return try FfiConverterSequenceTypeEnrollmentChangeEvent.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_apply_pending_experiments(self.uniffiClonePointer(),$0
)
})
}
open func clearEvents()throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_clear_events(self.uniffiClonePointer(),$0
)
}
}
/**
* This provides a unified String interpolation library which exposes the application context.
* It's first use is in the messaging helper, to add extra parameters to URLs.
*/
open func createStringHelper(additionalContext: JsonObject? = nil)throws -> NimbusStringHelper {
return try FfiConverterTypeNimbusStringHelper_lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_create_string_helper(self.uniffiClonePointer(),
FfiConverterOptionTypeJsonObject.lower(additionalContext),$0
)
})
}
/**
* This provides low level access to the targeting machinery for other uses by the application (e.g. messages)
* Additional parameters can be added via the optional JSON object. This allows for many JEXL expressions
* to be run across the same context.
*/
open func createTargetingHelper(additionalContext: JsonObject? = nil)throws -> NimbusTargetingHelper {
return try FfiConverterTypeNimbusTargetingHelper_lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_create_targeting_helper(self.uniffiClonePointer(),
FfiConverterOptionTypeJsonObject.lower(additionalContext),$0
)
})
}
open func dumpStateToLog()throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_dump_state_to_log(self.uniffiClonePointer(),$0
)
}
}
/**
* Fetches the list of experiments from the server. This does not affect the list
* of active experiments or experiment enrolment.
* Fetched experiments are not applied until `apply_pending_updates()` is called.
*/
open func fetchExperiments()throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_fetch_experiments(self.uniffiClonePointer(),$0
)
}
}
/**
* Returns a list of experiments this user is enrolled in.
*/
open func getActiveExperiments()throws -> [EnrolledExperiment] {
return try FfiConverterSequenceTypeEnrolledExperiment.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_get_active_experiments(self.uniffiClonePointer(),$0
)
})
}
/**
* Returns a list of experiments for this `app_name`, as specified in the `AppContext`.
* It is not intended to be used to be used for user facing applications.
*/
open func getAvailableExperiments()throws -> [AvailableExperiment] {
return try FfiConverterSequenceTypeAvailableExperiment.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_get_available_experiments(self.uniffiClonePointer(),$0
)
})
}
/**
* Returns the branch allocated for a given slug or id.
*/
open func getExperimentBranch(id: String)throws -> String? {
return try FfiConverterOptionString.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_get_experiment_branch(self.uniffiClonePointer(),
FfiConverterString.lower(id),$0
)
})
}
/**
* Returns a list of experiment branches for a given experiment ID.
*/
open func getExperimentBranches(experimentSlug: String)throws -> [ExperimentBranch] {
return try FfiConverterSequenceTypeExperimentBranch.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_get_experiment_branches(self.uniffiClonePointer(),
FfiConverterString.lower(experimentSlug),$0
)
})
}
open func getFeatureConfigVariables(featureId: String)throws -> String? {
return try FfiConverterOptionString.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_get_feature_config_variables(self.uniffiClonePointer(),
FfiConverterString.lower(featureId),$0
)
})
}
/**
* Getter and setter for user's participation in all experiments.
* Possible values are:
* * `true`: the user will not enroll in new experiments, and opt out of all existing ones.
* * `false`: experiments proceed as usual.
*/
open func getGlobalUserParticipation()throws -> Bool {
return try FfiConverterBool.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_get_global_user_participation(self.uniffiClonePointer(),$0
)
})
}
/**
* Initializes the database and caches enough information so that the
* non-blocking API functions (eg, `get_experiment_branch()`) can
* return accurate results rather than throwing a "not initialized" error.
* It's not strictly necessary to call this function - any function that
* wants to use the database will implicitly initialize too - this exists
* so that the consuming application can have confidence the non-blocking
* functions will return data instead of returning an error, and will do
* the minimum amount of work to achieve that.
*/
open func initialize()throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_initialize(self.uniffiClonePointer(),$0
)
}
}
open func isFetchEnabled()throws -> Bool {
return try FfiConverterBool.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_is_fetch_enabled(self.uniffiClonePointer(),$0
)
})
}
/**
* Opt in to a specific branch on a specific experiment. Useful for
* developers to test their app's interaction with the experiment.
*/
open func optInWithBranch(experimentSlug: String, branch: String)throws -> [EnrollmentChangeEvent] {
return try FfiConverterSequenceTypeEnrollmentChangeEvent.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_opt_in_with_branch(self.uniffiClonePointer(),
FfiConverterString.lower(experimentSlug),
FfiConverterString.lower(branch),$0
)
})
}
/**
* Opt out of a specific experiment.
*/
open func optOut(experimentSlug: String)throws -> [EnrollmentChangeEvent] {
return try FfiConverterSequenceTypeEnrollmentChangeEvent.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_opt_out(self.uniffiClonePointer(),
FfiConverterString.lower(experimentSlug),$0
)
})
}
/**
* Records an event for the purposes of behavioral targeting.
* This function is used to record and persist data used for the behavioral
* targeting such as "core-active" user targeting.
*/
open func recordEvent(eventId: String, count: Int64 = Int64(1))throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_record_event(self.uniffiClonePointer(),
FfiConverterString.lower(eventId),
FfiConverterInt64.lower(count),$0
)
}
}
/**
* Records a Glean event that this feature has been exposed.
* If the feature is not involved in an experiment, then the event is suppressed.
* If the feature is only involved in a rollout, then the event is suppressed.
* If the feature is involved in an experiment, then record the experiment slug
* and branch.
* If the feature is involved in an experiment and a rollout, then record only the
* experiment slug and branch.
* If the slug is specified, then use this as the experiment, and use it to look up
* the branch. This is useful for coenrolling features.
*/
open func recordFeatureExposure(featureId: String, slug: String?) {try! rustCall() {
uniffi_nimbus_fn_method_nimbusclient_record_feature_exposure(self.uniffiClonePointer(),
FfiConverterString.lower(featureId),
FfiConverterOptionString.lower(slug),$0
)
}
}
/**
* Records a Glean event that this feature configuration is malformed.
* Accepts a part_id to give the experiment owner or feature implementer
* clues where to look.
* The Glean event will always fire, but the content of that event will
* vary depending on whether then feature is part of an experiment or rollout
* or not.
*/
open func recordMalformedFeatureConfig(featureId: String, partId: String) {try! rustCall() {
uniffi_nimbus_fn_method_nimbusclient_record_malformed_feature_config(self.uniffiClonePointer(),
FfiConverterString.lower(featureId),
FfiConverterString.lower(partId),$0
)
}
}
/**
* Records an event as if it were in the past.
* This, and `advance_event_time` are useful for testing.
* `seconds_ago` must be positive.
*/
open func recordPastEvent(eventId: String, secondsAgo: Int64, count: Int64 = Int64(1))throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_record_past_event(self.uniffiClonePointer(),
FfiConverterString.lower(eventId),
FfiConverterInt64.lower(secondsAgo),
FfiConverterInt64.lower(count),$0
)
}
}
/**
* These are test-only functions and should never be exposed to production
* users, as they mess with the "statistical requirements" of the SDK.
* Reset the enrollments and experiments in the database to an empty state.
*/
open func resetEnrollments()throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_reset_enrollments(self.uniffiClonePointer(),$0
)
}
}
/**
* Reset internal state in response to application-level telemetry reset.
*
* Consumers should call this method when the user resets the telemetry state of the
* consuming application, such as by opting out of submitting telemetry. It resets the
* internal state of the Nimbus client to create a clean break between data collected
* before and after the reset, including:
*
* * clearing any unique identifiers used internally, so they will reset to
* new random values on next use.
* * accepting new randomization units, based on application-level ids that
* may have also changed.
* * disqualifying this client out of any active experiments, to avoid submitting
* misleading incomplete data.
*/
open func resetTelemetryIdentifiers()throws -> [EnrollmentChangeEvent] {
return try FfiConverterSequenceTypeEnrollmentChangeEvent.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_reset_telemetry_identifiers(self.uniffiClonePointer(),$0
)
})
}
/**
* A convenience method for apps to set the experiments from a local source
* for either testing, or before the first fetch has finished.
*
* Experiments set with this method are not applied until `apply_pending_updates()` is called.
*/
open func setExperimentsLocally(experimentsJson: String)throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_set_experiments_locally(self.uniffiClonePointer(),
FfiConverterString.lower(experimentsJson),$0
)
}
}
/**
* Toggles the enablement of the fetch. If `false`, then calling `fetch_experiments`
* returns immediately, having not done any fetching from remote settings.
* This is only useful for QA, and should not be used in production: use
* `set_global_user_participation` instead.
*/
open func setFetchEnabled(flag: Bool)throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_set_fetch_enabled(self.uniffiClonePointer(),
FfiConverterBool.lower(flag),$0
)
}
}
open func setGlobalUserParticipation(optIn: Bool)throws -> [EnrollmentChangeEvent] {
return try FfiConverterSequenceTypeEnrollmentChangeEvent.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbusclient_set_global_user_participation(self.uniffiClonePointer(),
FfiConverterBool.lower(optIn),$0
)
})
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeNimbusClient: FfiConverter {
typealias FfiType = UnsafeMutableRawPointer
typealias SwiftType = NimbusClient
public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> NimbusClient {
return NimbusClient(unsafeFromRawPointer: pointer)
}
public static func lower(_ value: NimbusClient) -> UnsafeMutableRawPointer {
return value.uniffiClonePointer()
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NimbusClient {
let v: UInt64 = try readInt(&buf)
// The Rust code won't compile if a pointer won't fit in a UInt64.
// We have to go via `UInt` because that's the thing that's the size of a pointer.
let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
if (ptr == nil) {
throw UniffiInternalError.unexpectedNullPointer
}
return try lift(ptr!)
}
public static func write(_ value: NimbusClient, into buf: inout [UInt8]) {
// This fiddling is because `Int` is the thing that's the same size as a pointer.
// The Rust code won't compile if a pointer won't fit in a `UInt64`.
writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusClient_lift(_ pointer: UnsafeMutableRawPointer) throws -> NimbusClient {
return try FfiConverterTypeNimbusClient.lift(pointer)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusClient_lower(_ value: NimbusClient) -> UnsafeMutableRawPointer {
return FfiConverterTypeNimbusClient.lower(value)
}
public protocol NimbusStringHelperProtocol: AnyObject {
/**
* Generates an optional UUID to be passed into the `string_format` method.
* If the return is not null, then it should be recorded with Glean as a UuidMetricType.
*/
func getUuid(template: String) -> String?
/**
* Take the given template and find patterns that match the regular expression `{\w+}`.
* Any matches are used as keys into the application context, the `additional_context` or the special case `uuid`.
*/
func stringFormat(template: String, uuid: String?) -> String
}
open class NimbusStringHelper: NimbusStringHelperProtocol, @unchecked Sendable {
fileprivate let pointer: UnsafeMutableRawPointer!
/// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct NoPointer {
public init() {}
}
// TODO: We'd like this to be `private` but for Swifty reasons,
// we can't implement `FfiConverter` without making this `required` and we can't
// make it `required` without making it `public`.
required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
self.pointer = pointer
}
// This constructor can be used to instantiate a fake object.
// - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
//
// - Warning:
// Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public init(noPointer: NoPointer) {
self.pointer = nil
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func uniffiClonePointer() -> UnsafeMutableRawPointer {
return try! rustCall { uniffi_nimbus_fn_clone_nimbusstringhelper(self.pointer, $0) }
}
// No primary constructor declared for this class.
deinit {
guard let pointer = pointer else {
return
}
try! rustCall { uniffi_nimbus_fn_free_nimbusstringhelper(pointer, $0) }
}
/**
* Generates an optional UUID to be passed into the `string_format` method.
* If the return is not null, then it should be recorded with Glean as a UuidMetricType.
*/
open func getUuid(template: String) -> String? {
return try! FfiConverterOptionString.lift(try! rustCall() {
uniffi_nimbus_fn_method_nimbusstringhelper_get_uuid(self.uniffiClonePointer(),
FfiConverterString.lower(template),$0
)
})
}
/**
* Take the given template and find patterns that match the regular expression `{\w+}`.
* Any matches are used as keys into the application context, the `additional_context` or the special case `uuid`.
*/
open func stringFormat(template: String, uuid: String? = nil) -> String {
return try! FfiConverterString.lift(try! rustCall() {
uniffi_nimbus_fn_method_nimbusstringhelper_string_format(self.uniffiClonePointer(),
FfiConverterString.lower(template),
FfiConverterOptionString.lower(uuid),$0
)
})
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeNimbusStringHelper: FfiConverter {
typealias FfiType = UnsafeMutableRawPointer
typealias SwiftType = NimbusStringHelper
public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> NimbusStringHelper {
return NimbusStringHelper(unsafeFromRawPointer: pointer)
}
public static func lower(_ value: NimbusStringHelper) -> UnsafeMutableRawPointer {
return value.uniffiClonePointer()
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NimbusStringHelper {
let v: UInt64 = try readInt(&buf)
// The Rust code won't compile if a pointer won't fit in a UInt64.
// We have to go via `UInt` because that's the thing that's the size of a pointer.
let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
if (ptr == nil) {
throw UniffiInternalError.unexpectedNullPointer
}
return try lift(ptr!)
}
public static func write(_ value: NimbusStringHelper, into buf: inout [UInt8]) {
// This fiddling is because `Int` is the thing that's the same size as a pointer.
// The Rust code won't compile if a pointer won't fit in a `UInt64`.
writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusStringHelper_lift(_ pointer: UnsafeMutableRawPointer) throws -> NimbusStringHelper {
return try FfiConverterTypeNimbusStringHelper.lift(pointer)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusStringHelper_lower(_ value: NimbusStringHelper) -> UnsafeMutableRawPointer {
return FfiConverterTypeNimbusStringHelper.lower(value)
}
public protocol NimbusTargetingHelperProtocol: AnyObject {
/**
* Execute the given jexl expression and evaluate against the existing targeting parameters and context passed to
* the helper at construction.
*/
func evalJexl(expression: String) throws -> Bool
}
open class NimbusTargetingHelper: NimbusTargetingHelperProtocol, @unchecked Sendable {
fileprivate let pointer: UnsafeMutableRawPointer!
/// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct NoPointer {
public init() {}
}
// TODO: We'd like this to be `private` but for Swifty reasons,
// we can't implement `FfiConverter` without making this `required` and we can't
// make it `required` without making it `public`.
required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
self.pointer = pointer
}
// This constructor can be used to instantiate a fake object.
// - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
//
// - Warning:
// Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public init(noPointer: NoPointer) {
self.pointer = nil
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func uniffiClonePointer() -> UnsafeMutableRawPointer {
return try! rustCall { uniffi_nimbus_fn_clone_nimbustargetinghelper(self.pointer, $0) }
}
// No primary constructor declared for this class.
deinit {
guard let pointer = pointer else {
return
}
try! rustCall { uniffi_nimbus_fn_free_nimbustargetinghelper(pointer, $0) }
}
/**
* Execute the given jexl expression and evaluate against the existing targeting parameters and context passed to
* the helper at construction.
*/
open func evalJexl(expression: String)throws -> Bool {
return try FfiConverterBool.lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_method_nimbustargetinghelper_eval_jexl(self.uniffiClonePointer(),
FfiConverterString.lower(expression),$0
)
})
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeNimbusTargetingHelper: FfiConverter {
typealias FfiType = UnsafeMutableRawPointer
typealias SwiftType = NimbusTargetingHelper
public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> NimbusTargetingHelper {
return NimbusTargetingHelper(unsafeFromRawPointer: pointer)
}
public static func lower(_ value: NimbusTargetingHelper) -> UnsafeMutableRawPointer {
return value.uniffiClonePointer()
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NimbusTargetingHelper {
let v: UInt64 = try readInt(&buf)
// The Rust code won't compile if a pointer won't fit in a UInt64.
// We have to go via `UInt` because that's the thing that's the size of a pointer.
let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
if (ptr == nil) {
throw UniffiInternalError.unexpectedNullPointer
}
return try lift(ptr!)
}
public static func write(_ value: NimbusTargetingHelper, into buf: inout [UInt8]) {
// This fiddling is because `Int` is the thing that's the same size as a pointer.
// The Rust code won't compile if a pointer won't fit in a `UInt64`.
writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusTargetingHelper_lift(_ pointer: UnsafeMutableRawPointer) throws -> NimbusTargetingHelper {
return try FfiConverterTypeNimbusTargetingHelper.lift(pointer)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusTargetingHelper_lower(_ value: NimbusTargetingHelper) -> UnsafeMutableRawPointer {
return FfiConverterTypeNimbusTargetingHelper.lower(value)
}
public protocol RecordedContext: AnyObject {
func getEventQueries() -> [String: String]
func record()
func setEventQueryValues(eventQueryValues: [String: Double])
func toJson() -> JsonObject
}
open class RecordedContextImpl: RecordedContext, @unchecked Sendable {
fileprivate let pointer: UnsafeMutableRawPointer!
/// Used to instantiate a [FFIObject] without an actual pointer, for fakes in tests, mostly.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct NoPointer {
public init() {}
}
// TODO: We'd like this to be `private` but for Swifty reasons,
// we can't implement `FfiConverter` without making this `required` and we can't
// make it `required` without making it `public`.
required public init(unsafeFromRawPointer pointer: UnsafeMutableRawPointer) {
self.pointer = pointer
}
// This constructor can be used to instantiate a fake object.
// - Parameter noPointer: Placeholder value so we can have a constructor separate from the default empty one that may be implemented for classes extending [FFIObject].
//
// - Warning:
// Any object instantiated with this constructor cannot be passed to an actual Rust-backed object. Since there isn't a backing [Pointer] the FFI lower functions will crash.
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public init(noPointer: NoPointer) {
self.pointer = nil
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func uniffiClonePointer() -> UnsafeMutableRawPointer {
return try! rustCall { uniffi_nimbus_fn_clone_recordedcontext(self.pointer, $0) }
}
// No primary constructor declared for this class.
deinit {
guard let pointer = pointer else {
return
}
try! rustCall { uniffi_nimbus_fn_free_recordedcontext(pointer, $0) }
}
open func getEventQueries() -> [String: String] {
return try! FfiConverterDictionaryStringString.lift(try! rustCall() {
uniffi_nimbus_fn_method_recordedcontext_get_event_queries(self.uniffiClonePointer(),$0
)
})
}
open func record() {try! rustCall() {
uniffi_nimbus_fn_method_recordedcontext_record(self.uniffiClonePointer(),$0
)
}
}
open func setEventQueryValues(eventQueryValues: [String: Double]) {try! rustCall() {
uniffi_nimbus_fn_method_recordedcontext_set_event_query_values(self.uniffiClonePointer(),
FfiConverterDictionaryStringDouble.lower(eventQueryValues),$0
)
}
}
open func toJson() -> JsonObject {
return try! FfiConverterTypeJsonObject_lift(try! rustCall() {
uniffi_nimbus_fn_method_recordedcontext_to_json(self.uniffiClonePointer(),$0
)
})
}
}
// Magic number for the Rust proxy to call using the same mechanism as every other method,
// to free the callback once it's dropped by Rust.
private let IDX_CALLBACK_FREE: Int32 = 0
// Callback return codes
private let UNIFFI_CALLBACK_SUCCESS: Int32 = 0
private let UNIFFI_CALLBACK_ERROR: Int32 = 1
private let UNIFFI_CALLBACK_UNEXPECTED_ERROR: Int32 = 2
// Put the implementation in a struct so we don't pollute the top-level namespace
fileprivate struct UniffiCallbackInterfaceRecordedContext {
// Create the VTable using a series of closures.
// Swift automatically converts these into C callback functions.
//
// This creates 1-element array, since this seems to be the only way to construct a const
// pointer that we can pass to the Rust code.
static let vtable: [UniffiVTableCallbackInterfaceRecordedContext] = [UniffiVTableCallbackInterfaceRecordedContext(
getEventQueries: { (
uniffiHandle: UInt64,
uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> [String: String] in
guard let uniffiObj = try? FfiConverterTypeRecordedContext.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.getEventQueries(
)
}
let writeReturn = { uniffiOutReturn.pointee = FfiConverterDictionaryStringString.lower($0) }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
record: { (
uniffiHandle: UInt64,
uniffiOutReturn: UnsafeMutableRawPointer,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> () in
guard let uniffiObj = try? FfiConverterTypeRecordedContext.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.record(
)
}
let writeReturn = { () }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
setEventQueryValues: { (
uniffiHandle: UInt64,
eventQueryValues: RustBuffer,
uniffiOutReturn: UnsafeMutableRawPointer,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> () in
guard let uniffiObj = try? FfiConverterTypeRecordedContext.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.setEventQueryValues(
eventQueryValues: try FfiConverterDictionaryStringDouble.lift(eventQueryValues)
)
}
let writeReturn = { () }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
toJson: { (
uniffiHandle: UInt64,
uniffiOutReturn: UnsafeMutablePointer<RustBuffer>,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> JsonObject in
guard let uniffiObj = try? FfiConverterTypeRecordedContext.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.toJson(
)
}
let writeReturn = { uniffiOutReturn.pointee = FfiConverterTypeJsonObject_lower($0) }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
uniffiFree: { (uniffiHandle: UInt64) -> () in
let result = try? FfiConverterTypeRecordedContext.handleMap.remove(handle: uniffiHandle)
if result == nil {
print("Uniffi callback interface RecordedContext: handle missing in uniffiFree")
}
}
)]
}
private func uniffiCallbackInitRecordedContext() {
uniffi_nimbus_fn_init_callback_vtable_recordedcontext(UniffiCallbackInterfaceRecordedContext.vtable)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeRecordedContext: FfiConverter {
fileprivate static let handleMap = UniffiHandleMap<RecordedContext>()
typealias FfiType = UnsafeMutableRawPointer
typealias SwiftType = RecordedContext
public static func lift(_ pointer: UnsafeMutableRawPointer) throws -> RecordedContext {
return RecordedContextImpl(unsafeFromRawPointer: pointer)
}
public static func lower(_ value: RecordedContext) -> UnsafeMutableRawPointer {
guard let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: handleMap.insert(obj: value))) else {
fatalError("Cast to UnsafeMutableRawPointer failed")
}
return ptr
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> RecordedContext {
let v: UInt64 = try readInt(&buf)
// The Rust code won't compile if a pointer won't fit in a UInt64.
// We have to go via `UInt` because that's the thing that's the size of a pointer.
let ptr = UnsafeMutableRawPointer(bitPattern: UInt(truncatingIfNeeded: v))
if (ptr == nil) {
throw UniffiInternalError.unexpectedNullPointer
}
return try lift(ptr!)
}
public static func write(_ value: RecordedContext, into buf: inout [UInt8]) {
// This fiddling is because `Int` is the thing that's the same size as a pointer.
// The Rust code won't compile if a pointer won't fit in a `UInt64`.
writeInt(&buf, UInt64(bitPattern: Int64(Int(bitPattern: lower(value)))))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeRecordedContext_lift(_ pointer: UnsafeMutableRawPointer) throws -> RecordedContext {
return try FfiConverterTypeRecordedContext.lift(pointer)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeRecordedContext_lower(_ value: RecordedContext) -> UnsafeMutableRawPointer {
return FfiConverterTypeRecordedContext.lower(value)
}
public struct AppContext {
public var appName: String
public var appId: String
public var channel: String
public var appVersion: String?
public var appBuild: String?
public var architecture: String?
public var deviceManufacturer: String?
public var deviceModel: String?
public var locale: String?
public var os: String?
public var osVersion: String?
public var androidSdkVersion: String?
public var debugTag: String?
public var installationDate: Int64?
public var homeDirectory: String?
public var customTargetingAttributes: JsonObject?
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(appName: String, appId: String, channel: String, appVersion: String?, appBuild: String?, architecture: String?, deviceManufacturer: String?, deviceModel: String?, locale: String?, os: String?, osVersion: String?, androidSdkVersion: String?, debugTag: String?, installationDate: Int64?, homeDirectory: String?, customTargetingAttributes: JsonObject?) {
self.appName = appName
self.appId = appId
self.channel = channel
self.appVersion = appVersion
self.appBuild = appBuild
self.architecture = architecture
self.deviceManufacturer = deviceManufacturer
self.deviceModel = deviceModel
self.locale = locale
self.os = os
self.osVersion = osVersion
self.androidSdkVersion = androidSdkVersion
self.debugTag = debugTag
self.installationDate = installationDate
self.homeDirectory = homeDirectory
self.customTargetingAttributes = customTargetingAttributes
}
}
#if compiler(>=6)
extension AppContext: Sendable {}
#endif
extension AppContext: Equatable, Hashable {
public static func ==(lhs: AppContext, rhs: AppContext) -> Bool {
if lhs.appName != rhs.appName {
return false
}
if lhs.appId != rhs.appId {
return false
}
if lhs.channel != rhs.channel {
return false
}
if lhs.appVersion != rhs.appVersion {
return false
}
if lhs.appBuild != rhs.appBuild {
return false
}
if lhs.architecture != rhs.architecture {
return false
}
if lhs.deviceManufacturer != rhs.deviceManufacturer {
return false
}
if lhs.deviceModel != rhs.deviceModel {
return false
}
if lhs.locale != rhs.locale {
return false
}
if lhs.os != rhs.os {
return false
}
if lhs.osVersion != rhs.osVersion {
return false
}
if lhs.androidSdkVersion != rhs.androidSdkVersion {
return false
}
if lhs.debugTag != rhs.debugTag {
return false
}
if lhs.installationDate != rhs.installationDate {
return false
}
if lhs.homeDirectory != rhs.homeDirectory {
return false
}
if lhs.customTargetingAttributes != rhs.customTargetingAttributes {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(appName)
hasher.combine(appId)
hasher.combine(channel)
hasher.combine(appVersion)
hasher.combine(appBuild)
hasher.combine(architecture)
hasher.combine(deviceManufacturer)
hasher.combine(deviceModel)
hasher.combine(locale)
hasher.combine(os)
hasher.combine(osVersion)
hasher.combine(androidSdkVersion)
hasher.combine(debugTag)
hasher.combine(installationDate)
hasher.combine(homeDirectory)
hasher.combine(customTargetingAttributes)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeAppContext: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AppContext {
return
try AppContext(
appName: FfiConverterString.read(from: &buf),
appId: FfiConverterString.read(from: &buf),
channel: FfiConverterString.read(from: &buf),
appVersion: FfiConverterOptionString.read(from: &buf),
appBuild: FfiConverterOptionString.read(from: &buf),
architecture: FfiConverterOptionString.read(from: &buf),
deviceManufacturer: FfiConverterOptionString.read(from: &buf),
deviceModel: FfiConverterOptionString.read(from: &buf),
locale: FfiConverterOptionString.read(from: &buf),
os: FfiConverterOptionString.read(from: &buf),
osVersion: FfiConverterOptionString.read(from: &buf),
androidSdkVersion: FfiConverterOptionString.read(from: &buf),
debugTag: FfiConverterOptionString.read(from: &buf),
installationDate: FfiConverterOptionInt64.read(from: &buf),
homeDirectory: FfiConverterOptionString.read(from: &buf),
customTargetingAttributes: FfiConverterOptionTypeJsonObject.read(from: &buf)
)
}
public static func write(_ value: AppContext, into buf: inout [UInt8]) {
FfiConverterString.write(value.appName, into: &buf)
FfiConverterString.write(value.appId, into: &buf)
FfiConverterString.write(value.channel, into: &buf)
FfiConverterOptionString.write(value.appVersion, into: &buf)
FfiConverterOptionString.write(value.appBuild, into: &buf)
FfiConverterOptionString.write(value.architecture, into: &buf)
FfiConverterOptionString.write(value.deviceManufacturer, into: &buf)
FfiConverterOptionString.write(value.deviceModel, into: &buf)
FfiConverterOptionString.write(value.locale, into: &buf)
FfiConverterOptionString.write(value.os, into: &buf)
FfiConverterOptionString.write(value.osVersion, into: &buf)
FfiConverterOptionString.write(value.androidSdkVersion, into: &buf)
FfiConverterOptionString.write(value.debugTag, into: &buf)
FfiConverterOptionInt64.write(value.installationDate, into: &buf)
FfiConverterOptionString.write(value.homeDirectory, into: &buf)
FfiConverterOptionTypeJsonObject.write(value.customTargetingAttributes, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeAppContext_lift(_ buf: RustBuffer) throws -> AppContext {
return try FfiConverterTypeAppContext.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeAppContext_lower(_ value: AppContext) -> RustBuffer {
return FfiConverterTypeAppContext.lower(value)
}
public struct AvailableExperiment {
public var slug: String
public var userFacingName: String
public var userFacingDescription: String
public var branches: [ExperimentBranch]
public var referenceBranch: String?
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(slug: String, userFacingName: String, userFacingDescription: String, branches: [ExperimentBranch], referenceBranch: String?) {
self.slug = slug
self.userFacingName = userFacingName
self.userFacingDescription = userFacingDescription
self.branches = branches
self.referenceBranch = referenceBranch
}
}
#if compiler(>=6)
extension AvailableExperiment: Sendable {}
#endif
extension AvailableExperiment: Equatable, Hashable {
public static func ==(lhs: AvailableExperiment, rhs: AvailableExperiment) -> Bool {
if lhs.slug != rhs.slug {
return false
}
if lhs.userFacingName != rhs.userFacingName {
return false
}
if lhs.userFacingDescription != rhs.userFacingDescription {
return false
}
if lhs.branches != rhs.branches {
return false
}
if lhs.referenceBranch != rhs.referenceBranch {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(slug)
hasher.combine(userFacingName)
hasher.combine(userFacingDescription)
hasher.combine(branches)
hasher.combine(referenceBranch)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeAvailableExperiment: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> AvailableExperiment {
return
try AvailableExperiment(
slug: FfiConverterString.read(from: &buf),
userFacingName: FfiConverterString.read(from: &buf),
userFacingDescription: FfiConverterString.read(from: &buf),
branches: FfiConverterSequenceTypeExperimentBranch.read(from: &buf),
referenceBranch: FfiConverterOptionString.read(from: &buf)
)
}
public static func write(_ value: AvailableExperiment, into buf: inout [UInt8]) {
FfiConverterString.write(value.slug, into: &buf)
FfiConverterString.write(value.userFacingName, into: &buf)
FfiConverterString.write(value.userFacingDescription, into: &buf)
FfiConverterSequenceTypeExperimentBranch.write(value.branches, into: &buf)
FfiConverterOptionString.write(value.referenceBranch, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeAvailableExperiment_lift(_ buf: RustBuffer) throws -> AvailableExperiment {
return try FfiConverterTypeAvailableExperiment.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeAvailableExperiment_lower(_ value: AvailableExperiment) -> RustBuffer {
return FfiConverterTypeAvailableExperiment.lower(value)
}
public struct CalculatedAttributes {
public var daysSinceInstall: Int32?
public var daysSinceUpdate: Int32?
public var language: String?
public var region: String?
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(daysSinceInstall: Int32?, daysSinceUpdate: Int32?, language: String?, region: String?) {
self.daysSinceInstall = daysSinceInstall
self.daysSinceUpdate = daysSinceUpdate
self.language = language
self.region = region
}
}
#if compiler(>=6)
extension CalculatedAttributes: Sendable {}
#endif
extension CalculatedAttributes: Equatable, Hashable {
public static func ==(lhs: CalculatedAttributes, rhs: CalculatedAttributes) -> Bool {
if lhs.daysSinceInstall != rhs.daysSinceInstall {
return false
}
if lhs.daysSinceUpdate != rhs.daysSinceUpdate {
return false
}
if lhs.language != rhs.language {
return false
}
if lhs.region != rhs.region {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(daysSinceInstall)
hasher.combine(daysSinceUpdate)
hasher.combine(language)
hasher.combine(region)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeCalculatedAttributes: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> CalculatedAttributes {
return
try CalculatedAttributes(
daysSinceInstall: FfiConverterOptionInt32.read(from: &buf),
daysSinceUpdate: FfiConverterOptionInt32.read(from: &buf),
language: FfiConverterOptionString.read(from: &buf),
region: FfiConverterOptionString.read(from: &buf)
)
}
public static func write(_ value: CalculatedAttributes, into buf: inout [UInt8]) {
FfiConverterOptionInt32.write(value.daysSinceInstall, into: &buf)
FfiConverterOptionInt32.write(value.daysSinceUpdate, into: &buf)
FfiConverterOptionString.write(value.language, into: &buf)
FfiConverterOptionString.write(value.region, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeCalculatedAttributes_lift(_ buf: RustBuffer) throws -> CalculatedAttributes {
return try FfiConverterTypeCalculatedAttributes.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeCalculatedAttributes_lower(_ value: CalculatedAttributes) -> RustBuffer {
return FfiConverterTypeCalculatedAttributes.lower(value)
}
public struct EnrolledExperiment {
public var featureIds: [String]
public var slug: String
public var userFacingName: String
public var userFacingDescription: String
public var branchSlug: String
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(featureIds: [String], slug: String, userFacingName: String, userFacingDescription: String, branchSlug: String) {
self.featureIds = featureIds
self.slug = slug
self.userFacingName = userFacingName
self.userFacingDescription = userFacingDescription
self.branchSlug = branchSlug
}
}
#if compiler(>=6)
extension EnrolledExperiment: Sendable {}
#endif
extension EnrolledExperiment: Equatable, Hashable {
public static func ==(lhs: EnrolledExperiment, rhs: EnrolledExperiment) -> Bool {
if lhs.featureIds != rhs.featureIds {
return false
}
if lhs.slug != rhs.slug {
return false
}
if lhs.userFacingName != rhs.userFacingName {
return false
}
if lhs.userFacingDescription != rhs.userFacingDescription {
return false
}
if lhs.branchSlug != rhs.branchSlug {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(featureIds)
hasher.combine(slug)
hasher.combine(userFacingName)
hasher.combine(userFacingDescription)
hasher.combine(branchSlug)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeEnrolledExperiment: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EnrolledExperiment {
return
try EnrolledExperiment(
featureIds: FfiConverterSequenceString.read(from: &buf),
slug: FfiConverterString.read(from: &buf),
userFacingName: FfiConverterString.read(from: &buf),
userFacingDescription: FfiConverterString.read(from: &buf),
branchSlug: FfiConverterString.read(from: &buf)
)
}
public static func write(_ value: EnrolledExperiment, into buf: inout [UInt8]) {
FfiConverterSequenceString.write(value.featureIds, into: &buf)
FfiConverterString.write(value.slug, into: &buf)
FfiConverterString.write(value.userFacingName, into: &buf)
FfiConverterString.write(value.userFacingDescription, into: &buf)
FfiConverterString.write(value.branchSlug, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrolledExperiment_lift(_ buf: RustBuffer) throws -> EnrolledExperiment {
return try FfiConverterTypeEnrolledExperiment.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrolledExperiment_lower(_ value: EnrolledExperiment) -> RustBuffer {
return FfiConverterTypeEnrolledExperiment.lower(value)
}
public struct EnrollmentChangeEvent {
public var experimentSlug: String
public var branchSlug: String
public var reason: String?
public var change: EnrollmentChangeEventType
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(experimentSlug: String, branchSlug: String, reason: String?, change: EnrollmentChangeEventType) {
self.experimentSlug = experimentSlug
self.branchSlug = branchSlug
self.reason = reason
self.change = change
}
}
#if compiler(>=6)
extension EnrollmentChangeEvent: Sendable {}
#endif
extension EnrollmentChangeEvent: Equatable, Hashable {
public static func ==(lhs: EnrollmentChangeEvent, rhs: EnrollmentChangeEvent) -> Bool {
if lhs.experimentSlug != rhs.experimentSlug {
return false
}
if lhs.branchSlug != rhs.branchSlug {
return false
}
if lhs.reason != rhs.reason {
return false
}
if lhs.change != rhs.change {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(experimentSlug)
hasher.combine(branchSlug)
hasher.combine(reason)
hasher.combine(change)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeEnrollmentChangeEvent: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EnrollmentChangeEvent {
return
try EnrollmentChangeEvent(
experimentSlug: FfiConverterString.read(from: &buf),
branchSlug: FfiConverterString.read(from: &buf),
reason: FfiConverterOptionString.read(from: &buf),
change: FfiConverterTypeEnrollmentChangeEventType.read(from: &buf)
)
}
public static func write(_ value: EnrollmentChangeEvent, into buf: inout [UInt8]) {
FfiConverterString.write(value.experimentSlug, into: &buf)
FfiConverterString.write(value.branchSlug, into: &buf)
FfiConverterOptionString.write(value.reason, into: &buf)
FfiConverterTypeEnrollmentChangeEventType.write(value.change, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrollmentChangeEvent_lift(_ buf: RustBuffer) throws -> EnrollmentChangeEvent {
return try FfiConverterTypeEnrollmentChangeEvent.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrollmentChangeEvent_lower(_ value: EnrollmentChangeEvent) -> RustBuffer {
return FfiConverterTypeEnrollmentChangeEvent.lower(value)
}
public struct EnrollmentStatusExtraDef {
public var branch: String?
public var conflictSlug: String?
public var errorString: String?
public var reason: String?
public var slug: String?
public var status: String?
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(branch: String?, conflictSlug: String?, errorString: String?, reason: String?, slug: String?, status: String?) {
self.branch = branch
self.conflictSlug = conflictSlug
self.errorString = errorString
self.reason = reason
self.slug = slug
self.status = status
}
}
#if compiler(>=6)
extension EnrollmentStatusExtraDef: Sendable {}
#endif
extension EnrollmentStatusExtraDef: Equatable, Hashable {
public static func ==(lhs: EnrollmentStatusExtraDef, rhs: EnrollmentStatusExtraDef) -> Bool {
if lhs.branch != rhs.branch {
return false
}
if lhs.conflictSlug != rhs.conflictSlug {
return false
}
if lhs.errorString != rhs.errorString {
return false
}
if lhs.reason != rhs.reason {
return false
}
if lhs.slug != rhs.slug {
return false
}
if lhs.status != rhs.status {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(branch)
hasher.combine(conflictSlug)
hasher.combine(errorString)
hasher.combine(reason)
hasher.combine(slug)
hasher.combine(status)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeEnrollmentStatusExtraDef: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EnrollmentStatusExtraDef {
return
try EnrollmentStatusExtraDef(
branch: FfiConverterOptionString.read(from: &buf),
conflictSlug: FfiConverterOptionString.read(from: &buf),
errorString: FfiConverterOptionString.read(from: &buf),
reason: FfiConverterOptionString.read(from: &buf),
slug: FfiConverterOptionString.read(from: &buf),
status: FfiConverterOptionString.read(from: &buf)
)
}
public static func write(_ value: EnrollmentStatusExtraDef, into buf: inout [UInt8]) {
FfiConverterOptionString.write(value.branch, into: &buf)
FfiConverterOptionString.write(value.conflictSlug, into: &buf)
FfiConverterOptionString.write(value.errorString, into: &buf)
FfiConverterOptionString.write(value.reason, into: &buf)
FfiConverterOptionString.write(value.slug, into: &buf)
FfiConverterOptionString.write(value.status, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrollmentStatusExtraDef_lift(_ buf: RustBuffer) throws -> EnrollmentStatusExtraDef {
return try FfiConverterTypeEnrollmentStatusExtraDef.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrollmentStatusExtraDef_lower(_ value: EnrollmentStatusExtraDef) -> RustBuffer {
return FfiConverterTypeEnrollmentStatusExtraDef.lower(value)
}
public struct ExperimentBranch {
public var slug: String
public var ratio: Int32
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(slug: String, ratio: Int32) {
self.slug = slug
self.ratio = ratio
}
}
#if compiler(>=6)
extension ExperimentBranch: Sendable {}
#endif
extension ExperimentBranch: Equatable, Hashable {
public static func ==(lhs: ExperimentBranch, rhs: ExperimentBranch) -> Bool {
if lhs.slug != rhs.slug {
return false
}
if lhs.ratio != rhs.ratio {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(slug)
hasher.combine(ratio)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeExperimentBranch: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> ExperimentBranch {
return
try ExperimentBranch(
slug: FfiConverterString.read(from: &buf),
ratio: FfiConverterInt32.read(from: &buf)
)
}
public static func write(_ value: ExperimentBranch, into buf: inout [UInt8]) {
FfiConverterString.write(value.slug, into: &buf)
FfiConverterInt32.write(value.ratio, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeExperimentBranch_lift(_ buf: RustBuffer) throws -> ExperimentBranch {
return try FfiConverterTypeExperimentBranch.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeExperimentBranch_lower(_ value: ExperimentBranch) -> RustBuffer {
return FfiConverterTypeExperimentBranch.lower(value)
}
public struct FeatureExposureExtraDef {
public var branch: String?
public var slug: String
public var featureId: String
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(branch: String?, slug: String, featureId: String) {
self.branch = branch
self.slug = slug
self.featureId = featureId
}
}
#if compiler(>=6)
extension FeatureExposureExtraDef: Sendable {}
#endif
extension FeatureExposureExtraDef: Equatable, Hashable {
public static func ==(lhs: FeatureExposureExtraDef, rhs: FeatureExposureExtraDef) -> Bool {
if lhs.branch != rhs.branch {
return false
}
if lhs.slug != rhs.slug {
return false
}
if lhs.featureId != rhs.featureId {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(branch)
hasher.combine(slug)
hasher.combine(featureId)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeFeatureExposureExtraDef: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> FeatureExposureExtraDef {
return
try FeatureExposureExtraDef(
branch: FfiConverterOptionString.read(from: &buf),
slug: FfiConverterString.read(from: &buf),
featureId: FfiConverterString.read(from: &buf)
)
}
public static func write(_ value: FeatureExposureExtraDef, into buf: inout [UInt8]) {
FfiConverterOptionString.write(value.branch, into: &buf)
FfiConverterString.write(value.slug, into: &buf)
FfiConverterString.write(value.featureId, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeFeatureExposureExtraDef_lift(_ buf: RustBuffer) throws -> FeatureExposureExtraDef {
return try FfiConverterTypeFeatureExposureExtraDef.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeFeatureExposureExtraDef_lower(_ value: FeatureExposureExtraDef) -> RustBuffer {
return FfiConverterTypeFeatureExposureExtraDef.lower(value)
}
public struct MalformedFeatureConfigExtraDef {
public var branch: String?
public var slug: String?
public var featureId: String
public var part: String
// Default memberwise initializers are never public by default, so we
// declare one manually.
public init(branch: String?, slug: String?, featureId: String, part: String) {
self.branch = branch
self.slug = slug
self.featureId = featureId
self.part = part
}
}
#if compiler(>=6)
extension MalformedFeatureConfigExtraDef: Sendable {}
#endif
extension MalformedFeatureConfigExtraDef: Equatable, Hashable {
public static func ==(lhs: MalformedFeatureConfigExtraDef, rhs: MalformedFeatureConfigExtraDef) -> Bool {
if lhs.branch != rhs.branch {
return false
}
if lhs.slug != rhs.slug {
return false
}
if lhs.featureId != rhs.featureId {
return false
}
if lhs.part != rhs.part {
return false
}
return true
}
public func hash(into hasher: inout Hasher) {
hasher.combine(branch)
hasher.combine(slug)
hasher.combine(featureId)
hasher.combine(part)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeMalformedFeatureConfigExtraDef: FfiConverterRustBuffer {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> MalformedFeatureConfigExtraDef {
return
try MalformedFeatureConfigExtraDef(
branch: FfiConverterOptionString.read(from: &buf),
slug: FfiConverterOptionString.read(from: &buf),
featureId: FfiConverterString.read(from: &buf),
part: FfiConverterString.read(from: &buf)
)
}
public static func write(_ value: MalformedFeatureConfigExtraDef, into buf: inout [UInt8]) {
FfiConverterOptionString.write(value.branch, into: &buf)
FfiConverterOptionString.write(value.slug, into: &buf)
FfiConverterString.write(value.featureId, into: &buf)
FfiConverterString.write(value.part, into: &buf)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMalformedFeatureConfigExtraDef_lift(_ buf: RustBuffer) throws -> MalformedFeatureConfigExtraDef {
return try FfiConverterTypeMalformedFeatureConfigExtraDef.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeMalformedFeatureConfigExtraDef_lower(_ value: MalformedFeatureConfigExtraDef) -> RustBuffer {
return FfiConverterTypeMalformedFeatureConfigExtraDef.lower(value)
}
// Note that we don't yet support `indirect` for enums.
// See https://github.com/mozilla/uniffi-rs/issues/396 for further discussion.
public enum EnrollmentChangeEventType {
case enrollment
case enrollFailed
case disqualification
case unenrollment
case unenrollFailed
}
#if compiler(>=6)
extension EnrollmentChangeEventType: Sendable {}
#endif
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeEnrollmentChangeEventType: FfiConverterRustBuffer {
typealias SwiftType = EnrollmentChangeEventType
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> EnrollmentChangeEventType {
let variant: Int32 = try readInt(&buf)
switch variant {
case 1: return .enrollment
case 2: return .enrollFailed
case 3: return .disqualification
case 4: return .unenrollment
case 5: return .unenrollFailed
default: throw UniffiInternalError.unexpectedEnumCase
}
}
public static func write(_ value: EnrollmentChangeEventType, into buf: inout [UInt8]) {
switch value {
case .enrollment:
writeInt(&buf, Int32(1))
case .enrollFailed:
writeInt(&buf, Int32(2))
case .disqualification:
writeInt(&buf, Int32(3))
case .unenrollment:
writeInt(&buf, Int32(4))
case .unenrollFailed:
writeInt(&buf, Int32(5))
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrollmentChangeEventType_lift(_ buf: RustBuffer) throws -> EnrollmentChangeEventType {
return try FfiConverterTypeEnrollmentChangeEventType.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeEnrollmentChangeEventType_lower(_ value: EnrollmentChangeEventType) -> RustBuffer {
return FfiConverterTypeEnrollmentChangeEventType.lower(value)
}
extension EnrollmentChangeEventType: Equatable, Hashable {}
public enum NimbusError {
case InvalidPersistedData(message: String)
case RkvError(message: String)
case IoError(message: String)
case JsonError(message: String)
case EvaluationError(message: String)
case InvalidExpression(message: String)
case InvalidFraction(message: String)
case TryFromSliceError(message: String)
case EmptyRatiosError(message: String)
case OutOfBoundsError(message: String)
case UrlParsingError(message: String)
case UuidError(message: String)
case InvalidExperimentFormat(message: String)
case InvalidPath(message: String)
case InternalError(message: String)
case NoSuchExperiment(message: String)
case NoSuchBranch(message: String)
case DatabaseNotReady(message: String)
case VersionParsingError(message: String)
case BehaviorError(message: String)
case TryFromIntError(message: String)
case ParseIntError(message: String)
case TransformParameterError(message: String)
case ClientError(message: String)
case UniFfiCallbackError(message: String)
case RegexError(message: String)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeNimbusError: FfiConverterRustBuffer {
typealias SwiftType = NimbusError
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> NimbusError {
let variant: Int32 = try readInt(&buf)
switch variant {
case 1: return .InvalidPersistedData(
message: try FfiConverterString.read(from: &buf)
)
case 2: return .RkvError(
message: try FfiConverterString.read(from: &buf)
)
case 3: return .IoError(
message: try FfiConverterString.read(from: &buf)
)
case 4: return .JsonError(
message: try FfiConverterString.read(from: &buf)
)
case 5: return .EvaluationError(
message: try FfiConverterString.read(from: &buf)
)
case 6: return .InvalidExpression(
message: try FfiConverterString.read(from: &buf)
)
case 7: return .InvalidFraction(
message: try FfiConverterString.read(from: &buf)
)
case 8: return .TryFromSliceError(
message: try FfiConverterString.read(from: &buf)
)
case 9: return .EmptyRatiosError(
message: try FfiConverterString.read(from: &buf)
)
case 10: return .OutOfBoundsError(
message: try FfiConverterString.read(from: &buf)
)
case 11: return .UrlParsingError(
message: try FfiConverterString.read(from: &buf)
)
case 12: return .UuidError(
message: try FfiConverterString.read(from: &buf)
)
case 13: return .InvalidExperimentFormat(
message: try FfiConverterString.read(from: &buf)
)
case 14: return .InvalidPath(
message: try FfiConverterString.read(from: &buf)
)
case 15: return .InternalError(
message: try FfiConverterString.read(from: &buf)
)
case 16: return .NoSuchExperiment(
message: try FfiConverterString.read(from: &buf)
)
case 17: return .NoSuchBranch(
message: try FfiConverterString.read(from: &buf)
)
case 18: return .DatabaseNotReady(
message: try FfiConverterString.read(from: &buf)
)
case 19: return .VersionParsingError(
message: try FfiConverterString.read(from: &buf)
)
case 20: return .BehaviorError(
message: try FfiConverterString.read(from: &buf)
)
case 21: return .TryFromIntError(
message: try FfiConverterString.read(from: &buf)
)
case 22: return .ParseIntError(
message: try FfiConverterString.read(from: &buf)
)
case 23: return .TransformParameterError(
message: try FfiConverterString.read(from: &buf)
)
case 24: return .ClientError(
message: try FfiConverterString.read(from: &buf)
)
case 25: return .UniFfiCallbackError(
message: try FfiConverterString.read(from: &buf)
)
case 26: return .RegexError(
message: try FfiConverterString.read(from: &buf)
)
default: throw UniffiInternalError.unexpectedEnumCase
}
}
public static func write(_ value: NimbusError, into buf: inout [UInt8]) {
switch value {
case .InvalidPersistedData(_ /* message is ignored*/):
writeInt(&buf, Int32(1))
case .RkvError(_ /* message is ignored*/):
writeInt(&buf, Int32(2))
case .IoError(_ /* message is ignored*/):
writeInt(&buf, Int32(3))
case .JsonError(_ /* message is ignored*/):
writeInt(&buf, Int32(4))
case .EvaluationError(_ /* message is ignored*/):
writeInt(&buf, Int32(5))
case .InvalidExpression(_ /* message is ignored*/):
writeInt(&buf, Int32(6))
case .InvalidFraction(_ /* message is ignored*/):
writeInt(&buf, Int32(7))
case .TryFromSliceError(_ /* message is ignored*/):
writeInt(&buf, Int32(8))
case .EmptyRatiosError(_ /* message is ignored*/):
writeInt(&buf, Int32(9))
case .OutOfBoundsError(_ /* message is ignored*/):
writeInt(&buf, Int32(10))
case .UrlParsingError(_ /* message is ignored*/):
writeInt(&buf, Int32(11))
case .UuidError(_ /* message is ignored*/):
writeInt(&buf, Int32(12))
case .InvalidExperimentFormat(_ /* message is ignored*/):
writeInt(&buf, Int32(13))
case .InvalidPath(_ /* message is ignored*/):
writeInt(&buf, Int32(14))
case .InternalError(_ /* message is ignored*/):
writeInt(&buf, Int32(15))
case .NoSuchExperiment(_ /* message is ignored*/):
writeInt(&buf, Int32(16))
case .NoSuchBranch(_ /* message is ignored*/):
writeInt(&buf, Int32(17))
case .DatabaseNotReady(_ /* message is ignored*/):
writeInt(&buf, Int32(18))
case .VersionParsingError(_ /* message is ignored*/):
writeInt(&buf, Int32(19))
case .BehaviorError(_ /* message is ignored*/):
writeInt(&buf, Int32(20))
case .TryFromIntError(_ /* message is ignored*/):
writeInt(&buf, Int32(21))
case .ParseIntError(_ /* message is ignored*/):
writeInt(&buf, Int32(22))
case .TransformParameterError(_ /* message is ignored*/):
writeInt(&buf, Int32(23))
case .ClientError(_ /* message is ignored*/):
writeInt(&buf, Int32(24))
case .UniFfiCallbackError(_ /* message is ignored*/):
writeInt(&buf, Int32(25))
case .RegexError(_ /* message is ignored*/):
writeInt(&buf, Int32(26))
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusError_lift(_ buf: RustBuffer) throws -> NimbusError {
return try FfiConverterTypeNimbusError.lift(buf)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeNimbusError_lower(_ value: NimbusError) -> RustBuffer {
return FfiConverterTypeNimbusError.lower(value)
}
extension NimbusError: Equatable, Hashable {}
extension NimbusError: Foundation.LocalizedError {
public var errorDescription: String? {
String(reflecting: self)
}
}
public protocol MetricsHandler: AnyObject {
func recordEnrollmentStatuses(enrollmentStatusExtras: [EnrollmentStatusExtraDef])
/**
* Feature activation is the pre-cursor to feature exposure: it is defined as the first time
* the feature configuration is asked for.
*/
func recordFeatureActivation(event: FeatureExposureExtraDef)
func recordFeatureExposure(event: FeatureExposureExtraDef)
func recordMalformedFeatureConfig(event: MalformedFeatureConfigExtraDef)
}
// Put the implementation in a struct so we don't pollute the top-level namespace
fileprivate struct UniffiCallbackInterfaceMetricsHandler {
// Create the VTable using a series of closures.
// Swift automatically converts these into C callback functions.
//
// This creates 1-element array, since this seems to be the only way to construct a const
// pointer that we can pass to the Rust code.
static let vtable: [UniffiVTableCallbackInterfaceMetricsHandler] = [UniffiVTableCallbackInterfaceMetricsHandler(
recordEnrollmentStatuses: { (
uniffiHandle: UInt64,
enrollmentStatusExtras: RustBuffer,
uniffiOutReturn: UnsafeMutableRawPointer,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> () in
guard let uniffiObj = try? FfiConverterCallbackInterfaceMetricsHandler.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.recordEnrollmentStatuses(
enrollmentStatusExtras: try FfiConverterSequenceTypeEnrollmentStatusExtraDef.lift(enrollmentStatusExtras)
)
}
let writeReturn = { () }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
recordFeatureActivation: { (
uniffiHandle: UInt64,
event: RustBuffer,
uniffiOutReturn: UnsafeMutableRawPointer,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> () in
guard let uniffiObj = try? FfiConverterCallbackInterfaceMetricsHandler.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.recordFeatureActivation(
event: try FfiConverterTypeFeatureExposureExtraDef_lift(event)
)
}
let writeReturn = { () }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
recordFeatureExposure: { (
uniffiHandle: UInt64,
event: RustBuffer,
uniffiOutReturn: UnsafeMutableRawPointer,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> () in
guard let uniffiObj = try? FfiConverterCallbackInterfaceMetricsHandler.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.recordFeatureExposure(
event: try FfiConverterTypeFeatureExposureExtraDef_lift(event)
)
}
let writeReturn = { () }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
recordMalformedFeatureConfig: { (
uniffiHandle: UInt64,
event: RustBuffer,
uniffiOutReturn: UnsafeMutableRawPointer,
uniffiCallStatus: UnsafeMutablePointer<RustCallStatus>
) in
let makeCall = {
() throws -> () in
guard let uniffiObj = try? FfiConverterCallbackInterfaceMetricsHandler.handleMap.get(handle: uniffiHandle) else {
throw UniffiInternalError.unexpectedStaleHandle
}
return uniffiObj.recordMalformedFeatureConfig(
event: try FfiConverterTypeMalformedFeatureConfigExtraDef_lift(event)
)
}
let writeReturn = { () }
uniffiTraitInterfaceCall(
callStatus: uniffiCallStatus,
makeCall: makeCall,
writeReturn: writeReturn
)
},
uniffiFree: { (uniffiHandle: UInt64) -> () in
let result = try? FfiConverterCallbackInterfaceMetricsHandler.handleMap.remove(handle: uniffiHandle)
if result == nil {
print("Uniffi callback interface MetricsHandler: handle missing in uniffiFree")
}
}
)]
}
private func uniffiCallbackInitMetricsHandler() {
uniffi_nimbus_fn_init_callback_vtable_metricshandler(UniffiCallbackInterfaceMetricsHandler.vtable)
}
// FfiConverter protocol for callback interfaces
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterCallbackInterfaceMetricsHandler {
fileprivate static let handleMap = UniffiHandleMap<MetricsHandler>()
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
extension FfiConverterCallbackInterfaceMetricsHandler : FfiConverter {
typealias SwiftType = MetricsHandler
typealias FfiType = UInt64
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func lift(_ handle: UInt64) throws -> SwiftType {
try handleMap.get(handle: handle)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
let handle: UInt64 = try readInt(&buf)
return try lift(handle)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func lower(_ v: SwiftType) -> UInt64 {
return handleMap.insert(obj: v)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public static func write(_ v: SwiftType, into buf: inout [UInt8]) {
writeInt(&buf, lower(v))
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterCallbackInterfaceMetricsHandler_lift(_ handle: UInt64) throws -> MetricsHandler {
return try FfiConverterCallbackInterfaceMetricsHandler.lift(handle)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterCallbackInterfaceMetricsHandler_lower(_ v: MetricsHandler) -> UInt64 {
return FfiConverterCallbackInterfaceMetricsHandler.lower(v)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionInt32: FfiConverterRustBuffer {
typealias SwiftType = Int32?
public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
guard let value = value else {
writeInt(&buf, Int8(0))
return
}
writeInt(&buf, Int8(1))
FfiConverterInt32.write(value, into: &buf)
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
switch try readInt(&buf) as Int8 {
case 0: return nil
case 1: return try FfiConverterInt32.read(from: &buf)
default: throw UniffiInternalError.unexpectedOptionalTag
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionInt64: FfiConverterRustBuffer {
typealias SwiftType = Int64?
public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
guard let value = value else {
writeInt(&buf, Int8(0))
return
}
writeInt(&buf, Int8(1))
FfiConverterInt64.write(value, into: &buf)
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
switch try readInt(&buf) as Int8 {
case 0: return nil
case 1: return try FfiConverterInt64.read(from: &buf)
default: throw UniffiInternalError.unexpectedOptionalTag
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionString: FfiConverterRustBuffer {
typealias SwiftType = String?
public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
guard let value = value else {
writeInt(&buf, Int8(0))
return
}
writeInt(&buf, Int8(1))
FfiConverterString.write(value, into: &buf)
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
switch try readInt(&buf) as Int8 {
case 0: return nil
case 1: return try FfiConverterString.read(from: &buf)
default: throw UniffiInternalError.unexpectedOptionalTag
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeRecordedContext: FfiConverterRustBuffer {
typealias SwiftType = RecordedContext?
public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
guard let value = value else {
writeInt(&buf, Int8(0))
return
}
writeInt(&buf, Int8(1))
FfiConverterTypeRecordedContext.write(value, into: &buf)
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
switch try readInt(&buf) as Int8 {
case 0: return nil
case 1: return try FfiConverterTypeRecordedContext.read(from: &buf)
default: throw UniffiInternalError.unexpectedOptionalTag
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeRemoteSettingsConfig: FfiConverterRustBuffer {
typealias SwiftType = RemoteSettingsConfig?
public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
guard let value = value else {
writeInt(&buf, Int8(0))
return
}
writeInt(&buf, Int8(1))
FfiConverterTypeRemoteSettingsConfig.write(value, into: &buf)
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
switch try readInt(&buf) as Int8 {
case 0: return nil
case 1: return try FfiConverterTypeRemoteSettingsConfig.read(from: &buf)
default: throw UniffiInternalError.unexpectedOptionalTag
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterOptionTypeJsonObject: FfiConverterRustBuffer {
typealias SwiftType = JsonObject?
public static func write(_ value: SwiftType, into buf: inout [UInt8]) {
guard let value = value else {
writeInt(&buf, Int8(0))
return
}
writeInt(&buf, Int8(1))
FfiConverterTypeJsonObject.write(value, into: &buf)
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> SwiftType {
switch try readInt(&buf) as Int8 {
case 0: return nil
case 1: return try FfiConverterTypeJsonObject.read(from: &buf)
default: throw UniffiInternalError.unexpectedOptionalTag
}
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceString: FfiConverterRustBuffer {
typealias SwiftType = [String]
public static func write(_ value: [String], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for item in value {
FfiConverterString.write(item, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String] {
let len: Int32 = try readInt(&buf)
var seq = [String]()
seq.reserveCapacity(Int(len))
for _ in 0 ..< len {
seq.append(try FfiConverterString.read(from: &buf))
}
return seq
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeAvailableExperiment: FfiConverterRustBuffer {
typealias SwiftType = [AvailableExperiment]
public static func write(_ value: [AvailableExperiment], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for item in value {
FfiConverterTypeAvailableExperiment.write(item, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [AvailableExperiment] {
let len: Int32 = try readInt(&buf)
var seq = [AvailableExperiment]()
seq.reserveCapacity(Int(len))
for _ in 0 ..< len {
seq.append(try FfiConverterTypeAvailableExperiment.read(from: &buf))
}
return seq
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeEnrolledExperiment: FfiConverterRustBuffer {
typealias SwiftType = [EnrolledExperiment]
public static func write(_ value: [EnrolledExperiment], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for item in value {
FfiConverterTypeEnrolledExperiment.write(item, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [EnrolledExperiment] {
let len: Int32 = try readInt(&buf)
var seq = [EnrolledExperiment]()
seq.reserveCapacity(Int(len))
for _ in 0 ..< len {
seq.append(try FfiConverterTypeEnrolledExperiment.read(from: &buf))
}
return seq
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeEnrollmentChangeEvent: FfiConverterRustBuffer {
typealias SwiftType = [EnrollmentChangeEvent]
public static func write(_ value: [EnrollmentChangeEvent], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for item in value {
FfiConverterTypeEnrollmentChangeEvent.write(item, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [EnrollmentChangeEvent] {
let len: Int32 = try readInt(&buf)
var seq = [EnrollmentChangeEvent]()
seq.reserveCapacity(Int(len))
for _ in 0 ..< len {
seq.append(try FfiConverterTypeEnrollmentChangeEvent.read(from: &buf))
}
return seq
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeEnrollmentStatusExtraDef: FfiConverterRustBuffer {
typealias SwiftType = [EnrollmentStatusExtraDef]
public static func write(_ value: [EnrollmentStatusExtraDef], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for item in value {
FfiConverterTypeEnrollmentStatusExtraDef.write(item, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [EnrollmentStatusExtraDef] {
let len: Int32 = try readInt(&buf)
var seq = [EnrollmentStatusExtraDef]()
seq.reserveCapacity(Int(len))
for _ in 0 ..< len {
seq.append(try FfiConverterTypeEnrollmentStatusExtraDef.read(from: &buf))
}
return seq
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterSequenceTypeExperimentBranch: FfiConverterRustBuffer {
typealias SwiftType = [ExperimentBranch]
public static func write(_ value: [ExperimentBranch], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for item in value {
FfiConverterTypeExperimentBranch.write(item, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [ExperimentBranch] {
let len: Int32 = try readInt(&buf)
var seq = [ExperimentBranch]()
seq.reserveCapacity(Int(len))
for _ in 0 ..< len {
seq.append(try FfiConverterTypeExperimentBranch.read(from: &buf))
}
return seq
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterDictionaryStringDouble: FfiConverterRustBuffer {
public static func write(_ value: [String: Double], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for (key, value) in value {
FfiConverterString.write(key, into: &buf)
FfiConverterDouble.write(value, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String: Double] {
let len: Int32 = try readInt(&buf)
var dict = [String: Double]()
dict.reserveCapacity(Int(len))
for _ in 0..<len {
let key = try FfiConverterString.read(from: &buf)
let value = try FfiConverterDouble.read(from: &buf)
dict[key] = value
}
return dict
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
fileprivate struct FfiConverterDictionaryStringString: FfiConverterRustBuffer {
public static func write(_ value: [String: String], into buf: inout [UInt8]) {
let len = Int32(value.count)
writeInt(&buf, len)
for (key, value) in value {
FfiConverterString.write(key, into: &buf)
FfiConverterString.write(value, into: &buf)
}
}
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> [String: String] {
let len: Int32 = try readInt(&buf)
var dict = [String: String]()
dict.reserveCapacity(Int(len))
for _ in 0..<len {
let key = try FfiConverterString.read(from: &buf)
let value = try FfiConverterString.read(from: &buf)
dict[key] = value
}
return dict
}
}
/**
* Typealias from the type name used in the UDL file to the builtin type. This
* is needed because the UDL type name is used in function/method signatures.
*/
public typealias JsonObject = String
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public struct FfiConverterTypeJsonObject: FfiConverter {
public static func read(from buf: inout (data: Data, offset: Data.Index)) throws -> JsonObject {
return try FfiConverterString.read(from: &buf)
}
public static func write(_ value: JsonObject, into buf: inout [UInt8]) {
return FfiConverterString.write(value, into: &buf)
}
public static func lift(_ value: RustBuffer) throws -> JsonObject {
return try FfiConverterString.lift(value)
}
public static func lower(_ value: JsonObject) -> RustBuffer {
return FfiConverterString.lower(value)
}
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeJsonObject_lift(_ value: RustBuffer) throws -> JsonObject {
return try FfiConverterTypeJsonObject.lift(value)
}
#if swift(>=5.8)
@_documentation(visibility: private)
#endif
public func FfiConverterTypeJsonObject_lower(_ value: JsonObject) -> RustBuffer {
return FfiConverterTypeJsonObject.lower(value)
}
/**
*/
public func getCalculatedAttributes(installationDate: Int64?, dbPath: String, locale: String)throws -> CalculatedAttributes {
return try FfiConverterTypeCalculatedAttributes_lift(try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_func_get_calculated_attributes(
FfiConverterOptionInt64.lower(installationDate),
FfiConverterString.lower(dbPath),
FfiConverterString.lower(locale),$0
)
})
}
/**
* A test utility used to validate event queries against the jexl evaluator.
*
* This method should only be used in tests.
*/
public func validateEventQueries(recordedContext: RecordedContext)throws {try rustCallWithError(FfiConverterTypeNimbusError_lift) {
uniffi_nimbus_fn_func_validate_event_queries(
FfiConverterTypeRecordedContext_lower(recordedContext),$0
)
}
}
private enum InitializationResult {
case ok
case contractVersionMismatch
case apiChecksumMismatch
}
// Use a global variable to perform the versioning checks. Swift ensures that
// the code inside is only computed once.
private let initializationResult: InitializationResult = {
// Get the bindings contract version from our ComponentInterface
let bindings_contract_version = 29
// Get the scaffolding contract version by calling the into the dylib
let scaffolding_contract_version = ffi_nimbus_uniffi_contract_version()
if bindings_contract_version != scaffolding_contract_version {
return InitializationResult.contractVersionMismatch
}
if (uniffi_nimbus_checksum_func_get_calculated_attributes() != 10534) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_func_validate_event_queries() != 42746) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_advance_event_time() != 40755) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_apply_pending_experiments() != 21020) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_clear_events() != 38691) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_create_string_helper() != 48136) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_create_targeting_helper() != 37928) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_dump_state_to_log() != 43374) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_fetch_experiments() != 7325) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_get_active_experiments() != 63303) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_get_available_experiments() != 53590) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_get_experiment_branch() != 35089) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_get_experiment_branches() != 60563) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_get_feature_config_variables() != 7354) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_get_global_user_participation() != 53001) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_initialize() != 500) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_is_fetch_enabled() != 9890) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_opt_in_with_branch() != 54676) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_opt_out() != 19195) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_record_event() != 60856) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_record_feature_exposure() != 19276) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_record_malformed_feature_config() != 52482) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_record_past_event() != 4442) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_reset_enrollments() != 39284) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_reset_telemetry_identifiers() != 44528) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_set_experiments_locally() != 29563) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_set_fetch_enabled() != 64996) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusclient_set_global_user_participation() != 42180) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusstringhelper_get_uuid() != 24293) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbusstringhelper_string_format() != 12685) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_nimbustargetinghelper_eval_jexl() != 42395) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_recordedcontext_get_event_queries() != 28844) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_recordedcontext_record() != 5916) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_recordedcontext_set_event_query_values() != 40199) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_recordedcontext_to_json() != 46595) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_constructor_nimbusclient_new() != 33958) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_metricshandler_record_enrollment_statuses() != 22229) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_metricshandler_record_feature_activation() != 6186) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_metricshandler_record_feature_exposure() != 14029) {
return InitializationResult.apiChecksumMismatch
}
if (uniffi_nimbus_checksum_method_metricshandler_record_malformed_feature_config() != 29240) {
return InitializationResult.apiChecksumMismatch
}
uniffiCallbackInitRecordedContext()
uniffiCallbackInitMetricsHandler()
uniffiEnsureRemoteSettingsInitialized()
return InitializationResult.ok
}()
// Make the ensure init function public so that other modules which have external type references to
// our types can call it.
public func uniffiEnsureNimbusInitialized() {
switch initializationResult {
case .ok:
break
case .contractVersionMismatch:
fatalError("UniFFI contract version mismatch: try cleaning and rebuilding your project")
case .apiChecksumMismatch:
fatalError("UniFFI API checksum mismatch: try cleaning and rebuilding your project")
}
}
// swiftlint:enable all