GetMethodVariables.
1316
public String getMethodVariables(String strMethodInterface)
    {
        int endChar = 0, startChar = 0;
        String strMethodVariables = "";
        int i = 0;
        boolean bBracketFound = false;
        for (i = 0; i < strMethodInterface.length(); i++)
        {
            if (strMethodInterface.charAt(i) == '<')
                bBracketFound = true;
            if (strMethodInterface.charAt(i) == '>')
                bBracketFound = false;
            if (bBracketFound)
                continue;   // Skip the area between the brackets.
            if (strMethodInterface.charAt(i) == ' ')
                startChar = i + 1;
            if (strMethodInterface.charAt(i) == ',')
            {
                endChar = i;
                if (endChar > startChar)
                {
                    if (strMethodVariables.length() != 0)
                        strMethodVariables += ", ";
                    strMethodVariables += strMethodInterface.substring(startChar, endChar);
                }
            }
        }
        endChar = i;
        if (endChar > startChar)
        {
            if (strMethodVariables.length() != 0)
                strMethodVariables += ", ";
            strMethodVariables += strMethodInterface.substring(startChar, endChar);
        }
        return strMethodVariables;
    }
702340
public List<String> getVariables() {
    return this.templateChunks.stream()
        .filter(templateChunk -> Expression.class.isAssignableFrom(templateChunk.getClass()))
        .map(templateChunk -> ((Expression) templateChunk).getName())
        .filter(Objects::nonNull)
        .collect(Collectors.toList());
  }
1329735
private String getMethodName(Method method) {
        StatName statName = method.getAnnotation(StatName.class);
        return statName == null ? method.getName() : statName.value();
    }
619634
@Override
  public Set<String> getVariables() {
    Set<String> variables = new HashSet<>();
    if(lhs.getVariable() != null) variables.add(lhs.getVariable());
    if(rhs.getVariable() != null) variables.add(rhs.getVariable());

    return variables;
  }
842395
def get_methods(self):
        
        for c in self.classes.values():
            for m in c.get_methods():
                yield m
566220
def GetAnnotatedMethods(cls):
    """"""

    result = {}

    # We want methods with the highest call-order to be processed last,
    # so that their annotations have precedence.
    for i_cls in reversed(inspect.getmro(cls)):
      for name in compatibility.ListAttrs(i_cls):
        cls_method = getattr(i_cls, name)

        if not callable(cls_method):
          continue

        if not hasattr(cls_method, "__http_methods__"):
          continue

        result[name] = RouterMethodMetadata(
            name=name,
            doc=cls_method.__doc__,
            args_type=getattr(cls_method, "__args_type__", None),
            result_type=getattr(cls_method, "__result_type__", None),
            category=getattr(cls_method, "__category__", None),
            http_methods=getattr(cls_method, "__http_methods__", set()),
            no_audit_log_required=getattr(cls_method,
                                          "__no_audit_log_required__", False))

    return result
319211
def variables(self):
        """"""
        variables = set([])
        for node in self.nodes:
            variables.add(node.variable)
        return sorted(variables)
522499
public static String[] getParameterNames(CtMethod ctMethod) throws NotFoundException {
		MethodInfo methodInfo = ctMethod.getMethodInfo();
		CodeAttribute codeAttribute = methodInfo.getCodeAttribute();
		// logger.info("methodInfo.getConstPool().getSize():");
		LocalVariableAttribute attribute = (LocalVariableAttribute) codeAttribute.getAttribute(LocalVariableAttribute.tag);
		// String[] names = new String[attribute.tableLength() - 1];
		String[] paramNames = new String[ctMethod.getParameterTypes().length];

		int pos = 0;
		if (true) {
			int size = attribute.tableLength();
			if (size > 0) {
				String[] names = new String[size - 1];
				for (int i = 0; i < names.length; i++) {
					names[i] = attribute.variableName(i);
					if ("this".equals(names[i])) {
						pos = i + 1;
						break;
					}
				}
				// logger.info(methodInfo.getName() + " pos:" + pos + " allNames:" + StringUtils.join(names, ", "));
			}
		}

		// logger.info(methodInfo.getName() + " pos:" + pos);
		for (int i = 0; i < paramNames.length; i++) {
			// paramNames[i] = attribute.variableName(i + 1);
			try {
				paramNames[i] = attribute.variableName(i + pos);
				// logger.info("paramNames[" + i + "]:" + paramNames[i]);
			}
			catch (RuntimeException e) {
				throw e;
			}
		}
		// System.err.println("paramNames:" + StringUtils.join(paramNames));
		return paramNames;
	}
