{-# 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.Glue.Types.Classifier
-- 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.Glue.Types.Classifier 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.CsvClassifier
import Amazonka.Glue.Types.GrokClassifier
import Amazonka.Glue.Types.JsonClassifier
import Amazonka.Glue.Types.XMLClassifier
import qualified Amazonka.Prelude as Prelude

-- | Classifiers are triggered during a crawl task. A classifier checks
-- whether a given file is in a format it can handle. If it is, the
-- classifier creates a schema in the form of a @StructType@ object that
-- matches that data format.
--
-- You can use the standard classifiers that Glue provides, or you can
-- write your own classifiers to best categorize your data sources and
-- specify the appropriate schemas to use for them. A classifier can be a
-- @grok@ classifier, an @XML@ classifier, a @JSON@ classifier, or a custom
-- @CSV@ classifier, as specified in one of the fields in the @Classifier@
-- object.
--
-- /See:/ 'newClassifier' smart constructor.
data Classifier = Classifier'
  { -- | A classifier for comma-separated values (CSV).
    Classifier -> Maybe CsvClassifier
csvClassifier :: Prelude.Maybe CsvClassifier,
    -- | A classifier that uses @grok@.
    Classifier -> Maybe GrokClassifier
grokClassifier :: Prelude.Maybe GrokClassifier,
    -- | A classifier for JSON content.
    Classifier -> Maybe JsonClassifier
jsonClassifier :: Prelude.Maybe JsonClassifier,
    -- | A classifier for XML content.
    Classifier -> Maybe XMLClassifier
xMLClassifier :: Prelude.Maybe XMLClassifier
  }
  deriving (Classifier -> Classifier -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Classifier -> Classifier -> Bool
$c/= :: Classifier -> Classifier -> Bool
== :: Classifier -> Classifier -> Bool
$c== :: Classifier -> Classifier -> Bool
Prelude.Eq, ReadPrec [Classifier]
ReadPrec Classifier
Int -> ReadS Classifier
ReadS [Classifier]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [Classifier]
$creadListPrec :: ReadPrec [Classifier]
readPrec :: ReadPrec Classifier
$creadPrec :: ReadPrec Classifier
readList :: ReadS [Classifier]
$creadList :: ReadS [Classifier]
readsPrec :: Int -> ReadS Classifier
$creadsPrec :: Int -> ReadS Classifier
Prelude.Read, Int -> Classifier -> ShowS
[Classifier] -> ShowS
Classifier -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Classifier] -> ShowS
$cshowList :: [Classifier] -> ShowS
show :: Classifier -> String
$cshow :: Classifier -> String
showsPrec :: Int -> Classifier -> ShowS
$cshowsPrec :: Int -> Classifier -> ShowS
Prelude.Show, forall x. Rep Classifier x -> Classifier
forall x. Classifier -> Rep Classifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep Classifier x -> Classifier
$cfrom :: forall x. Classifier -> Rep Classifier x
Prelude.Generic)

-- |
-- Create a value of 'Classifier' 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:
--
-- 'csvClassifier', 'classifier_csvClassifier' - A classifier for comma-separated values (CSV).
--
-- 'grokClassifier', 'classifier_grokClassifier' - A classifier that uses @grok@.
--
-- 'jsonClassifier', 'classifier_jsonClassifier' - A classifier for JSON content.
--
-- 'xMLClassifier', 'classifier_xMLClassifier' - A classifier for XML content.
newClassifier ::
  Classifier
newClassifier :: Classifier
newClassifier =
  Classifier'
    { $sel:csvClassifier:Classifier' :: Maybe CsvClassifier
csvClassifier = forall a. Maybe a
Prelude.Nothing,
      $sel:grokClassifier:Classifier' :: Maybe GrokClassifier
grokClassifier = forall a. Maybe a
Prelude.Nothing,
      $sel:jsonClassifier:Classifier' :: Maybe JsonClassifier
jsonClassifier = forall a. Maybe a
Prelude.Nothing,
      $sel:xMLClassifier:Classifier' :: Maybe XMLClassifier
xMLClassifier = forall a. Maybe a
Prelude.Nothing
    }

-- | A classifier for comma-separated values (CSV).
classifier_csvClassifier :: Lens.Lens' Classifier (Prelude.Maybe CsvClassifier)
classifier_csvClassifier :: Lens' Classifier (Maybe CsvClassifier)
classifier_csvClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Classifier' {Maybe CsvClassifier
csvClassifier :: Maybe CsvClassifier
$sel:csvClassifier:Classifier' :: Classifier -> Maybe CsvClassifier
csvClassifier} -> Maybe CsvClassifier
csvClassifier) (\s :: Classifier
s@Classifier' {} Maybe CsvClassifier
a -> Classifier
s {$sel:csvClassifier:Classifier' :: Maybe CsvClassifier
csvClassifier = Maybe CsvClassifier
a} :: Classifier)

