[Ginto8]

We will not be testing this until later today, but I wanted to share my expected solution to Conditional cancelling itself. It requires an extra class, edu.wpi.first.wpilibj.command.PublicCommand, which just exposes a number of Command's methods that are protected or package-private normally:

package edu.wpi.first.wpilibj.command;

import java.util.Enumeration;

/** A Command that exposes more internals to the world. */
public class PublicCommand extends Command {
    private final Command _c;

    public PublicCommand(Command c) {
        _c = c;
        for(Enumeration e = c.getRequirements();e.hasMoreElements();) {
            requires((Subsystem) e.nextElement());
        }
    }
    public Enumeration getRequirements() {
        return _c.getRequirements();
    }

    public void initialize() {
        if(_c != null) {
            _c.initialize();
        }
    }
    public void _initialize() {
        if(_c != null) {
            _c._initialize();
        }
    }

    public void execute() {
        if(_c != null) {
            _c.execute();
        }
    }
    public void _execute() {
        if(_c != null) {
            _c._execute();
        }
    }

    public boolean isFinished() {
        return _c == null || _c.isFinished();
    }

    public void end() {
        if(_c != null) {
            _c.end();
        }
    }
    public void _end() {
        if(_c != null) {
            _c._end();
        }
    }

    public void interrupted() {
        if(_c != null) {
            _c.interrupted();
        }
    }
    public void _interrupted() {
        if(_c != null) {
            _c._interrupted();
        }
    }
    
}

Then, Conditional becomes:

package storm2014.commands.control;

import edu.wpi.first.wpilibj.command.Command;
import edu.wpi.first.wpilibj.command.PublicCommand;
import edu.wpi.first.wpilibj.command.Subsystem;
import java.util.Enumeration;

public abstract class Conditional extends Command {
    private final PublicCommand _ifTrue,_ifFalse;
    private PublicCommand _running = null;

    public Conditional(final Command ifTrue,final Command ifFalse) {
        // Wrap the Commands to expose protected methods
        if(ifTrue != null) {
            _ifTrue  = new PublicCommand(ifTrue);
            for(Enumeration e = _ifTrue.getRequirements();e.hasMoreElements();) {
                requires((Subsystem) e.nextElement());
            }
        } else {
            _ifTrue = null;
        }
        if(ifFalse != null) {
            _ifFalse  = new PublicCommand(ifFalse);
            for(Enumeration e = _ifFalse.getRequirements();e.hasMoreElements();) {
                requires((Subsystem) e.nextElement());
            }
        } else {
            _ifFalse = null;
        }
    }
    
    protected abstract boolean condition();

    protected void initialize() {
        if(condition()) {
            _running = _ifTrue;
        } else {
            _running = _ifFalse;
        }
        if(_running != null) {
            _running._initialize();
            _running.initialize();
        }
    }

    protected void execute() {
        if(_running != null) {
            _running._execute();
            _running.execute();
        }
    }

    protected boolean isFinished() {
        return _running == null || _running.isFinished();
    }

    protected void end() {
        if(_running != null) {
            _running._end();
            _running.end();
        }
    }

    protected void interrupted() {
        if(_running != null) {
            _running._interrupted();
            _running.interrupted();
        }
    }
}

Instead of start()ing the Commands, it wraps them entirely. The Conditional has all the combined requirements of ifTrue and ifFalse, and each of initialize(), execute(), isFinished(), end(), and interrupted() call the corresponding method in the selected Command. Because of that, running it should have the same effect as start()ing, except that it will not cancel a CommandGroup it is in.