def resolve_resource_refs(self, input_dict, supported_resource_refs):
def do_replacement(full_ref, ref_value):<EOL><INDENT>"""<STR_LIT>"""<EOL>splits = ref_value.split(self._resource_ref_separator)<EOL>if len(splits) < <NUM_LIT:2>:<EOL><INDENT>return full_ref<EOL><DEDENT>logical_id = splits[<NUM_LIT:0>]<EOL>property = splits[<NUM_LIT:1>]<EOL>resolved_value = supported_resource_refs.get(logical_id, property)<EOL>if not resolved_value:<EOL><INDENT>return full_ref<EOL><DEDENT>replacement = self._resource_ref_separator.join([logical_id, property])<EOL>return full_ref.replace(replacement, resolved_value)<EOL><DEDENT>return self._handle_sub_action(input_dict, do_replacement)<EOL>
Resolves reference to some property of a resource. Inside string to be substituted, there could be either a
"Ref" or a "GetAtt" usage of this property. They have to be handled differently.

Ref usages are directly converted to a Ref on the resolved value. GetAtt usages are split under the assumption
that there can be only one property of resource referenced here. Everything else is an attribute reference.

Example:

    Let's say `LogicalId.Property` will be resolved to `ResolvedValue`

    Ref usage:
        ${LogicalId.Property}  => ${ResolvedValue}

    GetAtt usage:
        ${LogicalId.Property.Arn} => ${ResolvedValue.Arn}
        ${LogicalId.Property.Attr1.Attr2} => {ResolvedValue.Attr1.Attr2}


:param input_dict: Dictionary to be resolved
:param samtranslator.intrinsics.resource_refs.SupportedResourceReferences supported_resource_refs: Instance of
    an `SupportedResourceReferences` object that contain value of the property.
:return: Resolved dictionary