Returns the list of store defs as a map

@param storeDefs
@return
7178
private HashMap<String, StoreDefinition> makeStoreDefinitionMap(List<StoreDefinition> storeDefs) {
        HashMap<String, StoreDefinition> storeDefMap = new HashMap<String, StoreDefinition>();
        for(StoreDefinition storeDef: storeDefs)
            storeDefMap.put(storeDef.getName(), storeDef);
        return storeDefMap;
    }
316673
private final Collection<List<String>> catalogKeys(final Collection<String> keyCollections) {
    final Map<Session, List<String>> catalogMap = new HashMap<Session, List<String>>();

    for (String key : keyCollections) {
      Session index = this.sessionLocator.getSessionByKey(key);
      List<String> tmpKeys = catalogMap.get(index);
      if (tmpKeys == null) {
        tmpKeys = new ArrayList<String>(10);
        catalogMap.put(index, tmpKeys);
      }
      tmpKeys.add(key);
    }

    Collection<List<String>> catalogKeys = catalogMap.values();
    return catalogKeys;
  }
1304910
public <T> List<Key<T>> getKeysByManualRefs(final Class<T> clazz, final List<Object> refs) {
        final String collection = getCollectionName(clazz);
        final List<Key<T>> keys = new ArrayList<Key<T>>(refs.size());
        for (final Object ref : refs) {
            keys.add(this.<T>manualRefToKey(collection, ref));
        }

        return keys;
    }
918110
public static StoreDefinition getStoreDef(List<StoreDefinition> list, String name) {
        for(StoreDefinition def: list)
            if(def.getName().equals(name))
                return def;
        return null;
    }
831744
@SuppressWarnings("unchecked")
	public <T> Map<Serializable, T> get(Collection<? extends Serializable> keys) {
		Map<Serializable, T> result = Maps.newHashMapWithExpectedSize(keys.size());
		for (Serializable key : keys) {
			T value = (T) contents.getIfPresent(key);
			if (value != null) {
				result.put(key, value);
			}
		}
		if (log.isDebugEnabled() && !result.isEmpty()) {
			log.debug("Level 1 cache multiple hit: {}", result.keySet());
		}
		return result;
	}
814322
function checkContainingStores(objStoreNames) {
    return objStoreNames.every(function (storeName) {
        return (indexOf.call(this.database.objectStoreNames, storeName) !== -1);
    }, this);
}
982892
@GET
    public Response getStores() {
        String msg = "getting stores.";
        try {
            return doGetStores(msg);

        } catch (StorageException se) {
            return responseBad(msg, se);

        } catch (Exception e) {
            return responseBad(msg, e);
        }
    }
1351533
public <T> List<Key<T>> getKeysByRefs(final List<DBRef> refs) {
        final List<Key<T>> keys = new ArrayList<Key<T>>(refs.size());
        for (final DBRef ref : refs) {
            final Key<T> testKey = refToKey(ref);
            keys.add(testKey);
        }
        return keys;
    }
510560
def getStore(self) :
        """"""
        res = {}
        res.update(self.store)
        for k, v in self.subStores.items() :
            res[k] = v.getStore()
        
        return res
113593
public static List<String> getDimensions(Map<String, String> fetchDimensions) {
        return new ArrayList<>(fetchDimensions.keySet());
    }
582665
public Map<PluginClassLoaderDef, ClassLoader> create(Collection<PluginClassLoaderDef> defs) {
    ClassLoader baseClassLoader = baseClassLoader();

    ClassloaderBuilder builder = new ClassloaderBuilder();
    builder.newClassloader(API_CLASSLOADER_KEY, baseClassLoader);
    builder.setMask(API_CLASSLOADER_KEY, apiMask());

    for (PluginClassLoaderDef def : defs) {
      builder.newClassloader(def.getBasePluginKey());
      builder.setParent(def.getBasePluginKey(), API_CLASSLOADER_KEY, new Mask());
      builder.setLoadingOrder(def.getBasePluginKey(), def.isSelfFirstStrategy() ? SELF_FIRST : PARENT_FIRST);
      for (File jar : def.getFiles()) {
        builder.addURL(def.getBasePluginKey(), fileToUrl(jar));
      }
      exportResources(def, builder, defs);
    }

    return build(defs, builder);
  }
706898
public static void validateNewStoreDefsAreNonBreaking(List<StoreDefinition> oldStoreDefs, List<StoreDefinition> newStoreDefs){
        Map<String, StoreDefinition> oldStoreMap = new HashMap<String, StoreDefinition>();
        Map<String, StoreDefinition> newStoreMap = new HashMap<String, StoreDefinition>();
        for (StoreDefinition storeDef : oldStoreDefs){
           oldStoreMap.put(storeDef.getName(), storeDef);
        }
        for (StoreDefinition storeDef : newStoreDefs){
           newStoreMap.put(storeDef.getName(), storeDef);
        }
        for (String storeName : oldStoreMap.keySet()){
            if (newStoreMap.containsKey(storeName)){
               validateNewStoreDefIsNonBreaking(oldStoreMap.get(storeName), newStoreMap.get(storeName));
            }
        }
    }
