plugins/org.eclipse.wst.validation/vf2/org/eclipse/wst/validation/internal/model/FilterGroup.java - webtools-common/webtools.common - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2009 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.wst.validation.internal.model;

 import java.util.LinkedList;
 import java.util.List;

 import org.eclipse.core.resources.IProject;
 import org.eclipse.core.resources.IResource;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.wst.validation.internal.ContentTypeWrapper;
 import org.eclipse.wst.validation.internal.Deserializer;
 import org.eclipse.wst.validation.internal.ExtensionConstants;
 import org.eclipse.wst.validation.internal.Serializer;
 import org.eclipse.wst.validation.internal.ValMessages;

 /**
  * An immutable group of filter rules.
  * @author karasiuk
  *
  */
 public abstract class FilterGroup implements IAdaptable {

 	private final FilterRule[] _rules;

 	/** The version number of the serialization (in case we ever need to change this) */
 	private static final int SerializationVersion = 1;

 	/**
 	 * Answer a filter group based on the type of the group.
 	 *
 	 * @param name either "include" or "exclude"
 	 *
 	 * @return null if the name parameter isn't correct.
 	 */
 	public static FilterGroup create(String name, FilterRule[] rules) {
 		if (ExtensionConstants.include.equals(name))return new FilterIncludeGroup(rules);
 		if (ExtensionConstants.exclude.equals(name))return new FilterExcludeGroup(rules);
 		return null;
 	}

 	/**
 	 * Answer a filter group from a deserializer.
 	 * @param des
 	 *
 	 * @see FilterGroup#save(Serializer)
 	 */
 	public static FilterGroup create(Deserializer des){
 		des.getInt(); // get the version
 		String type = des.getString();

 		int numberRules = des.getInt();
 		List<FilterRule> list = new LinkedList<FilterRule>();
 		for (int i=0; i<numberRules; i++)list.add(FilterRule.create(des));
 		FilterRule[] rules = new FilterRule[list.size()];
 		list.toArray(rules);

 		return create(type, rules);
 	}

 	/**
 	 * Answer a new filter group.
 	 *
 	 * @param exclude if true an exclusion group is returned, otherwise an inclusion group is returned.
 	 */
 	public static FilterGroup create(boolean exclude, FilterRule[] rules){
 		if (exclude) return new FilterExcludeGroup(rules);
 		return new FilterIncludeGroup(rules);
 	}

 	/**
 	 * Answer true if this is a supported type of group.
 	 * @param name Type of group that is being tested.
 	 * @return
 	 */
 	public static boolean isKnownName(String name) {
 		if (ExtensionConstants.include.equals(name))return true;
 		if (ExtensionConstants.exclude.equals(name))return true;
 		return false;
 	}


 	private FilterGroup(FilterRule[] rules){
 		_rules = rules;
 	}

 	/**
 	 * The rules in the group.
 	 */
 	public final FilterRule[] getRules(){
 		FilterRule[] rules = new FilterRule[_rules.length];
 		System.arraycopy(_rules, 0, rules, 0, _rules.length);
 		return rules;
 	}

 	/**
 	 * Answer the internal type of group, e.g. "include" or "exclude".
 	 */
 	public abstract String getType();

 	/** Answer the type as a type that can be displayed to a user, that is it has been localized. */
 	public abstract String getDisplayableType();

 	@SuppressWarnings("unchecked")
 	public Object getAdapter(Class adapter) {
 		return Platform.getAdapterManager().getAdapter(this, adapter);
 	}

 	public static final class FilterIncludeGroup extends FilterGroup {

 		private FilterIncludeGroup(FilterRule[] rules){
 			super(rules);
 		}

 		public String getType() {
 			return ExtensionConstants.include;
 		}

 		public String getDisplayableType() {
 			return ValMessages.GroupInclude;
 		}

 		public boolean isInclude() {
 			return true;
 		}

 	}


 	public static final class FilterExcludeGroup extends FilterGroup {

 		private FilterExcludeGroup(FilterRule[] rules){
 			super(rules);
 		}
 		public String getType() {
 			return ExtensionConstants.exclude;
 		}

 		public String getDisplayableType() {
 			return ValMessages.GroupExclude;
 		}

 		public boolean isExclude() {
 			return true;
 		}
 	}

 	/**
 	 * Save your settings into the serializer.
 	 * @param ser
 	 */
 	public void save(Serializer ser){
 		ser.put(SerializationVersion);
 		ser.put(getType());
 		ser.put(_rules.length);
 		for (FilterRule rule : _rules)rule.save(ser);
 	}

 	/**
 	 * Answer whether or not we should validate the resource based on the filters in this group.
 	 *
 	 * @param project the project that is being validated.
 	 * @param resource the resource that is being validated. This can be null, in which case
 	 * only the project level checks are performed.
 	 */
 	public boolean shouldValidate(IProject project, IResource resource, ContentTypeWrapper contentTypeWrapper) {
 		boolean exclude = isExclude();
 		boolean include = isInclude();
 		int count = 0;
 		for (FilterRule rule : _rules){
 			if (resource != null){
 				Boolean match = rule.matchesResource(resource, contentTypeWrapper);
 				if (match != null)count++;
 				if (exclude && match != null && match)return false;
 				if (include && match != null && match)return true;
 			}

 			Boolean match = rule.matchesProject(project);
 			if (match != null)count++;
 			if (exclude && match != null && match)return false;
 			if (include && match != null && match)return true;
 		}
 		if (exclude)return true;
 		if (count == 0)return true;
 		return false;
 	}

 	/**
 	 * Answer true if this is an inclusion filter, that is at least one of the rules must
 	 * match in order to validate the resource.
 	 */
 	public boolean isInclude() {
 		return false;
 	}

 	/**
 	 * Answer true if this is an exclusion filter, that is if any of the rules match the
 	 * resource is not validated.
 	 */
 	public boolean isExclude() {
 		return false;
 	}

 	public int hashCodeForConfig() {
 		int h = 0;
 		if (isExclude())h += 13;
 		for (FilterRule fr : _rules)h += fr.hashCodeForConfig();
 		return h;
 	}

 	/**
 	 * Create a new group by adding a rule to an existing group.
 	 * @param baseGroup The group that holds the existing rules.
 	 * @param rule The new rule that is being added
 	 * @return
 	 */
 	public static FilterGroup addRule(FilterGroup baseGroup, FilterRule rule) {
 		List<FilterRule> list = new LinkedList<FilterRule>();
 		for (FilterRule r : baseGroup._rules)list.add(r);
 		list.add(rule);

 		FilterRule[] rules = new FilterRule[list.size()];
 		list.toArray(rules);
 		return FilterGroup.create(baseGroup.isExclude(), rules);
 	}

 	/**
 	 * Create a new group by removing a rule from an existing group.
 	 * @param baseGroup The group that holds the existing rules.
 	 * @param rule The rule that is being removed
 	 * @return
 	 */
 	public static FilterGroup removeRule(FilterGroup baseGroup,	FilterRule rule) {
 		List<FilterRule> list = new LinkedList<FilterRule>();
 		for (FilterRule r : baseGroup._rules){
 			if (!r.equals(rule))list.add(r);
 		}

 		FilterRule[] rules = new FilterRule[list.size()];
 		list.toArray(rules);
 		return FilterGroup.create(baseGroup.isExclude(), rules);
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2005, 2009 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.wst.validation.internal.model;

	import java.util.LinkedList;
	import java.util.List;

	import org.eclipse.core.resources.IProject;
	import org.eclipse.core.resources.IResource;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.wst.validation.internal.ContentTypeWrapper;
	import org.eclipse.wst.validation.internal.Deserializer;
	import org.eclipse.wst.validation.internal.ExtensionConstants;
	import org.eclipse.wst.validation.internal.Serializer;
	import org.eclipse.wst.validation.internal.ValMessages;

	/**
	* An immutable group of filter rules.
	* @author karasiuk
	*
	*/
	public abstract class FilterGroup implements IAdaptable {

	private final FilterRule[] _rules;

	/** The version number of the serialization (in case we ever need to change this) */
	private static final int SerializationVersion = 1;

	/**
	* Answer a filter group based on the type of the group.
	*
	* @param name either "include" or "exclude"
	*
	* @return null if the name parameter isn't correct.
	*/
	public static FilterGroup create(String name, FilterRule[] rules) {
	if (ExtensionConstants.include.equals(name))return new FilterIncludeGroup(rules);
	if (ExtensionConstants.exclude.equals(name))return new FilterExcludeGroup(rules);
	return null;
	}

	/**
	* Answer a filter group from a deserializer.
	* @param des
	*
	* @see FilterGroup#save(Serializer)
	*/
	public static FilterGroup create(Deserializer des){
	des.getInt(); // get the version
	String type = des.getString();

	int numberRules = des.getInt();
	List<FilterRule> list = new LinkedList<FilterRule>();
	for (int i=0; i<numberRules; i++)list.add(FilterRule.create(des));
	FilterRule[] rules = new FilterRule[list.size()];
	list.toArray(rules);

	return create(type, rules);
	}

	/**
	* Answer a new filter group.
	*
	* @param exclude if true an exclusion group is returned, otherwise an inclusion group is returned.
	*/
	public static FilterGroup create(boolean exclude, FilterRule[] rules){
	if (exclude) return new FilterExcludeGroup(rules);
	return new FilterIncludeGroup(rules);
	}

	/**
	* Answer true if this is a supported type of group.
	* @param name Type of group that is being tested.
	* @return
	*/
	public static boolean isKnownName(String name) {
	if (ExtensionConstants.include.equals(name))return true;
	if (ExtensionConstants.exclude.equals(name))return true;
	return false;
	}


	private FilterGroup(FilterRule[] rules){
	_rules = rules;
	}

	/**
	* The rules in the group.
	*/
	public final FilterRule[] getRules(){
	FilterRule[] rules = new FilterRule[_rules.length];
	System.arraycopy(_rules, 0, rules, 0, _rules.length);
	return rules;
	}

	/**
	* Answer the internal type of group, e.g. "include" or "exclude".
	*/
	public abstract String getType();

	/** Answer the type as a type that can be displayed to a user, that is it has been localized. */
	public abstract String getDisplayableType();

	@SuppressWarnings("unchecked")
	public Object getAdapter(Class adapter) {
	return Platform.getAdapterManager().getAdapter(this, adapter);
	}

	public static final class FilterIncludeGroup extends FilterGroup {

	private FilterIncludeGroup(FilterRule[] rules){
	super(rules);
	}

	public String getType() {
	return ExtensionConstants.include;
	}

	public String getDisplayableType() {
	return ValMessages.GroupInclude;
	}

	public boolean isInclude() {
	return true;
	}

	}


	public static final class FilterExcludeGroup extends FilterGroup {

	private FilterExcludeGroup(FilterRule[] rules){
	super(rules);
	}
	public String getType() {
	return ExtensionConstants.exclude;
	}

	public String getDisplayableType() {
	return ValMessages.GroupExclude;
	}

	public boolean isExclude() {
	return true;
	}
	}

	/**
	* Save your settings into the serializer.
	* @param ser
	*/
	public void save(Serializer ser){
	ser.put(SerializationVersion);
	ser.put(getType());
	ser.put(_rules.length);
	for (FilterRule rule : _rules)rule.save(ser);
	}

	/**
	* Answer whether or not we should validate the resource based on the filters in this group.
	*
	* @param project the project that is being validated.
	* @param resource the resource that is being validated. This can be null, in which case
	* only the project level checks are performed.
	*/
	public boolean shouldValidate(IProject project, IResource resource, ContentTypeWrapper contentTypeWrapper) {
	boolean exclude = isExclude();
	boolean include = isInclude();
	int count = 0;
	for (FilterRule rule : _rules){
	if (resource != null){
	Boolean match = rule.matchesResource(resource, contentTypeWrapper);
	if (match != null)count++;
	if (exclude && match != null && match)return false;
	if (include && match != null && match)return true;
	}

	Boolean match = rule.matchesProject(project);
	if (match != null)count++;
	if (exclude && match != null && match)return false;
	if (include && match != null && match)return true;
	}
	if (exclude)return true;
	if (count == 0)return true;
	return false;
	}

	/**
	* Answer true if this is an inclusion filter, that is at least one of the rules must
	* match in order to validate the resource.
	*/
	public boolean isInclude() {
	return false;
	}

	/**
	* Answer true if this is an exclusion filter, that is if any of the rules match the
	* resource is not validated.
	*/
	public boolean isExclude() {
	return false;
	}

	public int hashCodeForConfig() {
	int h = 0;
	if (isExclude())h += 13;
	for (FilterRule fr : _rules)h += fr.hashCodeForConfig();
	return h;
	}

	/**
	* Create a new group by adding a rule to an existing group.
	* @param baseGroup The group that holds the existing rules.
	* @param rule The new rule that is being added
	* @return
	*/
	public static FilterGroup addRule(FilterGroup baseGroup, FilterRule rule) {
	List<FilterRule> list = new LinkedList<FilterRule>();
	for (FilterRule r : baseGroup._rules)list.add(r);
	list.add(rule);

	FilterRule[] rules = new FilterRule[list.size()];
	list.toArray(rules);
	return FilterGroup.create(baseGroup.isExclude(), rules);
	}

	/**
	* Create a new group by removing a rule from an existing group.
	* @param baseGroup The group that holds the existing rules.
	* @param rule The rule that is being removed
	* @return
	*/
	public static FilterGroup removeRule(FilterGroup baseGroup, FilterRule rule) {
	List<FilterRule> list = new LinkedList<FilterRule>();
	for (FilterRule r : baseGroup._rules){
	if (!r.equals(rule))list.add(r);
	}

	FilterRule[] rules = new FilterRule[list.size()];
	list.toArray(rules);
	return FilterGroup.create(baseGroup.isExclude(), rules);
	}

	}