/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (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
 */
/*
 * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 *
 * ident	"%Z%%M%	%I%	%E% SMI"
 */

package com.sun.solaris.domain.pools;

import java.util.*;

import com.sun.solaris.service.pools.*;

/**
 * This class represents a move of resources between two resource
 * sets. It is designed to be extended by classes which implement
 * different types of moves.
 */
abstract class Move
{
	/**
	 * Source resource set
	 */
	private Resource from;

	/**
	 * Destination resource set
	 */
	private Resource to;

	/**
	 * Sole constructor.  (For invocation by subclass constructors)
	 *
	 * @param from The source of the move
	 * @param to The destination of the move
	 */
	protected Move(Resource from, Resource to)
	{
		this.from = from;
		this.to = to;
	}

	/**
	 * Return the source of this move.
	 */
	Resource getFrom()
	{
		return (from);
	}
	
	/**
	 * Return the destination of this move.
	 */
	Resource getTo()
	{
		return (to);
	}

	/**
	 * Apply this move to the resources described.
	 *
	 * @throws PoolsException If the move fails for any reason.
	 */
	abstract void apply() throws PoolsException;

	/**
	 * Return the quantity of moved resource.
	 */
	abstract long getQty();
}

/**
 * This class represents a move of component resources between two
 * resource sets. A component of a resource set is a uniquely
 * identifiable component, such as a processor.
 */
final class ComponentMove extends Move
{
	/**
	 * List of components being moved.
	 */
	private List compList;

	/**
	 * Constructor
	 *
	 * @param from The source of the move
	 * @param to The destination of the move
	 * @param comp The component which is to be moved
	 */
	ComponentMove(Resource from, Resource to, Component comp)
	{
		super(from, to);
		compList = new ArrayList();
		compList.add(comp);
	}

	/**
	 * Return a list of the components that comprise this move.
	 *
	 * The members of the list are guaranteed to be Component
	 * objects.
	 */
	List getComponents()
	{
		return ((List) ((ArrayList) compList).clone());
	}

	/**
	 * Apply the move to the configuration to which the resources
	 * belong.
	 *
	 * @throws PoolsException if the transfer of resource fails.
	 */
	void apply() throws PoolsException
	{
		getTo().transfer(getFrom(), compList);
	}

	/**
	 * Return the quantity of resource which is participating in
	 * this move.
	 */
	long getQty()
	{
		return (compList.size());
	}

	/**
	 * Converts the <code>ComponentMove</code> to a
	 * <code>String</code> of the form:
	 */
	public String toString()
	{
		return ("from " + getFrom().toString() + " to " +
		    getTo().toString() + " components " + compList);
	}
}

/**
 * This class represents a move of commodity resources between two
 * resource sets. Such a resource cannot be uniquely identified in the
 * resource abstraction and is thus different to a move consisting of
 * uniquely identifiable resource components.
 */
class QuantityMove extends Move
{
	/**
	 * The resource quantity of the move.
	 */
	private long qty;

	/**
	 * Construct a quantity move using the supplied details.
	 *
	 * @param from The source of the resources.
	 * @param to The destination of the resources.
	 * @param qty The quantity of the resources.
	 *
	 * @throws IllegalArgumentException if the qty is negative.
	 */
	QuantityMove(Resource from, Resource to, long qty)
	{
		super(from, to);
		if (qty < 0)
			throw new IllegalArgumentException(
			    "The resource quantity supplied (" + qty +
			    ") is illegal.");
		this.qty = qty;
	}

	/**
	 * Apply the move to the configuration to which the resources
	 * belong.
	 *
	 * @throws PoolsException if the transfer of resource fails.
	 */
	void apply() throws PoolsException
	{
		getTo().transfer(getFrom(), qty);
	}

	/**
	 * Return the quantity of resource which is participating in
	 * this move.
	 */
	long getQty()
	{
		return (qty);
	}

	/**
	 * Return a string representation of the move.
	 */
	public String toString()
	{
		return ("from " + getFrom().toString() + " to " +
		    getTo().toString() + " quantity " + qty);
	}
}