Gets all method names known to configuration engine.

 @param local_only [Boolean] optional flag that if set, causes only methods added
  by current class or module to be listed.

 @return [Array<Symbol>] delegated method names
551955
def get_configuration_methods(local_only = false)
      all_delegators = singleton_class.send(:cf_block_delegators) + cf_block_delegators
      return all_delegators if local_only
      ancestors.each_with_object(all_delegators) do |ancestor, all|
        all.merge(ancestor.send(__method__, true)) if ancestor.respond_to?(__method__)
      end
    end
1330016
def has_roles_mask_accessors?
      instance_method_names = instance_methods.map { |method_name| method_name.to_s }
      [roles_attribute_name.to_s, "#{roles_attribute_name}="].all? do |accessor| 
        instance_method_names.include?(accessor)
      end
    end
129947
def all_methods(cls):
        
        def name(fn):
            return fn.__get__(cls).__name__.replace("_", "-")
        return sorted(name(f) for f in cls.__dict__.values()
                      if isinstance(f, staticmethod))
1236728
def get_methods(self):
        
        return [x
                for x in self.direct_methods] + [x
                                                 for x in self.virtual_methods]
740523
def _check_local_handlers(cls, signals, handlers, namespace, configs):
        """"""
        for aname, sig_name in handlers.items():
            # WARN: this code doesn't take in account the case where a new
            # method with the same name of an handler in a base class is
            # present in this class but it isn't an handler (so the handler
            # with the same name should be removed from the handlers)
            if sig_name not in signals:
                disable_check = configs[aname].get('disable_check', False)
                if not disable_check:
                    raise SignalError("Cannot find a signal named '%s'"
                                      % sig_name)
316359
def get_methods_class(self, class_name):
        
        l = []
        for i in self.get_classes():
            for j in i.get_methods():
                if class_name == j.get_class_name():
                    l.append(j)

        return l
1135503
public Collection<Method> getMethods() {
        final Collection<Method> methods = new ArrayList<Method>();
        for (Map.Entry<String, Map<ParamList, Map<Class<?>, Method>>> entry : this.methods.entrySet()) {
            final Map<ParamList, Map<Class<?>, Method>> nameMap = entry.getValue();
            for (Map<Class<?>, Method> map : nameMap.values()) {
                methods.addAll(map.values());
            }
        }
        return methods;
    }
296187
def get_methods_class(self, class_name):
        
        l = []
        for i in self.classes.class_def:
            for j in i.get_methods():
                if class_name == j.get_class_name():
                    l.append(j)

        return l
535765
def get_methods(self):
        
        if self.__cache_all_methods is None:
            self.__cache_all_methods = []
            for i in self.get_classes():
                for j in i.get_methods():
                    self.__cache_all_methods.append(j)
        return self.__cache_all_methods
740409
def recursively_find_methods_matching(name, is_class_method)
      res = local_methods_matching(name, is_class_method)
      @inferior_classes.each do |c|
        res.concat(c.recursively_find_methods_matching(name, is_class_method))
      end
      res
    end
301310
def get_methods(getter = :methods)
      parent = inspect_superclass || Object
      diff   = constant.__send__(getter, false) -
        parent.__send__(getter, false)

      methods = diff | constant.__send__(getter, false)

      # If the constant manually defines the initialize method (= private)
      # we'll also want to include it.
      if include_initialize?(getter)
        methods = methods | [:initialize]
      end

      return methods
    end
579039
public static List<Method> getAllMethods(List<Method> methods, Class<?> clazz)
  {
    for (Method method : clazz.getDeclaredMethods())
    {
      methods.add(method);
    }

    if (clazz.getSuperclass() != null)
    {
      methods = getAllMethods(methods, clazz.getSuperclass());
    }

    return methods;
  }
1279355
public static LocalVariableAnnotation getParameterLocalVariableAnnotation(Method method, int local) {
        LocalVariableAnnotation lva = getLocalVariableAnnotation(method, local, 0, 0);
        if (lva.isNamed()) {
            lva.setDescription(LocalVariableAnnotation.PARAMETER_NAMED_ROLE);
        } else {
            lva.setDescription(LocalVariableAnnotation.PARAMETER_ROLE);
        }
        return lva;
    }
887724
def get_method_names(obj):
        
        method_names = []
        
        for method_name in dir(obj):

            method = getattr(obj, method_name)

            if MethodReflector._is_method(method, method_name):
                method_names.append(method_name)

        return method_names
837403
def lbmethods(self):
        '''
        
        '''
        methods = self.bigIP.LocalLB.Pool.typefactory.create(
            'LocalLB.LBMethod'
        )
        return [method[0].split('_', 2)[-1] for method in methods]
628973
def get_all_methods
      methods = []
      each_type do | type |
        type.each_method do |meth|
          methods << meth
        end
      end
      methods
    end
1040976
def all_method_names
      res = @class_methods.map {|m| m.full_name }
      @instance_methods.each {|m| res << m.full_name}
      res
    end