Protocolos

Um protocolo que define o suporte do iterador para RLMArray, RLMSet e RLMResults.

Veja mais

public protocol _RLMCollectionIterator : Sequence

Um protocolo que define o suporte ao iterador para RLMDictionary

public protocol _RLMDictionaryIterator

Um protocolo de tag que marca tipos que podem ser usados como valor da partição para Realms sincronizados.

public protocol PartitionValue : Sendable

Protocolo representando um valor BSON.

public protocol BSON : PartitionValue, Equatable

Um protocolo que define uma identidade padrão para Objeto de Realm

Declarar sua subclasse de objeto em conformidade com esse protocolo fornecerá uma implementação padrão para a Identifiable id , que funciona para Objeto de Realm:

// Automatically conforms to `Identifiable`
class MyObjectType: Object, ObjectKeyIdentifiable {
    // ...
}

Você também pode estar em conformidade com Identifiable manualmente se desejar, mas observe que o uso do endereço de memória do objeto não funciona para objeto managed.

Veja mais

@available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
public protocol ObjectKeyIdentifiable : Identifiable

Um tipo que pode ser passado para valuePublisher() ou changesetPublisher().

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
public protocol RealmSubscribable

Uma collection uniforme de Objects que pode ser recuperada, filtrada, classificada e operada.

Veja mais

public protocol RealmCollection : RealmCollectionBase, Equatable where Self.Iterator == RLMIterator<Self.Element>

Uma coleção uniforme de valores-chave de Objects que pode ser recuperada, filtrada, classificada e operada.

Veja mais

public protocol RealmKeyedCollection : ThreadConfined, CustomStringConvertible, Sequence

Um tipo que pode ser mapeado de e para um tipo suportado pelo Realm.

Para armazenar tipos em um Realm para o qual o Realm não oferece suporte nativo, declare o tipo como em conformidade com CustomPersistable ou FailableCustomPersistable. Isso requer a definição de um associatedtype chamado PersistedType , que indica para qual tipo de Realm esse tipo será mapeado, um inicializador que receba o PersistedType e uma propriedade que retorne o PersistedType apropriado. Por exemplo, para tornar o URL persistente:

// Not all strings are valid URLs, so this uses
// FailableCustomPersistable to handle the case when the data
// in the Realm isn't a valid URL.
extension URL: FailableCustomPersistable {
    typealias PersistedType = String
    init?(persistedValue: String) {
        self.init(string: persistedValue)
    }
    var persistableValue: PersistedType {
        self.absoluteString
    }
}

Depois de fazer isso, você pode definir propriedades usando a URL:

class MyModel: Object {
    @Persisted var url: URL
    @Persisted var mapOfUrls: Map<String, URL>
}

PersistedType pode ser qualquer um dos tipos primitivos suportados pelo Realm ou uma subclasse EmbeddedObject . Subclasses EmbeddedObject podem ser usadas se você precisar armazenar mais de uma parte dos dados para seu tipo mapeado. Por exemplo, para armazenar CGPoint:

// Define the storage object. A type used for custom mappings
// does not have to be used exclusively for custom mappings,
// and more than one type can map to a single embedded object
// type.
class CGPointObject: EmbeddedObject {
    @Persisted var double: x
    @Persisted var double: y
}

// Define the mapping. This mapping isn't failable, as the
// data stored in the Realm can always be interpreted as a
// CGPoint.
extension CGPoint: CustomPersistable {
    typealias PersistedType = CGPointObject
    init(persistedValue: CGPointObject) {
        self.init(x: persistedValue.x, y: persistedValue.y)
    }
    var persistableValue: PersistedType {
        CGPointObject(value: [x, y])
    }
}

class PointModel: Object {
    // Note that types which are mapped to embedded objects do
    // not have to be optional (but can be).
    @Persisted var point: CGPoint
    @Persisted var line: List<CGPoint>
}

A query é realizada no tipo persistente e não no tipo persistente personalizado. Os valores passados para query podem ser do tipo persistente ou do tipo persistente personalizado. Para tipos persistentes personalizados que são mapeados para objetos incorporados, a igualdade de todos os nós será usada. Por exemplo, realm.objects(PointModel.self).where { $0.point == CGPoint(x: 1, y: 2) } é equivalente a "point.x == 1 AND point.y == 2".

Veja mais

public protocol CustomPersistable : _CustomPersistable

Um tipo que pode ser mapeado de e para um tipo suportado pelo Realm.

Este protocolo é idêntico ao CustomPersistable, exceto com init?(persistedValue:) em vez de init(persistedValue:).

Os tipos FailableCustomPersistable são desencapsulados à força em contextos não opcionais e recolhidos para nil em contextos opcionais. Ou seja, se você tiver um valor que não possa ser convertido em uma URL, a leitura de uma propriedade @Persisted var url: URL lançará uma exceção com falha não envolvida, e a leitura de Persisted var url: URL? retornará nil.

Veja mais

public protocol FailableCustomPersistable : _CustomPersistable

Um tipo que tem uma representação personalizada em eventos do Realm.

Por padrão, os objetos são serializados para JSON usando regras integradas que incluem todas as propriedades. Se você deseja personalizar como uma classe é serializada em eventos, você pode declará-la como conforme com este protocolo e definir customEventRepresentation().

Veja mais

@objc(RLMCustomEventRepresentable)
public protocol CustomEventRepresentable

