org.eclipse.wst.validation.internal.delegates.ValidatorDelegatesRegistry Maven / Gradle / Ivy
The newest version!
/*******************************************************************************
* 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(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> _delegatesByTarget =
new HashMap>();
/**
* Validator ids that have been defined by the product to be the default validators, for some of the delegating validtors.
*/
private Set _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 delegates = _delegatesByTarget.get(targetID);
if (delegates == null) {
delegates = new HashMap();
_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 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 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 . May be null if the ID
* passed in is not a delegating validator.
*/
public Map 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 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 delegatesByID = _delegatesByTarget.get(targetID);
boolean hasDelegates = (delegatesByID != null && !delegatesByID.isEmpty());
return hasDelegates;
}
}