Init fields at creation by using an instance of the Java class

@param component {@link IsVueComponent} to process
@param createdMethodBuilder Builder for our Create method
427573
private void initFieldsValues(TypeElement component, MethodSpec.Builder createdMethodBuilder) {
    // Do not init instance fields for abstract components
    if (component.getModifiers().contains(Modifier.ABSTRACT)) {
      return;
    }

    createdMethodBuilder.addStatement(
        "$T.initComponentInstanceFields(this, new $T())",
        VueGWTTools.class,
        component);
  }
649688
@Override
    protected void init() throws Exception {
        final boolean trace = TraceComponent.isAnyTracingEnabled();

        try {
            PropertyService vProps = new PropertyService();
            NavigableMap<String, Object> wProps = parseConfiguration(properties, vProps);

            // Clone properties so that we can later detect modifications from the current values
            vProps = (PropertyService) vProps.clone();

            String jndiName = (String) wProps.remove(JNDI_NAME);
            String type = (String) wProps.remove(DSConfig.TYPE);

            // Trace some of the most important config settings
            if (trace && tc.isDebugEnabled())
                Tr.debug(this, tc, DATASOURCE, id, jndiName, type);

            // Get the connection manager service for this data source. If none is configured, then use defaults.
            conMgrSvc = (ConnectionManagerService) priv.locateService(componentContext,CONNECTION_MANAGER);

            boolean createdDefaultConnectionManager = false;
            
            if (conMgrSvc == null) {
                if (wProps.containsKey(DSConfig.CONNECTION_MANAGER_REF)) {
                    SQLNonTransientException failure = connectorSvc.ignoreWarnOrFail(tc, null, SQLNonTransientException.class, "MISSING_RESOURCE_J2CA8030",
                                                                                    DSConfig.CONNECTION_MANAGER_REF, "", DATASOURCE, jndiName == null ? id : jndiName);
                    if (failure != null)
                        throw failure;
                }
                conMgrSvc = ConnectionManagerService.createDefaultService(id);
                createdDefaultConnectionManager = true;

            }
            conMgrSvc.addObserver(this);

            // Obtain the data source from the JDBC driver
            // TODO: Switch to org.osgi.service.jdbc.DataSourceFactory for compatibility with OSGI JDBC drivers
            jdbcDriverSvc = (JDBCDriverService) priv.locateService(componentContext,JDBC_DRIVER);

            if (jdbcDriverSvc == null) {
                Tr.error(tc, "DSRA4003.driver.null", jndiName == null ? id : jndiName);

                throw new SQLNonTransientException(ConnectorService.getMessage("MISSING_RESOURCE_J2CA8030", DSConfig.JDBC_DRIVER_REF,
                                                                               "", DATASOURCE, jndiName == null ? id : jndiName));
            }
            jdbcDriverSvc.addObserver(this);

            Object vendorImpl;
            Class<?> ifc;

            if(type == null){
                boolean atLeastJDBC43 = jdbcRuntime.getVersion().compareTo(JDBCRuntimeVersion.VERSION_4_3) >= 0;
                vendorImpl = atLeastJDBC43 || id != null && id.contains("dataSource[DefaultDataSource]")
                                ? jdbcDriverSvc.createAnyPreferXADataSource(vProps, id)
                                : jdbcDriverSvc.createAnyPreferLegacyOrder(vProps, id);
                ifc = vendorImpl instanceof XADataSource ? XADataSource.class
                    : vendorImpl instanceof ConnectionPoolDataSource ? ConnectionPoolDataSource.class
                    : vendorImpl instanceof DataSource ? DataSource.class
                    : Driver.class;
            } else if (ConnectionPoolDataSource.class.getName().equals(type)) {
                ifc = ConnectionPoolDataSource.class;
                vendorImpl = jdbcDriverSvc.createConnectionPoolDataSource(vProps, id);
            } else if (XADataSource.class.getName().equals(type)) {
                ifc = XADataSource.class;
                vendorImpl = jdbcDriverSvc.createXADataSource(vProps, id);
            } else if (DataSource.class.getName().equals(type)) {
                ifc = DataSource.class;
                vendorImpl = jdbcDriverSvc.createDataSource(vProps, id);
            } else if (Driver.class.getName().equals(type)) {
                ifc = Driver.class;
                String url = vProps.getProperty("URL", vProps.getProperty("url"));
                if (url != null && !"".equals(url)) {
                    vendorImpl = jdbcDriverSvc.getDriver(url, vProps, id);
                } else 
                    throw new SQLNonTransientException(AdapterUtil.getNLSMessage("DSRA4014.URL.for.Driver.missing", jndiName == null ? id : jndiName));
            } else
                throw new SQLNonTransientException(ConnectorService.getMessage("MISSING_RESOURCE_J2CA8030", DSConfig.TYPE, type, DATASOURCE, jndiName == null ? id : jndiName));

            // Convert isolationLevel constant name to integer
            vendorImplClassName = vendorImpl.getClass().getName();
            parseIsolationLevel(wProps, vendorImplClassName);
            
            Object objIsolationLevel = wProps.get(DataSourceDef.isolationLevel.name());
            int wIsolationLevel = objIsolationLevel == null ? -1 : (int) objIsolationLevel;
            
            if(wIsolationLevel == Connection.TRANSACTION_NONE) {
                Object objTransactional = wProps.get(DataSourceDef.transactional.name());
                boolean wTransactional = objTransactional == null ? true : (boolean) objTransactional;
                
                if (wTransactional) {
                    throw new SQLException(AdapterUtil.getNLSMessage("DSRA4009.tran.none.transactional.unsupported", id));
                }
            }

            // Derby Embedded needs a reference count so that we can shutdown databases when no longer used.
            isDerbyEmbedded = vendorImplClassName.startsWith("org.apache.derby.jdbc.Embedded");
            if (isDerbyEmbedded) {
                String dbName = (String) vProps.get(DataSourceDef.databaseName.name());
                if (dbName != null) {
                    // Maintaining compatibility here. Variables are no longer normalized by default, but the ResourceFactoryBuilder is still
                    // using VariableRegistry.resolveString() to resolve variables in data source definitions. 
                    dbName = PathUtils.normalize(dbName);
                    embDerbyRefCount.add(dbName);
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        Tr.debug(this, tc, "ref count for database shutdown", dbName, embDerbyRefCount);
                }
            }

            isUCP = vendorImplClassName.startsWith("oracle.ucp");
            if (isUCP) {
                if (!createdDefaultConnectionManager && !sentUCPConnMgrPropsIgnoredInfoMessage) {
                    Set<String> connMgrPropsAllowed = Collections.singleton("enableSharingForDirectLookups");
                    Tr.info(tc, "DSRA4013.ignored.connection.manager.config.used", connMgrPropsAllowed);
                    sentUCPConnMgrPropsIgnoredInfoMessage = true;
                }
                updateConfigForUCP(wProps);
            }

            dsConfigRef.set(new DSConfig(id, jndiName, wProps, vProps, connectorSvc));

            WSManagedConnectionFactoryImpl mcfImpl = new WSManagedConnectionFactoryImpl(dsConfigRef, ifc, vendorImpl, jdbcRuntime);

            if (jdbcDriverSvc.loadFromApp()) {
                // data source class loaded from thread context class loader
                mcf = null;
                mcfPerClassLoader = new ConcurrentHashMap<String, WSManagedConnectionFactoryImpl>();
                ClassLoader tccl = priv.getContextClassLoader();
                String identifier = connectorSvc.getClassLoaderIdentifierService().getClassLoaderIdentifier(tccl);
                mcfPerClassLoader.put(identifier, mcfImpl);
            } else {
                // data source class loaded from shared library
                mcf = mcfImpl;
                mcfPerClassLoader = null;
            }

            isInitialized.set(true);
        } catch (Exception x) {
            FFDCFilter.processException(x, getClass().getName(), "587", this);
            // undo any partial initialization
            if (conMgrSvc != null)
                conMgrSvc.deleteObserver(this);
            if (jdbcDriverSvc != null)
                jdbcDriverSvc.deleteObserver(this);
            throw x;
        } catch (Error x) {
            FFDCFilter.processException(x, getClass().getName(), "591", this);
            // undo any partial initialization
            if (conMgrSvc != null)
                conMgrSvc.deleteObserver(this);
            if (jdbcDriverSvc != null)
                jdbcDriverSvc.deleteObserver(this);
            throw x;
        }
    }
