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

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

-- |
-- Module      : Amazonka.Glue.GetClassifier
-- Copyright   : (c) 2013-2023 Brendan Hay
-- License     : Mozilla Public License, v. 2.0.
-- Maintainer  : Brendan Hay
-- Stability   : auto-generated
-- Portability : non-portable (GHC extensions)
--
-- Retrieve a classifier by name.
module Amazonka.Glue.GetClassifier
  ( -- * Creating a Request
    GetClassifier (..),
    newGetClassifier,

    -- * Request Lenses
    getClassifier_name,

    -- * Destructuring the Response
    GetClassifierResponse (..),
    newGetClassifierResponse,

    -- * Response Lenses
    getClassifierResponse_classifier,
    getClassifierResponse_httpStatus,
  )
where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.Glue.Types
import qualified Amazonka.Prelude as Prelude
import qualified Amazonka.Request as Request
import qualified Amazonka.Response as Response

-- | /See:/ 'newGetClassifier' smart constructor.
data GetClassifier = GetClassifier'
  { -- | Name of the classifier to retrieve.
    GetClassifier -> Text
name :: Prelude.Text
  }
  deriving (GetClassifier -> GetClassifier -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetClassifier -> GetClassifier -> Bool
$c/= :: GetClassifier -> GetClassifier -> Bool
== :: GetClassifier -> GetClassifier -> Bool
$c== :: GetClassifier -> GetClassifier -> Bool
Prelude.Eq, ReadPrec [GetClassifier]
ReadPrec GetClassifier
Int -> ReadS GetClassifier
ReadS [GetClassifier]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetClassifier]
$creadListPrec :: ReadPrec [GetClassifier]
readPrec :: ReadPrec GetClassifier
$creadPrec :: ReadPrec GetClassifier
readList :: ReadS [GetClassifier]
$creadList :: ReadS [GetClassifier]
readsPrec :: Int -> ReadS GetClassifier
$creadsPrec :: Int -> ReadS GetClassifier
Prelude.Read, Int -> GetClassifier -> ShowS
[GetClassifier] -> ShowS
GetClassifier -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetClassifier] -> ShowS
$cshowList :: [GetClassifier] -> ShowS
show :: GetClassifier -> String
$cshow :: GetClassifier -> String
showsPrec :: Int -> GetClassifier -> ShowS
$cshowsPrec :: Int -> GetClassifier -> ShowS
Prelude.Show, forall x. Rep GetClassifier x -> GetClassifier
forall x. GetClassifier -> Rep GetClassifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetClassifier x -> GetClassifier
$cfrom :: forall x. GetClassifier -> Rep GetClassifier x
Prelude.Generic)

-- |
-- Create a value of 'GetClassifier' 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:
--
-- 'name', 'getClassifier_name' - Name of the classifier to retrieve.
newGetClassifier ::
  -- | 'name'
  Prelude.Text ->
  GetClassifier
newGetClassifier :: Text -> GetClassifier
newGetClassifier Text
pName_ =
  GetClassifier' {$sel:name:GetClassifier' :: Text
name = Text
pName_}

-- | Name of the classifier to retrieve.
getClassifier_name :: Lens.Lens' GetClassifier Prelude.Text
getClassifier_name :: Lens' GetClassifier Text
getClassifier_name = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetClassifier' {Text
name :: Text
$sel:name:GetClassifier' :: GetClassifier -> Text
name} -> Text
name) (\s :: GetClassifier
s@GetClassifier' {} Text
a -> GetClassifier
s {$sel:name:GetClassifier' :: Text
name = Text
a} :: GetClassifier)

instance Core.AWSRequest GetClassifier where
  type
    AWSResponse GetClassifier =
      GetClassifierResponse
  request :: (Service -> Service) -> GetClassifier -> Request GetClassifier
request Service -> Service
overrides =
    forall a. (ToRequest a, ToJSON a) => Service -> a -> Request a
