{-# 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.S3.Types.LifecycleRuleFilter
-- 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.S3.Types.LifecycleRuleFilter 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.S3.Internal
import Amazonka.S3.Types.LifecycleRuleAndOperator
import Amazonka.S3.Types.Tag

-- | The @Filter@ is used to identify objects that a Lifecycle Rule applies
-- to. A @Filter@ must have exactly one of @Prefix@, @Tag@, or @And@
-- specified.
--
-- /See:/ 'newLifecycleRuleFilter' smart constructor.
data LifecycleRuleFilter = LifecycleRuleFilter'
  { LifecycleRuleFilter -> Maybe LifecycleRuleAndOperator
and :: Prelude.Maybe LifecycleRuleAndOperator,
    -- | Minimum object size to which the rule applies.
    LifecycleRuleFilter -> Maybe Integer
objectSizeGreaterThan :: Prelude.Maybe Prelude.Integer,
    -- | Maximum object size to which the rule applies.
    LifecycleRuleFilter -> Maybe Integer
objectSizeLessThan :: Prelude.Maybe Prelude.Integer,
    -- | Prefix identifying one or more objects to which the rule applies.
    --
    -- Replacement must be made for object keys containing special characters
    -- (such as carriage returns) when using XML requests. For more
    -- information, see
    -- <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints XML related object key constraints>.
    LifecycleRuleFilter -> Maybe Text
prefix :: Prelude.Maybe Prelude.Text,
    -- | This tag must exist in the object\'s tag set in order for the rule to
    -- apply.
    LifecycleRuleFilter -> Maybe Tag
tag :: Prelude.Maybe Tag
  }
  deriving (LifecycleRuleFilter -> LifecycleRuleFilter -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LifecycleRuleFilter -> LifecycleRuleFilter -> Bool
$c/= :: LifecycleRuleFilter -> LifecycleRuleFilter -> Bool
== :: LifecycleRuleFilter -> LifecycleRuleFilter -> Bool
$c== :: LifecycleRuleFilter -> LifecycleRuleFilter -> Bool
Prelude.Eq, ReadPrec [LifecycleRuleFilter]
ReadPrec LifecycleRuleFilter
Int -> ReadS LifecycleRuleFilter
ReadS [LifecycleRuleFilter]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [LifecycleRuleFilter]
$creadListPrec :: ReadPrec [LifecycleRuleFilter]
readPrec :: ReadPrec LifecycleRuleFilter
$creadPrec :: ReadPrec LifecycleRuleFilter
readList :: ReadS [LifecycleRuleFilter]
$creadList :: ReadS [LifecycleRuleFilter]
readsPrec :: Int -> ReadS LifecycleRuleFilter
$creadsPrec :: Int -> ReadS LifecycleRuleFilter
Prelude.Read, Int -> LifecycleRuleFilter -> ShowS
[LifecycleRuleFilter] -> ShowS
LifecycleRuleFilter -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LifecycleRuleFilter] -> ShowS
$cshowList :: [LifecycleRuleFilter] -> ShowS
show :: LifecycleRuleFilter -> String
$cshow :: LifecycleRuleFilter -> String
showsPrec :: Int -> LifecycleRuleFilter -> ShowS
$cshowsPrec :: Int -> LifecycleRuleFilter -> ShowS
Prelude.Show, forall x. Rep LifecycleRuleFilter x -> LifecycleRuleFilter
forall x. LifecycleRuleFilter -> Rep LifecycleRuleFilter x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep LifecycleRuleFilter x -> LifecycleRuleFilter
$cfrom :: forall x. LifecycleRuleFilter -> Rep LifecycleRuleFilter x
Prelude.Generic)

-- |
-- Create a value of 'LifecycleRuleFilter' 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:
--
-- 'and', 'lifecycleRuleFilter_and' - Undocumented member.
--
-- 'objectSizeGreaterThan', 'lifecycleRuleFilter_objectSizeGreaterThan' - Minimum object size to which the rule applies.
--
-- 'objectSizeLessThan', 'lifecycleRuleFilter_objectSizeLessThan' - Maximum object size to which the rule applies.
--
-- 'prefix', 'lifecycleRuleFilter_prefix' - Prefix identifying one or more objects to which the rule applies.
--
-- Replacement must be made for object keys containing special characters
-- (such as carriage returns) when using XML requests. For more
-- information, see
-- <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints XML related object key constraints>.
--
-- 'tag', 'lifecycleRuleFilter_tag' - This tag must exist in the object\'s tag set in order for the rule to
-- apply.
newLifecycleRuleFilter ::
  LifecycleRuleFilter
