// Path: src/main/java/com/lmax/disruptor/EventHandler.java
// public interface EventHandler<T>
// {
//     /**
//      * Called when a publisher has published an event to the {@link RingBuffer}
//      *
//      * @param event published to the {@link RingBuffer}
//      * @param sequence of the event being processed
//      * @param endOfBatch flag to indicate if this is the last event in a batch from the {@link RingBuffer}
//      * @throws Exception if the EventHandler would like the exception handled further up the chain.
//      */
//     void onEvent(T event, long sequence, boolean endOfBatch) throws Exception;
// }
// 
// Path: src/main/java/com/lmax/disruptor/EventProcessor.java
// public interface EventProcessor extends Runnable
// {
//     /**
//      * Get a reference to the {@link Sequence} being used by this {@link EventProcessor}.
//      *
//      * @return reference to the {@link Sequence} for this {@link EventProcessor}
//      */
//     Sequence getSequence();
// 
//     /**
//      * Signal that this EventProcessor should stop when it has finished consuming at the next clean break.
//      * It will call {@link SequenceBarrier#alert()} to notify the thread to check status.
//      */
//     void halt();
// }
// 
// Path: src/main/java/com/lmax/disruptor/SequenceBarrier.java
// public interface SequenceBarrier
// {
//     /**
//      * Wait for the given sequence to be available for consumption.
//      *
//      * @param sequence to wait for
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence) throws AlertException, InterruptedException;
// 
//     /**
//      * Wait for the given sequence to be available for consumption with a time out.
//      *
//      * @param sequence to wait for
//      * @param timeout value
//      * @param units for the timeout value
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence, long timeout, TimeUnit units) throws AlertException, InterruptedException;
// 
//     /**
//      * Delegate a call to the {@link Sequencer#getCursor()}
//      *
//      * @return value of the cursor for entries that have been published.
//      */
//     long getCursor();
// 
//     /**
//      * The current alert status for the barrier.
//      *
//      * @return true if in alert otherwise false.
//      */
//     boolean isAlerted();
// 
//     /**
//      * Alert the {@link EventProcessor}s of a status change and stay in this status until cleared.
//      */
//     void alert();
// 
//     /**
//      * Clear the current alert status.
//      */
//     void clearAlert();
// 
//     /**
//      * Check if an alert has been raised and throw an {@link AlertException} if it has.
//      *
//      * @throws AlertException if alert has been raised.
//      */
//     void checkAlert() throws AlertException;
// }
// 
// Path: src/main/java/com/lmax/disruptor/util/Util.java
// public final class Util
// {
//     /**
//      * Calculate the next power of 2, greater than or equal to x.<p>
//      * From Hacker's Delight, Chapter 3, Harry S. Warren Jr.
//      *
//      * @param x Value to round up
//      * @return The next power of 2 from x inclusive
//      */
//     public static int ceilingNextPowerOfTwo(final int x)
//     {
//         return 1 << (32 - Integer.numberOfLeadingZeros(x - 1));
//     }
// 
//     /**
//      * Get the minimum sequence from an array of {@link com.lmax.disruptor.Sequence}s.
//      *
//      * @param sequences to compare.
//      * @return the minimum sequence found or Long.MAX_VALUE if the array is empty.
//      */
//     public static long getMinimumSequence(final Sequence[] sequences)
//     {
//         long minimum = Long.MAX_VALUE;
// 
//         for (Sequence sequence : sequences)
//         {
//             long value = sequence.get();
//             minimum = minimum < value ? minimum : value;
//         }
// 
//         return minimum;
//     }
// 
//     /**
//      * Get an array of {@link Sequence}s for the passed {@link EventProcessor}s
//      *
//      * @param processors for which to get the sequences
//      * @return the array of {@link Sequence}s
//      */
//     public static Sequence[] getSequencesFor(final EventProcessor... processors)
//     {
//         Sequence[] sequences = new Sequence[processors.length];
//         for (int i = 0; i < sequences.length; i++)
//         {
//             sequences[i] = processors[i].getSequence();
//         }
// 
//         return sequences;
//     }
// }


import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.EventProcessor;
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.util.Util;
/*
 * Copyright 2011 LMAX Ltd.
 *
 * 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 com.lmax.disruptor.dsl;


/**
 * A group of {@link EventProcessor}s used as part of the {@link Disruptor}.
 *
 * @param <T> the type of entry used by the event processors.
 */
public class EventHandlerGroup<T>
{
    private final Disruptor<T> disruptor;
    private final EventProcessorRepository<T> eventProcessorRepository;
    private final EventProcessor[] eventProcessors;

    EventHandlerGroup(final Disruptor<T> disruptor,
                      final EventProcessorRepository<T> eventProcessorRepository,
                      final EventProcessor[] eventProcessors)
    {
        this.disruptor = disruptor;
        this.eventProcessorRepository = eventProcessorRepository;
        this.eventProcessors = eventProcessors;
    }

