/*******************************************************************************
* Copyright (c) 2001, 2008 Oracle 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:
* Oracle Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.validation.internal;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.emf.common.util.Diagnostic;
import org.eclipse.jface.preference.IPreferenceStore;
import org.eclipse.jst.jsf.common.internal.types.TypeComparatorDiagnosticFactory;
import org.eclipse.jst.jsf.common.internal.types.TypeComparatorPreferences;
import org.eclipse.jst.jsf.core.internal.IJSFPreferenceModel;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
/**
* Type comparator preferences for JSF.
*
* @author cbateman
*
*/
public class JSFTypeComparatorPreferences extends TypeComparatorPreferences
implements IJSFPreferenceModel
{
private int[] _severities;
/**
* Loads the object from the preference store provided
*
* @param prefStore
*/
public void load(IPreferenceStore prefStore)
{
loadSeverities(prefStore);
}
private void loadSeverities(final IPreferenceStore prefStore)
{
final int severities[] = getSeverities();
for (int i = 0; i < TypeComparatorDiagnosticFactory.NUM_IDS; i++)
{
final String key = getKeyById(i);
if (!prefStore.contains(key))
{
final int diagSeverity = getDefaultSeverity(i);
final Severity severity = mapDiagToSeverity(diagSeverity);
prefStore.setDefault(key, severity.toString());
}
final String storedSeverity = prefStore.getString(key);
severities[i] = mapSeverityToDiag(storedSeverity);
}
}
/**
* Copies the object into the preference store but DOES NOT SAVE IT
*
* @param prefStore
*/
public void commit(IPreferenceStore prefStore)
{
commitSeverities(prefStore);
}
private void commitSeverities(final IPreferenceStore prefStore)
{
final int severities[] = getSeverities();
for (int i = 0; i < severities.length; i++)
{
final String key = getKeyById(i);
prefStore
.setValue(key, mapDiagToSeverity(severities[i]).toString());
}
}
/**
* Reverts the model to it's defaults. Does not commit to pref store.
*/
public void setDefaults()
{
setProblemSeverityDefaults();
}
private void setProblemSeverityDefaults()
{
final int[] severities = getSeverities();
for (int i = 0; i < TypeComparatorDiagnosticFactory.NUM_IDS; i++)
{
severities[i] = getDefaultSeverity(i);
}
}
public Object getValueByKey(IScopeContext context, String key)
{
try
{
final Severity severity = getSeverity(key);
return severity.toString();
}
catch (IllegalArgumentException e)
{
// getIdByKey will throw this exception if key is not a valid
// severity key. Ignore the exception here and fall-through
}
return null; // not found
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jst.jsf.core.internal.IJSFPreferenceModel#getStoredValueByKey(org.eclipse.core.runtime.preferences.IScopeContext,
* java.lang.String)
*/
public Object getStoredValueByKey(IScopeContext context, String key)
{
try
{
return context.getNode("org.eclipse.jst.jsf.core").get( //$NON-NLS-1$
key,
mapDiagToSeverity(getDefaultSeverity(getIdByKey(key)))
.toString());
}
catch (IllegalArgumentException e)
{
// getIdByKey will throw this exception if key is not a valid
// severity key. Ignore the exception here and fall-through
}
return null; // not found
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jst.jsf.core.internal.IJSFPreferenceModel#setValueByKey(org.eclipse.core.runtime.preferences.IScopeContext,
* java.lang.String, java.lang.Object)
*/
public Object setValueByKey(IScopeContext context, String key, Object value)
{
final Severity oldValue = getSeverity(key);
setSeverity(key, (Severity) value);
return oldValue;
}
/**
* @param key
* @return the severity
*/
public Severity getSeverity(final String key)
{
final int severityDiag = _severities[getIdByKey(key)];
final Severity severity = mapDiagToSeverity(severityDiag);
return severity;
}
/**
* @param key
* @param severity
*/
public void setSeverity(final String key, final Severity severity)
{
final int newSeverityDiag = mapSeverityToDiag(severity.toString());
final int diagId = getIdByKey(key);
_severities[diagId] = newSeverityDiag;
}
/**
* @param diagnosticId
* @return the severity as configured for diagnosticId. The value is
* relative to the Diagnostic class severity scheme
*/
public final int getDiagnosticSeverity(final int diagnosticId)
{
return getSeverities()[diagnosticId];
}
private int[] getSeverities()
{
if (_severities == null)
{
_severities = new int[TypeComparatorDiagnosticFactory.NUM_IDS];
}
return _severities;
}
/**
* @param diagSeverity
* @return a Severity preference value for a diagnostic severity
*/
public static Severity mapDiagToSeverity(int diagSeverity)
{
switch (diagSeverity)
{
case Diagnostic.ERROR:
return Severity.ERROR;
case Diagnostic.WARNING:
return Severity.WARNING;
default:
return Severity.IGNORE;
}
}
/**
* @param severity
* @return a Diagnostic severity level for a severity pref string
*/
public static int mapSeverityToDiag(String severity)
{
if ("error".equals(severity)) //$NON-NLS-1$
{
return Diagnostic.ERROR;
}
else if ("warning".equals(severity)) //$NON-NLS-1$
{
return Diagnostic.WARNING;
}
else if ("ignore".equals(severity)) //$NON-NLS-1$
{
return Diagnostic.OK;
}
else
{
throw new IllegalArgumentException("Invalid enum name: " + severity); //$NON-NLS-1$
}
}
/**
* @param diagnosticId
* @return the preference key for the corresponding diagnosticId in the el
* DiagnosticFactory
*/
public static String getKeyById(final int diagnosticId)
{
switch (diagnosticId)
{
case TypeComparatorDiagnosticFactory.INCOMPATIBLE_METHOD_TYPES_ID:
return INCOMPATIBLE_METHOD_TYPES;
case TypeComparatorDiagnosticFactory.INCOMPATIBLE_TYPES_ID:
return INCOMPATIBLE_TYPES;
case TypeComparatorDiagnosticFactory.METHOD_EXPRESSION_EXPECTED_ID:
return METHOD_EXPRESSION_EXPECTED;
case TypeComparatorDiagnosticFactory.PROPERTY_NOT_READABLE_ID:
return PROPERTY_NOT_READABLE;
case TypeComparatorDiagnosticFactory.PROPERTY_NOT_WRITABLE_ID:
return PROPERTY_NOT_WRITABLE;
case TypeComparatorDiagnosticFactory.VALUE_EXPRESSION_EXPECTED_ID:
return VALUE_EXPRESSION_EXPECTED;
default:
throw new IllegalArgumentException("Diagnostic Id: " //$NON-NLS-1$
+ diagnosticId + " is out of range"); //$NON-NLS-1$
}
}
/**
* @param key
* @return the preference key for the corresponding diagnosticId in the el
* DiagnosticFactory
*/
public static int getIdByKey(final String key)
{
if (INCOMPATIBLE_METHOD_TYPES.equals(key))
{
return TypeComparatorDiagnosticFactory.INCOMPATIBLE_METHOD_TYPES_ID;
}
else if (INCOMPATIBLE_TYPES.equals(key))
{
return TypeComparatorDiagnosticFactory.INCOMPATIBLE_TYPES_ID;
}
else if (METHOD_EXPRESSION_EXPECTED.equals(key))
{
return TypeComparatorDiagnosticFactory.METHOD_EXPRESSION_EXPECTED_ID;
}
else if (PROPERTY_NOT_READABLE.equals(key))
{
return TypeComparatorDiagnosticFactory.PROPERTY_NOT_READABLE_ID;
}
else if (PROPERTY_NOT_WRITABLE.equals(key))
{
return TypeComparatorDiagnosticFactory.PROPERTY_NOT_WRITABLE_ID;
}
else if (VALUE_EXPRESSION_EXPECTED.equals(key))
{
return TypeComparatorDiagnosticFactory.VALUE_EXPRESSION_EXPECTED_ID;
}
else
{
throw new IllegalArgumentException("Severity Key: " + key); //$NON-NLS-1$
}
}
/**
* e.g. createQualifiedKeyName("foo") -> org.eclipse.jst.jsf.core.foo
*
* @param baseName
* @return a plugin qualified key given the baseName
*
*/
private static String createQualifiedKeyName(final String baseName)
{
return JSFCorePlugin.PLUGIN_ID + "." + baseName; //$NON-NLS-1$
}
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String INCOMPATIBLE_METHOD_TYPES = createQualifiedKeyName("INCOMPATIBLE_METHOD_TYPES"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String INCOMPATIBLE_TYPES = createQualifiedKeyName("INCOMPATIBLE_TYPES"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String METHOD_EXPRESSION_EXPECTED = createQualifiedKeyName("METHOD_EXPRESSION_EXPECTED"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String PROPERTY_NOT_READABLE = createQualifiedKeyName("PROPERTY_NOT_READABLE"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String PROPERTY_NOT_WRITABLE = createQualifiedKeyName("PROPERTY_NOT_WRITABLE"); //$NON-NLS-1$
/**
* preference key. Match to DiagnosticFactory constants
*/
public final static String VALUE_EXPRESSION_EXPECTED = createQualifiedKeyName("VALUE_EXPRESSION_EXPECTED"); //$NON-NLS-1$
}