Request.postJSON (Service -> Service
overrides Service
defaultService)
  response :: forall (m :: * -> *).
MonadResource m =>
(ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy GetClassifier
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse GetClassifier)))
response =
    forall (m :: * -> *) a.
MonadResource m =>
(Int -> ResponseHeaders -> Object -> Either String (AWSResponse a))
-> (ByteStringLazy -> IO ByteStringLazy)
-> Service
-> Proxy a
-> ClientResponse ClientBody
-> m (Either Error (ClientResponse (AWSResponse a)))
Response.receiveJSON
      ( \Int
s ResponseHeaders
h Object
x ->
          Maybe Classifier -> Int -> GetClassifierResponse
GetClassifierResponse'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Either String (Maybe a)
Data..?> Key
"Classifier")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (forall (f :: * -> *) a. Applicative f => a -> f a
Prelude.pure (forall a. Enum a => a -> Int
Prelude.fromEnum Int
s))
      )

instance Prelude.Hashable GetClassifier where
  hashWithSalt :: Int -> GetClassifier -> Int
hashWithSalt Int
_salt GetClassifier' {Text
name :: Text
$sel:name:GetClassifier' :: GetClassifier -> Text
..} =
    Int
_salt forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
name

instance Prelude.NFData GetClassifier where
  rnf :: GetClassifier -> ()
rnf GetClassifier' {Text
name :: Text
$sel:name:GetClassifier' :: GetClassifier -> Text
..} = forall a. NFData a => a -> ()
Prelude.rnf Text
name

instance Data.ToHeaders GetClassifier where
  toHeaders :: GetClassifier -> ResponseHeaders
toHeaders =
    forall a b. a -> b -> a
Prelude.const
      ( forall a. Monoid a => [a] -> a
Prelude.mconcat
          [ HeaderName
"X-Amz-Target"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# (ByteString
"AWSGlue.GetClassifier" :: Prelude.ByteString),
            HeaderName
"Content-Type"
              forall a. ToHeader a => HeaderName -> a -> ResponseHeaders
Data.=# ( ByteString
"application/x-amz-json-1.1" ::
                          Prelude.ByteString
                      )
          ]
      )

instance Data.ToJSON GetClassifier where
  toJSON :: GetClassifier -> Value
toJSON GetClassifier' {Text
name :: Text
$sel:name:GetClassifier' :: GetClassifier -> Text
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [forall a. a -> Maybe a
Prelude.Just (Key
"Name" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
name)]
      )

instance Data.ToPath GetClassifier where
  toPath :: GetClassifier -> ByteString
toPath = forall a b. a -> b -> a
Prelude.const ByteString
"/"

instance Data.ToQuery GetClassifier where
  toQuery :: GetClassifier -> QueryString
toQuery = forall a b. a -> b -> a
Prelude.const forall a. Monoid a => a
Prelude.mempty

