/*******************************************************************************
 * Copyright (c) 2004, 2006 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.core.resources.mapping;

import java.util.ArrayList;
import org.eclipse.core.internal.resources.mapping.ModelProviderManager;
import org.eclipse.core.resources.*;
import org.eclipse.core.runtime.*;

/**
 * A resource mapping supports the transformation of an application model 
 * object into its underlying file system resources. It provides the
 * bridge between a logical element and the physical resource(s) into which it
 * is stored but does not provide more comprehensive model access or
 * manipulations.
 * <p>
 * Mappings provide two means of model traversal. The {@link #accept} method
 * can be used to visit the resources that constitute the model object. Alternatively,
 * a set or traversals can be obtained by calling {@link #getTraversals}. A traversal
 * contains a set of resources and a depth. This allows clients (such a repository providers)
 * to do optimal traversals of the resources w.r.t. the operation that is being performed
 * on the model object.
 * </p>
 * <p>
 * This class may be subclassed by clients.
 * </p>

 * @see IResource
 * @see ResourceTraversal
 * @since 3.2
 */
public abstract class ResourceMapping extends PlatformObject {

	/**
	 * Accepts the given visitor for all existing resources in this mapping.
	 * The visitor's {@link IResourceVisitor#visit} method is called for each 
	 * accessible resource in this mapping. 
	 * 
	 * @param context the traversal context
	 * @param visitor the visitor
	 * @param monitor a progress monitor, or <code>null</code> if progress
	 *    reporting is not desired
	 * @exception CoreException if this method fails. Reasons include:
	 * <ul>
	 * <li> The visitor failed with this exception.</li>
	 * <li> The traversals for this mapping could not be obtained.</li>
	 * </ul>
	 */
	public void accept(ResourceMappingContext context, IResourceVisitor visitor, IProgressMonitor monitor) throws CoreException {
		ResourceTraversal[] traversals = getTraversals(context, monitor);
		for (int i = 0; i < traversals.length; i++)
			traversals[i].accept(visitor);
	}

	/**
	 * Return whether this resource mapping contains all the resources
	 * of the given mapping.
	 * <p>
	 * This method always returns <code>false</code> when the given resource 
	 * mapping's model provider id does not match that the of the receiver.
	 * </p>
	 * 
	 * @param mapping the given resource mapping
	 * @return <code>true</code> if this mapping contains all the resources
	 * of the given mapping, and <code>false</code> otherwise.
	 */
	public boolean contains(ResourceMapping mapping) {
		return false;
	}

	/**
	 * Override equals to compare the model objects of the
	 * mapping in order to determine equality.
	 * @param obj the object to compare
	 * @return <code>true</code> if the receiver is equal to the
	 * given object, and <code>false</code> otherwise.
	 */
	public boolean equals(Object obj) {
		if (obj == this)
			return true;
		if (obj instanceof ResourceMapping) {
			ResourceMapping other = (ResourceMapping) obj;
			return other.getModelObject().equals(getModelObject());
		}
		return false;
	}

	/**
	 * Returns all markers of the specified type on the resources in this mapping.
	 * If <code>includeSubtypes</code> is <code>false</code>, only markers 
	 * whose type exactly matches the given type are returned.  Returns an empty 
	 * array if there are no matching markers.
	 *
	 * @param type the type of marker to consider, or <code>null</code> to indicate all types
	 * @param includeSubtypes whether or not to consider sub-types of the given type
	 * @param monitor a progress monitor, or <code>null</code> if progress
	 *    reporting is not desired
	 * @return an array of markers
	 * @exception CoreException if this method fails.
	 */
	public IMarker[] findMarkers(String type, boolean includeSubtypes, IProgressMonitor monitor) throws CoreException {
		final ResourceTraversal[] traversals = getTraversals(ResourceMappingContext.LOCAL_CONTEXT, monitor);
		ArrayList result = new ArrayList();
		for (int i = 0; i < traversals.length; i++)
			traversals[i].doFindMarkers(result, type, includeSubtypes);
		return (IMarker[]) result.toArray(new IMarker[result.size()]);
	}

	/**
	 * Returns the application model element associated with this
	 * resource mapping.
	 * 
	 * @return the application model element associated with this
	 * resource mapping.
	 */
	public abstract Object getModelObject();

	/**
	 * Return the model provider for the model object
	 * of this resource mapping. The model provider is obtained
	 * using the id returned from <code>getModelProviderId()</code>.
	 * @return the model provider
	 */
	public final ModelProvider getModelProvider() {
		try {
			return ModelProviderManager.getDefault().getModelProvider(getModelProviderId());
		} catch (CoreException e) {
			throw new IllegalStateException(e.getMessage());
		}
	}

	/**
	 * Returns the id of the model provider that generated this resource
	 * mapping.
	 * 
	 * @return the model provider id
	 */
	public abstract String getModelProviderId();

	/**
	 * Returns the projects that contain the resources that constitute this 
	 * application model.
	 * 
	 * @return the projects
	 */
	public abstract IProject[] getProjects();

	/**
	 * Returns one or more traversals that can be used to access all the
	 * physical resources that constitute the logical resource. A traversal is
	 * simply a set of resources and the depth to which they are to be
	 * traversed. This method returns an array of traversals in order to provide
	 * flexibility in describing the traversals that constitute a model element.
	 * <p>
	 * Subclasses should, when possible, include
	 * all resources that are or may be members of the model element. 
	 * For instance, a model element should return the same list of
	 * resources regardless of the existence of the files on the file system.
	 * For example, if a logical resource called "form" maps to "/p1/form.xml"
	 * and "/p1/form.java" then whether form.xml or form.java existed, they
	 * should be returned by this method.
	 *</p><p>
	 * In some cases, it may not be possible for a model element to know all the
	 * resources that may constitute the element without accessing the state of
	 * the model element in another location (e.g. a repository). This method is
	 * provided with a context which, when provided, gives access to
	 * the members of corresponding remote containers and the contents of
	 * corresponding remote files. This gives the model element the opportunity
	 * to deduce what additional resources should be included in the traversal.
	 * </p>
	 * 
	 * @param context gives access to the state of
	 *            remote resources that correspond to local resources for the
	 *            purpose of determining traversals that adequately cover the
	 *            model element resources given the state of the model element
	 *            in another location. This parameter may be <code>null</code>, in
	 *            which case the implementor can assume that only the local
	 *            resources are of interest to the client.
	 * @param monitor a progress monitor, or <code>null</code> if progress
	 *    reporting is not desired
	 * @return a set of traversals that cover the resources that constitute the
	 *         model element
	 * @exception CoreException if the traversals could not be obtained.
	 */
	public abstract ResourceTraversal[] getTraversals(ResourceMappingContext context, IProgressMonitor monitor) throws CoreException;
	
	/**
	 * Override hashCode to use the model object.
	 */
	public int hashCode() {
		return getModelObject().hashCode();
	}
}
