Gets the name of the quorum associated with specified cache

@param cacheName name of the cache
@return name of the associated quorum
null if there is no associated quorum
437020
@Override
    public String getQuorumName(String cacheName) {
        CacheConfig cacheConfig = getCacheConfig(cacheName);
        if (cacheConfig == null) {
            return null;
        }
        return cacheConfig.getQuorumName();
    }
1097392
public int getQueryCacheCount(String mapName) {
        Map<String, InternalQueryCache<K, V>> queryCacheRegistry = queryCacheRegistryPerMap.get(mapName);
        if (queryCacheRegistry == null) {
            return 0;
        }
        return queryCacheRegistry.size();
    }
798082
public static function GetCache($CacheName, $CacheKey) {
      if ($CacheName != 'locale') return;
      
      if (!array_key_exists($CacheName,self::$Caches)) 
         self::PrepareCache($CacheName);
         
      if (self::$Caches[$CacheName]['mode'] == 'flat') 
         $Target = &self::$Caches[$CacheName]['cache'][$CacheName];
      else
         $Target = &self::$Caches[$CacheName]['cache'];
      $Target = (array)$Target;
      
      if (array_key_exists($CacheKey,$Target))
         return $Target[$CacheKey];
         
      return NULL;
   }
1113408
public T getTemplateFromCache(String filename) {

        LRUCache.CacheEntry<String, T> cachedTemplate = cache.get(filename);

        // this is to avoid null pointer exception in case of the layout composite template
        if (cachedTemplate == null) {
            return null;
        }

        return cachedTemplate.compiled;
    }
656265
public static Method getMethodCache(String serviceName, String methodName) {
        ConcurrentHashMap<String, Method> methods = NOT_OVERLOAD_METHOD_CACHE.get(serviceName);
        return methods == null ? null : methods.get(methodName);
    }
923402
public ICache getCache(String name) {
        return cacheFactory != null ? cacheFactory.createCache(name) : null;
    }
1063742
public CommandCache getCommandCache(String cacheName) throws DynamicCacheServiceNotStarted, IllegalStateException {
    	if (servletCacheUnit == null) {
    		throw new DynamicCacheServiceNotStarted("Servlet cache service has not been started."); 
    	}
		return servletCacheUnit.getCommandCache(cacheName);
	}
312838
final List<? extends E> get(String hostname) {
        Entries entries = resolveCache.get(hostname);
        return entries == null ? null : entries.get();
    }
510746
private QName getQName(String key) {
    QName qname;
    if ((qname = qNames.get(key)) == null) {
      qname = new QName(namespaceURI, key);
      qNames.put(key, qname);
    }
    return qname;
  }
552397
@Override
  public Collection<String> getCacheNames() {
    Set<String> cacheNames = new HashSet<>();
    for (org.cache2k.Cache<?,?> cache : manager.getActiveCaches()) {
      cacheNames.add(cache.getName());
    }
    cacheNames.addAll(configuredCacheNames);
    return Collections.unmodifiableSet(cacheNames);
  }
86956
public void cacheCleared(String cacheName) {
            InvalidationTableList list = (InvalidationTableList) cacheinvalidationTables.get(cacheName);
            if (list != null ) 
                    list.clear();
	}
1138065
private MembershipType getFromCache(String name)
   {
      return (MembershipType)cache.get(name, CacheType.MEMBERSHIPTYPE);
   }
881823
private String getCacheNamePrefix() {
        String cacheNamePrefix = getPrefix(
                isDefaultURI ? null : uri,
                isDefaultClassLoader ? null : getClassLoader());
        if (cacheNamePrefix == null) {
            return HazelcastCacheManager.CACHE_MANAGER_PREFIX;
        } else {
            return HazelcastCacheManager.CACHE_MANAGER_PREFIX + cacheNamePrefix;
        }
    }
588997
private Bucket getCachedBucket(final String name) {
        Bucket cachedBucket = bucketCache.get(name);

        if(cachedBucket != null) {
            if (cachedBucket.isClosed()) {
                LOGGER.debug("Not returning cached bucket \"{}\", because it is closed.", name);
                bucketCache.remove(name);
            } else {
                LOGGER.debug("Returning still open, cached bucket \"{}\"", name);
                return cachedBucket;
            }
        }

        return null;
    }
304287
@SuppressWarnings("unchecked")
  @Override
  public SpringCache2kCache getCache(final String name) {
    return name2cache.computeIfAbsent(name, n -> {
        if (!allowUnknownCache && !configuredCacheNames.contains(n)) {
          throw new IllegalArgumentException("Cache configuration missing for: " + n);
        }
        return buildAndWrap(Cache2kBuilder.forUnknownTypes().manager(manager).name(n));
      });
  }
695873
@Override
    @SuppressWarnings("unchecked")
    public <K extends Serializable, V> Map<K, V> getCache(String cacheName)
            throws IllegalArgumentException {
        return (Map<K, V>) this.mapCacheCreator.get(cacheName);
    }
463904
public static CommandCache getCommandCache(String cacheName) {
        final String methodName = "getCommandCache()";
        CommandCache cacheOut = null;
        if (servletCacheEnabled == false) {
            // DYNA1059W=DYNA1059W: WebSphere Dynamic Cache instance named {0} cannot be used because of Dynamic Servlet
            // cache service has not be started.
            Tr.error(tc, "DYNA1059W", new Object[] { cacheName });
        } else {
            if (cacheName != null) {
                try {
                    cacheOut = cacheUnit.getCommandCache(cacheName);
                } catch (Exception e) {
                    // DYNA1003E=DYNA1003E: WebSphere Dynamic Cache instance named {0} can not be initialized because of
                    // error {1}.
                    Tr.error(tc, "DYNA1003E", new Object[] { cacheName, e });
                }
            } else {
                cacheOut = ServerCache.commandCache;
            }
        }
        if (cacheOut == null && TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(tc, methodName + " could not find CommandCache for cacheName=" + cacheName);
        }
        return cacheOut;
    }