Get the value as a list

@param formatter
the CCS target
@return the value
15235
public Operation listValue( CssFormatter formatter ) {
        Expression expr = unpack( formatter );
        if( expr == this ) {
            throw createException( "Exprestion is not a list: " + this );
        }
        return expr.listValue( formatter );
    }
369045
public List<T> parseList(JsonParser jsonParser) throws IOException {
        List<T> list = new ArrayList<>();
        if (jsonParser.getCurrentToken() == JsonToken.START_ARRAY) {
            while (jsonParser.nextToken() != JsonToken.END_ARRAY) {
                list.add(parse(jsonParser));
            }
        }
        return list;
    }
695475
public static <T> Parser<List<T>> list(Iterable<? extends Parser<? extends T>> parsers) {
    final Parser<? extends T>[] array = toArray(parsers);
    return new Parser<List<T>>() {
      @Override boolean apply(ParseContext ctxt) {
        ArrayList<T> list = Lists.arrayList(array.length);
        for (Parser<? extends T> parser : array) {
          if (!parser.apply(ctxt)) return false;
          list.add(parser.getReturn(ctxt));
        }
        ctxt.result = list;
        return true;
      }
      
      @Override public String toString() {
        return "list";
      }
    };
  }
763620
static List<TypeParameter> parseList(final Parser parser, final String definingClassName)
            throws ParseException {
        if (parser.peek() != '<') {
            return Collections.emptyList();
        }
        parser.expect('<');
        final List<TypeParameter> typeParams = new ArrayList<>(1);
        while (parser.peek() != '>') {
            if (!parser.hasMore()) {
                throw new ParseException(parser, "Missing '>'");
            }
            if (!TypeUtils.getIdentifierToken(parser)) {
                throw new ParseException(parser, "Could not parse identifier token");
            }
            final String identifier = parser.currToken();
            // classBound may be null
            final ReferenceTypeSignature classBound = ReferenceTypeSignature.parseClassBound(parser,
                    definingClassName);
            List<ReferenceTypeSignature> interfaceBounds;
            if (parser.peek() == ':') {
                interfaceBounds = new ArrayList<>();
                while (parser.peek() == ':') {
                    parser.expect(':');
                    final ReferenceTypeSignature interfaceTypeSignature = ReferenceTypeSignature
                            .parseReferenceTypeSignature(parser, definingClassName);
                    if (interfaceTypeSignature == null) {
                        throw new ParseException(parser, "Missing interface type signature");
                    }
                    interfaceBounds.add(interfaceTypeSignature);
                }
            } else {
                interfaceBounds = Collections.emptyList();
            }
            typeParams.add(new TypeParameter(identifier, classBound, interfaceBounds));
        }
        parser.expect('>');
        return typeParams;
    }
993067
public Iterator getFilterList(BaseMessageHeader messageHeader)
    {
        Iterator iterator = null;
        Object[][] mxString = messageHeader.getNameValueTree();
        NameValue node = this;
        int iIndex = -1;
        while (node != null)
        {
            Iterator nodeIterator = node.getFilterIterator();
            if (nodeIterator != null)
            {
                if (iterator == null)
                    iterator = nodeIterator;
                else
                {
                    if (!(iterator instanceof MultiIterator))
                        iterator = new MultiIterator(iterator);
                    ((MultiIterator)iterator).addIterator(nodeIterator);
                }
            }
            iIndex++;
            if ((mxString != null) && (iIndex < mxString.length))
                node = node.getNameValueNode((String)mxString[iIndex][MessageConstants.NAME], mxString[iIndex][MessageConstants.VALUE], false);
            else
                node = null;    // done
        }
        if (iterator == null)
            return gEmptyIterator;
        return iterator;
    }
209028
public List<GetterType<BeanType<T>>> getAllGetter()
   {
      List<GetterType<BeanType<T>>> list = new ArrayList<GetterType<BeanType<T>>>();
      List<Node> nodeList = childNode.get("getter");
      for(Node node: nodeList)
      {
         GetterType<BeanType<T>>  type = new GetterTypeImpl<BeanType<T>>(this, "getter", childNode, node);
         list.add(type);
      }
      return list;
   }
