Creates and assigns default Mappers various common types.
349133
private void createDefaultMappers() {
    BooleanMapper booleanMapper = new BooleanMapper();
    CharMapper charMapper = new CharMapper();
    ShortMapper shortMapper = new ShortMapper();
    IntegerMapper integerMapper = new IntegerMapper();
    LongMapper longMapper = new LongMapper();
    FloatMapper floatMapper = new FloatMapper();
    DoubleMapper doubleMapper = new DoubleMapper();

    cache.put(boolean.class, booleanMapper);
    cache.put(Boolean.class, booleanMapper);
    cache.put(char.class, charMapper);
    cache.put(Character.class, charMapper);
    cache.put(short.class, shortMapper);
    cache.put(Short.class, shortMapper);
    cache.put(int.class, integerMapper);
    cache.put(Integer.class, integerMapper);
    cache.put(long.class, longMapper);
    cache.put(Long.class, longMapper);
    cache.put(float.class, floatMapper);
    cache.put(Float.class, floatMapper);
    cache.put(double.class, doubleMapper);
    cache.put(Double.class, doubleMapper);
    cache.put(String.class, new StringMapper());
    cache.put(BigDecimal.class, new BigDecimalMapper());
    cache.put(byte[].class, new ByteArrayMapper());
    cache.put(char[].class, new CharArrayMapper());
    cache.put(Date.class, new DateMapper());
    cache.put(Calendar.class, new CalendarMapper());
    cache.put(GeoLocation.class, new GeoLocationMapper());
    cache.put(DatastoreKey.class, new KeyMapper());
    cache.put(LocalDate.class, new LocalDateMapper());
    cache.put(LocalTime.class, new LocalTimeMapper());
    cache.put(LocalDateTime.class, new LocalDateTimeMapper());
    cache.put(OffsetDateTime.class, new OffsetDateTimeMapper());
    cache.put(ZonedDateTime.class, new ZonedDateTimeMapper());
  }
805278
public void setMapperProperties(Properties properties) {
        if (this.mapperHelper == null) {
            this.mapperHelper = new MapperHelper();
        }
        this.mapperHelper.setProperties(properties);
    }
49816
private TypeVarToTypeMap mapTypes( TypeVarToTypeMap actualParamByVarName, IType... types )
  {
    for( int i = 0; i < types.length; i++ )
    {
      IType type = types[i];
      if( type instanceof ITypeVariableType )
      {
        actualParamByVarName.put( (ITypeVariableType)types[i], types[i] );
      }
      if( type instanceof ITypeVariableArrayType )
      {
        mapTypes( actualParamByVarName, type.getComponentType() );
      }
      if( type.isParameterizedType() )
      {
        IType[] parameters = type.getTypeParameters();
        mapTypes( actualParamByVarName, parameters );
      }
      if( type instanceof IFunctionType )
      {
        IFunctionType funType = (IFunctionType)type;
        mapTypes( actualParamByVarName, funType.getReturnType() );
        IType[] paramTypes = funType.getParameterTypes();
        for( IType paramType : paramTypes )
        {
          mapTypes( actualParamByVarName, paramType );
        }
      }
    }
    return actualParamByVarName;
  }
1184614
public void setDefaultProperties(Properties defaultProperties) {
		this.defaultProperties = new HashMap<>();
		for (Object key : Collections.list(defaultProperties.propertyNames())) {
			this.defaultProperties.put((String) key, defaultProperties.get(key));
		}
	}
279334
private void configureCustomTypes() {
        // empty binding is required in any case
        final Multibinder<OObjectSerializer> typesBinder =
                Multibinder.newSetBinder(binder(), OObjectSerializer.class);
        if (!customTypes.isEmpty()) {
            for (Class<? extends OObjectSerializer> type : customTypes) {
                bind(type).in(Singleton.class);
                typesBinder.addBinding().to(type);
            }
        }
    }
647649
public ConfigParams setDefaults(ConfigParams defaultConfigParams) {
		StringValueMap map = StringValueMap.fromMaps(defaultConfigParams, this);
		return new ConfigParams(map);
	}
