/*
(non-Javadoc)
@see javax.naming.Context#list(java.lang.String)
481554
@Override
	public NamingEnumeration<NameClassPair> list(String name) throws NamingException
    {
        return list(new CompositeName(name));
    }
208313
public static int listFindNoCase(String list, String value, String delimiter) {
	return listFindNoCase(list, value, delimiter, true);
    }
18732
@SuppressWarnings("unchecked")
	@Override
	public List<String> getStringList(String key) {
		return getData(key, List.class);
	}
634485
public static void removeFromList(List<String> list, String value) {
        int foundIndex = -1;
        int i = 0;
        for (String id : list) {
            if (id.equalsIgnoreCase(value)) {
                foundIndex = i;
                break;
            }
            i++;
        }
        if (foundIndex != -1) {
            list.remove(foundIndex);
        }
    }
199142
public Collection<? extends NameClassPair> listInstances(NamingConstants.JavaColonNamespace namespace, String contextName) throws NamingException {
        if (namespace == NamingConstants.JavaColonNamespace.COMP) {
            return listInstances(compLock, compBindings, contextName);
        }
        if (namespace == NamingConstants.JavaColonNamespace.COMP_ENV) {
            return listInstances(compLock, compEnvBindings, contextName);
        }
        if (namespace == this.namespace) {
            return listInstances(nonCompEnvLock, nonCompBindings, contextName);
        }
        return Collections.emptyList();
    }
489788
public void setList(List<?> list) {
		this.checkNull(list);
		this.list.add(list);
		this.type.add(List.class);
	}
1236712
@SuppressWarnings("unchecked")
    public <T> List<T> getList(String key) {
        return Reflection.toType(get(key), List.class);
    }
565152
@Override
	public NamingEnumeration<Binding> listBindings(String name) throws NamingException
    {
        return listBindings(new CompositeName(name));
    }
425911
public final void qualifiedNameList() throws RecognitionException {
		int qualifiedNameList_StartIndex = input.index();

		try {
			if ( state.backtracking>0 && alreadyParsedRule(input, 55) ) { return; }

			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:562:5: ( qualifiedName ( ',' qualifiedName )* )
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:562:7: qualifiedName ( ',' qualifiedName )*
			{
			pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2001);
			qualifiedName();
			state._fsp--;
			if (state.failed) return;
			// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:562:21: ( ',' qualifiedName )*
			loop77:
			while (true) {
				int alt77=2;
				int LA77_0 = input.LA(1);
				if ( (LA77_0==43) ) {
					alt77=1;
				}

				switch (alt77) {
				case 1 :
					// src/main/resources/org/drools/compiler/semantics/java/parser/Java.g:562:22: ',' qualifiedName
					{
					match(input,43,FOLLOW_43_in_qualifiedNameList2004); if (state.failed) return;
					pushFollow(FOLLOW_qualifiedName_in_qualifiedNameList2006);
					qualifiedName();
					state._fsp--;
					if (state.failed) return;
					}
					break;

				default :
					break loop77;
				}
			}

			}

		}
		catch (RecognitionException re) {
			reportError(re);
			recover(input,re);
		}
		finally {
			// do for sure before leaving
			if ( state.backtracking>0 ) { memoize(input, 55, qualifiedNameList_StartIndex); }

		}
	}
773917
List<? extends E> list() {
		List<E> result = new ArrayList<E>();
		while (hasNext()) {
			result.add(next());
		}
		return result;
	}
93390
private void addToList(List<Object> list, Object value) {
    if (value instanceof List) {
      list.addAll((List) value);
    } else {
      list.add(value);
    }
  }
1204637
@Override
    public <E> ListAttribute<? super X, E> getList(String paramName, Class<E> paramClass)
    {
        PluralAttribute<X, ?, ?> declaredAttrib = getDeclaredPluralAttribute(paramName);

        if (onCheckListAttribute(declaredAttrib, paramClass))
        {
            return (ListAttribute<X, E>) declaredAttrib;
        }

        PluralAttribute<? super X, ?, ?> superAttrib = getPluralAttriute(paramName);

        if (onCheckListAttribute(superAttrib, paramClass))
        {
            return (ListAttribute<? super X, E>) superAttrib;

        }
        throw new IllegalArgumentException(
                "attribute of the given name and type is not present in the managed type, for name:" + paramName
                        + " , type:" + paramClass);
    }
807957
public void setCrawlerNameList(java.util.Collection<String> crawlerNameList) {
        if (crawlerNameList == null) {
            this.crawlerNameList = null;
            return;
        }

        this.crawlerNameList = new java.util.ArrayList<String>(crawlerNameList);
    }
181888
public static <T,W> List<W> listSecond(List<Pair<T, W>> list) {
        ArrayList<W> ts = new ArrayList<W>();
        for (Pair<T, W> twPair : list) {
            ts.add(twPair.getSecond());
        }
        return ts;
    }
620863
public static <T> String listToString(List<T> list) {
    StringBuilder sb = new StringBuilder();
    for (T s : list) {
      if (sb.length() != 0) {
        sb.append(" ");
      }
      sb.append(s);
    }
    return sb.toString();
  }
101982
@Override
	public boolean add(String string) {
		if (filter.accept(string)) {
			list.add(string);
			return true;
		}
		return false;
	}
709111
@NotNull
    public static List<String> toList(@Nullable final String stringList, @NotNull final String delimiter) {
        return new ArrayList<>(Arrays.asList(toArray(stringList, delimiter)));
    }