Defines the slot triggered on Framework startup.
174821
def on_startup(self):
        

        LOGGER.debug("> Calling '{0}' Component Framework 'on_startup' method.".format(self.__class__.__name__))

        factory_default_script_editor_file = umbra.ui.common.get_resource_path(
            self.__factory_default_script_editor_file)
        if foundations.common.path_exists(factory_default_script_editor_file) and \
                not foundations.common.path_exists(self.__default_script_editor_file):
            shutil.copyfile(factory_default_script_editor_file, self.__default_script_editor_file)

        if foundations.common.path_exists(self.__default_script_editor_file):
            self.load_file(self.__default_script_editor_file)
        else:
            self.new_file()

        startup_script = self.__engine.parameters.startup_script
        if foundations.common.path_exists(startup_script):
            self.load_file(startup_script) and self.evaluate_script()

        self.restore_session()

        for argument in self.__engine.arguments[1:]:
            file = os.path.abspath(argument)
            if foundations.common.path_exists(file):
                os.path.isfile(file) and self.load_file(file)

        return True
1311303
public void start(SlotActions initialSlotActions) {
		this.slotActions = Preconditions.checkNotNull(initialSlotActions);

		timerService.start(this);

		started = true;
	}
73209
private void initializeDefaults() {
    defaultUlimitMinimum = rmConf.getInt(
        "mapred.capacity-scheduler.default-minimum-user-limit-percent", 100);
    defaultSupportPriority = rmConf.getBoolean(
        "mapred.capacity-scheduler.default-supports-priority", false);
    defaultMaxJobsPerUsersToInitialize = rmConf.getInt(
        "mapred.capacity-scheduler.default-maximum-initialized-jobs-per-user",
        2);
  }
123070
function initLoadingState(btnEl) {
          if (cfg.btnLoadingClass && !cfg.addClassToCurrentBtnOnly) {
            btnEl.addClass(cfg.btnLoadingClass);
          }
          if (cfg.disableBtn && !cfg.disableCurrentBtnOnly) {
            btnEl.attr('disabled', 'disabled');
          }
        }
343889
public void start() {
		try {
			Iterator iter = configLoadedList.keySet().iterator();
			while (iter.hasNext()) {
				String configFile = (String) iter.next();
				Debug.logVerbose("[JdonFramework] start configFile = " + configFile, module);
				ConfigureReader configureLoader = (ConfigureReader) configLoadedList.get(configFile);
				Map modelMappings = configureLoader.load();
				mps.putAll(modelMappings);

				Iterator mpsIter = modelMappings.keySet().iterator();
				while (mpsIter.hasNext()) {
					String formName = (String) mpsIter.next();
					build(formName);
				}
			}
			configLoadedList.clear();
		} catch (Exception ex) {
			Debug.logError("[JdonFramework] !!!!!!!framework started error: " + ex, module);
		}
	}
1306064
def slot_definition(compiler)
      return Mom::SlotDefinition.new(Mom::BlockConstant.new(parfait_block(compiler)) , [])
    end
1087453
def connect_after(self, slot, *extra_args):
        
        slot = Slot(slot, *extra_args)
        self._after_functions.add(slot)
359527
private void initFromSPIServiceLoader() {

        String property = System.getProperty("druid.load.spifilter.skip");
        if (property != null) {
            return;
        }

        ServiceLoader<Filter> druidAutoFilterLoader = ServiceLoader.load(Filter.class);

        for (Filter autoFilter : druidAutoFilterLoader) {
            AutoLoad autoLoad = autoFilter.getClass().getAnnotation(AutoLoad.class);
            if (autoLoad != null && autoLoad.value()) {
                if (LOG.isInfoEnabled()) {
                    LOG.info("load filter from spi :" + autoFilter.getClass().getName());
                }
                addFilter(autoFilter);
            }
        }
    }
425491
function start(event, element, activate, context) {
    if (isObject(activate)) {
      context = activate;
      activate = false;
    }

    // do not move connections or the root element
    if (element.waypoints || !element.parent) {
      return;
    }

    var referencePoint = mid(element);

    dragging.init(event, referencePoint, 'shape.move', {
      cursor: 'grabbing',
      autoActivate: activate,
      data: {
        shape: element,
        context: context || {}
      }
    });

    // we've handled the event
    return true;
  }
1338018
public function init()
    {
        if ($this->isEnabled()) {
            $this->asteriskclient = Pool::getInstance($this->config->asteriskclientname->value);
        }
    }
588943
public void start() throws Exception {
        baseFilterFactory = new DefaultFilterFactory(bundleContext, filterClass, priority, applicationName, initParams);
        baseFilterFactory.register();
    }
794581
public function actionInit() : void
    {
        $this->initSURole();
        $config = $this->loadConfig();
        $this->applyConfig($config);
        $this->applyAssignConfig($config);
        $this->addAssignmentsToSu();
        $this->log(true);
    }
61760
public void enableStart() {
    EventTarget targ = (EventTarget) element;
    targ.addEventListener(SVGConstants.SVG_EVENT_MOUSEDOWN, this, false);
  }
461912
public void onStartup() {
        try {
            preloadCaches();
            SpringAppContext.getInstance().loadPackageContexts();  // trigger dynamic context loading
            preloadDynamicCaches();
            // implementor cache relies on kotlin from preloadDynamicCaches()
            ImplementorCache implementorCache = new ImplementorCache();
            implementorCache.loadCache();
            allCaches.put(ImplementorCache.class.getSimpleName(), implementorCache);
        }
        catch (Exception ex){
            String message = "Failed to load caches";
            logger.severeException(message, ex);
            throw new StartupException(message, ex);
        }
    }
1363618
private void init() {
        setTitle("Validation Framework Test");
        setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);

        // Add contents
        JPanel contentPane = new JPanel(new MigLayout("fill, wrap 1", "[]", "[grow]unrelated[]"));
        setContentPane(contentPane);

        contentPane.add(new JScrollPane(table), "grow");
        installValidators(table);
        contentPane.add(changeButton, "align right");

        // Set size
        pack();
        Dimension size = getSize();
        size.width += 100;
        setMinimumSize(size);

        // Set location
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setLocation((screenSize.width - size.width) / 2, (screenSize.height - size.height) / 3);
    }
463811
def init_app(self, app):
        """"""

        self.app = app
        self.app.apscheduler = self

        self._load_config()
        self._load_jobs()

        if self.api_enabled:
            self._load_api()
151753
private void initialize()
    {
        activeOperators.stream()
                .map(Operator::getOperatorContext)
                .forEach(operatorContext -> operatorContext.setMemoryRevocationRequestListener(() -> driverBlockedFuture.get().set(null)));
    }