800185
public static <T> void callInitializers(T instance, CreationalContext<T> creationalContext, BeanManagerImpl manager,
            Iterable<? extends MethodInjectionPoint<?, ?>> initializerMethods) {
        for (MethodInjectionPoint<?, ?> initializer : initializerMethods) {
            initializer.invoke(instance, null, manager, creationalContext, CreationException.class);
        }
    }
317442
public void init(Converter converter, String strAltDesc, Converter convDescField)
    {
        super.init(converter);
        m_strAltDesc = strAltDesc;
        m_convDescField = convDescField;
    }
256392
protected void init() {
        FormModel model = createFormModel();
        if(getId() == null)
            formId = model.getId();
        if (model instanceof ValidatingFormModel) {
            ValidatingFormModel validatingFormModel = (ValidatingFormModel) model;
            setFormModel(validatingFormModel);
        } else {
            throw new IllegalArgumentException("Unsupported form model implementation " + formModel);
        }
        getApplicationConfig().applicationObjectConfigurer().configure(this, getId());
	}
1051095
@PostConstruct
	protected void init() throws IOException {
		// base configuration from XML file
		if (null != configurationFile) {
			log.debug("Get base configuration from {}", configurationFile);
			manager = new DefaultCacheManager(configurationFile);
		} else {
			GlobalConfigurationBuilder builder = new GlobalConfigurationBuilder();
			builder.globalJmxStatistics().allowDuplicateDomains(true);
			manager = new DefaultCacheManager(builder.build());
		}

		if (listener == null) {
			listener = new InfinispanCacheListener();
		}
		manager.addListener(listener);

		// cache for caching the cache configurations (hmmm, sounds a bit strange)
		Map<String, Map<CacheCategory, CacheService>> cacheCache = 
				new HashMap<String, Map<CacheCategory, CacheService>>();

		// build default configuration
		if (null != defaultConfiguration) {
			setCaches(cacheCache, null, defaultConfiguration);
		}

		// build layer specific configurations
		for (Layer layer : layerMap.values()) {
			CacheInfo ci = configurationService.getLayerExtraInfo(layer.getLayerInfo(), CacheInfo.class);
			if (null != ci) {
				setCaches(cacheCache, layer, ci);
			}
		}
	}
