{-# 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.SageMaker.Types.SearchExpression
-- 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.SageMaker.Types.SearchExpression where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import qualified Amazonka.Prelude as Prelude
import Amazonka.SageMaker.Types.BooleanOperator
import Amazonka.SageMaker.Types.Filter
import Amazonka.SageMaker.Types.NestedFilters

-- | A multi-expression that searches for the specified resource or resources
-- in a search. All resource objects that satisfy the expression\'s
-- condition are included in the search results. You must specify at least
-- one subexpression, filter, or nested filter. A @SearchExpression@ can
-- contain up to twenty elements.
--
-- A @SearchExpression@ contains the following components:
--
-- -   A list of @Filter@ objects. Each filter defines a simple Boolean
--     expression comprised of a resource property name, Boolean operator,
--     and value.
--
-- -   A list of @NestedFilter@ objects. Each nested filter defines a list
--     of Boolean expressions using a list of resource properties. A nested
--     filter is satisfied if a single object in the list satisfies all
--     Boolean expressions.
--
-- -   A list of @SearchExpression@ objects. A search expression object can
--     be nested in a list of search expression objects.
--
-- -   A Boolean operator: @And@ or @Or@.
--
-- /See:/ 'newSearchExpression' smart constructor.
data SearchExpression = SearchExpression'
  { -- | A list of filter objects.
    SearchExpression -> Maybe (NonEmpty Filter)
filters :: Prelude.Maybe (Prelude.NonEmpty Filter),
    -- | A list of nested filter objects.
    SearchExpression -> Maybe (NonEmpty NestedFilters)
nestedFilters :: Prelude.Maybe (Prelude.NonEmpty NestedFilters),
    -- | A Boolean operator used to evaluate the search expression. If you want
    -- every conditional statement in all lists to be satisfied for the entire
    -- search expression to be true, specify @And@. If only a single
    -- conditional statement needs to be true for the entire search expression
    -- to be true, specify @Or@. The default value is @And@.
    SearchExpression -> Maybe BooleanOperator
operator :: Prelude.Maybe BooleanOperator,
    -- | A list of search expression objects.
    SearchExpression -> Maybe (NonEmpty SearchExpression)
subExpressions :: Prelude.Maybe (Prelude.NonEmpty SearchExpression)
  }
  deriving (SearchExpression -> SearchExpression -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SearchExpression -> SearchExpression -> Bool
$c/= :: SearchExpression -> SearchExpression -> Bool
== :: SearchExpression -> SearchExpression -> Bool
$c== :: SearchExpression -> SearchExpression -> Bool
Prelude.Eq, ReadPrec [SearchExpression]
ReadPrec SearchExpression
Int -> ReadS SearchExpression
ReadS [SearchExpression]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [SearchExpression]
$creadListPrec :: ReadPrec [SearchExpression]
readPrec :: ReadPrec SearchExpression
$creadPrec :: ReadPrec SearchExpression
readList :: ReadS [SearchExpression]
$creadList :: ReadS [SearchExpression]
readsPrec :: Int -> ReadS SearchExpression
$creadsPrec :: Int -> ReadS SearchExpression
Prelude.Read, Int -> SearchExpression -> ShowS
[SearchExpression] -> ShowS
SearchExpression -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SearchExpression] -> ShowS
$cshowList :: [SearchExpression] -> ShowS
show :: SearchExpression -> String
$cshow :: SearchExpression -> String
showsPrec :: Int -> SearchExpression -> ShowS
$cshowsPrec :: Int -> SearchExpression -> ShowS
Prelude.Show, forall x. Rep SearchExpression x -> SearchExpression
forall x. SearchExpression -> Rep SearchExpression x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep SearchExpression x -> SearchExpression
$cfrom :: forall x. SearchExpression -> Rep SearchExpression x
Prelude.Generic)

