Changeset 79 for trunk/EventBenchCore/src/de/ugoe/cs/eventbench/data/ReplayableEvent.java

Timestamp:

06/21/11 11:25:45 (13 years ago)

Author:

sherbold

Message:

• documentation

File:

• trunk/EventBenchCore/src/de/ugoe/cs/eventbench/data/ReplayableEvent.java (modified) (1 diff)

trunk/EventBenchCore/src/de/ugoe/cs/eventbench/data/ReplayableEvent.java

@@ -6 +6 @@
 import de.ugoe.cs.eventbench.IReplayDecorator;
 
+/**
+ * <p>
+ * Subclass of {@link Event} for events that contain all informations required
+ * for replaying them, i.e., generating scripts that can used for automated
+ * software execution.
+ * </p>
+ * 
+ * @author Steffen Herbold
+ * @version 1.0
+ * 
+ * @param <T>
+ *            Allows only types that extend {@link IReplayable} and is used to
+ *            define a list of replayables that describe the replay of the
+ *            event.
+ */
 public class ReplayableEvent<T extends IReplayable> extends Event<T> {
 
+        /**
+         * <p>
+         * List of {@link IReplayable}s of type T that describes the replay of an
+         * event. The {@link IReplayable}s can be interpreted as <it>sub-events</it>
+         * on the platform level that make up the abstract event.
+         * </p>
+         */
         private List<T> replayEvents = new LinkedList<T>();;
 
+        /**
+         * <p>
+         * Defines whether the replay is valid or invalid. It may be invalid, e.g.,
+         * due to errors during the generation of the event or lack of vital
+         * information.
+         * </p>
+         */
         private boolean replayValid = true;
-        
+
+        /**
+         * <p>
+         * {@link IReplayDecorator} used when replays of this type are written.
+         * </p>
+         */
         private IReplayDecorator decorator = null;
-        
+
+        /**
+         * <p>
+         * Constructor. Creates a new event with the given type.
+         * <p>
+         * 
+         * @param type
+         *            type of the event
+         * @see Event#Event(String)
+         */
         public ReplayableEvent(String type) {
                 super(type);
         }
-        
+
+        /**
+         * <p>
+         * Adds a new {@link IReplayable} of type T to the replay sequence.
+         * </p>
+         * 
+         * @param replayable
+         *            element that is added to the sequence
+         */
+        public void addReplayEvent(T replayable) {
+                replayEvents.add(replayable);
+        }
+
+        /**
+         * <p>
+         * Adds a {@link List}ist of {@link IReplayable} to the replay sequence.
+         * </p>
+         * 
+         * @param generatedReplaySeq
+         *            {@link List} that is added to the sequence
+         */
         public void addReplaySequence(List<T> generatedReplaySeq) {
                 replayEvents.addAll(generatedReplaySeq);
         }
 
-        public void addReplayEvent(T replayable) {
-                replayEvents.add(replayable);
+        /**
+         * <p>
+         * Returns the {@link IReplayDecorator} of the event.
+         * </p>
+         * 
+         * @return {@link IReplayDecorator} of the event; null if no decorator has
+         *         been set
+         */
+        public IReplayDecorator getReplayDecorator() {
+                return decorator;
         }
-        
+
         /**
          * <p>
          * Returns a the list of replay events.
-         * </p> 
+         * </p>
          * <p>
          * The return value is a copy of the list used internally!
          * </p>
-         * @return list of replay events. 
+         * 
+         * @return list of replay events.
          */
         public List<T> getReplayMessages() {
                 return new LinkedList<T>(replayEvents);
         }
-        
+
+        /**
+         * <p>
+         * Returns whether the replay is valid or not.
+         * </p>
+         * 
+         * @return true, if replay is valid; false otherwise.
+         */
         public boolean hasValidReplay() {
                 return replayValid;
         }
 
+        /**
+         * <p>
+         * Marks the replay as invalid. Once marked as invalid, it remains so and
+         * cannot be changed back to valid.
+         * </p>
+         */
         public void invalidateReplay() {
                 replayValid = false;
         }
 
+        /**
+         * <p>
+         * Sets the {@link IReplayDecorator} associated with the event.
+         * </p>
+         * 
+         * @param decorator
+         *            decorator associated with the event
+         */
         public void setDecorator(IReplayDecorator decorator) {
                 this.decorator = decorator;
         }
-        
-        public IReplayDecorator getReplayDecorator() {
-                return decorator;
-        }
 
 }