* limitations under the License.
 */

package org.gradle.model.dsl.internal.transform;

public class InputReference {
    private final String path;
    private final int lineNumber;

    public InputReference(String path, int lineNumber) {
        this.path = path;
        this.lineNumber = lineNumber;
    }

    public String getPath() {
        return path;
    }

public class InputReferences {
    private final List<InputReference> ownReferences = new ArrayList<>();
    private final List<InputReference> nestedReferences = new ArrayList<>();

    public List<InputReference> getOwnReferences() {
        return ownReferences;
    }

    public void ownReference(String path, int lineNumber) {
        ownReferences.add(new InputReference(path, lineNumber));
    }

    public boolean isEmpty() {

        def rule1 = rule("other") { it.inputReference("path", ModelNode.State.Finalized) }
        def rule2 = rule("other") { it.inputReference(Long, ModelNode.State.Finalized) }
        def rule3 = rule("other") { it.inputReference("path", ModelNode.State.Finalized) }
        def rule4 = rule("other") { it.inputReference(Long, ModelNode.State.Finalized) }
        def rule5 = rule("other") { it.inputReference(Long, ModelNode.State.Finalized) }

        }

        void inputReference(ModelReference<?> reference) {
            inputReferences.add(new BindingPredicate(reference))
        }

        void inputReference(Class type) {
            inputReference(ModelReference.of(ModelType.of(type)).inScope(ModelPath.ROOT))
        }

        void inputReference(Class type, ModelNode.State state) {

        binder {
            descriptor("partiallyBoundRule")
            subjectReference("subject", Number)
            inputReference("reference.first", Number)
            inputReference(String)
            inputReference("reference.third", Boolean)
            bindSubjectReference("subject")
            bindInputReference(0, "reference.first")

                List<InputReference> inputReferences = supportsNestedRules ? inputs.getOwnReferences() : inputs.getAllReferences();
                final Map<String, PotentialInput> inputValues = new LinkedHashMap<>();
                List<ModelReference<?>> inputModelReferences = new ArrayList<>();

                for (InputReference inputReference : inputReferences) {

            }
            for (InputReference inputReference : inputs.getNestedReferences()) {
                statements.add(new ExpressionStatement(new MethodCallExpression(inputsVar,
                        "nestedReference",
                        new ArgumentListExpression(
                                new ConstantExpression(inputReference.getPath()),
                                new ConstantExpression(inputReference.getLineNumber())))));

        return action(ModelReference.of(modelPath, inputType, referenceDescription), action);
    }

    public <I> ModelAction action(final ModelReference<I> inputReference, final BiAction<? super T, ? super I> action) {
        return build(Collections.<ModelReference<?>>singletonList(inputReference), new TriAction<MutableModelNode, T, List<ModelView<?>>>() {
            @Override

        }
        ImmutableList.Builder<ModelBinding> bindings = ImmutableList.builderWithExpectedSize(inputReferences.size());
        for (BindingPredicate inputReference : inputReferences) {
            bindings.add(binding(inputReference, descriptor, false, inputBindAction));
        }
        return bindings.build();
    }

Class <org.gradle.model.dsl.internal.transform.InputReference> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (InputReference.java:0)
Class <org.gradle.model.dsl.internal.transform.InputReferences> is not annotated (directly or via its package) with @org.gradle.api.NonNullApi in (InputReferences.java:0)