325316
private static <L> Map<Name, TypeSet<ResourceType<L>>> buildTypeMapForConstructor(
            Collection<ResourceType<L>> allTypes) {
        TypeSetBuilder<ResourceType<L>> bldr = TypeSet.<ResourceType<L>> builder();
        bldr.enabled(true);
        bldr.name(new Name("all"));
        for (ResourceType<L> type : allTypes) {
            bldr.type(type);
        }
        TypeSet<ResourceType<L>> typeSet = bldr.build();

        return Collections.singletonMap(typeSet.getName(), typeSet);
    }
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'])
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'] = []
614942
private void setMappers(ObjectMapper mapper, XmlMapper xml) {
        synchronized (lock) {
            this.mapper = mapper;
            this.xml = xml;
            // mapper and xml are set to null on invalidation.
            if (mapper != null && xml != null) {
                applyMapperConfiguration(mapper, xml);
            }
        }
    }
874417
public static void init(Iterable<ObjectMapper> mappers, SquigglyPropertyFilter filter) {
        for (ObjectMapper mapper : mappers) {
            init(mapper, filter);
        }
    }
1048612
static void registerDefaultValues(String annotation, Map<String, Object> defaultValues) {
        if (StringUtils.isNotEmpty(annotation)) {
            ANNOTATION_DEFAULTS.put(annotation.intern(), defaultValues);
        }
    }
1276102
private void assignPreliminaryTypes(IAtomContainer container, String[] symbs) {
        // shallow copy
        IAtomContainer cpy = container.getBuilder().newInstance(IAtomContainer.class, container);
        Cycles.markRingAtomsAndBonds(cpy);
        for (AtomTypePattern matcher : patterns) {
            for (final int idx : matcher.matches(cpy)) {
                if (symbs[idx] == null) {
                    symbs[idx] = matcher.symb;
                }
            }
        }
    }
327781
public static <T> void registerReader(Class<T> type, JsonReaderI<T> mapper) {
		defaultReader.registerReader(type, mapper);
	}
853888
protected function setDefaultDataTypes()
    {
        foreach ($this->_params as $key => $value) {
            switch (gettype($value)) {
                case "boolean":
                    $this->_types[$key] = 'boolean';
                    break;
                case "integer":
                    $this->_types[$key] = 'integer';
                    break;
                case "double":
                    $this->_types[$key] = 'float';
                    break;
                case "string":
                    $this->_types[$key] = 'string';
                    break;
                case "array":
                    $this->_types[$key] = 'array';
                    break;
                default:
                    $this->_types[$key] = null;
                    break;
            }
        }
    }
1281897
private void setMapTypeInMap() {
        if (getInitialized()) {
            final String mapTypeName = getMapType().toString();
            if (logger.isDebugEnabled()) {
                logger.debug("setting map type in OpenLayers map: {}", mapTypeName);
            }
            bingMapsApiKey.ifPresent(apiKey -> jsMapView.call("setBingMapsApiKey", apiKey));
            wmsParam.ifPresent(wmsParam -> {
                jsMapView.call("newWMSParams");
                jsMapView.call("setWMSParamsUrl", wmsParam.getUrl());
                wmsParam.getParams().forEach((key, value) -> jsMapView.call("addWMSParamsParams", key, value));
            });
            xyzParam.ifPresent(xyzParam -> {
                jsMapView.call("setXYZParams", xyzParam.toJSON());
            });
            jsMapView.call("setMapType", mapTypeName);
        }
    }
764921
def _init_map(self, record_types=None, **kwargs):
        """"""
        osid_objects.OsidContainableForm._init_map(self)
        osid_objects.OsidOperableForm._init_map(self)
        osid_objects.OsidObjectForm._init_map(self, record_types=record_types)
        if 'assessment_part_id' in kwargs:
            self._my_map['assessmentPartId'] = str(kwargs['assessment_part_id'])
            if 'mdata' in kwargs:
                self._my_map['sequestered'] = kwargs['mdata']['sequestered']['default_boolean_values'][0]
        else:
            self._my_map['assessmentPartId'] = self._assessment_part_default
            self._my_map['sequestered'] = False  # Parts under Assessments must be "Sections"
        if 'assessment_id' in kwargs:
            self._my_map['assessmentId'] = str(kwargs['assessment_id'])
        else:
            self._my_map['assessmentId'] = self._assessment_default
        self._my_map['assignedBankIds'] = [str(kwargs['bank_id'])]
        self._my_map['allocatedTime'] = self._allocated_time_default
        self._my_map['itemsSequential'] = self._items_sequential_default
        self._my_map['itemsShuffled'] = self._items_shuffled_default
        self._my_map['weight'] = self._weight_default
        if self._supports_simple_sequencing():
            self._my_map['childIds'] = []