Initializes db specific domain mapping.
977243
protected function initialize()
    {
        parent::initialize();
        $this->setSchemaDomainMapping(new Domain(PropelTypes::BOOLEAN, 'BOOLEAN'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::TINYINT, 'INT2'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::SMALLINT, 'INT2'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::BIGINT, 'INT8'));
        //$this->setSchemaDomainMapping(new Domain(PropelTypes::REAL, 'FLOAT'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::DOUBLE, 'DOUBLE PRECISION'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::FLOAT, 'DOUBLE PRECISION'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::LONGVARCHAR, 'TEXT'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::BINARY, 'BYTEA'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::VARBINARY, 'BYTEA'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::LONGVARBINARY, 'BYTEA'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::BLOB, 'BYTEA'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::CLOB, 'TEXT'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::OBJECT, 'BYTEA'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::PHP_ARRAY, 'TEXT'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::ENUM, 'INT2'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::SET, 'INT4'));
        $this->setSchemaDomainMapping(new Domain(PropelTypes::DECIMAL, 'NUMERIC'));
    }
493946
public static void initialize(Object instance, Map namedArgs) {
        PersistentEntity dc = getDomainClass(instance);
        if (dc == null) {
            DataBindingUtils.bindObjectToInstance(instance, namedArgs);
        }
        else {
            DataBindingUtils.bindObjectToDomainInstance(dc, instance, namedArgs);
            DataBindingUtils.assignBidirectionalAssociations(instance, namedArgs, dc);
        }
        autowire(instance);
    }
811197
protected void init(String domain){
    // get list of public fields
    java.lang.reflect.Field[] fields = this.getClass().getDeclaredFields();
    if(fields.length > 0){
      if(domain == null)
        domain = fields[0].getDeclaringClass().getName();
      // Fix our debugging to use the child classname
      logger = Logging.getLogger(fields[0].getDeclaringClass().getName());
    }
    logger.debug("Beginning initialization from PropertyManager using domain='" + domain + "'");
    PropertyManager.ManagedProperties properties = PropertyManager.getProperties(domain);
    PropertyManager.ManagedProperties secureProperties = PropertyManager.getProperties("_" + domain);
    // Go through all the public fields in this class, and try to fill them from
    // our property class
    logger.debug("field count = " + fields.length);
    for(int i = 0; i < fields.length; i++){
      String fieldName = fields[i].getName();
      Class<?> type = fields[i].getType();
      String value = secureProperties.getProperty(fieldName);
      boolean doSecurely = value != null;
      if(value == null)
        value = properties.getProperty(fieldName);
      boolean isArray = fields[i].getType().isArray();
      try{
        if(isArray){
          if(value == null){
            // We need to grab all the values for the array (.0,.1,.2, etc)
            List<String> values = new ArrayList<String>();
            for(int j = 0; true; j++){
              if(doSecurely)
                value = secureProperties.getProperty(fieldName + "." + j);
              else
                value = properties.getProperty(fieldName + "." + j);
              if(value == null)
                break;
              if(doSecurely)
                logger.info("Setting field '" + fieldName + ":" + type.getComponentType().getName() + "' [" + j + "] to ***PROTECTED***");
              else
                logger.info("Setting field '" + fieldName + ":" + type.getComponentType().getName() + "' [" + j + "] to " + value);
              values.add(value);
            }
            if(values.size() == 0)
              continue;

            fields[i].setAccessible(true);
            fields[i].set(null, getObjectForString(type, values.toArray(new String[values.size()])));
          }else{
            // We have a single property value, try to deserialize gson
            fields[i].setAccessible(true);
            fields[i].set(null, getObjectForString(type, value));
          }
        }else if(value != null){
          if(doSecurely)
            logger.info("Setting field '" + fieldName + ":" + type.getName() + "' to ***PROTECTED***");
          else
            logger.info("Setting field '" + fieldName + ":" + type.getName() + "' to " + value);
          fields[i].setAccessible(true);
          fields[i].set(null, getObjectForString(type, value));
        }else{
          // debug.debug("'" + fieldName + "' does not exist in the properties
          // file. (Domain='" + domain + "') Leaving alone.");
        }
      }catch(Exception ex){
        logger.error("Error setting field '" + fieldName + "'. Check properties file.", ex);
      }
    }
    logger.debug("Init complete");
  }