226629
private void initComponents()//GEN-BEGIN:initComponents
    {
        java.awt.GridBagConstraints gridBagConstraints;

        jPanel1 = new javax.swing.JPanel();
        lblEnabled = new javax.swing.JLabel();
        cbEnabled = new javax.swing.JCheckBox();
        lblDisabledByParent = new javax.swing.JLabel();
        cbDisabledByParent = new javax.swing.JCheckBox();
        jLabel3 = new javax.swing.JLabel();
        jLabel4 = new javax.swing.JLabel();
        lblTableName = new javax.swing.JLabel();
        tfTableName = new javax.swing.JTextField();
        lblClassName = new javax.swing.JLabel();
        tfClassName = new javax.swing.JTextField();
        lblPackageName = new javax.swing.JLabel();
        tfPackageName = new javax.swing.JTextField();
        lblDynamicProxy = new javax.swing.JLabel();
        cbDynamicProxy = new javax.swing.JCheckBox();
        lblConversionStrategyClass = new javax.swing.JLabel();
        tfConversionStrategyClass = new javax.swing.JTextField();

        setLayout(new java.awt.GridBagLayout());

        addComponentListener(new java.awt.event.ComponentAdapter()
        {
            public void componentShown(java.awt.event.ComponentEvent evt)
            {
                formComponentShown(evt);
            }
            public void componentHidden(java.awt.event.ComponentEvent evt)
            {
                formComponentHidden(evt);
            }
        });

        addHierarchyListener(new java.awt.event.HierarchyListener()
        {
            public void hierarchyChanged(java.awt.event.HierarchyEvent evt)
            {
                formHierarchyChanged(evt);
            }
        });

        jPanel1.setLayout(new java.awt.GridLayout(8, 2));

        lblEnabled.setDisplayedMnemonic('e');
        lblEnabled.setText("enabled");
        jPanel1.add(lblEnabled);

        cbEnabled.setMnemonic('e');
        cbEnabled.addActionListener(new java.awt.event.ActionListener()
        {
            public void actionPerformed(java.awt.event.ActionEvent evt)
            {
                cbEnabledActionPerformed(evt);
            }
        });

        jPanel1.add(cbEnabled);

        lblDisabledByParent.setText("disabled by Parent:");
        jPanel1.add(lblDisabledByParent);

        cbDisabledByParent.setEnabled(false);
        jPanel1.add(cbDisabledByParent);

        jPanel1.add(jLabel3);

        jPanel1.add(jLabel4);

        lblTableName.setLabelFor(tfTableName);
        lblTableName.setText("Table Name:");
        jPanel1.add(lblTableName);

        tfTableName.setEditable(false);
        tfTableName.setText("jTextField1");
        tfTableName.setBorder(null);
        tfTableName.setDisabledTextColor(new java.awt.Color(0, 51, 51));
        tfTableName.setEnabled(false);
        jPanel1.add(tfTableName);

        lblClassName.setDisplayedMnemonic('c');
        lblClassName.setLabelFor(tfClassName);
        lblClassName.setText("Class Name:");
        jPanel1.add(lblClassName);

        tfClassName.setText("jTextField1");
        tfClassName.addActionListener(new java.awt.event.ActionListener()
        {
            public void actionPerformed(java.awt.event.ActionEvent evt)
            {
                tfClassNameActionPerformed(evt);
            }
        });

        tfClassName.addFocusListener(new java.awt.event.FocusAdapter()
        {
            public void focusLost(java.awt.event.FocusEvent evt)
            {
                tfClassNameFocusLost(evt);
            }
        });

        tfClassName.addKeyListener(new java.awt.event.KeyAdapter()
        {
            public void keyTyped(java.awt.event.KeyEvent evt)
            {
                tfClassNameKeyTyped(evt);
            }
        });

        jPanel1.add(tfClassName);

        lblPackageName.setDisplayedMnemonic('p');
        lblPackageName.setLabelFor(tfPackageName);
        lblPackageName.setText("Package:");
        jPanel1.add(lblPackageName);

        tfPackageName.setText("jTextField2");
        tfPackageName.addActionListener(new java.awt.event.ActionListener()
        {
            public void actionPerformed(java.awt.event.ActionEvent evt)
            {
                tfPackageNameActionPerformed(evt);
            }
        });

        tfPackageName.addFocusListener(new java.awt.event.FocusAdapter()
        {
            public void focusLost(java.awt.event.FocusEvent evt)
            {
                tfPackageNameFocusLost(evt);
            }
        });

        tfPackageName.addKeyListener(new java.awt.event.KeyAdapter()
        {
            public void keyTyped(java.awt.event.KeyEvent evt)
            {
                tfPackageNameKeyTyped(evt);
            }
        });

        jPanel1.add(tfPackageName);

        lblDynamicProxy.setDisplayedMnemonic('u');
        lblDynamicProxy.setText("Use Dynamic Proxy:");
        jPanel1.add(lblDynamicProxy);

        cbDynamicProxy.setMnemonic('u');
        cbDynamicProxy.addActionListener(new java.awt.event.ActionListener()
        {
            public void actionPerformed(java.awt.event.ActionEvent evt)
            {
                cbDynamicProxyActionPerformed(evt);
            }
        });

        jPanel1.add(cbDynamicProxy);

        lblConversionStrategyClass.setDisplayedMnemonic('s');
        lblConversionStrategyClass.setLabelFor(tfConversionStrategyClass);
        lblConversionStrategyClass.setText("Conversion Strategy Class:");
        jPanel1.add(lblConversionStrategyClass);

        tfConversionStrategyClass.setText("jTextField1");
        tfConversionStrategyClass.addActionListener(new java.awt.event.ActionListener()
        {
            public void actionPerformed(java.awt.event.ActionEvent evt)
            {
                tfConversionStrategyClassActionPerformed(evt);
            }
        });

        tfConversionStrategyClass.addFocusListener(new java.awt.event.FocusAdapter()
        {
            public void focusLost(java.awt.event.FocusEvent evt)
            {
                tfConversionStrategyClassFocusLost(evt);
            }
        });

        tfConversionStrategyClass.addKeyListener(new java.awt.event.KeyAdapter()
        {
            public void keyTyped(java.awt.event.KeyEvent evt)
            {
                tfConversionStrategyClassKeyTyped(evt);
            }
        });

        jPanel1.add(tfConversionStrategyClass);

        gridBagConstraints = new java.awt.GridBagConstraints();
        gridBagConstraints.fill = java.awt.GridBagConstraints.HORIZONTAL;
        gridBagConstraints.anchor = java.awt.GridBagConstraints.NORTH;
        gridBagConstraints.weightx = 1.0;
        gridBagConstraints.weighty = 1.0;
        add(jPanel1, gridBagConstraints);

    }
