{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE LambdaCase #-}
{-# LANGUAGE TypeApplications #-}

{- HLINT ignore "Use <&>" -}

module Data.RdsData.Types.Array
  ( Array(..)
  , fromArrayValue
  , toArrayValue
  ) where

import Control.Applicative
import Control.Lens
import Data.Generics.Product.Any
import Data.Text
import GHC.Generics

import qualified Amazonka.RDSData as AWS
import qualified Data.Aeson       as J

data Array =
    ArrayOfArrays   [Array]
  | ArrayOfBools    [Bool]
  | ArrayOfDoubles  [Double]
  | ArrayOfIntegers [Integer]
  | ArrayOfTexts    [Text]
  deriving (Array -> Array -> Bool
(Array -> Array -> Bool) -> (Array -> Array -> Bool) -> Eq Array
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Array -> Array -> Bool
== :: Array -> Array -> Bool
$c/= :: Array -> Array -> Bool
/= :: Array -> Array -> Bool
Eq, (forall x. Array -> Rep Array x)
-> (forall x. Rep Array x -> Array) -> Generic Array
forall x. Rep Array x -> Array
forall x. Array -> Rep Array x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Array -> Rep Array x
from :: forall x. Array -> Rep Array x
$cto :: forall x. Rep Array x -> Array
to :: forall x. Rep Array x -> Array
Generic, Int -> Array -> ShowS
[Array] -> ShowS
Array -> String
(Int -> Array -> ShowS)
-> (Array -> String) -> ([Array] -> ShowS) -> Show Array
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Array -> ShowS
showsPrec :: Int -> Array -> ShowS
$cshow :: Array -> String
show :: Array -> String
$cshowList :: [Array] -> ShowS
showList :: [Array] -> ShowS
Show)

instance J.ToJSON Array where

fromArrayValue :: AWS.ArrayValue -> Maybe Array
fromArrayValue :: ArrayValue -> Maybe Array
fromArrayValue ArrayValue
v =
  [Maybe Array] -> Maybe Array
forall (t :: * -> *) (f :: * -> *) a.
(Foldable t, Alternative f) =>
t (f a) -> f a
asum
    [ ArrayValue
v ArrayValue
-> Getting (Maybe [Bool]) ArrayValue (Maybe [Bool]) -> Maybe [Bool]
forall s a. s -> Getting a s a -> a
^. forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"booleanValues" Maybe [Bool] -> ([Bool] -> Maybe Array) -> Maybe Array
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Array -> Maybe Array
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Array -> Maybe Array)
-> ([Bool] -> Array) -> [Bool] -> Maybe Array
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Bool] -> Array
ArrayOfBools
    , ArrayValue
v ArrayValue
-> Getting (Maybe [Double]) ArrayValue (Maybe [Double])
-> Maybe [Double]
forall s a. s -> Getting a s a -> a
^. forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"doubleValues"  Maybe [Double] -> ([Double] -> Maybe Array) -> Maybe Array
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Array -> Maybe Array
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Array -> Maybe Array)
-> ([Double] -> Array) -> [Double] -> Maybe Array
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Double] -> Array
ArrayOfDoubles
    , ArrayValue
v ArrayValue
-> Getting (Maybe [Integer]) ArrayValue (Maybe [Integer])
-> Maybe [Integer]
forall s a. s -> Getting a s a -> a
^. forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"longValues"    Maybe [Integer] -> ([Integer] -> Maybe Array) -> Maybe Array
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Array -> Maybe Array
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Array -> Maybe Array)
-> ([Integer] -> Array) -> [Integer] -> Maybe Array
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Integer] -> Array
ArrayOfIntegers
    , ArrayValue
v ArrayValue
-> Getting (Maybe [Text]) ArrayValue (Maybe [Text]) -> Maybe [Text]
forall s a. s -> Getting a s a -> a
^. forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"stringValues"  Maybe [Text] -> ([Text] -> Maybe Array) -> Maybe Array
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= Array -> Maybe Array
forall a. a -> Maybe a
forall (f :: * -> *) a. Applicative f => a -> f a
pure (Array -> Maybe Array)
-> ([Text] -> Array) -> [Text] -> Maybe Array
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Text] -> Array
ArrayOfTexts
    , ArrayValue
