Caches the given statistics. They are later retrievable under the given identifier.

@param statistics The statistics to cache.
@param identifyer The identifier which may be later used to retrieve the statistics.
485046
public void cacheBaseStatistics(BaseStatistics statistics, String identifyer) {
		synchronized (this.baseStatisticsCache) {
			this.baseStatisticsCache.put(identifyer, statistics);
		}
	}
15841
public static void decodeCorrelationIdentifiers(Set<CorrelationIdentifier> correlations, String encoded) {
        if (encoded != null && !encoded.trim().isEmpty()) {
            StringTokenizer st = new StringTokenizer(encoded, ",");
            while (st.hasMoreTokens()) {
                String token = st.nextToken();
                String[] parts = token.split("[|]");
                if (parts.length == 2) {
                    String scope = parts[0].trim();
                    String value = parts[1].trim();

                    log.tracef("Extracted correlation identifier scope [%s] value [%s]", scope, value);

                    CorrelationIdentifier cid = new CorrelationIdentifier();
                    cid.setScope(Scope.valueOf(scope));
                    cid.setValue(value);

                    correlations.add(cid);
                }
            }
        }
    }
363357
public void setEnabledMetrics(java.util.Collection<EnabledMetric> enabledMetrics) {
        if (enabledMetrics == null) {
            this.enabledMetrics = null;
            return;
        }

        this.enabledMetrics = new com.amazonaws.internal.SdkInternalList<EnabledMetric>(enabledMetrics);
    }
1074686
public void setMetrics(java.util.Collection<MetricDataQuery> metrics) {
        if (metrics == null) {
            this.metrics = null;
            return;
        }

        this.metrics = new com.amazonaws.internal.SdkInternalList<MetricDataQuery>(metrics);
    }
903008
public void setTableStatistics(java.util.Collection<TableStatistics> tableStatistics) {
        if (tableStatistics == null) {
            this.tableStatistics = null;
            return;
        }

        this.tableStatistics = new java.util.ArrayList<TableStatistics>(tableStatistics);
    }
98723
@Override
	public FileBaseStatistics getStatistics(BaseStatistics cachedStats) throws IOException {
		final FileBaseStatistics stats = super.getStatistics(cachedStats);
		return stats == null ? null : 
			new FileBaseStatistics(stats.getLastModificationTime(), stats.getTotalInputSize(), this.recordLength);
	}
787015
public void setReadReplicaIdentifiers(java.util.Collection<String> readReplicaIdentifiers) {
        if (readReplicaIdentifiers == null) {
            this.readReplicaIdentifiers = null;
            return;
        }

        this.readReplicaIdentifiers = new java.util.ArrayList<String>(readReplicaIdentifiers);
    }
959971
public void setReadReplicaIdentifiers(java.util.Collection<String> readReplicaIdentifiers) {
        if (readReplicaIdentifiers == null) {
            this.readReplicaIdentifiers = null;
            return;
        }

        this.readReplicaIdentifiers = new com.amazonaws.internal.SdkInternalList<String>(readReplicaIdentifiers);
    }
423063
public void autoAttachStatsStorageBySessionId(Function<String, StatsStorage> statsStorageProvider) {
        if (statsStorageProvider != null) {
            this.statsStorageLoader = new StatsStorageLoader(statsStorageProvider);
        }
    }
955254
public void cache(String identifier, Object resource) {
		verifyState();

		if (!cacheLocked.get()) {
			resourceCache.get().put(identifier, resource);
		}
	}
666597
public void setDocumentIdentifiers(java.util.Collection<DocumentIdentifier> documentIdentifiers) {
        if (documentIdentifiers == null) {
            this.documentIdentifiers = null;
            return;
        }

        this.documentIdentifiers = new com.amazonaws.internal.SdkInternalList<DocumentIdentifier>(documentIdentifiers);
    }
