/*
 * Copyright 2002-2017 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.springframework.scheduling.commonj;

import commonj.timers.TimerListener;

import org.springframework.lang.Nullable;

JavaBean that describes a scheduled TimerListener, consisting of
the TimerListener itself (or a Runnable to create a TimerListener for)
and a delay plus period. Period needs to be specified;
there is no point in a default for it.
The CommonJ TimerManager does not offer more sophisticated scheduling
options such as cron expressions. Consider using Quartz for such
advanced needs.
Note that the TimerManager uses a TimerListener instance that is
shared between repeated executions, in contrast to Quartz which
instantiates a new Job for each execution.
Author:
Juergen Hoeller
Since:
2.0
Deprecated:
as of 5.1, in favor of EE 7's DefaultManagedTaskScheduler/**
 * JavaBean that describes a scheduled TimerListener, consisting of
 * the TimerListener itself (or a Runnable to create a TimerListener for)
 * and a delay plus period. Period needs to be specified;
 * there is no point in a default for it.
 *
 * <p>The CommonJ TimerManager does not offer more sophisticated scheduling
 * options such as cron expressions. Consider using Quartz for such
 * advanced needs.
 *
 * <p>Note that the TimerManager uses a TimerListener instance that is
 * shared between repeated executions, in contrast to Quartz which
 * instantiates a new Job for each execution.
 *
 * @author Juergen Hoeller
 * @since 2.0
 * @deprecated as of 5.1, in favor of EE 7's
 * {@link org.springframework.scheduling.concurrent.DefaultManagedTaskScheduler}
 */
@Deprecated
public class ScheduledTimerListener {

	@Nullable
	private TimerListener timerListener;

	private long delay = 0;

	private long period = -1;