717979
@Override
	public void onCreate(Bundle savedInstanceState) {
		
		super.onCreate(savedInstanceState);
		
		EVENT_CONFIGURATION = EventLinker.Configuration.newInstance(this);
	}
864162
@Override
    public void configureComponent(final Object component,
            final PlexusConfiguration configuration,
            final ExpressionEvaluator expressionEvaluator,
            final ClassRealm containerRealm,
            final ConfigurationListener listener)
            throws ComponentConfigurationException {

        addProjectDependenciesToClassRealm(expressionEvaluator, containerRealm);

        this.converterLookup.registerConverter(new ClassRealmConverter(
                containerRealm));

        final ObjectWithFieldsConverter converter = new ObjectWithFieldsConverter();

        converter.processConfiguration(this.converterLookup, component,
                containerRealm, configuration,
                expressionEvaluator, listener);

    }
1212801
public void init(final DroolsAssemblerContext kBuilder,
                     final InternalKnowledgePackage pkg,
                     final BaseDescr parentDescr,
                     final DialectCompiletimeRegistry dialectRegistry,
                     final Dialect defaultDialect,
                     final Dialectable component) {
        this.kBuilder = kBuilder;
        this.pkg = pkg;
        this.parentDescr = parentDescr;
        this.dialectRegistry = dialectRegistry;
        this.dialect = (component != null && component.getDialect() != null) ? this.dialectRegistry.getDialect( component.getDialect() ) : defaultDialect;
        this.typesafe = ((MVELDialect) dialectRegistry.getDialect( "mvel" )).isStrictMode();

        if ( dialect == null && (component != null && component.getDialect() != null) ) {
            this.errors.add( new DescrBuildError( null,
                                                  parentDescr,
                                                  component,
                                                  "Unable to load Dialect '" + component.getDialect() + "'" ) );
            // dialect is null, but fall back to default dialect so we can attempt to compile rest of rule.
            this.dialect = defaultDialect;
        }
    }
