method to initialize map of existing nucleotides in the database

@throws FastaFormatException
if the NucleotideFactory can not be initalialized
179994
private static void initMapNucleotides() throws FastaFormatException {
		try {
			nucleotides = NucleotideFactory.getInstance().getNucleotideTemplates().get("HELM Notation");
		} catch (IOException e) {
			e.printStackTrace();
			LOG.error("NucleotideFactory can not be initialized");
			throw new FastaFormatException(e.getMessage());
		}
	}
773132
@Override
  public final void createDatabase(final String pDbName,
    final int pDbId) throws Exception {
    String dbNm = this.databasePrefix + pDbName + ".sqlite";
    synchronized (this.factoryAppBeans) {
      if (!this.factoryAppBeans.getDatabaseName().equals(dbNm)) {
        this.factoryAppBeans.setDatabaseName(dbNm);
        this.factoryAppBeans.setNewDatabaseId(pDbId);
        this.factoryAppBeans.handleDatabaseChanged();
      }
    }
  }
991677
public static void init(String dirName, StoredProcedureFactory factory) {

		if (inited) {
			if (logger.isLoggable(Level.WARNING))
				logger.warning("discarding duplicated init request");
			return;
		}
		
		// Set the stored procedure factory
		spFactory = factory;

		/*
		 * Note: We read properties file here before, but we moved it to a
		 * utility class, PropertiesFetcher, for safety reason.
		 */

		// read classes
		queryPlannerCls = CoreProperties.getLoader().getPropertyAsClass(
				VanillaDb.class.getName() + ".QUERYPLANNER",
				HeuristicQueryPlanner.class, QueryPlanner.class);
		updatePlannerCls = CoreProperties.getLoader().getPropertyAsClass(
				VanillaDb.class.getName() + ".UPDATEPLANNER",
				IndexUpdatePlanner.class, UpdatePlanner.class);
		
		// initialize storage engine
		initFileAndLogMgr(dirName);
		initTaskMgr();
		initTxMgr();

		// the first transaction for initializing the system
		Transaction initTx = txMgr.newTransaction(
				Connection.TRANSACTION_SERIALIZABLE, false);

		/*
		 * initialize the catalog manager to ensure the recovery process can get
		 * the index info (required for index logical recovery)
		 */
		boolean isDbNew = fileMgr.isNew();
		initCatalogMgr(isDbNew, initTx);
		if (isDbNew) {
			if (logger.isLoggable(Level.INFO))
				logger.info("creating new database...");
		} else {
			if (logger.isLoggable(Level.INFO))
				logger.info("recovering existing database");
			// add a checkpoint record to limit rollback
			RecoveryMgr.initializeSystem(initTx);
		}

		// initialize the statistics manager to build the histogram
		initStatMgr(initTx);
		
		// create a checkpoint
		txMgr.createCheckpoint(initTx);

		// commit the initializing transaction
		initTx.commit();

		// initializing checkpointing task
		boolean doCheckpointing = CoreProperties.getLoader().getPropertyAsBoolean(
				VanillaDb.class.getName() + ".DO_CHECKPOINT", true);
		if (doCheckpointing)
			initCheckpointingTask();

		// finish initialization
		inited = true;
	}
492702
def _init_map(self, record_types=None, **kwargs):
        """"""

        osid_objects.OsidContainableForm._init_map(self)
        osid_objects.OsidSourceableForm._init_map(self)
        osid_objects.OsidObjectForm._init_map(self, record_types=record_types)
        self._my_map['childIds'] = self._children_default
        self._my_map['assignedRepositoryIds'] = [str(kwargs['repository_id'])]
626851
public void initialize() {
		mIsForceStop = false;
		mTagStack.clear();
		mTagValueCache.clear();
		mTagAttrCache.clear();
		mCurrentTagKey = null;
	}
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);
    }
859111
private static function init() {
        self::$huffmanLookup = self::huffmanLookupInit();
        self::$huffmanCodes = self::huffmanCodesInit();
        self::$huffmanLengths = self::huffmanLengthsInit();

        foreach (\array_column(self::TABLE, 0) as $index => $name) {
            if (isset(self::$indexMap[$name])) {
                continue;
            }

            self::$indexMap[$name] = $index + 1;
        }
    }
741172
public void initPropertyMap() {
        propertyMap = new HashMap<String, EntityColumn>(getEntityClassColumns().size());
        for (EntityColumn column : getEntityClassColumns()) {
            propertyMap.put(column.getProperty(), column);
        }
    }
1273547
public void init() {
      registerListener();
      for (int i = 0; i < entries.length; ++i) {
         final int index = i;
         awaitCounterOperation(readOnlyMap.eval(entries[index].key, ReadFunction.getInstance())
               .thenAccept(value -> initEntry(index, value)));
      }
      selector.updatePreferredKeys();
   }
