This method gets called from Allocator, during Allocator/MemoryHandler initialization

@param configuration
@param allocator
974646
@Override
    public void init(@NonNull Configuration configuration, @NonNull Allocator allocator) {
        this.configuration = configuration;

        this.deviceMemoryTracker = new DeviceAllocationsTracker(this.configuration);
        this.flowController.init(allocator);
    }
1140222
public void setDocumentLocator (@Nullable final Locator aLocator)
  {
    if (m_bTrackPosition)
    {
      m_aLocator = aLocator;
      _updatePosition ("setLocator");
      if (aLocator instanceof Locator2)
      {
        m_sSourceXMLVersion = ((Locator2) aLocator).getXMLVersion ();
        m_sSourceXMLEncoding = ((Locator2) aLocator).getEncoding ();
      }
    }
  }
1336541
public void configure() {
	  if (configurator != null && !underConfiguration.get() &&
			  underConfiguration.compareAndSet(false, true)) {
		 try {
			  configurator.configure(this);
		 } finally {
			 underConfiguration.set(false);
		 }
	  }
  }
1052221
@Override
    public synchronized void initialize(Settings settings) {
        super.initialize(settings);
        setEnabled(checkEnabled());
        numberOfRetries = getSettings().getInt(Settings.KEYS.ANALYZER_CENTRAL_RETRY_COUNT, numberOfRetries);
    }
405117
public void initialize(MessageStoreImpl ms, XidManager xidManager, Configuration configuration)
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "initialize", new Object[]{"MS="+ms, "XidManager="+xidManager, "Config="+configuration});

        _ms            = ms;
        _configuration = configuration;

       

        // Defect 496893
        _timeouts = new MEStartupTimeouts(_ms);

        

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "initialize");
    }
1146380
BufferAllocator allocator() {
    Class<?> allocator = reader.getClass(ALLOCATOR, UnpooledUnsafeHeapAllocator.class);
    try {
      return (BufferAllocator) allocator.newInstance();
    } catch (InstantiationException | IllegalAccessException e) {
      throw new ConfigurationException(e);
    } catch (ClassCastException e) {
      throw new ConfigurationException("invalid allocator class: " + allocator.getName());
    }
  }
619118
public void setConfiguration(Configuration configuration) {

        this.configuration = configuration;

        // init ParamReaders with the new <Configuration>
        ParamReaders.getInstance().setConfiguration(configuration);

        // register as listener to configuration change
        FoundationConfigurationListenerRegistry.addFoundationConfigurationListener(this);

        // verify that all configured values are correct
        verifyConfiguration();

    }
1092930
private final static void loadConfig() {
		try {
			conf = Configurations.loadConfig(configFilePath);
		} catch (ConfigurationException e) {
			terminate();
			throw new InitializationException(INIT_FAILED, e);
		}
	}
46995
public void init(Configuration configuration)
			throws Exception
	{
		String baseName = configuration.getBootstrapPropertyResolver().getProperty("ResourceBundleFactory.Bundle");
		if (baseName != null)
		{
			this.baseName = baseName;
		}
	}
16897
@Override
    public void init(FilterConfig filterConfig) throws ServletException {
        super.init(filterConfig);

        int reloadTime = readInt(filterConfig.getInitParameter(INIT_PARAM_RELOAD_TIME), 0);

        this.resetTime = readInt(filterConfig.getInitParameter(INIT_PARAM_RESET_TIME), resetTime);
        this.cacheKeyFormat = readString(filterConfig.getInitParameter(INIT_PARAM_CAHE_KEY_FORMAT), DEFAULT_CACHE_KEY_FORMAT);

        lastResetTime = new Date().getTime();

        CacheConfig<String, CachedResponse> cacheConfig = new CacheConfig<>();

        String providerValue = readString(filterConfig.getInitParameter(INIT_PARAM_CACHE_PROVIDER), null);

        if (providerValue != null)
            cacheConfig.setProvider(CacheConfig.CacheProvider.valueOf(providerValue.toUpperCase()));

        String cacheHost = filterConfig.getInitParameter(INIT_PARAM_CACHE_HOST);
        cacheConfig.setHostname(cacheHost);
        int cachePort = readInt(filterConfig.getInitParameter(INIT_PARAM_CACHE_PORT), 0);
        cacheConfig.setPortNumber(cachePort);

        if (!CacheFactory.isCacheProvider(cache, cacheConfig.getProvider())) {
            try {
                cache = CacheFactory.getCache(cacheConfig);
            } catch (Exception ex) {
                LOGGER.debug("Failed to initialize Cache Config: {}. Falling back to default Cache Service.", cacheConfig);
                cache = CacheFactory.<String, CachedResponse>getDefaultCache();
            }
        }

        LOGGER.debug("Cache Filter initialized with: " +
                        "{}:{},\n" +
                        "{}:{},\n" +
                        "{}:{},\n" +
                        "{}:{},\n" +
                        "{}:{}",
                INIT_PARAM_CACHE_PROVIDER, providerValue,
                INIT_PARAM_CACHE_HOST, cacheHost,
                INIT_PARAM_CACHE_PORT, String.valueOf(cachePort),
                INIT_PARAM_RELOAD_TIME, String.valueOf(reloadTime),
                INIT_PARAM_RESET_TIME, String.valueOf(resetTime));
    }