-- |
-- Create a value of 'SearchExpression' 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:
--
-- 'filters', 'searchExpression_filters' - A list of filter objects.
--
-- 'nestedFilters', 'searchExpression_nestedFilters' - A list of nested filter objects.
--
-- 'operator', 'searchExpression_operator' - A Boolean operator used to evaluate the search expression. If you want
-- every conditional statement in all lists to be satisfied for the entire
-- search expression to be true, specify @And@. If only a single
-- conditional statement needs to be true for the entire search expression
-- to be true, specify @Or@. The default value is @And@.
--
-- 'subExpressions', 'searchExpression_subExpressions' - A list of search expression objects.
newSearchExpression ::
  SearchExpression
newSearchExpression :: SearchExpression
newSearchExpression =
  SearchExpression'
    { $sel:filters:SearchExpression' :: Maybe (NonEmpty Filter)
filters = forall a. Maybe a
Prelude.Nothing,
      $sel:nestedFilters:SearchExpression' :: Maybe (NonEmpty NestedFilters)
nestedFilters = forall a. Maybe a
Prelude.Nothing,
      $sel:operator:SearchExpression' :: Maybe BooleanOperator
operator = forall a. Maybe a
Prelude.Nothing,
      $sel:subExpressions:SearchExpression' :: Maybe (NonEmpty SearchExpression)
subExpressions = forall a. Maybe a
Prelude.Nothing
    }

-- | A list of filter objects.
searchExpression_filters :: Lens.Lens' SearchExpression (Prelude.Maybe (Prelude.NonEmpty Filter))
searchExpression_filters :: Lens' SearchExpression (Maybe (NonEmpty Filter))
searchExpression_filters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchExpression' {Maybe (NonEmpty Filter)
filters :: Maybe (NonEmpty Filter)
$sel:filters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty Filter)
filters} -> Maybe (NonEmpty Filter)
filters) (\s :: SearchExpression
s@SearchExpression' {} Maybe (NonEmpty Filter)
a -> SearchExpression
s {$sel:filters:SearchExpression' :: Maybe (NonEmpty Filter)
filters = Maybe (NonEmpty Filter)
a} :: SearchExpression) 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

-- | A list of nested filter objects.
searchExpression_nestedFilters :: Lens.Lens' SearchExpression (Prelude.Maybe (Prelude.NonEmpty NestedFilters))
searchExpression_nestedFilters :: Lens' SearchExpression (Maybe (NonEmpty NestedFilters))
searchExpression_nestedFilters = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchExpression' {Maybe (NonEmpty NestedFilters)
nestedFilters :: Maybe (NonEmpty NestedFilters)
$sel:nestedFilters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty NestedFilters)
nestedFilters} -> Maybe (NonEmpty NestedFilters)
nestedFilters) (\s :: SearchExpression
s@SearchExpression' {} Maybe (NonEmpty NestedFilters)
a -> SearchExpression
s {$sel:nestedFilters:SearchExpression' :: Maybe (NonEmpty NestedFilters)
nestedFilters = Maybe (NonEmpty NestedFilters)
a} :: SearchExpression) 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

-- | A Boolean operator used to evaluate the search expression. If you want
-- every conditional statement in all lists to be satisfied for the entire
-- search expression to be true, specify @And@. If only a single
-- conditional statement needs to be true for the entire search expression
-- to be true, specify @Or@. The default value is @And@.
searchExpression_operator :: Lens.Lens' SearchExpression (Prelude.Maybe BooleanOperator)
searchExpression_operator :: Lens' SearchExpression (Maybe BooleanOperator)
searchExpression_operator = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchExpression' {Maybe BooleanOperator
operator :: Maybe BooleanOperator
$sel:operator:SearchExpression' :: SearchExpression -> Maybe BooleanOperator
operator} -> Maybe BooleanOperator
operator) (\s :: SearchExpression
s@SearchExpression' {} Maybe BooleanOperator
a -> SearchExpression
s {$sel:operator:SearchExpression' :: Maybe BooleanOperator
operator = Maybe BooleanOperator
a} :: SearchExpression)

