Retrieves a new instance of the converter necessary to convert the give input format to the given output format.

@throws ConverterNotFoundException
420181
public function get(string $input_format, string $output_format): ConverterInterface
    {
        $definition = $this->definition_factory->get($input_format, $output_format);

        foreach ($this->converters as $class => $formats) {
            if ([$input_format, $output_format] === $formats) {
                $assets = new Metadata\Assets();
                $assets->setLogger($this->logger);

                $toc = new Metadata\TableOfContents();
                $glossary = new Metadata\Glossary();

                /** @var ConverterInterface $converter */
                $converter = new $class($definition, $assets, $toc, $glossary);
                $converter->setLogger($this->logger);

                return $converter;
            }
        }

        throw new ConverterNotFoundException(
            'No converter could be found to convert from ' . $input_format . ' to ' . $output_format
        );
    }
127106
@SuppressWarnings("unchecked")
    static StyleConverter<?, Number[]> SizeConverter_SequenceConverter_getInstance() {
        try {
            if (mSizeConverter_SequenceConverter_getInstance == null) {
                Class<?> c = Class.forName(isJava9orLater
                        ? "javafx.css.converter.SizeConverter$SequenceConverter"
                        : "com.sun.javafx.css.converters.SizeConverter$SequenceConverter");
                mSizeConverter_SequenceConverter_getInstance = c.getMethod("getInstance");
            }
            return (StyleConverter<?, Number[]>) mSizeConverter_SequenceConverter_getInstance.invoke(null);
        } catch (ClassNotFoundException | NoSuchMethodException | SecurityException |
                IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
            e.printStackTrace();
            throw new Error(e);
        }
    }
652602
@Trivial
    public static <K> UserConverter<K> newInstance(Type type, Converter<K> converter) {
        return newInstance(type, getPriority(converter), converter);
    }
487612
public Converter getConverter() {

        if (this.converter != null) {
            return (this.converter);
        }
        return (Converter) getStateHelper().eval(PropertyKeys.converter);

    }
400835
@Override
    public InputStream getInputStream() throws IOException {
        try {
            InputStream result = entry.adapt(InputStream.class);
            if (result == null) {
                throw new IOException("The entry did not supply an input stream: " + entry);
            }
            return result;
        } catch (UnableToAdaptException e) {
            throw new IOException("Unable to get input stream for entry: " + entry.getPath() + '/' + entry.getName(), e);
        }
    }
23544
@Override
	public OUTPUT newInstance(Map<String, INPUT> inputMap) throws FAILURE {
		
		StringBuilder builder = new StringBuilder()
		.append(getClass().getName())
		.append(".newInstance(Map<String, Input>) is unsupported.");
		
		throw new UnsupportedOperationException(builder.toString());
	}
894714
private TransformerFactory getTransformerFactory()
        throws MojoFailureException, MojoExecutionException
    {
        if ( transformerFactory == null )
        {
            return TransformerFactory.newInstance();
        }

        try
        {
            return newTransformerFactory( transformerFactory, Thread.currentThread().getContextClassLoader() );
        }
        catch ( NoSuchMethodException exception )
        {
            throw new MojoFailureException( "JDK6 required when using transformerFactory parameter" );
        }
        catch ( IllegalAccessException exception )
        {
            throw new MojoExecutionException( "Cannot instantiate transformer factory", exception );
        }
        catch ( InvocationTargetException exception )
        {
            throw new MojoExecutionException( "Cannot instantiate transformer factory", exception );
        }
    }
742439
@SuppressWarnings("unchecked")
    private <T> TypedStringConverter<T> findAnyConverter(final Class<T> cls) {
        // check factories
        for (StringConverterFactory factory : factories) {
            StringConverter<T> factoryConv = (StringConverter<T>) factory.findConverter(cls);
            if (factoryConv != null) {
                return TypedAdapter.adapt(cls, factoryConv);
            }
        }
        return null;
    }
1194832
public static <T> InputReader getInstance(T input) throws IOException
    {
        return getInstance(input, -1, UTF_8, NO_FEATURES);
    }
469648
public <FT> CsvProcessor<T> withConverter(Class<FT> clazz, Converter<FT, ?> converter) {
		converterMap.put(clazz, converter);
		return this;
	}
184066
@SuppressWarnings("unchecked")
  public Class<? extends OutputFormat<?,?>> getOutputFormatClass() 
     throws ClassNotFoundException {
    return (Class<? extends OutputFormat<?,?>>) 
      conf.getClass(OUTPUT_FORMAT_CLASS_ATTR, TextOutputFormat.class);
  }
993243
public static ISonarConverter getConverterInstance() {

        if (converterInstance == null) {

            synchronized (DefaultSonarConverter.class) {

                if (converterInstance == null)
                    converterInstance = new DefaultSonarConverter();
            }
        }

        return converterInstance;
    }
727393
public final <S, T> void registerConverter(Class<S> input, Class<T> output, Converter<S, T> converter) {
        Class<? extends Annotation> scope = matchImplementationToScope(converter.getClass());
        registerConverter(new ConverterKey<S,T>(input, output, scope == null ? DefaultBinding.class : scope), converter);
    }
410749
def converter_options(inputformat ="", outputformat = "")
      response = @conversion_connection.get "conversiontypes", {:inputformat => inputformat,:outputformat => outputformat }
      parse_response(response.body)
    end
1324594
def converter(type_name):
    """"""
    converter = TYPES.get(type_name)
    if converter is None:
        raise ConverterError('Unknown converter: %r' % type_name)
    return converter()
106870
protected final CnvBnRsToDouble<RS>
    createPutCnvBnRsToDouble() throws Exception {
    CnvBnRsToDouble<RS> convrt = new CnvBnRsToDouble<RS>();
    //assigning fully initialized object:
    this.convertersMap
      .put(CnvBnRsToDouble.class.getSimpleName(), convrt);
    return convrt;
  }
975187
public static <T> InputReader getInstance(T input, int size, Set<ParserFeature> features) throws IOException
    {
        return getInstance(input, size, UTF_8, features);
    }