Initialise all the entity data providers available.
763576
private void initialiseProviders() {
        // Topic Provider
        final DBTopicProvider topicProvider = new DBTopicProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBTopicProvider.class, topicProvider);
        providerMap.put(TopicProvider.class, topicProvider);

        // Tag Provider
        final DBTagProvider tagProvider = new DBTagProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBTagProvider.class, tagProvider);
        providerMap.put(TagProvider.class, tagProvider);

        // Translated Topic Provider
        final DBTranslatedTopicProvider translatedTopicProvider = new DBTranslatedTopicProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBTranslatedTopicProvider.class, translatedTopicProvider);
        providerMap.put(TranslatedTopicProvider.class, translatedTopicProvider);

        // Translated Topic String Provider
        final DBTranslatedTopicStringProvider translatedTopicStringProvider = new DBTranslatedTopicStringProvider(getEntityManager(),
                this, getListeners());
        providerMap.put(DBTranslatedTopicStringProvider.class, translatedTopicStringProvider);
        providerMap.put(TranslatedTopicStringProvider.class, translatedTopicStringProvider);

        // User Provider
        final DBUserProvider userProvider = new DBUserProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBUserProvider.class, userProvider);
        providerMap.put(UserProvider.class, userProvider);

        // String Constant Provider
        final DBStringConstantProvider stringConstantProvider = new DBStringConstantProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBStringConstantProvider.class, stringConstantProvider);
        providerMap.put(StringConstantProvider.class, stringConstantProvider);

        // Blob Constant Provider
        final DBBlobConstantProvider blobConstantProvider = new DBBlobConstantProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBBlobConstantProvider.class, blobConstantProvider);
        providerMap.put(BlobConstantProvider.class, blobConstantProvider);

        // File Provider
        final DBFileProvider fileProvider = new DBFileProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBFileProvider.class, fileProvider);
        providerMap.put(FileProvider.class, fileProvider);

        // Language File Provider
        final DBLanguageFileProvider languageFileProvider = new DBLanguageFileProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBLanguageFileProvider.class, languageFileProvider);
        providerMap.put(LanguageFileProvider.class, languageFileProvider);

        // Image Provider
        final DBImageProvider imageProvider = new DBImageProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBImageProvider.class, imageProvider);
        providerMap.put(ImageProvider.class, imageProvider);

        // Language Image Provider
        final DBLanguageImageProvider languageImageProvider = new DBLanguageImageProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBLanguageImageProvider.class, languageImageProvider);
        providerMap.put(LanguageImageProvider.class, languageImageProvider);

        // Category Provider
        final DBCategoryProvider categoryProvider = new DBCategoryProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBCategoryProvider.class, categoryProvider);
        providerMap.put(CategoryProvider.class, categoryProvider);

        // Topic Source URL Provider
        final DBTopicSourceURLProvider topicSourceURLProvider = new DBTopicSourceURLProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBTopicSourceURLProvider.class, topicSourceURLProvider);
        providerMap.put(TopicSourceURLProvider.class, topicSourceURLProvider);

        // PropertyTag Provider
        final DBPropertyTagProvider propertyTagProvider = new DBPropertyTagProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBPropertyTagProvider.class, propertyTagProvider);
        providerMap.put(PropertyTagProvider.class, propertyTagProvider);

        // Content Spec Provider
        final DBContentSpecProvider contentSpecProvider = new DBContentSpecProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBContentSpecProvider.class, contentSpecProvider);
        providerMap.put(ContentSpecProvider.class, contentSpecProvider);

        // Text Content Spec Provider
        final DBTextContentSpecProvider textContentSpecProvider = new DBTextContentSpecProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBTextContentSpecProvider.class, textContentSpecProvider);
        providerMap.put(TextContentSpecProvider.class, textContentSpecProvider);

        // Content Spec Node Provider
        final DBCSNodeProvider csNodeProvider = new DBCSNodeProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBCSNodeProvider.class, csNodeProvider);
        providerMap.put(CSNodeProvider.class, csNodeProvider);

        // Content Spec Node Provider
        final DBCSInfoNodeProvider csNodeInfoProvider = new DBCSInfoNodeProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBCSInfoNodeProvider.class, csNodeInfoProvider);
        providerMap.put(CSInfoNodeProvider.class, csNodeInfoProvider);

        // Translated Content Spec Provider
        final DBTranslatedContentSpecProvider translatedContentSpecProvider = new DBTranslatedContentSpecProvider(getEntityManager(),
                this, getListeners());
        providerMap.put(DBTranslatedContentSpecProvider.class, translatedContentSpecProvider);
        providerMap.put(TranslatedContentSpecProvider.class, translatedContentSpecProvider);

        // Translated Content Spec Node Provider
        final DBTranslatedCSNodeProvider translatedCSNodeProvider = new DBTranslatedCSNodeProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBTranslatedCSNodeProvider.class, translatedCSNodeProvider);
        providerMap.put(TranslatedCSNodeProvider.class, translatedCSNodeProvider);

        // Translated Content Spec Node String Provider
        final DBTranslatedCSNodeStringProvider translatedCSNodeStringProvider = new DBTranslatedCSNodeStringProvider(getEntityManager(),
                this, getListeners());
        providerMap.put(DBTranslatedCSNodeStringProvider.class, translatedCSNodeStringProvider);
        providerMap.put(TranslatedCSNodeStringProvider.class, translatedCSNodeStringProvider);

        // Log Message Provider
        final DBLogMessageProvider logMessageProvider = new DBLogMessageProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBLogMessageProvider.class, logMessageProvider);
        providerMap.put(LogMessageProvider.class, logMessageProvider);

        // Server Settings Provider
        final DBServerSettingsProvider serverSettingsProvider = new DBServerSettingsProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBServerSettingsProvider.class, serverSettingsProvider);
        providerMap.put(ServerSettingsProvider.class, serverSettingsProvider);

        // Locales Provider
        final DBLocaleProvider localeProvider = new DBLocaleProvider(getEntityManager(), this, getListeners());
        providerMap.put(DBLocaleProvider.class, localeProvider);
        providerMap.put(LocaleProvider.class, localeProvider);

        // Translation Server Provider
        final DBTranslationServerProvider translationServerProvider = new DBTranslationServerProvider(getEntityManager(), this,
                getListeners());
        providerMap.put(DBTranslationServerProvider.class, translationServerProvider);

        providersInitialised = true;
    }