824142
def setup(db_class, simple_object_cls, primary_keys):
    """"""
    table_name = simple_object_cls.__name__
    column_names = simple_object_cls.FIELDS

    metadata = MetaData()
    table = Table(table_name, metadata,
                  *[Column(cname, _get_best_column_type(cname),
                           primary_key=cname in primary_keys)
                    for cname in column_names])

    db_class.metadata = metadata
    db_class.mapper_class = simple_object_cls
    db_class.table = table

    mapper(simple_object_cls, table)
1177306
protected void initialize() {
        this.mappedFields = new HashMap<String, PropertyDescriptor>();
        PropertyDescriptor[] pds = BeanUtils.getPropertyDescriptors(mappedClass);
        if (checkProperties) {
            mappedProperties = new HashSet<String>();
        }
        for (int i = 0; i < pds.length; i++) {
            PropertyDescriptor pd = pds[i];
            if (pd.getWriteMethod() != null) {
                if (checkProperties) {
                    this.mappedProperties.add(pd.getName());
                }
                this.mappedFields.put(pd.getName().toLowerCase(), pd);
                for (String underscoredName : underscoreName(pd.getName())) {
                    if (underscoredName != null
                            && !pd.getName().toLowerCase().equals(underscoredName)) {
                        this.mappedFields.put(underscoredName, pd);
                    }
                }
            }
        }
    }
191543
public function initialize()
    {
        $this->initializeShortAliases();
        $this->initializeDefaultAliases();
        foreach ($this->schemaManager->getSchemaTables() as $table) {
            $this->loadMetadataForTable($table);
        }
        $this->initialized = true;
    }
432054
def init(lang, domain):
    
    translations_dir = _get_translations_dir()
    domain = _get_translations_domain(domain)
    pot = os.path.join(translations_dir, f'{domain}.pot')
    return _run(f'init -i {pot} -d {translations_dir} -l {lang} --domain={domain}')
966204
@SuppressWarnings("unchecked")
    private void initTypesMapping() {
        if (mapping == null) {
            throw new IllegalStateException("Mapping does contain any information in " +
                    "DeployerTypesResolver " + this);
        }

        if (mapping.containsKey(NODE_TYPES_MAPPING_SECTION)) {
            log.debug("Mapping contains NodeTypes mapping");
            nodeTypesMapping = (Map<String, String>) mapping.get(NODE_TYPES_MAPPING_SECTION);
        }

        if (mapping.containsKey(RELATIONSHIP_TYPES_MAPPING_SECTION)) {
            log.debug("Mapping contains NodeTypes mapping");
            relationshipTypesMapping = (Map<String, String>) mapping
                    .get(RELATIONSHIP_TYPES_MAPPING_SECTION);
        }

        if (mapping.containsKey(NODE_TYPES_DEFINITIONS)) {
            log.debug("Mapping contains NodeTypes description");
            nodeTypesDefinitions = (Map<String, Object>) mapping.get(NODE_TYPES_DEFINITIONS);
        }

        if (mapping.containsKey(POLICY_TYPES_MAPPING_SECTION)) {
            log.debug("Mapping contains Policy mapping");
            policyTypesMapping = (Map<String, String>) mapping.get(POLICY_TYPES_MAPPING_SECTION);
        }
    }
1041878
public void init(final Map<String, Map<String, DataSourceConfiguration>> dataSourceConfigurationMap,
                     final Map<String, RuleConfiguration> schemaRuleMap, final Authentication authentication, final Properties props) {
        for (Entry<String, Map<String, DataSourceConfiguration>> entry : dataSourceConfigurationMap.entrySet()) {
            configService.persistConfiguration(entry.getKey(), dataSourceConfigurationMap.get(entry.getKey()), schemaRuleMap.get(entry.getKey()), authentication, props, isOverwrite);
        }
        stateService.persistInstanceOnline();
        stateService.persistDataSourcesNode();
        listenerManager.initListeners();
    }
835228
def _init_map(self, record_types=None, **kwargs):
        """"""
        osid_objects.OsidObjectForm._init_map(self, record_types=record_types)
        self._my_map['assignedObjectiveBankIds'] = [str(kwargs['objective_bank_id'])]
        self._my_map['cognitiveProcessId'] = self._cognitive_process_default
        self._my_map['assessmentId'] = self._assessment_default
        self._my_map['knowledgeCategoryId'] = self._knowledge_category_default