1077679
@PostConstruct
  @Override
  public void init()
    throws ConfigException
  {
    try {
      _codeSource = new CodeSource(new URL(_path.getURL()),
                                   (Certificate []) null);
    } catch (Exception e) {
      log.log(Level.FINE, e.toString(), e);
    }
    
    super.init();

    getClassLoader().addURL(_path, _isScanned);
  }
725508
@PostConstruct
  public void initialize() {

    if (this.pojoDescriptorBuilderFactory == null) {
      this.pojoDescriptorBuilderFactory = PojoDescriptorBuilderFactoryImpl.getInstance();
    }
    if (this.pojoDescriptorBuilder == null) {
      this.pojoDescriptorBuilder = this.pojoDescriptorBuilderFactory.createPrivateFieldDescriptorBuilder();
    }
    this.descriptor = this.pojoDescriptorBuilder.getDescriptor(EntityTo.class);
  }
104170
private void init(final String title, final int initialWidth, final int initialHeight,
		final Component component)
	{
		if (title != null)
		{
			setTitle(title);
		}
		setInitialWidth(initialWidth);
		setInitialHeight(initialHeight);
		setContent(component);
	}
581590
private void initializeSFSBInitMethodMap(BeanMetaData bmd, Method[] methods) throws EJBConfigurationException {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        String ejbName = bmd.enterpriseBeanName;

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.entry(tc, "initializeSFSBInitMethodMap: " + ejbName);
        }

        // Get the init-method from ejb-jar.xml if there is an ejb-jar.xml file.
        // Note, eb is set to null if there is no ejb-jar.xml file.
        List<InitMethod> initList = null;
        EnterpriseBean eb = bmd.wccm.enterpriseBean;
        if (eb != null) {
            // Get init-method list for this Session bean from WCCM and process.
            Session sb = (Session) eb;
            List<InitMethod> imList = sb.getInitMethod();
            initList = imList;
        }

        // Populate HashMap of all of the Init methods for SFSB.
        HashMap<String, String> map = new HashMap<String, String>();
        boolean isSessionBean = (SessionBean.class).isAssignableFrom(bmd.enterpriseBeanClass);
        if (isSessionBean) {
            // The bean is written to EJB 2.1 API or earlier, so the ejbCreate<METHOD> are the
            // only methods that can be annotated as a Init method, but is not required
            // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
            // in the EJB 3 core specifications.
            String ejbCreate = "ejbCreate";
            int ejbCreateLength = ejbCreate.length();

            // Process any init-method from ejb-jar.xml file and verify an init-method
            // provided only specifies a ejbCreate method name.
            if (initList != null) {
                if (isTraceOn && tc.isDebugEnabled()) {
                    Tr.debug(tc, "verify init-method is for ejbCreate of bean written to EJB 2.1 API");
                }

                // Verify an init-method provided only specifies a ejbCreate method name.
                for (InitMethod im : initList) {
                    // Get SFSB method name and verify it is ejbCreate. Don't bother with
                    // verifying whether method exists by signature specified. The code
                    // below automatically treats all ejbCreate methods as an init method.
                    // The JITDeploy code has to match up method signature of the init-method
                    // with the create method on the home.  It will provide an error message if
                    // signature does not match.
                    String method = im.getBeanMethod().getMethodName();
                    if (!ejbCreate.equals(method)) {
                        // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                        // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                        // cannot be applied to the {0} method of the {1} enterprise bean.
                        Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                        Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                        throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                            "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it " +
                                                            "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                    }
                }
            }

            // For each public method of the bean.
            if (isTraceOn && tc.isDebugEnabled()) {
                Tr.debug(tc, "processing public ejbCreate methods written to EJB 2.1 API");
            }

            for (Method m : methods) {
                // Is the method a ejbCreate<METHOD>?
                String methodName = m.getName();
                if (methodName.startsWith(ejbCreate)) {
                    // It is a ejbCreate<METHOD>, so insert a map entry using
                    // create<METHOD> + JDIMethodSignature as the key and
                    // METHOD as the value.
                    String key;
                    if (methodName.length() <= ejbCreateLength) {
                        key = "create" + MethodAttribUtils.jdiMethodSignature(m);
                    } else {
                        String suffix = methodName.substring(ejbCreateLength);
                        key = "create" + suffix + MethodAttribUtils.jdiMethodSignature(m);
                    }

                    map.put(key, m.getName());
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "added key: " + key
                                     + ", for method name = " + m.getName());
                    }
                } else {
                    // Don't bother to look for annotations if all config data
                    // came from xml.
                    if (!bmd.metadataComplete) {
                        // The bean is written to EJB 3 API,  or earlier, so the ejbCreate<METHOD> are the
                        // only methods that can be annotated as a Init method, but is not required
                        // to be annotated as a Init method. See section 4.3.10.1 Stateful Session Beans
                        // in the EJB 3 core specifications.
                        // Not a ejbCreate<METHOD>.  Verify it is not annotated as a Init method.
                        Init initMethod = m.getAnnotation(Init.class);
                        if (initMethod != null) {

                            // CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate&lt;METHOD&gt; method
                            // only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it
                            // cannot be applied to the {0} method of the {1} enterprise bean.
                            String method = m.toGenericString();
                            Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                            Tr.error(tc, "INVALID_INIT_ANNOTATION_CNTR0234E", data);
                            throw new EJBConfigurationException("CNTR0234E: An initialization method for a stateful session bean can be an ejbCreate<METHOD> method " +
                                                                "only when the bean conforms to the Enterprise JavaBeans (EJB) 2.1 or earlier specification levels. Therefore, it "
                                                                +
                                                                "cannot be applied to the " + method + " method of the " + bmd.enterpriseBeanName + " enterprise bean.");
                        }
                    } else {
                        if (isTraceOn && tc.isDebugEnabled()) {
                            Tr.debug(tc, "metadata complete, skipping Init annotations");
                        }
                    }
                }
            }
        } else {
            // The bean is written to EJB 3 API, so any method can be annotated as an Init method.
            // We only need to populate the HashMap if the EJB 3 bean has either a remote or
            // local home interface. If it has neither,  Init method will never be called,
            // so do not bother populating the map in that case.
            if (bmd.homeInterfaceClass != null || bmd.localHomeInterfaceClass != null) {
                // We have a remote or local home interface, so we need process init methods.
                // Always process any init-method from ejb-jar.xml file.
                if (initList != null) {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "processing init-method from ejb-jar.xml for bean written to EJB 3.0 API");
                    }
                    for (InitMethod im : initList) {
                        // Attempt to find Method object for the InitMethod.
                        NamedMethod namedMethod = im.getBeanMethod();
                        Method m = DDUtil.findMethod(namedMethod, methods);

                        // Method found for InitMethod?
                        if (m == null) {
                            // CNTR0236E: The {1} enterprise bean has an init-method element, which specifies
                            //  the {0} method. This method is not a public method of this bean.
                            String method = namedMethod.getMethodName();
                            Object[] data = new Object[] { method, bmd.enterpriseBeanName };
                            Tr.error(tc, "INIT_METHOD_NOT_FOUND_CNTR0236E", data);
                            throw new EJBConfigurationException("CNTR0236E: The " + bmd.enterpriseBeanName + " enterprise bean has an init-method element, which " +
                                                                "specifies the " + method + " method. This method is not a public method of this bean.");
                        } else {
                            // Method found. Create a HashMap entry for it using home method name
                            // and JDI method signature as the key and method name as the value.
                            // Note, if Init annotation did not provide home method name, then
                            // just the JDI method signature is used as key and JITDeploy has
                            // to handle this possiblity (this could result in CNTR0235E below).
                            String homeMethodName = im.getCreateMethod().getMethodName();
                            String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                            String oldValue = map.put(key, m.getName());
                            if (oldValue != null) {
                                // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                // of EJB 3 simplified view specification.

                                // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                // or the {1} method of the {2} enterprise bean.
                                Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                    "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                    + " enterprise bean.");
                            }
                        }
                    }
                }

                // Don't bother to look for annotations if all config data
                // came from xml.
                if (!bmd.metadataComplete) {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "processing Init annotations for bean written to EJB 3.0 API");
                    }

                    // Not metadata-complete, so we need to process all public methods
                    // to look for Init annotation.
                    for (Method m : methods) {
                        // Is this method annotated as an Init method?
                        Init initMethod = m.getAnnotation(Init.class);
                        if (initMethod != null) {
                            // Yes it is, so create a HashMap entry for it using home method name
                            // and JDI method signature as the key and method name as the value.
                            // Note, if Init annotation did not provide home method name, then
                            // just the JDI method signature is used as key and JITDeploy has
                            // to handle this possiblity (this could result in CNTR0235E below).
                            String homeMethodName = initMethod.value();
                            String key = homeMethodName + MethodAttribUtils.jdiMethodSignature(m);
                            String oldValue = map.put(key, m.getName());
                            if (oldValue != null) {
                                // See section 10.1.2.1 Init Annotation for Stateful Session Beans
                                // of EJB 3 simplified view specification.

                                // CNTR0235E: The name of the adapted create&lt;METHOD&gt; method must be specified for either the {0} method
                                // or the {1} method of the {2} enterprise bean.
                                Object[] data = new Object[] { oldValue, m.getName(), bmd.enterpriseBeanName };
                                Tr.error(tc, "AMBIGUOUS_INIT_ANNOTATION_CNTR0235E", data);
                                throw new EJBConfigurationException("CNTR0235E: The name of the adapted create<METHOD> method must be specified for either " +
                                                                    "the " + oldValue + " method or the " + m.getName() + " method of the " + bmd.enterpriseBeanName
                                                                    + " enterprise bean.");
                            }
                        }
                    }
                } else {
                    if (isTraceOn && tc.isDebugEnabled()) {
                        Tr.debug(tc, "metadata complete, skipping Init annotations for bean written to EJB 3.0 API");
                    }
                }
            }
        }

        // Put map in BeanMetaData if map is not empty. Otherwise, leave BMD
        // set to null.
        if (!map.isEmpty()) {
            bmd.ivInitMethodMap = map;
        }

        if (isTraceOn && tc.isEntryEnabled()) {
            Tr.exit(tc, "initializeSFSBInitMethodMap: " + ejbName);
        }

    }
