Initializes the manifest which executes checks, define the resource
roots, load the dependencies and the includes.
@private
359898
function(oInstance) {

			if (this._iInstanceCount === 0) {

				// version check => only if minVersion is available a warning
				// will be logged and the debug mode is turned on
				this.checkUI5Version();

				// define the resource roots
				// => if not loaded via manifest first approach the resource roots
				//    will be registered too late for the AMD modules of the Component
				//    controller. This is a constraint for the resource roots config
				//    in the manifest!
				this.defineResourceRoots();

				// load the component dependencies (other UI5 libraries)
				this.loadDependencies();

				// load the custom scripts and CSS files
				this.loadIncludes();

				// activate the static customizing
				this.activateCustomizing();

			}

			// activate the instance customizing
			if (oInstance) {
				this.activateCustomizing(oInstance);
			}

			this._iInstanceCount++;

		}
1331861
async function init () {
    // initialze logging
    initLogging(this.immutableApp)
    // initialize global dir config by merging module configs
    initDir(this.immutableApp)
    // initalize handlebars
    initHandlebars(this.immutableApp)
    // initalize express request handling - bodyParser, cookieParser, etc
    initExpress(this.immutableApp)
    // initialize app
    initApp(this.immutableApp)
    // add error handler after all other middleware and routers
    initErrorHandler(this.immutableApp)
    // initialize models
    await initModels(this.immutableApp)
    // intialize components after models since they may use models
    initComponents(this.immutableApp)
    // initialize services after models since they may use models
    await initServices(this.immutableApp)
    // set initialize flag to true
    this.immutableApp.initialized = true
    // debug
    debug('init', this.immutableApp)
}
677498
function (dependencies) {
            this._dependsOn = dependencies[this._name] || [];
            this._dependencyOf = [];
            Object.keys(dependencies).forEach(function (name) {
                var nameDependencies = dependencies[name];
                if (nameDependencies.indexOf(this._name) !== NOT_FOUND) {
                    this._dependencyOf.push(name);
                }
            }, this);
        }
376954
static void init(boolean includeAddOns) {
        loadedPlugins = new ArrayList<>(CoreFunctionality.getBuiltInActiveScanRules());
        if (includeAddOns) {
            loadedPlugins.addAll(ExtensionFactory.getAddOnLoader().getActiveScanRules());
        }
        //sort by the criteria below.
        Collections.sort(loadedPlugins, riskComparator);

        mapLoadedPlugins = new HashMap<>();
        for (Plugin plugin : loadedPlugins) {
            checkPluginId(plugin);
            mapLoadedPlugins.put(plugin.getId(), plugin);
        }
    }
333616
function init(){

        debug("Checking if there is a repository");
        return co(function*(){
            let repo;
            try {
                repo = yield nodegit.Repository.open(repositoryPath);
            } catch(err) {
                debug("Repository not found.");
                repo = yield _createRepository();
            }

            debug("Repository is ready");
            return repo;

        });
    }
120825
function init(ctx) {
        _.each(resources, function (resource) {
            _.each(resource.tasks, function (taskInfo, taskName) {
                taskInfo.name = taskName;
                taskInfo.service = pancakes.getService(resource.name);
                taskHandlers[taskName] = taskInfo;
            });
        });

        return new Q(ctx);
    }
686767
def initialize(self):
        
        if not os.path.exists(self.root_dir):
            os.makedirs(self.root_dir)
        assert os.path.isdir(self.root_dir), "%s is not a directory! Please move or remove it." % self.root_dir
        for d in ["bin", "lib", "include"]:
            target_path = os.path.join(self.root_dir, d)
            if not os.path.exists(target_path):
                os.makedirs(target_path)
        if not os.path.exists(self.manifest_path):
            open(self.manifest_path, "w+").close()
        self.new = False
396579
function init() {
        // This function is called during Ghost's initialization.
        // Reading translation file for messages from core .js files and keeping its content in memory
        // The English file is always loaded, until back-end translations are enabled in future versions.
        // Before that, see previous tasks on issue #6526 (error codes or identifiers, error message
        // translation at the point of display...)
        coreStrings = fs.readFileSync(path.join(__dirname, '..', '..', 'translations', 'en.json'));

        // if translation file is not valid, you will see an error
        try {
            coreStrings = JSON.parse(coreStrings);
        } catch (err) {
            coreStrings = undefined;
            throw err;
        }

        _private.initializeIntl();
    }
