plugins/org.eclipse.wst.validation/validate/org/eclipse/wst/validation/internal/delegates/ValidatorDelegatesRegistry.java

/*******************************************************************************
 * Copyright (c) 2008 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.delegates;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;

import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.wst.validation.internal.ConfigurationConstants;
import org.eclipse.wst.validation.internal.core.ValidationException;
import org.eclipse.wst.validation.internal.plugin.ValidationPlugin;
import org.eclipse.wst.validation.internal.provisional.core.IValidator;

/**
 * ValidatorDelegatesRegistry is a singleton used to store validator delegate
 * descriptors for each delegating validator.
 */
public class ValidatorDelegatesRegistry {
	
  /**
   * The one and only instance of this registry.
   */
  private static ValidatorDelegatesRegistry _instance;

  /**
   * Provides the one and only instance of this class.
   * 
   * The actual platform extension registry reading happens at this time.
   * 
   * @see ValidatorDelegatesRegistryReader
   * 
   * @return the validator delegates registry singleton instance.
   */
  public static ValidatorDelegatesRegistry getInstance() {
    if (_instance == null) {
    	ValidatorDelegatesRegistry instance = new ValidatorDelegatesRegistry();
    	ValidatorDelegatesRegistryReader reader = new ValidatorDelegatesRegistryReader(instance);
    	reader.readRegistry();
    	instance.initDefaults();
    	_instance = instance;
    }

    return _instance;
  }

  /**
   * Determine if the product defined any default delegate validators, by setting the old
   * DELEGATES_PREFERENCE preference in the default preference scope. If they did, we remember
   * them, so that if we every need to return a default for the delegating validator, we can return the one
   * that the product requested.
   */
  private void initDefaults() {
	  	// This code was copied from the ValidationConfiguration#deserializeDelegates() method. The code was copied because this
	  	// change is part of a patch and I didn't want to disturb the ValidationConfiguration class.
	  
		IEclipsePreferences prefs = new DefaultScope().getNode(ValidationPlugin.PLUGIN_ID);
		String delegatePref = prefs.get("DELEGATES_PREFERENCE", null); //$NON-NLS-1$
		if (delegatePref == null)return;

		int delegatesIndex = delegatePref.indexOf(ConfigurationConstants.DELEGATE_VALIDATORS);
		String delegates = delegatePref.substring(delegatesIndex + ConfigurationConstants.DELEGATE_VALIDATORS.length(), delegatePref.length());

		if (delegates == null)return;

		_defaultDelegates = new HashSet<String>(10);
		StringTokenizer tokenizer = new StringTokenizer(delegates, ConfigurationConstants.ELEMENT_SEPARATOR);
		while (tokenizer.hasMoreTokens()) {
			String delegateConfiguration = tokenizer.nextToken();
			int separatorIndex = delegateConfiguration.indexOf(ConfigurationConstants.DELEGATES_SEPARATOR);
//			String targetID = delegateConfiguration.substring(0, separatorIndex);
			String delegateID = delegateConfiguration.substring(separatorIndex + 1);
			_defaultDelegates.add(delegateID);
		}

	}

/**
   * The map of target validator id to Map of delegates by id.
   */
  private Map<String, Map<String,ValidatorDelegateDescriptor>> _delegatesByTarget = 
	  new HashMap<String, Map<String,ValidatorDelegateDescriptor>>();
  
  /**
   * Validator ids that have been defined by the product to be the default validators, for some of the delegating validtors.
   */
  private Set<String> _defaultDelegates;

  /**
   * Adds a descriptor to the registry.
   * 
   * @param descriptor
   *          The descriptor to add. Must not be null.
   */
  void add(ValidatorDelegateDescriptor descriptor) {
    if (descriptor == null)return;

    String targetID = descriptor.getTargetID();

    Map<String,ValidatorDelegateDescriptor> delegates = _delegatesByTarget.get(targetID);

    if (delegates == null) {
      delegates = new HashMap<String,ValidatorDelegateDescriptor>();
      _delegatesByTarget.put(targetID, delegates);
    }

    delegates.put(descriptor.getId(), descriptor);
  }

  /**
   * Provides the default delegate ID for the given delegating validator ID.
   * 
   * @param targetID
   *          The delegating validator's ID.
   * @return a String with the ID of the default delegate.
   */
  public String getDefaultDelegate(String targetID)
  {
    Map<String,ValidatorDelegateDescriptor> delegates = getDelegateDescriptors(targetID);

    if (delegates == null)return null;

    if (_defaultDelegates != null){
    	for (ValidatorDelegateDescriptor vdd : delegates.values()){
    		String id = vdd.getId();
    		if (_defaultDelegates.contains(id))return id;
    	}
    }
    
    // TODO: Implement a default attribute and use that to get the default?
    // What happens if two or more delegates claim to be the default one?
    // For now, just pick the first one in the list.

    Iterator<ValidatorDelegateDescriptor> delegatesIterator = delegates.values().iterator();
    
    if (!delegatesIterator.hasNext())return null;

    return delegatesIterator.next().getId();
  }

  /**
   * Retrieves a delegate instance based on the target and delegate IDs.
   * 
   * @param targetID
   *          the delegating validator's ID.
   * @param delegateID
   *          the delegate validator's ID.
   * @return an instance of the delegate validator or null if one cannot be
   *         found.
   */
  public IValidator getDelegate(String targetID, String delegateID) throws ValidationException
  {
    ValidatorDelegateDescriptor descriptor = getDescriptor(targetID, delegateID);

    if (descriptor == null)return null;

    IValidator delegate = descriptor.getValidator();

    return delegate;
  }

  /**
   * Provides a map with all delegates descriptors for the given target, keyed
   * by their ID.
   * 
   * @param targetID
   *          the target (delegating) validator id. Must not be null.
   * @return a Map <string, ValidatorDelegateDescriptor>. May be null if the ID
   *         passed in is not a delegating validator.
   */
  public Map<String,ValidatorDelegateDescriptor> getDelegateDescriptors(String targetID) {
    return _delegatesByTarget.get(targetID);
  }

  /**
   * Finds a delegate descriptor based on the target id and delegate id.
   * 
   * @param targetID
   *          the delegating validator's id
   * @param delegateID
   *          the delegate id
   * @return a ValidatorDelegateDescriptor for the given target and id or null
   *         if one cannot be found.
   */
  public ValidatorDelegateDescriptor getDescriptor(String targetID, String delegateID)
  {
    Map<String,ValidatorDelegateDescriptor> delegates = _delegatesByTarget.get(targetID);

    if (delegates == null || delegateID == null)return null;
    
    ValidatorDelegateDescriptor descriptor = (ValidatorDelegateDescriptor) delegates.get(delegateID);

    return descriptor;
  }

  /**
   * Determines if a given validator has delegates.
   * 
   * @param targetID
   *          the target validator id.
   * @return true if the target has registered delegates, false otherwise.
   */
  public boolean hasDelegates(String targetID)
  {
    Map<String,ValidatorDelegateDescriptor> delegatesByID = _delegatesByTarget.get(targetID);

    boolean hasDelegates = (delegatesByID != null && !delegatesByID.isEmpty());
    return hasDelegates;
  }
}