907097
@PostConstruct
    public synchronized void initialize() {
        final FwCoreDirection direction = assistCoreDirection();
        developmentHere = direction.isDevelopmentHere();

        final JsonResourceProvider provider = direction.assistJsonResourceProvider();
        mappingOption = OptionalThing.ofNullable(extractMappingOption(provider), () -> {
            throw new IllegalStateException("Not found the JSON mapping option.");
        });
        printControlState = OptionalThing.of(preparePrintState(provider)); // fixedly exists for now
        yourEngineCreator = OptionalThing.ofNullable(extractYourEngineCreator(provider), () -> {
            throw new IllegalStateException("Not found the your engine creator.");
        });

        // should be last because of using other instance variable
        realJsonEngine = createDefaultJsonEngine();
        showBootLogging();
    }
878336
public void init(Convert converter, JComponent component1, JComponent component2)
    {
        m_converter = converter;
        this.setBorder(null);
        this.setOpaque(false);
        
        this.setLayout(new BoxLayout(this, BoxLayout.X_AXIS));
        if (component1 != null)
            this.addComponent(component1, true);
        
        if (component2 != null)
            this.addComponent(component2, true);
    }
1122157
private void addFieldsForComputedMethod(TypeElement component, Set<String> alreadyDone) {
    getMethodsWithAnnotation(component, Computed.class).forEach(method -> {
      String propertyName = computedPropertyNameToFieldName(getComputedPropertyName(method));

      if (alreadyDone.contains(propertyName)) {
        return;
      }

      TypeMirror propertyType = getComputedPropertyTypeFromMethod(method);
      componentExposedTypeBuilder
          .addField(FieldSpec
              .builder(TypeName.get(propertyType),
                  propertyName,
                  Modifier.PROTECTED)
              .addAnnotation(JsProperty.class)
              .build());
      alreadyDone.add(propertyName);
    });

    getSuperComponentType(component)
        .ifPresent(superComponent -> addFieldsForComputedMethod(superComponent, alreadyDone));
  }