org.springframework.shell.core.Converter Java Examples

@SuppressWarnings("rawtypes")
public void afterPropertiesSet() {

  Map<String, CommandMarker> commands = BeanFactoryUtils.beansOfTypeIncludingAncestors(
          applicationContext, CommandMarker.class);
  for (CommandMarker command : commands.values()) {
    getSimpleParser().add(command);
  }

  Map<String, Converter> converters = BeanFactoryUtils.beansOfTypeIncludingAncestors(
          applicationContext, Converter.class);
  for (Converter<?> converter : converters.values()) {
    getSimpleParser().add(converter);
  }
  
  setHistorySize(commandLine.getHistorySize());
  if (commandLine.getShellCommandsToExecute() != null) {
    setPrintBanner(false);
  }
}
 

/**
 * Looks for a matching {@link Converter}
 * 
 * @param parameterType
 * @param context
 * @return {@link Converter}
 */
public Converter<?> getConverter(Class<?> parameterType, String context) {
  for (Converter<?> converter : converters) {
    if (converter.supports(parameterType, context)) {
      return converter;
    }
  }
  return null;
}
 

/**
 * Looks for a matching {@link Converter}
 * 
 * @param parameterType
 * @param context
 * @return {@link Converter}
 */
public Converter<?> getConverter(Class<?> parameterType, String context) {
  for (Converter<?> converter : converters) {
    if (converter.supports(parameterType, context)) {
      return converter;
    }
  }
  return null;
}
 

@Bean
Converter localeConverter() {
  return new LocaleConverter();
}
 

@Bean
Converter booleanConverter() {
  return new BooleanConverter();
}
 

@Bean
Converter characterConverter() {
  return new CharacterConverter();
}
 

@Bean
Converter dateConverter() {
  return new DateConverter();
}
 

@Bean
Converter doubleConverter() {
  return new DoubleConverter();
}
 

@Bean
Converter enumConverter() {
  return new EnumConverter();
}
 

@Bean
Converter floatConverter() {
  return new FloatConverter();
}
 

@Bean
Converter integerConverter() {
  return new IntegerConverter();
}
 

@Bean
Converter availableCommandsConverter() {
  return new AvailableCommandsConverter();
}
 

@Bean
Converter longConverter() {
  return new LongConverter();
}
 

@Bean
Converter shortConverter() {
  return new ShortConverter();
}
 

@Bean
Converter staticFieldConverterImpl() {
  return new StaticFieldConverterImpl();
}
 

@Bean
Converter blueprintConverter() {
  return new BlueprintConverter(client);
}
 

@Bean
Converter hostConverter() {
  return new HostConverter(client);
}
 

@Bean
Converter serviceConverter() {
  return new ServiceConverter(client);
}
 

@Bean
Converter configConverter() {
  return new ConfigTypeConverter(client);
}
 

@Bean
Converter bigIntegerConverter() {
  return new BigIntegerConverter();
}
 

@Bean
Converter bigDecimalConverter() {
  return new BigDecimalConverter();
}
 

public Converter<?> getConverter() {
  return converter;
}
 

@Bean
Converter stringConverter() {
  return new StringConverter();
}
 