166513
def init_from_datastore(self):
    """"""
    self._data = {}
    for entity in self._datastore_client.query_fetch(
        kind=self._entity_kind_batches):
      batch_id = entity.key.flat_path[-1]
      self._data[batch_id] = dict(entity)
      self._data[batch_id]['images'] = {}
    for entity in self._datastore_client.query_fetch(
        kind=self._entity_kind_images):
      batch_id = entity.key.flat_path[-3]
      image_id = entity.key.flat_path[-1]
      self._data[batch_id]['images'][image_id] = dict(entity)
1115481
public void initSchema() {
		List<Resource> scripts = getScripts("spring.datasource.data",
				this.properties.getData(), "data");
		if (!scripts.isEmpty()) {
			if (!isEnabled()) {
				logger.debug("Initialization disabled (not running data scripts)");
				return;
			}
			String username = this.properties.getDataUsername();
			String password = this.properties.getDataPassword();
			runScripts(scripts, username, password);
		}
	}
1323142
private void init()
    {
        jdbcProperties = new Properties();
        dbcpProperties = new Properties();
        setFetchSize(0);
        this.setTestOnBorrow(true);
        this.setTestOnReturn(false);
        this.setTestWhileIdle(false);
        this.setLogAbandoned(false);
        this.setRemoveAbandoned(false);
    }
738835
private void initDataUpgraders() {
        final Map<PortalDataKey, IDataUpgrader> dataUpgraderMap = new LinkedHashMap<>();

        for (final IDataUpgrader dataUpgrader : dataUpgraders) {

            try {

                final Set<PortalDataKey> upgradeDataKeys = dataUpgrader.getSourceDataTypes();
                for (final PortalDataKey upgradeDataKey : upgradeDataKeys) {
                    this.logger.debug(
                            "Registering IDataUpgrader for '{}' - {}",
                            upgradeDataKey,
                            dataUpgrader);
                    final IDataUpgrader existing =
                            dataUpgraderMap.put(upgradeDataKey, dataUpgrader);
                    if (existing != null) {
                        this.logger.warn(
                                "Duplicate IDataUpgrader PortalDataKey for {} Replacing {} with {}",
                                upgradeDataKey,
                                existing,
                                dataUpgrader);
                    }
                }

            } catch (Exception exception) {
                logger.error("Failed to register data upgrader {}.", dataUpgrader, exception);
            }
        }

        this.portalDataUpgraders = Collections.unmodifiableMap(dataUpgraderMap);
    }
