import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public static Parameterization createParameter( Command command,
		String parameterId, Object value ) throws NotDefinedException,
		ExecutionException, ParameterValueConversionException
{
	ParameterType parameterType = command.getParameterType( parameterId );
	if ( parameterType == null )
	{
		throw new ExecutionException( "Command does not have a parameter type for the given parameter" ); //$NON-NLS-1$
	}

	IParameter param = command.getParameter( parameterId );
	AbstractParameterValueConverter valueConverter = parameterType.getValueConverter( );
	if ( valueConverter == null )
	{
		throw new ExecutionException( "Command does not have a value converter" ); //$NON-NLS-1$
	}

	String valueString = valueConverter.convertToString( value );
	Parameterization parm = new Parameterization( param, valueString );
	return parm;
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
@Override
public String convertToString ( final Object parameterValue ) throws ParameterValueConversionException
{
    if ( parameterValue instanceof Map )
    {
        final Gson gson = this.builder.create ();
        return gson.toJson ( parameterValue );
    }
    throw new ParameterValueConversionException ( "Unable to convert type " + parameterValue.getClass () );
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public Object convertToObject( String parameterValue )
		throws ParameterValueConversionException
{
	String elementId = parameterValue.substring( 0,
			parameterValue.indexOf( "#" ) ); //$NON-NLS-1$
	String slotId = parameterValue.substring( parameterValue.indexOf( "#" ) + 1, //$NON-NLS-1$
			parameterValue.length( ) );
	return SessionHandleAdapter.getInstance( )
			.getReportDesignHandle( )
			.getElementByID( Long.parseLong( elementId ) )
			.getSlot( Integer.parseInt( slotId ) );
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public String convertToString( Object parameterValue )
		throws ParameterValueConversionException
{

	return ( (SlotHandle) parameterValue ).getElement( ).getID( )
			+ "#" //$NON-NLS-1$
			+ ( (SlotHandle) parameterValue ).getSlotID( );
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public static Object executeCommand( String commandId, Map paramMap )
		throws NotDefinedException, ExecutionException,
		ParameterValueConversionException, NotEnabledException,
		NotHandledException
{
	Command cmd = CommandUtils.getCommand( commandId );
	List paramList = new ArrayList( );
	if ( paramMap != null )
	{
		for ( Iterator iter = paramMap.entrySet( ).iterator( ); iter.hasNext( ); )
		{
			Map.Entry entry = (Entry) iter.next( );
			String paramId = entry.getKey( ).toString( );
			Object value = entry.getValue( );
			if ( value != null )
			{
				paramList.add( createParameter( cmd, paramId, value ) );
			}
		}
	}
	if ( paramList.size( ) > 0 )
	{
		ParameterizedCommand paramCommand = new ParameterizedCommand( cmd,
				(Parameterization[]) paramList.toArray( new Parameterization[paramList.size( )] ) );

		return getHandlerService( ).executeCommand( paramCommand, null );
	}
	else
	{
		return getHandlerService( ).executeCommand( commandId, null );
	}
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public String convertToString( Object parameterValue )
		throws ParameterValueConversionException
{
	String retString = ""; //$NON-NLS-1$
	Integer integer = (Integer)parameterValue;
	retString = integer.toString();
	return retString;
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
/**
 * @see org.eclipse.core.commands.AbstractParameterValueConverter#convertToObject(java.lang.String)
 */
@Override
public Object convertToObject(String parameterValue) throws ParameterValueConversionException {
	Integer result = null;
	try {
		result = new Integer(parameterValue);
	} catch (NumberFormatException e) {
		result = new Integer(1);
	}
	return result;
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
/**
 * @see org.eclipse.core.commands.AbstractParameterValueConverter#convertToString(java.lang.Object)
 */
@Override
public String convertToString(Object parameterValue) throws ParameterValueConversionException {
	String result = "1";	//$NON-NLS-1$ // default to 1 execution
	if (parameterValue instanceof Integer) {
		result = ((Integer)parameterValue).toString();
	} else if (parameterValue instanceof String) {
		result = (String)parameterValue;
	}
	return result;
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
/**
 * @see org.eclipse.core.commands.AbstractParameterValueConverter#convertToString(java.lang.Object)
 */
@Override
public String convertToString(Object parameterValue) throws ParameterValueConversionException {
	String result = EmacsPlusUtils.EMPTY_STR;
	if (parameterValue != null) {
		result = parameterValue.toString();
	}
	return result;
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
@Override
public String convertToString(Object parameterValue) throws ParameterValueConversionException{
	if (parameterValue instanceof Tree) {
		String ret = StringTool.unique(getClass().getName());
		map.put(ret, (Tree<?>) parameterValue);
		return ret;
	}
	throw new ParameterValueConversionException("Parameter was not instance of Tree");
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
@Override
public Object convertToObject ( final String parameterValue ) throws ParameterValueConversionException
{
    final Gson gson = this.builder.create ();
    return gson.fromJson ( parameterValue, new TypeToken<Map<String, String>> () {}.getType () );
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
@Override
public String convertToString(Object parameterValue) throws ParameterValueConversionException {

	if (!(parameterValue instanceof IJavaElement)) {
		throw new ParameterValueConversionException("parameterValue must be an IJavaElement"); //$NON-NLS-1$
	}

	IJavaElement javaElement= (IJavaElement) parameterValue;

	IJavaProject javaProject= javaElement.getJavaProject();
	if (javaProject == null) {
		throw new ParameterValueConversionException("Could not get IJavaProject for element"); //$NON-NLS-1$
	}

	StringBuffer buffer;

	if (javaElement instanceof IType) {
		IType type= (IType) javaElement;
		buffer= composeTypeReference(type);
	} else
		if (javaElement instanceof IMethod) {
			IMethod method= (IMethod) javaElement;
			buffer= composeTypeReference(method.getDeclaringType());
			buffer.append(TYPE_END_CHAR);
			buffer.append(method.getElementName());
			String[] parameterTypes= method.getParameterTypes();
			buffer.append(PARAM_START_CHAR);
			for (int i= 0; i < parameterTypes.length; i++) {
				buffer.append(parameterTypes[i]);
			}
			buffer.append(PARAM_END_CHAR);
		} else
			if (javaElement instanceof IField) {
				IField field= (IField) javaElement;
				buffer= composeTypeReference(field.getDeclaringType());
				buffer.append(TYPE_END_CHAR);
				buffer.append(field.getElementName());
			} else {
				throw new ParameterValueConversionException("Unsupported IJavaElement type"); //$NON-NLS-1$
			}

	return buffer.toString();
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public Object convertToObject( String parameterValue )
		throws ParameterValueConversionException
{
	return new Integer(parameterValue);
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public Object convertToObject( String parameterValue )
		throws ParameterValueConversionException
{
	return parameterValue;
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public String convertToString( Object parameterValue )
		throws ParameterValueConversionException
{
	return parameterValue != null ? parameterValue.toString( ) : ""; //$NON-NLS-1$
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public Object convertToObject( String parameterValue )
		throws ParameterValueConversionException
{
	return Boolean.valueOf( parameterValue );
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
public String convertToString( Object parameterValue )
		throws ParameterValueConversionException
{
	boolean value = ((Boolean)parameterValue).booleanValue( );
	return Boolean.toString( value );
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
/**
 * @see org.eclipse.core.commands.AbstractParameterValueConverter#convertToObject(java.lang.String)
 */
@Override
public Object convertToObject(String parameterValue) throws ParameterValueConversionException {
	return parameterValue;
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
/**
 * @see org.eclipse.core.commands.AbstractParameterValueConverter#convertToObject(java.lang.String)
 */
@Override
public Object convertToObject(String parameterValue) throws ParameterValueConversionException {
	return Boolean.valueOf(parameterValue);
}
 

import org.eclipse.core.commands.ParameterValueConversionException; //导入依赖的package包/类
/**
 * @see org.eclipse.core.commands.AbstractParameterValueConverter#convertToString(java.lang.Object)
 */
@Override
public String convertToString(Object parameterValue) throws ParameterValueConversionException {
	return parameterValue.toString(); 
}