-- | /See:/ 'newGetClassifierResponse' smart constructor.
data GetClassifierResponse = GetClassifierResponse'
  { -- | The requested classifier.
    GetClassifierResponse -> Maybe Classifier
classifier :: Prelude.Maybe Classifier,
    -- | The response's http status code.
    GetClassifierResponse -> Int
httpStatus :: Prelude.Int
  }
  deriving (GetClassifierResponse -> GetClassifierResponse -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: GetClassifierResponse -> GetClassifierResponse -> Bool
$c/= :: GetClassifierResponse -> GetClassifierResponse -> Bool
== :: GetClassifierResponse -> GetClassifierResponse -> Bool
$c== :: GetClassifierResponse -> GetClassifierResponse -> Bool
Prelude.Eq, ReadPrec [GetClassifierResponse]
ReadPrec GetClassifierResponse
Int -> ReadS GetClassifierResponse
ReadS [GetClassifierResponse]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [GetClassifierResponse]
$creadListPrec :: ReadPrec [GetClassifierResponse]
readPrec :: ReadPrec GetClassifierResponse
$creadPrec :: ReadPrec GetClassifierResponse
readList :: ReadS [GetClassifierResponse]
$creadList :: ReadS [GetClassifierResponse]
readsPrec :: Int -> ReadS GetClassifierResponse
$creadsPrec :: Int -> ReadS GetClassifierResponse
Prelude.Read, Int -> GetClassifierResponse -> ShowS
[GetClassifierResponse] -> ShowS
GetClassifierResponse -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [GetClassifierResponse] -> ShowS
$cshowList :: [GetClassifierResponse] -> ShowS
show :: GetClassifierResponse -> String
$cshow :: GetClassifierResponse -> String
showsPrec :: Int -> GetClassifierResponse -> ShowS
$cshowsPrec :: Int -> GetClassifierResponse -> ShowS
Prelude.Show, forall x. Rep GetClassifierResponse x -> GetClassifierResponse
forall x. GetClassifierResponse -> Rep GetClassifierResponse x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep GetClassifierResponse x -> GetClassifierResponse
$cfrom :: forall x. GetClassifierResponse -> Rep GetClassifierResponse x
Prelude.Generic)

-- |
-- Create a value of 'GetClassifierResponse' 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:
--
-- 'classifier', 'getClassifierResponse_classifier' - The requested classifier.
--
-- 'httpStatus', 'getClassifierResponse_httpStatus' - The response's http status code.
newGetClassifierResponse ::
  -- | 'httpStatus'
  Prelude.Int ->
  GetClassifierResponse
newGetClassifierResponse :: Int -> GetClassifierResponse
newGetClassifierResponse Int
pHttpStatus_ =
  GetClassifierResponse'
    { $sel:classifier:GetClassifierResponse' :: Maybe Classifier
classifier =
        forall a. Maybe a
Prelude.Nothing,
      $sel:httpStatus:GetClassifierResponse' :: Int
httpStatus = Int
pHttpStatus_
    }

-- | The requested classifier.
getClassifierResponse_classifier :: Lens.Lens' GetClassifierResponse (Prelude.Maybe Classifier)
getClassifierResponse_classifier :: Lens' GetClassifierResponse (Maybe Classifier)
getClassifierResponse_classifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetClassifierResponse' {Maybe Classifier
classifier :: Maybe Classifier
$sel:classifier:GetClassifierResponse' :: GetClassifierResponse -> Maybe Classifier
classifier} -> Maybe Classifier
classifier) (\s :: GetClassifierResponse
s@GetClassifierResponse' {} Maybe Classifier
a -> GetClassifierResponse
s {$sel:classifier:GetClassifierResponse' :: Maybe Classifier
classifier = Maybe Classifier
a} :: GetClassifierResponse)

-- | The response's http status code.
getClassifierResponse_httpStatus :: Lens.Lens' GetClassifierResponse Prelude.Int
getClassifierResponse_httpStatus :: Lens' GetClassifierResponse Int
getClassifierResponse_httpStatus = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\GetClassifierResponse' {Int
httpStatus :: Int
$sel:httpStatus:GetClassifierResponse' :: GetClassifierResponse -> Int
httpStatus} -> Int
httpStatus) (\s :: GetClassifierResponse
s@GetClassifierResponse' {} Int
a -> GetClassifierResponse
s {$sel:httpStatus:GetClassifierResponse' :: Int
httpStatus = Int
a} :: GetClassifierResponse)

instance Prelude.NFData GetClassifierResponse where
  rnf :: GetClassifierResponse -> ()
rnf GetClassifierResponse' {Int
Maybe Classifier
httpStatus :: Int
classifier :: Maybe Classifier
$sel:httpStatus:GetClassifierResponse' :: GetClassifierResponse -> Int
$sel:classifier:GetClassifierResponse' :: GetClassifierResponse -> Maybe Classifier
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe Classifier
classifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Int
httpStatus