{-# 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.EC2.Types.PlacementGroup
-- 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.EC2.Types.PlacementGroup where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.EC2.Internal
import Amazonka.EC2.Types.PlacementGroupState
import Amazonka.EC2.Types.PlacementStrategy
import Amazonka.EC2.Types.SpreadLevel
import Amazonka.EC2.Types.Tag
import qualified Amazonka.Prelude as Prelude

-- | Describes a placement group.
--
-- /See:/ 'newPlacementGroup' smart constructor.
data PlacementGroup = PlacementGroup'
  { -- | The Amazon Resource Name (ARN) of the placement group.
    PlacementGroup -> Maybe Text
groupArn :: Prelude.Maybe Prelude.Text,
    -- | The ID of the placement group.
    PlacementGroup -> Maybe Text
groupId :: Prelude.Maybe Prelude.Text,
    -- | The name of the placement group.
    PlacementGroup -> Maybe Text
groupName :: Prelude.Maybe Prelude.Text,
    -- | The number of partitions. Valid only if __strategy__ is set to
    -- @partition@.
    PlacementGroup -> Maybe Int
partitionCount :: Prelude.Maybe Prelude.Int,
    -- | The spread level for the placement group. /Only/ Outpost placement
    -- groups can be spread across hosts.
    PlacementGroup -> Maybe SpreadLevel
spreadLevel :: Prelude.Maybe SpreadLevel,
    -- | The state of the placement group.
    PlacementGroup -> Maybe PlacementGroupState
state :: Prelude.Maybe PlacementGroupState,
    -- | The placement strategy.
    PlacementGroup -> Maybe PlacementStrategy
strategy :: Prelude.Maybe PlacementStrategy,
    -- | Any tags applied to the placement group.
    PlacementGroup -> Maybe [Tag]
tags :: Prelude.Maybe [Tag]
  }
  deriving (PlacementGroup -> PlacementGroup -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PlacementGroup -> PlacementGroup -> Bool
$c/= :: PlacementGroup -> PlacementGroup -> Bool
== :: PlacementGroup -> PlacementGroup -> Bool
$c== :: PlacementGroup -> PlacementGroup -> Bool
Prelude.Eq, ReadPrec [PlacementGroup]
ReadPrec PlacementGroup
Int -> ReadS PlacementGroup
ReadS [PlacementGroup]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [PlacementGroup]
$creadListPrec :: ReadPrec [PlacementGroup]
readPrec :: ReadPrec PlacementGroup
$creadPrec :: ReadPrec PlacementGroup
readList :: ReadS [PlacementGroup]
$creadList :: ReadS [PlacementGroup]
readsPrec :: Int -> ReadS PlacementGroup
$creadsPrec :: Int -> ReadS PlacementGroup
Prelude.Read, Int -> PlacementGroup -> ShowS
[PlacementGroup] -> ShowS
PlacementGroup -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PlacementGroup] -> ShowS
$cshowList :: [PlacementGroup] -> ShowS
show :: PlacementGroup -> String
$cshow :: PlacementGroup -> String
showsPrec :: Int -> PlacementGroup -> ShowS
$cshowsPrec :: Int -> PlacementGroup -> ShowS
Prelude.Show, forall x. Rep PlacementGroup x -> PlacementGroup
forall x. PlacementGroup -> Rep PlacementGroup x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep PlacementGroup x -> PlacementGroup
$cfrom :: forall x. PlacementGroup -> Rep PlacementGroup x
Prelude.Generic)

-- |
-- Create a value of 'PlacementGroup' 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:
--
-- 'groupArn', 'placementGroup_groupArn' - The Amazon Resource Name (ARN) of the placement group.
--
-- 'groupId', 'placementGroup_groupId' - The ID of the placement group.
--
-- 'groupName', 'placementGroup_groupName' - The name of the placement group.
--
-- 'partitionCount', 'placementGroup_partitionCount' - The number of partitions. Valid only if __strategy__ is set to
-- @partition@.
--
-- 'spreadLevel', 'placementGroup_spreadLevel' - The spread level for the placement group. /Only/ Outpost placement
-- groups can be spread across hosts.
--
-- 'state', 'placementGroup_state' - The state of the placement group.
--
-- 'strategy', 'placementGroup_strategy' - The placement strategy.
--
-- 'tags', 'placementGroup_tags' - Any tags applied to the placement group.
newPlacementGroup ::
  PlacementGroup
newPlacementGroup :: PlacementGroup
newPlacementGroup =
  PlacementGroup'
    { $sel:groupArn:PlacementGroup' :: Maybe Text
groupArn = forall a. Maybe a
Prelude.Nothing,
      $sel:groupId:PlacementGroup' :: Maybe Text
groupId = forall a. Maybe a
Prelude.Nothing,
      $sel:groupName:PlacementGroup' :: Maybe Text
groupName = forall a. Maybe a
Prelude.Nothing,
      $sel:partitionCount:PlacementGroup' :: Maybe Int
partitionCount = forall a. Maybe a
Prelude.Nothing,
      $sel:spreadLevel:PlacementGroup' :: Maybe SpreadLevel
spreadLevel = forall a. Maybe a
Prelude.Nothing,
      $sel:state:PlacementGroup' :: Maybe PlacementGroupState
state = forall a. Maybe a
Prelude.Nothing,
      $sel:strategy:PlacementGroup' :: Maybe PlacementStrategy
strategy = forall a. Maybe a
Prelude.Nothing,
      $sel:tags:PlacementGroup' :: Maybe [Tag]
tags = forall a. Maybe a
Prelude.Nothing
    }

