public class JodaConvertConverterProvider extends AbstractAnnotationMatchingConverterProvider<ToString, FromString> implements ConverterProvider {
	
	/**
	 * Subclasses can override this template method with their own matching strategy
	 * @param method The method to be determined
	 * @return True if match
	 */
	protected boolean isToMatch(Method method) {
		return String.class.equals(method.getReturnType());
	}

	/**
	 * Subclasses can override this template method with their own matching strategy
	 * @param constructor The constructor to be determined
	 * @return True if match
	 */
	protected boolean isFromMatch(Constructor<?> constructor) {
		return String.class.equals(constructor.getParameterTypes()[0]);
	}

	/**
	 * Subclasses can override this template method with their own matching strategy
	 * @param method The method to be determined
	 * @return True if match
	 */
	protected boolean isFromMatch(Method method) {
		return String.class.equals(method.getParameterTypes()[0]);
	}
}

            return unmarshal.newInstance(str);
        } catch (IllegalAccessException ex) {
            throw new IllegalStateException("Constructor is not accessible");
        } catch (InstantiationException ex) {
            throw new IllegalStateException("Constructor is not valid");
        } catch (InvocationTargetException ex) {
            if (ex.getCause() instanceof RuntimeException) {
                throw (RuntimeException) ex.getCause();
            }
            throw new BindingException(ex.getMessage(), ex.getCause());
        }
    }

        } catch (Throwable ex) {
        	if (ex.getCause() instanceof RuntimeException) {
                throw (RuntimeException) ex.getCause();
            }
            throw new BindingException(ex.getMessage(), ex.getCause());
        }
    }
   
	/**
	 * {@inheritDoc}
	 */
	/* @Override */
    public Class<S> getBoundClass() {
        return boundClass;
    }
    
	/**
	 * {@inheritDoc}
	 */
	/* @Override */
	public Class<T> getTargetClass() {
		return targetClass;
	}
}

                for (Provider nextProvider : nextConfig.getProviders()) {
            
	                try {
	                    registerConverterProvider(nextProvider.getProviderClass().newInstance());
	                } catch (InstantiationException e) {
	                    throw new IllegalStateException("Cannot instantiate binding provider class: " + nextProvider.getProviderClass().getName());
	                } catch (IllegalAccessException e) {
	                    throw new IllegalStateException("Cannot access binding provider class: " + nextProvider.getProviderClass().getName());
	                }
                }

        @SuppressWarnings("unchecked")
        Class<T> myTarget = (Class<T>)unmarshal.getParameterTypes()[0];
        this.targetClass = myTarget;
    }

	/**
	 * {@inheritDoc}
	 */
	/* @Override */
    public S unmarshal(T object) {
    	
    	if (object != null && !targetClass.isAssignableFrom(object.getClass())) {
    		throw new IllegalArgumentException("Supplied object was not instance of target class");
    	}
    	
        try {
            return unmarshal.newInstance(object);

        } catch (InvocationTargetException ex) {
            if (ex.getCause() instanceof RuntimeException) {
                throw (RuntimeException) ex.getCause();
            }
            throw new BindingException(ex.getMessage(), ex.getCause());
        }
    }

        } catch (Throwable ex) {
        	if (ex.getCause() instanceof RuntimeException) {
                throw (RuntimeException) ex.getCause();
            }
            throw new BindingException(ex.getMessage(), ex.getCause());
        }
    }

	public <I,O> Map<ConverterKey<?, ?>, Method> matchToMethods(Class<?> cls) {

		Map<ConverterKey<?, ?>, Method> matchedMethods = new HashMap<ConverterKey<?, ?>, Method>();
		
		@SuppressWarnings("unchecked")
		Class<T> toAnnotation = (Class<T>) TypeHelper.getTypeArguments(

		return findUnmarshaller(new ConverterKey<S,T>(source, target, DefaultBinding.class));
	}

	/**
	 * Resolve a Binding with the given source and target class.
	 * A binding unifies a marshaller and an unmarshaller and both must be available to resolve a binding.
	 * 
	 * The source class is considered the owning class of the binding. The source can be marshalled
	 * into the target class. Similarly, the target can be unmarshalled to produce an instance of the source type.
	 * @param source The source (owning) class
	 * @param target The target (foreign) class
	 * @param qualifier The qualifier for which the binding must be registered
	 */
	public <S, T> Binding<S, T> findBinding(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
		return findBinding(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));

		return binder.convertTo(String.class, output, object);
	}

	/**
	 * {@inheritDoc}
	 */
	/* @Override */
	public <T> T convertFromString(Class<T> output, String object, Class<? extends Annotation> qualifier) {
		return binder.convertTo(String.class, output, object, qualifier);

		return binder.convertTo(input, String.class, object);
	}

	/**
	 * {@inheritDoc}
	 */
	/* @Override */
	public <S> String convertToString(Class<S> input, Object object,
			Class<? extends Annotation> qualifier) {
		return binder.convertTo(input, String.class, object, qualifier);

	}

	/**
	 * Resolve a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class
	 * @param qualifier The qualifier for which the marshaller must be registered 
	 */
	public <S, T> ToMarshaller<S, T> findMarshaller(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
		return findMarshaller(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));

	}

	/**
	 * Resolve a Converter with the given input and output classes. Instances of the input class can be converted into 
	 * instances of the output class
	 * @param source The source class
	 * @param target The target class
	 * @param qualifier The qualifier for which the marshaller must be registered   
	 */
	public <S, T> Converter<S, T> findConverter(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
		return findConverter(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));

	}

	/**
	 * Resolve an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class 
	 * @param qualifier The qualifier for which the unmarshaller must be registered 
	 */
	public <S, T> FromUnmarshaller<S, T> findUnmarshaller(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
		return findUnmarshaller(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));

    <S, T> void registerConverter(ConverterKey<S,T> key, Converter<S, T> converter);
	
	/**
	 * Register a Binding with the given source and target class.
	 * A binding unifies a marshaller and an unmarshaller and both must be available to resolve a binding.
	 * 
	 * The source class is considered the owning class of the binding. The source can be marshalled
	 * into the target class. Similarly, the target can be unmarshalled to produce an instance of the source type.
	 * @param sourceClass The source (owning) class
	 * @param targetClass The target (foreign) class
	 * @param converter The binding to be registered
	 * @param <S> Source type
	 * @param <T> Target type
	 */
    <S, T> void registerBinding(final Class<S> sourceClass, Class<T> targetClass, Binding<S, T> converter);

				this.getClass()).get(0);

		Class<?> loopCls = cls;

		while (loopCls != Object.class) {
			Method[] methods = loopCls.getDeclaredMethods();
			for (Method method : methods) {
				if (signatureIndicatesToMethodCandidate(method)) {

        for (Annotation next : bindingAnnotation.annotationType().getAnnotations()) {
            Class<? extends Annotation> nextType = next.annotationType();
            if (nextType.getAnnotation(BindingScope.class) != null) {
                result.add(nextType);
            }
        }

                ConstructorFromUnmarshaller<I,O> fromUnmarshaller = new ConstructorFromUnmarshaller<I,O>(con); 
                registerBinding(key.getInputClass(), key.getOutputClass(), new CompositeBinding<I,O>(toMarshaller, fromUnmarshaller), key.getQualifierAnnotation());               
            } else if (fromMethod != null) {

	<S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter, Class<? extends Annotation> qualifier);

	<S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter, Class<? extends Annotation> qualifier);

		registerBinding(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier), converter);
	}

	/**
	 * Register a Binding with the given source and target class.
	 * A binding unifies a marshaller and an unmarshaller and both must be available to resolve a binding.
	 * 
	 * The source class is considered the owning class of the binding. The source can be marshalled
	 * into the target class. Similarly, the target can be unmarshalled to produce an instance of the source type.
	 * @param key Converter Key to use
	 * @param converter The binding to be registered
	 */
	public final <S, T> void registerBinding(ConverterKey<S,T> key, Binding<S, T> converter) {

						List<Class<? extends Annotation>> qualifiers = determineQualifiers(fromConstructorAnnotation, constructor.getAnnotations());
						
						for (Class<? extends Annotation> nextQualifier : qualifiers) {
							@SuppressWarnings("unchecked")
							Class<I> paramType = (Class<I>)constructor.getParameterTypes()[0];

        for (Annotation next : implementation.getAnnotations()) {
            Class<? extends Annotation> nextType = next.annotationType();
            if (nextType.getAnnotation(BindingScope.class) != null) {
                return nextType;
            }
        }
        return null;

        for (Annotation next : implementation.getAnnotations()) {
            Class<? extends Annotation> nextType = next.annotationType();
            if (nextType.getAnnotation(BindingScope.class) != null) {

		BINDING.registerBinding(sourceClass, targetClass, converter);
	}

    /**
     * {@inheritDoc}
     */
    /* @Override */
	public <S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter) {

		BINDING.registerUnmarshaller(sourceClass, targetClass, converter);
	}

    /**
     * {@inheritDoc}
     */
    /* @Override */
	public <S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter) {

		BINDING.registerMarshaller(sourceClass, targetClass, converter);
	}

    /**
     * {@inheritDoc}
     */
    /* @Override */
	public <S, T> void registerConverter(Class<S> sourceClass, Class<T> targetClass, Converter<S, T> converter) {

			Method fromMethod) {
		
		this.sourceClass = sourceClass;
		this.targetClass = targetClass;
		this.qualifier = qualifier == null ? DefaultBinding.class : qualifier;
		this.toMethod = toMethod;
		this.fromMethod = fromMethod;

		return findMarshaller(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));
	}
	
	/**
	 * Resolve a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param key The key to look up
	 */
	public <S, T> ToMarshaller<S, T> findMarshaller(ConverterKey<S,T> key) {

    <S, T> Binding<S, T> findBinding(final Class<S> source, final Class<T> target, final Class<? extends Annotation> qualifier);
    
	/**
	 * Resolve a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class
	 * @param qualifier The qualifier for which the marshaller must be registered
	 * @param <S> The Source type
	 * @param <T> The Target type
	 * @return The found Marshaller 
	 */
    <S, T> ToMarshaller<S, T> findMarshaller(final Class<S> source, final Class<T> target, final Class<? extends Annotation> qualifier);

public class CalendarStringBinding extends AbstractStringBinding<Calendar> implements Binding<Calendar, String> {

    private static final ThreadLocal<SimpleDateFormat> DATE_FORMAT = new ThreadLocal<SimpleDateFormat>() {
        @Override
        public SimpleDateFormat initialValue() {

		this.fromConstructor = null;
	}
	
	/**
	 * Create a new entry for the given options
	 * @param sourceClass The source class to be bound
	 * @param targetClass The foreign side of the relationship
	 * @param qualifier The qualifier
	 * @param toMethod The to method to be bound
	 * @param fromMethod The from method to be bound
	 */
	public BindingConfigurationEntry(Class<?> sourceClass, Class<?> targetClass,
			Class<? extends Annotation> qualifier, Method toMethod,

        for (Annotation next : bindingAnnotation.annotationType().getAnnotations()) {
            Class<? extends Annotation> nextType = next.annotationType();
            if (nextType.getAnnotation(BindingScope.class) != null) {

    <S, T> void registerBinding(final Class<S> sourceClass, Class<T> targetClass, Binding<S, T> converter);

	/**
	 * Register an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param sourceClass The source (input) class
	 * @param targetClass The target (output) class
	 * @param converter The FromUnmarshaller to be registered
	 * @param <S> Source type
	 * @param <T> Target type  
	 */
	<S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter);

	<S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter);

	<S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter);
	
	/**
	 * Register a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param sourceClass The source (input) class
	 * @param targetClass The target (output) class
	 * @param converter The ToMarshaller to be registered
	 * @param <S> Source type
	 * @param <T> Target type
	 */
	<S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter);

	<S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter);

    <S, T> void registerBinding(final Class<S> sourceClass, Class<T> targetClass, Binding<S, T> converter, Class<? extends Annotation> qualifier);

    <S, T> void registerConverter(final Class<S> sourceClass, Class<T> targetClass, Converter<S, T> converter, Class<? extends Annotation> qualifier);

	public final <S, T> void registerBinding(ConverterKey<S,T> key, Binding<S, T> converter) {
		registerConverter(key.invert(), new FromUnmarshallerConverter<S,T>(converter));

		return conv.convert(myObject);
	}
	
    /*************************
     *                       *
     * Conversion Resolution * 
     *                       *
     *************************/
	
	/**
	 * Resolve a Binding with the given source and target class.
	 * A binding unifies a marshaller and an unmarshaller and both must be available to resolve a binding.
	 * 
	 * The source class is considered the owning class of the binding. The source can be marshalled
	 * into the target class. Similarly, the target can be unmarshalled to produce an instance of the source type.
	 * @param source The source (owning) class
	 * @param target The target (foreign) class
	 */
	public <S, T> Binding<S, T> findBinding(Class<S> source, Class<T> target) {

		return findConverter(new ConverterKey<S,T>(input, output, DefaultBinding.class));
	}

	/**
	 * Resolve an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class 
	 */
	public <S, T> FromUnmarshaller<S, T> findUnmarshaller(Class<S> source, Class<T> target) {

	<S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter);

	<S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter);

	<S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter, Class<? extends Annotation> qualifier);

	<S, T> void registerMarshaller(Class<S> sourceClass, Class<T> targetClass, ToMarshaller<S, T> converter, Class<? extends Annotation> qualifier);

    <S, T> FromUnmarshaller<S, T> findUnmarshaller(ConverterKey<S,T> key);

	/**
	 * Resolve a Binding with the given source and target class.
	 * A binding unifies a marshaller and an unmarshaller and both must be available to resolve a binding.
	 * <br>
	 * The source class is considered the owning class of the binding. The source can be marshalled
	 * into the target class. Similarly, the target can be unmarshalled to produce an instance of the source type.
	 * @param source The source (owning) class
	 * @param target The target (foreign) class
	 * @param <S> The Source type
	 * @param <T> The Target type
	 * @return The found Binding
	 */
    <S, T> Binding<S, T> findBinding(final Class<S> source, final Class<T> target);

    <S, T> Binding<S, T> findBinding(final Class<S> source, final Class<T> target);
    
	/**
	 * Resolve a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class
	 * @param <S> The Source type
	 * @param <T> The Target type
	 * @return The found Marshaller
	 */
    <S, T> ToMarshaller<S, T> findMarshaller(final Class<S> source, final Class<T> target);

    <S, T> ToMarshaller<S, T> findMarshaller(final Class<S> source, final Class<T> target);
    
	/**
	 * Resolve a Converter with the given input and output classes. Instances of the input class can be converted into 
	 * instances of the output class
	 * @param source The input class
	 * @param target The output class
	 * @param <S> The Source type
	 * @param <T> The Target type  
	 * @return The found Converter
	 */
    <S, T> Converter<S, T> findConverter(final Class<S> source, final Class<T> target);

    <S, T> Converter<S, T> findConverter(final Class<S> source, final Class<T> target);
    
	/**
	 * Resolve an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class
	 * @param <S> The Source type
	 * @param <T> The Target type 
	 * @return The found Unmarshaller
	 */
    <S, T> FromUnmarshaller<S, T> findUnmarshaller(final Class<S> source, final Class<T> target);

		return BINDING.findMarshaller(source, target);
	}

    /**
     * {@inheritDoc}
     */
    /* @Override */
	public <S, T> Converter<S, T> findConverter(Class<S> source, Class<T> target) {

        Class<?> providerClass = lookupClass(element.getAttribute("class"));

        if (providerClass == null) {
            throw new IllegalStateException("Referenced class {" + element.getAttribute("class")
                    + "} could not be found");
        }
        if (!ConverterProvider.class.isAssignableFrom(providerClass)) {

						List<Class<? extends Annotation>> qualifiers = determineQualifiers(toMethodAnnotation, method.getAnnotations());
						
						for (Class<? extends Annotation> nextQualifier : qualifiers) {
							@SuppressWarnings("unchecked")
							Class<O> returnType = (Class<O>)method.getReturnType();

	public <I,O> Map<ConverterKey<?,?>, Constructor<O>> matchFromConstructors(Class<O> cls) {

		return binder.convertTo(String.class, object);
	}

	/**
	 * {@inheritDoc}
	 */
	/* @Override */
	public String convertToString(Object object, Class<? extends Annotation> qualifier) {
		return binder.convertTo(String.class, object, qualifier);

	}

	/**
	 * Resolve an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class 
	 */
	public <S, T> FromUnmarshaller<S, T> findUnmarshaller(Class<S> source, Class<T> target) {

	}

	/**
	 * Resolve a Converter with the given input and output classes. Instances of the input class can be converted into 
	 * instances of the output class
	 * @param source The source class
	 * @param target The target class
	 * @param qualifier The qualifier for which the marshaller must be registered   
	 */
	public <S, T> Converter<S, T> findConverter(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {

	public final <S, T> void registerBinding(ConverterKey<S,T> key, Binding<S, T> converter) {

	public final <S, T> void registerUnmarshaller(ConverterKey<S,T> key, FromUnmarshaller<S, T> converter) {

	public final <S, T> void registerMarshaller(ConverterKey<S,T> key, ToMarshaller<S, T> converter) {

	public final <S, T> void registerConverter(ConverterKey<S,T> key, Converter<S, T> converter) {	

		return findBinding(new ConverterKey<S,T>(source, target, DefaultBinding.class));
	}

	/**
	 * Resolve a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class 
	 */
	public <S, T> ToMarshaller<S, T> findMarshaller(Class<S> source, Class<T> target) {

		return findBinding(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));
	}

		return findMarshaller(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));
	}
	
	/**
	 * Resolve a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param key The key to look up
	 */
	public <S, T> ToMarshaller<S, T> findMarshaller(ConverterKey<S,T> key) {

		return findConverter(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));
	}
	
	/**
	 * Resolve a Converter with the given input and output classes. Instances of the input class can be converted into 
	 * instances of the output class
	 * @param key The key to look up
	 */
	public <S, T> Converter<S, T> findConverter(ConverterKey<S,T> key) {

		return findUnmarshaller(new ConverterKey<S,T>(source, target, qualifier == null ? DefaultBinding.class : qualifier));
	}
	
	/**
	 * Resolve an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param key The key to look up 
	 */
	public <S, T> FromUnmarshaller<S, T> findUnmarshaller(ConverterKey<S,T> key) {

	private void matchTo(Class<?> target, Set<ConverterKey<?,?>> previouslySeenKeys, Map<ConverterKey<?,?>, Method> toMethods) {

	private void matchTo(Class<?> target, Set<ConverterKey<?,?>> previouslySeenKeys, Map<ConverterKey<?,?>, Method> toMethods) {

		for (ConverterProvider nextConverter : converterProviders) {
			Map<ConverterKey<?,?>, Method> nextMethods = nextConverter.matchToMethods(target);

	<S,T> T convertTo(Class<T> output, Object object, Class<? extends Annotation> qualifier);
	
	// TODO Add find methods equating to convertTo
    
	/**
	 * Convert an object which is an instance of source class to the given target class
	 * @param input The class of the object to be converted
	 * @param output The target class to convert the object to
	 * @param object The object to be converted
	 * @param <S> The Source type
	 * @param <T> The Target type
	 * @return The result of the conversion
	 */
	<S, T> T convertTo(Class<S> input, Class<T> output, Object object);

		return BINDING.convertTo(output, object, qualifier);
	}
    
    /**
     * {@inheritDoc}
     */
    /* @Override */
	public <S, T> T convertTo(Class<S> sourceClass, Class<T> target, Object object) {

	public <S, T> Binding<S, T> findBinding(Class<S> source, Class<T> target, Class<? extends Annotation> qualifier) {
		return BINDING.findBinding(source, target, qualifier);

    public ConverterToMarshaller(Converter<S,T> converter) {
        
    	if (converter == null) {
    		throw new IllegalStateException("converter must not be null");
    	}
        this.converter = converter;     
    }

	/**
	 * {@inheritDoc}
	 */
	/* @Override */
    public T marshal(S object) {

	                        fromMethod = bindingClass.getMethod(fromMethodName, new Class[] { String.class });
	                    } catch (SecurityException e) {
	                    } catch (NoSuchMethodException e) {
	                    }

						List<Class<? extends Annotation>> qualifiers = determineQualifiers(toMethodAnnotation, method.getAnnotations());
						
						for (Class<? extends Annotation> nextQualifier : qualifiers) {
							@SuppressWarnings("unchecked")
							Class<O> returnType = (Class<O>)method.getReturnType();

		if ((!(Modifier.isStatic(method.getModifiers()) && method.getParameterTypes().length == 1))

            builtInBindingsUrl = new URL(classPrefix + "META-INF/bindings.xml");
        } catch (IOException e) {
            throw new IllegalStateException("Error registering bindings: " + e.getMessage(), e);
        }

	public final <S, T> void registerBinding(Class<S> source, Class<T> target, Binding<S, T> converter) {
        Class<? extends Annotation> scope = matchImplementationToScope(converter.getClass());

	public final <S, T> void registerUnmarshaller(ConverterKey<S,T> key, FromUnmarshaller<S, T> converter) {

	public final <S, T> void registerConverter(ConverterKey<S,T> key, Converter<S, T> converter) {	

	}
	
	/**
	 * Convert an object which is an instance of source class to the given target class
	 * @param input The class of the object to be converted
	 * @param output The target class to convert the object to
	 * @param object The object to be converted
	 */
	public <S, T> T convertTo(Class<S> input, Class<T> output, Object object) {

		Map<ConverterKey<?,?>, Method> toMethods = new HashMap<ConverterKey<?,?>, Method>();
		Map<ConverterKey<?,?>, Method> fromMethods = new HashMap<ConverterKey<?,?>, Method>();

    <S, T> Binding<S, T> findBinding(final Class<S> source, final Class<T> target, final Class<? extends Annotation> qualifier);

	public <I,O> Map<ConverterKey<?, ?>, Method> matchToMethods(Class<?> cls) {

			(!(!Modifier.isStatic(method.getModifiers()) && method.getParameterTypes().length == 0))) {
			return false;
		}
		return true;
	}

	public <I,O> Map<ConverterKey<?,?>, Constructor<O>> matchFromConstructors(Class<O> cls) {

	public <I,O> Map<ConverterKey<?,?>, Method> matchFromMethods(Class<?> cls) {

		return binder.convertTo(String.class, object, qualifier);
	}

	/**
	 * {@inheritDoc}
	 */
	/* @Override */
	public <S> String convertToString(Class<S> input, Object object) {
		return binder.convertTo(input, String.class, object);

	public <S> String convertToString(Class<S> input, Object object,
			Class<? extends Annotation> qualifier) {

        registerBinding(new ConverterKey<S,T>(source, target, scope == null ? DefaultBinding.class : scope), converter);	
	}

	/**
	 * Register an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class
	 * @param converter The FromUnmarshaller to be registered  
	 */
	public final <S, T> void registerUnmarshaller(Class<S> source, Class<T> target, FromUnmarshaller<S, T> converter) {

	public <S, T> Binding<S, T> findBinding(ConverterKey<S,T> key) {

	public <S, T> Converter<S, T> findConverter(ConverterKey<S,T> key) {

    <S, T> void registerBinding(final Class<S> sourceClass, Class<T> targetClass, Binding<S, T> converter, Class<? extends Annotation> qualifier);
    
	/**
	 * Register an UnMarshaller with the given source and target class.
	 * The unmarshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param sourceClass The source (input) class
	 * @param targetClass The target (output) class
	 * @param converter The FromUnmarshaller to be registered
	 * @param qualifier The qualifier for which the unmarshaller must be registered
	 * @param <S> Source type
	 * @param <T> Target type  
	 */
	<S, T> void registerUnmarshaller(Class<S> sourceClass, Class<T> targetClass, FromUnmarshaller<S, T> converter, Class<? extends Annotation> qualifier);

public final class MethodConstructorBinding<S, T> extends MethodToMarshaller<S, T> implements Binding<S, T> {

    private final Constructor<S> unmarshal;

		return binder.convertTo(String.class, object);
	}

	/**
	 * {@inheritDoc}
	 */
	/* @Override */
	public String convertToString(Object object, Class<? extends Annotation> qualifier) {
		return binder.convertTo(String.class, object, qualifier);

		if (Binding.class.isAssignableFrom(theBinding.getBindingClass())) {
        	
        	/*
         	 * If the binding class is an instance of the Binding interface then register it.
         	 * When the binding class is an interface, you must define source and target class if they cannot be
         	 * determined from introspecting the interface.
         	 * 
         	 * You can optionally supply a qualifier so that the binding is associated with a qualifier
         	 */
        	try {
        		@SuppressWarnings("unchecked")

			for(ConverterKey<?,?> currentKey : nextMethods.keySet()) {
				if (previouslySeenKeys.contains(currentKey)) {
					throw new IllegalStateException("Method is resolved by two converters: " + currentKey.toString());

    <S, T> void registerBinding(final Class<S> sourceClass, Class<T> targetClass, Binding<S, T> converter);

    <S, T> void registerConverter(final Class<S> sourceClass, Class<T> targetClass, Converter<S, T> converter);

    <S, T> Binding<S, T> findBinding(final Class<S> source, final Class<T> target);
    
	/**
	 * Resolve a Marshaller with the given source and target class.
	 * The marshaller is used as follows: Instances of the source can be marshalled into the target class.
	 * @param source The source (input) class
	 * @param target The target (output) class
	 * @param <S> The Source type
	 * @param <T> The Target type
	 * @return The found Marshaller
	 */
    <S, T> ToMarshaller<S, T> findMarshaller(final Class<S> source, final Class<T> target);