{-# 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.IoTFleetWise.Types.NetworkInterface
-- 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.IoTFleetWise.Types.NetworkInterface where

import qualified Amazonka.Core as Core
import qualified Amazonka.Core.Lens.Internal as Lens
import qualified Amazonka.Data as Data
import Amazonka.IoTFleetWise.Types.CanInterface
import Amazonka.IoTFleetWise.Types.NetworkInterfaceType
import Amazonka.IoTFleetWise.Types.ObdInterface
import qualified Amazonka.Prelude as Prelude

-- | Represents a node and its specifications in an in-vehicle communication
-- network. All signal decoders must be associated with a network node.
--
-- To return this information about all the network interfaces specified in
-- a decoder manifest, use the API operation.
--
-- /See:/ 'newNetworkInterface' smart constructor.
data NetworkInterface = NetworkInterface'
  { -- | Information about a network interface specified by the Controller Area
    -- Network (CAN) protocol.
    NetworkInterface -> Maybe CanInterface
canInterface :: Prelude.Maybe CanInterface,
    -- | Information about a network interface specified by the On-board
    -- diagnostic (OBD) II protocol.
    NetworkInterface -> Maybe ObdInterface
obdInterface :: Prelude.Maybe ObdInterface,
    -- | The ID of the network interface.
    NetworkInterface -> Text
interfaceId :: Prelude.Text,
    -- | The network protocol for the vehicle. For example, @CAN_SIGNAL@
    -- specifies a protocol that defines how data is communicated between
    -- electronic control units (ECUs). @OBD_SIGNAL@ specifies a protocol that
    -- defines how self-diagnostic data is communicated between ECUs.
    NetworkInterface -> NetworkInterfaceType
type' :: NetworkInterfaceType
  }
  deriving (NetworkInterface -> NetworkInterface -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: NetworkInterface -> NetworkInterface -> Bool
$c/= :: NetworkInterface -> NetworkInterface -> Bool
== :: NetworkInterface -> NetworkInterface -> Bool
$c== :: NetworkInterface -> NetworkInterface -> Bool
Prelude.Eq, ReadPrec [NetworkInterface]
ReadPrec NetworkInterface
Int -> ReadS NetworkInterface
ReadS [NetworkInterface]
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
readListPrec :: ReadPrec [NetworkInterface]
$creadListPrec :: ReadPrec [NetworkInterface]
readPrec :: ReadPrec NetworkInterface
$creadPrec :: ReadPrec NetworkInterface
readList :: ReadS [NetworkInterface]
$creadList :: ReadS [NetworkInterface]
readsPrec :: Int -> ReadS NetworkInterface
$creadsPrec :: Int -> ReadS NetworkInterface
Prelude.Read, Int -> NetworkInterface -> ShowS
[NetworkInterface] -> ShowS
NetworkInterface -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [NetworkInterface] -> ShowS
$cshowList :: [NetworkInterface] -> ShowS
show :: NetworkInterface -> String
$cshow :: NetworkInterface -> String
showsPrec :: Int -> NetworkInterface -> ShowS
$cshowsPrec :: Int -> NetworkInterface -> ShowS
Prelude.Show, forall x. Rep NetworkInterface x -> NetworkInterface
forall x. NetworkInterface -> Rep NetworkInterface x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cto :: forall x. Rep NetworkInterface x -> NetworkInterface
$cfrom :: forall x. NetworkInterface -> Rep NetworkInterface x
Prelude.Generic)

-- |
-- Create a value of 'NetworkInterface' 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:
--
-- 'canInterface', 'networkInterface_canInterface' - Information about a network interface specified by the Controller Area
-- Network (CAN) protocol.
--
-- 'obdInterface', 'networkInterface_obdInterface' - Information about a network interface specified by the On-board
-- diagnostic (OBD) II protocol.
--
-- 'interfaceId', 'networkInterface_interfaceId' - The ID of the network interface.
--
-- 'type'', 'networkInterface_type' - The network protocol for the vehicle. For example, @CAN_SIGNAL@
-- specifies a protocol that defines how data is communicated between
-- electronic control units (ECUs). @OBD_SIGNAL@ specifies a protocol that
-- defines how self-diagnostic data is communicated between ECUs.
newNetworkInterface ::
  -- | 'interfaceId'
  Prelude.Text ->
  -- | 'type''
  NetworkInterfaceType ->
  NetworkInterface
newNetworkInterface :: Text -> NetworkInterfaceType -> NetworkInterface
newNetworkInterface Text
pInterfaceId_ NetworkInterfaceType
pType_ =
  NetworkInterface'
    { $sel:canInterface:NetworkInterface' :: Maybe CanInterface
canInterface = forall a. Maybe a
Prelude.Nothing,
      $sel:obdInterface:NetworkInterface' :: Maybe ObdInterface
obdInterface = forall a. Maybe a
Prelude.Nothing,
      $sel:interfaceId:NetworkInterface' :: Text
interfaceId = Text
pInterfaceId_,
      $sel:type':NetworkInterface' :: NetworkInterfaceType
type' = NetworkInterfaceType
pType_
    }

-- | Information about a network interface specified by the Controller Area
-- Network (CAN) protocol.
networkInterface_canInterface :: Lens.Lens' NetworkInterface (Prelude.Maybe CanInterface)
networkInterface_canInterface :: Lens' NetworkInterface (Maybe CanInterface)
networkInterface_canInterface = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NetworkInterface' {Maybe CanInterface
canInterface :: Maybe CanInterface
$sel:canInterface:NetworkInterface' :: NetworkInterface -> Maybe CanInterface
canInterface} -> Maybe CanInterface
canInterface) (\s :: NetworkInterface
s@NetworkInterface' {} Maybe CanInterface
a -> NetworkInterface
s {$sel:canInterface:NetworkInterface' :: Maybe CanInterface
canInterface = Maybe CanInterface
a} :: NetworkInterface)

