Returns parser function to represents value as a list.

        Parses a value applying given methods one after another.

        :param parse_methods:
        :rtype: callable
340041
def _get_parser_compound(cls, *parse_methods):
        
        def parse(value):
            parsed = value

            for method in parse_methods:
                parsed = method(parsed)

            return parsed

        return parse
683981
def GetNamesOfParsersWithPlugins(cls):
    
    parser_names = []

    for parser_name, parser_class in cls.GetParsers():
      if parser_class.SupportsPlugins():
        parser_names.append(parser_name)

    return sorted(parser_names)
16831
def parse(self, expression):
        
        if isinstance(expression, (list, dict)):
            return (True if expression else False, expression)
        if sys.version_info[0] > 2:
            self.next = self.tokenize(expression).__next__
        else:
            self.next = self.tokenize(expression).next
        self.token = self.next()
        return self.expression()
707038
def parse_value_array(parser, event, node): #pylint: disable=unused-argument
    # pylint: disable=invalid-name
    

    value_array = []

    (next_event, next_node) = six.next(parser)

    if _is_start(next_event, next_node, 'VALUE'):

        value_array.append(parse_value(parser, next_event, next_node))

        while 1:

            (next_event, next_node) = six.next(parser)

            if _is_end(next_event, next_node, 'VALUE.ARRAY'):
                break

            if _is_start(next_event, next_node, 'VALUE'):
                value_array.append(parse_value(parser, next_event, next_node))
            else:
                raise ParseError('Expecting VALUE element')

    return value_array
702396
def parse_list(cls, api, json_list):
        
        results = []
        for json_obj in json_list:
            if json_obj:
                obj = cls.parse(api, json_obj)
                results.append(obj)

        return results
651888
def _parse(self):
        
        # Is this a shorthand template?
        if self._element.tag == 'template':
            return self._parse_template(self._element)

        # Is this a shorthand redirect?
        if self._element.tag == 'redirect':
            return self._parse_redirect(self._element)

        for child in self._element:
            method_name = '_parse_' + child.tag

            if hasattr(self, method_name):
                parse = getattr(self, method_name)
                parse(child)
917498
def _apply_list(self, methods):
    
    def call(value):
      for method in methods:
        newvalue = method(self, value)
        if newvalue is not None:
          value = newvalue
      return value
    return call
1124177
def parse_options(self, option_values):
        
        self.set_options_values(option_values, parse=True)
        return self.get_options_values(hidden=False)
657828
public List<String> parseMethodList(String methods) {

        String[] methodArray = StringUtils.delimitedListToStringArray(methods, ",");

        List<String> methodList = new ArrayList<String>();

        for (String methodName : methodArray) {
            methodList.add(methodName.trim());
        }
        return methodList;
    }
459322
def parse_options(self, options):
        
        for name in self.get_option_names():
            parse = getattr(self, "parse_option_{name:s}".format(
                name=name), None)
            if parse is not None and isinstance(parse, collections.Callable):
                options[name] = parse()
        return options
540121
def parse(self, *args, **kwargs):  # pylint: disable=unused-argument
        
        # pylint: disable=W0703
        cmd = args[0]
        resp = args[1]
        if cmd in self.parsers:
            try:
                return self.parsers[cmd](resp)
            except Exception as err:
                print(err)
        return {}
748219
private List<String> parseMethodParams(String methodParameters, Node methodSignature) {
    List<String> parsedParameters = new ArrayList<>();

    char nextDelimeter = ',';
    String currentTerm = "";
    for (int i = 0; i < methodParameters.length(); i++) {
      if (methodParameters.charAt(i) == nextDelimeter) {
        if (nextDelimeter == ',') {
          parsedParameters.add(currentTerm.trim());
          currentTerm = "";
        } else {
          currentTerm += nextDelimeter;
          nextDelimeter = ',';
        }
      } else {
        currentTerm += methodParameters.charAt(i);
        if (methodParameters.charAt(i) == '"' || methodParameters.charAt(i) == '\'') {
          nextDelimeter = methodParameters.charAt(i);
        }
      }
    }
    if (nextDelimeter != ',') {
      compiler.report(JSError.make(methodSignature, PolymerPassErrors.POLYMER_UNPARSABLE_STRING));
      return parsedParameters;
    }
    if (currentTerm.length() > 0) {
      parsedParameters.add(currentTerm.trim());
    }
    return parsedParameters;
  }
1173162
def p_parse(cls, input, methodname=None, parse_all=True):
        
        if methodname is None:
            methodname = cls.__default__
        p = cls(input)
        result = getattr(p, methodname)()
        if result is cls.NoMatch or parse_all and p.p_peek() is not None:
            p.p_raise()
        return result
211612
def parse(self, *args):
        

        if isinstance(self.dictionary, dict):
            return self.dictionary

        raise self.subparserException("Argument passed to Dictionary SubParser is not a dict: %s" % type(self.dictionary))
587148
def iter_parsed_values(self, field: Field) -> Iterable[Tuple[str, Any]]:
        
        for key, func in self.parsers.items():
            value = func(field)
            if not value:
                continue
            yield key, value
553157
def _parse_calls_data(klass, format_, infos, gt_str):
        
        data = OrderedDict()
        # The standard is very nice to parsers, we can simply split at
        # colon characters, although I (Manuel) don't know how strict
        # programs follow this
        for key, info, value in zip(format_, infos, gt_str.split(":")):
            data[key] = parse_field_value(info, value)
        return data
384706
def parse(self, arguments):
    
    new_values = self._parse(arguments)
    if self.present:
      self.value.extend(new_values)
    else:
      self.value = new_values
    self.present += len(new_values)