/**
 * A package header
 */
package test.scaladoc;

/**
 * Testing java comments. The presence of a :marker:
 * tag is verified by tests.
 */
public class JavaComments {

    /** A field */
    public final int x;
    /** A field */
    protected int y;
    /** A field */
    private int z;

    /**
     * Inner class
     */
    public class Inner {
	/** Inner method */
	public void foo() {
	}
    }

    /**
     * A typed inner class
     * @param <T> some type
     */
    public class InnerTyped<T> {
    }

    /**
     * Compute the answer to the ultimate question of life, the
     * universe, and everything. :marker:
     * @param factor scaling factor to the answer
     * @return the answer to everything (42) scaled by factor
     */
    public int answer(int factor) {
	return 42 * factor;
    }

    /** Private */
    private double foo(double value) {
	return value;
    }

    /** Protected */
    protected double bar(double value) {
	return value;
    }

    /** No qualifier*/
    String noqualifier() {
	return "something";
    }

    /** Void */
    public void voidmethod(boolean t) {
    }

    /**
     * Typed parameter
     * @param <A> the parameter type
     * @param a parameter
     * @return something
     */
    public <A> void tparams(A a) {
    }

    /**
     * Typed parameter
     * @param <A> the return type
     * @param <B> the parameter typeA
     * @param b parameter
     * @return casts B to A
     */
    public <A, B extends A> A cast(B b) {
	return (B) b;
    }

}

// The following snippet is taken from Akka, it mainly tests interfaces

/**
 * Class that encapsulates all the Functional Interfaces
 * used for creating partial functions.
 *
 * This is an EXPERIMENTAL feature and is subject to change until it has received more real world testing.
 */
public final class FI {

    /** Doc comment on constructor */
    private FI() {
    }

    /**
     * Functional interface for an application.
     *
     * @param <I> the input type, that this Apply will be applied to
     * @param <R> the return type, that the results of the application will have
     */
    public static interface Apply<I, R> {
	/**
	 * The application to perform.
	 *
	 * @param i  an instance that the application is performed on
	 * @return  the result of the application
	 */
	public R apply(I i) throws Exception;
    }

    /**
     * Functional interface for an application.
     *
     * @param <I1> the first input type, that this Apply will be applied to
     * @param <I2> the second input type, that this Apply will be applied to
     * @param <R> the return type, that the results of the application will have
     */
    public static interface Apply2<I1, I2, R> {
	/**
	 * The application to perform.
	 *
	 * @param i1  an instance that the application is performed on
	 * @param i2  an instance that the application is performed on
	 * @return  the result of the application
	 */
	public R apply(I1 i1, I2 i2) throws Exception;
    }

    /**
     * Functional interface for a predicate.
     *
     * @param <T> the type that the predicate will operate on.
     */
    public static interface TypedPredicate<T> {
	/**
	 * The predicate to evaluate.
	 *
	 * @param t  an instance that the predicate is evaluated on.
	 * @return  the result of the predicate
	 */
	public boolean defined(T t);
    }

    /**
     * Functional interface for a predicate.
     *
     * @param <T> the type that the predicate will operate on.
     * @param <U> the type that the predicate will operate on.
     */
    public static interface TypedPredicate2<T, U> {
	/**
	 * The predicate to evaluate.
	 *
	 * @param t  an instance that the predicate is evaluated on.
	 * @param u  an instance that the predicate is evaluated on.
	 * @return  the result of the predicate
	 */
	public boolean defined(T t, U u);
    }

    /**
     * Functional interface for an application.
     *
     * @param <I> the input type, that this Apply will be applied to
     */
    public static interface UnitApply<I> {
	/**
	 * The application to perform.
	 *
	 * @param i  an instance that the application is performed on
	 */
	public void apply(I i) throws Exception;
    }

    /**
     * Functional interface for an application.
     *
     * @param <I1> the first input type, that this Apply will be applied to
     * @param <I2> the second input type, that this Apply will be applied to
     */
    public static interface UnitApply2<I1, I2> {
	/**
	 * The application to perform.
	 *
	 * @param i1  an instance that the application is performed on
	 * @param i2  an instance that the application is performed on
	 */
	public void apply(I1 i1, I2 i2) throws Exception;
    }

    /**
     * Functional interface for an application.
     *
     * @param <I1> the first input type, that this Apply will be applied to
     * @param <I2> the second input type, that this Apply will be applied to
     * @param <I3> the third input type, that this Apply will be applied to
     */
    public static interface UnitApply3<I1, I2, I3> {
	/**
	 * The application to perform.
	 *
	 * @param i1  an instance that the application is performed on
	 * @param i2  an instance that the application is performed on
	 * @param i3  an instance that the application is performed on
	 */
	public void apply(I1 i1, I2 i2, I3 i3) throws Exception;
    }

    /**
     * Functional interface for an application.
     *
     * @param <I1> the first input type, that this Apply will be applied to
     * @param <I2> the second input type, that this Apply will be applied to
     * @param <I3> the third input type, that this Apply will be applied to
     * @param <I4> the fourth input type, that this Apply will be applied to
     */
    public static interface UnitApply4<I1, I2, I3, I4> {
	/**
	 * The application to perform.
	 *
	 * @param i1 an instance that the application is performed on
	 * @param i2 an instance that the application is performed on
	 * @param i3 an instance that the application is performed on
	 * @param i4 an instance that the application is performed on
	 */
	public void apply(I1 i1, I2 i2, I3 i3, I4 i4) throws Exception;
    }

    /**
     * Functional interface for an application.
     */
    public static interface UnitApplyVoid {
	/**
	 * The application to perform.
	 */
	public void apply() throws Exception;
    }

    /**
     * Package scoped functional interface for a predicate. Used internally to match against arbitrary types.
     */
    static interface Predicate {
	/**
	 * The predicate to evaluate.
	 *
	 * @param o  an instance that the predicate is evaluated on.
	 * @return  the result of the predicate
	 */
	public boolean defined(Object o);
    }

}

/**
 * Functional interface for an application.
 *
 * @param <I1> the first input type, that this Apply will be applied to
 * @param <I2> the second input type, that this Apply will be applied to
 * @param <I3> the third input type, that this Apply will be applied to
 * @param <I4> the fourth input type, that this Apply will be applied to
 */
public interface UnitApply4<I1, I2, I3, I4> {
    /**
     * The application to perform.
     *
     * @param i1 an instance that the application is performed on
     * @param i2 an instance that the application is performed on
     * @param i3 an instance that the application is performed on
     * @param i4 an instance that the application is performed on
     */
    public void apply(I1 i1, I2 i2, I3 i3, I4 i4) throws Exception;
}

/**
 * Functional interface for an application.
 */
public interface UnitApplyVoid {
    /**
     * The application to perform.
     */
    public void apply() throws Exception;
}

/**
 * Package scoped functional interface for a predicate. Used internally to match against arbitrary types.
 */
interface Predicate {
    /**
     * The predicate to evaluate.
     *
     * @param o  an instance that the predicate is evaluated on.
     * @return  the result of the predicate
     */
    public boolean defined(Object o);
}