{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE DuplicateRecordFields #-}
{-# LANGUAGE NamedFieldPuns #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE RecordWildCards #-}
{-# LANGUAGE StrictData #-}
{-# LANGUAGE NoImplicitPrelude #-}
{-# OPTIONS_GHC -fno-warn-unused-imports #-}
{-# OPTIONS_GHC -fno-warn-unused-matches #-}

-- Derived from AWS service descriptions, licensed under Apache 2.0.

-- |
-- Module      : Amazonka.Inspector2.Types.RepositoryAggregation
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
module Amazonka.Inspector2.Types.RepositoryAggregation where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Inspector2.Types.RepositorySortBy
import Amazonka.Inspector2.Types.SortOrder
import Amazonka.Inspector2.Types.StringFilter
import qualified Amazonka.Prelude as Prelude

-- | The details that define an aggregation based on repository.
--
-- /See:/ 'newRepositoryAggregation' smart constructor.
data RepositoryAggregation = RepositoryAggregation'
  { -- | The names of repositories to aggregate findings on.
    RepositoryAggregation -> Maybe (NonEmpty StringFilter)
repositories :: Prelude.Maybe (Prelude.NonEmpty StringFilter),
    -- | The value to sort results by.
    RepositoryAggregation -> Maybe RepositorySortBy
sortBy :: Prelude.Maybe RepositorySortBy,
    -- | The order to sort results by.
    RepositoryAggregation -> Maybe SortOrder
sortOrder :: Prelude.Maybe SortOrder
  }
  deriving (RepositoryAggregation -> RepositoryAggregation -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RepositoryAggregation -> RepositoryAggregation -> Bool
$c/= :: RepositoryAggregation -> RepositoryAggregation -> Bool
== :: RepositoryAggregation -> RepositoryAggregation -> Bool
$c== :: RepositoryAggregation -> RepositoryAggregation -> Bool
Prelude.Eq, ReadPrec [RepositoryAggregation]
ReadPrec RepositoryAggregation
Int -> ReadS RepositoryAggregation
ReadS [RepositoryAggregation]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [RepositoryAggregation]
$creadListPrec :: ReadPrec [RepositoryAggregation]
readPrec :: ReadPrec RepositoryAggregation
$creadPrec :: ReadPrec RepositoryAggregation
readList :: ReadS [RepositoryAggregation]
$creadList :: ReadS [RepositoryAggregation]
readsPrec :: Int -> ReadS RepositoryAggregation
$creadsPrec :: Int -> ReadS RepositoryAggregation
Prelude.Read, Int -> RepositoryAggregation -> ShowS
[RepositoryAggregation] -> ShowS
RepositoryAggregation -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RepositoryAggregation] -> ShowS
$cshowList :: [RepositoryAggregation] -> ShowS
show :: RepositoryAggregation -> String
$cshow :: RepositoryAggregation -> String
showsPrec :: Int -> RepositoryAggregation -> ShowS
$cshowsPrec :: Int -> RepositoryAggregation -> ShowS
Prelude.Show, forall x. Rep RepositoryAggregation x -> RepositoryAggregation
forall x. RepositoryAggregation -> Rep RepositoryAggregation x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep RepositoryAggregation x -> RepositoryAggregation
$cfrom :: forall x. RepositoryAggregation -> Rep RepositoryAggregation x
Prelude.Generic)

-- |
-- Create a value of 'RepositoryAggregation' with all optional fields omitted.
--
-- Use <https://hackage.haskell.org/package/generic-lens generic-lens> or <https://hackage.haskell.org/package/optics optics> to modify other optional fields.
--
-- The following record fields are available, with the corresponding lenses provided
-- for backwards compatibility:
--
-- 'repositories', 'repositoryAggregation_repositories' - The names of repositories to aggregate findings on.
--
-- 'sortBy', 'repositoryAggregation_sortBy' - The value to sort results by.
--
-- 'sortOrder', 'repositoryAggregation_sortOrder' - The order to sort results by.
newRepositoryAggregation ::
  RepositoryAggregation
newRepositoryAggregation :: RepositoryAggregation
newRepositoryAggregation =
  RepositoryAggregation'
    { $sel:repositories:RepositoryAggregation' :: Maybe (NonEmpty StringFilter)
repositories =
        forall a. Maybe a
Prelude.Nothing,
      $sel:sortBy:RepositoryAggregation' :: Maybe RepositorySortBy
sortBy = forall a. Maybe a
Prelude.Nothing,
      $sel:sortOrder:RepositoryAggregation' :: Maybe SortOrder
sortOrder = forall a. Maybe a
Prelude.Nothing
    }

-- | The names of repositories to aggregate findings on.
repositoryAggregation_repositories :: Lens.Lens' RepositoryAggregation (Prelude.Maybe (Prelude.NonEmpty StringFilter))
repositoryAggregation_repositories :: Lens' RepositoryAggregation (Maybe (NonEmpty StringFilter))
repositoryAggregation_repositories = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RepositoryAggregation' {Maybe (NonEmpty StringFilter)
repositories :: Maybe (NonEmpty StringFilter)
$sel:repositories:RepositoryAggregation' :: RepositoryAggregation -> Maybe (NonEmpty StringFilter)
repositories} -> Maybe (NonEmpty StringFilter)
repositories) (\s :: RepositoryAggregation
s@RepositoryAggregation' {} Maybe (NonEmpty StringFilter)
a -> RepositoryAggregation
s {$sel:repositories:RepositoryAggregation' :: Maybe (NonEmpty StringFilter)
repositories = Maybe (NonEmpty StringFilter)
a} :: RepositoryAggregation) forall b c a. (b -> c) -> (a -> b) -> a -> c
Prelude.. forall (f :: * -> *) (g :: * -> *) s t a b.
(Functor f, Functor g) =>
AnIso s t a b -> Iso (f s) (g t) (f a) (g b)
Lens.mapping forall s t a b. (Coercible s a, Coercible t b) => Iso s t a b
Lens.coerced

-- | The value to sort results by.
repositoryAggregation_sortBy :: Lens.Lens' RepositoryAggregation (Prelude.Maybe RepositorySortBy)
repositoryAggregation_sortBy :: Lens' RepositoryAggregation (Maybe RepositorySortBy)
repositoryAggregation_sortBy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RepositoryAggregation' {Maybe RepositorySortBy
sortBy :: Maybe RepositorySortBy
$sel:sortBy:RepositoryAggregation' :: RepositoryAggregation -> Maybe RepositorySortBy
sortBy} -> Maybe RepositorySortBy
sortBy) (\s :: RepositoryAggregation
s@RepositoryAggregation' {} Maybe RepositorySortBy
a -> RepositoryAggregation
s {$sel:sortBy:RepositoryAggregation' :: Maybe RepositorySortBy
sortBy = Maybe RepositorySortBy
a} :: RepositoryAggregation)

-- | The order to sort results by.
repositoryAggregation_sortOrder :: Lens.Lens' RepositoryAggregation (Prelude.Maybe SortOrder)
repositoryAggregation_sortOrder :: Lens' RepositoryAggregation (Maybe SortOrder)
repositoryAggregation_sortOrder = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\RepositoryAggregation' {Maybe SortOrder
sortOrder :: Maybe SortOrder
$sel:sortOrder:RepositoryAggregation' :: RepositoryAggregation -> Maybe SortOrder
sortOrder} -> Maybe SortOrder
sortOrder) (\s :: RepositoryAggregation
s@RepositoryAggregation' {} Maybe SortOrder
a -> RepositoryAggregation
s {$sel:sortOrder:RepositoryAggregation' :: Maybe SortOrder
sortOrder = Maybe SortOrder
a} :: RepositoryAggregation)