1072545
@Override
    public void visitClass(ClassDescriptor classDescriptor) throws CheckedAnalysisException {

        // Just get the ClassContext from the analysis cache
        // and apply the detector to it.

        IAnalysisCache analysisCache = Global.getAnalysisCache();
        ClassContext classContext = analysisCache.getClassAnalysis(ClassContext.class, classDescriptor);
        Profiler profiler = analysisCache.getProfiler();
        profiler.start(detector.getClass());
        try {
            detector.visitClassContext(classContext);
        } finally {
            profiler.end(detector.getClass());
        }
    }
1044282
public static void registerStatsTemplateLookup(StatsTemplateLookup lookupClass) {
        if (tc.isEntryEnabled())
            Tr.entry(tc, new StringBuffer("registerStatsTemplateLookup: ").append(lookupClass.getClass().getName()).toString());

        PerfModules.registerTemplateLookupClass(lookupClass);

        if (tc.isEntryEnabled())
            Tr.exit(tc, "registerStatsTemplateLookup");
    }
1143905
public void cache(Identity oid, Object obj)
    {
        try
        {
            jcsCache.put(oid.toString(), obj);
        }
        catch (CacheException e)
        {
            throw new RuntimeCacheException(e);
        }
    }
294798
public void enableServletCacheStats() {
        final String methodName = "enableServletCacheStats";
        try {
            if (null == _statsInstance) {

                _iCacheType = TYPE_SERVLET;

                if (tc.isDebugEnabled())
                    Tr.debug(tc, methodName + " Creating statistic for " + _sCacheName + " instance (servlet cache)");
                _statsInstance = StatsFactory.createStatsInstance(WSDynamicCacheStats.SERVLET_CACHE_TYPE_PREFIX + _sCacheName, _cacheRootStatsGroup,
                        null, this);
                if (_diskOffloadEnabled) {
                    if (_cacheDiskStatsGroup == null) {
                        if (tc.isDebugEnabled())
                            Tr.debug(tc, methodName + " Creating disk group" + " for cacheName=" + _sCacheName);
                        _cacheDiskStatsGroup = StatsFactory.createStatsGroup(WSDynamicCacheStats.DISK_GROUP, templateCount13, _statsInstance, null,
                                this);
                    }
                    _csmDisk = new CacheStatsModule(_sCacheName, WSDynamicCacheStats.DISK_OFFLOAD_ENABLED, _cacheDiskStatsGroup, this);
                }
            }
        } catch (StatsFactoryException e) {
            com.ibm.ws.ffdc.FFDCFilter.processException(e, "com.ibm.ws.cache.stat.CacheStatsModule", "198", this);
            if (tc.isDebugEnabled())
                Tr.debug(tc, methodName + " Exception while enabling servlet cache stats template - cacheName=" + _sCacheName + ": "
                        + ExceptionUtility.getStackTrace(e));
        }
    }
909096
private static void populateCache() {
        if (cache == null) {
            cache = new LinkedHashMap<>();

            logger.info("IDataDecoders found:");

            ServiceLoader<IDataDecoder> loader =
                    ServiceLoader.load(IDataDecoder.class);

            // Logging.
            for (IDataDecoder discoveredDecoder : loader) {
                String name = discoveredDecoder.getClass().getCanonicalName();
                String decoderMimeType = discoveredDecoder.getMimeType();
                logger.info(String.format("    %s -> %s",
                        decoderMimeType, name));
                cache.put(decoderMimeType, discoveredDecoder.getClass());
            }
        }
    }
1028589
public void setIdentifierResolver(final Object identifierResolver) {
        if (identifierResolver instanceof IdentifierResolver) {
            this.identifierResolver = (IdentifierResolver) identifierResolver;
        } else if (identifierResolver instanceof String) {
            this.identifierResolver = new IdentifierResolver() {
                public String getIdentifierFor(String nodeName) {
                    return (String) identifierResolver;
                }
            };
        } else if (identifierResolver instanceof Closure) {
            final ObjectGraphBuilder self = this;
            this.identifierResolver = new IdentifierResolver() {
                public String getIdentifierFor(String nodeName) {
                    Closure cls = (Closure) identifierResolver;
                    cls.setDelegate(self);
                    return (String) cls.call(new Object[]{nodeName});
                }
            };
        } else {
            this.identifierResolver = new DefaultIdentifierResolver();
        }
    }