-- | The Amazon Resource Name (ARN) of the placement group.
placementGroup_groupArn :: Lens.Lens' PlacementGroup (Prelude.Maybe Prelude.Text)
placementGroup_groupArn :: Lens' PlacementGroup (Maybe Text)
placementGroup_groupArn = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe Text
groupArn :: Maybe Text
$sel:groupArn:PlacementGroup' :: PlacementGroup -> Maybe Text
groupArn} -> Maybe Text
groupArn) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe Text
a -> PlacementGroup
s {$sel:groupArn:PlacementGroup' :: Maybe Text
groupArn = Maybe Text
a} :: PlacementGroup)

-- | The ID of the placement group.
placementGroup_groupId :: Lens.Lens' PlacementGroup (Prelude.Maybe Prelude.Text)
placementGroup_groupId :: Lens' PlacementGroup (Maybe Text)
placementGroup_groupId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe Text
groupId :: Maybe Text
$sel:groupId:PlacementGroup' :: PlacementGroup -> Maybe Text
groupId} -> Maybe Text
groupId) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe Text
a -> PlacementGroup
s {$sel:groupId:PlacementGroup' :: Maybe Text
groupId = Maybe Text
a} :: PlacementGroup)

-- | The name of the placement group.
placementGroup_groupName :: Lens.Lens' PlacementGroup (Prelude.Maybe Prelude.Text)
placementGroup_groupName :: Lens' PlacementGroup (Maybe Text)
placementGroup_groupName = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe Text
groupName :: Maybe Text
$sel:groupName:PlacementGroup' :: PlacementGroup -> Maybe Text
groupName} -> Maybe Text
groupName) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe Text
a -> PlacementGroup
s {$sel:groupName:PlacementGroup' :: Maybe Text
groupName = Maybe Text
a} :: PlacementGroup)

-- | The number of partitions. Valid only if __strategy__ is set to
-- @partition@.
placementGroup_partitionCount :: Lens.Lens' PlacementGroup (Prelude.Maybe Prelude.Int)
placementGroup_partitionCount :: Lens' PlacementGroup (Maybe Int)
placementGroup_partitionCount = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe Int
partitionCount :: Maybe Int
$sel:partitionCount:PlacementGroup' :: PlacementGroup -> Maybe Int
partitionCount} -> Maybe Int
partitionCount) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe Int
a -> PlacementGroup
s {$sel:partitionCount:PlacementGroup' :: Maybe Int
partitionCount = Maybe Int
a} :: PlacementGroup)

-- | The spread level for the placement group. /Only/ Outpost placement
-- groups can be spread across hosts.
placementGroup_spreadLevel :: Lens.Lens' PlacementGroup (Prelude.Maybe SpreadLevel)
placementGroup_spreadLevel :: Lens' PlacementGroup (Maybe SpreadLevel)
placementGroup_spreadLevel = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe SpreadLevel
spreadLevel :: Maybe SpreadLevel
$sel:spreadLevel:PlacementGroup' :: PlacementGroup -> Maybe SpreadLevel
spreadLevel} -> Maybe SpreadLevel
spreadLevel) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe SpreadLevel
a -> PlacementGroup
s {$sel:spreadLevel:PlacementGroup' :: Maybe SpreadLevel
spreadLevel = Maybe SpreadLevel
a} :: PlacementGroup)

-- | The state of the placement group.
placementGroup_state :: Lens.Lens' PlacementGroup (Prelude.Maybe PlacementGroupState)
placementGroup_state :: Lens' PlacementGroup (Maybe PlacementGroupState)
placementGroup_state = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe PlacementGroupState
state :: Maybe PlacementGroupState
$sel:state:PlacementGroup' :: PlacementGroup -> Maybe PlacementGroupState
state} -> Maybe PlacementGroupState
state) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe PlacementGroupState
a -> PlacementGroup
s {$sel:state:PlacementGroup' :: Maybe PlacementGroupState
state = Maybe PlacementGroupState
a} :: PlacementGroup)

-- | The placement strategy.
placementGroup_strategy :: Lens.Lens' PlacementGroup (Prelude.Maybe PlacementStrategy)
placementGroup_strategy :: Lens' PlacementGroup (Maybe PlacementStrategy)
placementGroup_strategy = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe PlacementStrategy
strategy :: Maybe PlacementStrategy
$sel:strategy:PlacementGroup' :: PlacementGroup -> Maybe PlacementStrategy
strategy} -> Maybe PlacementStrategy
strategy) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe PlacementStrategy
a -> PlacementGroup
s {$sel:strategy:PlacementGroup' :: Maybe PlacementStrategy
strategy = Maybe PlacementStrategy
a} :: PlacementGroup)