@Bean
Converter simpleFileConverter() {
  return new SimpleFileConverter();
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
private Object getConversionObject(Converter<?> converter, String string,
    Class<?> dataType, String context, String valueSeparator) {

  try {
    if (converter != null && converter instanceof MultipleValueConverter) {
        return ((MultipleValueConverter) converter).convertFromText(
            ParserUtils.splitValues(
                ((string != null) ? string.trim() : null),
                valueSeparator), dataType, context);
    }

    // Remove outer single or double quotes if found
    if (string != null && ((string.endsWith("\"") && string.endsWith("\""))
        || (string.startsWith("\'") && string.endsWith("\'")))) {
      string = string.substring(1, string.length() - 1);
    }

    if (converter != null) {
    return converter.convertFromText((string != null) ? string.trim()
        : null, dataType, context);
    }

    //TODO consider multiple value case for primitives
    if (string != null) {
      if (String.class.isAssignableFrom(dataType)) {
        return string.trim();
      } else if (Byte.class.isAssignableFrom(dataType)
          || byte.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Short.class.isAssignableFrom(dataType)
          || short.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Boolean.class.isAssignableFrom(dataType)
          || boolean.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Integer.class.isAssignableFrom(dataType)
          || int.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Long.class.isAssignableFrom(dataType)
          || long.class.isAssignableFrom(dataType)) {
        return Long.parseLong(string);
      } else if (Float.class.isAssignableFrom(dataType)
          || float.class.isAssignableFrom(dataType)) {
        return Float.parseFloat(string);
      } else if (Double.class.isAssignableFrom(dataType)
          || double.class.isAssignableFrom(dataType)) {
        return Double.parseDouble(string);
      } else if (Character.class.isAssignableFrom(dataType)
          || char.class.isAssignableFrom(dataType)) {
        if (string.length() == 1) {
          string.charAt(0);
        } else {
          // FIXME Use a constant here
          return '0';
        }
      }
    }
  } catch (Exception e) {
    // TODO add logging
    // Do nothing, just return null
  }
  return null;
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
private boolean getAllPossibleValuesForParameter(
    List<Completion> completionCandidates, Parameter parameter,
    String existingData, GfshMethodTarget gfshMethodTarget) {
  Converter<?> converter = parameter.getConverter();
  // Check if any new converter is available which
  // satisfies the requirements for this argument
  if (converter == null) {
    parameter.setConverter(commandManager.getConverter(
        parameter.getDataType(), parameter.getContext()));
    converter = parameter.getConverter();
  }
  // If still we do not have any matching converters, we return
  if (converter == null) {
    return false;
  } else {
    // Now pass the getAllPossibleValues function of Converter interface
    // all the required parameters

    // Check whether it is a MultipleValueConverter
    String valueSeparator = SyntaxConstants.VALUE_SEPARATOR;
    if (parameter instanceof Option && ((Option) parameter).getValueSeparator() != null) {
      valueSeparator = ((Option) parameter).getValueSeparator();
    }
    if (converter instanceof MultipleValueConverter) {
      ((MultipleValueConverter) converter).getAllPossibleValues(
          completionCandidates,
          parameter.getDataType(),
          ParserUtils.splitValues(existingData, valueSeparator),
          parameter.getContext(),
          new MethodTarget(gfshMethodTarget.getMethod(), gfshMethodTarget
              .getTarget(), gfshMethodTarget.getRemainingBuffer(),
              gfshMethodTarget.getKey()));
    } else {
      converter.getAllPossibleValues(
          completionCandidates,
          parameter.getDataType(),
          existingData,
          parameter.getContext(),
          new MethodTarget(gfshMethodTarget.getMethod(), gfshMethodTarget
              .getTarget(), gfshMethodTarget.getRemainingBuffer(),
              gfshMethodTarget.getKey()));
    }
  }
  if (completionCandidates.size() > 0) {
    return true;
  } else {
    return false;
  }
}
 

public void add(final Converter<?> converter) {
  commandManager.add(converter);
}
 

public void setConverter(Converter<?> converter) {
  this.converter = converter;
}
 

public Converter<?> getConverter() {
  return converter;
}
 

@SuppressWarnings({ "rawtypes", "unchecked" })
private Object getConversionObject(Converter<?> converter, String string,
    Class<?> dataType, String context, String valueSeparator) {

  try {
    if (converter != null && converter instanceof MultipleValueConverter) {
        return ((MultipleValueConverter) converter).convertFromText(
            ParserUtils.splitValues(
                ((string != null) ? string.trim() : null),
                valueSeparator), dataType, context);
    }

    // Remove outer single or double quotes if found
    if (string != null && ((string.endsWith("\"") && string.endsWith("\""))
        || (string.startsWith("\'") && string.endsWith("\'")))) {
      string = string.substring(1, string.length() - 1);
    }

    if (converter != null) {
    return converter.convertFromText((string != null) ? string.trim()
        : null, dataType, context);
    }

    //TODO consider multiple value case for primitives
    if (string != null) {
      if (String.class.isAssignableFrom(dataType)) {
        return string.trim();
      } else if (Byte.class.isAssignableFrom(dataType)
          || byte.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Short.class.isAssignableFrom(dataType)
          || short.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Boolean.class.isAssignableFrom(dataType)
          || boolean.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Integer.class.isAssignableFrom(dataType)
          || int.class.isAssignableFrom(dataType)) {
        return Integer.parseInt(string);
      } else if (Long.class.isAssignableFrom(dataType)
          || long.class.isAssignableFrom(dataType)) {
        return Long.parseLong(string);
      } else if (Float.class.isAssignableFrom(dataType)
          || float.class.isAssignableFrom(dataType)) {
        return Float.parseFloat(string);
      } else if (Double.class.isAssignableFrom(dataType)
          || double.class.isAssignableFrom(dataType)) {
        return Double.parseDouble(string);
      } else if (Character.class.isAssignableFrom(dataType)
          || char.class.isAssignableFrom(dataType)) {
        if (string.length() == 1) {
          string.charAt(0);
        } else {
          // FIXME Use a constant here
          return '0';
        }
      }
    }
  } catch (Exception e) {
    // TODO add logging
    // Do nothing, just return null
  }
  return null;
}