v ArrayValue
-> Getting (Maybe [ArrayValue]) ArrayValue (Maybe [ArrayValue])
-> Maybe [ArrayValue]
forall s a. s -> Getting a s a -> a
^. forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"arrayValues"   Maybe [ArrayValue] -> ([ArrayValue] -> Maybe Array) -> Maybe Array
forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= ([Array] -> Array) -> Maybe [Array] -> Maybe Array
forall a b. (a -> b) -> Maybe a -> Maybe b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap [Array] -> Array
ArrayOfArrays (Maybe [Array] -> Maybe Array)
-> ([ArrayValue] -> Maybe [Array]) -> [ArrayValue] -> Maybe Array
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ArrayValue -> Maybe Array) -> [ArrayValue] -> Maybe [Array]
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> [a] -> f [b]
traverse ArrayValue -> Maybe Array
fromArrayValue
    ]

toArrayValue :: Array -> AWS.ArrayValue
toArrayValue :: Array -> ArrayValue
toArrayValue = \case
  ArrayOfArrays   [Array]
vs -> ArrayValue
AWS.newArrayValue ArrayValue -> (ArrayValue -> ArrayValue) -> ArrayValue
forall a b. a -> (a -> b) -> b
& forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"arrayValues"    ((Maybe [ArrayValue] -> Identity (Maybe [ArrayValue]))
 -> ArrayValue -> Identity ArrayValue)
-> Maybe [ArrayValue] -> ArrayValue -> ArrayValue
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [ArrayValue] -> Maybe [ArrayValue]
forall a. a -> Maybe a
Just (Array -> ArrayValue
toArrayValue (Array -> ArrayValue) -> [Array] -> [ArrayValue]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Array]
vs)
  ArrayOfBools    [Bool]
vs -> ArrayValue
AWS.newArrayValue ArrayValue -> (ArrayValue -> ArrayValue) -> ArrayValue
forall a b. a -> (a -> b) -> b
& forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"booleanValues"  ((Maybe [Bool] -> Identity (Maybe [Bool]))
 -> ArrayValue -> Identity ArrayValue)
-> Maybe [Bool] -> ArrayValue -> ArrayValue
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Bool] -> Maybe [Bool]
forall a. a -> Maybe a
Just [Bool]
vs
  ArrayOfDoubles  [Double]
vs -> ArrayValue
AWS.newArrayValue ArrayValue -> (ArrayValue -> ArrayValue) -> ArrayValue
forall a b. a -> (a -> b) -> b
& forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"doubleValues"   ((Maybe [Double] -> Identity (Maybe [Double]))
 -> ArrayValue -> Identity ArrayValue)
-> Maybe [Double] -> ArrayValue -> ArrayValue
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Double] -> Maybe [Double]
forall a. a -> Maybe a
Just [Double]
vs
  ArrayOfIntegers [Integer]
vs -> ArrayValue
AWS.newArrayValue ArrayValue -> (ArrayValue -> ArrayValue) -> ArrayValue
forall a b. a -> (a -> b) -> b
& forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"longValues"     ((Maybe [Integer] -> Identity (Maybe [Integer]))
 -> ArrayValue -> Identity ArrayValue)
-> Maybe [Integer] -> ArrayValue -> ArrayValue
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Integer] -> Maybe [Integer]
forall a. a -> Maybe a
Just [Integer]
vs
  ArrayOfTexts    [Text]
vs -> ArrayValue
AWS.newArrayValue ArrayValue -> (ArrayValue -> ArrayValue) -> ArrayValue
forall a b. a -> (a -> b) -> b
& forall {k} (sel :: k) s t a b. HasAny sel s t a b => Lens s t a b
forall (sel :: Symbol) s t a b. HasAny sel s t a b => Lens s t a b
the @"stringValues"   ((Maybe [Text] -> Identity (Maybe [Text]))
 -> ArrayValue -> Identity ArrayValue)
-> Maybe [Text] -> ArrayValue -> ArrayValue
forall s t a b. ASetter s t a b -> b -> s -> t
.~ [Text] -> Maybe [Text]
forall a. a -> Maybe a
Just [Text]
vs