Creates a CronMapper that maps a cron4j expression to a quartz expression.
@return a CronMapper for mapping from cron4j to quartz
14258
public static CronMapper fromCron4jToQuartz() {
        return new CronMapper(
                CronDefinitionBuilder.instanceDefinitionFor(CronType.CRON4J),
                CronDefinitionBuilder.instanceDefinitionFor(CronType.QUARTZ),
                setQuestionMark()
        );
    }
855630
public static ScheduledExecutorService createScheduler() {
		final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1, new DaemonThreadFactory(DEFAULT_SCHEDULER_NAME));
		SCHEDULERS.add(scheduler);
		return scheduler;
	}
687246
public static Scheduler createScheduler(SchedulerFactory schedulerFactory)
      throws SundialSchedulerException {

    if (scheduler == null) {
      try {
        scheduler = schedulerFactory.getScheduler();

      } catch (SchedulerException e) {
        throw new SundialSchedulerException("COULD NOT CREATE SUNDIAL SCHEDULER!!!", e);
      }
    }
    return scheduler;
  }
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());
  }
1253063
private static <T extends ObjectMapper> T initializeObjectMapper(T mapper) {
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false)
                .configure(SerializationFeature.WRITE_EMPTY_JSON_ARRAYS, true)
                .configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false)
                .configure(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT, true)
                .configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false)
                .configure(DeserializationFeature.ACCEPT_SINGLE_VALUE_AS_ARRAY, true)
                .setSerializationInclusion(JsonInclude.Include.NON_NULL)
                .registerModule(new JavaTimeModule())
                .registerModule(ByteArraySerializer.getModule())
                .registerModule(Base64UrlSerializer.getModule())
                .registerModule(DateTimeSerializer.getModule())
                .registerModule(DateTimeRfc1123Serializer.getModule())
                .registerModule(DurationSerializer.getModule());
        mapper.setVisibility(mapper.getSerializationConfig().getDefaultVisibilityChecker()
                .withFieldVisibility(JsonAutoDetect.Visibility.ANY)
                .withSetterVisibility(JsonAutoDetect.Visibility.NONE)
                .withGetterVisibility(JsonAutoDetect.Visibility.NONE)
                .withIsGetterVisibility(JsonAutoDetect.Visibility.NONE));
        return mapper;
    }
883396
public ObjectMapper createObjectMapper() {
		ObjectMapper mapper = new ObjectMapper();
		mapper.setVisibility(PropertyAccessor.FIELD, JsonAutoDetect.Visibility.ANY)
				.setVisibility(PropertyAccessor.CREATOR, JsonAutoDetect.Visibility.ANY)
				.setVisibility(PropertyAccessor.SETTER, JsonAutoDetect.Visibility.NONE)
				.setVisibility(PropertyAccessor.GETTER, JsonAutoDetect.Visibility.NONE)
				.setVisibility(PropertyAccessor.IS_GETTER, JsonAutoDetect.Visibility.NONE);

		mapper.configure(SerializationFeature.FAIL_ON_EMPTY_BEANS, false);

		return mapper;
	}
404583
@Override
    protected ImmutableMap<Class<? extends QueryOptimizationProposal>, Class<? extends ProposalExecutor>>
    generateOptimizationConfigurationMap() {
        ImmutableMap.Builder<Class<? extends QueryOptimizationProposal>, Class<? extends ProposalExecutor>>
                internalExecutorMapBuilder = ImmutableMap.builder();
        internalExecutorMapBuilder.putAll(super.generateOptimizationConfigurationMap());
        internalExecutorMapBuilder.putAll(optimizationConfiguration.generateOptimizationConfigurationMap());

        return internalExecutorMapBuilder.build();
    }
535701
function(jd) {
        var date = gregorianCalendar.fromJD(jd);
        var lunar = toLunar(date.year(), date.month(), date.day());
        var monthIndex = this.toMonthIndex(
            lunar.year, lunar.month, lunar.isIntercalary);
        return this.newDate(lunar.year, monthIndex, lunar.day);
    }
