// Create (or get) a destroyer ordinal node that depends on the output locations of this task node
        ordinal.getDestroyerLocationsNode().addDependenciesFrom(destroyer);

        // Depend on any previous producer ordinal nodes (i.e. any producer ordinal nodes with a lower ordinal)
        if (ordinal.getPrevious() != null) {
            OrdinalNode producerLocations = ordinal.getPrevious().getProducerLocationsNode();

public class OrdinalGroup extends NodeGroup {
    private final int ordinal;
    @Nullable
    private final OrdinalGroup previous;
    private final Set<Node> entryNodes = new LinkedHashSet<>();
    private OrdinalNode producerLocationsNode;
    private OrdinalNode destroyerLocationsNode;

    OrdinalGroup(int ordinal, @Nullable OrdinalGroup previous) {
        this.ordinal = ordinal;
        this.previous = previous;
    }

    @Override

func podInOrdinalRange(pod *v1.Pod, set *apps.StatefulSet) bool {
	ordinal := getOrdinal(pod)
	return ordinal >= getStartOrdinal(set) && ordinal <= getEndOrdinal(set)
}

// getPodName gets the name of set's child Pod with an ordinal index of ordinal
func getPodName(set *apps.StatefulSet, ordinal int) string {
	return fmt.Sprintf("%s-%d", set.Name, ordinal)
}

 * limitations under the License.
 */

package org.gradle.launcher.daemon.server.expiry;

/**
 * Expiration status for daemon expiration check results.  Note that order here is important, higher ordinal statuses take precedent over lower ordinal statuses when aggregating results in {@link
 * AllDaemonExpirationStrategy}.
 */
public enum DaemonExpirationStatus {
    DO_NOT_EXPIRE,
    QUIET_EXPIRE,
    GRACEFUL_EXPIRE,

    public enum Type {DESTROYER, PRODUCER}

    private final Type type;
    private final OrdinalGroup ordinal;

    public OrdinalNode(Type type, OrdinalGroup ordinal) {
        this.type = type;
        this.ordinal = ordinal;
        setGroup(ordinal);
    }

    @Nullable
    @Override
    public Throwable getNodeFailure() {
        return null;
    }

    @Override

        // Check to see if we should adjust the level based on a set lifecycle log level
        if (lifecycleLogLevel != null) {
            if (defaultLevel.ordinal() < LogLevel.LIFECYCLE.ordinal()
                && AntMessagePriority.from(messagePriority).ordinal() >= lifecycleLogLevel.ordinal()) {
                // we would normally log at a lower level than lifecycle, but the Ant message priority is actually higher

 * to be freely compared by identity.
 */
@ServiceScope(Scope.Build.class)
public class OrdinalGroupFactory {

    private final List<OrdinalGroup> groups = new ArrayList<>();

    public final OrdinalGroup group(int ordinal) {
        growTo(ordinal);
        return groups.get(ordinal);
    }

    public List<OrdinalGroup> getAllGroups() {

    }

    def 'returns the same group for the same ordinal'() {
        given:
        def subject = new OrdinalGroupFactory()

        when:
        def g0 = subject.group(0)
        def g1 = subject.group(1)

        then:
        g1 != g0
        subject.group(0) == g0
        subject.group(1) == g1

        and:
        g0.ordinal == 0
        g1.ordinal == 1
    }

        if (length < MAX_BYTES) {
            return UNKNOWN;
        }
        try {
            int ordinal = dataInput.readByte();
            if (ordinal < TYPES.size()) {
                return TYPES.get(ordinal);
            }
        } catch (EOFException ignore) {
            // old versions don't send a type
        }
        return UNKNOWN;
    }

 *         A "requested task", which is a task requested on the command-line. For example given `gradle a b:` then all the tasks that match `a` are treated as a requested task group (with ordinal 0)
 *         and all the tasks that match `b` are treated as another requested task group (with ordinal 1).
 *     </li>
 *     <li>A finalizer node. Each finalizer is treated as its own node group.</li>
 * </ul>
 *