Sequence

public extension Sequence where Element: ParseInstallation
public extension Sequence where Element: ParseObject
public extension Sequence where Element: ParseUser

Available where Element: ParseInstallation

  • Fetches a collection of installations aynchronously with the current data from the server and sets an error if one occurs. Publishes when complete.

    Important

    If an object fetched has the same objectId as current, it will automatically update the current.

    Declaration

    Swift

    func fetchAllPublisher(includeKeys: [String]? = nil,
                           options: API.Options = []) -> Future<[(Result<Self.Element, ParseError>)], ParseError>

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Saves a collection of installations asynchronously and publishes when complete.

    Important

    If an object saved has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAllPublisher(batchLimit limit: Int? = nil,
                          transaction: Bool = false,
                          options: API.Options = []) -> Future<[(Result<Self.Element, ParseError>)], ParseError>

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Deletes a collection of installations asynchronously and publishes when complete.

    Important

    If an object deleted has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAllPublisher(batchLimit limit: Int? = nil,
                            transaction: Bool = false,
                            options: API.Options = []) -> Future<[(Result<Void, ParseError>)], ParseError>

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Saves a collection of installations synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Important

    If an object saved has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAll(batchLimit limit: Int? = nil, // swiftlint:disable:this function_body_length
                 transaction: Bool = false,
                 options: API.Options = []) throws -> [(Result<Self.Element, ParseError>)]

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    options

    A set of header options sent to the server. Defaults to an empty set.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    Return Value

    Returns a Result enum with the object if a save was successful or a ParseError if it failed.

  • Saves a collection of installations all at once asynchronously and executes the completion block when done.

    Important

    If an object saved has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAll( // swiftlint:disable:this function_body_length cyclomatic_complexity
        batchLimit limit: Int? = nil,
        transaction: Bool = false,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Element, ParseError>)], ParseError>) -> Void
    )

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[(Result<Element, ParseError>)], ParseError>).

  • Fetches a collection of installations synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Important

    If an object fetched has the same objectId as current, it will automatically update the current.

    Warning

    The order in which installations are returned are not guarenteed. You shouldn’t expect results in any particular order.

    Declaration

    Swift

    func fetchAll(includeKeys: [String]? = nil,
                  options: API.Options = []) throws -> [(Result<Self.Element, ParseError>)]

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns a Result enum with the object if a fetch was successful or a ParseError if it failed.

  • Fetches a collection of installations all at once asynchronously and executes the completion block when done.

    Important

    If an object fetched has the same objectId as current, it will automatically update the current.

    Warning

    The order in which installations are returned are not guarenteed. You shouldn’t expect results in any particular order.

    Declaration

    Swift

    func fetchAll(
        includeKeys: [String]? = nil,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Element, ParseError>)], ParseError>) -> Void
    )

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[(Result<Element, ParseError>)], ParseError>).

  • Deletes a collection of installations synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Important

    If an object deleted has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAll(batchLimit limit: Int? = nil,
                   transaction: Bool = false,
                   options: API.Options = []) throws -> [(Result<Void, ParseError>)]

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns nil if the delete successful or a ParseError if it failed.

    1. A ParseError.Code.aggregateError. This object’s “errors” property is an array of other Parse.Error objects. Each error object in this array has an “object” property that references the object that could not be deleted (for instance, because that object could not be found).
    2. A non-aggregate Parse.Error. This indicates a serious error that caused the delete operation to be aborted partway through (for instance, a connection failure in the middle of the delete).
  • Deletes a collection of installations all at once asynchronously and executes the completion block when done.

    • A ParseError.Code.aggregateError. This object’s “errors” property is an array of other Parse.Error objects. Each error object in this array has an “object” property that references the object that could not be deleted (for instance, because that object could not be found).
    • A non-aggregate Parse.Error. This indicates a serious error that caused the delete operation to be aborted partway through (for instance, a connection failure in the middle of the delete).

    Important

    If an object deleted has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAll(
        batchLimit limit: Int? = nil,
        transaction: Bool = false,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Void, ParseError>)], ParseError>) -> Void
    )

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[ParseError?], ParseError>). Each element in the array is either nil if the delete successful or a ParseError if it failed.

