public static ZonedDateTimeSerializer RegisterSerializer(IDateTimeZoneProvider provider)
{
ZonedDateTimeSerializer serializer = new ZonedDateTimeSerializer(provider);
BsonSerializer.RegisterSerializer(typeof(ZonedDateTime), serializer);
return(serializer);
}
public CreateTemplateValidator(
IValidator <BillingDate> billingDateValidator,
IDateTimeZoneProvider dateTimeZoneProvider)
{
this.RuleFor(m => m.Name)
.NotEmpty()
.Length(Template.NameMinLength, Template.NameMaxLength);
this.RuleFor(m => m.BillingModeId)
.Must(Enumeration.ContainsValue <BillingMode>);
this.RuleFor(m => m.BillingDate)
.NotNull()
.SetValidator(billingDateValidator);
this.RuleFor(m => m.BillingPeriodMonth)
.NotEmpty()
.GreaterThan(0);
this.RuleFor(m => m.BillingPeriodOffsetMonth)
.NotEmpty()
.GreaterThan(0).When(m => m.BillingModeId == BillingMode.Prepaid.Id)
.LessThan(0).When(m => m.BillingModeId == BillingMode.Postpaid.Id);
this.RuleFor(m => m.TimeZone)
.NotEmpty()
.Must(dateTimeZoneProvider.Ids.Contains);
}
public MainPage()
{
InitializeComponent();
_clock = SystemClock.Instance;
_dateTimeZoneProvider = DateTimeZoneProviders.Tzdb;
}
protected BaseController(
IClock clock,
IDateTimeZoneProvider dateTimeZoneProvider)
{
this.clock = clock;
this.dateTimeZoneProvider = dateTimeZoneProvider;
}
/// <summary>
/// Converts a <see cref="DateTime"/> of any <see cref="DateTimeKind"/> to a <see cref="ZonedTime"/> instance for the timezone.
/// </summary>
/// <remarks><see cref="DateTimeKind.Unspecified"/> will be treated like <see cref="DateTimeKind.Utc"/></remarks>
/// <param name="dateTimeOfAnyKind"></param>
/// <param name="timeZoneId"></param>
/// <param name="cultureInfo">The see <see cref="CultureInfo"/> to use for localizing timezone strings. Default is <see cref="CultureInfo.CurrentUICulture"/>.</param>
/// <param name="timeZoneProvider">The <see cref="IDateTimeZoneProvider"/> to use. For performance use a <see cref="DateTimeZoneCache"/>.
/// <example>
/// IDateTimeZoneProvider dtzp = new DateTimeZoneCache(TzdbDateTimeZoneSource.Default)
/// </example>
/// </param>
/// <returns>Returns the converted <see cref="DateTime"/> as a <see cref="ZonedTime"/> instance or null, if the <see cref="dateTimeOfAnyKind"/> parameter is null.</returns>
/// <exception cref="DateTimeZoneNotFoundException">If <see cref="timeZoneId"/> is unknown.</exception>
public static ZonedTime ToZonedTime(DateTime?dateTimeOfAnyKind, string timeZoneId,
CultureInfo cultureInfo = null, IDateTimeZoneProvider timeZoneProvider = null)
{
if (!dateTimeOfAnyKind.HasValue)
{
return(null);
}
DateTime utcDateTime;
switch (dateTimeOfAnyKind.Value.Kind)
{
case DateTimeKind.Utc:
utcDateTime = dateTimeOfAnyKind.Value;
break;
case DateTimeKind.Local:
utcDateTime = dateTimeOfAnyKind.Value.ToUniversalTime();
break;
default: //DateTimeKind.Unspecified
utcDateTime = DateTime.SpecifyKind(dateTimeOfAnyKind.Value, DateTimeKind.Utc);
break;
}
return(ToZonedTime(new DateTimeOffset(utcDateTime), timeZoneId, cultureInfo, timeZoneProvider));
}
public TimestampTzHandler(PostgresType postgresType, bool convertInfinityDateTime)
: base(postgresType)
{
_dateTimeZoneProvider = DateTimeZoneProviders.Tzdb;
_convertInfinityDateTime = convertInfinityDateTime;
_bclHandler = new BclTimestampTzHandler(postgresType, convertInfinityDateTime);
}
public TimeZoneController(
IClock clock,
IDateTimeZoneProvider dateTimeZoneProvider,
TzdbDateTimeZoneSource dateTimeZoneSource)
: base(clock, dateTimeZoneProvider)
{
var now = clock.GetCurrentInstant();
foreach (var temp in dateTimeZoneSource.ZoneLocations)
{
var timeZone = dateTimeZoneProvider.GetZoneOrNull(temp.ZoneId);
var zoneInterval = timeZone.GetZoneInterval(now);
var offset = zoneInterval.WallOffset;
if (timeZone != null)
{
timeZones.Add(new TimeZoneInformation
{
Id = timeZone.Id,
Name = zoneInterval.Name,
Offset = offset.ToTimeSpan().Hours
});
}
}
}
public static void ConfigureForNodaTime(this SwaggerGenOptions config, IDateTimeZoneProvider dateTimeZoneProvider)
{
var dateTimeZone = dateTimeZoneProvider[America.NewYork];
var instant = SystemClock.Instance.GetCurrentInstant();
var interval = new Interval(instant, instant + Duration.FromMilliseconds(182713784L));
var dateTimeInterval = interval.InZoneStrictly(dateTimeZone);
var zonedDateTime = dateTimeZone.AtLeniently(instant.InZone(dateTimeZone).LocalDateTime.With(TimeAdjusters.TruncateToMinute));
var localDateTime = zonedDateTime.LocalDateTime;
var localDate = localDateTime.Date;
var dateInterval = localDateTime.Date.GetContainingWeekInterval(IsoDayOfWeek.Monday);
var localTime = localDateTime.TimeOfDay;
var timeInterval = new TimeInterval(localTime, localTime + Period.FromHours(3) + Period.FromMinutes(45));
var offsetDateTime = zonedDateTime.ToOffsetDateTime();
var duration = Duration.FromDays(2) + Duration.FromHours(3) + Duration.FromMinutes(45);
var offset = dateTimeZone.GetUtcOffset(instant);
var period = Period.FromTicks(duration.BclCompatibleTicks);
config.MapStruct(instant);
config.MapStruct(localDate);
config.MapStruct(localTime);
config.MapStruct(localDateTime);
config.MapStruct(offsetDateTime);
config.MapStruct(zonedDateTime);
config.MapStruct(interval);
config.MapClass(dateInterval);
config.MapClass(dateTimeInterval);
config.MapClass(timeInterval);
config.MapStruct(offset);
config.MapClass(period);
config.MapStruct(duration);
config.MapClass(dateTimeZone);
}
private static void _addDefaultConverters(IList <JsonConverter> converters, IDateTimeZoneProvider provider)
{
converters.Insert(0, NodaConverters.InstantConverter);
converters.Insert(0, NodaConverters.IntervalConverter);
converters.Insert(0, NodaConverters.LocalDateConverter);
converters.Insert(0, NodaConverters.LocalDateTimeConverter);
converters.Insert(0, NodaConverters.LocalTimeConverter);
converters.Insert(0, NodaConverters.AnnualDateConverter);
converters.Insert(0, NodaConverters.DateIntervalConverter);
converters.Insert(0, NodaConverters.OffsetConverter);
converters.Insert(0, NodaConverters.CreateDateTimeZoneConverter(provider));
converters.Insert(0, NodaConverters.DurationConverter);
converters.Insert(0, NodaConverters.RoundtripPeriodConverter);
converters.Insert(0, NodaConverters.OffsetDateTimeConverter);
converters.Insert(0, NodaConverters.OffsetDateConverter);
//converters.Insert(0, NodaConverters.OffsetTimeConverter);
converters.Add(new NodaPatternConverter <OffsetDateTime>(
OffsetDateTimePattern.ExtendedIso, x =>
{
if (x.Calendar != CalendarSystem.Iso)
{
throw new ArgumentException("Calendar must be Iso when serializing", typeof(OffsetDateTime).Name);
}
}));
converters.Insert(0, NodaConverters.CreateZonedDateTimeConverter(provider));
}
private void LoadData()
{
// init noda time
using (var stream = File.OpenRead(Directory.GetFiles(_nzdPath)[0]))
{
_tzdbSource = TzdbDateTimeZoneSource.FromStream(stream);
_tzdbProvider = new DateTimeZoneCache(_tzdbSource);
}
// this has to be loaded first
LoadMetaZones();
// these can be loaded in parallel
var actions = new Action[]
{
LoadZoneCountries,
LoadZoneAliases,
LoadWindowsMappings,
LoadLanguages
};
Task.WhenAll(actions.Select(Task.Run)).Wait();
// patch the data for any known issues
PatchData();
// this has to come last, as it relies on patched data
LoadSelectionZones();
}
/// <summary>
/// Dumps the contents of a provider to a writer. This is used in both unit tests and TzdbCompiler, so we can validate
/// that changes to time zone code don't change behaviour. It's not expected to be exposed publicly; this used to
/// be in NodaTime.CheckZones, but that didn't really prove its worth. It's currently very fix in format and options;
/// we can make it more flexible later if we want.
/// </summary>
internal static void Dump([NotNull] this IDateTimeZoneProvider provider, [NotNull] TextWriter writer)
{
Preconditions.CheckNotNull(provider, nameof(provider));
Preconditions.CheckNotNull(writer, nameof(writer));
writer.WriteLine("TZDB version: {0}", provider.VersionId);
foreach (var id in provider.Ids)
{
var zone = provider[id];
writer.WriteLine($"Zone: {zone.Id}");
var start = Instant.FromUtc(1800, 1, 1, 0, 0);
var end = Instant.FromUtc(2100, 1, 1, 0, 0);
ZoneInterval lastDisplayed = null;
foreach (var interval in zone.GetZoneIntervals(start, end))
{
writer.WriteLine(interval);
lastDisplayed = interval;
}
// This will never be null; every interval has at least one zone interval.
if (lastDisplayed.HasEnd)
{
writer.WriteLine("...");
writer.WriteLine(zone.GetZoneInterval(Instant.MaxValue));
}
writer.WriteLine();
}
}
public GeoCoder(TelemetryClient telemetryClient, IOptions <GeoCoderConfiguration> geoCoderOptions, YandexMapsClient yandexMapsClient, ZonedClock clock, IDateTimeZoneProvider dateTimeZoneProvider)
{
myTelemetryClient = telemetryClient;
myYandexMapsClient = yandexMapsClient;
myClock = clock;
myDateTimeZoneProvider = dateTimeZoneProvider;
myGeoCoderOptions = geoCoderOptions.Value ?? throw new ArgumentNullException(nameof(geoCoderOptions));
}
/// <summary>
/// Configures <seealso cref="HttpConfiguration"/> with everything required for working with NodaTime.
/// </summary>
/// <param name="config">An http configuration.</param>
/// <param name="dateTimeZoneProvider">A date time zone provider.</param>
public static void ConfigureForNodaTime(this HttpConfiguration config, IDateTimeZoneProvider dateTimeZoneProvider)
{
// Configure serialization for NodaTime
config.Formatters.JsonFormatter.SerializerSettings.ConfigureForNodaTime(dateTimeZoneProvider);
// Adds action value binder for NodaTime model binders
config.Services.Replace(typeof(IActionValueBinder), new ActionValueBinder(dateTimeZoneProvider));
}
internal ZonedDateTimePatternParser(ZonedDateTime templateValue, ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider)
{
templateValueDate = templateValue.Date;
templateValueTime = templateValue.TimeOfDay;
templateValueZone = templateValue.Zone;
this.resolver = resolver;
this.zoneProvider = zoneProvider;
}
public MovieNightService(BotService bot, IMediator mediator, IDateTimeZoneProvider timeZoneProvider, OmdbClient omdbClient, IClock clock)
{
this.bot = bot;
this.mediator = mediator;
this.timeZoneProvider = timeZoneProvider;
this.omdbClient = omdbClient;
this.clock = clock;
}
public TimeZoneNotifyService(RaidBattlesContext db, IDateTimeZoneProvider dateTimeZoneProvider, DateTimeZone dateTimeZone, IClock clock, ITelegramBotClient bot)
{
myDB = db;
myDateTimeZoneProvider = dateTimeZoneProvider;
myDateTimeZone = dateTimeZone;
myClock = clock;
myBot = bot;
}
protected virtual void LoadTimeZoneData()
{
using (Stream stream = File.Open(Path.Combine(SharpIrcBotUtil.AppDirectory, Config.TimeZoneDatabaseFile), FileMode.Open, FileAccess.Read, FileShare.Read))
{
TzdbDateTimeZoneSource timeZoneSource = TzdbDateTimeZoneSource.FromStream(stream);
TimeZoneProvider = new DateTimeZoneCache(timeZoneSource);
}
}
public TimeZoneHelper(
IDateTimeZoneProvider timeZoneProvider,
ILogger <TimeZoneHelper> logger = null
)
{
tzSource = timeZoneProvider;
log = logger;
}
/// <summary>
/// Configuration for ServiceStack.Text with everything required to properly serialize and deserialize NodaTime data
/// types to and from json.
/// </summary>
/// <param name="provider">The time zone provider to use when parsing time zones and zoned date/times.</param>
/// <returns>A new Noda serializer settings.</returns>
public static INodaSerializerSettings CreateDefaultSerializersForNodaTime(this IDateTimeZoneProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException(nameof(provider));
}
return(new DefaultNodaSerializerSettings(provider));
}
/// <summary>
/// CTOR.
/// </summary>
/// <param name="dateTimeZoneProvider"></param>
/// <param name="ianaTimeZoneId">The IANA timezone ID to use for converting.</param>
/// <param name="cultureInfo">The <see cref="CultureInfo"/> to use for converting.</param>
/// <param name="resolver">The <see cref="ZoneLocalMappingResolver"/> to use for converting.</param>
public TimeZoneConverter(IDateTimeZoneProvider dateTimeZoneProvider, string ianaTimeZoneId,
CultureInfo cultureInfo = null, ZoneLocalMappingResolver resolver = null)
{
_dateTimeZoneProvider = dateTimeZoneProvider;
_timeZoneId = ianaTimeZoneId;
_cultureInfo = cultureInfo;
_resolver = resolver;
}
public TimeZoneHelper(
IDateTimeZoneProvider timeZoneProvider,
ILogger<TimeZoneHelper> logger = null
)
{
tzSource = timeZoneProvider;
log = logger;
}
/// <summary>
/// Configures MVC model binding and validation for NodaTime types.
/// </summary>
/// <param name="options">MVC options.</param>
/// <param name="dateTimeZoneProvider">A date time zone provider to be used for binding date time zones.
/// It is recommended to use <see cref="DateTimeZoneProviderFactory.Create"/>.</param>
/// <returns>The <see cref="MvcOptions"/> provided in <paramref name="options"/>.</returns>
public static MvcOptions ConfigureForNodaTime(this MvcOptions options, IDateTimeZoneProvider dateTimeZoneProvider)
{
NodaTimeTypeConverters.Setup(dateTimeZoneProvider);
options.Filters.Add(new CheckModelStateAttribute());
return(options);
}
internal ZonedDateTimeParseBucket(ZonedDateTime templateValue, ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider)
{
Date = new LocalDatePatternParser.LocalDateParseBucket(templateValue.Date);
Time = new LocalTimePatternParser.LocalTimeParseBucket(templateValue.TimeOfDay);
Zone = templateValue.Zone;
this.resolver = resolver;
this.zoneProvider = zoneProvider;
}
public static T ConfigureForNodaTime <T>(this T documentStore, IDateTimeZoneProvider zoneProvider)
where T : IDocumentStore
{
var existing = documentStore.Conventions.CustomizeJsonSerializer;
documentStore.Conventions.CustomizeJsonSerializer = serializer =>
{
// Chain any existing serialization conventions
if (existing != null)
{
existing.Invoke(serializer);
}
// Don't do anything if we've already registered them
if (serializer.Converters.OfType <NodaConverterBase <Instant> >().Any())
{
return;
}
// Register standard json converters
serializer.Converters.Add(CustomPatternBasedJsonConverters.InstantConverter);
serializer.Converters.Add(NodaConverters.IntervalConverter);
serializer.Converters.Add(CustomPatternBasedJsonConverters.LocalDateTimeConverter);
serializer.Converters.Add(NodaConverters.LocalDateConverter);
serializer.Converters.Add(NodaConverters.RoundtripPeriodConverter);
serializer.Converters.Add(NodaConverters.InstantDictionaryKeyConverter);
serializer.Converters.Add(NodaConverters.LocalDateDictionaryKeyConverter);
serializer.Converters.Add(NodaConverters.LocalDateTimeDictionaryKeyConverter);
serializer.Converters.Add(NodaConverters.LocalTimeDictionaryKeyConverter);
// Register custom json converters
serializer.Converters.Add(new LocalTimeConverter());
serializer.Converters.Add(new NodaDateTimeZoneConverter(zoneProvider));
serializer.Converters.Add(new OffsetConverter());
serializer.Converters.Add(new DurationConverter());
serializer.Converters.Add(new OffsetDateTimeConverter());
serializer.Converters.Add(new ZonedDateTimeConverter());
};
// Register query value converters
documentStore.Conventions.RegisterQueryValueConverter <Instant>(CustomQueryValueConverters.InstantConverter);
documentStore.Conventions.RegisterQueryValueConverter <LocalDateTime>(CustomQueryValueConverters.LocalDateTimeConverter);
documentStore.Conventions.RegisterQueryValueConverter <LocalDate>(CustomQueryValueConverters.LocalDateConverter);
documentStore.Conventions.RegisterQueryValueConverter <LocalTime>(CustomQueryValueConverters.LocalTimeConverter, RangeType.Long);
documentStore.Conventions.RegisterQueryValueConverter <Offset>(CustomQueryValueConverters.OffsetConverter, RangeType.Long);
documentStore.Conventions.RegisterQueryValueConverter <Duration>(CustomQueryValueConverters.DurationConverter, RangeType.Long);
documentStore.Conventions.RegisterQueryValueConverter <OffsetDateTime>(CustomQueryValueConverters.OffsetDateTimeConverter);
documentStore.Conventions.RegisterQueryValueConverter <Period>(CustomQueryValueConverters.PeriodConverter);
documentStore.Conventions.RegisterQueryValueConverter <ZonedDateTime>(CustomQueryValueConverters.ZonedDateTimeConverter);
documentStore.Conventions.RegisterQueryValueConverter <DateTimeZone>(CustomQueryValueConverters.DateTimeZoneConverter);
// Register query translators
documentStore.Conventions.RegisterCustomQueryTranslator <OffsetDateTime>(x => x.ToInstant(), CustomQueryTranslators.OffsetDateTimeToInstantTranslator);
documentStore.Conventions.RegisterCustomQueryTranslator <OffsetDateTime>(x => x.LocalDateTime, CustomQueryTranslators.OffsetDateTimeLocalDateTimeTranslator);
documentStore.Conventions.RegisterCustomQueryTranslator <ZonedDateTime>(x => x.ToInstant(), CustomQueryTranslators.ZonedDateTimeTimeToInstantTranslator);
return(documentStore);
}
internal ZonedDateTimeParseBucket(LocalDate templateDate, LocalTime templateTime,
DateTimeZone templateZone, ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider)
{
Date = new LocalDatePatternParser.LocalDateParseBucket(templateDate);
Time = new LocalTimePatternParser.LocalTimeParseBucket(templateTime);
Zone = templateZone;
this.resolver = resolver;
this.zoneProvider = zoneProvider;
}
/// <summary>
/// Creates an instance of the <see cref="DateTimeZone"/> serializer for the given <see cref="IDateTimeZoneProvider"/>.
/// </summary>
/// <param name="provider">The <see cref="IDateTimeZoneProvider"/> to use.</param>
public DateTimeZoneSerializer(IDateTimeZoneProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
this._provider = provider;
}
public UserSettingsCommandHandler(RaidBattlesContext context, ITelegramBotClient bot, IMemoryCache cache, IClock clock, GeoCoder geoCoder, IDateTimeZoneProvider dateTimeZoneProvider)
{
myContext = context;
myBot = bot;
myCache = cache;
myClock = clock;
myGeoCoder = geoCoder;
myDateTimeZoneProvider = dateTimeZoneProvider;
}
public TemplatesController(IMapper mapper,
ITemplateQuery templateQuery,
ITemplateRepository templateRepository,
IDateTimeZoneProvider dateTimeZoneProvider)
{
_mapper = mapper;
_templateQuery = templateQuery;
_templateRepository = templateRepository;
_dateTimeZoneProvider = dateTimeZoneProvider;
}
private ZonedDateTimePattern(string patternText, NodaFormatInfo formatInfo, ZonedDateTime templateValue,
ZoneLocalMappingResolver resolver, IDateTimeZoneProvider zoneProvider, IPattern <ZonedDateTime> pattern)
{
this.PatternText = patternText;
this.FormatInfo = formatInfo;
this.TemplateValue = templateValue;
this.Resolver = resolver;
this.ZoneProvider = zoneProvider;
this.pattern = pattern;
}
public static Instant ToInstant(this LocalDateTime local, IDateTimeZoneProvider provider, string timeZoneId)
{
var timeZone = provider.GetZoneOrNull(timeZoneId);
if (timeZone is null)
{
throw new ArgumentException(nameof(timeZoneId));
}
return(local.InZoneLeniently(timeZone).ToInstant());
}
/// <summary>
/// Initializes a new instance of the <see cref="NodaTimeSchemaSettings"/> class.
/// </summary>
/// <param name="resolvePropertyName">Function that resolves property name by proper naming strategy.</param>
/// <param name="formatToJson">Function that formats object as json text.</param>
/// <param name="shouldGenerateExamples">Should the example node be generated.</param>
/// <param name="dateTimeZoneProvider"><see cref="IDateTimeZoneProvider"/> configured in Startup.</param>
public NodaTimeSchemaSettings(
Func <string, string> resolvePropertyName,
Func <object, string> formatToJson,
bool shouldGenerateExamples,
IDateTimeZoneProvider dateTimeZoneProvider = null)
{
ResolvePropertyName = resolvePropertyName;
FormatToJson = formatToJson;
ShouldGenerateExamples = shouldGenerateExamples;
DateTimeZoneProvider = dateTimeZoneProvider;
}
/// <summary>
/// Creates an instance of default serializers using the given <see cref="IDateTimeZoneProvider"/>.
/// </summary>
/// <param name="provider"></param>
public DefaultNodaSerializerSettings(IDateTimeZoneProvider provider)
{
if (provider == null)
{
throw new ArgumentNullException("provider");
}
DurationSerializer = NodaSerializerDefinitions.DurationSerializer;
DateTimeZoneSerializer = NodaSerializerDefinitions.CreateDateTimeZoneSerializer(provider);
InstantSerializer = NodaSerializerDefinitions.InstantSerializer;
IntervalSerializer = NodaSerializerDefinitions.ComplexIntervalSerializer;
LocalDateSerializer = NodaSerializerDefinitions.LocalDateSerializer;
LocalDateTimeSerializer = NodaSerializerDefinitions.LocalDateTimeSerializer;
LocalTimeSerializer = NodaSerializerDefinitions.LocalTimeSerializer;
OffsetSerializer = NodaSerializerDefinitions.OffsetSerializer;
OffsetDateTimeSerializer = NodaSerializerDefinitions.OffsetDateTimeSerializer;
PeriodSerializer = NodaSerializerDefinitions.RoundtripPeriodSerializer;
ZonedDateTimeSerializer = NodaSerializerDefinitions.CreateZonedDateTimeSerializer(provider);
Provider = provider;
}
/// <summary>
/// Removes the given time zone provider from the provider list.
/// </summary>
/// <remarks>
/// If the provider is not on the list nothing changes.
/// </remarks>
/// <param name="provider">The <see cref="IDateTimeZoneProvider" /> to remove.</param>
/// <returns><c>true</c> if the provider was removed.</returns>
internal bool RemoveProvider(IDateTimeZoneProvider provider)
{
accessLock.AcquireReaderLock(Timeout.Infinite);
try
{
if (providers.Contains(provider))
{
LockCookie lockCookie = accessLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
providers.Remove(provider);
timeZoneMap.Clear();
idList.Clear();
return true;
}
finally
{
accessLock.DowngradeFromWriterLock(ref lockCookie);
}
}
}
finally
{
accessLock.ReleaseReaderLock();
}
return false;
}
public UserController()
{
dateTimeZoneProvider = DateTimeZoneProviders.Tzdb;
}
/// <summary>
/// Adds the given time zone provider to the front of the provider list.
/// </summary>
/// <remarks>
/// Because this adds the new provider to the from of the list, it will be checked first for
/// time zone definitions and therefore can override the default system definitions. This
/// allows for adding new or replacing existing time zones without updating the system. If
/// the provider is already on the list nothing changes.
/// </remarks>
/// <param name="provider">The <see cref="IDateTimeZoneProvider" /> to add.</param>
public static void AddProvider(IDateTimeZoneProvider provider)
{
cache.AddProvider(provider);
}
/// <summary>
/// Removes the given time zone provider from the provider list.
/// </summary>
/// <remarks>
/// If the provider is not on the list nothing changes.
/// </remarks>
/// <param name="provider">The <see cref="IDateTimeZoneProvider" /> to remove.</param>
/// <returns><c>true</c> if the provider was removed.</returns>
public static bool RemoveProvider(IDateTimeZoneProvider provider)
{
return cache.RemoveProvider(provider);
}
/// <summary>
/// Adds the given time zone provider to the front of the provider list.
/// </summary>
/// <remarks>
/// Because this adds the new provider to the from of the list, it will be checked first for
/// time zone definitions and therefore can override the default system definitions. This
/// allows for adding new or replacing existing time zones without updating the system. If
/// the provider is already on the list nothing changes.
/// </remarks>
/// <param name="provider">The <see cref="IDateTimeZoneProvider" /> to add.</param>
internal void AddProvider(IDateTimeZoneProvider provider)
{
accessLock.AcquireReaderLock(Timeout.Infinite);
try
{
if (!providers.Contains(provider))
{
LockCookie lockCookie = accessLock.UpgradeToWriterLock(Timeout.Infinite);
try
{
providers.AddFirst(provider);
timeZoneMap.Clear();
idList.Clear();
}
finally
{
accessLock.DowngradeFromWriterLock(ref lockCookie);
}
}
}
finally
{
accessLock.ReleaseReaderLock();
}
}
/// <summary>
/// Sets the <see cref="DateTimeZoneProvider"/> to the time zone database given.
/// </summary>
/// <param name="path">The path of the database file to load, or <see langword="null"/> to use the path in the configuration.
/// If no path is given in the config, the default NodaTime <see cref="DateTimeZoneProviders.Tzdb"/> will be used.</param>
/// <returns></returns>
public static void SetDateTimeZoneProvider(string path = null)
{
_dateTimeZoneProvider = LoadTzdb(path);
_isFromConfig = path == null;
}
private CurrentTzdbProvider(IDateTimeZoneProvider provider, ILookup<string, string> aliases)
{
_provider = provider;
_aliases = aliases;
}