805713
public function init()
    {

        // initialize the prepared statements
        $this->productLinkAttributeDecimalStmt =
            $this->getConnection()->prepare($this->loadStatement(SqlStatementKeys::PRODUCT_LINK_ATTRIBUTE_DECIMAL));
    }
93013
def _init_map(self):
        """"""
        DecimalValuesFormRecord._init_map(self)
        IntegerValuesFormRecord._init_map(self)
        TextAnswerFormRecord._init_map(self)
        super(MultiLanguageCalculationInteractionFeedbackAndFilesAnswerFormRecord, self)._init_map()
        self.my_osid_object_form._my_map['toleranceMode'] = \
            self._tolerance_mode_metadata['default_string_values'][0]
631498
private void initTangoFactory() {
        // we get the properties with instance of objects
        final Properties properties = getPropertiesFile();
        // if(properties == null || properties.size() == 0 ||
        // !properties.containsKey(TANGO_FACTORY))
        // {
        // //tangoFactory = new DefaultTangoFactoryImpl();
        // //TANGO_FACTORY = fr.esrf.TangoApi.factory.WebTangoFactoryImpl
        //
        // tangoFactory = (ITangoFactory)getObject("");
        // isDefaultFactory = false;
        // }
        // else
        // {

        String factoryClassName = properties.getProperty(TANGO_FACTORY);
        if (factoryClassName == null) {
            factoryClassName = "fr.esrf.TangoApi.factory.DefaultTangoFactoryImpl";
        }
        //System.out.println("TANGO_FACTORY " + factoryClassName);
        tangoFactory = (ITangoFactory) getObject(factoryClassName);
        isDefaultFactory = false;
        // }
    }
1091191
def initRnaQuantificationSet(self):
        
        store = rnaseq2ga.RnaSqliteStore(self._args.filePath)
        store.createTables()
1235985
def _init_map(self):
        """"""
        DecimalValuesFormRecord._init_map(self)
        IntegerValuesFormRecord._init_map(self)
        TextAnswerFormRecord._init_map(self)
        FilesAnswerFormRecord._init_map(self)
        FeedbackAnswerFormRecord._init_map(self)
        super(CalculationInteractionFeedbackAndFilesAnswerFormRecord, self)._init_map()
        self.my_osid_object_form._my_map['toleranceMode'] = \
            self._tolerance_mode_metadata['default_string_values'][0]
1342816
void initialize() {
        Preconditions.checkState(this.database.get() == null, "%s has already been initialized.", this.logId);

        try {
            clear(true);
            this.database.set(openDatabase());
        } catch (Exception ex) {
            // Make sure we cleanup anything we may have created in case of failure.
            try {
                close();
            } catch (Exception closeEx) {
                ex.addSuppressed(closeEx);
            }

            throw ex;
        }

        log.info("{}: Initialized.", this.logId);
    }
1264763
private void initMapper() {
        final BeanPropertyFilter filterOutAllExcept =
                SimpleBeanPropertyFilter.filterOutAllExcept("fname", "executionTimeNano");
        this.mapper.addMixInAnnotations(
                PortalEvent.class, PortletRenderExecutionEventFilterMixIn.class);
        final SimpleFilterProvider filterProvider = new SimpleFilterProvider();
        filterProvider.addFilter(
                PortletRenderExecutionEventFilterMixIn.FILTER_NAME, filterOutAllExcept);
        this.portletEventWriter = this.mapper.writer(filterProvider);
    }