Available where Element: ParseObject

  • Fetches a collection of objects aynchronously with the current data from the server and sets an error if one occurs. Publishes when complete.

    Important

    If an object fetched has the same objectId as current, it will automatically update the current.

    Declaration

    Swift

    func fetchAllPublisher(includeKeys: [String]? = nil,
                           options: API.Options = []) -> Future<[(Result<Self.Element, ParseError>)], ParseError>

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Saves a collection of objects asynchronously and publishes when complete.

    Important

    If an object saved has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAllPublisher(batchLimit limit: Int? = nil,
                          transaction: Bool = false,
                          options: API.Options = []) -> Future<[(Result<Self.Element, ParseError>)], ParseError>

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Deletes a collection of objects asynchronously and publishes when complete.

    Important

    If an object deleted has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAllPublisher(batchLimit limit: Int? = nil,
                            transaction: Bool = false,
                            options: API.Options = []) -> Future<[(Result<Void, ParseError>)], ParseError>

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Saves a collection of objects synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAll(batchLimit limit: Int? = nil, // swiftlint:disable:this function_body_length
                 transaction: Bool = false,
                 options: API.Options = []) throws -> [(Result<Self.Element, ParseError>)]

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns a Result enum with the object if a save was successful or a ParseError if it failed.

  • Saves a collection of objects all at once asynchronously and executes the completion block when done.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAll( // swiftlint:disable:this function_body_length cyclomatic_complexity
        batchLimit limit: Int? = nil,
        transaction: Bool = false,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Element, ParseError>)], ParseError>) -> Void
    )

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[(Result<Element, ParseError>)], ParseError>).

  • Fetches a collection of objects synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Warning

    The order in which objects are returned are not guarenteed. You shouldn’t expect results in any particular order.

    Declaration

    Swift

    func fetchAll(includeKeys: [String]? = nil,
                  options: API.Options = []) throws -> [(Result<Self.Element, ParseError>)]

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns a Result enum with the object if a fetch was successful or a ParseError if it failed.

  • Fetches a collection of objects all at once asynchronously and executes the completion block when done.

    Warning

    The order in which objects are returned are not guarenteed. You shouldn’t expect results in any particular order.

    Declaration

    Swift

    func fetchAll(
        includeKeys: [String]? = nil,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Element, ParseError>)], ParseError>) -> Void
    )

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[(Result<Element, ParseError>)], ParseError>).

  • Deletes a collection of objects synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAll(batchLimit limit: Int? = nil,
                   transaction: Bool = false,
                   options: API.Options = []) throws -> [(Result<Void, ParseError>)]

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns nil if the delete successful or a ParseError if it failed.

    1. A ParseError.Code.aggregateError. This object’s “errors” property is an array of other Parse.Error objects. Each error object in this array has an “object” property that references the object that could not be deleted (for instance, because that object could not be found).
    2. A non-aggregate Parse.Error. This indicates a serious error that caused the delete operation to be aborted partway through (for instance, a connection failure in the middle of the delete).
  • Deletes a collection of objects all at once asynchronously and executes the completion block when done.

    • A ParseError.Code.aggregateError. This object’s “errors” property is an array of other Parse.Error objects. Each error object in this array has an “object” property that references the object that could not be deleted (for instance, because that object could not be found).
    • A non-aggregate Parse.Error. This indicates a serious error that caused the delete operation to be aborted partway through (for instance, a connection failure in the middle of the delete).

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAll(
        batchLimit limit: Int? = nil,
        transaction: Bool = false,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Void, ParseError>)], ParseError>) -> Void
    )

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[ParseError?], ParseError>). Each element in the array is nil if the delete successful or a ParseError if it failed.