newLifecycleRuleFilter :: LifecycleRuleFilter
newLifecycleRuleFilter =
  LifecycleRuleFilter'
    { $sel:and:LifecycleRuleFilter' :: Maybe LifecycleRuleAndOperator
and = forall a. Maybe a
Prelude.Nothing,
      $sel:objectSizeGreaterThan:LifecycleRuleFilter' :: Maybe Integer
objectSizeGreaterThan = forall a. Maybe a
Prelude.Nothing,
      $sel:objectSizeLessThan:LifecycleRuleFilter' :: Maybe Integer
objectSizeLessThan = forall a. Maybe a
Prelude.Nothing,
      $sel:prefix:LifecycleRuleFilter' :: Maybe Text
prefix = forall a. Maybe a
Prelude.Nothing,
      $sel:tag:LifecycleRuleFilter' :: Maybe Tag
tag = forall a. Maybe a
Prelude.Nothing
    }

-- | Undocumented member.
lifecycleRuleFilter_and :: Lens.Lens' LifecycleRuleFilter (Prelude.Maybe LifecycleRuleAndOperator)
lifecycleRuleFilter_and :: Lens' LifecycleRuleFilter (Maybe LifecycleRuleAndOperator)
lifecycleRuleFilter_and = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LifecycleRuleFilter' {Maybe LifecycleRuleAndOperator
and :: Maybe LifecycleRuleAndOperator
$sel:and:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe LifecycleRuleAndOperator
and} -> Maybe LifecycleRuleAndOperator
and) (\s :: LifecycleRuleFilter
s@LifecycleRuleFilter' {} Maybe LifecycleRuleAndOperator
a -> LifecycleRuleFilter
s {$sel:and:LifecycleRuleFilter' :: Maybe LifecycleRuleAndOperator
and = Maybe LifecycleRuleAndOperator
a} :: LifecycleRuleFilter)

-- | Minimum object size to which the rule applies.
lifecycleRuleFilter_objectSizeGreaterThan :: Lens.Lens' LifecycleRuleFilter (Prelude.Maybe Prelude.Integer)
lifecycleRuleFilter_objectSizeGreaterThan :: Lens' LifecycleRuleFilter (Maybe Integer)
lifecycleRuleFilter_objectSizeGreaterThan = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LifecycleRuleFilter' {Maybe Integer
objectSizeGreaterThan :: Maybe Integer
$sel:objectSizeGreaterThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
objectSizeGreaterThan} -> Maybe Integer
objectSizeGreaterThan) (\s :: LifecycleRuleFilter
s@LifecycleRuleFilter' {} Maybe Integer
a -> LifecycleRuleFilter
s {$sel:objectSizeGreaterThan:LifecycleRuleFilter' :: Maybe Integer
objectSizeGreaterThan = Maybe Integer
a} :: LifecycleRuleFilter)

-- | Maximum object size to which the rule applies.
lifecycleRuleFilter_objectSizeLessThan :: Lens.Lens' LifecycleRuleFilter (Prelude.Maybe Prelude.Integer)
lifecycleRuleFilter_objectSizeLessThan :: Lens' LifecycleRuleFilter (Maybe Integer)
lifecycleRuleFilter_objectSizeLessThan = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LifecycleRuleFilter' {Maybe Integer
objectSizeLessThan :: Maybe Integer
$sel:objectSizeLessThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
objectSizeLessThan} -> Maybe Integer
objectSizeLessThan) (\s :: LifecycleRuleFilter
s@LifecycleRuleFilter' {} Maybe Integer
a -> LifecycleRuleFilter
s {$sel:objectSizeLessThan:LifecycleRuleFilter' :: Maybe Integer
objectSizeLessThan = Maybe Integer
a} :: LifecycleRuleFilter)

-- | Prefix identifying one or more objects to which the rule applies.
--
-- Replacement must be made for object keys containing special characters
-- (such as carriage returns) when using XML requests. For more
-- information, see
-- <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-keys.html#object-key-xml-related-constraints XML related object key constraints>.
lifecycleRuleFilter_prefix :: Lens.Lens' LifecycleRuleFilter (Prelude.Maybe Prelude.Text)
lifecycleRuleFilter_prefix :: Lens' LifecycleRuleFilter (Maybe Text)
lifecycleRuleFilter_prefix = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LifecycleRuleFilter' {Maybe Text
prefix :: Maybe Text
$sel:prefix:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Text
prefix} -> Maybe Text
prefix) (\s :: LifecycleRuleFilter
s@LifecycleRuleFilter' {} Maybe Text
a -> LifecycleRuleFilter
s {$sel:prefix:LifecycleRuleFilter' :: Maybe Text
prefix = Maybe Text
a} :: LifecycleRuleFilter)

