anchor.diff:  [[TypeConverter-WritingyourownTypeConverters]]
   ==== Writing your own Type Converters
   
  -[NOTE]
  -====
  -*Use FQN*
  -
  -In Camel 2.8 the TypeConverter file now supports specifying the FQN
  -class name. This is recommended to be used. See below for more details.
  -Using FQN must be used. The older way with just package name is
  -deprecated and should not be used, and it may also not work in some
  -application servers due to classpath scanning issues.
  -====
  - 
  -
   You are welcome to write your own converters. Remember to use the
  -`@Converter` annotations on the classes and methods you wish to use. Then
  -add the packages to a file called
  -`META-INF/services/org/apache/camel/TypeConverter` in your jar. Remember
  -to make sure that :
  +`@Converter` annotations on the classes and methods you wish to use.
  +And on the top-level class add `Converter(loader = true)` to support the _fast way_
  +of using type converters.
   
   * static methods are encouraged to reduce caching, but instance methods
   are fine, particularly if you want to allow optional dependency
   injection to customize the converter
   * converter methods should be thread safe and reentrant
   
  -[[TypeConverter-ExamplesofTypeConverterfile]]
  -===== Examples of TypeConverter file
  -
  -The file in the JAR: `META-INF/services/org/apache/camel/TypeConverter`
  -contains the following line(s):
  -
  -----
  -com.foo com.bar
  -----
  -
  -Each line in the file is a package name. This tells Camel to go scan
  -those packages for any classes that has been annotated with the
  -`@Converter`.
  -
  -[[TypeConverter-ImprovedTypeConverterbyusingFQNclassnames]]
  -===== Improved TypeConverter by using FQN class names
  -
  -*Available as of Camel 2.8*
  -
  -In Camel 2.8 we improved the type converter loader to support specifying
  -the FQN class name of the converter classes. This has the advantage of
  -avoiding having to scan packages for `@Converter` classes. Instead it
  -loads the `@Converter` class directly. This is a *highly* recommend
  -approach to use going forward.
  -
  -[[TypeConverter-ExamplesofTypeConverterfile.1]]
  -===== Examples of TypeConverter file
  -
  -The file in the JAR: `META-INF/services/org/apache/camel/TypeConverter`
  -contains the following line(s) for FQN class names:
  -
  -----
  -com.foo.MyConverter
  -com.bar.MyOtherConverter
  -com.bar.YetOtherConverter
  -----
  -
  -As you can see each line in the file now contains a FQN class name. This
  -is the recommended approach.
  -
  -[[TypeConverter-Encodingsupportforbyte[]andStringConversion]]
  -==== Encoding support for byte[] and String Conversion
  -
  -*Available in Camel 1.5*
  -
  -Since Java provides converting the `byte[]` to `String` and `String` to `byte[]`
  -with the
  -http://java.sun.com/j2se/1.5.0/docs/api/java/nio/charset/Charset.html[charset
  -name] parameter. You can define the charset name by setting the exchange
  -property name `Exchange.CHARSET_NAME` with the charset name, such as
  -`"UTF-8"` or `"iso-8859-1"`.
  -
   [[TypeConverter-Exchangeparameter]]
   ==== Exchange parameter
  -
  -*Available in Camel 1.5*
   
   The type converter accepts the `Exchange` as an optional 2nd parameter.
   This is usable if the type converter for instance needs information from
  
positive.code: interface that can be customized on a
  http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/CamelContext.html[CamelContext].
  
  The default implementation,
  http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/impl/converter/DefaultTypeConverter.html[DefaultTypeConverter],
  uses pluggable strategies to load type converters via
  http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/impl/converter/TypeConverterLoader.html[TypeConverterLoader].
  The default strategy,
  http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/impl/converter/AnnotationTypeConverterLoader.html[AnnotationTypeConverterLoader],
  uses a discovery mechanism to find converters.
  
  *New in Camel 1.5*
  
  The default implementation,
  http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/impl/converter/DefaultTypeConverter.html[DefaultTypeConverter],
  now throws a
  http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/NoTypeConversionAvailableException.html[NoTypeConversionAvailableException]
  if a suitable conversion cannot be found
  (https://issues.apache.org/jira/browse/CAMEL-84[CAMEL-84]).
  The semantical ambiguity of `null` (both valid result and indication
  of no conversion found) is now resolved, but this may impact existing
  code in that it should now catch the exception instead of checking
  for `null`.
  
  [[TypeConverter-TypeConverterRegistry]]
  ==== TypeConverterRegistry
  
  *New in Camel 2.0*
  
  Exposed the
  http://camel.apache.org/maven/current/camel-core/apidocs/org/apache/camel/spi/TypeConverterRegistry.html[TypeConverterRegistry]
  
negative.code: </camelContext>
  ----
  
  [[TypeConverter-Addtypeconverterclassesatruntime]]
  ===== Add type converter classes at runtime
  
  You can add new type converters at runtime, by having your classes
  implement `org.apache.camel.TypeConverters` which is an marker
  interface. Then for each type converter you want use
  the `@Converter` annotation.
  