def _get_target(self, prop, *targets):
        """
        The actual target methods are retrieved (possibly from the list of targets) and a
        wrapper-property is installed on a throwaway type that is specifically created for
        the purpose of holding this property if necessary. In that case, an instance of this type
        (with the wrapper-property forwarding calls to the correct target) is returned so
        that :class:`BoundPV` can do the right thing.

        .. seealso:: :meth:`_create_getter`, :meth:`_create_setter`

        :param prop: Property, is either 'value' or 'meta'.
        :param targets: List of targets with decreasing priority for finding the wrapped method.
        :return: Target object to be used by :class:`BoundPV`.
        """

        if prop is None:
            return None

        raw_getter, raw_setter = self._specifications.get(prop, (None, None))

        target = None

        if isinstance(raw_getter, string_types):
            target = next(
                (obj for obj in targets if
                 isinstance(
                     getattr(type(obj), raw_getter, None), property)
                 or not callable(
                     getattr(obj, raw_getter, lambda: True))),
                None)

        if target is not None:
            # If the property is an actual property and has no setter, read_only can be
            # set to True at this point automatically.
            target_prop = getattr(type(target), raw_getter, None)

            if prop == 'value' and isinstance(target_prop, property) and target_prop.fset is None:
                self.read_only = True

            # Now the target does not need to be constructed, property or meta_data_property
            # needs to change.
            setattr(self, 'property' if prop == 'value' else 'meta_data_property', raw_getter)
            return target

        getter = self._create_getter(raw_getter, *targets)
        setter = self._create_setter(raw_setter, *targets)

        if getter is None and setter is None:
            return None

        if prop == 'value' and setter is None:
            self.read_only = True

        return type(prop, (object,), {prop: property(getter, setter)})()
The actual target methods are retrieved (possibly from the list of targets) and a
        wrapper-property is installed on a throwaway type that is specifically created for
        the purpose of holding this property if necessary. In that case, an instance of this type
        (with the wrapper-property forwarding calls to the correct target) is returned so
        that :class:`BoundPV` can do the right thing.

        .. seealso:: :meth:`_create_getter`, :meth:`_create_setter`

        :param prop: Property, is either 'value' or 'meta'.
        :param targets: List of targets with decreasing priority for finding the wrapped method.
        :return: Target object to be used by :class:`BoundPV`.