-- | This tag must exist in the object\'s tag set in order for the rule to
-- apply.
lifecycleRuleFilter_tag :: Lens.Lens' LifecycleRuleFilter (Prelude.Maybe Tag)
lifecycleRuleFilter_tag :: Lens' LifecycleRuleFilter (Maybe Tag)
lifecycleRuleFilter_tag = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\LifecycleRuleFilter' {Maybe Tag
tag :: Maybe Tag
$sel:tag:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Tag
tag} -> Maybe Tag
tag) (\s :: LifecycleRuleFilter
s@LifecycleRuleFilter' {} Maybe Tag
a -> LifecycleRuleFilter
s {$sel:tag:LifecycleRuleFilter' :: Maybe Tag
tag = Maybe Tag
a} :: LifecycleRuleFilter)

instance Data.FromXML LifecycleRuleFilter where
  parseXML :: [Node] -> Either String LifecycleRuleFilter
parseXML [Node]
x =
    Maybe LifecycleRuleAndOperator
-> Maybe Integer
-> Maybe Integer
-> Maybe Text
-> Maybe Tag
-> LifecycleRuleFilter
LifecycleRuleFilter'
      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"And")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ObjectSizeGreaterThan")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"ObjectSizeLessThan")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Prefix")
      forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> ([Node]
x forall a. FromXML a => [Node] -> Text -> Either String (Maybe a)
Data..@? Text
"Tag")

instance Prelude.Hashable LifecycleRuleFilter where
  hashWithSalt :: Int -> LifecycleRuleFilter -> Int
hashWithSalt Int
_salt LifecycleRuleFilter' {Maybe Integer
Maybe Text
Maybe Tag
Maybe LifecycleRuleAndOperator
tag :: Maybe Tag
prefix :: Maybe Text
objectSizeLessThan :: Maybe Integer
objectSizeGreaterThan :: Maybe Integer
and :: Maybe LifecycleRuleAndOperator
$sel:tag:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Tag
$sel:prefix:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Text
$sel:objectSizeLessThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
$sel:objectSizeGreaterThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
$sel:and:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe LifecycleRuleAndOperator
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe LifecycleRuleAndOperator
and
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Integer
objectSizeGreaterThan
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Integer
objectSizeLessThan
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
prefix
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Tag
tag

instance Prelude.NFData LifecycleRuleFilter where
  rnf :: LifecycleRuleFilter -> ()
rnf LifecycleRuleFilter' {Maybe Integer
Maybe Text
Maybe Tag
Maybe LifecycleRuleAndOperator
tag :: Maybe Tag
prefix :: Maybe Text
objectSizeLessThan :: Maybe Integer
objectSizeGreaterThan :: Maybe Integer
and :: Maybe LifecycleRuleAndOperator
$sel:tag:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Tag
$sel:prefix:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Text
$sel:objectSizeLessThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
$sel:objectSizeGreaterThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
$sel:and:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe LifecycleRuleAndOperator
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe LifecycleRuleAndOperator
and
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Integer
objectSizeGreaterThan
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Integer
objectSizeLessThan
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
prefix
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Tag
tag

instance Data.ToXML LifecycleRuleFilter where
  toXML :: LifecycleRuleFilter -> XML
toXML LifecycleRuleFilter' {Maybe Integer
Maybe Text
Maybe Tag
Maybe LifecycleRuleAndOperator
tag :: Maybe Tag
prefix :: Maybe Text
objectSizeLessThan :: Maybe Integer
objectSizeGreaterThan :: Maybe Integer
and :: Maybe LifecycleRuleAndOperator
$sel:tag:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Tag
$sel:prefix:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Text
$sel:objectSizeLessThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
$sel:objectSizeGreaterThan:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe Integer
$sel:and:LifecycleRuleFilter' :: LifecycleRuleFilter -> Maybe LifecycleRuleAndOperator
..} =
    forall a. Monoid a => [a] -> a
Prelude.mconcat
      [ Name
"And" forall a. ToXML a => Name -> a -> XML
Data.@= Maybe LifecycleRuleAndOperator
and,
        Name
"ObjectSizeGreaterThan"
          forall a. ToXML a => Name -> a -> XML
Data.@= Maybe Integer
objectSizeGreaterThan,
        Name
"ObjectSizeLessThan" forall a. ToXML a => Name -> a -> XML
Data.@= Maybe Integer
objectSizeLessThan,
        Name
"Prefix" forall a. ToXML a => Name -> a -> XML
Data.@= Maybe Text
prefix,
        Name
"Tag" forall a. ToXML a => Name -> a -> XML
Data.@= Maybe Tag
tag
      ]