def is_able_to_convert_detailed(self, strict: bool, from_type: Type[Any], to_type: Type[Any])-> Tuple[bool, bool, bool]:
<EOL>if from_type is JOKER and to_type is JOKER:<EOL><INDENT>return True, None, None<EOL><DEDENT>if self.is_able_to_convert_func is not None:<EOL><INDENT>if not self.is_able_to_convert_func(strict,<EOL>from_type=None if from_type is JOKER else from_type,<EOL>to_type=None if to_type is JOKER else to_type):<EOL><INDENT>return False, None, None<EOL><DEDENT><DEDENT>if (from_type is JOKER) or (from_type is self.from_type) or is_any_type(from_type):<EOL><INDENT>if (to_type is JOKER) or self.is_generic() or (to_type is self.to_type):<EOL><INDENT>return True, True, True  <EOL><DEDENT>elif (not strict) and issubclass(self.to_type, to_type):<EOL><INDENT>return True, True, False  <EOL><DEDENT><DEDENT>elif (not strict) and issubclass(from_type, self.from_type):<EOL><INDENT>if (to_type is JOKER) or self.is_generic() or (to_type is self.to_type):<EOL><INDENT>return True, False, True  <EOL><DEDENT>elif (not strict) and issubclass(self.to_type, to_type):<EOL><INDENT>return True, False, False  <EOL><DEDENT><DEDENT>return False, None, None<EOL>
Utility method to check if a parser is able to convert a given type to the given type, either in
* strict mode : provided_type and desired_type must be equal to this converter's from_type and to_type
respectively (or the to_type does not match but this converter is generic
* inference mode (non-strict) : provided_type may be a subclass of from_type, and to_type may be a subclass
of desired_type

If a custom function was provided at construction time, it is called to enable converters to reject some
conversions based on source and/or dest type provided.

:param strict: a boolean indicating if matching should be in strict mode or not
:param from_type:
:param to_type:
:return: a tuple of 3 booleans : (does match?, strict source match? (None if no match), strict dest match?
(None if no match))