Available where Element: ParseUser

  • Fetches a collection of users aynchronously with the current data from the server and sets an error if one occurs. Publishes when complete.

    Important

    If an object fetched has the same objectId as current, it will automatically update the current.

    Declaration

    Swift

    func fetchAllPublisher(includeKeys: [String]? = nil,
                           options: API.Options = []) -> Future<[(Result<Self.Element, ParseError>)], ParseError>

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Saves a collection of users asynchronously and publishes when complete.

    Important

    If an object saved has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAllPublisher(batchLimit limit: Int? = nil,
                          transaction: Bool = false,
                          options: API.Options = []) -> Future<[(Result<Self.Element, ParseError>)], ParseError>

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Deletes a collection of users asynchronously and publishes when complete.

    Important

    If an object deleted has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAllPublisher(batchLimit limit: Int? = nil,
                            transaction: Bool = false,
                            options: API.Options = []) -> Future<[(Result<Void, ParseError>)], ParseError>

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    A publisher that eventually produces a single value and then finishes or fails.

  • Saves a collection of users synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Important

    If an object saved has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAll(batchLimit limit: Int? = nil, // swiftlint:disable:this function_body_length
                 transaction: Bool = false,
                 options: API.Options = []) throws -> [(Result<Self.Element, ParseError>)]

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns a Result enum with the object if a save was successful or a ParseError if it failed.

  • Saves a collection of users all at once asynchronously and executes the completion block when done.

    Important

    If an object saved has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func saveAll( // swiftlint:disable:this function_body_length cyclomatic_complexity
        batchLimit limit: Int? = nil,
        transaction: Bool = false,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Element, ParseError>)], ParseError>) -> Void
    )

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[(Result<Element, ParseError>)], ParseError>).

  • Fetches a collection of users synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Important

    If an object fetched has the same objectId as current, it will automatically update the current.

    Warning

    The order in which users are returned are not guarenteed. You shouldn’t expect results in any particular order.

    Declaration

    Swift

    func fetchAll(includeKeys: [String]? = nil,
                  options: API.Options = []) throws -> [(Result<Self.Element, ParseError>)]

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns a Result enum with the object if a fetch was successful or a ParseError if it failed.

  • Fetches a collection of users all at once asynchronously and executes the completion block when done.

    Important

    If an object fetched has the same objectId as current, it will automatically update the current.

    Warning

    The order in which users are returned are not guarenteed. You shouldn’t expect results in any particular order.

    Declaration

    Swift

    func fetchAll(
        includeKeys: [String]? = nil,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Element, ParseError>)], ParseError>) -> Void
    )

    Parameters

    includeKeys

    The name(s) of the key(s) to include that are ParseObjects. Use ["*"] to include all keys. This is similar to include and includeAll for Query.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[(Result<Element, ParseError>)], ParseError>).

  • Deletes a collection of users synchronously all at once and throws an error if necessary.

    Throws

    ParseError

    Important

    If an object deleted has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAll(batchLimit limit: Int? = nil,
                   transaction: Bool = false,
                   options: API.Options = []) throws -> [(Result<Void, ParseError>)]

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    Return Value

    Returns nil if the delete successful or a ParseError if it failed.

    1. A ParseError.Code.aggregateError. This object’s “errors” property is an array of other Parse.Error objects. Each error object in this array has an “object” property that references the object that could not be deleted (for instance, because that object could not be found).
    2. A non-aggregate Parse.Error. This indicates a serious error that caused the delete operation to be aborted partway through (for instance, a connection failure in the middle of the delete).
  • Deletes a collection of users all at once asynchronously and executes the completion block when done.

    • A ParseError.Code.aggregateError. This object’s “errors” property is an array of other Parse.Error objects. Each error object in this array has an “object” property that references the object that could not be deleted (for instance, because that object could not be found).
    • A non-aggregate Parse.Error. This indicates a serious error that caused the delete operation to be aborted partway through (for instance, a connection failure in the middle of the delete).

    Important

    If an object deleted has the same objectId as current, it will automatically update the current.

    Warning

    If transaction = true, then batchLimit will be automatically be set to the amount of the objects in the transaction. The developer should ensure their respective Parse Servers can handle the limit or else the transactions can fail.

    Declaration

    Swift

    func deleteAll(
        batchLimit limit: Int? = nil,
        transaction: Bool = false,
        options: API.Options = [],
        callbackQueue: DispatchQueue = .main,
        completion: @escaping (Result<[(Result<Void, ParseError>)], ParseError>) -> Void
    )

    Parameters

    batchLimit

    The maximum number of objects to send in each batch. If the items to be batched. is greater than the batchLimit, the objects will be sent to the server in waves up to the batchLimit. Defaults to 50.

    transaction

    Treat as an all-or-nothing operation. If some operation failure occurs that prevents the transaction from completing, then none of the objects are committed to the Parse Server database.

    options

    A set of header options sent to the server. Defaults to an empty set.

    callbackQueue

    The queue to return to after completion. Default value of .main.

    completion

    The block to execute. It should have the following argument signature: (Result<[ParseError?], ParseError>). Each element in the array is nil if the delete successful or a ParseError if it failed.