1232542
def _init_data_map(self):
        

        if self._data_map is not None:
            return  # Initiation happens once

        # Parse and validate the FGDC metadata root

        if self._xml_tree is None:
            fgdc_root = FGDC_ROOT
        else:
            fgdc_root = get_element_name(self._xml_tree)

        if fgdc_root != FGDC_ROOT:
            raise InvalidContent('Invalid XML root for ISO-19115 standard: {root}', root=fgdc_root)

        fgdc_data_map = {'_root': FGDC_ROOT}
        fgdc_data_structures = {}

        # Capture and format other complex XPATHs

        ad_format = _fgdc_tag_formats[ATTRIBUTES]
        fgdc_data_structures[ATTRIBUTES] = format_xpaths(
            _fgdc_definitions[ATTRIBUTES],
            label=ad_format.format(ad_path='attrlabl'),
            aliases=ad_format.format(ad_path='attalias'),
            definition=ad_format.format(ad_path='attrdef'),
            definition_src=ad_format.format(ad_path='attrdefs')
        )

        bb_format = _fgdc_tag_formats[BOUNDING_BOX]
        fgdc_data_structures[BOUNDING_BOX] = format_xpaths(
            _fgdc_definitions[BOUNDING_BOX],
            east=bb_format.format(bbox_path='eastbc'),
            south=bb_format.format(bbox_path='southbc'),
            west=bb_format.format(bbox_path='westbc'),
            north=bb_format.format(bbox_path='northbc')
        )

        ct_format = _fgdc_tag_formats[CONTACTS]
        fgdc_data_structures[CONTACTS] = format_xpaths(
            _fgdc_definitions[CONTACTS],

            name=ct_format.format(ct_path='cntperp/cntper'),
            _name=ct_format.format(ct_path='cntorgp/cntper'),  # If not in cntperp

            organization=ct_format.format(ct_path='cntperp/cntorg'),
            _organization=ct_format.format(ct_path='cntorgp/cntorg'),  # If not in cntperp

            position=ct_format.format(ct_path='cntpos'),
            email=ct_format.format(ct_path='cntemail')
        )

        dt_format = _fgdc_tag_formats[DATES]
        fgdc_data_structures[DATES] = {
            DATE_TYPE_MULTIPLE: dt_format.format(type_path='mdattim/sngdate/caldate'),
            DATE_TYPE_RANGE_BEGIN: dt_format.format(type_path='rngdates/begdate'),
            DATE_TYPE_RANGE_END: dt_format.format(type_path='rngdates/enddate'),
            DATE_TYPE_SINGLE: dt_format.format(type_path='sngdate/caldate')
        }
        fgdc_data_structures[DATES][DATE_TYPE_RANGE] = [
            fgdc_data_structures[DATES][DATE_TYPE_RANGE_BEGIN],
            fgdc_data_structures[DATES][DATE_TYPE_RANGE_END]
        ]

        df_format = _fgdc_tag_formats[DIGITAL_FORMS]
        fgdc_data_structures[DIGITAL_FORMS] = format_xpaths(
            _fgdc_definitions[DIGITAL_FORMS],
            name=df_format.format(df_path='digtinfo/formname'),
            content=df_format.format(df_path='digtinfo/formcont'),
            decompression=df_format.format(df_path='digtinfo/filedec'),
            version=df_format.format(df_path='digtinfo/formvern'),
            specification=df_format.format(df_path='digtinfo/formspec'),
            access_desc=df_format.format(df_path='digtopt/onlinopt/oncomp'),
            access_instrs=df_format.format(df_path='digtopt/onlinopt/accinstr'),
            network_resource=df_format.format(df_path='digtopt/onlinopt/computer/networka/networkr')
        )

        lw_format = _fgdc_tag_formats[LARGER_WORKS]
        fgdc_data_structures[LARGER_WORKS] = format_xpaths(
            _fgdc_definitions[LARGER_WORKS],
            title=lw_format.format(lw_path='title'),
            edition=lw_format.format(lw_path='edition'),
            origin=lw_format.format(lw_path='origin'),
            online_linkage=lw_format.format(lw_path='onlink'),
            other_citation=lw_format.format(lw_path='othercit'),
            date=lw_format.format(lw_path='pubdate'),
            place=lw_format.format(lw_path='pubinfo/pubplace'),
            info=lw_format.format(lw_path='pubinfo/publish')
        )

        ps_format = _fgdc_tag_formats[PROCESS_STEPS]
        fgdc_data_structures[PROCESS_STEPS] = format_xpaths(
            _fgdc_definitions[PROCESS_STEPS],
            description=ps_format.format(ps_path='procdesc'),
            date=ps_format.format(ps_path='procdate'),
            sources=ps_format.format(ps_path='srcused')
        )

        ri_format = _fgdc_tag_formats[RASTER_INFO]
        fgdc_data_structures[RASTER_INFO] = format_xpaths(
            _fgdc_definitions[RASTER_INFO],

            dimensions=ri_format.format(ri_path='rasttype'),
            row_count=ri_format.format(ri_path='rowcount'),
            column_count=ri_format.format(ri_path='colcount'),
            vertical_count=ri_format.format(ri_path='vrtcount'),

            x_resolution=_fgdc_tag_formats['_raster_resolution'] + '/absres',
            _x_resolution=_fgdc_tag_formats['__raster_resolution'] + '/longres',
            y_resolution=_fgdc_tag_formats['_raster_resolution'] + '/ordres',
            _y_resolution=_fgdc_tag_formats['__raster_resolution'] + '/latres',
        )

        # Assign XPATHS and gis_metadata.utils.ParserProperties to fgdc_data_map

        fgdc_data_formats = dict(_fgdc_tag_formats)

        for prop, xpath in iteritems(fgdc_data_formats):
            if prop in (ATTRIBUTES, CONTACTS, DIGITAL_FORMS, PROCESS_STEPS):
                fgdc_data_map[prop] = ParserProperty(self._parse_complex_list, self._update_complex_list)

            elif prop in (BOUNDING_BOX, LARGER_WORKS):
                fgdc_data_map[prop] = ParserProperty(self._parse_complex, self._update_complex)

            elif prop == DATES:
                fgdc_data_map[prop] = ParserProperty(self._parse_dates, self._update_dates)

            elif prop == RASTER_INFO:
                fgdc_data_map[prop] = ParserProperty(self._parse_complex, self._update_raster_info)

            else:
                fgdc_data_map[prop] = xpath

        self._data_map = fgdc_data_map
        self._data_structures = fgdc_data_structures