1167243
function init(theConfig) {
        exports.config = theConfig;

        Inspector.on("error", _onError);
        Inspector.Inspector.on("detached", _onDetached);

        // Only listen for styleSheetAdded
        // We may get interim added/removed events when pushing incremental updates
        CSSAgent.on("styleSheetAdded.livedev", _styleSheetAdded);

        MainViewManager
            .on("currentFileChange", _onFileChanged);
        DocumentManager
            .on("documentSaved", _onDocumentSaved)
            .on("dirtyFlagChange", _onDirtyFlagChange);
        ProjectManager
            .on("beforeProjectClose beforeAppClose", close);

        // Initialize exports.status
        _setStatus(STATUS_INACTIVE);
    }
380748
function() {
    this.force_first = true;
    this.relpath = '';
    this.root = process.cwd();
    this.counters = {
      files: 0,
      dependencies: 0,
      depAddUpd: 0
    };
    this.error = null;
    this.exit = null;
    this.temp = '';
    this.files = [];
    this.dependecies = [];
    this.package = null;
    this.settings = null;
    this.options = null;
  }
1196870
function canInitialize(dependencies, initialized) {
  return !dependencies || 
    dependencies.length === 0 || 
    dependencies.every(function (name) {
      return !!initialized[name];
    });
}
951002
public void initialize() {
        val pair = buildLoggerContext(environment, resourceLoader);
        pair.ifPresent(it -> {
            this.logConfigurationFile = it.getKey();
            this.loggerContext = it.getValue();
        });
    }
1093121
function Init(appGlobal, pathsList) {
            debug("Initializing Boot");
            loadFinder = new Finder();
            loadProvider = new Provider();
            loadNamespace = new Namespace();
            global = appGlobal;
            global.App = {};
            global.Modules = {};
            global.Config = {};
            this.initProviders(sortProvider);
            this.initApplication();
            this.initModules();
            var mainApp = require("../express");
            this.boot(mainApp);
            mainApp.boot = function (nameProvider, userApp) {
                debug("Booting Manual Provider");
                loadProvider.bootProvider(nameProvider, userApp ? userApp : mainApp);
            };
            mainApp.provider = function (nameProvider) {
                debug("Getting " + nameProvider + " Provider");
                return loadProvider.providerByName(nameProvider).instance;
            };
            return mainApp;
        }
429764
function (dependencies, extension) {
            if (dependencies) {
                for (var i = dependencies.length - 1; i >= 0; i--) {
                    this.addDependency(dependencies[i], extension);
                }
            }
        }
218057
public function initialize()
    {
        if (true == $this->initialized) {
            return;
        }

        $this->initialized = true;
        
        if ($this->isEnabled()) {
            $headScript = $this->getView()->plugin('headScript');
            
            $headScript->prependFile($this->src);
            
            $options = array();
            foreach (array('async', 'parseOnLoad') as $property) {
                if (null !== $this->$property) {
                    $options[$property] = $this->$property;
                }
            }
            if (!empty($this->packages)) {
                $options['packages'] = array_values($this->packages);
            }
            if (!empty($options)) {
                $headScript->prependScript("dojoConfig=" . json_encode($options) . ";");
            }
            if (!empty($this->modules)) {
                $require = 'require(["' . implode('", "', $this->modules) . '"]);';
                $headScript->appendScript($require);
            }
        }
    }
1006393
function init() {
      var _this = this;

      this._shouldSyncFromOpts = true;
      this.on('update', function () {
        if (_this._shouldSyncFromOpts) _this.trigger('sync');
        _this._shouldSyncFromOpts = true;
      });
    }
904960
def load_application_files
      if %w(development test).include?(env.to_s)
        config['autoload_paths'].each(&method(:autoreload_constants))
        autoreload_yml
      end
      config['autoload_paths'].each(&method(:require_dependencies))
    end