delegado que é usado para assinar alterações em um fluxo MongoCollection.watch() .

Veja mais

public protocol ChangeEventDelegate : AnyObject

Um tipo de enumeração que pode ser armazenado em um Objeto de Realm.

Somente enumerações @objc apoiados por um Int podem ser armazenados em um Objeto de Realm, e o tipo de enumeração deve estar explicitamente em conformidade com esse protocolo. Por exemplo:

@objc enum MyEnum: Int, RealmEnum {
   case first = 1
   case second = 2
   case third = 7
}

class MyModel: Object {
   @objc dynamic enumProperty = MyEnum.first
   let optionalEnumProperty = RealmOptional<MyEnum>()
}

public protocol RealmEnum : RealmOptionalType, _RealmSchemaDiscoverable

Um protocolo que descreve os tipos que podem parametrizar um RealmOptional.

public protocol RealmOptionalType : _ObjcBridgeable

Um tipo de enumeração que pode ser usado com @Persisted e collection Realm.

A persistência de uma enumeração no Realm exige que ela tenha um valor bruto e esse valor bruto por um tipo que o Realm pode armazenar. A enumeração também deve ser explicitamente marcada como em conformidade com esse protocolo, pois o Swift não nos permite fazer isso implicitamente.

enum IntEnum: Int, PersistableEnum {
   case first = 1
   case second = 2
   case third = 7
}
enum StringEnum: String, PersistableEnum {
   case first = "a"
   case second = "b"
   case third = "g"
}

Se o Realm contiver um valor que não for um membro válido da enumeração (como se tivesse sido gravado por um cliente de sincronização diferente que não concorda com quais valores são válidos), as propriedade opcionais da enumeração retornarão nil, e as propriedade não opcionais abortará o processo.

public protocol PersistableEnum : MinMaxType, RealmEnum, _PersistableInsideOptional, _RealmCollectionValueInsideOptional, CaseIterable, Comparable, RawRepresentable where Self.RawValue : Comparable

Um tipo que pode ser indexado.

Este protocolo é apenas uma marcação, e declarar tipos adicionais em conformidade com ele resultará simplesmente em erros de tempo de execução em vez de erros de tempo de compilação.

@_marker
public protocol _Indexable

Um tipo que pode se tornar a chave primária de um objeto.

Este protocolo é apenas uma marcação, e declarar tipos adicionais em conformidade com ele resultará simplesmente em erros de tempo de execução em vez de erros de tempo de compilação.

@_marker
public protocol _PrimaryKey

Um tipo de projeção apagada.

ProjectionObservable é um editor Combine

Veja mais

public protocol ProjectionObservable : AnyObject, ThreadConfined

Protocolo de tags para todos os tipos numéricos.

public protocol _QueryNumeric : _RealmSchemaDiscoverable

Protocolo de tags para todos os tipos compatíveis com String.

public protocol _QueryString : _QueryBinary

Protocolo de tags para todos os tipos compatíveis com Binary.

public protocol _QueryBinary

Objetos que podem ser obtidos no Realm - Objeto de Realm ou projeção

public protocol RealmFetchable : RealmCollectionValue

Um tipo que pode ser armazenado em uma Lista de Realm, MutableSet, Mapa ou Resultados.

Declarar tipos adicionais como em conformidade com este protocolo não os fará realmente funcionar. A maior parte da lógica de como armazenar valores no Realm não está implementada no Swift e, atualmente, não há mecanismo de extensão para oferecer suporte a mais tipos.

public protocol RealmCollectionValue : _HasPersistedType, Hashable where Self.PersistedType : RealmCollectionValue

Um protocolo que descreve os tipos que podem parametrizar um RealmPropertyType.

public protocol RealmPropertyType : _ObjcBridgeable, _RealmSchemaDiscoverable

Tipos de propriedade que podem ser usadas com as API de valor mínimo e máximo.

@_marker
public protocol MinMaxType

Tipos de propriedade que podem ser usadas com as API de soma e valor médio.

@_marker
public protocol AddableType

Tipos de propriedades que podem ser diretamente classificadas ou distintas.

@_marker
public protocol SortableType

Tipos que têm propriedades que podem ser classificadas ou distintas.

@_marker
public protocol KeypathSortable

RealmSectionedResult define propriedades e métodos que são comuns entre SectionedResults e ResultSection.

Veja mais

public protocol RealmSectionedResult : ThreadConfined, Equatable, RandomAccessCollection

Um tipo que pode ser usado com o wrapper de propriedade @ObservedResults. Classe secundária de Objeto de Realm ou projeção de Realm. Foi feito para especializar os métodos de inicialização do ObservedResults.

@available(iOS 13.0, macOS 10.15, tvOS 13.0, watchOS 6.0, *)
public protocol _ObservedResultsValue : RealmCollectionValue

objeto de tipos que estão em conformidade com ThreadConfined podem ser managed por um Realm, o que os tornará vinculados a uma instância Realm específica do thread. Os managed objeto devem ser explicitamente exportados e importados para serem passados entre threads.

Managed objeto em conformidade com este protocolo podem ser convertidas em uma referência segura de thread para transporte entre threads passando para o construtor ThreadSafeReference(to:) .

Observe que somente os tipos definidos pelo Realm podem estar em conformidade com este protocolo, e definir novas classes que tentam estar em conformidade com ele não as fará funcionar com ThreadSafeReference.

Veja mais

public protocol ThreadConfined