{@inheritDoc}
@see org.jboss.as.controller.Extension#initialize(org.jboss.as.controller.ExtensionContext)
178535
@Override
    public void initialize(ExtensionContext context) {
        // IMPORTANT: Management API version != xsd version! Not all Management API changes result in XSD changes
        SubsystemRegistration subsystem = context.registerSubsystem(SUBSYSTEM_NAME, InfinispanSchema.CURRENT.getVersion());
        // Create the path resolver handler
        final ResolvePathHandler resolvePathHandler;
        final PathManager pathManager;
        if (context.getProcessType().isServer()) {
            resolvePathHandler = ResolvePathHandler.Builder.of(context.getPathManager())
                    .setPathAttribute(FileStoreResource.PATH)
                    .setRelativeToAttribute(FileStoreResource.RELATIVE_TO)
                    .build();
            pathManager = context.getPathManager();
        } else {
            resolvePathHandler = null;
            pathManager = null;
        }

        subsystem.registerSubsystemModel(InfinispanSubsystemRootResource.create(resolvePathHandler, pathManager, context.isRuntimeOnlyRegistrationValid()));
        subsystem.registerXMLElementWriter(InfinispanSubsystemXMLWriter::new);
    }
1283217
public void initialize(Context context, ResponseListener listener) {
        this.context = context;
        this.listener = (listener != null) ? listener : new ResponseListener() {
            final String message = "ResponseListener is not specified. Defaulting to empty listener.";

            @Override
            public void onSuccess(Response response) {
                logger.debug(message);
            }

            @Override
            public void onFailure(Response response, Throwable t, JSONObject extendedInfo) {
                logger.debug(message);
            }
        };

        logger.debug("AuthorizationRequestAgent is initialized.");
    }
419270
public final void initialize() throws PersistenceException
    {
        if (!initialized)
        {
            if (persistenceDelegator == null)
            {
                throw new LazyInitializationException("could not initialize proxy " + persistentClass.getName() + "_"
                        + id + " - no EntityManager");
            }
            else if (!persistenceDelegator.isOpen())
            {
                throw new LazyInitializationException("could not initialize proxy " + persistentClass.getName() + "_"
                        + id + " - the owning Session was closed");
            }
            else
            {
                if (log.isDebugEnabled())
                    log.debug("Proxy >> Initialization >> " + persistentClass.getName() + "_" + id);

                // TODO: consider not calling em.find from here. Not sure 'why',
                // but something
                // doesn't feel right.
                target = persistenceDelegator.findById(persistentClass, id);
                initialized = true;
            }
        }
    }
67396
public void init(ClientContext clientContext) {
        this.clientContext = clientContext;
        this.clientConnectionStrategyConfig = clientContext.getClientConfig().getConnectionStrategyConfig();
        this.logger = clientContext.getLoggingService().getLogger(ClientConnectionStrategy.class);
    }
524295
protected void initialize()
	{
		// init transient fields
		bcmListeners = new ArrayList<BeanContextMembershipListener>();
		children = new HashMap();
		serializing = false;
		inNeedsGui = false;
		nonSerPCL = new PropertyChangeListener() {
			public void propertyChange(PropertyChangeEvent event)
			{
				BeanContextSupport.this.propertyChange(event);
			}
		};
	}
903806
public function initialize()
    {
        parent::initialize();
        $this->loadComponent($this->plugin . '.Extension');
        $this->loadModel($this->plugin . '.Extensions');
    }
1055177
private Context createContext() throws Exception
   {
      Properties properties = new Properties();
      properties.setProperty("java.naming.factory.initial", "org.jnp.interfaces.LocalOnlyContextFactory");
      properties.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");
      return new InitialContext(properties);
   }
990391
@Override
	public void init(JawrConfig config, List<JoinableResourceBundle> globalBundles,
			List<JoinableResourceBundle> contextBundles) {

		if (null == mainScriptTemplate) {
			mainScriptTemplate = loadScriptTemplate(SCRIPT_TEMPLATE);
		}
		if (null == debugScriptTemplate) {
			debugScriptTemplate = loadScriptTemplate(DEBUG_SCRIPT_TEMPLATE);
		}
		this.globalBundles = globalBundles;
		this.contextBundles = contextBundles;
		this.config = config;

	}
