{-# LANGUAGE UndecidableInstances #-}

-- | Provides network interface types.
--
-- @since 0.1
module Pythia.Services.NetInterface.Types
  ( -- * Configuration
    NetInterfaceApp (..),

    -- * NetInterface Fields
    NetInterfaceType (..),
    NetInterfaceState (..),
    NetInterface (..),
    NetInterfaces (..),

    -- * Errors
    DeviceNotFound (..),

    -- * Optics
    _NetInterfaceAppNmCli,
    _NetInterfaceAppIp,
    _Ethernet,
    _Wifi,
    _Wifi_P2P,
    _Loopback,
    _Tun,
    _NetStateUp,
    _NetStateDown,
    _NetStateUnknown,
  )
where

import Data.Text qualified as T
import Pythia.Prelude
import Pythia.Services.Types.Network
  ( Device,
    IpAddresses,
    IpType (Ipv4, Ipv6),
  )

-- $setup
-- >>> import Pythia.Prelude

-- | Determines how we should query the system for interface state information.
--
-- @since 0.1
type NetInterfaceApp :: Type
data NetInterfaceApp
  = -- | Uses the Network Manager cli utility.
    --
    -- @since 0.1
    NetInterfaceAppNmCli
  | -- | Uses the \'ip\' utility.
    --
    -- @since 0.1
    NetInterfaceAppIp
  deriving stock
    ( -- | @since 0.1
      NetInterfaceApp
NetInterfaceApp -> NetInterfaceApp -> Bounded NetInterfaceApp
forall a. a -> a -> Bounded a
$cminBound :: NetInterfaceApp
minBound :: NetInterfaceApp
$cmaxBound :: NetInterfaceApp
maxBound :: NetInterfaceApp
Bounded,
      -- | @since 0.1
      Int -> NetInterfaceApp
NetInterfaceApp -> Int
NetInterfaceApp -> [NetInterfaceApp]
NetInterfaceApp -> NetInterfaceApp
NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
NetInterfaceApp
-> NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
(NetInterfaceApp -> NetInterfaceApp)
-> (NetInterfaceApp -> NetInterfaceApp)
-> (Int -> NetInterfaceApp)
-> (NetInterfaceApp -> Int)
-> (NetInterfaceApp -> [NetInterfaceApp])
-> (NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp])
-> (NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp])
-> (NetInterfaceApp
    -> NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp])
-> Enum NetInterfaceApp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: NetInterfaceApp -> NetInterfaceApp
succ :: NetInterfaceApp -> NetInterfaceApp
$cpred :: NetInterfaceApp -> NetInterfaceApp
pred :: NetInterfaceApp -> NetInterfaceApp
$ctoEnum :: Int -> NetInterfaceApp
toEnum :: Int -> NetInterfaceApp
$cfromEnum :: NetInterfaceApp -> Int
fromEnum :: NetInterfaceApp -> Int
$cenumFrom :: NetInterfaceApp -> [NetInterfaceApp]
enumFrom :: NetInterfaceApp -> [NetInterfaceApp]
$cenumFromThen :: NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
enumFromThen :: NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
$cenumFromTo :: NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
enumFromTo :: NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
$cenumFromThenTo :: NetInterfaceApp
-> NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
enumFromThenTo :: NetInterfaceApp
-> NetInterfaceApp -> NetInterfaceApp -> [NetInterfaceApp]
Enum,
      -- | @since 0.1
      NetInterfaceApp -> NetInterfaceApp -> Bool
(NetInterfaceApp -> NetInterfaceApp -> Bool)
-> (NetInterfaceApp -> NetInterfaceApp -> Bool)
-> Eq NetInterfaceApp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NetInterfaceApp -> NetInterfaceApp -> Bool
== :: NetInterfaceApp -> NetInterfaceApp -> Bool
$c/= :: NetInterfaceApp -> NetInterfaceApp -> Bool
/= :: NetInterfaceApp -> NetInterfaceApp -> Bool
Eq,
      -- | @since 0.1
      (forall x. NetInterfaceApp -> Rep NetInterfaceApp x)
-> (forall x. Rep NetInterfaceApp x -> NetInterfaceApp)
-> Generic NetInterfaceApp
forall x. Rep NetInterfaceApp x -> NetInterfaceApp
forall x. NetInterfaceApp -> Rep NetInterfaceApp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NetInterfaceApp -> Rep NetInterfaceApp x
from :: forall x. NetInterfaceApp -> Rep NetInterfaceApp x
$cto :: forall x. Rep NetInterfaceApp x -> NetInterfaceApp
to :: forall x. Rep NetInterfaceApp x -> NetInterfaceApp
Generic,
      -- | @since 0.1
      Eq NetInterfaceApp
Eq NetInterfaceApp =>
(NetInterfaceApp -> NetInterfaceApp -> Ordering)
-> (NetInterfaceApp -> NetInterfaceApp -> Bool)
-> (NetInterfaceApp -> NetInterfaceApp -> Bool)
-> (NetInterfaceApp -> NetInterfaceApp -> Bool)
-> (NetInterfaceApp -> NetInterfaceApp -> Bool)
-> (NetInterfaceApp -> NetInterfaceApp -> NetInterfaceApp)
-> (NetInterfaceApp -> NetInterfaceApp -> NetInterfaceApp)
-> Ord NetInterfaceApp
NetInterfaceApp -> NetInterfaceApp -> Bool
NetInterfaceApp -> NetInterfaceApp -> Ordering
NetInterfaceApp -> NetInterfaceApp -> NetInterfaceApp
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NetInterfaceApp -> NetInterfaceApp -> Ordering
compare :: NetInterfaceApp -> NetInterfaceApp -> Ordering
$c< :: NetInterfaceApp -> NetInterfaceApp -> Bool
< :: NetInterfaceApp -> NetInterfaceApp -> Bool
$c<= :: NetInterfaceApp -> NetInterfaceApp -> Bool
<= :: NetInterfaceApp -> NetInterfaceApp -> Bool
$c> :: NetInterfaceApp -> NetInterfaceApp -> Bool
> :: NetInterfaceApp -> NetInterfaceApp -> Bool
$c>= :: NetInterfaceApp -> NetInterfaceApp -> Bool
>= :: NetInterfaceApp -> NetInterfaceApp -> Bool
$cmax :: NetInterfaceApp -> NetInterfaceApp -> NetInterfaceApp
max :: NetInterfaceApp -> NetInterfaceApp -> NetInterfaceApp
$cmin :: NetInterfaceApp -> NetInterfaceApp -> NetInterfaceApp
min :: NetInterfaceApp -> NetInterfaceApp -> NetInterfaceApp
Ord,
      -- | @since 0.1
      Int -> NetInterfaceApp -> ShowS
