def get_getter(cls, prop_name,  # @NoSelf
                   user_getter=None, getter_takes_name=False):
        """This implementation returns the PROP_NAME value if there
          exists such property. Otherwise there must exist a logical
          getter (user_getter) which the value is taken from.  If no
          getter is found, None is returned (i.e. the property cannot
          be created)"""

        has_prop_variable = cls.has_prop_attribute(prop_name)

        # WARNING! Deprecated
        has_specific_getter = hasattr(cls, GET_PROP_NAME % \
                                      {'prop_name' : prop_name})
        has_general_getter = hasattr(cls, GET_GENERIC_NAME)

        if not (has_prop_variable or
                has_specific_getter or
                has_general_getter or
                user_getter):
            return None

        # when property variable is given, it overrides all the getters
        if has_prop_variable:
            if has_specific_getter or user_getter:
                logger.warning("In class %s.%s ignoring custom logical getter "
                               "for property '%s' as a corresponding "
                               "attribute exists" \
                                  % (cls.__module__, cls.__name__, prop_name))

            # user_getter is ignored here, so it has not to be passed up
            user_getter = None
            getter_takes_name = False

        else:

            # uses logical getter. Sees if the getter needs to receive the
            # property name (i.e. if the getter is used for multiple
            # properties)
            if user_getter:
                pass
            else:
                if has_specific_getter:
                    _getter = getattr(cls, GET_PROP_NAME % \
                                      {'prop_name' : prop_name})
                    _deps = type(cls)._get_old_style_getter_deps(cls,
                                                                 prop_name,
                                                                 _getter)

                    # this is done to delay getter call, to have
                    # bound methods to allow overloading of getter in
                    # derived classes
                    def __getter(self, deps=_deps):
                        _getter = getattr(self, GET_PROP_NAME % \
                                          {'prop_name' : prop_name})
                        return _getter()
                    user_getter = __getter
                    getter_takes_name = False
                else:
                    assert has_general_getter
                    _getter = getattr(cls, GET_GENERIC_NAME)
                    _deps = type(cls)._get_old_style_getter_deps(cls,
                                                                 prop_name,
                                                                 _getter)

                    def __getter(self, name, deps=_deps):
                        _getter = getattr(self, GET_GENERIC_NAME)
                        return _getter(name)
                    user_getter = __getter
                    getter_takes_name = True

        return PropertyMeta.get_getter(cls, prop_name, user_getter,
                                       getter_takes_name)