From 671e37ce25e26765331a9282e99e583204d08a54 Mon Sep 17 00:00:00 2001 From: "Krumlauf, Michael" Date: Mon, 7 Sep 2015 16:19:08 -0400 Subject: [PATCH] Rename EnsembleListeger to EnsembleListener --- .../ensemble/CompositeEnsembleListener.java | 22 +++--- .../ensemble/DistributedStateMachine.java | 2 +- .../ensemble/EnsembleListeger.java | 72 ------------------- .../ensemble/StateMachineEnsemble.java | 10 +-- .../StateMachineEnsembleObjectSupport.java | 4 +- .../ZookeeperStateMachineEnsembleTests.java | 4 +- 6 files changed, 21 insertions(+), 93 deletions(-) delete mode 100644 spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/EnsembleListeger.java diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/CompositeEnsembleListener.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/CompositeEnsembleListener.java index f185e11a..0a926100 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/CompositeEnsembleListener.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/CompositeEnsembleListener.java @@ -22,44 +22,44 @@ import org.springframework.statemachine.StateMachineContext; import org.springframework.statemachine.listener.AbstractCompositeListener; /** - * Default {@link EnsembleListeger} dispatcher. + * Default {@link EnsembleListener} dispatcher. * * @author Janne Valkealahti * * @param the type of state * @param the type of event */ -public class CompositeEnsembleListener extends AbstractCompositeListener> implements - EnsembleListeger { +public class CompositeEnsembleListener extends AbstractCompositeListener> implements + EnsembleListener { @Override public void stateMachineJoined(StateMachine stateMachine, StateMachineContext context) { - for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { - EnsembleListeger listener = iterator.next(); + for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { + EnsembleListener listener = iterator.next(); listener.stateMachineJoined(stateMachine, context); } } @Override public void stateMachineLeft(StateMachine stateMachine, StateMachineContext context) { - for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { - EnsembleListeger listener = iterator.next(); + for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { + EnsembleListener listener = iterator.next(); listener.stateMachineLeft(stateMachine, context); } } @Override public void stateChanged(StateMachineContext context) { - for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { - EnsembleListeger listener = iterator.next(); + for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { + EnsembleListener listener = iterator.next(); listener.stateChanged(context); } } @Override public void ensembleError(StateMachineEnsembleException exception) { - for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { - EnsembleListeger listener = iterator.next(); + for (Iterator> iterator = getListeners().reverse(); iterator.hasNext();) { + EnsembleListener listener = iterator.next(); listener.ensembleError(exception); } } diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/DistributedStateMachine.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/DistributedStateMachine.java index 5b75f4cf..95cd3223 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/DistributedStateMachine.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/DistributedStateMachine.java @@ -243,7 +243,7 @@ public class DistributedStateMachine extends LifecycleObjectSupport implem * Bridge for instructing delegating machine based on what * is happening in an ensemble. */ - private class LocalEnsembleListener implements EnsembleListeger { + private class LocalEnsembleListener implements EnsembleListener { @Override public void stateMachineJoined(final StateMachine stateMachine, final StateMachineContext context) { diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/EnsembleListeger.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/EnsembleListeger.java deleted file mode 100644 index 1b15063c..00000000 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/EnsembleListeger.java +++ /dev/null @@ -1,72 +0,0 @@ -/* - * Copyright 2015 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.statemachine.ensemble; - -import org.springframework.statemachine.StateMachine; -import org.springframework.statemachine.StateMachineContext; - -/** - * {@code EnsembleListeger} for various ensemble events. - * - * @author Janne Valkealahti - * - * @param the type of state - * @param the type of event - */ -public interface EnsembleListeger { - - /** - * Called when state machine joined an ensemble. This callback - * is guaranteed to be called for a {@link StateMachine} who - * requested a join. User of this listener should check that a - * {@link StateMachine} is the one interested of. Implementation - * may choose to notify other {@link StateMachine} joins if it is - * able to do so. This may be called multiple time in case ensemble - * has made a choice to leave machine due to ensemble errors. - * - * @param stateMachine the state machine - * @param context the state machine context - */ - void stateMachineJoined(StateMachine stateMachine, StateMachineContext context); - - /** - * Called when state machine left an ensemble. This callback - * is guaranteed to be called for a {@link StateMachine} who - * requested a leave. User of this listener should check that a - * {@link StateMachine} is the one interested of. Implementation - * may choose to notify other {@link StateMachine} leaves if it is - * able to do so. - * - * @param stateMachine the state machine - * @param context the state machine context - */ - void stateMachineLeft(StateMachine stateMachine, StateMachineContext context); - - /** - * Called when ensemble is discovering a state change. - * - * @param context the state machine context - */ - void stateChanged(StateMachineContext context); - - /** - * Called when {@link StateMachineEnsemble} resulted an error. - * - * @param exception the exception - */ - void ensembleError(StateMachineEnsembleException exception); - -} diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsemble.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsemble.java index f8daa71c..0bfb23ac 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsemble.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsemble.java @@ -33,8 +33,8 @@ public interface StateMachineEnsemble { * Request a join to a state machine ensemble. This method * is a request to join an ensemble and doesn't guarantee * a requester will eventually successfully join. Join operation - * needs to be used together with {@link EnsembleListeger} and - * {@link EnsembleListeger#stateMachineJoined(StateMachine, StateMachineContext)} + * needs to be used together with {@link EnsembleListener} and + * {@link EnsembleListener#stateMachineJoined(StateMachine, StateMachineContext)} * is called with a {@link StateMachine} instance for successful join. * * @param stateMachine the state machine @@ -45,7 +45,7 @@ public interface StateMachineEnsemble { * Request a leave from an ensemble. This method is a request to * leave an ensemble. After this method is called no further processing * is done for a instance of {@link StateMachine}. Additionally - * {@link EnsembleListeger#stateMachineLeft(StateMachine, StateMachineContext)} + * {@link EnsembleListener#stateMachineLeft(StateMachine, StateMachineContext)} * is called when leave request is fully processed. * * @param stateMachine the state machine @@ -57,14 +57,14 @@ public interface StateMachineEnsemble { * * @param listener the listener */ - void addEnsembleListener(EnsembleListeger listener); + void addEnsembleListener(EnsembleListener listener); /** * Removes the ensemble listener. * * @param listener the listener */ - void removeEnsembleListener(EnsembleListeger listener); + void removeEnsembleListener(EnsembleListener listener); /** * Sets the state as a {@link StateMachineContext}. diff --git a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsembleObjectSupport.java b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsembleObjectSupport.java index 8554408c..9e95d804 100644 --- a/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsembleObjectSupport.java +++ b/spring-statemachine-core/src/main/java/org/springframework/statemachine/ensemble/StateMachineEnsembleObjectSupport.java @@ -42,12 +42,12 @@ public abstract class StateMachineEnsembleObjectSupport extends LifecycleO public abstract void leave(StateMachine stateMachine); @Override - public void addEnsembleListener(EnsembleListeger listener) { + public void addEnsembleListener(EnsembleListener listener) { ensembleListener.register(listener); } @Override - public void removeEnsembleListener(EnsembleListeger listener) { + public void removeEnsembleListener(EnsembleListener listener) { ensembleListener.unregister(listener); } diff --git a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java index a167adca..095d5bc0 100644 --- a/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java +++ b/spring-statemachine-zookeeper/src/test/java/org/springframework/statemachine/zookeeper/ZookeeperStateMachineEnsembleTests.java @@ -39,7 +39,7 @@ import org.springframework.statemachine.StateMachine; import org.springframework.statemachine.StateMachineContext; import org.springframework.statemachine.StateMachineException; import org.springframework.statemachine.access.StateMachineAccessor; -import org.springframework.statemachine.ensemble.EnsembleListeger; +import org.springframework.statemachine.ensemble.EnsembleListener; import org.springframework.statemachine.ensemble.StateMachineEnsembleException; import org.springframework.statemachine.listener.StateMachineListener; import org.springframework.statemachine.state.State; @@ -641,7 +641,7 @@ public class ZookeeperStateMachineEnsembleTests extends AbstractZookeeperTests { return new AnnotationConfigApplicationContext(); } - private class TestEnsembleListener implements EnsembleListeger { + private class TestEnsembleListener implements EnsembleListener { volatile CountDownLatch joinedLatch = new CountDownLatch(1); volatile CountDownLatch eventLatch = new CountDownLatch(1);