[NetInterfaceApp] -> ShowS
NetInterfaceApp -> [Char]
(Int -> NetInterfaceApp -> ShowS)
-> (NetInterfaceApp -> [Char])
-> ([NetInterfaceApp] -> ShowS)
-> Show NetInterfaceApp
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NetInterfaceApp -> ShowS
showsPrec :: Int -> NetInterfaceApp -> ShowS
$cshow :: NetInterfaceApp -> [Char]
show :: NetInterfaceApp -> [Char]
$cshowList :: [NetInterfaceApp] -> ShowS
showList :: [NetInterfaceApp] -> ShowS
Show
    )
  deriving anyclass
    ( -- | @since 0.1
      NetInterfaceApp -> ()
(NetInterfaceApp -> ()) -> NFData NetInterfaceApp
forall a. (a -> ()) -> NFData a
$crnf :: NetInterfaceApp -> ()
rnf :: NetInterfaceApp -> ()
NFData
    )

-- | @since 0.1
_NetInterfaceAppIp :: Prism' NetInterfaceApp ()
_NetInterfaceAppIp :: Prism' NetInterfaceApp ()
_NetInterfaceAppIp =
  (() -> NetInterfaceApp)
-> (NetInterfaceApp -> Either NetInterfaceApp ())
-> Prism' NetInterfaceApp ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceApp -> () -> NetInterfaceApp
forall a b. a -> b -> a
const NetInterfaceApp
NetInterfaceAppIp)
    ( \NetInterfaceApp
x -> case NetInterfaceApp
x of
        NetInterfaceApp
NetInterfaceAppIp -> () -> Either NetInterfaceApp ()
forall a b. b -> Either a b
Right ()
        NetInterfaceApp
_ -> NetInterfaceApp -> Either NetInterfaceApp ()
forall a b. a -> Either a b
Left NetInterfaceApp
x
    )
{-# INLINE _NetInterfaceAppIp #-}

-- | @since 0.1
_NetInterfaceAppNmCli :: Prism' NetInterfaceApp ()
_NetInterfaceAppNmCli :: Prism' NetInterfaceApp ()
_NetInterfaceAppNmCli =
  (() -> NetInterfaceApp)
-> (NetInterfaceApp -> Either NetInterfaceApp ())
-> Prism' NetInterfaceApp ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceApp -> () -> NetInterfaceApp
forall a b. a -> b -> a
const NetInterfaceApp
NetInterfaceAppNmCli)
    ( \NetInterfaceApp
x -> case NetInterfaceApp
x of
        NetInterfaceApp
NetInterfaceAppNmCli -> () -> Either NetInterfaceApp ()
forall a b. b -> Either a b
Right ()
        NetInterfaceApp
_ -> NetInterfaceApp -> Either NetInterfaceApp ()
forall a b. a -> Either a b
Left NetInterfaceApp
x
    )
{-# INLINE _NetInterfaceAppNmCli #-}

-- | Various connection types.
--
-- @since 0.1
type NetInterfaceType :: Type
data NetInterfaceType
  = -- | @since 0.1
    Ethernet
  | -- | @since 0.1
    Wifi
  | -- | @since 0.1
    Wifi_P2P
  | -- | @since 0.1
    Loopback
  | -- | @since 0.1
    Tun
  deriving stock
    ( -- | @since 0.1
      NetInterfaceType -> NetInterfaceType -> Bool
(NetInterfaceType -> NetInterfaceType -> Bool)
-> (NetInterfaceType -> NetInterfaceType -> Bool)
-> Eq NetInterfaceType
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NetInterfaceType -> NetInterfaceType -> Bool
== :: NetInterfaceType -> NetInterfaceType -> Bool
$c/= :: NetInterfaceType -> NetInterfaceType -> Bool
/= :: NetInterfaceType -> NetInterfaceType -> Bool
Eq,
      -- | @since 0.1
      (forall x. NetInterfaceType -> Rep NetInterfaceType x)
-> (forall x. Rep NetInterfaceType x -> NetInterfaceType)
-> Generic NetInterfaceType
forall x. Rep NetInterfaceType x -> NetInterfaceType
forall x. NetInterfaceType -> Rep NetInterfaceType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NetInterfaceType -> Rep NetInterfaceType x
from :: forall x. NetInterfaceType -> Rep NetInterfaceType x
$cto :: forall x. Rep NetInterfaceType x -> NetInterfaceType
to :: forall x. Rep NetInterfaceType x -> NetInterfaceType
Generic,
      -- | @since 0.1
      Eq NetInterfaceType
Eq NetInterfaceType =>
(NetInterfaceType -> NetInterfaceType -> Ordering)
-> (NetInterfaceType -> NetInterfaceType -> Bool)
-> (NetInterfaceType -> NetInterfaceType -> Bool)
-> (NetInterfaceType -> NetInterfaceType -> Bool)
-> (NetInterfaceType -> NetInterfaceType -> Bool)
-> (NetInterfaceType -> NetInterfaceType -> NetInterfaceType)
-> (NetInterfaceType -> NetInterfaceType -> NetInterfaceType)
-> Ord NetInterfaceType
NetInterfaceType -> NetInterfaceType -> Bool
NetInterfaceType -> NetInterfaceType -> Ordering
NetInterfaceType -> NetInterfaceType -> NetInterfaceType
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NetInterfaceType -> NetInterfaceType -> Ordering
compare :: NetInterfaceType -> NetInterfaceType -> Ordering
$c< :: NetInterfaceType -> NetInterfaceType -> Bool
< :: NetInterfaceType -> NetInterfaceType -> Bool
$c<= :: NetInterfaceType -> NetInterfaceType -> Bool
<= :: NetInterfaceType -> NetInterfaceType -> Bool
$c> :: NetInterfaceType -> NetInterfaceType -> Bool
> :: NetInterfaceType -> NetInterfaceType -> Bool
$c>= :: NetInterfaceType -> NetInterfaceType -> Bool
>= :: NetInterfaceType -> NetInterfaceType -> Bool
$cmax :: NetInterfaceType -> NetInterfaceType -> NetInterfaceType
max :: NetInterfaceType -> NetInterfaceType -> NetInterfaceType
$cmin :: NetInterfaceType -> NetInterfaceType -> NetInterfaceType
min :: NetInterfaceType -> NetInterfaceType -> NetInterfaceType
Ord,
      -- | @since 0.1
      Int -> NetInterfaceType -> ShowS
[NetInterfaceType] -> ShowS
NetInterfaceType -> [Char]
(Int -> NetInterfaceType -> ShowS)
-> (NetInterfaceType -> [Char])
-> ([NetInterfaceType] -> ShowS)
-> Show NetInterfaceType
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NetInterfaceType -> ShowS
showsPrec :: Int -> NetInterfaceType -> ShowS
$cshow :: NetInterfaceType -> [Char]
show :: NetInterfaceType -> [Char]
$cshowList :: [NetInterfaceType] -> ShowS
showList :: [NetInterfaceType] -> ShowS
Show
    )
  deriving anyclass
    ( -- | @since 0.1
      NetInterfaceType -> ()
(NetInterfaceType -> ()) -> NFData NetInterfaceType
forall a. (a -> ()) -> NFData a
$crnf :: NetInterfaceType -> ()
rnf :: NetInterfaceType -> ()
NFData
    )

-- | @since 0.1
_Ethernet :: Prism' NetInterfaceType ()
_Ethernet :: Prism' NetInterfaceType ()
_Ethernet =
  (() -> NetInterfaceType)
-> (NetInterfaceType -> Either NetInterfaceType ())
-> Prism' NetInterfaceType ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceType -> () -> NetInterfaceType
forall a b. a -> b -> a
const NetInterfaceType
Ethernet)
    ( \NetInterfaceType
x -> case NetInterfaceType
x of
        NetInterfaceType
Ethernet -> () -> Either NetInterfaceType ()
forall a b. b -> Either a b
Right ()
        NetInterfaceType
_ -> NetInterfaceType -> Either NetInterfaceType ()
forall a b. a -> Either a b
Left NetInterfaceType
x
    )
{-# INLINE _Ethernet #-}

-- | @since 0.1
_Wifi :: Prism' NetInterfaceType ()
_Wifi :: Prism' NetInterfaceType ()
_Wifi =
  (() -> NetInterfaceType)
-> (NetInterfaceType -> Either NetInterfaceType ())
-> Prism' NetInterfaceType ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceType -> () -> NetInterfaceType
forall a b. a -> b -> a
const NetInterfaceType
Wifi)
    ( \NetInterfaceType
x -> case NetInterfaceType
x of
        NetInterfaceType
Wifi -> () -> Either NetInterfaceType ()
forall a b. b -> Either a b
Right ()
        NetInterfaceType
_ -> NetInterfaceType -> Either NetInterfaceType ()
forall a b. a -> Either a b
Left NetInterfaceType
x
    )
{-# INLINE _Wifi #-}

-- | @since 0.1
_Wifi_P2P :: Prism' NetInterfaceType ()
_Wifi_P2P :: Prism' NetInterfaceType ()
_Wifi_P2P =
  (() -> NetInterfaceType)
-> (NetInterfaceType -> Either NetInterfaceType ())
-> Prism' NetInterfaceType ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceType -> () -> NetInterfaceType
forall a b. a -> b -> a
const NetInterfaceType
Wifi_P2P)
    ( \NetInterfaceType
x -> case NetInterfaceType
x of
        NetInterfaceType
Wifi_P2P -> () -> Either NetInterfaceType ()
forall a b. b -> Either a b
Right ()
        NetInterfaceType
_ -> NetInterfaceType -> Either NetInterfaceType ()
forall a b. a -> Either a b
Left NetInterfaceType
x
    )
{-# INLINE _Wifi_P2P #-}

-- | @since 0.1
_Loopback :: Prism' NetInterfaceType ()
_Loopback :: Prism' NetInterfaceType ()
_Loopback =
  (() -> NetInterfaceType)
-> (NetInterfaceType -> Either NetInterfaceType ())
-> Prism' NetInterfaceType ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceType -> () -> NetInterfaceType
forall a b. a -> b -> a
const NetInterfaceType
Loopback)
    ( \NetInterfaceType
x -> case NetInterfaceType
x of
        NetInterfaceType
Loopback -> () -> Either NetInterfaceType ()
forall a b. b -> Either a b
Right ()
        NetInterfaceType
_ -> NetInterfaceType -> Either NetInterfaceType ()
forall a b. a -> Either a b
Left NetInterfaceType
x
    )
{-# INLINE _Loopback #-}

-- | @since 0.1
_Tun :: Prism' NetInterfaceType ()
_Tun :: Prism' NetInterfaceType ()
_Tun =
  (() -> NetInterfaceType)
-> (NetInterfaceType -> Either NetInterfaceType ())
-> Prism' NetInterfaceType ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceType -> () -> NetInterfaceType
forall a b. a -> b -> a
const NetInterfaceType
Tun)
    ( \NetInterfaceType
x -> case NetInterfaceType
x of
        NetInterfaceType
Tun -> () -> Either NetInterfaceType ()
forall a b. b -> Either a b
Right ()
        NetInterfaceType
_ -> NetInterfaceType -> Either NetInterfaceType ()
forall a b. a -> Either a b
Left NetInterfaceType
x
    )
{-# INLINE _Tun #-}

instance Display NetInterfaceType where
  displayBuilder :: NetInterfaceType -> Builder
displayBuilder = [Char] -> Builder
forall a. Display a => a -> Builder
displayBuilder ([Char] -> Builder)
-> (NetInterfaceType -> [Char]) -> NetInterfaceType -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NetInterfaceType -> [Char]
forall a. Show a => a -> [Char]
show

-- | Various connection states.
--
-- @since 0.1
type NetInterfaceState :: Type
data NetInterfaceState
  = -- | @since 0.1
    NetStateUp
  | -- | @since 0.1
    NetStateDown
  | -- | @since 0.1
    NetStateUnknown Text
  deriving stock
    ( -- | @since 0.1
      NetInterfaceState -> NetInterfaceState -> Bool
(NetInterfaceState -> NetInterfaceState -> Bool)
-> (NetInterfaceState -> NetInterfaceState -> Bool)
-> Eq NetInterfaceState
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NetInterfaceState -> NetInterfaceState -> Bool
== :: NetInterfaceState -> NetInterfaceState -> Bool
$c/= :: NetInterfaceState -> NetInterfaceState -> Bool
/= :: NetInterfaceState -> NetInterfaceState -> Bool
Eq,
      -- | @since 0.1
      (forall x. NetInterfaceState -> Rep NetInterfaceState x)
-> (forall x. Rep NetInterfaceState x -> NetInterfaceState)
-> Generic NetInterfaceState
forall x. Rep NetInterfaceState x -> NetInterfaceState
forall x. NetInterfaceState -> Rep NetInterfaceState x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NetInterfaceState -> Rep NetInterfaceState x
from :: forall x. NetInterfaceState -> Rep NetInterfaceState x
$cto :: forall x. Rep NetInterfaceState x -> NetInterfaceState
to :: forall x. Rep NetInterfaceState x -> NetInterfaceState
Generic,
      -- | @since 0.1
      Eq NetInterfaceState
Eq NetInterfaceState =>
(NetInterfaceState -> NetInterfaceState -> Ordering)
-> (NetInterfaceState -> NetInterfaceState -> Bool)
-> (NetInterfaceState -> NetInterfaceState -> Bool)
-> (NetInterfaceState -> NetInterfaceState -> Bool)
-> (NetInterfaceState -> NetInterfaceState -> Bool)
-> (NetInterfaceState -> NetInterfaceState -> NetInterfaceState)
-> (NetInterfaceState -> NetInterfaceState -> NetInterfaceState)
-> Ord NetInterfaceState
NetInterfaceState -> NetInterfaceState -> Bool
NetInterfaceState -> NetInterfaceState -> Ordering
NetInterfaceState -> NetInterfaceState -> NetInterfaceState
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NetInterfaceState -> NetInterfaceState -> Ordering
compare :: NetInterfaceState -> NetInterfaceState -> Ordering
$c< :: NetInterfaceState -> NetInterfaceState -> Bool
< :: NetInterfaceState -> NetInterfaceState -> Bool
$c<= :: NetInterfaceState -> NetInterfaceState -> Bool
<= :: NetInterfaceState -> NetInterfaceState -> Bool
$c> :: NetInterfaceState -> NetInterfaceState -> Bool
> :: NetInterfaceState -> NetInterfaceState -> Bool
$c>= :: NetInterfaceState -> NetInterfaceState -> Bool
>= :: NetInterfaceState -> NetInterfaceState -> Bool
$cmax :: NetInterfaceState -> NetInterfaceState -> NetInterfaceState
max :: NetInterfaceState -> NetInterfaceState -> NetInterfaceState
$cmin :: NetInterfaceState -> NetInterfaceState -> NetInterfaceState
min :: NetInterfaceState -> NetInterfaceState -> NetInterfaceState
Ord,
      -- | @since 0.1
      Int -> NetInterfaceState -> ShowS
[NetInterfaceState] -> ShowS
NetInterfaceState -> [Char]
(Int -> NetInterfaceState -> ShowS)
-> (NetInterfaceState -> [Char])
-> ([NetInterfaceState] -> ShowS)
-> Show NetInterfaceState
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NetInterfaceState -> ShowS
showsPrec :: Int -> NetInterfaceState -> ShowS
$cshow :: NetInterfaceState -> [Char]
show :: NetInterfaceState -> [Char]
$cshowList :: [NetInterfaceState] -> ShowS
showList :: [NetInterfaceState] -> ShowS
Show
    )
  deriving anyclass
    ( -- | @since 0.1
      NetInterfaceState -> ()
(NetInterfaceState -> ()) -> NFData NetInterfaceState
forall a. (a -> ()) -> NFData a
$crnf :: NetInterfaceState -> ()
rnf :: NetInterfaceState -> ()
NFData
    )

-- | @since 0.1
_NetStateUp :: Prism' NetInterfaceState ()
_NetStateUp :: Prism' NetInterfaceState ()
_NetStateUp =
  (() -> NetInterfaceState)
-> (NetInterfaceState -> Either NetInterfaceState ())
-> Prism' NetInterfaceState ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceState -> () -> NetInterfaceState
forall a b. a -> b -> a
const NetInterfaceState
NetStateUp)
    ( \NetInterfaceState
x -> case NetInterfaceState
x of
        NetInterfaceState
NetStateUp -> () -> Either NetInterfaceState ()
forall a b. b -> Either a b
Right ()
        NetInterfaceState
_ -> NetInterfaceState -> Either NetInterfaceState ()
forall a b. a -> Either a b
Left NetInterfaceState
x
    )
{-# INLINE _NetStateUp #-}

-- | @since 0.1
_NetStateDown :: Prism' NetInterfaceState ()
_NetStateDown :: Prism' NetInterfaceState ()
_NetStateDown =
  (() -> NetInterfaceState)
-> (NetInterfaceState -> Either NetInterfaceState ())
-> Prism' NetInterfaceState ()
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    (NetInterfaceState -> () -> NetInterfaceState
forall a b. a -> b -> a
const NetInterfaceState
NetStateDown)
    ( \NetInterfaceState
x -> case NetInterfaceState
x of
        NetInterfaceState
NetStateDown -> () -> Either NetInterfaceState ()
forall a b. b -> Either a b
Right ()
        NetInterfaceState
_ -> NetInterfaceState -> Either NetInterfaceState ()
forall a b. a -> Either a b
Left NetInterfaceState
x
    )
{-# INLINE _NetStateDown #-}

-- | @since 0.1
_NetStateUnknown :: Prism' NetInterfaceState Text
_NetStateUnknown :: Prism' NetInterfaceState Text
_NetStateUnknown =
  (Text -> NetInterfaceState)
-> (NetInterfaceState -> Either NetInterfaceState Text)
-> Prism' NetInterfaceState Text
forall b t s a. (b -> t) -> (s -> Either t a) -> Prism s t a b
prism
    Text -> NetInterfaceState
NetStateUnknown
    ( \NetInterfaceState
x -> case NetInterfaceState
x of
        NetStateUnknown Text
t -> Text -> Either NetInterfaceState Text
forall a b. b -> Either a b
Right Text
t
        NetInterfaceState
_ -> NetInterfaceState -> Either NetInterfaceState Text
forall a b. a -> Either a b
Left NetInterfaceState
x
    )
{-# INLINE _NetStateUnknown #-}

instance Display NetInterfaceState where
  displayBuilder :: NetInterfaceState -> Builder
displayBuilder NetInterfaceState
NetStateUp = Builder
"Up"
  displayBuilder NetInterfaceState
NetStateDown = Builder
"Down"
  displayBuilder (NetStateUnknown Text
t) = Builder
"Unknown: " Builder -> Builder -> Builder
forall a. Semigroup a => a -> a -> a
<> Text -> Builder
forall a. Display a => a -> Builder
displayBuilder Text
t

-- | Full connection data.
--
-- @since 0.1
type NetInterface :: Type
data NetInterface = MkNetInterface
  { -- | @since 0.1
    NetInterface -> Device
device :: Device,
    -- | @since 0.1
    NetInterface -> Maybe NetInterfaceType
ntype :: Maybe NetInterfaceType,
    -- | @since 0.1
    NetInterface -> NetInterfaceState
state :: NetInterfaceState,
    -- | The name of the connection (e.g. Wifi SSID).
    --
    -- @since 0.1
    NetInterface -> Maybe Text
name :: Maybe Text,
    -- | @since 0.1
    NetInterface -> IpAddresses 'Ipv4
ipv4s :: IpAddresses Ipv4,
    -- | @since 0.1
    NetInterface -> IpAddresses 'Ipv6
ipv6s :: IpAddresses Ipv6
  }
  deriving stock
    ( -- | @since 0.1
      NetInterface -> NetInterface -> Bool
(NetInterface -> NetInterface -> Bool)
-> (NetInterface -> NetInterface -> Bool) -> Eq NetInterface
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NetInterface -> NetInterface -> Bool
== :: NetInterface -> NetInterface -> Bool
$c/= :: NetInterface -> NetInterface -> Bool
/= :: NetInterface -> NetInterface -> Bool
Eq,
      -- | @since 0.1
      (forall x. NetInterface -> Rep NetInterface x)
-> (forall x. Rep NetInterface x -> NetInterface)
-> Generic NetInterface
forall x. Rep NetInterface x -> NetInterface
forall x. NetInterface -> Rep NetInterface x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NetInterface -> Rep NetInterface x
from :: forall x. NetInterface -> Rep NetInterface x
$cto :: forall x. Rep NetInterface x -> NetInterface
to :: forall x. Rep NetInterface x -> NetInterface
Generic,
      -- | @since 0.1
      Eq NetInterface
Eq NetInterface =>
(NetInterface -> NetInterface -> Ordering)
-> (NetInterface -> NetInterface -> Bool)
-> (NetInterface -> NetInterface -> Bool)
-> (NetInterface -> NetInterface -> Bool)
-> (NetInterface -> NetInterface -> Bool)
-> (NetInterface -> NetInterface -> NetInterface)
-> (NetInterface -> NetInterface -> NetInterface)
-> Ord NetInterface
NetInterface -> NetInterface -> Bool
NetInterface -> NetInterface -> Ordering
NetInterface -> NetInterface -> NetInterface
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NetInterface -> NetInterface -> Ordering
compare :: NetInterface -> NetInterface -> Ordering
$c< :: NetInterface -> NetInterface -> Bool
< :: NetInterface -> NetInterface -> Bool
$c<= :: NetInterface -> NetInterface -> Bool
<= :: NetInterface -> NetInterface -> Bool
$c> :: NetInterface -> NetInterface -> Bool
> :: NetInterface -> NetInterface -> Bool
$c>= :: NetInterface -> NetInterface -> Bool
>= :: NetInterface -> NetInterface -> Bool
$cmax :: NetInterface -> NetInterface -> NetInterface
max :: NetInterface -> NetInterface -> NetInterface
$cmin :: NetInterface -> NetInterface -> NetInterface
min :: NetInterface -> NetInterface -> NetInterface
Ord,
      -- | @since 0.1
      Int -> NetInterface -> ShowS
[NetInterface] -> ShowS
NetInterface -> [Char]
(Int -> NetInterface -> ShowS)
-> (NetInterface -> [Char])
-> ([NetInterface] -> ShowS)
-> Show NetInterface
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NetInterface -> ShowS
showsPrec :: Int -> NetInterface -> ShowS
$cshow :: NetInterface -> [Char]
show :: NetInterface -> [Char]
$cshowList :: [NetInterface] -> ShowS
showList :: [NetInterface] -> ShowS
Show
    )
  deriving anyclass
    ( -- | @since 0.1
      NetInterface -> ()
(NetInterface -> ()) -> NFData NetInterface
forall a. (a -> ()) -> NFData a
$crnf :: NetInterface -> ()
rnf :: NetInterface -> ()
NFData
    )

-- | @since 0.1
instance
  (k ~ A_Lens, a ~ Device, b ~ Device) =>
  LabelOptic "device" k NetInterface NetInterface a b
  where
  labelOptic :: Optic k NoIx NetInterface NetInterface a b
labelOptic = LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL NetInterface NetInterface a b
 -> Lens NetInterface NetInterface a b)
-> LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) ->
    (Device -> NetInterface) -> f Device -> f NetInterface
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Device
device' -> Device
-> Maybe NetInterfaceType
-> NetInterfaceState
-> Maybe Text
-> IpAddresses 'Ipv4
-> IpAddresses 'Ipv6
-> NetInterface
MkNetInterface Device
device' Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) (a -> f b
f a
Device
_device)
  {-# INLINE labelOptic #-}

-- | @since 0.1
instance
  (k ~ A_Lens, a ~ Maybe NetInterfaceType, b ~ Maybe NetInterfaceType) =>
  LabelOptic "ntype" k NetInterface NetInterface a b
  where
  labelOptic :: Optic k NoIx NetInterface NetInterface a b
labelOptic = LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL NetInterface NetInterface a b
 -> Lens NetInterface NetInterface a b)
-> LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) ->
    (Maybe NetInterfaceType -> NetInterface)
-> f (Maybe NetInterfaceType) -> f NetInterface
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe NetInterfaceType
ntype' -> Device
-> Maybe NetInterfaceType
-> NetInterfaceState
-> Maybe Text
-> IpAddresses 'Ipv4
-> IpAddresses 'Ipv6
-> NetInterface
MkNetInterface Device
_device Maybe NetInterfaceType
ntype' NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) (a -> f b
f a
Maybe NetInterfaceType
_ntype)
  {-# INLINE labelOptic #-}

-- | @since 0.1
instance
  (k ~ A_Lens, a ~ NetInterfaceState, b ~ NetInterfaceState) =>
  LabelOptic "state" k NetInterface NetInterface a b
  where
  labelOptic :: Optic k NoIx NetInterface NetInterface a b
labelOptic = LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL NetInterface NetInterface a b
 -> Lens NetInterface NetInterface a b)
-> LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) ->
    (NetInterfaceState -> NetInterface)
-> f NetInterfaceState -> f NetInterface
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (\NetInterfaceState
state' -> Device
-> Maybe NetInterfaceType
-> NetInterfaceState
-> Maybe Text
-> IpAddresses 'Ipv4
-> IpAddresses 'Ipv6
-> NetInterface
MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
state' Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) (a -> f b
f a
NetInterfaceState
_state)
  {-# INLINE labelOptic #-}

-- | @since 0.1
instance
  (k ~ A_Lens, a ~ Maybe Text, b ~ Maybe Text) =>
  LabelOptic "name" k NetInterface NetInterface a b
  where
  labelOptic :: Optic k NoIx NetInterface NetInterface a b
labelOptic = LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL NetInterface NetInterface a b
 -> Lens NetInterface NetInterface a b)
-> LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) ->
    (Maybe Text -> NetInterface) -> f (Maybe Text) -> f NetInterface
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (\Maybe Text
name' -> Device
-> Maybe NetInterfaceType
-> NetInterfaceState
-> Maybe Text
-> IpAddresses 'Ipv4
-> IpAddresses 'Ipv6
-> NetInterface
MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
name' IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) (a -> f b
f a
Maybe Text
_name)
  {-# INLINE labelOptic #-}

-- | @since 0.1
instance
  (k ~ A_Lens, a ~ IpAddresses Ipv4, b ~ IpAddresses Ipv4) =>
  LabelOptic "ipv4s" k NetInterface NetInterface a b
  where
  labelOptic :: Optic k NoIx NetInterface NetInterface a b
labelOptic = LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL NetInterface NetInterface a b
 -> Lens NetInterface NetInterface a b)
-> LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) ->
    (IpAddresses 'Ipv4 -> NetInterface)
-> f (IpAddresses 'Ipv4) -> f NetInterface
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (\IpAddresses 'Ipv4
ipv4s' -> Device
-> Maybe NetInterfaceType
-> NetInterfaceState
-> Maybe Text
-> IpAddresses 'Ipv4
-> IpAddresses 'Ipv6
-> NetInterface
MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
ipv4s' IpAddresses 'Ipv6
_ipv6s) (a -> f b
f a
IpAddresses 'Ipv4
_ipv4s)
  {-# INLINE labelOptic #-}

-- | @since 0.1
instance
  (k ~ A_Lens, a ~ IpAddresses Ipv6, b ~ IpAddresses Ipv6) =>
  LabelOptic "ipv6s" k NetInterface NetInterface a b
  where
  labelOptic :: Optic k NoIx NetInterface NetInterface a b
labelOptic = LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall s t a b. LensVL s t a b -> Lens s t a b
lensVL (LensVL NetInterface NetInterface a b
 -> Lens NetInterface NetInterface a b)
-> LensVL NetInterface NetInterface a b
-> Lens NetInterface NetInterface a b
forall a b. (a -> b) -> a -> b
$ \a -> f b
f (MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s IpAddresses 'Ipv6
_ipv6s) ->
    (IpAddresses 'Ipv6 -> NetInterface)
-> f (IpAddresses 'Ipv6) -> f NetInterface
forall a b. (a -> b) -> f a -> f b
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap (Device
-> Maybe NetInterfaceType
-> NetInterfaceState
-> Maybe Text
-> IpAddresses 'Ipv4
-> IpAddresses 'Ipv6
-> NetInterface
MkNetInterface Device
_device Maybe NetInterfaceType
_ntype NetInterfaceState
_state Maybe Text
_name IpAddresses 'Ipv4
_ipv4s) (a -> f b
f a
IpAddresses 'Ipv6
_ipv6s)
  {-# INLINE labelOptic #-}

-- | @since 0.1
instance Display NetInterface where
  displayBuilder :: NetInterface -> Builder
displayBuilder NetInterface
netif =
    [Builder] -> Builder
vsep
      [ Builder
device,
        Builder
ctype,
        Builder
state,
        Builder
name,
        Builder
ipv4s,
        Builder
ipv6s
      ]
    where
      device :: Builder
device = Builder
"Device:" Builder -> Builder -> Builder
<+> Device -> Builder
forall a. Display a => a -> Builder
displayBuilder (NetInterface
netif NetInterface -> Optic' A_Lens NoIx NetInterface Device -> Device
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx NetInterface Device
#device)
      ctype :: Builder
ctype = Builder
"Type:" Builder -> Builder -> Builder
<+> Maybe NetInterfaceType -> Builder
forall a. Display a => Maybe a -> Builder
displayMaybe (NetInterface
netif NetInterface
-> Optic' A_Lens NoIx NetInterface (Maybe NetInterfaceType)
-> Maybe NetInterfaceType
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx NetInterface (Maybe NetInterfaceType)
#ntype)
      state :: Builder
state = Builder
"State:" Builder -> Builder -> Builder
<+> NetInterfaceState -> Builder
forall a. Display a => a -> Builder
displayBuilder (NetInterface
netif NetInterface
-> Optic' A_Lens NoIx NetInterface NetInterfaceState
-> NetInterfaceState
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx NetInterface NetInterfaceState
#state)
      name :: Builder
name = Builder
"Name:" Builder -> Builder -> Builder
<+> Maybe Text -> Builder
forall a. Display a => Maybe a -> Builder
displayMaybe (NetInterface
netif NetInterface
-> Optic' A_Lens NoIx NetInterface (Maybe Text) -> Maybe Text
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx NetInterface (Maybe Text)
#name)
      ipv4s :: Builder
ipv4s = Builder
"IPv4:" Builder -> Builder -> Builder
<+> IpAddresses 'Ipv4 -> Builder
forall a. Display a => a -> Builder
displayBuilder (NetInterface
netif NetInterface
-> Optic' A_Lens NoIx NetInterface (IpAddresses 'Ipv4)
-> IpAddresses 'Ipv4
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx NetInterface (IpAddresses 'Ipv4)
#ipv4s)
      ipv6s :: Builder
ipv6s = Builder
"IPv6:" Builder -> Builder -> Builder
<+> IpAddresses 'Ipv6 -> Builder
forall a. Display a => a -> Builder
displayBuilder (NetInterface
netif NetInterface
-> Optic' A_Lens NoIx NetInterface (IpAddresses 'Ipv6)
-> IpAddresses 'Ipv6
forall k s (is :: IxList) a.
Is k A_Getter =>
s -> Optic' k is s a -> a
^. Optic' A_Lens NoIx NetInterface (IpAddresses 'Ipv6)
#ipv6s)

-- | @since 0.1
type NetInterfaces :: Type
newtype NetInterfaces = MkNetInterfaces {NetInterfaces -> [NetInterface]
unNetInterfaces :: [NetInterface]}
  deriving stock
    ( -- | @since 0.1
      NetInterfaces -> NetInterfaces -> Bool
(NetInterfaces -> NetInterfaces -> Bool)
-> (NetInterfaces -> NetInterfaces -> Bool) -> Eq NetInterfaces
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NetInterfaces -> NetInterfaces -> Bool
== :: NetInterfaces -> NetInterfaces -> Bool
$c/= :: NetInterfaces -> NetInterfaces -> Bool
/= :: NetInterfaces -> NetInterfaces -> Bool
Eq,
      -- | @since 0.1
      (forall x. NetInterfaces -> Rep NetInterfaces x)
-> (forall x. Rep NetInterfaces x -> NetInterfaces)
-> Generic NetInterfaces
forall x. Rep NetInterfaces x -> NetInterfaces
forall x. NetInterfaces -> Rep NetInterfaces x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NetInterfaces -> Rep NetInterfaces x
from :: forall x. NetInterfaces -> Rep NetInterfaces x
$cto :: forall x. Rep NetInterfaces x -> NetInterfaces
to :: forall x. Rep NetInterfaces x -> NetInterfaces
Generic,
      -- | @since 0.1
      Eq NetInterfaces
Eq NetInterfaces =>
(NetInterfaces -> NetInterfaces -> Ordering)
-> (NetInterfaces -> NetInterfaces -> Bool)
-> (NetInterfaces -> NetInterfaces -> Bool)
-> (NetInterfaces -> NetInterfaces -> Bool)
-> (NetInterfaces -> NetInterfaces -> Bool)
-> (NetInterfaces -> NetInterfaces -> NetInterfaces)
-> (NetInterfaces -> NetInterfaces -> NetInterfaces)
-> Ord NetInterfaces
NetInterfaces -> NetInterfaces -> Bool
NetInterfaces -> NetInterfaces -> Ordering
NetInterfaces -> NetInterfaces -> NetInterfaces
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NetInterfaces -> NetInterfaces -> Ordering
compare :: NetInterfaces -> NetInterfaces -> Ordering
$c< :: NetInterfaces -> NetInterfaces -> Bool
< :: NetInterfaces -> NetInterfaces -> Bool
$c<= :: NetInterfaces -> NetInterfaces -> Bool
<= :: NetInterfaces -> NetInterfaces -> Bool
$c> :: NetInterfaces -> NetInterfaces -> Bool
> :: NetInterfaces -> NetInterfaces -> Bool
$c>= :: NetInterfaces -> NetInterfaces -> Bool
>= :: NetInterfaces -> NetInterfaces -> Bool
$cmax :: NetInterfaces -> NetInterfaces -> NetInterfaces
max :: NetInterfaces -> NetInterfaces -> NetInterfaces
$cmin :: NetInterfaces -> NetInterfaces -> NetInterfaces
min :: NetInterfaces -> NetInterfaces -> NetInterfaces
Ord,
      -- | @since 0.1
      Int -> NetInterfaces -> ShowS
[NetInterfaces] -> ShowS
NetInterfaces -> [Char]
(Int -> NetInterfaces -> ShowS)
-> (NetInterfaces -> [Char])
-> ([NetInterfaces] -> ShowS)
-> Show NetInterfaces
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NetInterfaces -> ShowS
showsPrec :: Int -> NetInterfaces -> ShowS
$cshow :: NetInterfaces -> [Char]
show :: NetInterfaces -> [Char]
$cshowList :: [NetInterfaces] -> ShowS
showList :: [NetInterfaces] -> ShowS
Show
    )
  deriving anyclass
    ( -- | @since 0.1
      NetInterfaces -> ()
(NetInterfaces -> ()) -> NFData NetInterfaces
forall a. (a -> ()) -> NFData a
$crnf :: NetInterfaces -> ()
rnf :: NetInterfaces -> ()
NFData
    )

-- | @since 0.1
instance Display NetInterfaces where
  displayBuilder :: NetInterfaces -> Builder
displayBuilder = [Builder] -> Builder
vsep ([Builder] -> Builder)
-> (NetInterfaces -> [Builder]) -> NetInterfaces -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Builder -> [Builder] -> [Builder]
punctuate Builder
"\n" ([Builder] -> [Builder])
-> (NetInterfaces -> [Builder]) -> NetInterfaces -> [Builder]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (NetInterface -> Builder) -> [NetInterface] -> [Builder]
forall a b. (a -> b) -> [a] -> [b]
forall (f :: Type -> Type) a b. Functor f => (a -> b) -> f a -> f b
fmap NetInterface -> Builder
forall a. Display a => a -> Builder
displayBuilder ([NetInterface] -> [Builder])
-> (NetInterfaces -> [NetInterface]) -> NetInterfaces -> [Builder]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Optic' A_Lens NoIx NetInterfaces [NetInterface]
-> NetInterfaces -> [NetInterface]
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Optic' A_Lens NoIx NetInterfaces [NetInterface]
#unNetInterfaces

-- | Exception for when we cannot find a desired device.
--
-- ==== __Examples__
--
-- >>> displayException $ MkDeviceNotFound "bad device"
-- "Device not found: bad device"
--
-- @since 0.1
type DeviceNotFound :: Type
newtype DeviceNotFound = MkDeviceNotFound Device
  deriving stock
    ( -- | @since 0.1
      DeviceNotFound -> DeviceNotFound -> Bool
(DeviceNotFound -> DeviceNotFound -> Bool)
-> (DeviceNotFound -> DeviceNotFound -> Bool) -> Eq DeviceNotFound
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: DeviceNotFound -> DeviceNotFound -> Bool
== :: DeviceNotFound -> DeviceNotFound -> Bool
$c/= :: DeviceNotFound -> DeviceNotFound -> Bool
/= :: DeviceNotFound -> DeviceNotFound -> Bool
Eq,
      -- | @since 0.1
      (forall x. DeviceNotFound -> Rep DeviceNotFound x)
-> (forall x. Rep DeviceNotFound x -> DeviceNotFound)
-> Generic DeviceNotFound
forall x. Rep DeviceNotFound x -> DeviceNotFound
forall x. DeviceNotFound -> Rep DeviceNotFound x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DeviceNotFound -> Rep DeviceNotFound x
from :: forall x. DeviceNotFound -> Rep DeviceNotFound x
$cto :: forall x. Rep DeviceNotFound x -> DeviceNotFound
to :: forall x. Rep DeviceNotFound x -> DeviceNotFound
Generic,
      -- | @since 0.1
      Int -> DeviceNotFound -> ShowS
[DeviceNotFound] -> ShowS
DeviceNotFound -> [Char]
(Int -> DeviceNotFound -> ShowS)
-> (DeviceNotFound -> [Char])
-> ([DeviceNotFound] -> ShowS)
-> Show DeviceNotFound
forall a.
(Int -> a -> ShowS) -> (a -> [Char]) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DeviceNotFound -> ShowS
showsPrec :: Int -> DeviceNotFound -> ShowS
$cshow :: DeviceNotFound -> [Char]
show :: DeviceNotFound -> [Char]
$cshowList :: [DeviceNotFound] -> ShowS
showList :: [DeviceNotFound] -> ShowS
Show
    )
  deriving anyclass
    ( -- | @since 0.1
      DeviceNotFound -> ()
(DeviceNotFound -> ()) -> NFData DeviceNotFound
forall a. (a -> ()) -> NFData a
$crnf :: DeviceNotFound -> ()
rnf :: DeviceNotFound -> ()
NFData
    )

-- | @since 0.1
instance Exception DeviceNotFound where
  displayException :: DeviceNotFound -> [Char]
displayException (MkDeviceNotFound Device
d) =
    ([Char]
"Device not found: " [Char] -> ShowS
forall a. Semigroup a => a -> a -> a
<>)
      ShowS -> (Device -> [Char]) -> Device -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Text -> [Char]
T.unpack
      (Text -> [Char]) -> (Device -> Text) -> Device -> [Char]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Optic' An_Iso NoIx Device Text -> Device -> Text
forall k (is :: IxList) s a.
Is k A_Getter =>
Optic' k is s a -> s -> a
view Optic' An_Iso NoIx Device Text
#unDevice
      (Device -> [Char]) -> Device -> [Char]
forall a b. (a -> b) -> a -> b
$ Device
d