Returns list (null safe) of elements for desired key from dataSource files

@param key desired node key
@return list of elements for desired key
@throws IllegalArgumentException if no element for key has been found
18732
@SuppressWarnings("unchecked")
	@Override
	public List<String> getStringList(String key) {
		return getData(key, List.class);
	}
1134836
public String[] getArray(final String key) {
		final String value = getProperty(key);
		if (value != null) {
			final String[] strings = value.split(",[\\s]*|[\\s]*$");
			return strings;
		}
		return null;
	}
62963
E get(E key)
    {
        int idx = indexOf(key);
        if (idx >= 0)
        {
            return list.get(idx);
        }
        return null;
    }
191568
@Override
    public String[] getStringArray(final String key) {
        List<String> list = getList(key);
        return list.toArray(new String[list.size()]);
    }
949674
static
	public List<?> getContent(NDArray array, String key){
		Map<String, ?> content = (Map<String, ?>)array.getContent();

		return asJavaList(array, (List<?>)content.get(key));
	}
428985
@Override
    public List<Node> getNodes(ByteArray key) {
        logger.debug("Giving pref to localhost ! ");
        List<Node> nodes = null;
        List<Node> reorderedNodes = new ArrayList<Node>();

        try {
            nodes = super.getNodes(key);
            if(nodes == null) {
                return null;
            }

            String currentHost = InetAddress.getLocalHost().getHostName();
            for(Node n: nodes) {
                if(currentHost.contains(n.getHost()) || n.getHost().contains(currentHost)) {
                    logger.debug("Found localhost ! ");
                    reorderedNodes.add(n);
                    nodes.remove(n);
                    break;
                }
            }
            reorderedNodes.addAll(nodes);
            nodes = reorderedNodes;
        } catch(VoldemortException e) {
            pipelineData.setFatalError(e);
            return null;
        } catch(UnknownHostException e) {
            e.printStackTrace();
            return null;
        }
        return nodes;
    }
1236712
@SuppressWarnings("unchecked")
    public <T> List<T> getList(String key) {
        return Reflection.toType(get(key), List.class);
    }
470733
public JSONArray getArray(String key) {
        Object tmp = objectMap.get(key);
        return tmp == null ? null : tmp instanceof JSONArray ? (JSONArray) tmp
                : null;
    }
281007
public List<String> getKeys() {
        CodeGeneratorLoggerFactory.getLogger().debug(String.format("Reading keys from data file [%s]", fileName));
        List<String> keys = reader.getAllKeys();
        checkForDuplicateKeys(keys);
        return keys;
    }
1341282
public Map<String, String> getMBeanAttributes(String key) throws Exception {
        return getMBeanAttributes(new ObjectName(key));
    }
1160993
public <T> boolean containsKey(Key<T> key) {
        if (key == null) {
            throw new IllegalArgumentException("key must not be null");
        }
        return data.containsKey(key.getName());
    }
17258
public Optional<List<String>> getList(String key) {
    return this.get(key).map(v -> ImmutableList.copyOf(Splitter.on(',').split(v)));
  }
