Add to the second input the union of the given operators.

@param input The operator(s) to be unioned with the second input.
@deprecated This method will be removed in future versions. Use the {@link Union} operator instead.
544024
@Deprecated
	public void addSecondInput(Operator<IN2>... input) {
		this.input2 = Operator.createUnionCascade(this.input2, input);
	}
198153
public static String[] nullifyBadInput(String[] input)
    {
        if (input != null)
        {
            if (input.length > 0)
            {
                return input;
            }
        }
        return null;
    }
101416
public static byte[] decodeMultiple(final byte[] input) {

        if (input == null) {
            throw new NullPointerException("input");
        }

        final byte[] output = new byte[input.length >> 1]; // /2

        decodeMultiple(input, 0, output, 0, output.length);

        return output;
    }
1152230
public boolean add(int e)
    {
        if(e < 0 || e >= has.length)
            throw new IllegalArgumentException("Input must be in range [0, " + has.length + ") not " + e);
        else if(contains(e) )
            return false;
        else
        {
            if (nnz == 0)
            {
                first = e;
                next[e] = prev[e] = STOP;
            }
            else
            {
                prev[first] = e;
                next[e] = first;
                prev[e] = STOP;
                first = e;
            }
            nnz++;
            return has[e] = true;
        }
    }
794523
public static <T extends Collection<?>> T removeDuplicates(T input) {
        List<Object> unique = new ArrayList<>(input.size());
        for (Iterator<?> iter = input.iterator(); iter.hasNext(); ) {
            Object next = iter.next();
            if (unique.contains(next)) {
                iter.remove();
            } else {
                unique.add(next);
            }
        }
        return input;
    }
704605
public static void setInput(Input input, InputSource inputSource) {
    input.setByteStream(inputSource.getByteStream());
    input.setCharacterStream(inputSource.getCharacterStream());
    input.setUri(inputSource.getSystemId());
    input.setEncoding(inputSource.getEncoding());
  }
1322888
@Nonnull
    public static List<String> splitAtCommasAndTrim(Iterable<String> input) {
        if(input==null) {
            return Collections.emptyList();
        }
        Iterable<String> nonEmptyInputs = Iterables.filter(input, Predicates.notNull());
        return Lists.newArrayList(Iterables.concat(Iterables.transform(nonEmptyInputs, COMMA_SPLITTER)));
    }
53224
protected void processInput(String input) {
        String command = input.trim();
        if (!command.isEmpty()) {
            runCommand(command);
        }
    }
369062
@Deprecated
	public void setSecondInputs(List<Operator<IN2>> inputs) {
		this.input2 = Operator.createUnionCascade(inputs);
	}
1146034
public void setInput(final byte[] input)
	{

		if (input[0] == -128) {
			r = new BitReader(inflateInput(input, 1));
		}
		else {
			r = new BitReader(input);
		}
	}
943848
public void engineUpdate(byte input) {
        bytes++;
        if (padding < 63) {
            pad[padding++] = input;
            return;
        }
        pad[63] = input;
        computeBlock(pad, 0);
        padding = 0;
    }
234386
public static String[] removeDuplicates(String[] input)
    {
        if (input != null)
        {
            if (input.length > 0)
            {
                Set<String> inputSet = new HashSet<String>(Arrays.asList(input));
                if (inputSet.size() > 0)
                {
                    return inputSet.toArray(new String[inputSet.size()]);
                }
            }
        }
        return null;
    }
853771
@Override
    public boolean condition(Object input) {
        return op.apply(input.toString(), value, set);
    }
440871
@SuppressWarnings("unchecked")
	@Deprecated
	public void addInputs(List<? extends Operator<IN>> inputs) {
		Preconditions.checkNotNull(inputs, "The inputs may not be null.");
		this.input = createUnionCascade(this.input, (Operator<IN>[]) inputs.toArray(new Operator[inputs.size()]));
	}
692125
@Deprecated
	public void addFirstInput(Operator<IN1>... input) {
		this.input1 = Operator.createUnionCascade(this.input1, input);
	}
365419
@Override
    public Object map(Object input) {
        List<Long> list = (List<Long>) input;
        switch (mathOp) {
            case Add:
                long sum = 0;
                for (Long w : list)
                    sum += w;
                return new LongWritable(sum);
            case Subtract:
                return list.get(0) - list.get(1);
            case Multiply:
                long product = 1;
                for (Long w : list)
                    product *= w;
                return product;
            case Divide:
                return list.get(0) / list.get(1);
            case Modulus:
                return list.get(0) % list.get(1);
            case ReverseSubtract:
            case ReverseDivide:
            case ScalarMin:
            case ScalarMax:
            default:
                throw new RuntimeException("Invalid mathOp: " + mathOp); //Should never happen
        }
    }
595607
public void addAfter(CompilerInput input, CompilerInput other) {
    checkState(inputs.contains(other));
    inputs.add(inputs.indexOf(other), input);
    input.setModule(this);
  }