Get a list of all JSON-RPC methods from all defined traits
511473
function getMethodsFromRustTraits () {
  const traitsDir = path.join(__dirname, '../../.parity/rpc/src/v1/traits');

  return fs
    .readdirSync(traitsDir)
    .filter((name) => name !== 'mod.rs' && /\.rs$/.test(name))
    .map((name) => fs.readFileSync(path.join(traitsDir, name)))
    .map(parseMethodsFromRust)
    .reduce((a, b) => a.concat(b));
}
974810
private Map<MethodSymbol, Attribute> getAllValues() {
        Map<MethodSymbol, Attribute> res =
            new LinkedHashMap<MethodSymbol, Attribute>();

        // First find the default values.
        ClassSymbol sym = (ClassSymbol) anno.type.tsym;
        for (Scope.Entry e = sym.members().elems; e != null; e = e.sibling) {
            if (e.sym.kind == Kinds.MTH) {
                MethodSymbol m = (MethodSymbol) e.sym;
                Attribute def = m.getDefaultValue();
                if (def != null)
                    res.put(m, def);
            }
        }
        // Next find the explicit values, possibly overriding defaults.
        for (Pair<MethodSymbol, Attribute> p : anno.values)
            res.put(p.fst, p.snd);
        return res;
    }
1333073
public static MessageMarshaller jsonMarshaller(List<MethodDescriptor<?, ?>> methods) {
        final MessageMarshaller.Builder builder = MessageMarshaller.builder()
                                                                   .omittingInsignificantWhitespace(true)
                                                                   .ignoringUnknownFields(true);
        for (MethodDescriptor<?, ?> method : methods) {
            marshallerPrototype(method.getRequestMarshaller()).ifPresent(builder::register);
            marshallerPrototype(method.getResponseMarshaller()).ifPresent(builder::register);
        }
        return builder.build();
    }
666207
private function mergeTraitMethods()
    {
        $reflection = $this->__reflection();
        $mergedMethods = [];
        do {
            $staticProperties = $reflection->getStaticProperties();

            if (!isset($staticProperties['___classMocker_traitMethods'])) {
                continue;
            }

            $mergedMethods = array_merge_recursive($mergedMethods, $staticProperties['___classMocker_traitMethods']);
        } while ($reflection = $reflection->getParentClass());

        return $mergedMethods;
    }
760917
def collect(cls):
        
        constants = {}

        for method_path in WebpackConstants.get_constant_processors():
            method = import_string(method_path)

            if not callable(method):
                raise ImproperlyConfigured('Constant processor "%s" is not callable' % method_path)

            result = method(constants)

            if isinstance(result, dict):
                constants.update(result)

        return constants
1116640
function getMutations(spec, attr) {
      var fns = compose(extraction, cleanup, stitch)(spec);
      return _.callmap(fns, attr);
    }
214779
def get_method_bridges(self, name, arg_types=()):
        

        for m in self.get_methods_by_name(name):
            if ((m.is_bridge() and
                 m.get_arg_type_descriptors() == arg_types)):
                yield m
505813
def get_all_methods(self, entry_point=ALL, protocol=ALL, sort_methods=False):
        """"""

        if sort_methods:
            return [
                method for (_, method) in sorted(self._registry.items()) if method.is_valid_for(entry_point, protocol)
            ]

        return self._registry.values()
1274494
private List<MethodNode> findMacroMethods(String methodName, List<Expression> callArguments) {
        List<MethodNode> methods = MacroMethodsCache.get(classLoader).get(methodName);

        if (methods == null) {
            // Not a macro call
            return Collections.emptyList();
        }

        ClassNode[] argumentsList = new ClassNode[callArguments.size()];

        for (int i = 0; i < callArguments.size(); i++) {
            argumentsList[i] = ClassHelper.make(callArguments.get(i).getClass());
        }

        return StaticTypeCheckingSupport.chooseBestMethod(MACRO_CONTEXT_CLASS_NODE, methods, argumentsList);
    }
405888
def _get_rh_methods(rh):
    """"""
    for k, v in vars(rh).items():
        if all([
            k in HTTP_METHODS,
            is_method(v),
            hasattr(v, "input_schema")
        ]):
            yield (k, v)
1264480
function getJavaScriptCallbackParameterListSimple(parameters) {
    var result = []

    parameters.forEach(function(parameter){
        if (!parameter.out) return
        result.push("/*" + getIdlType(parameter.type) + "*/ "+ parameter.name)
    })

    return result.join(", ")
}
251733
function traits() {
    for (var _len = arguments.length, traitList = Array(_len), _key = 0; _key < _len; _key++) {
        traitList[_key] = arguments[_key];
    }

    return function (target) {
        traitList.forEach(function (trait) {
            _addTrait.call(target, trait);
        });
    };
}
1288634
static <T extends Annotation> List<List<T>> getParameterAnnotations(Method method, Class<T> type) {
		List<List<T>> annotations = new ArrayList<>();
		for (List<Annotation> paramAnnotations : getParameterAnnotations(method)) {
			annotations.add(filterAnnotations(paramAnnotations, type));
		}
		return annotations;
	}
211093
def get_all_attributes(klass_or_instance):
    
    pairs = list()
    for attr, value in inspect.getmembers(
            klass_or_instance, lambda x: not inspect.isroutine(x)):
        if not (attr.startswith("__") or attr.endswith("__")):
            pairs.append((attr, value))
    return pairs
749829
private Map<MethodSymbol, Attribute> getAllValues() {
        Map<MethodSymbol, Attribute> res = new LinkedHashMap<>();

        // First find the default values.
        ClassSymbol sym = (ClassSymbol) anno.type.tsym;
        for (Symbol s : sym.members().getSymbols(NON_RECURSIVE)) {
            if (s.kind == MTH) {
                MethodSymbol m = (MethodSymbol) s;
                Attribute def = m.getDefaultValue();
                if (def != null)
                    res.put(m, def);
            }
        }
        // Next find the explicit values, possibly overriding defaults.
        for (Pair<MethodSymbol, Attribute> p : anno.values)
            res.put(p.fst, p.snd);
        return res;
    }
439172
protected List<Method> getMethods(Class type, String name)
    {
        return introspector(type).getMethods( toJavaIdentifierForm(name));
    }
1141003
private static List<Method> getMethodsList(final Class cls, final boolean declared) {
		$.checkNotNull(cls);

		final List<Method> allMethods = new ArrayList<Method>();
		Class currentClass = cls;
		while (currentClass != null) {
			final Method[] methods = declared ? currentClass.getDeclaredMethods() : currentClass.getMethods();
			for (Method method : methods) {
				allMethods.add(method);
			}
			currentClass = currentClass.getSuperclass();
		}
		return allMethods;
	}