1246882
@SuppressWarnings("unchecked")
	public void init(ServletContext context, JawrConfig config) {
		super.init(context, config);
		pluginPathMap = (Map<String, String>) context.getAttribute(pluginMapAttributeName);
		if (pluginPathMap == null) {
			throw new BundlingProcessException("No grails plugin paths map defined in the servlet context");
		}

		// Determine wether this is run-app or run-war style of runtime.
		warDeployed = ((Boolean) context.getAttribute(JawrGrailsConstant.GRAILS_WAR_DEPLOYED)).booleanValue();
	}
718587
protected void initialiseApplicationContext() {
        if (context != null) {
            return;
        }

        context = createApplicationContext(parent);

        if (parent != null && classLoader == null) {
            trySettingClassLoaderOnContextIfFoundInParent(parent);
        }
        else if (classLoader != null) {
            setClassLoaderOnContext(classLoader);
        }

        Assert.notNull(context, "ApplicationContext cannot be null");
    }
809586
@Override
    public void init (ExtendedProperties config)
    {
        // the web framework was kind enough to slip this into the runtime when it started up
        _sctx = (ServletContext)rsvc.getApplicationAttribute("ServletContext");
        if (_sctx == null) {
            rsvc.getLog().warn("ServletContextResourceLoader: servlet context was not supplied " +
                               "as application context. A user of the servlet context resource " +
                               "loader must call Velocity.setApplicationAttribute(" +
                               "\"ServletContext\", getServletContext()).");
        }
    }
277220
@SuppressWarnings({ "rawtypes", "unchecked" })
	protected void applyInitializers(ConfigurableApplicationContext context) {
		for (ApplicationContextInitializer initializer : getInitializers()) {
			Class<?> requiredType = GenericTypeResolver.resolveTypeArgument(
					initializer.getClass(), ApplicationContextInitializer.class);
			Assert.isInstanceOf(requiredType, context, "Unable to call initializer.");
			initializer.initialize(context);
		}
	}
1319095
public void init(HttpInboundServiceContext context) {
        this.isc = context;
        this.message = context.getResponse();
        this.body = null;
    }
616488
public void init(ServletContext context) {
        if (profiles != null) {
            for (IDiagramProfile profile : profiles) {
                profile.init(context);
                _registry.put(profile.getName(),
                              profile);
            }
        }
    }
115321
public static void init(@NonNull final Context context, IInnerImageSetter innerImageSetter,
        Class<? extends ImageView> imageClazz) {
        if (sInitialized) {
            return;
        }
        //noinspection ConstantConditions
        Preconditions.checkArgument(context != null, "context should not be null");
        Preconditions
            .checkArgument(innerImageSetter != null, "innerImageSetter should not be null");
        Preconditions.checkArgument(imageClazz != null, "imageClazz should not be null");
        TangramViewMetrics.initWith(context.getApplicationContext());
        ImageUtils.sImageClass = imageClazz;
        ImageUtils.setImageSetter(innerImageSetter);
        sInitialized = true;
    }
893813
public static void initialize(Object androidContext) throws AndroidException {
		assert androidContext != null;
		try {
			final Class<?> contextType = androidContext.getClass();
			final Class<?> contextClass = getContextClass();
			if (!contextClass.isAssignableFrom(contextType)) {
				throw new AndroidException(Locale.getString("E1", androidContext)); //$NON-NLS-1$
			}
			synchronized (Android.class) {
				contextResolver = null;
				context = new SoftReference<>(androidContext);
			}
		} catch (AssertionError e) {
			throw e;
		} catch (Throwable e) {
			throw new AndroidException(e);
		}
		ClassLoaderFinder.setPreferredClassLoader(getContextClassLoader());
	}
249596
public function initializeContext(Context $context)
    {
        if (!$context instanceof FixtureServiceAwareContextInterface && !$this->usesReferenceDictionary($context)) {
            return;
        }

        $context->setFixtureService($this->fixtureService);
    }