Move TimeZoneCache to a separate file (#466)

src/TimeZones.jl

@@ -33,7 +33,7 @@ export TimeZone, @tz_str, istimezone, FixedTimeZone, VariableTimeZone, ZonedDate
 
 _scratch_dir() = @get_scratch!("build")
 
-const _COMPILED_DIR = Ref{String}()
+const _COMPILED_DIR = Ref{String}(TZJData.ARTIFACT_DIR)
 
 # TimeZone types used to disambiguate the context of a DateTime
 # abstract type UTC <: TimeZone end  # Already defined in the Dates stdlib
@@ -53,9 +53,10 @@ include("indexable_generator.jl")
 
 include("class.jl")
 include("utcoffset.jl")
+include(joinpath("types", "timezone.jl"))
 include(joinpath("types", "fixedtimezone.jl"))
 include(joinpath("types", "variabletimezone.jl"))
-include(joinpath("types", "timezone.jl"))
+include(joinpath("types", "timezonecache.jl"))
 include(joinpath("types", "zoneddatetime.jl"))
 include(joinpath("tzfile", "TZFile.jl"))
 include(joinpath("tzjfile", "TZJFile.jl"))

src/types/timezone.jl

@@ -1,80 +1,3 @@
-# Use a separate cache for FixedTimeZone (which is `isbits`) so the container is concretely
-# typed and we avoid allocating a FixedTimeZone every time we get one from the cache.
-struct TimeZoneCache
-    ftz::Dict{String,Tuple{FixedTimeZone,Class}}
-    vtz::Dict{String,Tuple{VariableTimeZone,Class}}
-    lock::ReentrantLock
-    initialized::Threads.Atomic{Bool}
-end
-
-TimeZoneCache() = TimeZoneCache(Dict(), Dict(), ReentrantLock(), Threads.Atomic{Bool}(false))
-
-# Retains the compiled tzdata in memory. Read-only access to the cache is thread-safe and
-# any changes to this structure can result in inconsistent behaviour. Do not access this
-# object directly, instead use `get` to access the cache content.
-const _TZ_CACHE = TimeZoneCache()
-
-function Base.copy!(dst::TimeZoneCache, src::TimeZoneCache)
-    copy!(dst.ftz, src.ftz)
-    copy!(dst.vtz, src.vtz)
-    dst.initialized[] = src.initialized[]
-    return dst
-end
-
-function reload!(cache::TimeZoneCache, compiled_dir::AbstractString=_COMPILED_DIR[])
-    empty!(cache.ftz)
-    empty!(cache.vtz)
-
-    walk_tz_dir(compiled_dir) do name, path
-        tz, class = open(TZJFile.read, path, "r")(name)
-
-        if tz isa FixedTimeZone
-            cache.ftz[name] = (tz, class)
-        elseif tz isa VariableTimeZone
-            cache.vtz[name] = (tz, class)
-        else
-            error("Unhandled TimeZone class encountered: $(typeof(tz))")
-        end
-    end
-
-    !isempty(cache.ftz) && !isempty(cache.vtz) || error("Cache remains empty after loading")
-
-    return cache
-end
-
-function Base.get(body::Function, cache::TimeZoneCache, name::AbstractString)
-    if !cache.initialized[]
-        lock(cache.lock) do
-            if !cache.initialized[]
-                _initialize()
-                reload!(cache)
-                cache.initialized[] = true
-            end
-        end
-    end
-
-    return get(cache.ftz, name) do
-        get(cache.vtz, name) do
-            body()
-        end
-    end
-end
-
-function _initialize()
-    # Write out our compiled tzdata representations into a scratchspace
-    desired_version = TZData.tzdata_version()
-
-    _COMPILED_DIR[] = if desired_version == TZJData.TZDATA_VERSION
-        TZJData.ARTIFACT_DIR
-    else
-        TZData.build(desired_version, _scratch_dir())
-    end
-
-    return nothing
-end
-
-_reload_tz_cache(compiled_dir::AbstractString) = reload!(_TZ_CACHE, compiled_dir)
-
 """
     TimeZone(str::AbstractString) -> TimeZone
 

src/types/timezonecache.jl

@@ -0,0 +1,73 @@
+# Use a separate cache for FixedTimeZone (which is `isbits`) so the container is concretely
+# typed and we avoid allocating a FixedTimeZone every time we get one from the cache.
+struct TimeZoneCache
+    ftz::Dict{String,Tuple{FixedTimeZone,Class}}
+    vtz::Dict{String,Tuple{VariableTimeZone,Class}}
+    lock::ReentrantLock
+    initialized::Threads.Atomic{Bool}
+end
+
+TimeZoneCache() = TimeZoneCache(Dict(), Dict(), ReentrantLock(), Threads.Atomic{Bool}(false))
+
+# Retains the compiled tzdata in memory. Read-only access to the cache is thread-safe and
+# any changes to this structure can result in inconsistent behaviour. Do not access this
+# object directly, instead use `get` to access the cache content.
+const _TZ_CACHE = TimeZoneCache()
+
+function Base.copy!(dst::TimeZoneCache, src::TimeZoneCache)
+    copy!(dst.ftz, src.ftz)
+    copy!(dst.vtz, src.vtz)
+    dst.initialized[] = src.initialized[]
+    return dst
+end
+
+function reload!(cache::TimeZoneCache, compiled_dir::AbstractString=_COMPILED_DIR[])
+    empty!(cache.ftz)
+    empty!(cache.vtz)
+
+    walk_tz_dir(compiled_dir) do name, path
+        tz, class = open(TZJFile.read, path, "r")(name)
+
+        if tz isa FixedTimeZone
+            cache.ftz[name] = (tz, class)
+        elseif tz isa VariableTimeZone
+            cache.vtz[name] = (tz, class)
+        else
+            error("Unhandled TimeZone class encountered: $(typeof(tz))")
+        end
+    end
+
+    !isempty(cache.ftz) && !isempty(cache.vtz) || error("Cache remains empty after loading")
+
+    return cache
+end
+
+function Base.get(body::Function, cache::TimeZoneCache, name::AbstractString)
+    if !cache.initialized[]
+        lock(cache.lock) do
+            if !cache.initialized[]
+                _build()
+                reload!(cache)
+                cache.initialized[] = true
+            end
+        end
+    end
+
+    return get(cache.ftz, name) do
+        get(cache.vtz, name) do
+            body()
+        end
+    end
+end
+
+# Build specific tzdata version if specified by `JULIA_TZ_VERSION`
+function _build()
+    desired_version = TZData.tzdata_version()
+    if desired_version != TZJData.TZDATA_VERSION
+        _COMPILED_DIR[] = TZData.build(desired_version, _scratch_dir())
+    end
+
+    return nothing
+end
+
+_reload_tz_cache(compiled_dir::AbstractString) = reload!(_TZ_CACHE, compiled_dir)