340385
private String getSuperMethodCallParameters(ExecutableElement sourceMethod) {
    return sourceMethod
        .getParameters()
        .stream()
        .map(parameter -> parameter.getSimpleName().toString())
        .collect(Collectors.joining(", "));
  }
66688
def _get_variables(self):
        """"""
        if self._specs_in[_VARIABLES_STR] == 'all':
            return _get_all_objs_of_type(
                Var, getattr(self._obj_lib, 'variables', self._obj_lib)
            )
        else:
            return set(self._specs_in[_VARIABLES_STR])
1128164
def get_kwargs(self):
        """"""
        return {k: v for k, v in vars(self).items() if k not in self._ignored}
1190172
protected function getVariables() {
        if (!$this->_variables) {
            $this->_variables = new VariableList(
                $this->version,
                $this->solution['serviceSid'],
                $this->solution['sid']
            );
        }

        return $this->_variables;
    }
1020467
public function getVariables() 
	{
		$variables = parent::getVariables();
		
		$loaded = self::$loaded;
		self::$loaded = true;
		
		$variables['loaded'] = $loaded;
		
		return $variables;
	}
1176416
def get_variables(expression, variables=None):
    """"""
    if variables is None:
        variables = set()
    if hasattr(expression, 'variable_name') and expression.variable_name is not None:
        variables.add(expression.variable_name)
    if isinstance(expression, Operation):
        for operand in op_iter(expression):
            get_variables(operand, variables)
    return variables
487159
private List<Method> paramGetMethods() {

        List<Method> list = new ArrayList<Method>();
        Method[] methods = this.getClass().getMethods();
        int length = methods.length;
        for (int i = 0; i < length; i++) {
            Method method = methods[i];
            if (method.getName().startsWith("getParam") && (method.getParameterTypes().length == 0)) {
                if (DEBUG) {
                    System.err.println("getMethod: " + method.getName());
                }
                list.add(method);
            }
        }
        return list;
    }
1280829
private static <T> List<Method> getMethods(Class<T> type, String... names) {

		Assert.notNull(type, "Missing class to search for methods!");
		Assert.notNullOrEmpty(names, "Missing method names to search for!");

		Map<String, Method> candidates = new HashMap<>();
		for (Method method : type.getMethods()) {

			if (Modifier.isStatic(method.getModifiers()) &&
			    method.getReturnType().equals(type) &&
			    method.getParameterTypes().length == 1 &&
			    method.getParameterTypes()[0].isAssignableFrom(String.class)) {

				candidates.put(method.getName(), method);
			}
		}

		List<Method> output = new ArrayList<>();

		// go in order desired
		for (String name : names) {
			if (candidates.containsKey(name)) {
				output.add(candidates.get(name));
			}
		}

		return output;
	}
1355827
def __getVariables(self):
        """'"""
        try:
            startupinfo = None
            if os.name == 'nt':
                startupinfo = subprocess.STARTUPINFO()
                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
            output = subprocess.check_output(['p4', 'set'], startupinfo=startupinfo)
            if six.PY3:
                output = str(output, 'utf8')
        except subprocess.CalledProcessError as err:
            LOGGER.error(err)
            return

        p4vars = {}
        for line in output.splitlines():
            if not line:
                continue
            try:
                k, v = line.split('=', 1)
            except ValueError:
                continue
            p4vars[k.strip()] = v.strip().split(' (')[0]
            if p4vars[k.strip()].startswith('(config'):
                del p4vars[k.strip()]

        self._port = self._port or os.getenv('P4PORT', p4vars.get('P4PORT'))
        self._user = self._user or os.getenv('P4USER', p4vars.get('P4USER'))
        self._client = self._client or os.getenv('P4CLIENT', p4vars.get('P4CLIENT'))