instance Prelude.Hashable RepositoryAggregation where
  hashWithSalt :: Int -> RepositoryAggregation -> Int
hashWithSalt Int
_salt RepositoryAggregation' {Maybe (NonEmpty StringFilter)
Maybe RepositorySortBy
Maybe SortOrder
sortOrder :: Maybe SortOrder
sortBy :: Maybe RepositorySortBy
repositories :: Maybe (NonEmpty StringFilter)
$sel:sortOrder:RepositoryAggregation' :: RepositoryAggregation -> Maybe SortOrder
$sel:sortBy:RepositoryAggregation' :: RepositoryAggregation -> Maybe RepositorySortBy
$sel:repositories:RepositoryAggregation' :: RepositoryAggregation -> Maybe (NonEmpty StringFilter)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty StringFilter)
repositories
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe RepositorySortBy
sortBy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SortOrder
sortOrder

instance Prelude.NFData RepositoryAggregation where
  rnf :: RepositoryAggregation -> ()
rnf RepositoryAggregation' {Maybe (NonEmpty StringFilter)
Maybe RepositorySortBy
Maybe SortOrder
sortOrder :: Maybe SortOrder
sortBy :: Maybe RepositorySortBy
repositories :: Maybe (NonEmpty StringFilter)
$sel:sortOrder:RepositoryAggregation' :: RepositoryAggregation -> Maybe SortOrder
$sel:sortBy:RepositoryAggregation' :: RepositoryAggregation -> Maybe RepositorySortBy
$sel:repositories:RepositoryAggregation' :: RepositoryAggregation -> Maybe (NonEmpty StringFilter)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty StringFilter)
repositories
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe RepositorySortBy
sortBy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SortOrder
sortOrder

instance Data.ToJSON RepositoryAggregation where
  toJSON :: RepositoryAggregation -> Value
toJSON RepositoryAggregation' {Maybe (NonEmpty StringFilter)
Maybe RepositorySortBy
Maybe SortOrder
sortOrder :: Maybe SortOrder
sortBy :: Maybe RepositorySortBy
repositories :: Maybe (NonEmpty StringFilter)
$sel:sortOrder:RepositoryAggregation' :: RepositoryAggregation -> Maybe SortOrder
$sel:sortBy:RepositoryAggregation' :: RepositoryAggregation -> Maybe RepositorySortBy
$sel:repositories:RepositoryAggregation' :: RepositoryAggregation -> Maybe (NonEmpty StringFilter)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"repositories" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe (NonEmpty StringFilter)
repositories,
            (Key
"sortBy" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe RepositorySortBy
sortBy,
            (Key
"sortOrder" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..=) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> Maybe SortOrder
sortOrder
          ]
      )