795361
public static Set<Key<?>> getAllUnboundKeys(List<Element> elements) {
        final Set<Key<?>> boundKeys = new HashSet<>();
        for (Element element : elements) {
            element.acceptVisitor(new DefaultElementVisitor<Void>() {
                public <T> Void visit(Binding<T> binding) {
                    boundKeys.add(binding.getKey());
                    return null;
                }
            });
        }

        final Set<Key<?>> foundKeys = new HashSet<>();
        
        for (Element element : elements) {
            element.acceptVisitor(new DefaultElementVisitor<Void>() {
                @Override
                public <T> Void visit(Binding<T> binding) {
                    binding.acceptTargetVisitor(new DefaultBindingTargetVisitor<T, Void>() {
                        @Override
                        public Void visit(ProviderKeyBinding<? extends T> binding) {
                            addFoundKeys(getUnboundDirectDependencies(binding.getProviderKey().getTypeLiteral(), boundKeys));
                            return null;
                        }

                        @Override
                        public Void visit(LinkedKeyBinding<? extends T> binding) {
                            if (!boundKeys.contains(binding.getLinkedKey())) {
                                addFoundKeys(getUnboundDirectDependencies(binding.getLinkedKey().getTypeLiteral(), boundKeys));
                            }
                            return null;
                        }

                        @Override
                        public Void visit(UntargettedBinding<? extends T> binding) {
                            addFoundKeys(getUnboundDirectDependencies(binding.getKey().getTypeLiteral(), boundKeys));
                            return null;
                        }

                        @Override
                        public Void visit(ConstructorBinding<? extends T> binding) {
                            addFoundKeys(getUnboundDirectDependencies(binding.getInjectableMembers(), boundKeys));
                            addFoundKeys(getUnboundDirectDependencies(binding.getDependencies(), boundKeys));
                            return null;
                        }

                        @Override
                        public Void visit(ProviderBinding<? extends T> binding) {
                            addFoundKeys(getUnboundDirectDependencies(binding.getProvidedKey().getTypeLiteral(), boundKeys));
                            return null;
                        }
                        
                        private void addFoundKeys(Set<Key<?>> keys) {
                            foundKeys.addAll(keys);
                        }
                    });
                    return null;
                }

                /**
                 * Visit a request to inject the instance fields and methods of an instance.
                 */
                @Override
                public Void visit(InjectionRequest<?> request) {
                    for (InjectionPoint ip : request.getInjectionPoints()) {
                        for (Dependency<?> dep : ip.getDependencies()) {
                            foundKeys.addAll(getUnboundDirectDependencies(dep.getKey().getTypeLiteral(), boundKeys));
                        }
                    }
                    return null;
                }

                /**
                 * Visit a request to inject the static fields and methods of type.
                 */
                @Override
                public Void visit(StaticInjectionRequest request) {
                    for (InjectionPoint ip : request.getInjectionPoints()) {
                        for (Dependency<?> dep : ip.getDependencies()) {
                            foundKeys.addAll(getUnboundDirectDependencies(dep.getKey().getTypeLiteral(), boundKeys));
                        }
                    }
                    return null;
                }

                
                /**
                 * Visit a lookup of the provider for a type.
                 */
                @Override
                public <T> Void visit(ProviderLookup<T> lookup) {
                    foundKeys.add(lookup.getDependency().getKey());
                    return null;
                }
            });
        }
        
        // Recursively look at the final list of unbound keys to further discover dependencies
        // and exclude keys that may be instantiated using the JIT
        for (Key<?> key : foundKeys) {
            discoverDependencies(key, boundKeys);
        }
        foundKeys.removeAll(boundKeys);
        foundKeys.remove(Key.get(Injector.class));
        return foundKeys;
    }
1031355
public String[] getArray(@NotNull final String key) {
        final String string = getString(key);
        if (string != null) {
            if (string.charAt(0) == '{' || string.charAt(0) == '[') {
                return new Gson().fromJson(string, String[].class);
            } else {
                return string.split(ARRAY_SEP);
            }
        }
        return null;
    }
329133
public List<ITopicNode> getTopicNodesForKey(final String key) {
        if (topicsKeys.containsKey(key)) {
            return topicsKeys.get(key);
        }

        return new LinkedList<ITopicNode>();
    }
539367
@SuppressWarnings("unchecked")
	private Vector<Object> getList(TreeMap<String, Object> map, String key) {
	    Object obj = null;
	    synchronized (map) {
	        obj = map.get(key);
	    }
	    
	    if (obj != null && obj instanceof Vector) {
	    	// ZAP: Added the type argument.
	        return (Vector<Object>) obj;
	    }
	    return null;
	    
	}
824008
public Collection<Argument> getArguments(final String key) {
        final Collection<Argument> args = map.get(key);
        if (args != null) {
            return new ArrayList<>(args);
        }
        return Collections.emptyList();
    }