-- | Any tags applied to the placement group.
placementGroup_tags :: Lens.Lens' PlacementGroup (Prelude.Maybe [Tag])
placementGroup_tags :: Lens' PlacementGroup (Maybe [Tag])
placementGroup_tags = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\PlacementGroup' {Maybe [Tag]
tags :: Maybe [Tag]
$sel:tags:PlacementGroup' :: PlacementGroup -> Maybe [Tag]
tags} -> Maybe [Tag]
tags) (\s :: PlacementGroup
s@PlacementGroup' {} Maybe [Tag]
a -> PlacementGroup
s {$sel:tags:PlacementGroup' :: Maybe [Tag]
tags = Maybe [Tag]
a} :: PlacementGroup) 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 Data.FromXML PlacementGroup where
  parseXML :: [Node] -> Either String PlacementGroup
parseXML [Node]
x =
    Maybe Text
-> Maybe Text
-> Maybe Text
-> Maybe Int
-> Maybe SpreadLevel
-> Maybe PlacementGroupState
-> Maybe PlacementStrategy
-> Maybe [Tag]
-> PlacementGroup
PlacementGroup'
      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
"groupArn")
      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
"groupId")
      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
"groupName")
      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
"partitionCount")
      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
"spreadLevel")
      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
"state")
      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
"strategy")
      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
"tagSet"
                      forall (f :: * -> *) a. Functor f => f (Maybe a) -> a -> f a
Core..!@ forall a. Monoid a => a
Prelude.mempty
                      forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
Prelude.>>= forall (f :: * -> *) a b.
Applicative f =>
([a] -> f b) -> [a] -> f (Maybe b)
Core.may (forall a. FromXML a => Text -> [Node] -> Either String [a]
Data.parseXMLList Text
"item")
                  )

instance Prelude.Hashable PlacementGroup where
  hashWithSalt :: Int -> PlacementGroup -> Int
hashWithSalt Int
_salt PlacementGroup' {Maybe Int
Maybe [Tag]
Maybe Text
Maybe PlacementGroupState
Maybe PlacementStrategy
Maybe SpreadLevel
tags :: Maybe [Tag]
strategy :: Maybe PlacementStrategy
state :: Maybe PlacementGroupState
spreadLevel :: Maybe SpreadLevel
partitionCount :: Maybe Int
groupName :: Maybe Text
groupId :: Maybe Text
groupArn :: Maybe Text
$sel:tags:PlacementGroup' :: PlacementGroup -> Maybe [Tag]
$sel:strategy:PlacementGroup' :: PlacementGroup -> Maybe PlacementStrategy
$sel:state:PlacementGroup' :: PlacementGroup -> Maybe PlacementGroupState
$sel:spreadLevel:PlacementGroup' :: PlacementGroup -> Maybe SpreadLevel
$sel:partitionCount:PlacementGroup' :: PlacementGroup -> Maybe Int
$sel:groupName:PlacementGroup' :: PlacementGroup -> Maybe Text
$sel:groupId:PlacementGroup' :: PlacementGroup -> Maybe Text
$sel:groupArn:PlacementGroup' :: PlacementGroup -> Maybe Text
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
groupArn
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
groupId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Text
groupName
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe Int
partitionCount
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe SpreadLevel
spreadLevel
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PlacementGroupState
state
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe PlacementStrategy
strategy
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe [Tag]
tags

instance Prelude.NFData PlacementGroup where
  rnf :: PlacementGroup -> ()
rnf PlacementGroup' {Maybe Int
Maybe [Tag]
Maybe Text
Maybe PlacementGroupState
Maybe PlacementStrategy
Maybe SpreadLevel
tags :: Maybe [Tag]
strategy :: Maybe PlacementStrategy
state :: Maybe PlacementGroupState
spreadLevel :: Maybe SpreadLevel
partitionCount :: Maybe Int
groupName :: Maybe Text
groupId :: Maybe Text
groupArn :: Maybe Text
$sel:tags:PlacementGroup' :: PlacementGroup -> Maybe [Tag]
$sel:strategy:PlacementGroup' :: PlacementGroup -> Maybe PlacementStrategy
$sel:state:PlacementGroup' :: PlacementGroup -> Maybe PlacementGroupState
$sel:spreadLevel:PlacementGroup' :: PlacementGroup -> Maybe SpreadLevel
$sel:partitionCount:PlacementGroup' :: PlacementGroup -> Maybe Int
$sel:groupName:PlacementGroup' :: PlacementGroup -> Maybe Text
$sel:groupId:PlacementGroup' :: PlacementGroup -> Maybe Text
$sel:groupArn:PlacementGroup' :: PlacementGroup -> Maybe Text
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
groupArn
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
groupId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Text
groupName
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe Int
partitionCount
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe SpreadLevel
spreadLevel
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PlacementGroupState
state
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe PlacementStrategy
strategy
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe [Tag]
tags