@@ -2,20 +2,20 @@
22-----------------------------------------------------------------------------
33-- |
44-- Module : Data.Time.LocalTime.TimeZone.Olson.Render
5−-- Copyright : Yitzchak Gale 2018
5+-- Copyright : Yitzchak Gale 2010
66--
77-- Maintainer : Yitzchak Gale <gale@sefer.org>
88-- Portability : portable
99--
10−-- Render Olson timezone data in the standard binary format as used in
11−-- Olson timezone files, and as specified by the tzfile(5) man page on
12−-- Unix-like systems. For more information about this format, see
13−-- <http://www.twinsun.com/tz/tz-link.htm>.
10+-- Render Olson timezone data in the standard binary format as
11+-- used in Olson timezone files, and as specified by the
12+-- tzfile(5) man page on Unix-like systems. For more information
13+-- about this format, see http://www.twinsun.com/tz/tz-link.htm.
1414
15−{- Copyright (c) 2018ZZ Yitzchak Gale. All rights reserved.
16−For licensing information, see the BSD3-style license in the file
17−LICENSE that was originally distributed by the author together with
18−this file. -}
15+{- Copyright (c) 2010 Yitzchak Gale. All rights reserved. For
16+licensing information, see the BSD3-style license in the file LICENSE
17+that was originally distributed by the author together with this file.
18+-}
1919
2020module Data.Time.LocalTime.TimeZone.Olson.Render
2121(
@@ -25,19 +25,13 @@ module Data.Time.LocalTime.TimeZone.Olson.Render
2525 -- timestamp, or if a POSIX-style TZ string is specified, timezone
2626 -- data is rendered using Version 2 format. Otherwise, the timezone data
2727 -- is rendered using Version 1 format.
28− renderTimeZoneSeriesToOlsonFile,
29− timeZoneSeriesToOlson,
3028 renderOlsonToFile,
31− verifyOlsonLimits,
3229 putOlson,
33− extractOlsonV1
30+ splitOlson
3431)
3532where
3633
3734import Data.Time.LocalTime.TimeZone.Olson.Types
38−import Data.Time.LocalTime.TimeZone.Series (TimeZoneSeries(TimeZoneSeries))
39−import Data.Time (TimeZone(TimeZone, timeZoneSummerOnly, timeZoneName))
40−import Data.Time.Clock.POSIX (utcTimeToPOSIXSeconds)
4135import Data.Binary.Put (Put, runPut, putByteString, putWord8, flush,
4236 putWord32be, putWord64be)
4337import qualified Data.ByteString as B
@@ -45,117 +39,78 @@ import qualified Data.ByteString.Lazy as L
4539import Data.List (partition, sortBy, sort, group)
4640import Data.Ord (comparing)
4741import Data.Word (Word8)
48−import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe, catMaybes)
42+import Data.Maybe (listToMaybe, maybeToList, isNothing, fromMaybe)
4943import Data.Monoid (mempty)
50−import Control.Monad (guard, replicateM_, unless)
44+import Control.Monad (guard, replicateM_)
5145
52−-- | Render a @TimeZoneSeries@ as a binary Olson timezone file.
53−--
54−-- If the values in the Olson timezone data exceed the standard size
55−-- limits (see 'defaultLimits'), this function throws an
56−-- exception. For other behavior, use 'timeZoneSeriesToOlson',
57−-- 'verifyOlsonLimits', 'putOlson' and 'Data.Binary.Put.runPut'
58−-- directly.
59−renderTimeZoneSeriesToOlsonFile :: FilePath -> TimeZoneSeries -> IO ()
60−renderTimeZoneSeriesToOlsonFile fp = renderOlsonToFile fp .
61− fromMaybe (error "Cannot render TimeZoneSeries: default is summer time") .
62− timeZoneSeriesToOlson
63−
64−-- | Convert a @TimeZoneSeries@ to @OlsonData@ for rendering.
65−timeZoneSeriesToOlson :: TimeZoneSeries -> Maybe OlsonData
66−timeZoneSeriesToOlson (TimeZoneSeries dflt pairs)
67− | timeZoneSummerOnly dflt && not (all timeZoneSummerOnly $ map snd pairs)
68− = Nothing
69− | otherwise = Just $
70− OlsonData
71− [Transition secs ttinfo |
72− (t, tz) <- reverse pairs,
73− let secs = round $ utcTimeToPOSIXSeconds t,
74− ttinfo <- maybeToList $ lookup (mkTT tz) ttAssocs]
75− ttinfos
76− []
77− Nothing
78− where
79− mkTT (TimeZone offset isdst abbr) =
80− TtInfo (offset*60) isdst Wall abbr
81− dfltTT = mkTT dflt
82− ttAssocs = (dfltTT, 0) :
83− zip (uniq . sort . filter (/= dfltTT) $ map (mkTT . snd) pairs) [1..]
84− ttinfos = map fst ttAssocs
85−
86−-- | Check whether @OlsonData@ is within size limits.
87−verifyOlsonLimits :: SizeLimits -> OlsonData -> Bool
88−verifyOlsonLimits limits (OlsonData transs ttinfos leaps _) =
89− withinLimit maxTimes transs &&
90− withinLimit maxTypes ttinfos &&
91− withinLimit maxLeaps leaps &&
92− withinLimit maxAbbrChars abbrChars
93− where
94− withinLimit limit items = maybe True (null . flip drop items) $
95− limit limits
96− abbrChars = concat abbrStrs ++ map (const '\NUL') abbrStrs
97− abbrStrs = map tt_abbr ttinfos
9846
9947-- | Render Olson timezone data as a binary Olson timezone file
100−--
101−-- If the values in the Olson timezone data exceed the standard size
102−-- limits (see 'defaultLimits'), this function throws an
103−-- exception. For other behavior, use 'verifyOlsonLimits', 'putOlson'
104−-- and 'Data.Binary.Put.runPut' directly.
10548renderOlsonToFile :: FilePath -> OlsonData -> IO ()
106−renderOlsonToFile fp olson = do
107− unless (verifyOlsonLimits defaultLimits olson) $
108− error "Olson timezone data exceeds size limits"
109− L.writeFile fp . runPut . putOlson $ olson
49+renderOlsonToFile fp = L.writeFile fp . runPut . putOlson
11050
11151-- | Render Olson timezone data in binary Olson timezone file format
11252-- as a lazy @ByteString@
113−putOlson olson@(OlsonData _ _ _ posix)
114− | fitsInVersion1 = putOlsonPart 0 put32bitIntegral olson
115− | otherwise = do putOlsonPart 50 put32bitIntegral olson1
116− putOlsonPart 50 put64bitIntegral olson
117− putPosixTZ posix
53+putOlson :: OlsonData -> Put
54+putOlson olson = do
55+ putASCII "TZif"
56+ putWord8 version
57+ putByteString . B.pack $ replicate 15 0 -- padding nulls
58+ putOlsonParts version olson1 olson2 posix
59+ flush
11860 where
119− olson1 = extractOlsonV1 olson
120− fitsInVersion1 = fmap null posix /= Just False &&
121− olson1 == olson {olsonPosixTZ = Nothing}
122−
123−-- | Extract Olson timezone data that can be rendered using Version 1 format
124−extractOlsonV1 :: OlsonData -> OlsonData
125−extractOlsonV1 (OlsonData transs ttinfos leaps _)
126− | allV1 = OlsonData transs ttinfos leaps Nothing
127− | otherwise = OlsonData transs1 ttinfos1 leaps1 Nothing
61+ (olson1, olson2, posix) = splitOlson olson
62+ version
63+ | olson2 /= mempty = 50
64+ | otherwise = maybe 0 (const 50) $ posix >>= guard . not . null
65+
66+-- | Split Olson timezone data into three parts: timezone data that can
67+-- be rendered using Version 1 format, timezone data that can only be
68+-- rendered using Version 2 format, and the POSIX-style TZ string
69+-- if specified
70+splitOlson :: OlsonData -> (OlsonData, OlsonData, Maybe String)
71+splitOlson (OlsonData transs ttinfos leaps posix) =
72+ (OlsonData transs1 ttinfos1 leaps1 Nothing,
73+ OlsonData transs2 ttinfos2 leaps2 Nothing,
74+ posix)
12875 where
12976 cutoff = 0x80000000 -- 2^31
130− fitsIn32bits x = x < cutoff && x >= negate cutoff
131− leaps1 = filter (fitsIn32bits . leapTime) leaps
132− transs1' = filter (fitsIn32bits . transTime) transs
133− allV1 = length leaps1 == length leaps && length transs1' == length transs
134− assoc1 = zip
77+ ( leaps1 , leaps2 ) = partition ((>= cutoff) . leapTime) leaps
78+ (transs1', transs2') = partition ((>= cutoff) . transTime) transs
79+ assoc1 = mkAssoc [0] transs1'
80+ assoc2 = mkAssoc [] transs2'
81+ transs1 = mkTranss transs1' assoc1
82+ transs2 = mkTranss transs2' assoc2
83+ ttinfos1 = mkTtinfos assoc1
84+ ttinfos2 = mkTtinfos assoc2
85+ mkAssoc prepend transs' = zip
13586 (sortBy (comparing $ fmap tt_ttype . listToMaybe . flip drop ttinfos) .
136− uniq . sort . (0 :) $ map transIndex transs1')
87+ uniq . sort . (prepend ++) $ map transIndex transs')
13788 [0..]
138− transs1 = [t {transIndex = i} |
139− t <- transs1', i <- maybeToList $ lookup (transIndex t) assoc1]
140− ttinfos1 = map snd . dropWhile (isNothing . fst) .
141− sortBy (comparing fst) $ zip (map (flip lookup assoc1) [0..]) ttinfos
142−
143−putOlsonPart :: Word8 -> (Integer -> Put) -> OlsonData -> Put
144−putOlsonPart version putTime (OlsonData transs ttinfos leaps _) = do
145− putASCII "magic number" "TZif"
146− putWord8 version
147− putByteString . B.pack $ replicate 15 0 -- padding nulls
89+ mkTranss transs' assoc = [t {transIndex = i} |
90+ t <- transs', i <- maybeToList $ lookup (transIndex t) assoc]
91+ mkTtinfos assoc = map snd . dropWhile (isNothing . fst) .
92+ sortBy (comparing fst) $ zip (map (flip lookup assoc) [0..]) ttinfos
93+
94+putOlsonParts :: Word8 -> OlsonData -> OlsonData -> Maybe String -> Put
95+putOlsonParts 0 olson1 _ _ = putOlsonPart put32bitIntegral olson1
96+putOlsonParts _ olson1 olson2 posix = do
97+ putOlsonPart put32bitIntegral olson1
98+ putOlsonPart put64bitIntegral olson2
99+ putPosixTZ posix
100+
101+putOlsonPart :: (Integer -> Put) -> OlsonData -> Put
102+putOlsonPart putTime (OlsonData transs ttinfos leaps _) = do
148103 replicateM_ 2 $ putCount ttinfosWithTtype
149− -- tzh_ttisgmtcnt
150− -- tzh_ttisstdcnt
151− putCount leaps -- tzh_leapcnt
152− putCount transs -- tzh_timecnt
153− putCount ttinfos -- tzh_typecnt
154− put32bitIntegral abbrChars -- tzh_charcnt
104+ -- tzh_ttisgmtcnt
105+ -- tzh_ttisstdcnt
106+ putCount leaps -- tzh_leapcnt
107+ putCount transs -- tzh_timecnt
108+ putCount ttinfos -- tzh_typecnt
109+ putCount abbrChars -- tzh_charcnt
155110 mapM_ (putTime . transTime ) transs
156111 mapM_ (put8bitIntegral . transIndex) transs
157112 mapM_ putTtInfo ttinfosIndexed
158− mapM_ putAbbr abbrStrings
113+ putASCII abbrChars
159114 mapM_ (putLeapInfo putTime) leaps
160115 mapM_ (putBool . (== Std) . tt_ttype) ttinfosWithTtype -- isstd
161116 mapM_ (putBool . (== UTC) . tt_ttype) ttinfosWithTtype -- isgmt
@@ -163,18 +118,16 @@ putOlsonPart version putTime (OlsonData transs ttinfos leaps _) = do
163118 putCount = put32bitIntegral . length
164119 ttinfosWithTtype = takeWhile ((<= UTC) . tt_ttype) ttinfosIndexed
165120 abbrStrings = uniq . sort $ map tt_abbr ttinfos
166− abbrChars = sum (map length abbrStrings) + length abbrStrings
167− putAbbr abbr = putASCII "time zone abbreviation" abbr >> putWord8 0
168− abbrAssocs = zip abbrStrings . scanl (+) 0 $
169− map ((+ 1) . length) abbrStrings
121+ abbrChars = concatMap (++ "\NUL") abbrStrings
170122 ttinfosIndexed = [TtInfo gmtoff isdst ttype i |
171123 TtInfo gmtoff isdst ttype abbr <- ttinfos,
172− i <- maybeToList $ lookup abbr abbrAssocs]
124+ i <- maybeToList . lookup abbr . zip abbrStrings .
125+ scanl (+) 0 $ map ((+ 1) . length) abbrStrings]
173126
174127putPosixTZ :: Maybe String -> Put
175128putPosixTZ posix = do
176129 putWord8 10
177− putASCII "POSIX TZ string"$ fromMaybe "" posix
130+ putASCII $ fromMaybe "" posix
178131 putWord8 10
179132
180133putTtInfo :: TtInfo Int -> Put
@@ -207,11 +160,5 @@ putBool True = putWord8 1
207160uniq :: Eq a => [a] -> [a]
208161uniq = map head . group
209162
210−putASCII :: String -> String -> Put
211−putASCII what =
212− putByteString . B.pack . map (fromIntegral . verify . fromEnum)
213− where
214− verify c
215− | c >= 32 && c <= 126 = c
216− | otherwise = error $ "Cannot render TimeZoneSeries: " ++
217− what ++ " contains non-ASCII characters"
163+putASCII :: String -> Put
164+putASCII = putByteString . B.pack . map (fromIntegral . fromEnum)