/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License (the "License").

 * You may not use this file except in compliance with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 */

/*

 */

package org.opensolaris.os.adr;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

public class MethodDiff extends FeatureDiff<Method> {

    public MethodDiff(Map<Stability, Diff> diffs) {

	super(diffs);

    }

    void generateDiffs(Map<String, Method> methodsOld,

	Map<String, Method> methodsNew) {

	Set<String> common = getDiffSet(methodsOld, methodsNew);

	for (String mname : common) {

	    Method mOld = methodsOld.get(mname);

	    Method mNew = methodsNew.get(mname);

	    assert (mOld != null && mNew != null);

	    updateFeatureDiffs(mOld, mNew, true, false);

	    updateDiffs(mOld.getStability(),

	    updateDiffs(mOld.getStability(), diffArgs(mOld.getArguments(),

		mNew.getArguments()));

	}

    }

    /*

     * A change in the number of args is an incompatible change

     * A change in the order of the args (types) is an incompatible change

     * A change of args from optional to required is an incompatible change

     * A change of args from required to optional is a compatible change

     */

    private Diff diffArgs(List<Argument> aold, List<Argument> anew) {

	if (aold == null || anew == null)

	    return (aold == null && anew == null) ? Diff.NONE :

		Diff.INCOMPATIBLE;

	if (aold.size() != anew.size())

	    return Diff.INCOMPATIBLE;

	Diff diff = Diff.NONE;

	Argument[] oldarr = new Argument[aold.size()];

	aold.toArray(oldarr);

	Argument[] newarr = new Argument[aold.size()];

	anew.toArray(newarr);

	for (int i = 0; i < aold.size(); i++) {

	    Diff adiff = diffOptional(oldarr[i].isOptional(),

		    newarr[i].isOptional(), false, true);

	    if (adiff.compareTo(diff) > 0)

		diff = adiff;

	    adiff = diffType(oldarr[i].getType(), newarr[i].getType(),

		false, true);

	    if (adiff.compareTo(diff) > 0)

		diff = adiff;

	}

	return diff;

    }

}