358292
public synchronized void initialize() {

        List<I_CmsContextMenuItem> result = Lists.newArrayList();
        for (I_CmsContextMenuItemProvider provider : m_providerMap.values()) {
            result.addAll(provider.getMenuItems());
        }
        m_itemCache = result;
    }
781755
private void initializeDefaultTenant() {
        DBService dbService = DBService.instance();
        dbService.createNamespace();
        dbService.createStoreIfAbsent(SchemaService.APPS_STORE_NAME, false);
        dbService.createStoreIfAbsent(TaskManagerService.TASKS_STORE_NAME, false);
        dbService.createStoreIfAbsent(TENANTS_STORE_NAME, false);
        storeInitialDefaultTenantDef();
    }
714163
public function initialize()
    {
        $userMethods = $this->getCustomMethods();

        // Parse EntityMap for method based relationship
        if (count($userMethods) > 0) {
            $this->relationships = $this->parseMethodsForRelationship($userMethods);
        }

        // Parse EntityMap for dynamic relationships
        if (count($this->dynamicRelationships) > 0) {
            $this->relationships = $this->relationships + $this->getDynamicRelationships();
        }
    }
1201293
def load(self, data):
        
        objs = {}
        for mapper in self.entities:
            objs[mapper.name] = mapper.load(self.loader, data)

        for mapper in self.relations:
            objs[mapper.name] = mapper.load(self.loader, data, objs)
1060535
private function initDbal()
	{
		$app = $this->getApp();

		$config = $app->getConfig();

		$config->load('db', true);
		$config->load('dbal', true);

		$this->defaultConfig = Arr::filterKeys($config->get('dbal', []), ['connections', 'types'], true);

		// Register types
		foreach ($config->get('dbal.types', []) as $type => $class)
		{
			Type::addType($type, $class);
		}
	}
332433
public function initialise()
    {
        $this->lti_context_id = null;
        $this->lti_resource_id = null;
        $this->title = '';
        $this->settings = [];
        $this->groupSets = null;
        $this->groups = null;
        $this->primary_consumer_key = null;
        $this->primary_resource_link_id = null;
        $this->share_approved = null;
        $this->created = null;
        $this->updated = null;
    }
191543
public function initialize()
    {
        $this->initializeShortAliases();
        $this->initializeDefaultAliases();
        foreach ($this->schemaManager->getSchemaTables() as $table) {
            $this->loadMetadataForTable($table);
        }
        $this->initialized = true;
    }
952478
protected final void initialize() {
        // Enabling development mode forces these settings. This is somewhat inelegant, because to configure one of
        // these values differently will require disabling development mode and manually configure the remaining values.
        if (development) {
            loggingSettings.getLoggers().put("org.hibernate.SQL", Level.DEBUG);
            loggingSettings.getLoggers().put("com.metrink.croquet", Level.DEBUG);
        }

        // call the class's init method
        init();
    }
383600
protected function initialize()
    {
        if ($this->isInitialized) {
            return;
        }
        if (!$this->dbAdapter instanceof Adapter) {
            throw new \Exception('No db adapter present');
        }
        if (!$this->hydrator instanceof HydratorInterface) {
            $this->hydrator = new ClassMethods;
        }
        if (!is_object($this->entityPrototype)) {
            throw new \Exception('No entity prototype set');
        }

        $this->isInitialized = true;
    }
1116483
protected function init()
    {
        $this->checkDatabaseFile();

        $this->reader = new Reader(
            $this->getDatabasePath(),
            $this->getLocales()
        );
    }
759746
private void initialize() {

		domainIds.addAll(getResourceIds("rdfs:domain"));
		rangeIds.addAll(getResourceIds("rdfs:range"));
		typeIds.addAll(getResourceIds("krdf:type"));

		allowsInstances     = "true".equals(getValue(getFirstElement(getElement(), "krdf:allowsInstances")));
		multipleOccurrences = "true".equals(getValue(getFirstElement(getElement(), "krdf:multipleOccurrences")));
		isMixedIn           = "true".equals(getValue(getFirstElement(getElement(), "krdf:isMixedIn")));
		oneWay              = "true".equals(getValue(getFirstElement(getElement(), "krdf:oneWay")));
	}
562943
def _initialize(self):
        """"""

        self.log.debug("Start initializing data from %s",
                       self.url)
        resp = self.get(self.url,
                        verify=False,
                        proxies=self.rtc_obj.proxies,
                        headers=self.rtc_obj.headers)
        self.__initialize(resp)
        self.log.info("Finish the initialization for <%s %s>",
                      self.__class__.__name__, self)