    /**
     * Create a new event handler group that combines the handlers in this group with
     * <tt>handlers</tt>.
     *
     * @param handlers the handlers to combine.
     * @return a new EventHandlerGroup combining the existing and new handlers into a
     * single dependency group.
     */
// Path: src/main/java/com/lmax/disruptor/EventHandler.java
// public interface EventHandler<T>
// {
//     /**
//      * Called when a publisher has published an event to the {@link RingBuffer}
//      *
//      * @param event published to the {@link RingBuffer}
//      * @param sequence of the event being processed
//      * @param endOfBatch flag to indicate if this is the last event in a batch from the {@link RingBuffer}
//      * @throws Exception if the EventHandler would like the exception handled further up the chain.
//      */
//     void onEvent(T event, long sequence, boolean endOfBatch) throws Exception;
// }
// 
// Path: src/main/java/com/lmax/disruptor/EventProcessor.java
// public interface EventProcessor extends Runnable
// {
//     /**
//      * Get a reference to the {@link Sequence} being used by this {@link EventProcessor}.
//      *
//      * @return reference to the {@link Sequence} for this {@link EventProcessor}
//      */
//     Sequence getSequence();
// 
//     /**
//      * Signal that this EventProcessor should stop when it has finished consuming at the next clean break.
//      * It will call {@link SequenceBarrier#alert()} to notify the thread to check status.
//      */
//     void halt();
// }
// 
// Path: src/main/java/com/lmax/disruptor/SequenceBarrier.java
// public interface SequenceBarrier
// {
//     /**
//      * Wait for the given sequence to be available for consumption.
//      *
//      * @param sequence to wait for
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence) throws AlertException, InterruptedException;
// 
//     /**
//      * Wait for the given sequence to be available for consumption with a time out.
//      *
//      * @param sequence to wait for
//      * @param timeout value
//      * @param units for the timeout value
//      * @return the sequence up to which is available
//      * @throws AlertException if a status change has occurred for the Disruptor
//      * @throws InterruptedException if the thread needs awaking on a condition variable.
//      */
//     long waitFor(long sequence, long timeout, TimeUnit units) throws AlertException, InterruptedException;
// 
//     /**
//      * Delegate a call to the {@link Sequencer#getCursor()}
//      *
//      * @return value of the cursor for entries that have been published.
//      */
//     long getCursor();
// 
//     /**
//      * The current alert status for the barrier.
//      *
//      * @return true if in alert otherwise false.
//      */
//     boolean isAlerted();
// 
//     /**
//      * Alert the {@link EventProcessor}s of a status change and stay in this status until cleared.
//      */
//     void alert();
// 
//     /**
//      * Clear the current alert status.
//      */
//     void clearAlert();
// 
//     /**
//      * Check if an alert has been raised and throw an {@link AlertException} if it has.
//      *
//      * @throws AlertException if alert has been raised.
//      */
//     void checkAlert() throws AlertException;
// }
// 
// Path: src/main/java/com/lmax/disruptor/util/Util.java
// public final class Util
// {
//     /**
//      * Calculate the next power of 2, greater than or equal to x.<p>
//      * From Hacker's Delight, Chapter 3, Harry S. Warren Jr.
//      *
//      * @param x Value to round up
//      * @return The next power of 2 from x inclusive
//      */
//     public static int ceilingNextPowerOfTwo(final int x)
//     {
//         return 1 << (32 - Integer.numberOfLeadingZeros(x - 1));
//     }
// 
//     /**
//      * Get the minimum sequence from an array of {@link com.lmax.disruptor.Sequence}s.
//      *
//      * @param sequences to compare.
//      * @return the minimum sequence found or Long.MAX_VALUE if the array is empty.
//      */
//     public static long getMinimumSequence(final Sequence[] sequences)
//     {
//         long minimum = Long.MAX_VALUE;
// 
//         for (Sequence sequence : sequences)
//         {
//             long value = sequence.get();
//             minimum = minimum < value ? minimum : value;
//         }
// 
//         return minimum;
//     }
// 
//     /**
//      * Get an array of {@link Sequence}s for the passed {@link EventProcessor}s
//      *
//      * @param processors for which to get the sequences
//      * @return the array of {@link Sequence}s
//      */
//     public static Sequence[] getSequencesFor(final EventProcessor... processors)
//     {
//         Sequence[] sequences = new Sequence[processors.length];
//         for (int i = 0; i < sequences.length; i++)
//         {
//             sequences[i] = processors[i].getSequence();
//         }
// 
//         return sequences;
//     }
// }


// Path: src/main/java/com/lmax/disruptor/dsl/EventHandlerGroup.java
import com.lmax.disruptor.EventHandler;
import com.lmax.disruptor.EventProcessor;
import com.lmax.disruptor.SequenceBarrier;
import com.lmax.disruptor.util.Util;

/*
 * Copyright 2011 LMAX Ltd.
 *
 * 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 com.lmax.disruptor.dsl;


/**
 * A group of {@link EventProcessor}s used as part of the {@link Disruptor}.
 *
 * @param <T> the type of entry used by the event processors.
 */
public class EventHandlerGroup<T>
{
    private final Disruptor<T> disruptor;
    private final EventProcessorRepository<T> eventProcessorRepository;
    private final EventProcessor[] eventProcessors;

    EventHandlerGroup(final Disruptor<T> disruptor,
                      final EventProcessorRepository<T> eventProcessorRepository,
                      final EventProcessor[] eventProcessors)
    {
        this.disruptor = disruptor;
        this.eventProcessorRepository = eventProcessorRepository;
        this.eventProcessors = eventProcessors;
    }

    /**
     * Create a new event handler group that combines the handlers in this group with
     * <tt>handlers</tt>.
     *
     * @param handlers the handlers to combine.
     * @return a new EventHandlerGroup combining the existing and new handlers into a
     * single dependency group.
     */
    public EventHandlerGroup<T> and(final EventHandler<T>... handlers)