1174702
@Override
    public synchronized void init(Map<?, ?> properties)
    {
        if (manager != null)
        {
            log.warn("Attempt to restart an already started CacheFactory. Using previously created EhCacheFactory.");
            return;
        }
        initializing = true;
        try
        {
            String configurationResourceName = null;
            if (properties != null)
            {
                configurationResourceName = (String) properties.get(NET_SF_EHCACHE_CONFIGURATION_RESOURCE_NAME);
            }
            if (configurationResourceName == null || configurationResourceName.length() == 0)
            {
                manager = CacheManager.create();
            }
            else
            {
                if (!configurationResourceName.startsWith("/"))
                {
                    configurationResourceName = "/" + configurationResourceName;
                    log.info("prepending / to " + configurationResourceName + ". It should be placed in the root"
                            + "of the classpath rather than in a package.");
                }
                URL url = loadResource(configurationResourceName);
                manager = CacheManager.create(url);
            }
        }
        catch (net.sf.ehcache.CacheException e)
        {
            if (e.getMessage().startsWith(
                    "Cannot parseConfiguration CacheManager. Attempt to create a new instance of "
                            + "CacheManager using the diskStorePath"))
            {
                throw new CacheException("Could not init EhCacheFactory.", e);
            }
            else
            {
                throw new CacheException(e);
            }
        }
        finally
        {
            initializing = false;
        }

    }
1085140
@Override public void init(ServletConfig config) throws ServletException{
		super.init(config);
		
		getStats          = new ServletStats("get", getMonitoringIntervals());
		postStats         = new ServletStats("post", getMonitoringIntervals());
		putStats          = new ServletStats("put", getMonitoringIntervals());
		headStats         = new ServletStats("head", getMonitoringIntervals());
		optionsStats      = new ServletStats("options", getMonitoringIntervals());
		traceStats        = new ServletStats("trace", getMonitoringIntervals());
		deleteStats       = new ServletStats("delete", getMonitoringIntervals());
		lastModifiedStats = new ServletStats("lastModified", getMonitoringIntervals());
		
		cachedStatList = new ArrayList<IStats>(useShortStatList()? 2 : 8);
		cachedStatList.add(getStats);
		cachedStatList.add(postStats);
		if (!useShortStatList()){
			cachedStatList.add(deleteStats);
			cachedStatList.add(headStats);
			cachedStatList.add(optionsStats);
			cachedStatList.add(putStats);
			cachedStatList.add(traceStats);
			cachedStatList.add(lastModifiedStats);
		}

		ProducerRegistryFactory.getProducerRegistryInstance().registerProducer(this);
	}
234669
public void setConfigurations(java.util.Collection<java.util.Map<String, String>> configurations) {
        if (configurations == null) {
            this.configurations = null;
            return;
        }

        this.configurations = new java.util.ArrayList<java.util.Map<String, String>>(configurations);
    }
536136
@Override
    public void init(org.apache.commons.configuration.Configuration phoneNumberProvisioningConfiguration,
            org.apache.commons.configuration.Configuration telestaxProxyConfiguration, ContainerConfiguration
            containerConfiguration) {
        this.containerConfiguration = containerConfiguration;
        telestaxProxyEnabled = telestaxProxyConfiguration.getBoolean("enabled", false);
        if (telestaxProxyEnabled) {
            uri = telestaxProxyConfiguration.getString("uri");
            username = telestaxProxyConfiguration.getString("login");
            password = telestaxProxyConfiguration.getString("password");
            accountId = telestaxProxyConfiguration.getString("endpoint");
            siteId = telestaxProxyConfiguration.getString("siteId");
            activeConfiguration = telestaxProxyConfiguration;
        } else {
            Configuration bandwidthConfiguration = phoneNumberProvisioningConfiguration.subset("bandwidth");
            uri = bandwidthConfiguration.getString("uri");
            username = bandwidthConfiguration.getString("username");
            password = bandwidthConfiguration.getString("password");
            accountId = bandwidthConfiguration.getString("accountId");
            siteId = bandwidthConfiguration.getString("siteId");
            activeConfiguration = bandwidthConfiguration;
        }
        httpClient = new DefaultHttpClient();
        Credentials credentials = new UsernamePasswordCredentials(username, password);
        httpClient.getCredentialsProvider().setCredentials(AuthScope.ANY, credentials);
    }
267630
public void setConfigurations(Collection<? extends Configuration> configurations) {
		Assert.notNull(configurations, "Configurations must not be null");
		this.configurations = new ArrayList<>(configurations);
	}
1371695
@Override void init0() {
    _sums = MemoryManager.malloc8d(_nbin);
    _ssqs = MemoryManager.malloc8d(_nbin);
  }
240596
@Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        try {
            fedoraServerPort = m_server.getParameter("fedoraServerPort");
            fedoraServerRedirectPort =
                    m_server.getParameter("fedoraRedirectPort");
            fedoraServerHost = m_server.getParameter("fedoraServerHost");
            m_manager =
                    (DOManager) m_server
                            .getModule("org.fcrepo.server.storage.DOManager");
            String expireLimit =
                    m_server.getParameter("datastreamMediationLimit");
            if (expireLimit == null || expireLimit.equalsIgnoreCase("")) {
                logger.info("datastreamMediationLimit unspecified, using default "
                        + "of 5 seconds");
                datastreamMediationLimit = 5000;
            } else {
                datastreamMediationLimit = Integer.parseInt(expireLimit);
                logger.info("datastreamMediationLimit: {}",
                        datastreamMediationLimit);
            }
        } catch (Throwable th) {
            logger.error("Error initializing servlet", th);
        }
    }