{- |
Module      : Data.Time.Zones.Types
Copyright   : (C) 2014 Mihaly Barasz
License     : Apache-2.0, see LICENSE
Maintainer  : Janus Troelsen <ysangkok@gmail.com>
Stability   : experimental
-}

{-# LANGUAGE DeriveDataTypeable #-}

module Data.Time.Zones.Types (
  TZ(..),
  utcTZ,
  ) where

import           Control.DeepSeq
import           Data.Data
import           Data.Default
import           Data.Int
import qualified Data.Vector as VB
import qualified Data.Vector.Unboxed as VU

data TZ = TZ {
  TZ -> Vector Int64
_tzTrans :: !(VU.Vector Int64),
  TZ -> Vector Int
_tzDiffs :: !(VU.Vector Int),
  -- TODO(klao): maybe we should store it as a vector of indices and a
  -- (short) vector of expanded 'TimeZone's, similarly to how it's
  -- stored?
  TZ -> Vector (Bool, String)
_tzInfos :: !(VB.Vector (Bool, String))   -- (summer, name)
  } deriving (TZ -> TZ -> Bool
(TZ -> TZ -> Bool) -> (TZ -> TZ -> Bool) -> Eq TZ
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: TZ -> TZ -> Bool
$c/= :: TZ -> TZ -> Bool
== :: TZ -> TZ -> Bool
$c== :: TZ -> TZ -> Bool
Eq, Int -> TZ -> ShowS
[TZ] -> ShowS
TZ -> String
(Int -> TZ -> ShowS)
-> (TZ -> String) -> ([TZ] -> ShowS) -> Show TZ
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TZ] -> ShowS
$cshowList :: [TZ] -> ShowS
show :: TZ -> String
$cshow :: TZ -> String
showsPrec :: Int -> TZ -> ShowS
$cshowsPrec :: Int -> TZ -> ShowS
Show, Typeable, Typeable TZ
DataType
Constr
Typeable TZ
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> TZ -> c TZ)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c TZ)
-> (TZ -> Constr)
-> (TZ -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c TZ))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TZ))
-> ((forall b. Data b => b -> b) -> TZ -> TZ)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r)
-> (forall u. (forall d. Data d => d -> u) -> TZ -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> TZ -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> TZ -> m TZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TZ -> m TZ)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> TZ -> m TZ)
-> Data TZ
TZ -> DataType
TZ -> Constr
(forall b. Data b => b -> b) -> TZ -> TZ
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TZ -> c TZ
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TZ
forall a.
Typeable a
-> (forall (c :: * -> *).
    (forall d b. Data d => c (d -> b) -> d -> c b)
    -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> TZ -> u
forall u. (forall d. Data d => d -> u) -> TZ -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TZ -> m TZ
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TZ -> m TZ
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TZ
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TZ -> c TZ
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TZ)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TZ)
$cTZ :: Constr
$tTZ :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> TZ -> m TZ
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TZ -> m TZ
gmapMp :: (forall d. Data d => d -> m d) -> TZ -> m TZ
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> TZ -> m TZ
gmapM :: (forall d. Data d => d -> m d) -> TZ -> m TZ
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> TZ -> m TZ
gmapQi :: Int -> (forall d. Data d => d -> u) -> TZ -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> TZ -> u
gmapQ :: (forall d. Data d => d -> u) -> TZ -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> TZ -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TZ -> r
gmapT :: (forall b. Data b => b -> b) -> TZ -> TZ
$cgmapT :: (forall b. Data b => b -> b) -> TZ -> TZ
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TZ)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TZ)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c TZ)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c TZ)
dataTypeOf :: TZ -> DataType
$cdataTypeOf :: TZ -> DataType
toConstr :: TZ -> Constr
$ctoConstr :: TZ -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TZ
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c TZ
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TZ -> c TZ
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> TZ -> c TZ
$cp1Data :: Typeable TZ
Data, ReadPrec [TZ]
ReadPrec TZ
Int -> ReadS TZ
ReadS [TZ]
(Int -> ReadS TZ)
-> ReadS [TZ] -> ReadPrec TZ -> ReadPrec [TZ] -> Read TZ
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [TZ]
$creadListPrec :: ReadPrec [TZ]
readPrec :: ReadPrec TZ
$creadPrec :: ReadPrec TZ
readList :: ReadS [TZ]
$creadList :: ReadS [TZ]
readsPrec :: Int -> ReadS TZ
$creadsPrec :: Int -> ReadS TZ
Read)

instance NFData TZ where
  rnf :: TZ -> ()
rnf (TZ { _tzInfos :: TZ -> Vector (Bool, String)
_tzInfos = Vector (Bool, String)
infos }) = Vector (Bool, String) -> ()
forall a. NFData a => a -> ()
rnf Vector (Bool, String)
infos

-- | The `TZ` definition for UTC.
utcTZ :: TZ
utcTZ :: TZ
utcTZ = Vector Int64 -> Vector Int -> Vector (Bool, String) -> TZ
TZ (Int64 -> Vector Int64
forall a. Unbox a => a -> Vector a
VU.singleton Int64
forall a. Bounded a => a
minBound) (Int -> Vector Int
forall a. Unbox a => a -> Vector a
VU.singleton Int
0) ((Bool, String) -> Vector (Bool, String)
forall a. a -> Vector a
VB.singleton (Bool
False, String
"UTC"))

instance Default TZ where
  def :: TZ
def = TZ
utcTZ