Get the list of store names from a list of store definitions

@param list
@param ignoreViews
@return list of store names
764961
public static List<String> getStoreNames(List<StoreDefinition> list, boolean ignoreViews) {
        List<String> storeNameSet = new ArrayList<String>();
        for(StoreDefinition def: list)
            if(!def.isView() || !ignoreViews)
                storeNameSet.add(def.getName());
        return storeNameSet;
    }
22729
public static List<StoreDefinition> filterStores(List<StoreDefinition> storeDefs,
                                                     final boolean isReadOnly) {
        List<StoreDefinition> filteredStores = Lists.newArrayList();
        for(StoreDefinition storeDef: storeDefs) {
            if(storeDef.getType().equals(ReadOnlyStorageConfiguration.TYPE_NAME) == isReadOnly) {
                filteredStores.add(storeDef);
            }
        }
        return filteredStores;
    }
292765
public long list(List<Map<String,Object>> list, Map<String,Object> search, int skip, int max){
        return 0;
    }
300927
public List<String> getOrphansList() throws DuplicateBundlePathException {

		// Create a mapping for every resource available
		JoinableResourceBundleImpl tempBundle = new JoinableResourceOrphanBundleImpl("orphansTemp", "orphansTemp",
				this.resourceExtension, new InclusionPattern(), Collections.singletonList(this.baseDir), rsHandler,
				generatorRegistry);

		// Add licenses
		Set<String> licensesPathList = tempBundle.getLicensesPathList();
		for (Iterator<String> it = licensesPathList.iterator(); it.hasNext();) {
			addFileIfNotMapped(it.next());
		}

		// Add resources
		List<BundlePath> allPaths = tempBundle.getItemPathList();
		for (Iterator<BundlePath> it = allPaths.iterator(); it.hasNext();) {
			addFileIfNotMapped(it.next().getPath());
		}
		return this.bundleMapping;
	}
1149072
List<String> getNames() {
     if (addrList == null)
       return jmfNames;

     // Create a readonly list that extracts the 'names' information from the main list
     return new AbstractList<String>() {
       public int size() {
         return addrList.size();
       }
       public String get(int index) {
         return ((JsDestinationAddress)addrList.get(index)).getDestinationName();
       }
     };
   }
1028838
public static String[] getArrayOfNames(List<Dependency> dependencyList) {
        List<String> nameList = new LinkedList<String>();

        for (Dependency dependency : dependencyList) {
            nameList.add(dependency.getName());
        }

        return nameList.toArray(new String[nameList.size()]);
    }
700137
private boolean tableListIncludesReadOnlyView(List<Table> tableList) {
        for (Table table : tableList) {
            if (table.getMaterializer() != null && !TableType.isStream(table.getMaterializer().getTabletype())) {
                return true;
            }
        }
        return false;
    }
400548
protected final List<?> list(Object... datas) {
    List<Object> items = CollectUtils.newArrayList(datas.length);
    for (Object obj : datas) {
      if (obj instanceof Class<?>) {
        items.add(buildInnerReference((Class<?>) obj));
      } else {
        items.add(obj);
      }
    }
    return items;
  }
12911
@SuppressWarnings("unchecked")
    public static <E> List<E> without(final List<E> list, E ... values) {
        final List<E> valuesList = Arrays.asList(values);
        return filter(list, new Predicate<E>() {
            @Override
            public boolean test(E elem) {
                return !contains(valuesList, elem);
            }
        });
    }
31632
public static Set<String> getStoreNamesSet(List<StoreDefinition> storeDefList) {
        HashSet<String> storeSet = new HashSet<String>();
        for(StoreDefinition def: storeDefList) {
            storeSet.add(def.getName());
        }
        return storeSet;
    }
21033
private static List<String> addToList(List<String> list, String part, boolean isTrim, boolean ignoreEmpty){
		if(isTrim){
			part = StrUtil.trim(part);
		}
		if(false == ignoreEmpty || false == part.isEmpty()){
			list.add(part);
		}
		return list;
	}
1009448
public static List<Catalog> getCatalogs(@NonNull final MetadataContext context, final boolean nonempty)
            throws SQLException {
        final List<Catalog> catalogs = context.getCatalogs();
        if (catalogs.isEmpty() && nonempty) {
            final Catalog catalog = new Catalog();
            catalog.virtual = true;
            catalog.setTableCat("");
            catalogs.add(catalog);
            if (!context.isSuppressionPath("catalog/schemas")) {
                catalog.getSchemas().addAll(context.getSchemas(catalog.getTableCat(), ""));
            }
        }
        if (!context.isSuppressionPath("catalog/schemas")) {
            boolean allempty = true;
            for (final Catalog catalog : catalogs) {
                if (!catalog.getSchemas().isEmpty()) {
                    allempty = false;
                    break;
                }
            }
            if (allempty) {
                logger.warning("schemas are all empty");
                for (final Catalog catalog : catalogs) {
                    catalog.getSchemas().addAll(getSchemas(context, catalog.getTableCat(), true));
                }
            }
        }
        return catalogs;
    }
431132
public static <T> List<T> getOrNullList(Optional<T>... optionals) {
        return Arrays.stream(optionals).map(opt -> opt.orElse(null))
                .collect(Collectors.toList());
    }
364670
@Deprecated
  public SoyEasyList newEasyListFromList(SoyList list) {
    EasyListImpl result = new EasyListImpl();
    for (SoyValueProvider provider : list.asJavaList()) {
      result.add(provider);
    }
    return result;
  }
446345
def _get_dsnames(cls, data, ignore_keys=['attrs', 'plotter', 'ds'],
                     concat_dim=False):
        """"""
        def filter_ignores(item):
            return item[0] not in ignore_keys and isinstance(item[1], dict)
        if 'fname' in data:
            return {tuple(
                [data['fname'], data['store']] +
                ([data.get('concat_dim')] if concat_dim else []))}
        return set(chain(*map(partial(cls._get_dsnames, concat_dim=concat_dim,
                                      ignore_keys=ignore_keys),
                              dict(filter(filter_ignores,
                                          six.iteritems(data))).values())))
1108108
async def ignore_list(self, ctx):
        """"""

        ignored = self.config.get('ignored', [])
        channel_ids = set(c.id for c in ctx.message.server.channels)
        result = []
        for channel in ignored:
            if channel in channel_ids:
                result.append('<#{}>'.format(channel))

        if result:
            await self.bot.responses.basic(title="Ignored Channels:", message='\n\n{}'.format(', '.join(result)))
        else:
            await self.bot.responses.failure(message='I am not ignoring any channels here.')
1163692
function ignoreFactory (ignoreList) {

    if (typeof ignoreList === 'function') {
        return ignoreList;
    }

    var fn = ignore().add(ignoreList || []);

    // @param   {String}
    // @return  {Boolean}
    return ignoreList.length ? function (src) {

        if (!src) {
            return false;
        }

        return !fn.filter([src])[0];

    } : function () {
        return false;
    };
}