772501
public List<String> getValueList() {
        if (tokensList == null) {
            return null;
        }
        if (tokensList.isEmpty()) {
            return new ArrayList<>();
        } else {
            List<String> list = new ArrayList<>(tokensList.size());
            for (Token[] tokens : tokensList) {
                list.add(TokenParser.toString(tokens));
            }
            return list;
        }
    }
545431
public static Formatter getFormatter()
    {
        Formatter formatter = out.get();
        if (formatter == null)
        {
            formatter = new Formatter(new StringBuilder());
            out.set(formatter);
        }
        else
        {
            StringBuilder sb = (StringBuilder) formatter.out();
            sb.setLength(0);
        }
        return formatter;
    }
1206519
public static String formatParameterList(Collection<String> value) {
		return value == null ? null : StringUtils.collectionToDelimitedString(value, " ");
	}
801726
protected static List<String> getHeadIncludes(I_CmsFormatterBean formatter, String type) {

        if (TYPE_CSS.equals(type)) {
            return Lists.newArrayList(formatter.getCssHeadIncludes());
        } else if (TYPE_JAVASCRIPT.equals(type)) {
            return formatter.getJavascriptHeadIncludes();
        }
        return null;
    }
730782
protected<T, C extends Collection<T>> ParamListValidator<T, C> getListValidator(ParamValidator<T> validator) {

        if (validator == null) {
            return null;
        }

        return new ParamListValidator<T, C>(validator);
    }
669000
protected static String getInlineData(I_CmsFormatterBean formatter, String type) {

        if (TYPE_CSS.equals(type)) {
            return formatter.getInlineCss();
        } else if (TYPE_JAVASCRIPT.equals(type)) {
            return formatter.getInlineJavascript();
        }
        return null;
    }
1329583
private static List<Integer> parseArray(String value, ValueParser parser){
		final List<Integer> values = new ArrayList<>();
	
		final List<String> parts = StrUtil.split(value, StrUtil.C_COMMA);
		for (String part : parts) {
			CollectionUtil.addAllIfNotContains(values, parseStep(part, parser));
		}
		return values;
	}
500970
@Override
    public List<String> getStringList( final String    key,
                                       final String    delim )
    {
        return formatStringList( key, getFormattedPropValue( key ), delim );
    }
369824
private void format( CssFormatter formatter ) {
        String fmt = get( 0 ).stringValue( formatter );
        int idx = 1;
        for( int i = 0; i < fmt.length(); i++ ) {
            char ch = fmt.charAt( i );
            if( ch == '%' ) {
                ch = fmt.charAt( ++i );
                switch( ch ){
                    case '%':
                        formatter.append( ch );
                        break;
                    case 'a':
                    case 'd':
                        get( idx++ ).appendTo( formatter );
                        break;
                    case 'A':
                    case 'D':
                        String str = get( idx++ ).stringValue( formatter );
                        try {
                            str = new URI( null, null, str, null ).getRawPath();
                        } catch( URISyntaxException e ) {
                            e.printStackTrace();
                        }
                        formatter.append( str );
                        break;
                    case 's':
                        formatter.setInlineMode( true );
                        get( idx++ ).appendTo( formatter );
                        formatter.setInlineMode( false );
                        break;
                    case 'S':
                        formatter.setInlineMode( true );
                        str = get( idx++ ).stringValue( formatter );
                        try {
                            str = new URI( null, null, str, null ).getRawPath();
                        } catch( URISyntaxException e ) {
                            e.printStackTrace();
                        }
                        formatter.append( str );
                        formatter.setInlineMode( false );
                        break;
                    default:
                        formatter.append( ch );
                }
            } else {
                formatter.append( ch );
            }
        }
    }
1025223
public List<CmsFormatterBean> getFormatters() {

        CmsFormatterBean mainFormatter = createFormatterBean(m_mainFormat, true);
        List<CmsFormatterBean> formatters = new ArrayList<CmsFormatterBean>();
        formatters.add(mainFormatter);
        for (Format format : m_otherFormats) {
            formatters.add(createFormatterBean(format, false));
        }
        return formatters;
    }
918845
public org.tensorflow.framework.AttrValue.ListValue getList() {
    if (valueCase_ == 1) {
       return (org.tensorflow.framework.AttrValue.ListValue) value_;
    }
    return org.tensorflow.framework.AttrValue.ListValue.getDefaultInstance();
  }