{-# LINE 1 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
module Database.PostgreSQL.PQTypes.Interval (
    Interval(..)
  , iyears
  , imonths
  , idays
  , ihours
  , iminutes
  , iseconds
  , imicroseconds
  ) where

import Data.Int
import Data.List
import Foreign.Storable
import qualified Data.ByteString.Char8 as BS
import qualified Data.Semigroup as SG

import Database.PostgreSQL.PQTypes.Format
import Database.PostgreSQL.PQTypes.FromSQL
import Database.PostgreSQL.PQTypes.Internal.Utils
import Database.PostgreSQL.PQTypes.ToSQL



----------------------------------------

-- | Representation of INTERVAL PostgreSQL type.
data Interval = Interval
  { Interval -> Int32
intYears         :: !Int32
  , Interval -> Int32
intMonths        :: !Int32
  , Interval -> Int32
intDays          :: !Int32
  , Interval -> Int32
intHours         :: !Int32
  , Interval -> Int32
intMinutes       :: !Int32
  , Interval -> Int32
intSeconds       :: !Int32
  , Interval -> Int32
intMicroseconds  :: !Int32
  } deriving (Interval -> Interval -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Interval -> Interval -> Bool
$c/= :: Interval -> Interval -> Bool
== :: Interval -> Interval -> Bool
$c== :: Interval -> Interval -> Bool
Eq, Eq Interval
Interval -> Interval -> Bool
Interval -> Interval -> Ordering
Interval -> Interval -> Interval
forall a.
Eq a
-> (a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
min :: Interval -> Interval -> Interval
$cmin :: Interval -> Interval -> Interval
max :: Interval -> Interval -> Interval
$cmax :: Interval -> Interval -> Interval
>= :: Interval -> Interval -> Bool
$c>= :: Interval -> Interval -> Bool
> :: Interval -> Interval -> Bool
$c> :: Interval -> Interval -> Bool
<= :: Interval -> Interval -> Bool
$c<= :: Interval -> Interval -> Bool
< :: Interval -> Interval -> Bool
$c< :: Interval -> Interval -> Bool
compare :: Interval -> Interval -> Ordering
$ccompare :: Interval -> Interval -> Ordering
Ord)

instance Show Interval where
  showsPrec :: Int -> Interval -> ShowS
showsPrec Int
_ Interval{Int32
intMicroseconds :: Int32
intSeconds :: Int32
intMinutes :: Int32
intHours :: Int32
intDays :: Int32
intMonths :: Int32
intYears :: Int32
intMicroseconds :: Interval -> Int32
intSeconds :: Interval -> Int32
intMinutes :: Interval -> Int32
intHours :: Interval -> Int32
intDays :: Interval -> Int32
intMonths :: Interval -> Int32
intYears :: Interval -> Int32
..} = forall a. [a] -> [a] -> [a]
(++) forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> [[a]] -> [a]
intercalate String
", " forall a b. (a -> b) -> a -> b
$ forall a. (a -> Bool) -> [a] -> [a]
filter (Bool -> Bool
not forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (t :: * -> *) a. Foldable t => t a -> Bool
null) [
      forall {a}. (Eq a, Num a, Show a) => a -> ShowS
f Int32
intYears String
"year"
    , forall {a}. (Eq a, Num a, Show a) => a -> ShowS
f Int32
intMonths String
"month"
    , forall {a}. (Eq a, Num a, Show a) => a -> ShowS
f Int32
intDays String
"day"
    , forall {a}. (Eq a, Num a, Show a) => a -> ShowS
f Int32
intHours String
"hour"
    , forall {a}. (Eq a, Num a, Show a) => a -> ShowS
f Int32
intMinutes String
"minute"
    , forall {a}. (Eq a, Num a, Show a) => a -> ShowS
f Int32
intSeconds String
"second"
    , forall {a}. (Eq a, Num a, Show a) => a -> ShowS
f Int32
intMicroseconds String
"microsecond"
    ]
    where
      f :: a -> ShowS
f a
n String
desc = case a
n of
        a
0 -> String
""
        a
1 -> forall a. Show a => a -> String
show a
n forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ String
desc
        a
_ -> forall a. Show a => a -> String
show a
n forall a. [a] -> [a] -> [a]
++ String
" " forall a. [a] -> [a] -> [a]
++ String
desc forall a. [a] -> [a] -> [a]
++ String
"s"

instance SG.Semigroup Interval where
  Interval
a <> :: Interval -> Interval -> Interval
<> Interval
b = Interval {
    intYears :: Int32
intYears = Interval -> Int32
intYears Interval
a forall a. Num a => a -> a -> a
+ Interval -> Int32
intYears Interval
b
  , intMonths :: Int32
intMonths = Interval -> Int32
intMonths Interval
a forall a. Num a => a -> a -> a
+ Interval -> Int32
intMonths Interval
b
  , intDays :: Int32
intDays = Interval -> Int32
intDays Interval
a forall a. Num a => a -> a -> a
+ Interval -> Int32
intDays Interval
b
  , intHours :: Int32
intHours = Interval -> Int32
intHours Interval
a forall a. Num a => a -> a -> a
+ Interval -> Int32
intHours Interval
b
  , intMinutes :: Int32
intMinutes = Interval -> Int32
intMinutes Interval
a forall a. Num a => a -> a -> a
+ Interval -> Int32
intMinutes Interval
b
  , intSeconds :: Int32
intSeconds = Interval -> Int32
intSeconds Interval
a forall a. Num a => a -> a -> a
+ Interval -> Int32
intSeconds Interval
b
  , intMicroseconds :: Int32
intMicroseconds = Interval -> Int32
intMicroseconds Interval
a forall a. Num a => a -> a -> a
+ Interval -> Int32
intMicroseconds Interval
b
  }

instance Monoid Interval where
  mempty :: Interval
mempty  = Int32
-> Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> Int32 -> Interval
Interval Int32
0 Int32
0 Int32
0 Int32
0 Int32
0 Int32
0 Int32
0
  mappend :: Interval -> Interval -> Interval
mappend = forall a. Semigroup a => a -> a -> a
(SG.<>)

instance Storable Interval where
  sizeOf :: Interval -> Int
sizeOf Interval
_ = (Int
28)
{-# LINE 71 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
  alignment _ = 4
{-# LINE 72 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
  peek ptr = Interval
    <$> (\hsc_ptr -> peekByteOff hsc_ptr 0) ptr
{-# LINE 74 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 4) ptr
{-# LINE 75 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 8) ptr
{-# LINE 76 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 12) ptr
{-# LINE 77 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 16) ptr
{-# LINE 78 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 20) ptr
{-# LINE 79 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    <*> (\hsc_ptr -> peekByteOff hsc_ptr 24) ptr
{-# LINE 80 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
  poke ptr Interval{..} = do
    (\hsc_ptr -> pokeByteOff hsc_ptr 0) ptr intYears
{-# LINE 82 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 4) ptr intMonths
{-# LINE 83 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 8) ptr intDays
{-# LINE 84 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 12) ptr intHours
{-# LINE 85 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 16) ptr intMinutes
{-# LINE 86 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 20) ptr intSeconds
{-# LINE 87 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}
    (\hsc_ptr -> pokeByteOff hsc_ptr 24) ptr intMicroseconds
{-# LINE 88 "src/Database/PostgreSQL/PQTypes/Interval.hsc" #-}

instance PQFormat Interval where
  pqFormat :: ByteString
pqFormat = String -> ByteString
BS.pack String
"%interval"

instance FromSQL Interval where
  type PQBase Interval = Interval
  fromSQL :: Maybe (PQBase Interval) -> IO Interval
fromSQL Maybe (PQBase Interval)
Nothing = forall a. IO a
unexpectedNULL
  fromSQL (Just PQBase Interval
int) = forall (m :: * -> *) a. Monad m => a -> m a
return PQBase Interval
int

instance ToSQL Interval where
  type PQDest Interval = Interval
  toSQL :: forall r.
Interval
-> ParamAllocator -> (Ptr (PQDest Interval) -> IO r) -> IO r
toSQL Interval
int ParamAllocator
_ = forall t r. Storable t => t -> (Ptr t -> IO r) -> IO r
putAsPtr Interval
int

----------------------------------------

-- | Convert 'Int32' to appropriate 'Interval'
-- representation of given number of years.
iyears :: Int32 -> Interval
iyears :: Int32 -> Interval
iyears Int32
v = forall a. Monoid a => a
mempty { intYears :: Int32
intYears = Int32
v }

-- | Convert 'Int32' to appropriate 'Interval'
-- representation of given number of months.
imonths :: Int32 -> Interval
imonths :: Int32 -> Interval
imonths Int32
v = forall a. Monoid a => a
mempty { intMonths :: Int32
intMonths = Int32
v }

-- | Convert 'Int32' to appropriate 'Interval'
-- representation of given number of days.
idays :: Int32 -> Interval
idays :: Int32 -> Interval
idays Int32
v = forall a. Monoid a => a
mempty { intDays :: Int32
intDays = Int32
v }

-- | Convert 'Int32' to appropriate 'Interval'
-- representation of given number of hours.
ihours :: Int32 -> Interval
ihours :: Int32 -> Interval
ihours Int32
v = forall a. Monoid a => a
mempty { intHours :: Int32
intHours = Int32
v }

-- | Convert 'Int32' to appropriate 'Interval'
-- representation of given number of minutes.
iminutes :: Int32 -> Interval
iminutes :: Int32 -> Interval
iminutes Int32
v = forall a. Monoid a => a
mempty { intMinutes :: Int32
intMinutes = Int32
v }

-- | Convert 'Int32' to appropriate 'Interval'
-- representation of given number of seconds.
iseconds :: Int32 -> Interval
iseconds :: Int32 -> Interval
iseconds Int32
v = forall a. Monoid a => a
mempty { intSeconds :: Int32
intSeconds = Int32
v }

-- | Convert 'Int32' to appropriate 'Interval'
-- representation of given number of microseconds.
imicroseconds :: Int32 -> Interval
imicroseconds :: Int32 -> Interval
imicroseconds Int32
v = forall a. Monoid a => a
mempty { intMicroseconds :: Int32
intMicroseconds = Int32
v }