	private boolean fixedRate = false;


	
Create a new ScheduledTimerListener,
to be populated via bean properties.
See Also:
setTimerListener
setDelay
setPeriod
setFixedRate/**
	 * Create a new ScheduledTimerListener,
	 * to be populated via bean properties.
	 * @see #setTimerListener
	 * @see #setDelay
	 * @see #setPeriod
	 * @see #setFixedRate
	 */
	public ScheduledTimerListener() {
	}

	
Create a new ScheduledTimerListener, with default
one-time execution without delay.
Params:
timerListener – the TimerListener to schedule/**
	 * Create a new ScheduledTimerListener, with default
	 * one-time execution without delay.
	 * @param timerListener the TimerListener to schedule
	 */
	public ScheduledTimerListener(TimerListener timerListener) {
		this.timerListener = timerListener;
	}

	
Create a new ScheduledTimerListener, with default
one-time execution with the given delay.
Params:
timerListener – the TimerListener to schedule
delay – the delay before starting the task for the first time (ms)/**
	 * Create a new ScheduledTimerListener, with default
	 * one-time execution with the given delay.
	 * @param timerListener the TimerListener to schedule
	 * @param delay the delay before starting the task for the first time (ms)
	 */
	public ScheduledTimerListener(TimerListener timerListener, long delay) {
		this.timerListener = timerListener;
		this.delay = delay;
	}

	
Create a new ScheduledTimerListener.
Params:
timerListener – the TimerListener to schedule
delay – the delay before starting the task for the first time (ms)
period – the period between repeated task executions (ms)
fixedRate – whether to schedule as fixed-rate execution/**
	 * Create a new ScheduledTimerListener.
	 * @param timerListener the TimerListener to schedule
	 * @param delay the delay before starting the task for the first time (ms)
	 * @param period the period between repeated task executions (ms)
	 * @param fixedRate whether to schedule as fixed-rate execution
	 */
	public ScheduledTimerListener(TimerListener timerListener, long delay, long period, boolean fixedRate) {
		this.timerListener = timerListener;
		this.delay = delay;
		this.period = period;
		this.fixedRate = fixedRate;
	}

	
Create a new ScheduledTimerListener, with default
one-time execution without delay.
Params:
timerTask – the Runnable to schedule as TimerListener/**
	 * Create a new ScheduledTimerListener, with default
	 * one-time execution without delay.
	 * @param timerTask the Runnable to schedule as TimerListener
	 */
	public ScheduledTimerListener(Runnable timerTask) {
		setRunnable(timerTask);
	}

	
Create a new ScheduledTimerListener, with default
one-time execution with the given delay.
Params:
timerTask – the Runnable to schedule as TimerListener
delay – the delay before starting the task for the first time (ms)/**
	 * Create a new ScheduledTimerListener, with default
	 * one-time execution with the given delay.
	 * @param timerTask the Runnable to schedule as TimerListener
	 * @param delay the delay before starting the task for the first time (ms)
	 */
	public ScheduledTimerListener(Runnable timerTask, long delay) {
		setRunnable(timerTask);
		this.delay = delay;
	}

	
Create a new ScheduledTimerListener.
Params:
timerTask – the Runnable to schedule as TimerListener
delay – the delay before starting the task for the first time (ms)
period – the period between repeated task executions (ms)
fixedRate – whether to schedule as fixed-rate execution/**
	 * Create a new ScheduledTimerListener.
	 * @param timerTask the Runnable to schedule as TimerListener
	 * @param delay the delay before starting the task for the first time (ms)
	 * @param period the period between repeated task executions (ms)
	 * @param fixedRate whether to schedule as fixed-rate execution
	 */
	public ScheduledTimerListener(Runnable timerTask, long delay, long period, boolean fixedRate) {
		setRunnable(timerTask);
		this.delay = delay;
		this.period = period;
		this.fixedRate = fixedRate;
	}


	
Set the Runnable to schedule as TimerListener.
See Also:
DelegatingTimerListener/**
	 * Set the Runnable to schedule as TimerListener.
	 * @see DelegatingTimerListener
	 */
	public void setRunnable(Runnable timerTask) {
		this.timerListener = new DelegatingTimerListener(timerTask);
	}

	
Set the TimerListener to schedule.
/**
	 * Set the TimerListener to schedule.
	 */
	public void setTimerListener(@Nullable TimerListener timerListener) {
		this.timerListener = timerListener;
	}

	
Return the TimerListener to schedule.
/**
	 * Return the TimerListener to schedule.
	 */
	@Nullable
	public TimerListener getTimerListener() {
		return this.timerListener;
	}

	
Set the delay before starting the task for the first time,
in milliseconds. Default is 0, immediately starting the
task after successful scheduling.
If the "firstTime" property is specified, this property will be ignored.
Specify one or the other, not both.
/**
	 * Set the delay before starting the task for the first time,
	 * in milliseconds. Default is 0, immediately starting the
	 * task after successful scheduling.
	 * <p>If the "firstTime" property is specified, this property will be ignored.
	 * Specify one or the other, not both.
	 */
	public void setDelay(long delay) {
		this.delay = delay;
	}

	
Return the delay before starting the job for the first time.
/**
	 * Return the delay before starting the job for the first time.
	 */
	public long getDelay() {
		return this.delay;
	}

	
Set the period between repeated task executions, in milliseconds.
Default is -1, leading to one-time execution. In case of zero or a
positive value, the task will be executed repeatedly, with the given
interval in-between executions.
Note that the semantics of the period value vary between fixed-rate
and fixed-delay execution.
Note: A period of 0 (for example as fixed delay) is supported, because the CommonJ specification defines this as a legal value. Hence a value of 0 will result in immediate re-execution after a job has finished (not in one-time execution like with java.util.Timer). 
See Also:
setFixedRate
isOneTimeTask()
TimerManager.schedule(TimerListener, long, long)/**
	 * Set the period between repeated task executions, in milliseconds.
	 * <p>Default is -1, leading to one-time execution. In case of zero or a
	 * positive value, the task will be executed repeatedly, with the given
	 * interval in-between executions.
	 * <p>Note that the semantics of the period value vary between fixed-rate
	 * and fixed-delay execution.
	 * <p><b>Note:</b> A period of 0 (for example as fixed delay) <i>is</i>
	 * supported, because the CommonJ specification defines this as a legal value.
	 * Hence a value of 0 will result in immediate re-execution after a job has
	 * finished (not in one-time execution like with {@code java.util.Timer}).
	 * @see #setFixedRate
	 * @see #isOneTimeTask()
	 * @see commonj.timers.TimerManager#schedule(commonj.timers.TimerListener, long, long)
	 */
	public void setPeriod(long period) {
		this.period = period;
	}

	
Return the period between repeated task executions.
/**
	 * Return the period between repeated task executions.
	 */
	public long getPeriod() {
		return this.period;
	}

	
Is this task only ever going to execute once?
See Also:
getPeriod()
Returns:
true if this task is only ever going to execute once/**
	 * Is this task only ever going to execute once?
	 * @return {@code true} if this task is only ever going to execute once
	 * @see #getPeriod()
	 */
	public boolean isOneTimeTask() {
		return (this.period < 0);
	}

	
Set whether to schedule as fixed-rate execution, rather than
fixed-delay execution. Default is "false", i.e. fixed delay.
See TimerManager javadoc for details on those execution modes.
See Also:
schedule.schedule(TimerListener, long, long)
TimerManager.scheduleAtFixedRate(TimerListener, long, long)/**
	 * Set whether to schedule as fixed-rate execution, rather than
	 * fixed-delay execution. Default is "false", i.e. fixed delay.
	 * <p>See TimerManager javadoc for details on those execution modes.
	 * @see commonj.timers.TimerManager#schedule(commonj.timers.TimerListener, long, long)
	 * @see commonj.timers.TimerManager#scheduleAtFixedRate(commonj.timers.TimerListener, long, long)
	 */
	public void setFixedRate(boolean fixedRate) {
		this.fixedRate = fixedRate;
	}

	
Return whether to schedule as fixed-rate execution.
/**
	 * Return whether to schedule as fixed-rate execution.
	 */
	public boolean isFixedRate() {
		return this.fixedRate;
	}

}