1247132
List<JCTree> normalizeDefs(List<JCTree> defs, ClassSymbol c) {
        ListBuffer<JCStatement> initCode = new ListBuffer<JCStatement>();
        ListBuffer<Attribute.TypeCompound> initTAs = new ListBuffer<Attribute.TypeCompound>();
        ListBuffer<JCStatement> clinitCode = new ListBuffer<JCStatement>();
        ListBuffer<Attribute.TypeCompound> clinitTAs = new ListBuffer<Attribute.TypeCompound>();
        ListBuffer<JCTree> methodDefs = new ListBuffer<JCTree>();
        // Sort definitions into three listbuffers:
        //  - initCode for instance initializers
        //  - clinitCode for class initializers
        //  - methodDefs for method definitions
        for (List<JCTree> l = defs; l.nonEmpty(); l = l.tail) {
            JCTree def = l.head;
            switch (def.getTag()) {
            case BLOCK:
                JCBlock block = (JCBlock)def;
                if ((block.flags & STATIC) != 0)
                    clinitCode.append(block);
                else if ((block.flags & SYNTHETIC) == 0)
                    initCode.append(block);
                break;
            case METHODDEF:
                methodDefs.append(def);
                break;
            case VARDEF:
                JCVariableDecl vdef = (JCVariableDecl) def;
                VarSymbol sym = vdef.sym;
                checkDimension(vdef.pos(), sym.type);
                if (vdef.init != null) {
                    if ((sym.flags() & STATIC) == 0) {
                        // Always initialize instance variables.
                        JCStatement init = make.at(vdef.pos()).
                            Assignment(sym, vdef.init);
                        initCode.append(init);
                        endPosTable.replaceTree(vdef, init);
                        initTAs.addAll(getAndRemoveNonFieldTAs(sym));
                    } else if (sym.getConstValue() == null) {
                        // Initialize class (static) variables only if
                        // they are not compile-time constants.
                        JCStatement init = make.at(vdef.pos).
                            Assignment(sym, vdef.init);
                        clinitCode.append(init);
                        endPosTable.replaceTree(vdef, init);
                        clinitTAs.addAll(getAndRemoveNonFieldTAs(sym));
                    } else {
                        checkStringConstant(vdef.init.pos(), sym.getConstValue());
                        /* if the init contains a reference to an external class, add it to the
                         * constant's pool
                         */
                        vdef.init.accept(classReferenceVisitor);
                    }
                }
                break;
            default:
                Assert.error();
            }
        }
        // Insert any instance initializers into all constructors.
        if (initCode.length() != 0) {
            List<JCStatement> inits = initCode.toList();
            initTAs.addAll(c.getInitTypeAttributes());
            List<Attribute.TypeCompound> initTAlist = initTAs.toList();
            for (JCTree t : methodDefs) {
                normalizeMethod((JCMethodDecl)t, inits, initTAlist);
            }
        }
        // If there are class initializers, create a <clinit> method
        // that contains them as its body.
        if (clinitCode.length() != 0) {
            MethodSymbol clinit = new MethodSymbol(
                STATIC | (c.flags() & STRICTFP),
                names.clinit,
                new MethodType(
                    List.<Type>nil(), syms.voidType,
                    List.<Type>nil(), syms.methodClass),
                c);
            c.members().enter(clinit);
            List<JCStatement> clinitStats = clinitCode.toList();
            JCBlock block = make.at(clinitStats.head.pos()).Block(0, clinitStats);
            block.endpos = TreeInfo.endPos(clinitStats.last());
            methodDefs.append(make.MethodDef(clinit, block));

            if (!clinitTAs.isEmpty())
                clinit.appendUniqueTypeAttributes(clinitTAs.toList());
            if (!c.getClassInitTypeAttributes().isEmpty())
                clinit.appendUniqueTypeAttributes(c.getClassInitTypeAttributes());
        }
        // Return all method definitions.
        return methodDefs.toList();
    }
667888
public List<DataStore> getDataStores() {
        return invoke(DATA_STORES,
                new RequestClosure<JsonArray>() {
                    @Override
                    public JsonArray call(Invocation.Builder request) {
                        return request.get(JsonArray.class);
                    }
                },
                new ResponseClosure<JsonArray, List<DataStore>>() {
                    @Override
                    public List<DataStore> call(JsonArray json) {
                        List<DataStore> ds = new ArrayList<DataStore>(json.size());
                        for (int k = 0; k < json.size(); ++k) {
                            ds.add(new DataStore(json.getJsonObject(k)));
                        }
                        return ds;
                    }
                }
        );
    }
1012822
Map<String, WSKeyStore> getKeyStores() {
        Map<String, WSKeyStore> ret = new HashMap<String, WSKeyStore>(keystoreIdMap);
        ret.putAll(keystorePidMap);
        return ret;
    }
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;
    }
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;
    }