1191539
private Calendar createCalendar(long time)
    {
        // The specification accounts for gregorian dates only.
        Calendar cal = new GregorianCalendar(timeZone); // d639610
        cal.setTimeInMillis(time);

        return cal;
    }
1025279
public static CronDefinition instanceDefinitionFor(final CronType cronType) {
        switch (cronType) {
            case CRON4J:
                return cron4j();
            case QUARTZ:
                return quartz();
            case UNIX:
                return unixCrontab();
            case SPRING:
                return spring();
            default:
                throw new IllegalArgumentException(String.format("No cron definition found for %s", cronType));
        }
    }
1366875
public static Map<String, String> getSchedulerNames(){
		Map<String, String> schedulerNames = new HashMap<String, String>();
		MySchedule mySchedule = MySchedule.getInstance();
		for(String settingsName: mySchedule.getSchedulerSettingsNames()){
			SchedulerSettings settings = mySchedule.getSchedulerSettings(settingsName);
			schedulerNames.put(settingsName, settings.getSchedulerFullName());
		}
		return schedulerNames;
	}
243327
public static JavaTimeZone createTimeZone(String id) {
        java.util.TimeZone jtz = null;

        if (AVAILABLESET.contains(id)) {
            jtz = java.util.TimeZone.getTimeZone(id);
        }

        if (jtz == null) {
            // Use ICU's canonical ID mapping
            boolean[] isSystemID = new boolean[1];
            String canonicalID = TimeZone.getCanonicalID(id, isSystemID);
            if (isSystemID[0] && AVAILABLESET.contains(canonicalID)) {
                jtz = java.util.TimeZone.getTimeZone(canonicalID);
            }
        }

        if (jtz == null) {
            return null;
        }

        return new JavaTimeZone(jtz, id);
    }
844361
public static Scheduler createScheduler(int threadPoolSize, String annotatedJobsPackageName)
      throws SundialSchedulerException {

    if (scheduler == null) {
      try {
        scheduler = new SchedulerFactory().getScheduler(threadPoolSize, annotatedJobsPackageName);

      } catch (SchedulerException e) {
        throw new SundialSchedulerException("COULD NOT CREATE SUNDIAL SCHEDULER!!!", e);
      }
    }
    return scheduler;
  }
1105919
public <T> Mapping<T> getMapping(Class<T> clazz) {
        return (cache != null) ? cache.getMapping(clazz, annotationSet)
                : new Mapping<T>(clazz, annotationSet);
    }
287596
public ParsedScheduleExpression parseScheduleExpression(TimerMethodData.AutomaticTimer timer) {
        ScheduleExpression schedule = timer.getSchedule();
        String start = timer.getStart();
        String end = timer.getEnd();

        try {
            if (start != null) {
                schedule.start(parseXSDDateTime("start", start));
            }

            if (end != null) {
                schedule.end(parseXSDDateTime("end", end));
            }

            return ScheduleExpressionParser.parse(schedule);
        } catch (ScheduleExpressionParserException ex) {
            FFDCFilter.processException(ex, CLASS_NAME + ".parseScheduleExpression", "541", this);
            if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                Tr.debug(tc, "failed to parse schedule expression", ex);

            // Use the exception to call Tr.error().
            ex.logError(ivBMD.j2eeName.getModule(), ivBMD.j2eeName.getComponent(), timer.getMethod().getMethod().getName());
            throw ex;
        }
    }
1289015
@Override
    protected PersistentTimer createTimer(EJBRuntime ejbRuntime) {
        return ejbRuntime.getPersistentTimer(TaskIdAccessor.get(), j2eeName, this);
    }
506770
public static function createDateTime(
        string $name,
        bool $emptyToNull = false
    ): DenormalizationFieldMappingBuilderInterface {
        $self = new self($name);
        $self->fieldDenormalizer = new DateTimeFieldDenormalizer(new PropertyAccessor($name), $emptyToNull);

        return $self;
    }