-- | A list of search expression objects.
searchExpression_subExpressions :: Lens.Lens' SearchExpression (Prelude.Maybe (Prelude.NonEmpty SearchExpression))
searchExpression_subExpressions :: Lens' SearchExpression (Maybe (NonEmpty SearchExpression))
searchExpression_subExpressions = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\SearchExpression' {Maybe (NonEmpty SearchExpression)
subExpressions :: Maybe (NonEmpty SearchExpression)
$sel:subExpressions:SearchExpression' :: SearchExpression -> Maybe (NonEmpty SearchExpression)
subExpressions} -> Maybe (NonEmpty SearchExpression)
subExpressions) (\s :: SearchExpression
s@SearchExpression' {} Maybe (NonEmpty SearchExpression)
a -> SearchExpression
s {$sel:subExpressions:SearchExpression' :: Maybe (NonEmpty SearchExpression)
subExpressions = Maybe (NonEmpty SearchExpression)
a} :: SearchExpression) 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

instance Prelude.Hashable SearchExpression where
  hashWithSalt :: Int -> SearchExpression -> Int
hashWithSalt Int
_salt SearchExpression' {Maybe (NonEmpty Filter)
Maybe (NonEmpty NestedFilters)
Maybe (NonEmpty SearchExpression)
Maybe BooleanOperator
subExpressions :: Maybe (NonEmpty SearchExpression)
operator :: Maybe BooleanOperator
nestedFilters :: Maybe (NonEmpty NestedFilters)
filters :: Maybe (NonEmpty Filter)
$sel:subExpressions:SearchExpression' :: SearchExpression -> Maybe (NonEmpty SearchExpression)
$sel:operator:SearchExpression' :: SearchExpression -> Maybe BooleanOperator
$sel:nestedFilters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty NestedFilters)
$sel:filters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty Filter)
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty Filter)
filters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty NestedFilters)
nestedFilters
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe BooleanOperator
operator
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe (NonEmpty SearchExpression)
subExpressions

instance Prelude.NFData SearchExpression where
  rnf :: SearchExpression -> ()
rnf SearchExpression' {Maybe (NonEmpty Filter)
Maybe (NonEmpty NestedFilters)
Maybe (NonEmpty SearchExpression)
Maybe BooleanOperator
subExpressions :: Maybe (NonEmpty SearchExpression)
operator :: Maybe BooleanOperator
nestedFilters :: Maybe (NonEmpty NestedFilters)
filters :: Maybe (NonEmpty Filter)
$sel:subExpressions:SearchExpression' :: SearchExpression -> Maybe (NonEmpty SearchExpression)
$sel:operator:SearchExpression' :: SearchExpression -> Maybe BooleanOperator
$sel:nestedFilters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty NestedFilters)
$sel:filters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty Filter)
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty Filter)
filters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty NestedFilters)
nestedFilters
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe BooleanOperator
operator
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe (NonEmpty SearchExpression)
subExpressions

instance Data.ToJSON SearchExpression where
  toJSON :: SearchExpression -> Value
toJSON SearchExpression' {Maybe (NonEmpty Filter)
Maybe (NonEmpty NestedFilters)
Maybe (NonEmpty SearchExpression)
Maybe BooleanOperator
subExpressions :: Maybe (NonEmpty SearchExpression)
operator :: Maybe BooleanOperator
nestedFilters :: Maybe (NonEmpty NestedFilters)
filters :: Maybe (NonEmpty Filter)
$sel:subExpressions:SearchExpression' :: SearchExpression -> Maybe (NonEmpty SearchExpression)
$sel:operator:SearchExpression' :: SearchExpression -> Maybe BooleanOperator
$sel:nestedFilters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty NestedFilters)
$sel:filters:SearchExpression' :: SearchExpression -> Maybe (NonEmpty Filter)
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"Filters" 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 Filter)
filters,
            (Key
"NestedFilters" 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 NestedFilters)
nestedFilters,
            (Key
"Operator" 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 BooleanOperator
operator,
            (Key
"SubExpressions" 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 SearchExpression)
subExpressions
          ]
      )