-- | Information about a network interface specified by the On-board
-- diagnostic (OBD) II protocol.
networkInterface_obdInterface :: Lens.Lens' NetworkInterface (Prelude.Maybe ObdInterface)
networkInterface_obdInterface :: Lens' NetworkInterface (Maybe ObdInterface)
networkInterface_obdInterface = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NetworkInterface' {Maybe ObdInterface
obdInterface :: Maybe ObdInterface
$sel:obdInterface:NetworkInterface' :: NetworkInterface -> Maybe ObdInterface
obdInterface} -> Maybe ObdInterface
obdInterface) (\s :: NetworkInterface
s@NetworkInterface' {} Maybe ObdInterface
a -> NetworkInterface
s {$sel:obdInterface:NetworkInterface' :: Maybe ObdInterface
obdInterface = Maybe ObdInterface
a} :: NetworkInterface)

-- | The ID of the network interface.
networkInterface_interfaceId :: Lens.Lens' NetworkInterface Prelude.Text
networkInterface_interfaceId :: Lens' NetworkInterface Text
networkInterface_interfaceId = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NetworkInterface' {Text
interfaceId :: Text
$sel:interfaceId:NetworkInterface' :: NetworkInterface -> Text
interfaceId} -> Text
interfaceId) (\s :: NetworkInterface
s@NetworkInterface' {} Text
a -> NetworkInterface
s {$sel:interfaceId:NetworkInterface' :: Text
interfaceId = Text
a} :: NetworkInterface)

-- | The network protocol for the vehicle. For example, @CAN_SIGNAL@
-- specifies a protocol that defines how data is communicated between
-- electronic control units (ECUs). @OBD_SIGNAL@ specifies a protocol that
-- defines how self-diagnostic data is communicated between ECUs.
networkInterface_type :: Lens.Lens' NetworkInterface NetworkInterfaceType
networkInterface_type :: Lens' NetworkInterface NetworkInterfaceType
networkInterface_type = forall s a b t. (s -> a) -> (s -> b -> t) -> Lens s t a b
Lens.lens (\NetworkInterface' {NetworkInterfaceType
type' :: NetworkInterfaceType
$sel:type':NetworkInterface' :: NetworkInterface -> NetworkInterfaceType
type'} -> NetworkInterfaceType
type') (\s :: NetworkInterface
s@NetworkInterface' {} NetworkInterfaceType
a -> NetworkInterface
s {$sel:type':NetworkInterface' :: NetworkInterfaceType
type' = NetworkInterfaceType
a} :: NetworkInterface)

