address/de.fenste.ms.address.domain.model/Address/EntityClass

EntityClass

object EntityClass : UUIDEntityClass<Address>

Functions

open fun all(): SizedIterable<Address>

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<REF?>): ReadOnlyProperty<Entity<UUID>, Target>

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.backReferencedOn(column: Column<REF>): ReadOnlyProperty<Entity<UUID>, Target>

count

fun count(op: Op<Boolean>?): Long

find

fun find(op: SqlExpressionBuilder.() -> Op<Boolean>): SizedIterable<Address>

fun find(op: Op<Boolean>): SizedIterable<Address>

findById

fun findById(id: UUID): Address?

open fun findById(id: EntityID<UUID>): Address?

findWithCacheCondition

fun findWithCacheCondition(cacheCheckCondition: Address.() -> Boolean, op: SqlExpressionBuilder.() -> Op<Boolean>): Sequence<Address>

forEntityIds

open fun forEntityIds(ids: List<EntityID<UUID>>): SizedIterable<Address>

forIds

fun forIds(ids: List<UUID>): SizedIterable<Address>

get

operator fun get(id: UUID): Address

operator fun get(id: EntityID<UUID>): Address

isAssignableTo

fun <ID : Comparable<ID>, T : Entity<ID>> isAssignableTo(entityClass: EntityClass<ID, T>): Boolean

memoizedTransform

fun <TColumn, TReal> Column<TColumn>.memoizedTransform(toColumn: (TReal) -> TColumn, toReal: (TColumn) -> TReal): ColumnWithTransform<TColumn, TReal>

new

open fun new(init: Address.() -> Unit): Address

open fun new(id: UUID?, init: Address.() -> Unit): Address

optionalBackReferencedOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<REF?>): OptionalBackReference<TargetID, Target, UUID, Entity<UUID>, REF>

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<REF>): OptionalBackReference<TargetID, Target, UUID, Entity<UUID>, REF>

optionalReferencedOn

infix fun <REF : Comparable<REF>> optionalReferencedOn(column: Column<REF?>): OptionalReference<REF, UUID, Address>

optionalReferrersOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalReferrersOn(column: Column<REF?>): OptionalReferrers<UUID, Entity<UUID>, TargetID, Target, REF>

fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalReferrersOn(column: Column<REF?>, cache: Boolean): OptionalReferrers<UUID, Entity<UUID>, TargetID, Target, REF>

referencedOn

infix fun <REF : Comparable<REF>> referencedOn(column: Column<REF>): Reference<REF, UUID, Address>

referrersOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.referrersOn(column: Column<REF>): Referrers<UUID, Entity<UUID>, TargetID, Target, REF>

fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.referrersOn(column: Column<REF>, cache: Boolean): Referrers<UUID, Entity<UUID>, TargetID, Target, REF>

reload

fun reload(entity: Entity<UUID>, flush: Boolean): Address?

removeFromCache

fun removeFromCache(entity: Entity<UUID>)

searchQuery

open fun searchQuery(op: Op<Boolean>): Query

testCache

fun testCache(cacheCheckCondition: Address.() -> Boolean): Sequence<Address>

fun testCache(id: EntityID<UUID>): Address?

transform

fun <TColumn, TReal> Column<TColumn>.transform(toColumn: (TReal) -> TColumn, toReal: (TColumn) -> TReal): ColumnWithTransform<TColumn, TReal>

view

inline fun view(op: SqlExpressionBuilder.() -> Op<Boolean>): View<Address>

warmUpLinkedReferences

fun <SID : Comparable<SID>> warmUpLinkedReferences(references: List<EntityID<SID>>, linkTable: Table, forUpdate: Boolean?, optimizedLoad: Boolean): List<Address>

warmUpOptReferences

fun <SID> warmUpOptReferences(references: List<SID>, refColumn: Column<SID?>, forUpdate: Boolean?): List<Address>

warmUpReferences

fun <SID> warmUpReferences(references: List<SID>, refColumn: Column<SID>, forUpdate: Boolean?): List<Address>

wrap

fun wrap(id: EntityID<UUID>, row: ResultRow?): Address

wrapRow

fun wrapRow(row: ResultRow): Address

fun wrapRow(row: ResultRow, alias: Alias<IdTable<*>>): Address

fun wrapRow(row: ResultRow, alias: QueryAlias): Address

wrapRows

fun wrapRows(rows: SizedIterable<ResultRow>): SizedIterable<Address>

fun wrapRows(rows: SizedIterable<ResultRow>, alias: Alias<IdTable<*>>): SizedIterable<Address>

fun wrapRows(rows: SizedIterable<ResultRow>, alias: QueryAlias): SizedIterable<Address>

Properties

dependsOnColumns

open val dependsOnColumns: List<Column<out Any?>>

dependsOnTables

open val dependsOnTables: ColumnSet

table

val table: IdTable<UUID>

Extensions

backReferencedOn

optionalBackReferencedOn

infix fun <TargetID : Comparable<TargetID>, Target : Entity<TargetID>, REF : Comparable<REF>> EntityClass<TargetID, Target>.optionalBackReferencedOn(column: Column<REF>): OptionalBackReference<TargetID, Target, UUID, Entity<UUID>, REF>

optionalReferrersOn

referrersOn