-- | A classifier that uses @grok@.
classifier_grokClassifier :: Lens.Lens' Classifier (Prelude.Maybe GrokClassifier)
classifier_grokClassifier :: Lens' Classifier (Maybe GrokClassifier)
classifier_grokClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Classifier' {Maybe GrokClassifier
grokClassifier :: Maybe GrokClassifier
$sel:grokClassifier:Classifier' :: Classifier -> Maybe GrokClassifier
grokClassifier} -> Maybe GrokClassifier
grokClassifier) (\s :: Classifier
s@Classifier' {} Maybe GrokClassifier
a -> Classifier
s {$sel:grokClassifier:Classifier' :: Maybe GrokClassifier
grokClassifier = Maybe GrokClassifier
a} :: Classifier)

-- | A classifier for JSON content.
classifier_jsonClassifier :: Lens.Lens' Classifier (Prelude.Maybe JsonClassifier)
classifier_jsonClassifier :: Lens' Classifier (Maybe JsonClassifier)
classifier_jsonClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Classifier' {Maybe JsonClassifier
jsonClassifier :: Maybe JsonClassifier
$sel:jsonClassifier:Classifier' :: Classifier -> Maybe JsonClassifier
jsonClassifier} -> Maybe JsonClassifier
jsonClassifier) (\s :: Classifier
s@Classifier' {} Maybe JsonClassifier
a -> Classifier
s {$sel:jsonClassifier:Classifier' :: Maybe JsonClassifier
jsonClassifier = Maybe JsonClassifier
a} :: Classifier)

-- | A classifier for XML content.
classifier_xMLClassifier :: Lens.Lens' Classifier (Prelude.Maybe XMLClassifier)
classifier_xMLClassifier :: Lens' Classifier (Maybe XMLClassifier)
classifier_xMLClassifier = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\Classifier' {Maybe XMLClassifier
xMLClassifier :: Maybe XMLClassifier
$sel:xMLClassifier:Classifier' :: Classifier -> Maybe XMLClassifier
xMLClassifier} -> Maybe XMLClassifier
xMLClassifier) (\s :: Classifier
s@Classifier' {} Maybe XMLClassifier
a -> Classifier
s {$sel:xMLClassifier:Classifier' :: Maybe XMLClassifier
xMLClassifier = Maybe XMLClassifier
a} :: Classifier)

instance Data.FromJSON Classifier where
  parseJSON :: Value -> Parser Classifier
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"Classifier"
      ( \Object
x ->
          Maybe CsvClassifier
-> Maybe GrokClassifier
-> Maybe JsonClassifier
-> Maybe XMLClassifier
-> Classifier
Classifier'
            forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
Prelude.<$> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"CsvClassifier")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"GrokClassifier")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"JsonClassifier")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser (Maybe a)
Data..:? Key
"XMLClassifier")
      )

instance Prelude.Hashable Classifier where
  hashWithSalt :: Int -> Classifier -> Int
hashWithSalt Int
_salt Classifier' {Maybe CsvClassifier
Maybe GrokClassifier
Maybe JsonClassifier
Maybe XMLClassifier
xMLClassifier :: Maybe XMLClassifier
jsonClassifier :: Maybe JsonClassifier
grokClassifier :: Maybe GrokClassifier
csvClassifier :: Maybe CsvClassifier
$sel:xMLClassifier:Classifier' :: Classifier -> Maybe XMLClassifier
$sel:jsonClassifier:Classifier' :: Classifier -> Maybe JsonClassifier
$sel:grokClassifier:Classifier' :: Classifier -> Maybe GrokClassifier
$sel:csvClassifier:Classifier' :: Classifier -> Maybe CsvClassifier
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CsvClassifier
csvClassifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe GrokClassifier
grokClassifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe JsonClassifier
jsonClassifier
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe XMLClassifier
xMLClassifier

instance Prelude.NFData Classifier where
  rnf :: Classifier -> ()
rnf Classifier' {Maybe CsvClassifier
Maybe GrokClassifier
Maybe JsonClassifier
Maybe XMLClassifier
xMLClassifier :: Maybe XMLClassifier
jsonClassifier :: Maybe JsonClassifier
grokClassifier :: Maybe GrokClassifier
csvClassifier :: Maybe CsvClassifier
$sel:xMLClassifier:Classifier' :: Classifier -> Maybe XMLClassifier
$sel:jsonClassifier:Classifier' :: Classifier -> Maybe JsonClassifier
$sel:grokClassifier:Classifier' :: Classifier -> Maybe GrokClassifier
$sel:csvClassifier:Classifier' :: Classifier -> Maybe CsvClassifier
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CsvClassifier
csvClassifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe GrokClassifier
grokClassifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe JsonClassifier
jsonClassifier
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe XMLClassifier
xMLClassifier