instance Data.FromJSON NetworkInterface where
  parseJSON :: Value -> Parser NetworkInterface
parseJSON =
    forall a. String -> (Object -> Parser a) -> Value -> Parser a
Data.withObject
      String
"NetworkInterface"
      ( \Object
x ->
          Maybe CanInterface
-> Maybe ObdInterface
-> Text
-> NetworkInterfaceType
-> NetworkInterface
NetworkInterface'
            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
"canInterface")
            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
"obdInterface")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"interfaceId")
            forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
Prelude.<*> (Object
x forall a. FromJSON a => Object -> Key -> Parser a
Data..: Key
"type")
      )

instance Prelude.Hashable NetworkInterface where
  hashWithSalt :: Int -> NetworkInterface -> Int
hashWithSalt Int
_salt NetworkInterface' {Maybe CanInterface
Maybe ObdInterface
Text
NetworkInterfaceType
type' :: NetworkInterfaceType
interfaceId :: Text
obdInterface :: Maybe ObdInterface
canInterface :: Maybe CanInterface
$sel:type':NetworkInterface' :: NetworkInterface -> NetworkInterfaceType
$sel:interfaceId:NetworkInterface' :: NetworkInterface -> Text
$sel:obdInterface:NetworkInterface' :: NetworkInterface -> Maybe ObdInterface
$sel:canInterface:NetworkInterface' :: NetworkInterface -> Maybe CanInterface
..} =
    Int
_salt
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe CanInterface
canInterface
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Maybe ObdInterface
obdInterface
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` Text
interfaceId
      forall a. Hashable a => Int -> a -> Int
`Prelude.hashWithSalt` NetworkInterfaceType
type'

instance Prelude.NFData NetworkInterface where
  rnf :: NetworkInterface -> ()
rnf NetworkInterface' {Maybe CanInterface
Maybe ObdInterface
Text
NetworkInterfaceType
type' :: NetworkInterfaceType
interfaceId :: Text
obdInterface :: Maybe ObdInterface
canInterface :: Maybe CanInterface
$sel:type':NetworkInterface' :: NetworkInterface -> NetworkInterfaceType
$sel:interfaceId:NetworkInterface' :: NetworkInterface -> Text
$sel:obdInterface:NetworkInterface' :: NetworkInterface -> Maybe ObdInterface
$sel:canInterface:NetworkInterface' :: NetworkInterface -> Maybe CanInterface
..} =
    forall a. NFData a => a -> ()
Prelude.rnf Maybe CanInterface
canInterface
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Maybe ObdInterface
obdInterface
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf Text
interfaceId
      seq :: forall a b. a -> b -> b
`Prelude.seq` forall a. NFData a => a -> ()
Prelude.rnf NetworkInterfaceType
type'

instance Data.ToJSON NetworkInterface where
  toJSON :: NetworkInterface -> Value
toJSON NetworkInterface' {Maybe CanInterface
Maybe ObdInterface
Text
NetworkInterfaceType
type' :: NetworkInterfaceType
interfaceId :: Text
obdInterface :: Maybe ObdInterface
canInterface :: Maybe CanInterface
$sel:type':NetworkInterface' :: NetworkInterface -> NetworkInterfaceType
$sel:interfaceId:NetworkInterface' :: NetworkInterface -> Text
$sel:obdInterface:NetworkInterface' :: NetworkInterface -> Maybe ObdInterface
$sel:canInterface:NetworkInterface' :: NetworkInterface -> Maybe CanInterface
..} =
    [Pair] -> Value
Data.object
      ( forall a. [Maybe a] -> [a]
Prelude.catMaybes
          [ (Key
"canInterface" 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 CanInterface
canInterface,
            (Key
"obdInterface" 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 ObdInterface
obdInterface,
            forall a. a -> Maybe a
Prelude.Just (Key
"interfaceId" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= Text
interfaceId),
            forall a. a -> Maybe a
Prelude.Just (Key
"type" forall kv v. (KeyValue kv, ToJSON v) => Key -> v -> kv
Data..= NetworkInterfaceType
type')
          ]
      )