Class

Timer.TimerPublisher

A publisher that repeatedly emits the current date on a given interval. 繰り返し現在の日付をこの与えられた間隔で発布するあるパブリッシャー。

Declaration 宣言 

final class TimerPublisher

Topics 話題

Type Aliases 型エイリアス

typealias Timer.TimerPublisher.Failure
The kind of errors this publisher might publish. このパブリッシャーが出版するかもしれないエラーの種類。
typealias Timer.TimerPublisher.Output
The kind of values published by this publisher. このパブリッシャーによって出版される値の種類。

Initializers イニシャライザ

init(interval: TimeInterval, tolerance: TimeInterval?, runLoop: RunLoop, mode: RunLoop.Mode, options: RunLoop.SchedulerOptions?)
Creates a publisher that repeatedly emits the current date on the given interval. 繰り返し現在の日付をこの与えられた間隔で発布するあるパブリッシャーを作成します。

Instance Properties インスタンスプロパティ

let interval: TimeInterval
let mode: RunLoop.Mode
let options: RunLoop.SchedulerOptions?
let runLoop: RunLoop
let tolerance: TimeInterval?
var values: AsyncThrowingPublisher<Timer.TimerPublisher>
var values: AsyncPublisher<Timer.TimerPublisher>

Instance Methods インスタンス メソッド