816282
public function initialize()
    {
        $contentTypes = $this->contentTypeRepository->findAllNotDeletedInLastVersion();

        foreach ($contentTypes as $contentType) {
            $this->schemaGenerator->createMapping($contentType);
        }
    }
769432
def _init_map(self, record_types=None, **kwargs):
        """"""
        osid_objects.OsidRelationshipForm._init_map(self, record_types=record_types)
        self._my_map['assignedVaultIds'] = [str(kwargs['vault_id'])]
        self._my_map['functionId'] = str(kwargs['function_id'])
        self._my_map['qualifierId'] = str(kwargs['qualifier_id'])
        self._my_map['agentId'] = None
        self._my_map['resourceId'] = None
        self._my_map['trustId'] = None
        self._my_map['implicit'] = None
        if 'agent_id' in kwargs:
            self._my_map['agentId'] = str(kwargs['agent_id'])
        if 'resource_id' in kwargs:
            self._my_map['resourceId'] = str(kwargs['resource_id'])
926317
void initialize()
    {
        if (m_backend == BackendTarget.HSQLDB_BACKEND) {
            m_non_voltdb_backend = HsqlBackend.initializeHSQLBackend(m_siteId,
                                                       m_context);
        }
        else if (m_backend == BackendTarget.POSTGRESQL_BACKEND) {
            m_non_voltdb_backend = PostgreSQLBackend.initializePostgreSQLBackend(m_context);
        }
        else if (m_backend == BackendTarget.POSTGIS_BACKEND) {
            m_non_voltdb_backend = PostGISBackend.initializePostGISBackend(m_context);
        }
        else {
            m_non_voltdb_backend = null;
        }
    }
1281533
def _init_map(self, record_types=None, **kwargs):
        """"""
        osid_objects.OsidObjectForm._init_map(self, record_types=record_types)
        self._my_map['rubricId'] = self._rubric_default
        self._my_map['assignedBankIds'] = [str(kwargs['bank_id'])]
        self._my_map['levelId'] = self._level_default
        if self._supports_simple_sequencing():
            self._my_map['childIds'] = []
11605
public void initialize() {
        /*
         * Use a set to ensure we ignore duplicates.
         */
        val attributes = new HashSet<String>();
        LOGGER.debug("Initializing LDAP attribute configuration...");
        if (StringUtils.isNotBlank(this.principalIdAttribute)) {
            LOGGER.debug("Configured to retrieve principal id attribute [{}]", this.principalIdAttribute);
            attributes.add(this.principalIdAttribute);
        }
        if (this.principalAttributeMap != null && !this.principalAttributeMap.isEmpty()) {
            val attrs = this.principalAttributeMap.keySet();
            attributes.addAll(attrs);
            LOGGER.debug("Configured to retrieve principal attribute collection of [{}]", attrs);
        }
        if (authenticator.getReturnAttributes() != null) {
            val authenticatorAttributes = CollectionUtils.wrapList(authenticator.getReturnAttributes());
            if (!authenticatorAttributes.isEmpty()) {
                LOGGER.debug("Filtering authentication entry attributes [{}] based on authenticator attributes [{}]", authenticatedEntryAttributes, authenticatorAttributes);
                attributes.removeIf(authenticatorAttributes::contains);
            }
        }
        this.authenticatedEntryAttributes = attributes.toArray(ArrayUtils.EMPTY_STRING_ARRAY);
        LOGGER.debug("LDAP authentication entry attributes for the authentication request are [{}]", (Object[]) this.authenticatedEntryAttributes);
    }
311340
def _init_map(self, record_types=None, **kwargs):
        """"""
        osid_objects.OsidObjectForm._init_map(self, record_types=record_types)
        self._my_map['outputScore'] = self._output_score_default
        self._my_map['gradeSystemId'] = str(kwargs['grade_system_id'])
        self._my_map['inputScoreEndRange'] = self._input_score_end_range_default
        self._my_map['inputScoreStartRange'] = self._input_score_start_range_default
        self._my_map['assignedGradebookIds'] = [str(kwargs['gradebook_id'])]
348496
protected function initDatabase()
    {
        $dbConfig = (array) config("database");

        if (count($dbConfig) > 0) {
            $this->db = new Database($dbConfig);
            Model::$db = $this->db;
        }
    }