func allSatisfy((Date) -> Bool) -> Publishers.AllSatisfy<Timer.TimerPublisher>
func append(Date...) -> Publishers.Concatenate<Timer.TimerPublisher, Publishers.Sequence<[Date], Never>>
func assertNoFailure(String, file: StaticString, line: UInt) -> Publishers.AssertNoFailure<Timer.TimerPublisher>
func assign(to: inout Published<Date>.Publisher)
func assign<Root>(to: ReferenceWritableKeyPath<Root, Date>, on: Root) -> AnyCancellable
func autoconnect() -> Publishers.Autoconnect<Timer.TimerPublisher>
func breakpoint(receiveSubscription: ((Subscription) -> Bool)?, receiveOutput: ((Date) -> Bool)?, receiveCompletion: ((Subscribers.Completion<Never>) -> Bool)?) -> Publishers.Breakpoint<Timer.TimerPublisher>
func breakpointOnError() -> Publishers.Breakpoint<Timer.TimerPublisher>
func buffer(size: Int, prefetch: Publishers.PrefetchStrategy, whenFull: Publishers.BufferingStrategy<Never>) -> Publishers.Buffer<Timer.TimerPublisher>
func `catch`<P>((Never) -> P) -> Publishers.Catch<Timer.TimerPublisher, P>
func collect() -> Publishers.Collect<Timer.TimerPublisher>
func collect(Int) -> Publishers.CollectByCount<Timer.TimerPublisher>
func collect<S>(Publishers.TimeGroupingStrategy<S>, options: S.SchedulerOptions?) -> Publishers.CollectByTime<Timer.TimerPublisher, S>
func combineLatest<P>(P) -> Publishers.CombineLatest<Timer.TimerPublisher, P>
func combineLatest<P, Q>(P, Q) -> Publishers.CombineLatest3<Timer.TimerPublisher, P, Q>
func combineLatest<P, T>(P, (Date, P.Output) -> T) -> Publishers.Map<Publishers.CombineLatest<Timer.TimerPublisher, P>, T>
func combineLatest<P, Q, R>(P, Q, R) -> Publishers.CombineLatest4<Timer.TimerPublisher, P, Q, R>
func combineLatest<P, Q, T>(P, Q, (Date, P.Output, Q.Output) -> T) -> Publishers.Map<Publishers.CombineLatest3<Timer.TimerPublisher, P, Q>, T>
func combineLatest<P, Q, R, T>(P, Q, R, (Date, P.Output, Q.Output, R.Output) -> T) -> Publishers.Map<Publishers.CombineLatest4<Timer.TimerPublisher, P, Q, R>, T>
func compactMap<T>((Date) -> T?) -> Publishers.CompactMap<Timer.TimerPublisher, T>
func connect() -> Cancellable
func contains(Date) -> Publishers.Contains<Timer.TimerPublisher>
func contains(where: (Date) -> Bool) -> Publishers.ContainsWhere<Timer.TimerPublisher>
func count() -> Publishers.Count<Timer.TimerPublisher>
func debounce<S>(for: S.SchedulerTimeType.Stride, scheduler: S, options: S.SchedulerOptions?) -> Publishers.Debounce<Timer.TimerPublisher, S>
func decode<Item, Coder>(type: Item.Type, decoder: Coder) -> Publishers.Decode<Timer.TimerPublisher, Item, Coder>
func delay<S>(for: S.SchedulerTimeType.Stride, tolerance: S.SchedulerTimeType.Stride?, scheduler: S, options: S.SchedulerOptions?) -> Publishers.Delay<Timer.TimerPublisher, S>
func drop<P>(untilOutputFrom: P) -> Publishers.DropUntilOutput<Timer.TimerPublisher, P>
func drop(while: (Date) -> Bool) -> Publishers.DropWhile<Timer.TimerPublisher>
func dropFirst(Int) -> Publishers.Drop<Timer.TimerPublisher>
func encode<Coder>(encoder: Coder) -> Publishers.Encode<Timer.TimerPublisher, Coder>
func eraseToAnyPublisher() -> AnyPublisher<Date, Never>
func filter((Date) -> Bool) -> Publishers.Filter<Timer.TimerPublisher>
func first() -> Publishers.First<Timer.TimerPublisher>
func first(where: (Date) -> Bool) -> Publishers.FirstWhere<Timer.TimerPublisher>
func flatMap<T, P>(maxPublishers: Subscribers.Demand, (Date) -> P) -> Publishers.FlatMap<P, Timer.TimerPublisher>
func flatMap<P>(maxPublishers: Subscribers.Demand, (Date) -> P) -> Publishers.FlatMap<Publishers.SetFailureType<P, Never>, Timer.TimerPublisher>
func flatMap<P>(maxPublishers: Subscribers.Demand, (Date) -> P) -> Publishers.FlatMap<P, Publishers.SetFailureType<Timer.TimerPublisher, P.Failure>>
func flatMap<P>(maxPublishers: Subscribers.Demand, (Date) -> P) -> Publishers.FlatMap<P, Timer.TimerPublisher>
func handleEvents(receiveSubscription: ((Subscription) -> Void)?, receiveOutput: ((Date) -> Void)?, receiveCompletion: ((Subscribers.Completion<Never>) -> Void)?, receiveCancel: (() -> Void)?, receiveRequest: ((Subscribers.Demand) -> Void)?) -> Publishers.HandleEvents<Timer.TimerPublisher>
func ignoreOutput() -> Publishers.IgnoreOutput<Timer.TimerPublisher>
func last() -> Publishers.Last<Timer.TimerPublisher>
func last(where: (Date) -> Bool) -> Publishers.LastWhere<Timer.TimerPublisher>
func makeConnectable() -> Publishers.MakeConnectable<Timer.TimerPublisher>
func map<T>((Date) -> T) -> Publishers.Map<Timer.TimerPublisher, T>
func map<T>(KeyPath<Date, T>) -> Publishers.MapKeyPath<Timer.TimerPublisher, T>
func map<T0, T1>(KeyPath<Date, T0>, KeyPath<Date, T1>) -> Publishers.MapKeyPath2<Timer.TimerPublisher, T0, T1>
func map<T0, T1, T2>(KeyPath<Date, T0>, KeyPath<Date, T1>, KeyPath<Date, T2>) -> Publishers.MapKeyPath3<Timer.TimerPublisher, T0, T1, T2>
func mapError<E>((Never) -> E) -> Publishers.MapError<Timer.TimerPublisher, E>
func max() -> Publishers.Comparison<Timer.TimerPublisher>
func max(by: (Date, Date) -> Bool) -> Publishers.Comparison<Timer.TimerPublisher>
func measureInterval<S>(using: S, options: S.SchedulerOptions?) -> Publishers.MeasureInterval<Timer.TimerPublisher, S>
func merge(with: Timer.TimerPublisher) -> Publishers.MergeMany<Timer.TimerPublisher>
func merge<B, C>(with: B, C) -> Publishers.Merge3<Timer.TimerPublisher, B, C>
func merge<B, C, D>(with: B, C, D) -> Publishers.Merge4<Timer.TimerPublisher, B, C, D>
func merge<B, C, D, E>(with: B, C, D, E) -> Publishers.Merge5<Timer.TimerPublisher, B, C, D, E>
func merge<B, C, D, E, F>(with: B, C, D, E, F) -> Publishers.Merge6<Timer.TimerPublisher, B, C, D, E, F>
func merge<B, C, D, E, F, G>(with: B, C, D, E, F, G) -> Publishers.Merge7<Timer.TimerPublisher, B, C, D, E, F, G>
func merge<B, C, D, E, F, G, H>(with: B, C, D, E, F, G, H) -> Publishers.Merge8<Timer.TimerPublisher, B, C, D, E, F, G, H>
func min() -> Publishers.Comparison<Timer.TimerPublisher>
func min(by: (Date, Date) -> Bool) -> Publishers.Comparison<Timer.TimerPublisher>
func multicast<S>(() -> S) -> Publishers.Multicast<Timer.TimerPublisher, S>
func multicast<S>(subject: S) -> Publishers.Multicast<Timer.TimerPublisher, S>
func output(at: Int) -> Publishers.Output<Timer.TimerPublisher>
func output<R>(in: R) -> Publishers.Output<Timer.TimerPublisher>
func prefix(Int) -> Publishers.Output<Timer.TimerPublisher>
func prefix<P>(untilOutputFrom: P) -> Publishers.PrefixUntilOutput<Timer.TimerPublisher, P>
func prefix(while: (Date) -> Bool) -> Publishers.PrefixWhile<Timer.TimerPublisher>
func prepend(Date...) -> Publishers.Concatenate<Publishers.Sequence<[Date], Never>, Timer.TimerPublisher>
func print(String, to: TextOutputStream?) -> Publishers.Print<Timer.TimerPublisher>
func receive<S>(on: S, options: S.SchedulerOptions?) -> Publishers.ReceiveOn<Timer.TimerPublisher, S>
func receive<S>(subscriber: S)
func reduce<T>(T, (T, Date) -> T) -> Publishers.Reduce<Timer.TimerPublisher, T>
func removeDuplicates() -> Publishers.RemoveDuplicates<Timer.TimerPublisher>
func removeDuplicates(by: (Date, Date) -> Bool) -> Publishers.RemoveDuplicates<Timer.TimerPublisher>
func replaceEmpty(with: Date) -> Publishers.ReplaceEmpty<Timer.TimerPublisher>
func replaceError(with: Date) -> Publishers.ReplaceError<Timer.TimerPublisher>
func replaceNil<T>(with: T) -> Publishers.Map<Timer.TimerPublisher, T>
func retry(Int) -> Publishers.Retry<Timer.TimerPublisher>
func scan<T>(T, (T, Date) -> T) -> Publishers.Scan<Timer.TimerPublisher, T>
func setFailureType<E>(to: E.Type) -> Publishers.SetFailureType<Timer.TimerPublisher, E>
func share() -> Publishers.Share<Timer.TimerPublisher>
func sink(receiveCompletion: ((Subscribers.Completion<Never>) -> Void), receiveValue: ((Date) -> Void)) -> AnyCancellable
func sink(receiveValue: ((Date) -> Void)) -> AnyCancellable
func subscribe<S>(S) -> AnyCancellable
func subscribe<S>(S)
func subscribe<S>(on: S, options: S.SchedulerOptions?) -> Publishers.SubscribeOn<Timer.TimerPublisher, S>
func throttle<S>(for: S.SchedulerTimeType.Stride, scheduler: S, latest: Bool) -> Publishers.Throttle<Timer.TimerPublisher, S>
func timeout<S>(S.SchedulerTimeType.Stride, scheduler: S, options: S.SchedulerOptions?, customError: (() -> Never)?) -> Publishers.Timeout<Timer.TimerPublisher, S>
func tryAllSatisfy((Date) -> Bool) -> Publishers.TryAllSatisfy<Timer.TimerPublisher>
func tryCatch<P>((Never) -> P) -> Publishers.TryCatch<Timer.TimerPublisher, P>
func tryCompactMap<T>((Date) -> T?) -> Publishers.TryCompactMap<Timer.TimerPublisher, T>
func tryContains(where: (Date) -> Bool) -> Publishers.TryContainsWhere<Timer.TimerPublisher>
func tryDrop(while: (Date) -> Bool) -> Publishers.TryDropWhile<Timer.TimerPublisher>
func tryFilter((Date) -> Bool) -> Publishers.TryFilter<Timer.TimerPublisher>
func tryFirst(where: (Date) -> Bool) -> Publishers.TryFirstWhere<Timer.TimerPublisher>
func tryLast(where: (Date) -> Bool) -> Publishers.TryLastWhere<Timer.TimerPublisher>
func tryMap<T>((Date) -> T) -> Publishers.TryMap<Timer.TimerPublisher, T>
func tryMax(by: (Date, Date) -> Bool) -> Publishers.TryComparison<Timer.TimerPublisher>
func tryMin(by: (Date, Date) -> Bool) -> Publishers.TryComparison<Timer.TimerPublisher>
func tryPrefix(while: (Date) -> Bool) -> Publishers.TryPrefixWhile<Timer.TimerPublisher>
func tryReduce<T>(T, (T, Date) -> T) -> Publishers.TryReduce<Timer.TimerPublisher, T>
func tryRemoveDuplicates(by: (Date, Date) -> Bool) -> Publishers.TryRemoveDuplicates<Timer.TimerPublisher>
func tryScan<T>(T, (T, Date) -> T) -> Publishers.TryScan<Timer.TimerPublisher, T>
func zip<P>(P) -> Publishers.Zip<Timer.TimerPublisher, P>
func zip<P, Q>(P, Q) -> Publishers.Zip3<Timer.TimerPublisher, P, Q>
func zip<P, T>(P, (Date, P.Output) -> T) -> Publishers.Map<Publishers.Zip<Timer.TimerPublisher, P>, T>
func zip<P, Q, R>(P, Q, R) -> Publishers.Zip4<Timer.TimerPublisher, P, Q, R>
func zip<P, Q, T>(P, Q, (Date, P.Output, Q.Output) -> T) -> Publishers.Map<Publishers.Zip3<Timer.TimerPublisher, P, Q>, T>
func zip<P, Q, R, T>(P, Q, R, (Date, P.Output, Q.Output, R.Output) -> T) -> Publishers.Map<Publishers.Zip4<Timer.TimerPublisher, P, Q, R>, T>

Relationships 関係

Conforms To 次に準拠

See Also 参照

Firing Messages as a Combine Publisher メッセージそれらをあるCombineパブリッシャーとして発火する

static func publish(every: TimeInterval, tolerance: TimeInterval?, on: RunLoop, in: RunLoop.Mode, options: RunLoop.SchedulerOptions?) -> Timer.TimerPublisher
Returns a publisher that repeatedly emits the current date on the given interval. 繰り返し現在の日付をこの与えられた間隔で発布するあるパブリッシャーを返します。