-- PacketClass.hs: OpenPGP (RFC4880) data types
-- Copyright © 2012-2018  Clint Adams
-- This software is released under the terms of the Expat license.
-- (See the LICENSE file).
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE TypeFamilies #-}

module Codec.Encryption.OpenPGP.Types.Internal.PacketClass where

import Codec.Encryption.OpenPGP.Types.Internal.Base
import Codec.Encryption.OpenPGP.Types.Internal.PKITypes
import Codec.Encryption.OpenPGP.Types.Internal.Pkt

import Control.Lens (makeLenses)
import Data.ByteString.Lazy (ByteString)
import qualified Data.ByteString.Lazy as BL
import Data.Data (Data)
import Data.List.NonEmpty (NonEmpty)
import Data.Text (Text)
import Data.Text.Prettyprint.Doc (Pretty(..))
import Data.Typeable (Typeable)
import Data.Word (Word8)

class Packet a where
  data PacketType a :: *
  packetType :: a -> PacketType a
  packetCode :: PacketType a -> Word8
  toPkt :: a -> Pkt
  fromPkt :: Pkt -> a

data PKESK =
  PKESK
    { PKESK -> PacketVersion
_pkeskPacketVersion :: PacketVersion
    , PKESK -> EightOctetKeyId
_pkeskEightOctetKeyId :: EightOctetKeyId
    , PKESK -> PubKeyAlgorithm
_pkeskPubKeyAlgorithm :: PubKeyAlgorithm
    , PKESK -> NonEmpty MPI
_pkeskMPIs :: NonEmpty MPI
    }
  deriving (Typeable PKESK
DataType
Constr
Typeable PKESK =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PKESK -> c PKESK)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PKESK)
-> (PKESK -> Constr)
-> (PKESK -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PKESK))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKESK))
-> ((forall b. Data b => b -> b) -> PKESK -> PKESK)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r)
-> (forall u. (forall d. Data d => d -> u) -> PKESK -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> PKESK -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PKESK -> m PKESK)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PKESK -> m PKESK)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PKESK -> m PKESK)
-> Data PKESK
PKESK -> DataType
PKESK -> Constr
(forall b. Data b => b -> b) -> PKESK -> PKESK
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKESK -> c PKESK
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKESK
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PKESK -> u
forall u. (forall d. Data d => d -> u) -> PKESK -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PKESK -> m PKESK
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKESK -> m PKESK
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKESK
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKESK -> c PKESK
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PKESK)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKESK)
$cPKESK :: Constr
$tPKESK :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PKESK -> m PKESK
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKESK -> m PKESK
gmapMp :: (forall d. Data d => d -> m d) -> PKESK -> m PKESK
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PKESK -> m PKESK
gmapM :: (forall d. Data d => d -> m d) -> PKESK -> m PKESK
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PKESK -> m PKESK
gmapQi :: Int -> (forall d. Data d => d -> u) -> PKESK -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PKESK -> u
gmapQ :: (forall d. Data d => d -> u) -> PKESK -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PKESK -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PKESK -> r
gmapT :: (forall b. Data b => b -> b) -> PKESK -> PKESK
$cgmapT :: (forall b. Data b => b -> b) -> PKESK -> PKESK
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKESK)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PKESK)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PKESK)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PKESK)
dataTypeOf :: PKESK -> DataType
$cdataTypeOf :: PKESK -> DataType
toConstr :: PKESK -> Constr
$ctoConstr :: PKESK -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKESK
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PKESK
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKESK -> c PKESK
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PKESK -> c PKESK
$cp1Data :: Typeable PKESK
Data, PKESK -> PKESK -> Bool
(PKESK -> PKESK -> Bool) -> (PKESK -> PKESK -> Bool) -> Eq PKESK
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PKESK -> PKESK -> Bool
$c/= :: PKESK -> PKESK -> Bool
== :: PKESK -> PKESK -> Bool
$c== :: PKESK -> PKESK -> Bool
Eq, Int -> PKESK -> ShowS
[PKESK] -> ShowS
PKESK -> String
(Int -> PKESK -> ShowS)
-> (PKESK -> String) -> ([PKESK] -> ShowS) -> Show PKESK
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PKESK] -> ShowS
$cshowList :: [PKESK] -> ShowS
show :: PKESK -> String
$cshow :: PKESK -> String
showsPrec :: Int -> PKESK -> ShowS
$cshowsPrec :: Int -> PKESK -> ShowS
Show, Typeable)

instance Packet PKESK where
  data PacketType PKESK = PKESKType
                          deriving (Int -> PacketType PKESK -> ShowS
[PacketType PKESK] -> ShowS
PacketType PKESK -> String
(Int -> PacketType PKESK -> ShowS)
-> (PacketType PKESK -> String)
-> ([PacketType PKESK] -> ShowS)
-> Show (PacketType PKESK)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType PKESK] -> ShowS
$cshowList :: [PacketType PKESK] -> ShowS
show :: PacketType PKESK -> String
$cshow :: PacketType PKESK -> String
showsPrec :: Int -> PacketType PKESK -> ShowS
$cshowsPrec :: Int -> PacketType PKESK -> ShowS
Show, PacketType PKESK -> PacketType PKESK -> Bool
(PacketType PKESK -> PacketType PKESK -> Bool)
-> (PacketType PKESK -> PacketType PKESK -> Bool)
-> Eq (PacketType PKESK)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType PKESK -> PacketType PKESK -> Bool
$c/= :: PacketType PKESK -> PacketType PKESK -> Bool
== :: PacketType PKESK -> PacketType PKESK -> Bool
$c== :: PacketType PKESK -> PacketType PKESK -> Bool
Eq)
  packetType :: PKESK -> PacketType PKESK
packetType _ = PacketType PKESK
PKESKType
  packetCode :: PacketType PKESK -> PacketVersion
packetCode _ = 1
  toPkt :: PKESK -> Pkt
toPkt (PKESK a :: PacketVersion
a b :: EightOctetKeyId
b c :: PubKeyAlgorithm
c d :: NonEmpty MPI
d) = PacketVersion
-> EightOctetKeyId -> PubKeyAlgorithm -> NonEmpty MPI -> Pkt
PKESKPkt PacketVersion
a EightOctetKeyId
b PubKeyAlgorithm
c NonEmpty MPI
d
  fromPkt :: Pkt -> PKESK
fromPkt (PKESKPkt a :: PacketVersion
a b :: EightOctetKeyId
b c :: PubKeyAlgorithm
c d :: NonEmpty MPI
d) = PacketVersion
-> EightOctetKeyId -> PubKeyAlgorithm -> NonEmpty MPI -> PKESK
PKESK PacketVersion
a EightOctetKeyId
b PubKeyAlgorithm
c NonEmpty MPI
d
  fromPkt _ = String -> PKESK
forall a. HasCallStack => String -> a
error "Cannot coerce non-PKESK packet"

instance Pretty PKESK where
  pretty :: PKESK -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (PKESK -> Pkt) -> PKESK -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PKESK -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype Signature =
  Signature -- FIXME?
    { Signature -> SignaturePayload
_signaturePayload :: SignaturePayload
    }
  deriving (Typeable Signature
DataType
Constr
Typeable Signature =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Signature -> c Signature)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Signature)
-> (Signature -> Constr)
-> (Signature -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Signature))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature))
-> ((forall b. Data b => b -> b) -> Signature -> Signature)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Signature -> r)
-> (forall u. (forall d. Data d => d -> u) -> Signature -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Signature -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Signature -> m Signature)
-> Data Signature
Signature -> DataType
Signature -> Constr
(forall b. Data b => b -> b) -> Signature -> Signature
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Signature -> c Signature
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Signature
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Signature -> u
forall u. (forall d. Data d => d -> u) -> Signature -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Signature -> m Signature
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Signature -> m Signature
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Signature
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Signature -> c Signature
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Signature)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature)
$cSignature :: Constr
$tSignature :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Signature -> m Signature
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Signature -> m Signature
gmapMp :: (forall d. Data d => d -> m d) -> Signature -> m Signature
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Signature -> m Signature
gmapM :: (forall d. Data d => d -> m d) -> Signature -> m Signature
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Signature -> m Signature
gmapQi :: Int -> (forall d. Data d => d -> u) -> Signature -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Signature -> u
gmapQ :: (forall d. Data d => d -> u) -> Signature -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Signature -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Signature -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Signature -> r
gmapT :: (forall b. Data b => b -> b) -> Signature -> Signature
$cgmapT :: (forall b. Data b => b -> b) -> Signature -> Signature
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Signature)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Signature)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Signature)
dataTypeOf :: Signature -> DataType
$cdataTypeOf :: Signature -> DataType
toConstr :: Signature -> Constr
$ctoConstr :: Signature -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Signature
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Signature
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Signature -> c Signature
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Signature -> c Signature
$cp1Data :: Typeable Signature
Data, Signature -> Signature -> Bool
(Signature -> Signature -> Bool)
-> (Signature -> Signature -> Bool) -> Eq Signature
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Signature -> Signature -> Bool
$c/= :: Signature -> Signature -> Bool
== :: Signature -> Signature -> Bool
$c== :: Signature -> Signature -> Bool
Eq, Int -> Signature -> ShowS
[Signature] -> ShowS
Signature -> String
(Int -> Signature -> ShowS)
-> (Signature -> String)
-> ([Signature] -> ShowS)
-> Show Signature
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Signature] -> ShowS
$cshowList :: [Signature] -> ShowS
show :: Signature -> String
$cshow :: Signature -> String
showsPrec :: Int -> Signature -> ShowS
$cshowsPrec :: Int -> Signature -> ShowS
Show, Typeable)

instance Packet Signature where
  data PacketType Signature = SignatureType
                              deriving (Int -> PacketType Signature -> ShowS
[PacketType Signature] -> ShowS
PacketType Signature -> String
(Int -> PacketType Signature -> ShowS)
-> (PacketType Signature -> String)
-> ([PacketType Signature] -> ShowS)
-> Show (PacketType Signature)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType Signature] -> ShowS
$cshowList :: [PacketType Signature] -> ShowS
show :: PacketType Signature -> String
$cshow :: PacketType Signature -> String
showsPrec :: Int -> PacketType Signature -> ShowS
$cshowsPrec :: Int -> PacketType Signature -> ShowS
Show, PacketType Signature -> PacketType Signature -> Bool
(PacketType Signature -> PacketType Signature -> Bool)
-> (PacketType Signature -> PacketType Signature -> Bool)
-> Eq (PacketType Signature)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType Signature -> PacketType Signature -> Bool
$c/= :: PacketType Signature -> PacketType Signature -> Bool
== :: PacketType Signature -> PacketType Signature -> Bool
$c== :: PacketType Signature -> PacketType Signature -> Bool
Eq)
  packetType :: Signature -> PacketType Signature
packetType _ = PacketType Signature
SignatureType
  packetCode :: PacketType Signature -> PacketVersion
packetCode _ = 2
  toPkt :: Signature -> Pkt
toPkt (Signature a :: SignaturePayload
a) = SignaturePayload -> Pkt
SignaturePkt SignaturePayload
a
  fromPkt :: Pkt -> Signature
fromPkt (SignaturePkt a :: SignaturePayload
a) = SignaturePayload -> Signature
Signature SignaturePayload
a
  fromPkt _ = String -> Signature
forall a. HasCallStack => String -> a
error "Cannot coerce non-Signature packet"

instance Pretty Signature where
  pretty :: Signature -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (Signature -> Pkt) -> Signature -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Signature -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data SKESK =
  SKESK
    { SKESK -> PacketVersion
_skeskPacketVersion :: PacketVersion
    , SKESK -> SymmetricAlgorithm
_skeskSymmetricAlgorithm :: SymmetricAlgorithm
    , SKESK -> S2K
_skeskS2K :: S2K
    , SKESK -> Maybe ByteString
_skeskESK :: Maybe BL.ByteString
    }
  deriving (Typeable SKESK
DataType
Constr
Typeable SKESK =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SKESK -> c SKESK)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SKESK)
-> (SKESK -> Constr)
-> (SKESK -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SKESK))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKESK))
-> ((forall b. Data b => b -> b) -> SKESK -> SKESK)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r)
-> (forall u. (forall d. Data d => d -> u) -> SKESK -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SKESK -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SKESK -> m SKESK)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SKESK -> m SKESK)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SKESK -> m SKESK)
-> Data SKESK
SKESK -> DataType
SKESK -> Constr
(forall b. Data b => b -> b) -> SKESK -> SKESK
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKESK -> c SKESK
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKESK
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SKESK -> u
forall u. (forall d. Data d => d -> u) -> SKESK -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SKESK -> m SKESK
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKESK -> m SKESK
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKESK
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKESK -> c SKESK
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SKESK)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKESK)
$cSKESK :: Constr
$tSKESK :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SKESK -> m SKESK
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKESK -> m SKESK
gmapMp :: (forall d. Data d => d -> m d) -> SKESK -> m SKESK
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SKESK -> m SKESK
gmapM :: (forall d. Data d => d -> m d) -> SKESK -> m SKESK
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SKESK -> m SKESK
gmapQi :: Int -> (forall d. Data d => d -> u) -> SKESK -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SKESK -> u
gmapQ :: (forall d. Data d => d -> u) -> SKESK -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SKESK -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> SKESK -> r
gmapT :: (forall b. Data b => b -> b) -> SKESK -> SKESK
$cgmapT :: (forall b. Data b => b -> b) -> SKESK -> SKESK
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKESK)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SKESK)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SKESK)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SKESK)
dataTypeOf :: SKESK -> DataType
$cdataTypeOf :: SKESK -> DataType
toConstr :: SKESK -> Constr
$ctoConstr :: SKESK -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKESK
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SKESK
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKESK -> c SKESK
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SKESK -> c SKESK
$cp1Data :: Typeable SKESK
Data, SKESK -> SKESK -> Bool
(SKESK -> SKESK -> Bool) -> (SKESK -> SKESK -> Bool) -> Eq SKESK
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SKESK -> SKESK -> Bool
$c/= :: SKESK -> SKESK -> Bool
== :: SKESK -> SKESK -> Bool
$c== :: SKESK -> SKESK -> Bool
Eq, Int -> SKESK -> ShowS
[SKESK] -> ShowS
SKESK -> String
(Int -> SKESK -> ShowS)
-> (SKESK -> String) -> ([SKESK] -> ShowS) -> Show SKESK
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SKESK] -> ShowS
$cshowList :: [SKESK] -> ShowS
show :: SKESK -> String
$cshow :: SKESK -> String
showsPrec :: Int -> SKESK -> ShowS
$cshowsPrec :: Int -> SKESK -> ShowS
Show, Typeable)

instance Packet SKESK where
  data PacketType SKESK = SKESKType
                          deriving (Int -> PacketType SKESK -> ShowS
[PacketType SKESK] -> ShowS
PacketType SKESK -> String
(Int -> PacketType SKESK -> ShowS)
-> (PacketType SKESK -> String)
-> ([PacketType SKESK] -> ShowS)
-> Show (PacketType SKESK)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType SKESK] -> ShowS
$cshowList :: [PacketType SKESK] -> ShowS
show :: PacketType SKESK -> String
$cshow :: PacketType SKESK -> String
showsPrec :: Int -> PacketType SKESK -> ShowS
$cshowsPrec :: Int -> PacketType SKESK -> ShowS
Show, PacketType SKESK -> PacketType SKESK -> Bool
(PacketType SKESK -> PacketType SKESK -> Bool)
-> (PacketType SKESK -> PacketType SKESK -> Bool)
-> Eq (PacketType SKESK)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType SKESK -> PacketType SKESK -> Bool
$c/= :: PacketType SKESK -> PacketType SKESK -> Bool
== :: PacketType SKESK -> PacketType SKESK -> Bool
$c== :: PacketType SKESK -> PacketType SKESK -> Bool
Eq)
  packetType :: SKESK -> PacketType SKESK
packetType _ = PacketType SKESK
SKESKType
  packetCode :: PacketType SKESK -> PacketVersion
packetCode _ = 3
  toPkt :: SKESK -> Pkt
toPkt (SKESK a :: PacketVersion
a b :: SymmetricAlgorithm
b c :: S2K
c d :: Maybe ByteString
d) = PacketVersion
-> SymmetricAlgorithm -> S2K -> Maybe ByteString -> Pkt
SKESKPkt PacketVersion
a SymmetricAlgorithm
b S2K
c Maybe ByteString
d
  fromPkt :: Pkt -> SKESK
fromPkt (SKESKPkt a :: PacketVersion
a b :: SymmetricAlgorithm
b c :: S2K
c d :: Maybe ByteString
d) = PacketVersion
-> SymmetricAlgorithm -> S2K -> Maybe ByteString -> SKESK
SKESK PacketVersion
a SymmetricAlgorithm
b S2K
c Maybe ByteString
d
  fromPkt _ = String -> SKESK
forall a. HasCallStack => String -> a
error "Cannot coerce non-SKESK packet"

instance Pretty SKESK where
  pretty :: SKESK -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (SKESK -> Pkt) -> SKESK -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SKESK -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data OnePassSignature =
  OnePassSignature
    { OnePassSignature -> PacketVersion
_onePassSignaturePacketVersion :: PacketVersion
    , OnePassSignature -> SigType
_onePassSignatureSigType :: SigType
    , OnePassSignature -> HashAlgorithm
_onePassSignatureHashAlgorithm :: HashAlgorithm
    , OnePassSignature -> PubKeyAlgorithm
_onePassSignaturePubKeyAlgorithm :: PubKeyAlgorithm
    , OnePassSignature -> EightOctetKeyId
_onePassSignatureEightOctetKeyId :: EightOctetKeyId
    , OnePassSignature -> Bool
_onePassSignatureNestedFlag :: NestedFlag
    }
  deriving (Typeable OnePassSignature
DataType
Constr
Typeable OnePassSignature =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OnePassSignature -> c OnePassSignature)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OnePassSignature)
-> (OnePassSignature -> Constr)
-> (OnePassSignature -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OnePassSignature))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OnePassSignature))
-> ((forall b. Data b => b -> b)
    -> OnePassSignature -> OnePassSignature)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> OnePassSignature -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OnePassSignature -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> OnePassSignature -> m OnePassSignature)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OnePassSignature -> m OnePassSignature)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> OnePassSignature -> m OnePassSignature)
-> Data OnePassSignature
OnePassSignature -> DataType
OnePassSignature -> Constr
(forall b. Data b => b -> b)
-> OnePassSignature -> OnePassSignature
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OnePassSignature -> c OnePassSignature
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OnePassSignature
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> OnePassSignature -> u
forall u. (forall d. Data d => d -> u) -> OnePassSignature -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OnePassSignature
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OnePassSignature -> c OnePassSignature
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OnePassSignature)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OnePassSignature)
$cOnePassSignature :: Constr
$tOnePassSignature :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
gmapMp :: (forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
gmapM :: (forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> OnePassSignature -> m OnePassSignature
gmapQi :: Int -> (forall d. Data d => d -> u) -> OnePassSignature -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> OnePassSignature -> u
gmapQ :: (forall d. Data d => d -> u) -> OnePassSignature -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OnePassSignature -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OnePassSignature -> r
gmapT :: (forall b. Data b => b -> b)
-> OnePassSignature -> OnePassSignature
$cgmapT :: (forall b. Data b => b -> b)
-> OnePassSignature -> OnePassSignature
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OnePassSignature)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OnePassSignature)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OnePassSignature)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OnePassSignature)
dataTypeOf :: OnePassSignature -> DataType
$cdataTypeOf :: OnePassSignature -> DataType
toConstr :: OnePassSignature -> Constr
$ctoConstr :: OnePassSignature -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OnePassSignature
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OnePassSignature
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OnePassSignature -> c OnePassSignature
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OnePassSignature -> c OnePassSignature
$cp1Data :: Typeable OnePassSignature
Data, OnePassSignature -> OnePassSignature -> Bool
(OnePassSignature -> OnePassSignature -> Bool)
-> (OnePassSignature -> OnePassSignature -> Bool)
-> Eq OnePassSignature
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OnePassSignature -> OnePassSignature -> Bool
$c/= :: OnePassSignature -> OnePassSignature -> Bool
== :: OnePassSignature -> OnePassSignature -> Bool
$c== :: OnePassSignature -> OnePassSignature -> Bool
Eq, Int -> OnePassSignature -> ShowS
[OnePassSignature] -> ShowS
OnePassSignature -> String
(Int -> OnePassSignature -> ShowS)
-> (OnePassSignature -> String)
-> ([OnePassSignature] -> ShowS)
-> Show OnePassSignature
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OnePassSignature] -> ShowS
$cshowList :: [OnePassSignature] -> ShowS
show :: OnePassSignature -> String
$cshow :: OnePassSignature -> String
showsPrec :: Int -> OnePassSignature -> ShowS
$cshowsPrec :: Int -> OnePassSignature -> ShowS
Show, Typeable)

instance Packet OnePassSignature where
  data PacketType OnePassSignature = OnePassSignatureType
                                     deriving (Int -> PacketType OnePassSignature -> ShowS
[PacketType OnePassSignature] -> ShowS
PacketType OnePassSignature -> String
(Int -> PacketType OnePassSignature -> ShowS)
-> (PacketType OnePassSignature -> String)
-> ([PacketType OnePassSignature] -> ShowS)
-> Show (PacketType OnePassSignature)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType OnePassSignature] -> ShowS
$cshowList :: [PacketType OnePassSignature] -> ShowS
show :: PacketType OnePassSignature -> String
$cshow :: PacketType OnePassSignature -> String
showsPrec :: Int -> PacketType OnePassSignature -> ShowS
$cshowsPrec :: Int -> PacketType OnePassSignature -> ShowS
Show, PacketType OnePassSignature -> PacketType OnePassSignature -> Bool
(PacketType OnePassSignature
 -> PacketType OnePassSignature -> Bool)
-> (PacketType OnePassSignature
    -> PacketType OnePassSignature -> Bool)
-> Eq (PacketType OnePassSignature)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType OnePassSignature -> PacketType OnePassSignature -> Bool
$c/= :: PacketType OnePassSignature -> PacketType OnePassSignature -> Bool
== :: PacketType OnePassSignature -> PacketType OnePassSignature -> Bool
$c== :: PacketType OnePassSignature -> PacketType OnePassSignature -> Bool
Eq)
  packetType :: OnePassSignature -> PacketType OnePassSignature
packetType _ = PacketType OnePassSignature
OnePassSignatureType
  packetCode :: PacketType OnePassSignature -> PacketVersion
packetCode _ = 4
  toPkt :: OnePassSignature -> Pkt
toPkt (OnePassSignature a :: PacketVersion
a b :: SigType
b c :: HashAlgorithm
c d :: PubKeyAlgorithm
d e :: EightOctetKeyId
e f :: Bool
f) = PacketVersion
-> SigType
-> HashAlgorithm
-> PubKeyAlgorithm
-> EightOctetKeyId
-> Bool
-> Pkt
OnePassSignaturePkt PacketVersion
a SigType
b HashAlgorithm
c PubKeyAlgorithm
d EightOctetKeyId
e Bool
f
  fromPkt :: Pkt -> OnePassSignature
fromPkt (OnePassSignaturePkt a :: PacketVersion
a b :: SigType
b c :: HashAlgorithm
c d :: PubKeyAlgorithm
d e :: EightOctetKeyId
e f :: Bool
f) = PacketVersion
-> SigType
-> HashAlgorithm
-> PubKeyAlgorithm
-> EightOctetKeyId
-> Bool
-> OnePassSignature
OnePassSignature PacketVersion
a SigType
b HashAlgorithm
c PubKeyAlgorithm
d EightOctetKeyId
e Bool
f
  fromPkt _ = String -> OnePassSignature
forall a. HasCallStack => String -> a
error "Cannot coerce non-OnePassSignature packet"

instance Pretty OnePassSignature where
  pretty :: OnePassSignature -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (OnePassSignature -> Pkt) -> OnePassSignature -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OnePassSignature -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data SecretKey =
  SecretKey
    { SecretKey -> PKPayload
_secretKeyPKPayload :: PKPayload
    , SecretKey -> SKAddendum
_secretKeySKAddendum :: SKAddendum
    }
  deriving (Typeable SecretKey
DataType
Constr
Typeable SecretKey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SecretKey -> c SecretKey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SecretKey)
-> (SecretKey -> Constr)
-> (SecretKey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SecretKey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SecretKey))
-> ((forall b. Data b => b -> b) -> SecretKey -> SecretKey)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SecretKey -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SecretKey -> r)
-> (forall u. (forall d. Data d => d -> u) -> SecretKey -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SecretKey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey)
-> Data SecretKey
SecretKey -> DataType
SecretKey -> Constr
(forall b. Data b => b -> b) -> SecretKey -> SecretKey
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretKey -> c SecretKey
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretKey
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SecretKey -> u
forall u. (forall d. Data d => d -> u) -> SecretKey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SecretKey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SecretKey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretKey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretKey -> c SecretKey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SecretKey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SecretKey)
$cSecretKey :: Constr
$tSecretKey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
gmapMp :: (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
gmapM :: (forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SecretKey -> m SecretKey
gmapQi :: Int -> (forall d. Data d => d -> u) -> SecretKey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SecretKey -> u
gmapQ :: (forall d. Data d => d -> u) -> SecretKey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SecretKey -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SecretKey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SecretKey -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SecretKey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SecretKey -> r
gmapT :: (forall b. Data b => b -> b) -> SecretKey -> SecretKey
$cgmapT :: (forall b. Data b => b -> b) -> SecretKey -> SecretKey
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SecretKey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SecretKey)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SecretKey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SecretKey)
dataTypeOf :: SecretKey -> DataType
$cdataTypeOf :: SecretKey -> DataType
toConstr :: SecretKey -> Constr
$ctoConstr :: SecretKey -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretKey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretKey
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretKey -> c SecretKey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretKey -> c SecretKey
$cp1Data :: Typeable SecretKey
Data, SecretKey -> SecretKey -> Bool
(SecretKey -> SecretKey -> Bool)
-> (SecretKey -> SecretKey -> Bool) -> Eq SecretKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SecretKey -> SecretKey -> Bool
$c/= :: SecretKey -> SecretKey -> Bool
== :: SecretKey -> SecretKey -> Bool
$c== :: SecretKey -> SecretKey -> Bool
Eq, Int -> SecretKey -> ShowS
[SecretKey] -> ShowS
SecretKey -> String
(Int -> SecretKey -> ShowS)
-> (SecretKey -> String)
-> ([SecretKey] -> ShowS)
-> Show SecretKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SecretKey] -> ShowS
$cshowList :: [SecretKey] -> ShowS
show :: SecretKey -> String
$cshow :: SecretKey -> String
showsPrec :: Int -> SecretKey -> ShowS
$cshowsPrec :: Int -> SecretKey -> ShowS
Show, Typeable)

instance Packet SecretKey where
  data PacketType SecretKey = SecretKeyType
                              deriving (Int -> PacketType SecretKey -> ShowS
[PacketType SecretKey] -> ShowS
PacketType SecretKey -> String
(Int -> PacketType SecretKey -> ShowS)
-> (PacketType SecretKey -> String)
-> ([PacketType SecretKey] -> ShowS)
-> Show (PacketType SecretKey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType SecretKey] -> ShowS
$cshowList :: [PacketType SecretKey] -> ShowS
show :: PacketType SecretKey -> String
$cshow :: PacketType SecretKey -> String
showsPrec :: Int -> PacketType SecretKey -> ShowS
$cshowsPrec :: Int -> PacketType SecretKey -> ShowS
Show, PacketType SecretKey -> PacketType SecretKey -> Bool
(PacketType SecretKey -> PacketType SecretKey -> Bool)
-> (PacketType SecretKey -> PacketType SecretKey -> Bool)
-> Eq (PacketType SecretKey)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType SecretKey -> PacketType SecretKey -> Bool
$c/= :: PacketType SecretKey -> PacketType SecretKey -> Bool
== :: PacketType SecretKey -> PacketType SecretKey -> Bool
$c== :: PacketType SecretKey -> PacketType SecretKey -> Bool
Eq)
  packetType :: SecretKey -> PacketType SecretKey
packetType _ = PacketType SecretKey
SecretKeyType
  packetCode :: PacketType SecretKey -> PacketVersion
packetCode _ = 5
  toPkt :: SecretKey -> Pkt
toPkt (SecretKey a :: PKPayload
a b :: SKAddendum
b) = PKPayload -> SKAddendum -> Pkt
SecretKeyPkt PKPayload
a SKAddendum
b
  fromPkt :: Pkt -> SecretKey
fromPkt (SecretKeyPkt a :: PKPayload
a b :: SKAddendum
b) = PKPayload -> SKAddendum -> SecretKey
SecretKey PKPayload
a SKAddendum
b
  fromPkt _ = String -> SecretKey
forall a. HasCallStack => String -> a
error "Cannot coerce non-SecretKey packet"

instance Pretty SecretKey where
  pretty :: SecretKey -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (SecretKey -> Pkt) -> SecretKey -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SecretKey -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype PublicKey =
  PublicKey
    { PublicKey -> PKPayload
_publicKeyPKPayload :: PKPayload
    }
  deriving (Typeable PublicKey
DataType
Constr
Typeable PublicKey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PublicKey -> c PublicKey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PublicKey)
-> (PublicKey -> Constr)
-> (PublicKey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PublicKey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey))
-> ((forall b. Data b => b -> b) -> PublicKey -> PublicKey)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicKey -> r)
-> (forall u. (forall d. Data d => d -> u) -> PublicKey -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PublicKey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey)
-> Data PublicKey
PublicKey -> DataType
PublicKey -> Constr
(forall b. Data b => b -> b) -> PublicKey -> PublicKey
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicKey -> c PublicKey
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicKey
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PublicKey -> u
forall u. (forall d. Data d => d -> u) -> PublicKey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublicKey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublicKey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicKey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicKey -> c PublicKey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PublicKey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey)
$cPublicKey :: Constr
$tPublicKey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
gmapMp :: (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
gmapM :: (forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PublicKey -> m PublicKey
gmapQi :: Int -> (forall d. Data d => d -> u) -> PublicKey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PublicKey -> u
gmapQ :: (forall d. Data d => d -> u) -> PublicKey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PublicKey -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublicKey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublicKey -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublicKey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublicKey -> r
gmapT :: (forall b. Data b => b -> b) -> PublicKey -> PublicKey
$cgmapT :: (forall b. Data b => b -> b) -> PublicKey -> PublicKey
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PublicKey)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PublicKey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PublicKey)
dataTypeOf :: PublicKey -> DataType
$cdataTypeOf :: PublicKey -> DataType
toConstr :: PublicKey -> Constr
$ctoConstr :: PublicKey -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicKey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicKey
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicKey -> c PublicKey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicKey -> c PublicKey
$cp1Data :: Typeable PublicKey
Data, PublicKey -> PublicKey -> Bool
(PublicKey -> PublicKey -> Bool)
-> (PublicKey -> PublicKey -> Bool) -> Eq PublicKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PublicKey -> PublicKey -> Bool
$c/= :: PublicKey -> PublicKey -> Bool
== :: PublicKey -> PublicKey -> Bool
$c== :: PublicKey -> PublicKey -> Bool
Eq, Int -> PublicKey -> ShowS
[PublicKey] -> ShowS
PublicKey -> String
(Int -> PublicKey -> ShowS)
-> (PublicKey -> String)
-> ([PublicKey] -> ShowS)
-> Show PublicKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PublicKey] -> ShowS
$cshowList :: [PublicKey] -> ShowS
show :: PublicKey -> String
$cshow :: PublicKey -> String
showsPrec :: Int -> PublicKey -> ShowS
$cshowsPrec :: Int -> PublicKey -> ShowS
Show, Typeable)

instance Packet PublicKey where
  data PacketType PublicKey = PublicKeyType
                              deriving (Int -> PacketType PublicKey -> ShowS
[PacketType PublicKey] -> ShowS
PacketType PublicKey -> String
(Int -> PacketType PublicKey -> ShowS)
-> (PacketType PublicKey -> String)
-> ([PacketType PublicKey] -> ShowS)
-> Show (PacketType PublicKey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType PublicKey] -> ShowS
$cshowList :: [PacketType PublicKey] -> ShowS
show :: PacketType PublicKey -> String
$cshow :: PacketType PublicKey -> String
showsPrec :: Int -> PacketType PublicKey -> ShowS
$cshowsPrec :: Int -> PacketType PublicKey -> ShowS
Show, PacketType PublicKey -> PacketType PublicKey -> Bool
(PacketType PublicKey -> PacketType PublicKey -> Bool)
-> (PacketType PublicKey -> PacketType PublicKey -> Bool)
-> Eq (PacketType PublicKey)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType PublicKey -> PacketType PublicKey -> Bool
$c/= :: PacketType PublicKey -> PacketType PublicKey -> Bool
== :: PacketType PublicKey -> PacketType PublicKey -> Bool
$c== :: PacketType PublicKey -> PacketType PublicKey -> Bool
Eq)
  packetType :: PublicKey -> PacketType PublicKey
packetType _ = PacketType PublicKey
PublicKeyType
  packetCode :: PacketType PublicKey -> PacketVersion
packetCode _ = 6
  toPkt :: PublicKey -> Pkt
toPkt (PublicKey a :: PKPayload
a) = PKPayload -> Pkt
PublicKeyPkt PKPayload
a
  fromPkt :: Pkt -> PublicKey
fromPkt (PublicKeyPkt a :: PKPayload
a) = PKPayload -> PublicKey
PublicKey PKPayload
a
  fromPkt _ = String -> PublicKey
forall a. HasCallStack => String -> a
error "Cannot coerce non-PublicKey packet"

instance Pretty PublicKey where
  pretty :: PublicKey -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (PublicKey -> Pkt) -> PublicKey -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PublicKey -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data SecretSubkey =
  SecretSubkey
    { SecretSubkey -> PKPayload
_secretSubkeyPKPayload :: PKPayload
    , SecretSubkey -> SKAddendum
_secretSubkeySKAddendum :: SKAddendum
    }
  deriving (Typeable SecretSubkey
DataType
Constr
Typeable SecretSubkey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SecretSubkey -> c SecretSubkey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SecretSubkey)
-> (SecretSubkey -> Constr)
-> (SecretSubkey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SecretSubkey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SecretSubkey))
-> ((forall b. Data b => b -> b) -> SecretSubkey -> SecretSubkey)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r)
-> (forall u. (forall d. Data d => d -> u) -> SecretSubkey -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SecretSubkey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey)
-> Data SecretSubkey
SecretSubkey -> DataType
SecretSubkey -> Constr
(forall b. Data b => b -> b) -> SecretSubkey -> SecretSubkey
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretSubkey -> c SecretSubkey
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretSubkey
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SecretSubkey -> u
forall u. (forall d. Data d => d -> u) -> SecretSubkey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretSubkey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretSubkey -> c SecretSubkey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SecretSubkey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SecretSubkey)
$cSecretSubkey :: Constr
$tSecretSubkey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
gmapMp :: (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
gmapM :: (forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SecretSubkey -> m SecretSubkey
gmapQi :: Int -> (forall d. Data d => d -> u) -> SecretSubkey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SecretSubkey -> u
gmapQ :: (forall d. Data d => d -> u) -> SecretSubkey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SecretSubkey -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SecretSubkey -> r
gmapT :: (forall b. Data b => b -> b) -> SecretSubkey -> SecretSubkey
$cgmapT :: (forall b. Data b => b -> b) -> SecretSubkey -> SecretSubkey
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SecretSubkey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SecretSubkey)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SecretSubkey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SecretSubkey)
dataTypeOf :: SecretSubkey -> DataType
$cdataTypeOf :: SecretSubkey -> DataType
toConstr :: SecretSubkey -> Constr
$ctoConstr :: SecretSubkey -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretSubkey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SecretSubkey
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretSubkey -> c SecretSubkey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SecretSubkey -> c SecretSubkey
$cp1Data :: Typeable SecretSubkey
Data, SecretSubkey -> SecretSubkey -> Bool
(SecretSubkey -> SecretSubkey -> Bool)
-> (SecretSubkey -> SecretSubkey -> Bool) -> Eq SecretSubkey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SecretSubkey -> SecretSubkey -> Bool
$c/= :: SecretSubkey -> SecretSubkey -> Bool
== :: SecretSubkey -> SecretSubkey -> Bool
$c== :: SecretSubkey -> SecretSubkey -> Bool
Eq, Int -> SecretSubkey -> ShowS
[SecretSubkey] -> ShowS
SecretSubkey -> String
(Int -> SecretSubkey -> ShowS)
-> (SecretSubkey -> String)
-> ([SecretSubkey] -> ShowS)
-> Show SecretSubkey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SecretSubkey] -> ShowS
$cshowList :: [SecretSubkey] -> ShowS
show :: SecretSubkey -> String
$cshow :: SecretSubkey -> String
showsPrec :: Int -> SecretSubkey -> ShowS
$cshowsPrec :: Int -> SecretSubkey -> ShowS
Show, Typeable)

instance Packet SecretSubkey where
  data PacketType SecretSubkey = SecretSubkeyType
                                 deriving (Int -> PacketType SecretSubkey -> ShowS
[PacketType SecretSubkey] -> ShowS
PacketType SecretSubkey -> String
(Int -> PacketType SecretSubkey -> ShowS)
-> (PacketType SecretSubkey -> String)
-> ([PacketType SecretSubkey] -> ShowS)
-> Show (PacketType SecretSubkey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType SecretSubkey] -> ShowS
$cshowList :: [PacketType SecretSubkey] -> ShowS
show :: PacketType SecretSubkey -> String
$cshow :: PacketType SecretSubkey -> String
showsPrec :: Int -> PacketType SecretSubkey -> ShowS
$cshowsPrec :: Int -> PacketType SecretSubkey -> ShowS
Show, PacketType SecretSubkey -> PacketType SecretSubkey -> Bool
(PacketType SecretSubkey -> PacketType SecretSubkey -> Bool)
-> (PacketType SecretSubkey -> PacketType SecretSubkey -> Bool)
-> Eq (PacketType SecretSubkey)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType SecretSubkey -> PacketType SecretSubkey -> Bool
$c/= :: PacketType SecretSubkey -> PacketType SecretSubkey -> Bool
== :: PacketType SecretSubkey -> PacketType SecretSubkey -> Bool
$c== :: PacketType SecretSubkey -> PacketType SecretSubkey -> Bool
Eq)
  packetType :: SecretSubkey -> PacketType SecretSubkey
packetType _ = PacketType SecretSubkey
SecretSubkeyType
  packetCode :: PacketType SecretSubkey -> PacketVersion
packetCode _ = 7
  toPkt :: SecretSubkey -> Pkt
toPkt (SecretSubkey a :: PKPayload
a b :: SKAddendum
b) = PKPayload -> SKAddendum -> Pkt
SecretSubkeyPkt PKPayload
a SKAddendum
b
  fromPkt :: Pkt -> SecretSubkey
fromPkt (SecretSubkeyPkt a :: PKPayload
a b :: SKAddendum
b) = PKPayload -> SKAddendum -> SecretSubkey
SecretSubkey PKPayload
a SKAddendum
b
  fromPkt _ = String -> SecretSubkey
forall a. HasCallStack => String -> a
error "Cannot coerce non-SecretSubkey packet"

instance Pretty SecretSubkey where
  pretty :: SecretSubkey -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (SecretSubkey -> Pkt) -> SecretSubkey -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SecretSubkey -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data CompressedData =
  CompressedData
    { CompressedData -> CompressionAlgorithm
_compressedDataCompressionAlgorithm :: CompressionAlgorithm
    , CompressedData -> ByteString
_compressedDataPayload :: CompressedDataPayload
    }
  deriving (Typeable CompressedData
DataType
Constr
Typeable CompressedData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> CompressedData -> c CompressedData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompressedData)
-> (CompressedData -> Constr)
-> (CompressedData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompressedData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CompressedData))
-> ((forall b. Data b => b -> b)
    -> CompressedData -> CompressedData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompressedData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompressedData -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CompressedData -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CompressedData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CompressedData -> m CompressedData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompressedData -> m CompressedData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompressedData -> m CompressedData)
-> Data CompressedData
CompressedData -> DataType
CompressedData -> Constr
(forall b. Data b => b -> b) -> CompressedData -> CompressedData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompressedData -> c CompressedData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompressedData
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int -> (forall d. Data d => d -> u) -> CompressedData -> u
forall u. (forall d. Data d => d -> u) -> CompressedData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompressedData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompressedData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompressedData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompressedData -> c CompressedData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompressedData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompressedData)
$cCompressedData :: Constr
$tCompressedData :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
gmapMp :: (forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
gmapM :: (forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompressedData -> m CompressedData
gmapQi :: Int -> (forall d. Data d => d -> u) -> CompressedData -> u
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompressedData -> u
gmapQ :: (forall d. Data d => d -> u) -> CompressedData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> CompressedData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompressedData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompressedData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompressedData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompressedData -> r
gmapT :: (forall b. Data b => b -> b) -> CompressedData -> CompressedData
$cgmapT :: (forall b. Data b => b -> b) -> CompressedData -> CompressedData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompressedData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompressedData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c CompressedData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompressedData)
dataTypeOf :: CompressedData -> DataType
$cdataTypeOf :: CompressedData -> DataType
toConstr :: CompressedData -> Constr
$ctoConstr :: CompressedData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompressedData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompressedData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompressedData -> c CompressedData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> CompressedData -> c CompressedData
$cp1Data :: Typeable CompressedData
Data, CompressedData -> CompressedData -> Bool
(CompressedData -> CompressedData -> Bool)
-> (CompressedData -> CompressedData -> Bool) -> Eq CompressedData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: CompressedData -> CompressedData -> Bool
$c/= :: CompressedData -> CompressedData -> Bool
== :: CompressedData -> CompressedData -> Bool
$c== :: CompressedData -> CompressedData -> Bool
Eq, Int -> CompressedData -> ShowS
[CompressedData] -> ShowS
CompressedData -> String
(Int -> CompressedData -> ShowS)
-> (CompressedData -> String)
-> ([CompressedData] -> ShowS)
-> Show CompressedData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [CompressedData] -> ShowS
$cshowList :: [CompressedData] -> ShowS
show :: CompressedData -> String
$cshow :: CompressedData -> String
showsPrec :: Int -> CompressedData -> ShowS
$cshowsPrec :: Int -> CompressedData -> ShowS
Show, Typeable)

instance Packet CompressedData where
  data PacketType CompressedData = CompressedDataType
                                   deriving (Int -> PacketType CompressedData -> ShowS
[PacketType CompressedData] -> ShowS
PacketType CompressedData -> String
(Int -> PacketType CompressedData -> ShowS)
-> (PacketType CompressedData -> String)
-> ([PacketType CompressedData] -> ShowS)
-> Show (PacketType CompressedData)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType CompressedData] -> ShowS
$cshowList :: [PacketType CompressedData] -> ShowS
show :: PacketType CompressedData -> String
$cshow :: PacketType CompressedData -> String
showsPrec :: Int -> PacketType CompressedData -> ShowS
$cshowsPrec :: Int -> PacketType CompressedData -> ShowS
Show, PacketType CompressedData -> PacketType CompressedData -> Bool
(PacketType CompressedData -> PacketType CompressedData -> Bool)
-> (PacketType CompressedData -> PacketType CompressedData -> Bool)
-> Eq (PacketType CompressedData)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType CompressedData -> PacketType CompressedData -> Bool
$c/= :: PacketType CompressedData -> PacketType CompressedData -> Bool
== :: PacketType CompressedData -> PacketType CompressedData -> Bool
$c== :: PacketType CompressedData -> PacketType CompressedData -> Bool
Eq)
  packetType :: CompressedData -> PacketType CompressedData
packetType _ = PacketType CompressedData
CompressedDataType
  packetCode :: PacketType CompressedData -> PacketVersion
packetCode _ = 8
  toPkt :: CompressedData -> Pkt
toPkt (CompressedData a :: CompressionAlgorithm
a b :: ByteString
b) = CompressionAlgorithm -> ByteString -> Pkt
CompressedDataPkt CompressionAlgorithm
a ByteString
b
  fromPkt :: Pkt -> CompressedData
fromPkt (CompressedDataPkt a :: CompressionAlgorithm
a b :: ByteString
b) = CompressionAlgorithm -> ByteString -> CompressedData
CompressedData CompressionAlgorithm
a ByteString
b
  fromPkt _ = String -> CompressedData
forall a. HasCallStack => String -> a
error "Cannot coerce non-CompressedData packet"

instance Pretty CompressedData where
  pretty :: CompressedData -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (CompressedData -> Pkt) -> CompressedData -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. CompressedData -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype SymEncData =
  SymEncData
    { SymEncData -> ByteString
_symEncDataPayload :: ByteString
    }
  deriving (Typeable SymEncData
DataType
Constr
Typeable SymEncData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SymEncData -> c SymEncData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SymEncData)
-> (SymEncData -> Constr)
-> (SymEncData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SymEncData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SymEncData))
-> ((forall b. Data b => b -> b) -> SymEncData -> SymEncData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SymEncData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SymEncData -> r)
-> (forall u. (forall d. Data d => d -> u) -> SymEncData -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SymEncData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData)
-> Data SymEncData
SymEncData -> DataType
SymEncData -> Constr
(forall b. Data b => b -> b) -> SymEncData -> SymEncData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymEncData -> c SymEncData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncData
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> SymEncData -> u
forall u. (forall d. Data d => d -> u) -> SymEncData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymEncData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymEncData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymEncData -> c SymEncData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymEncData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymEncData)
$cSymEncData :: Constr
$tSymEncData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
gmapMp :: (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
gmapM :: (forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SymEncData -> m SymEncData
gmapQi :: Int -> (forall d. Data d => d -> u) -> SymEncData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SymEncData -> u
gmapQ :: (forall d. Data d => d -> u) -> SymEncData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SymEncData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymEncData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymEncData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymEncData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymEncData -> r
gmapT :: (forall b. Data b => b -> b) -> SymEncData -> SymEncData
$cgmapT :: (forall b. Data b => b -> b) -> SymEncData -> SymEncData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymEncData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SymEncData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c SymEncData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymEncData)
dataTypeOf :: SymEncData -> DataType
$cdataTypeOf :: SymEncData -> DataType
toConstr :: SymEncData -> Constr
$ctoConstr :: SymEncData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymEncData -> c SymEncData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SymEncData -> c SymEncData
$cp1Data :: Typeable SymEncData
Data, SymEncData -> SymEncData -> Bool
(SymEncData -> SymEncData -> Bool)
-> (SymEncData -> SymEncData -> Bool) -> Eq SymEncData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SymEncData -> SymEncData -> Bool
$c/= :: SymEncData -> SymEncData -> Bool
== :: SymEncData -> SymEncData -> Bool
$c== :: SymEncData -> SymEncData -> Bool
Eq, Int -> SymEncData -> ShowS
[SymEncData] -> ShowS
SymEncData -> String
(Int -> SymEncData -> ShowS)
-> (SymEncData -> String)
-> ([SymEncData] -> ShowS)
-> Show SymEncData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SymEncData] -> ShowS
$cshowList :: [SymEncData] -> ShowS
show :: SymEncData -> String
$cshow :: SymEncData -> String
showsPrec :: Int -> SymEncData -> ShowS
$cshowsPrec :: Int -> SymEncData -> ShowS
Show, Typeable)

instance Packet SymEncData where
  data PacketType SymEncData = SymEncDataType
                               deriving (Int -> PacketType SymEncData -> ShowS
[PacketType SymEncData] -> ShowS
PacketType SymEncData -> String
(Int -> PacketType SymEncData -> ShowS)
-> (PacketType SymEncData -> String)
-> ([PacketType SymEncData] -> ShowS)
-> Show (PacketType SymEncData)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType SymEncData] -> ShowS
$cshowList :: [PacketType SymEncData] -> ShowS
show :: PacketType SymEncData -> String
$cshow :: PacketType SymEncData -> String
showsPrec :: Int -> PacketType SymEncData -> ShowS
$cshowsPrec :: Int -> PacketType SymEncData -> ShowS
Show, PacketType SymEncData -> PacketType SymEncData -> Bool
(PacketType SymEncData -> PacketType SymEncData -> Bool)
-> (PacketType SymEncData -> PacketType SymEncData -> Bool)
-> Eq (PacketType SymEncData)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType SymEncData -> PacketType SymEncData -> Bool
$c/= :: PacketType SymEncData -> PacketType SymEncData -> Bool
== :: PacketType SymEncData -> PacketType SymEncData -> Bool
$c== :: PacketType SymEncData -> PacketType SymEncData -> Bool
Eq)
  packetType :: SymEncData -> PacketType SymEncData
packetType _ = PacketType SymEncData
SymEncDataType
  packetCode :: PacketType SymEncData -> PacketVersion
packetCode _ = 9
  toPkt :: SymEncData -> Pkt
toPkt (SymEncData a :: ByteString
a) = ByteString -> Pkt
SymEncDataPkt ByteString
a
  fromPkt :: Pkt -> SymEncData
fromPkt (SymEncDataPkt a :: ByteString
a) = ByteString -> SymEncData
SymEncData ByteString
a
  fromPkt _ = String -> SymEncData
forall a. HasCallStack => String -> a
error "Cannot coerce non-SymEncData packet"

instance Pretty SymEncData where
  pretty :: SymEncData -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (SymEncData -> Pkt) -> SymEncData -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SymEncData -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype Marker =
  Marker
    { Marker -> ByteString
_markerPayload :: ByteString
    }
  deriving (Typeable Marker
DataType
Constr
Typeable Marker =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Marker -> c Marker)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Marker)
-> (Marker -> Constr)
-> (Marker -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Marker))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Marker))
-> ((forall b. Data b => b -> b) -> Marker -> Marker)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Marker -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Marker -> r)
-> (forall u. (forall d. Data d => d -> u) -> Marker -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Marker -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Marker -> m Marker)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Marker -> m Marker)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Marker -> m Marker)
-> Data Marker
Marker -> DataType
Marker -> Constr
(forall b. Data b => b -> b) -> Marker -> Marker
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Marker -> c Marker
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Marker
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Marker -> u
forall u. (forall d. Data d => d -> u) -> Marker -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Marker -> m Marker
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Marker -> m Marker
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Marker
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Marker -> c Marker
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Marker)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Marker)
$cMarker :: Constr
$tMarker :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Marker -> m Marker
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Marker -> m Marker
gmapMp :: (forall d. Data d => d -> m d) -> Marker -> m Marker
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Marker -> m Marker
gmapM :: (forall d. Data d => d -> m d) -> Marker -> m Marker
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Marker -> m Marker
gmapQi :: Int -> (forall d. Data d => d -> u) -> Marker -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Marker -> u
gmapQ :: (forall d. Data d => d -> u) -> Marker -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Marker -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Marker -> r
gmapT :: (forall b. Data b => b -> b) -> Marker -> Marker
$cgmapT :: (forall b. Data b => b -> b) -> Marker -> Marker
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Marker)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Marker)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Marker)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Marker)
dataTypeOf :: Marker -> DataType
$cdataTypeOf :: Marker -> DataType
toConstr :: Marker -> Constr
$ctoConstr :: Marker -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Marker
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Marker
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Marker -> c Marker
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Marker -> c Marker
$cp1Data :: Typeable Marker
Data, Marker -> Marker -> Bool
(Marker -> Marker -> Bool)
-> (Marker -> Marker -> Bool) -> Eq Marker
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Marker -> Marker -> Bool
$c/= :: Marker -> Marker -> Bool
== :: Marker -> Marker -> Bool
$c== :: Marker -> Marker -> Bool
Eq, Int -> Marker -> ShowS
[Marker] -> ShowS
Marker -> String
(Int -> Marker -> ShowS)
-> (Marker -> String) -> ([Marker] -> ShowS) -> Show Marker
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Marker] -> ShowS
$cshowList :: [Marker] -> ShowS
show :: Marker -> String
$cshow :: Marker -> String
showsPrec :: Int -> Marker -> ShowS
$cshowsPrec :: Int -> Marker -> ShowS
Show, Typeable)

instance Packet Marker where
  data PacketType Marker = MarkerType
                           deriving (Int -> PacketType Marker -> ShowS
[PacketType Marker] -> ShowS
PacketType Marker -> String
(Int -> PacketType Marker -> ShowS)
-> (PacketType Marker -> String)
-> ([PacketType Marker] -> ShowS)
-> Show (PacketType Marker)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType Marker] -> ShowS
$cshowList :: [PacketType Marker] -> ShowS
show :: PacketType Marker -> String
$cshow :: PacketType Marker -> String
showsPrec :: Int -> PacketType Marker -> ShowS
$cshowsPrec :: Int -> PacketType Marker -> ShowS
Show, PacketType Marker -> PacketType Marker -> Bool
(PacketType Marker -> PacketType Marker -> Bool)
-> (PacketType Marker -> PacketType Marker -> Bool)
-> Eq (PacketType Marker)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType Marker -> PacketType Marker -> Bool
$c/= :: PacketType Marker -> PacketType Marker -> Bool
== :: PacketType Marker -> PacketType Marker -> Bool
$c== :: PacketType Marker -> PacketType Marker -> Bool
Eq)
  packetType :: Marker -> PacketType Marker
packetType _ = PacketType Marker
MarkerType
  packetCode :: PacketType Marker -> PacketVersion
packetCode _ = 10
  toPkt :: Marker -> Pkt
toPkt (Marker a :: ByteString
a) = ByteString -> Pkt
MarkerPkt ByteString
a
  fromPkt :: Pkt -> Marker
fromPkt (MarkerPkt a :: ByteString
a) = ByteString -> Marker
Marker ByteString
a
  fromPkt _ = String -> Marker
forall a. HasCallStack => String -> a
error "Cannot coerce non-Marker packet"

instance Pretty Marker where
  pretty :: Marker -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (Marker -> Pkt) -> Marker -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Marker -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data LiteralData =
  LiteralData
    { LiteralData -> DataType
_literalDataDataType :: DataType
    , LiteralData -> ByteString
_literalDataFileName :: FileName
    , LiteralData -> ThirtyTwoBitTimeStamp
_literalDataTimeStamp :: ThirtyTwoBitTimeStamp
    , LiteralData -> ByteString
_literalDataPayload :: ByteString
    }
  deriving (Typeable LiteralData
DataType
Constr
Typeable LiteralData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> LiteralData -> c LiteralData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c LiteralData)
-> (LiteralData -> Constr)
-> (LiteralData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c LiteralData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c LiteralData))
-> ((forall b. Data b => b -> b) -> LiteralData -> LiteralData)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> LiteralData -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> LiteralData -> r)
-> (forall u. (forall d. Data d => d -> u) -> LiteralData -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> LiteralData -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData)
-> Data LiteralData
LiteralData -> DataType
LiteralData -> Constr
(forall b. Data b => b -> b) -> LiteralData -> LiteralData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LiteralData -> c LiteralData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LiteralData
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> LiteralData -> u
forall u. (forall d. Data d => d -> u) -> LiteralData -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LiteralData -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LiteralData -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LiteralData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LiteralData -> c LiteralData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LiteralData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LiteralData)
$cLiteralData :: Constr
$tLiteralData :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
gmapMp :: (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
gmapM :: (forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> LiteralData -> m LiteralData
gmapQi :: Int -> (forall d. Data d => d -> u) -> LiteralData -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> LiteralData -> u
gmapQ :: (forall d. Data d => d -> u) -> LiteralData -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> LiteralData -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LiteralData -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> LiteralData -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LiteralData -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> LiteralData -> r
gmapT :: (forall b. Data b => b -> b) -> LiteralData -> LiteralData
$cgmapT :: (forall b. Data b => b -> b) -> LiteralData -> LiteralData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LiteralData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c LiteralData)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c LiteralData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c LiteralData)
dataTypeOf :: LiteralData -> DataType
$cdataTypeOf :: LiteralData -> DataType
toConstr :: LiteralData -> Constr
$ctoConstr :: LiteralData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LiteralData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c LiteralData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LiteralData -> c LiteralData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> LiteralData -> c LiteralData
$cp1Data :: Typeable LiteralData
Data, LiteralData -> LiteralData -> Bool
(LiteralData -> LiteralData -> Bool)
-> (LiteralData -> LiteralData -> Bool) -> Eq LiteralData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: LiteralData -> LiteralData -> Bool
$c/= :: LiteralData -> LiteralData -> Bool
== :: LiteralData -> LiteralData -> Bool
$c== :: LiteralData -> LiteralData -> Bool
Eq, Int -> LiteralData -> ShowS
[LiteralData] -> ShowS
LiteralData -> String
(Int -> LiteralData -> ShowS)
-> (LiteralData -> String)
-> ([LiteralData] -> ShowS)
-> Show LiteralData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [LiteralData] -> ShowS
$cshowList :: [LiteralData] -> ShowS
show :: LiteralData -> String
$cshow :: LiteralData -> String
showsPrec :: Int -> LiteralData -> ShowS
$cshowsPrec :: Int -> LiteralData -> ShowS
Show, Typeable)

instance Packet LiteralData where
  data PacketType LiteralData = LiteralDataType
                                deriving (Int -> PacketType LiteralData -> ShowS
[PacketType LiteralData] -> ShowS
PacketType LiteralData -> String
(Int -> PacketType LiteralData -> ShowS)
-> (PacketType LiteralData -> String)
-> ([PacketType LiteralData] -> ShowS)
-> Show (PacketType LiteralData)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType LiteralData] -> ShowS
$cshowList :: [PacketType LiteralData] -> ShowS
show :: PacketType LiteralData -> String
$cshow :: PacketType LiteralData -> String
showsPrec :: Int -> PacketType LiteralData -> ShowS
$cshowsPrec :: Int -> PacketType LiteralData -> ShowS
Show, PacketType LiteralData -> PacketType LiteralData -> Bool
(PacketType LiteralData -> PacketType LiteralData -> Bool)
-> (PacketType LiteralData -> PacketType LiteralData -> Bool)
-> Eq (PacketType LiteralData)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType LiteralData -> PacketType LiteralData -> Bool
$c/= :: PacketType LiteralData -> PacketType LiteralData -> Bool
== :: PacketType LiteralData -> PacketType LiteralData -> Bool
$c== :: PacketType LiteralData -> PacketType LiteralData -> Bool
Eq)
  packetType :: LiteralData -> PacketType LiteralData
packetType _ = PacketType LiteralData
LiteralDataType
  packetCode :: PacketType LiteralData -> PacketVersion
packetCode _ = 11
  toPkt :: LiteralData -> Pkt
toPkt (LiteralData a :: DataType
a b :: ByteString
b c :: ThirtyTwoBitTimeStamp
c d :: ByteString
d) = DataType
-> ByteString -> ThirtyTwoBitTimeStamp -> ByteString -> Pkt
LiteralDataPkt DataType
a ByteString
b ThirtyTwoBitTimeStamp
c ByteString
d
  fromPkt :: Pkt -> LiteralData
fromPkt (LiteralDataPkt a :: DataType
a b :: ByteString
b c :: ThirtyTwoBitTimeStamp
c d :: ByteString
d) = DataType
-> ByteString -> ThirtyTwoBitTimeStamp -> ByteString -> LiteralData
LiteralData DataType
a ByteString
b ThirtyTwoBitTimeStamp
c ByteString
d
  fromPkt _ = String -> LiteralData
forall a. HasCallStack => String -> a
error "Cannot coerce non-LiteralData packet"

instance Pretty LiteralData where
  pretty :: LiteralData -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (LiteralData -> Pkt) -> LiteralData -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. LiteralData -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype Trust =
  Trust
    { Trust -> ByteString
_trustPayload :: ByteString
    }
  deriving (Typeable Trust
DataType
Constr
Typeable Trust =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Trust -> c Trust)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Trust)
-> (Trust -> Constr)
-> (Trust -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Trust))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trust))
-> ((forall b. Data b => b -> b) -> Trust -> Trust)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r)
-> (forall u. (forall d. Data d => d -> u) -> Trust -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Trust -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Trust -> m Trust)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Trust -> m Trust)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Trust -> m Trust)
-> Data Trust
Trust -> DataType
Trust -> Constr
(forall b. Data b => b -> b) -> Trust -> Trust
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trust -> c Trust
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trust
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Trust -> u
forall u. (forall d. Data d => d -> u) -> Trust -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trust -> m Trust
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trust -> m Trust
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trust
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trust -> c Trust
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trust)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trust)
$cTrust :: Constr
$tTrust :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> Trust -> m Trust
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trust -> m Trust
gmapMp :: (forall d. Data d => d -> m d) -> Trust -> m Trust
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Trust -> m Trust
gmapM :: (forall d. Data d => d -> m d) -> Trust -> m Trust
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Trust -> m Trust
gmapQi :: Int -> (forall d. Data d => d -> u) -> Trust -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Trust -> u
gmapQ :: (forall d. Data d => d -> u) -> Trust -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Trust -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Trust -> r
gmapT :: (forall b. Data b => b -> b) -> Trust -> Trust
$cgmapT :: (forall b. Data b => b -> b) -> Trust -> Trust
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trust)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Trust)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c Trust)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Trust)
dataTypeOf :: Trust -> DataType
$cdataTypeOf :: Trust -> DataType
toConstr :: Trust -> Constr
$ctoConstr :: Trust -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trust
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Trust
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trust -> c Trust
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Trust -> c Trust
$cp1Data :: Typeable Trust
Data, Trust -> Trust -> Bool
(Trust -> Trust -> Bool) -> (Trust -> Trust -> Bool) -> Eq Trust
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: Trust -> Trust -> Bool
$c/= :: Trust -> Trust -> Bool
== :: Trust -> Trust -> Bool
$c== :: Trust -> Trust -> Bool
Eq, Int -> Trust -> ShowS
[Trust] -> ShowS
Trust -> String
(Int -> Trust -> ShowS)
-> (Trust -> String) -> ([Trust] -> ShowS) -> Show Trust
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Trust] -> ShowS
$cshowList :: [Trust] -> ShowS
show :: Trust -> String
$cshow :: Trust -> String
showsPrec :: Int -> Trust -> ShowS
$cshowsPrec :: Int -> Trust -> ShowS
Show, Typeable)

instance Packet Trust where
  data PacketType Trust = TrustType
                          deriving (Int -> PacketType Trust -> ShowS
[PacketType Trust] -> ShowS
PacketType Trust -> String
(Int -> PacketType Trust -> ShowS)
-> (PacketType Trust -> String)
-> ([PacketType Trust] -> ShowS)
-> Show (PacketType Trust)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType Trust] -> ShowS
$cshowList :: [PacketType Trust] -> ShowS
show :: PacketType Trust -> String
$cshow :: PacketType Trust -> String
showsPrec :: Int -> PacketType Trust -> ShowS
$cshowsPrec :: Int -> PacketType Trust -> ShowS
Show, PacketType Trust -> PacketType Trust -> Bool
(PacketType Trust -> PacketType Trust -> Bool)
-> (PacketType Trust -> PacketType Trust -> Bool)
-> Eq (PacketType Trust)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType Trust -> PacketType Trust -> Bool
$c/= :: PacketType Trust -> PacketType Trust -> Bool
== :: PacketType Trust -> PacketType Trust -> Bool
$c== :: PacketType Trust -> PacketType Trust -> Bool
Eq)
  packetType :: Trust -> PacketType Trust
packetType _ = PacketType Trust
TrustType
  packetCode :: PacketType Trust -> PacketVersion
packetCode _ = 12
  toPkt :: Trust -> Pkt
toPkt (Trust a :: ByteString
a) = ByteString -> Pkt
TrustPkt ByteString
a
  fromPkt :: Pkt -> Trust
fromPkt (TrustPkt a :: ByteString
a) = ByteString -> Trust
Trust ByteString
a
  fromPkt _ = String -> Trust
forall a. HasCallStack => String -> a
error "Cannot coerce non-Trust packet"

instance Pretty Trust where
  pretty :: Trust -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (Trust -> Pkt) -> Trust -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Trust -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype UserId =
  UserId
    { UserId -> Text
_userIdPayload :: Text
    }
  deriving (Typeable UserId
DataType
Constr
Typeable UserId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UserId -> c UserId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UserId)
-> (UserId -> Constr)
-> (UserId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UserId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UserId))
-> ((forall b. Data b => b -> b) -> UserId -> UserId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UserId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UserId -> r)
-> (forall u. (forall d. Data d => d -> u) -> UserId -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> UserId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UserId -> m UserId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UserId -> m UserId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UserId -> m UserId)
-> Data UserId
UserId -> DataType
UserId -> Constr
(forall b. Data b => b -> b) -> UserId -> UserId
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserId -> c UserId
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserId
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UserId -> u
forall u. (forall d. Data d => d -> u) -> UserId -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UserId -> m UserId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UserId -> m UserId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserId -> c UserId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UserId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UserId)
$cUserId :: Constr
$tUserId :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> UserId -> m UserId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UserId -> m UserId
gmapMp :: (forall d. Data d => d -> m d) -> UserId -> m UserId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UserId -> m UserId
gmapM :: (forall d. Data d => d -> m d) -> UserId -> m UserId
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UserId -> m UserId
gmapQi :: Int -> (forall d. Data d => d -> u) -> UserId -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UserId -> u
gmapQ :: (forall d. Data d => d -> u) -> UserId -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UserId -> [u]
gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r
gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> UserId -> r
gmapT :: (forall b. Data b => b -> b) -> UserId -> UserId
$cgmapT :: (forall b. Data b => b -> b) -> UserId -> UserId
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UserId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c UserId)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c UserId)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UserId)
dataTypeOf :: UserId -> DataType
$cdataTypeOf :: UserId -> DataType
toConstr :: UserId -> Constr
$ctoConstr :: UserId -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserId
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserId -> c UserId
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserId -> c UserId
$cp1Data :: Typeable UserId
Data, UserId -> UserId -> Bool
(UserId -> UserId -> Bool)
-> (UserId -> UserId -> Bool) -> Eq UserId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserId -> UserId -> Bool
$c/= :: UserId -> UserId -> Bool
== :: UserId -> UserId -> Bool
$c== :: UserId -> UserId -> Bool
Eq, Int -> UserId -> ShowS
[UserId] -> ShowS
UserId -> String
(Int -> UserId -> ShowS)
-> (UserId -> String) -> ([UserId] -> ShowS) -> Show UserId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserId] -> ShowS
$cshowList :: [UserId] -> ShowS
show :: UserId -> String
$cshow :: UserId -> String
showsPrec :: Int -> UserId -> ShowS
$cshowsPrec :: Int -> UserId -> ShowS
Show, Typeable)

instance Packet UserId where
  data PacketType UserId = UserIdType
                           deriving (Int -> PacketType UserId -> ShowS
[PacketType UserId] -> ShowS
PacketType UserId -> String
(Int -> PacketType UserId -> ShowS)
-> (PacketType UserId -> String)
-> ([PacketType UserId] -> ShowS)
-> Show (PacketType UserId)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType UserId] -> ShowS
$cshowList :: [PacketType UserId] -> ShowS
show :: PacketType UserId -> String
$cshow :: PacketType UserId -> String
showsPrec :: Int -> PacketType UserId -> ShowS
$cshowsPrec :: Int -> PacketType UserId -> ShowS
Show, PacketType UserId -> PacketType UserId -> Bool
(PacketType UserId -> PacketType UserId -> Bool)
-> (PacketType UserId -> PacketType UserId -> Bool)
-> Eq (PacketType UserId)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType UserId -> PacketType UserId -> Bool
$c/= :: PacketType UserId -> PacketType UserId -> Bool
== :: PacketType UserId -> PacketType UserId -> Bool
$c== :: PacketType UserId -> PacketType UserId -> Bool
Eq)
  packetType :: UserId -> PacketType UserId
packetType _ = PacketType UserId
UserIdType
  packetCode :: PacketType UserId -> PacketVersion
packetCode _ = 13
  toPkt :: UserId -> Pkt
toPkt (UserId a :: Text
a) = Text -> Pkt
UserIdPkt Text
a
  fromPkt :: Pkt -> UserId
fromPkt (UserIdPkt a :: Text
a) = Text -> UserId
UserId Text
a
  fromPkt _ = String -> UserId
forall a. HasCallStack => String -> a
error "Cannot coerce non-UserId packet"

instance Pretty UserId where
  pretty :: UserId -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (UserId -> Pkt) -> UserId -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UserId -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype PublicSubkey =
  PublicSubkey
    { PublicSubkey -> PKPayload
_publicSubkeyPKPayload :: PKPayload
    }
  deriving (Typeable PublicSubkey
DataType
Constr
Typeable PublicSubkey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PublicSubkey -> c PublicSubkey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PublicSubkey)
-> (PublicSubkey -> Constr)
-> (PublicSubkey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PublicSubkey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PublicSubkey))
-> ((forall b. Data b => b -> b) -> PublicSubkey -> PublicSubkey)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r)
-> (forall u. (forall d. Data d => d -> u) -> PublicSubkey -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PublicSubkey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey)
-> Data PublicSubkey
PublicSubkey -> DataType
PublicSubkey -> Constr
(forall b. Data b => b -> b) -> PublicSubkey -> PublicSubkey
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicSubkey -> c PublicSubkey
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicSubkey
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> PublicSubkey -> u
forall u. (forall d. Data d => d -> u) -> PublicSubkey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicSubkey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicSubkey -> c PublicSubkey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PublicSubkey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PublicSubkey)
$cPublicSubkey :: Constr
$tPublicSubkey :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
gmapMp :: (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
gmapM :: (forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> PublicSubkey -> m PublicSubkey
gmapQi :: Int -> (forall d. Data d => d -> u) -> PublicSubkey -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> PublicSubkey -> u
gmapQ :: (forall d. Data d => d -> u) -> PublicSubkey -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PublicSubkey -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PublicSubkey -> r
gmapT :: (forall b. Data b => b -> b) -> PublicSubkey -> PublicSubkey
$cgmapT :: (forall b. Data b => b -> b) -> PublicSubkey -> PublicSubkey
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PublicSubkey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PublicSubkey)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c PublicSubkey)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PublicSubkey)
dataTypeOf :: PublicSubkey -> DataType
$cdataTypeOf :: PublicSubkey -> DataType
toConstr :: PublicSubkey -> Constr
$ctoConstr :: PublicSubkey -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicSubkey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PublicSubkey
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicSubkey -> c PublicSubkey
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PublicSubkey -> c PublicSubkey
$cp1Data :: Typeable PublicSubkey
Data, PublicSubkey -> PublicSubkey -> Bool
(PublicSubkey -> PublicSubkey -> Bool)
-> (PublicSubkey -> PublicSubkey -> Bool) -> Eq PublicSubkey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PublicSubkey -> PublicSubkey -> Bool
$c/= :: PublicSubkey -> PublicSubkey -> Bool
== :: PublicSubkey -> PublicSubkey -> Bool
$c== :: PublicSubkey -> PublicSubkey -> Bool
Eq, Int -> PublicSubkey -> ShowS
[PublicSubkey] -> ShowS
PublicSubkey -> String
(Int -> PublicSubkey -> ShowS)
-> (PublicSubkey -> String)
-> ([PublicSubkey] -> ShowS)
-> Show PublicSubkey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PublicSubkey] -> ShowS
$cshowList :: [PublicSubkey] -> ShowS
show :: PublicSubkey -> String
$cshow :: PublicSubkey -> String
showsPrec :: Int -> PublicSubkey -> ShowS
$cshowsPrec :: Int -> PublicSubkey -> ShowS
Show, Typeable)

instance Packet PublicSubkey where
  data PacketType PublicSubkey = PublicSubkeyType
                                 deriving (Int -> PacketType PublicSubkey -> ShowS
[PacketType PublicSubkey] -> ShowS
PacketType PublicSubkey -> String
(Int -> PacketType PublicSubkey -> ShowS)
-> (PacketType PublicSubkey -> String)
-> ([PacketType PublicSubkey] -> ShowS)
-> Show (PacketType PublicSubkey)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType PublicSubkey] -> ShowS
$cshowList :: [PacketType PublicSubkey] -> ShowS
show :: PacketType PublicSubkey -> String
$cshow :: PacketType PublicSubkey -> String
showsPrec :: Int -> PacketType PublicSubkey -> ShowS
$cshowsPrec :: Int -> PacketType PublicSubkey -> ShowS
Show, PacketType PublicSubkey -> PacketType PublicSubkey -> Bool
(PacketType PublicSubkey -> PacketType PublicSubkey -> Bool)
-> (PacketType PublicSubkey -> PacketType PublicSubkey -> Bool)
-> Eq (PacketType PublicSubkey)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType PublicSubkey -> PacketType PublicSubkey -> Bool
$c/= :: PacketType PublicSubkey -> PacketType PublicSubkey -> Bool
== :: PacketType PublicSubkey -> PacketType PublicSubkey -> Bool
$c== :: PacketType PublicSubkey -> PacketType PublicSubkey -> Bool
Eq)
  packetType :: PublicSubkey -> PacketType PublicSubkey
packetType _ = PacketType PublicSubkey
PublicSubkeyType
  packetCode :: PacketType PublicSubkey -> PacketVersion
packetCode _ = 14
  toPkt :: PublicSubkey -> Pkt
toPkt (PublicSubkey a :: PKPayload
a) = PKPayload -> Pkt
PublicSubkeyPkt PKPayload
a
  fromPkt :: Pkt -> PublicSubkey
fromPkt (PublicSubkeyPkt a :: PKPayload
a) = PKPayload -> PublicSubkey
PublicSubkey PKPayload
a
  fromPkt _ = String -> PublicSubkey
forall a. HasCallStack => String -> a
error "Cannot coerce non-PublicSubkey packet"

instance Pretty PublicSubkey where
  pretty :: PublicSubkey -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (PublicSubkey -> Pkt) -> PublicSubkey -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. PublicSubkey -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype UserAttribute =
  UserAttribute
    { UserAttribute -> [UserAttrSubPacket]
_userAttributeSubPackets :: [UserAttrSubPacket]
    }
  deriving (Typeable UserAttribute
DataType
Constr
Typeable UserAttribute =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> UserAttribute -> c UserAttribute)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UserAttribute)
-> (UserAttribute -> Constr)
-> (UserAttribute -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UserAttribute))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UserAttribute))
-> ((forall b. Data b => b -> b) -> UserAttribute -> UserAttribute)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UserAttribute -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UserAttribute -> r)
-> (forall u. (forall d. Data d => d -> u) -> UserAttribute -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UserAttribute -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute)
-> Data UserAttribute
UserAttribute -> DataType
UserAttribute -> Constr
(forall b. Data b => b -> b) -> UserAttribute -> UserAttribute
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserAttribute -> c UserAttribute
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserAttribute
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> UserAttribute -> u
forall u. (forall d. Data d => d -> u) -> UserAttribute -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttribute -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttribute -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserAttribute
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserAttribute -> c UserAttribute
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UserAttribute)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UserAttribute)
$cUserAttribute :: Constr
$tUserAttribute :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
gmapMp :: (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
gmapM :: (forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> UserAttribute -> m UserAttribute
gmapQi :: Int -> (forall d. Data d => d -> u) -> UserAttribute -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> UserAttribute -> u
gmapQ :: (forall d. Data d => d -> u) -> UserAttribute -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UserAttribute -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttribute -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttribute -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttribute -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttribute -> r
gmapT :: (forall b. Data b => b -> b) -> UserAttribute -> UserAttribute
$cgmapT :: (forall b. Data b => b -> b) -> UserAttribute -> UserAttribute
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UserAttribute)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UserAttribute)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c UserAttribute)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UserAttribute)
dataTypeOf :: UserAttribute -> DataType
$cdataTypeOf :: UserAttribute -> DataType
toConstr :: UserAttribute -> Constr
$ctoConstr :: UserAttribute -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserAttribute
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserAttribute
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserAttribute -> c UserAttribute
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserAttribute -> c UserAttribute
$cp1Data :: Typeable UserAttribute
Data, UserAttribute -> UserAttribute -> Bool
(UserAttribute -> UserAttribute -> Bool)
-> (UserAttribute -> UserAttribute -> Bool) -> Eq UserAttribute
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: UserAttribute -> UserAttribute -> Bool
$c/= :: UserAttribute -> UserAttribute -> Bool
== :: UserAttribute -> UserAttribute -> Bool
$c== :: UserAttribute -> UserAttribute -> Bool
Eq, Int -> UserAttribute -> ShowS
[UserAttribute] -> ShowS
UserAttribute -> String
(Int -> UserAttribute -> ShowS)
-> (UserAttribute -> String)
-> ([UserAttribute] -> ShowS)
-> Show UserAttribute
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [UserAttribute] -> ShowS
$cshowList :: [UserAttribute] -> ShowS
show :: UserAttribute -> String
$cshow :: UserAttribute -> String
showsPrec :: Int -> UserAttribute -> ShowS
$cshowsPrec :: Int -> UserAttribute -> ShowS
Show, Typeable)

instance Packet UserAttribute where
  data PacketType UserAttribute = UserAttributeType
                                  deriving (Int -> PacketType UserAttribute -> ShowS
[PacketType UserAttribute] -> ShowS
PacketType UserAttribute -> String
(Int -> PacketType UserAttribute -> ShowS)
-> (PacketType UserAttribute -> String)
-> ([PacketType UserAttribute] -> ShowS)
-> Show (PacketType UserAttribute)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType UserAttribute] -> ShowS
$cshowList :: [PacketType UserAttribute] -> ShowS
show :: PacketType UserAttribute -> String
$cshow :: PacketType UserAttribute -> String
showsPrec :: Int -> PacketType UserAttribute -> ShowS
$cshowsPrec :: Int -> PacketType UserAttribute -> ShowS
Show, PacketType UserAttribute -> PacketType UserAttribute -> Bool
(PacketType UserAttribute -> PacketType UserAttribute -> Bool)
-> (PacketType UserAttribute -> PacketType UserAttribute -> Bool)
-> Eq (PacketType UserAttribute)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType UserAttribute -> PacketType UserAttribute -> Bool
$c/= :: PacketType UserAttribute -> PacketType UserAttribute -> Bool
== :: PacketType UserAttribute -> PacketType UserAttribute -> Bool
$c== :: PacketType UserAttribute -> PacketType UserAttribute -> Bool
Eq)
  packetType :: UserAttribute -> PacketType UserAttribute
packetType _ = PacketType UserAttribute
UserAttributeType
  packetCode :: PacketType UserAttribute -> PacketVersion
packetCode _ = 17
  toPkt :: UserAttribute -> Pkt
toPkt (UserAttribute a :: [UserAttrSubPacket]
a) = [UserAttrSubPacket] -> Pkt
UserAttributePkt [UserAttrSubPacket]
a
  fromPkt :: Pkt -> UserAttribute
fromPkt (UserAttributePkt a :: [UserAttrSubPacket]
a) = [UserAttrSubPacket] -> UserAttribute
UserAttribute [UserAttrSubPacket]
a
  fromPkt _ = String -> UserAttribute
forall a. HasCallStack => String -> a
error "Cannot coerce non-UserAttribute packet"

instance Pretty UserAttribute where
  pretty :: UserAttribute -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (UserAttribute -> Pkt) -> UserAttribute -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. UserAttribute -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data SymEncIntegrityProtectedData =
  SymEncIntegrityProtectedData
    { SymEncIntegrityProtectedData -> PacketVersion
_symEncIntegrityProtectedDataPacketVersion :: PacketVersion
    , SymEncIntegrityProtectedData -> ByteString
_symEncIntegrityProtectedDataPayload :: ByteString
    }
  deriving (Typeable SymEncIntegrityProtectedData
DataType
Constr
Typeable SymEncIntegrityProtectedData =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SymEncIntegrityProtectedData
 -> c SymEncIntegrityProtectedData)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c SymEncIntegrityProtectedData)
-> (SymEncIntegrityProtectedData -> Constr)
-> (SymEncIntegrityProtectedData -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c SymEncIntegrityProtectedData))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SymEncIntegrityProtectedData))
-> ((forall b. Data b => b -> b)
    -> SymEncIntegrityProtectedData -> SymEncIntegrityProtectedData)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SymEncIntegrityProtectedData
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SymEncIntegrityProtectedData
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> SymEncIntegrityProtectedData -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> SymEncIntegrityProtectedData
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData)
-> Data SymEncIntegrityProtectedData
SymEncIntegrityProtectedData -> DataType
SymEncIntegrityProtectedData -> Constr
(forall b. Data b => b -> b)
-> SymEncIntegrityProtectedData -> SymEncIntegrityProtectedData
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SymEncIntegrityProtectedData
-> c SymEncIntegrityProtectedData
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncIntegrityProtectedData
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u)
-> SymEncIntegrityProtectedData
-> u
forall u.
(forall d. Data d => d -> u) -> SymEncIntegrityProtectedData -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SymEncIntegrityProtectedData
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SymEncIntegrityProtectedData
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncIntegrityProtectedData
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SymEncIntegrityProtectedData
-> c SymEncIntegrityProtectedData
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c SymEncIntegrityProtectedData)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymEncIntegrityProtectedData)
$cSymEncIntegrityProtectedData :: Constr
$tSymEncIntegrityProtectedData :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
gmapMp :: (forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
gmapM :: (forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymEncIntegrityProtectedData -> m SymEncIntegrityProtectedData
gmapQi :: Int
-> (forall d. Data d => d -> u)
-> SymEncIntegrityProtectedData
-> u
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> SymEncIntegrityProtectedData
-> u
gmapQ :: (forall d. Data d => d -> u) -> SymEncIntegrityProtectedData -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> SymEncIntegrityProtectedData -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SymEncIntegrityProtectedData
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SymEncIntegrityProtectedData
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SymEncIntegrityProtectedData
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SymEncIntegrityProtectedData
-> r
gmapT :: (forall b. Data b => b -> b)
-> SymEncIntegrityProtectedData -> SymEncIntegrityProtectedData
$cgmapT :: (forall b. Data b => b -> b)
-> SymEncIntegrityProtectedData -> SymEncIntegrityProtectedData
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymEncIntegrityProtectedData)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymEncIntegrityProtectedData)
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c SymEncIntegrityProtectedData)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c SymEncIntegrityProtectedData)
dataTypeOf :: SymEncIntegrityProtectedData -> DataType
$cdataTypeOf :: SymEncIntegrityProtectedData -> DataType
toConstr :: SymEncIntegrityProtectedData -> Constr
$ctoConstr :: SymEncIntegrityProtectedData -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncIntegrityProtectedData
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymEncIntegrityProtectedData
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SymEncIntegrityProtectedData
-> c SymEncIntegrityProtectedData
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SymEncIntegrityProtectedData
-> c SymEncIntegrityProtectedData
$cp1Data :: Typeable SymEncIntegrityProtectedData
Data, SymEncIntegrityProtectedData
-> SymEncIntegrityProtectedData -> Bool
(SymEncIntegrityProtectedData
 -> SymEncIntegrityProtectedData -> Bool)
-> (SymEncIntegrityProtectedData
    -> SymEncIntegrityProtectedData -> Bool)
-> Eq SymEncIntegrityProtectedData
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: SymEncIntegrityProtectedData
-> SymEncIntegrityProtectedData -> Bool
$c/= :: SymEncIntegrityProtectedData
-> SymEncIntegrityProtectedData -> Bool
== :: SymEncIntegrityProtectedData
-> SymEncIntegrityProtectedData -> Bool
$c== :: SymEncIntegrityProtectedData
-> SymEncIntegrityProtectedData -> Bool
Eq, Int -> SymEncIntegrityProtectedData -> ShowS
[SymEncIntegrityProtectedData] -> ShowS
SymEncIntegrityProtectedData -> String
(Int -> SymEncIntegrityProtectedData -> ShowS)
-> (SymEncIntegrityProtectedData -> String)
-> ([SymEncIntegrityProtectedData] -> ShowS)
-> Show SymEncIntegrityProtectedData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [SymEncIntegrityProtectedData] -> ShowS
$cshowList :: [SymEncIntegrityProtectedData] -> ShowS
show :: SymEncIntegrityProtectedData -> String
$cshow :: SymEncIntegrityProtectedData -> String
showsPrec :: Int -> SymEncIntegrityProtectedData -> ShowS
$cshowsPrec :: Int -> SymEncIntegrityProtectedData -> ShowS
Show, Typeable)

instance Packet SymEncIntegrityProtectedData where
  data PacketType
       SymEncIntegrityProtectedData = SymEncIntegrityProtectedDataType
                                        deriving (Int -> PacketType SymEncIntegrityProtectedData -> ShowS
[PacketType SymEncIntegrityProtectedData] -> ShowS
PacketType SymEncIntegrityProtectedData -> String
(Int -> PacketType SymEncIntegrityProtectedData -> ShowS)
-> (PacketType SymEncIntegrityProtectedData -> String)
-> ([PacketType SymEncIntegrityProtectedData] -> ShowS)
-> Show (PacketType SymEncIntegrityProtectedData)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType SymEncIntegrityProtectedData] -> ShowS
$cshowList :: [PacketType SymEncIntegrityProtectedData] -> ShowS
show :: PacketType SymEncIntegrityProtectedData -> String
$cshow :: PacketType SymEncIntegrityProtectedData -> String
showsPrec :: Int -> PacketType SymEncIntegrityProtectedData -> ShowS
$cshowsPrec :: Int -> PacketType SymEncIntegrityProtectedData -> ShowS
Show, PacketType SymEncIntegrityProtectedData
-> PacketType SymEncIntegrityProtectedData -> Bool
(PacketType SymEncIntegrityProtectedData
 -> PacketType SymEncIntegrityProtectedData -> Bool)
-> (PacketType SymEncIntegrityProtectedData
    -> PacketType SymEncIntegrityProtectedData -> Bool)
-> Eq (PacketType SymEncIntegrityProtectedData)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType SymEncIntegrityProtectedData
-> PacketType SymEncIntegrityProtectedData -> Bool
$c/= :: PacketType SymEncIntegrityProtectedData
-> PacketType SymEncIntegrityProtectedData -> Bool
== :: PacketType SymEncIntegrityProtectedData
-> PacketType SymEncIntegrityProtectedData -> Bool
$c== :: PacketType SymEncIntegrityProtectedData
-> PacketType SymEncIntegrityProtectedData -> Bool
Eq)
  packetType :: SymEncIntegrityProtectedData
-> PacketType SymEncIntegrityProtectedData
packetType _ = PacketType SymEncIntegrityProtectedData
SymEncIntegrityProtectedDataType
  packetCode :: PacketType SymEncIntegrityProtectedData -> PacketVersion
packetCode _ = 18
  toPkt :: SymEncIntegrityProtectedData -> Pkt
toPkt (SymEncIntegrityProtectedData a :: PacketVersion
a b :: ByteString
b) = PacketVersion -> ByteString -> Pkt
SymEncIntegrityProtectedDataPkt PacketVersion
a ByteString
b
  fromPkt :: Pkt -> SymEncIntegrityProtectedData
fromPkt (SymEncIntegrityProtectedDataPkt a :: PacketVersion
a b :: ByteString
b) =
    PacketVersion -> ByteString -> SymEncIntegrityProtectedData
SymEncIntegrityProtectedData PacketVersion
a ByteString
b
  fromPkt _ = String -> SymEncIntegrityProtectedData
forall a. HasCallStack => String -> a
error "Cannot coerce non-SymEncIntegrityProtectedData packet"

instance Pretty SymEncIntegrityProtectedData where
  pretty :: SymEncIntegrityProtectedData -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (SymEncIntegrityProtectedData -> Pkt)
-> SymEncIntegrityProtectedData
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SymEncIntegrityProtectedData -> Pkt
forall a. Packet a => a -> Pkt
toPkt

newtype ModificationDetectionCode =
  ModificationDetectionCode
    { ModificationDetectionCode -> ByteString
_modificationDetectionCodePayload :: ByteString
    }
  deriving (Typeable ModificationDetectionCode
DataType
Constr
Typeable ModificationDetectionCode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ModificationDetectionCode
 -> c ModificationDetectionCode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ModificationDetectionCode)
-> (ModificationDetectionCode -> Constr)
-> (ModificationDetectionCode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c ModificationDetectionCode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ModificationDetectionCode))
-> ((forall b. Data b => b -> b)
    -> ModificationDetectionCode -> ModificationDetectionCode)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ModificationDetectionCode
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ModificationDetectionCode
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ModificationDetectionCode -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> ModificationDetectionCode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ModificationDetectionCode -> m ModificationDetectionCode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModificationDetectionCode -> m ModificationDetectionCode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ModificationDetectionCode -> m ModificationDetectionCode)
-> Data ModificationDetectionCode
ModificationDetectionCode -> DataType
ModificationDetectionCode -> Constr
(forall b. Data b => b -> b)
-> ModificationDetectionCode -> ModificationDetectionCode
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ModificationDetectionCode
-> c ModificationDetectionCode
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModificationDetectionCode
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u.
Int
-> (forall d. Data d => d -> u) -> ModificationDetectionCode -> u
forall u.
(forall d. Data d => d -> u) -> ModificationDetectionCode -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ModificationDetectionCode
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ModificationDetectionCode
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModificationDetectionCode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ModificationDetectionCode
-> c ModificationDetectionCode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c ModificationDetectionCode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModificationDetectionCode)
$cModificationDetectionCode :: Constr
$tModificationDetectionCode :: DataType
gmapMo :: (forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
gmapMp :: (forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
gmapM :: (forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ModificationDetectionCode -> m ModificationDetectionCode
gmapQi :: Int
-> (forall d. Data d => d -> u) -> ModificationDetectionCode -> u
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> ModificationDetectionCode -> u
gmapQ :: (forall d. Data d => d -> u) -> ModificationDetectionCode -> [u]
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> ModificationDetectionCode -> [u]
gmapQr :: (r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ModificationDetectionCode
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> ModificationDetectionCode
-> r
gmapQl :: (r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ModificationDetectionCode
-> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> ModificationDetectionCode
-> r
gmapT :: (forall b. Data b => b -> b)
-> ModificationDetectionCode -> ModificationDetectionCode
$cgmapT :: (forall b. Data b => b -> b)
-> ModificationDetectionCode -> ModificationDetectionCode
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModificationDetectionCode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ModificationDetectionCode)
dataCast1 :: (forall d. Data d => c (t d))
-> Maybe (c ModificationDetectionCode)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c ModificationDetectionCode)
dataTypeOf :: ModificationDetectionCode -> DataType
$cdataTypeOf :: ModificationDetectionCode -> DataType
toConstr :: ModificationDetectionCode -> Constr
$ctoConstr :: ModificationDetectionCode -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModificationDetectionCode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ModificationDetectionCode
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ModificationDetectionCode
-> c ModificationDetectionCode
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ModificationDetectionCode
-> c ModificationDetectionCode
$cp1Data :: Typeable ModificationDetectionCode
Data, ModificationDetectionCode -> ModificationDetectionCode -> Bool
(ModificationDetectionCode -> ModificationDetectionCode -> Bool)
-> (ModificationDetectionCode -> ModificationDetectionCode -> Bool)
-> Eq ModificationDetectionCode
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: ModificationDetectionCode -> ModificationDetectionCode -> Bool
$c/= :: ModificationDetectionCode -> ModificationDetectionCode -> Bool
== :: ModificationDetectionCode -> ModificationDetectionCode -> Bool
$c== :: ModificationDetectionCode -> ModificationDetectionCode -> Bool
Eq, Int -> ModificationDetectionCode -> ShowS
[ModificationDetectionCode] -> ShowS
ModificationDetectionCode -> String
(Int -> ModificationDetectionCode -> ShowS)
-> (ModificationDetectionCode -> String)
-> ([ModificationDetectionCode] -> ShowS)
-> Show ModificationDetectionCode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ModificationDetectionCode] -> ShowS
$cshowList :: [ModificationDetectionCode] -> ShowS
show :: ModificationDetectionCode -> String
$cshow :: ModificationDetectionCode -> String
showsPrec :: Int -> ModificationDetectionCode -> ShowS
$cshowsPrec :: Int -> ModificationDetectionCode -> ShowS
Show, Typeable)

instance Packet ModificationDetectionCode where
  data PacketType
       ModificationDetectionCode = ModificationDetectionCodeType
                                     deriving (Int -> PacketType ModificationDetectionCode -> ShowS
[PacketType ModificationDetectionCode] -> ShowS
PacketType ModificationDetectionCode -> String
(Int -> PacketType ModificationDetectionCode -> ShowS)
-> (PacketType ModificationDetectionCode -> String)
-> ([PacketType ModificationDetectionCode] -> ShowS)
-> Show (PacketType ModificationDetectionCode)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType ModificationDetectionCode] -> ShowS
$cshowList :: [PacketType ModificationDetectionCode] -> ShowS
show :: PacketType ModificationDetectionCode -> String
$cshow :: PacketType ModificationDetectionCode -> String
showsPrec :: Int -> PacketType ModificationDetectionCode -> ShowS
$cshowsPrec :: Int -> PacketType ModificationDetectionCode -> ShowS
Show, PacketType ModificationDetectionCode
-> PacketType ModificationDetectionCode -> Bool
(PacketType ModificationDetectionCode
 -> PacketType ModificationDetectionCode -> Bool)
-> (PacketType ModificationDetectionCode
    -> PacketType ModificationDetectionCode -> Bool)
-> Eq (PacketType ModificationDetectionCode)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType ModificationDetectionCode
-> PacketType ModificationDetectionCode -> Bool
$c/= :: PacketType ModificationDetectionCode
-> PacketType ModificationDetectionCode -> Bool
== :: PacketType ModificationDetectionCode
-> PacketType ModificationDetectionCode -> Bool
$c== :: PacketType ModificationDetectionCode
-> PacketType ModificationDetectionCode -> Bool
Eq)
  packetType :: ModificationDetectionCode -> PacketType ModificationDetectionCode
packetType _ = PacketType ModificationDetectionCode
ModificationDetectionCodeType
  packetCode :: PacketType ModificationDetectionCode -> PacketVersion
packetCode _ = 19
  toPkt :: ModificationDetectionCode -> Pkt
toPkt (ModificationDetectionCode a :: ByteString
a) = ByteString -> Pkt
ModificationDetectionCodePkt ByteString
a
  fromPkt :: Pkt -> ModificationDetectionCode
fromPkt (ModificationDetectionCodePkt a :: ByteString
a) = ByteString -> ModificationDetectionCode
ModificationDetectionCode ByteString
a
  fromPkt _ = String -> ModificationDetectionCode
forall a. HasCallStack => String -> a
error "Cannot coerce non-ModificationDetectionCode packet"

instance Pretty ModificationDetectionCode where
  pretty :: ModificationDetectionCode -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (ModificationDetectionCode -> Pkt)
-> ModificationDetectionCode
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ModificationDetectionCode -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data OtherPacket =
  OtherPacket
    { OtherPacket -> PacketVersion
_otherPacketType :: Word8
    , OtherPacket -> ByteString
_otherPacketPayload :: ByteString
    }
  deriving (Typeable OtherPacket
DataType
Constr
Typeable OtherPacket =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> OtherPacket -> c OtherPacket)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c OtherPacket)
-> (OtherPacket -> Constr)
-> (OtherPacket -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c OtherPacket))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c OtherPacket))
-> ((forall b. Data b => b -> b) -> OtherPacket -> OtherPacket)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> OtherPacket -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> OtherPacket -> r)
-> (forall u. (forall d. Data d => d -> u) -> OtherPacket -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> OtherPacket -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket)
-> Data OtherPacket
OtherPacket -> DataType
OtherPacket -> Constr
(forall b. Data b => b -> b) -> OtherPacket -> OtherPacket
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OtherPacket -> c OtherPacket
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OtherPacket
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> OtherPacket -> u
forall u. (forall d. Data d => d -> u) -> OtherPacket -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OtherPacket -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OtherPacket -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OtherPacket
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OtherPacket -> c OtherPacket
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OtherPacket)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OtherPacket)
$cOtherPacket :: Constr
$tOtherPacket :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
gmapMp :: (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
gmapM :: (forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> OtherPacket -> m OtherPacket
gmapQi :: Int -> (forall d. Data d => d -> u) -> OtherPacket -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> OtherPacket -> u
gmapQ :: (forall d. Data d => d -> u) -> OtherPacket -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> OtherPacket -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OtherPacket -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> OtherPacket -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OtherPacket -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> OtherPacket -> r
gmapT :: (forall b. Data b => b -> b) -> OtherPacket -> OtherPacket
$cgmapT :: (forall b. Data b => b -> b) -> OtherPacket -> OtherPacket
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OtherPacket)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c OtherPacket)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c OtherPacket)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c OtherPacket)
dataTypeOf :: OtherPacket -> DataType
$cdataTypeOf :: OtherPacket -> DataType
toConstr :: OtherPacket -> Constr
$ctoConstr :: OtherPacket -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OtherPacket
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c OtherPacket
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OtherPacket -> c OtherPacket
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> OtherPacket -> c OtherPacket
$cp1Data :: Typeable OtherPacket
Data, OtherPacket -> OtherPacket -> Bool
(OtherPacket -> OtherPacket -> Bool)
-> (OtherPacket -> OtherPacket -> Bool) -> Eq OtherPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: OtherPacket -> OtherPacket -> Bool
$c/= :: OtherPacket -> OtherPacket -> Bool
== :: OtherPacket -> OtherPacket -> Bool
$c== :: OtherPacket -> OtherPacket -> Bool
Eq, Int -> OtherPacket -> ShowS
[OtherPacket] -> ShowS
OtherPacket -> String
(Int -> OtherPacket -> ShowS)
-> (OtherPacket -> String)
-> ([OtherPacket] -> ShowS)
-> Show OtherPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [OtherPacket] -> ShowS
$cshowList :: [OtherPacket] -> ShowS
show :: OtherPacket -> String
$cshow :: OtherPacket -> String
showsPrec :: Int -> OtherPacket -> ShowS
$cshowsPrec :: Int -> OtherPacket -> ShowS
Show, Typeable)

instance Packet OtherPacket where
  data PacketType OtherPacket = OtherPacketType
                                deriving (Int -> PacketType OtherPacket -> ShowS
[PacketType OtherPacket] -> ShowS
PacketType OtherPacket -> String
(Int -> PacketType OtherPacket -> ShowS)
-> (PacketType OtherPacket -> String)
-> ([PacketType OtherPacket] -> ShowS)
-> Show (PacketType OtherPacket)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType OtherPacket] -> ShowS
$cshowList :: [PacketType OtherPacket] -> ShowS
show :: PacketType OtherPacket -> String
$cshow :: PacketType OtherPacket -> String
showsPrec :: Int -> PacketType OtherPacket -> ShowS
$cshowsPrec :: Int -> PacketType OtherPacket -> ShowS
Show, PacketType OtherPacket -> PacketType OtherPacket -> Bool
(PacketType OtherPacket -> PacketType OtherPacket -> Bool)
-> (PacketType OtherPacket -> PacketType OtherPacket -> Bool)
-> Eq (PacketType OtherPacket)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType OtherPacket -> PacketType OtherPacket -> Bool
$c/= :: PacketType OtherPacket -> PacketType OtherPacket -> Bool
== :: PacketType OtherPacket -> PacketType OtherPacket -> Bool
$c== :: PacketType OtherPacket -> PacketType OtherPacket -> Bool
Eq)
  packetType :: OtherPacket -> PacketType OtherPacket
packetType _ = PacketType OtherPacket
OtherPacketType
  packetCode :: PacketType OtherPacket -> PacketVersion
packetCode _ = PacketVersion
forall a. HasCallStack => a
undefined -- FIXME
  toPkt :: OtherPacket -> Pkt
toPkt (OtherPacket a :: PacketVersion
a b :: ByteString
b) = PacketVersion -> ByteString -> Pkt
OtherPacketPkt PacketVersion
a ByteString
b
  fromPkt :: Pkt -> OtherPacket
fromPkt (OtherPacketPkt a :: PacketVersion
a b :: ByteString
b) = PacketVersion -> ByteString -> OtherPacket
OtherPacket PacketVersion
a ByteString
b
  fromPkt _ = String -> OtherPacket
forall a. HasCallStack => String -> a
error "Cannot coerce non-OtherPacket packet"

instance Pretty OtherPacket where
  pretty :: OtherPacket -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann) -> (OtherPacket -> Pkt) -> OtherPacket -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. OtherPacket -> Pkt
forall a. Packet a => a -> Pkt
toPkt

data BrokenPacket =
  BrokenPacket
    { BrokenPacket -> String
_brokenPacketParseError :: String
    , BrokenPacket -> PacketVersion
_brokenPacketType :: Word8
    , BrokenPacket -> ByteString
_brokenPacketPayload :: ByteString
    }
  deriving (Typeable BrokenPacket
DataType
Constr
Typeable BrokenPacket =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> BrokenPacket -> c BrokenPacket)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c BrokenPacket)
-> (BrokenPacket -> Constr)
-> (BrokenPacket -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c BrokenPacket))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c BrokenPacket))
-> ((forall b. Data b => b -> b) -> BrokenPacket -> BrokenPacket)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r)
-> (forall u. (forall d. Data d => d -> u) -> BrokenPacket -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> BrokenPacket -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket)
-> Data BrokenPacket
BrokenPacket -> DataType
BrokenPacket -> Constr
(forall b. Data b => b -> b) -> BrokenPacket -> BrokenPacket
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BrokenPacket -> c BrokenPacket
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BrokenPacket
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> BrokenPacket -> u
forall u. (forall d. Data d => d -> u) -> BrokenPacket -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BrokenPacket
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BrokenPacket -> c BrokenPacket
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BrokenPacket)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BrokenPacket)
$cBrokenPacket :: Constr
$tBrokenPacket :: DataType
gmapMo :: (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
gmapMp :: (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
gmapM :: (forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> BrokenPacket -> m BrokenPacket
gmapQi :: Int -> (forall d. Data d => d -> u) -> BrokenPacket -> u
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> BrokenPacket -> u
gmapQ :: (forall d. Data d => d -> u) -> BrokenPacket -> [u]
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> BrokenPacket -> [u]
gmapQr :: (r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r
gmapQl :: (r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> BrokenPacket -> r
gmapT :: (forall b. Data b => b -> b) -> BrokenPacket -> BrokenPacket
$cgmapT :: (forall b. Data b => b -> b) -> BrokenPacket -> BrokenPacket
dataCast2 :: (forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BrokenPacket)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c BrokenPacket)
dataCast1 :: (forall d. Data d => c (t d)) -> Maybe (c BrokenPacket)
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c BrokenPacket)
dataTypeOf :: BrokenPacket -> DataType
$cdataTypeOf :: BrokenPacket -> DataType
toConstr :: BrokenPacket -> Constr
$ctoConstr :: BrokenPacket -> Constr
gunfold :: (forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BrokenPacket
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c BrokenPacket
gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BrokenPacket -> c BrokenPacket
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> BrokenPacket -> c BrokenPacket
$cp1Data :: Typeable BrokenPacket
Data, BrokenPacket -> BrokenPacket -> Bool
(BrokenPacket -> BrokenPacket -> Bool)
-> (BrokenPacket -> BrokenPacket -> Bool) -> Eq BrokenPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: BrokenPacket -> BrokenPacket -> Bool
$c/= :: BrokenPacket -> BrokenPacket -> Bool
== :: BrokenPacket -> BrokenPacket -> Bool
$c== :: BrokenPacket -> BrokenPacket -> Bool
Eq, Int -> BrokenPacket -> ShowS
[BrokenPacket] -> ShowS
BrokenPacket -> String
(Int -> BrokenPacket -> ShowS)
-> (BrokenPacket -> String)
-> ([BrokenPacket] -> ShowS)
-> Show BrokenPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [BrokenPacket] -> ShowS
$cshowList :: [BrokenPacket] -> ShowS
show :: BrokenPacket -> String
$cshow :: BrokenPacket -> String
showsPrec :: Int -> BrokenPacket -> ShowS
$cshowsPrec :: Int -> BrokenPacket -> ShowS
Show, Typeable)

instance Packet BrokenPacket where
  data PacketType BrokenPacket = BrokenPacketType
                                 deriving (Int -> PacketType BrokenPacket -> ShowS
[PacketType BrokenPacket] -> ShowS
PacketType BrokenPacket -> String
(Int -> PacketType BrokenPacket -> ShowS)
-> (PacketType BrokenPacket -> String)
-> ([PacketType BrokenPacket] -> ShowS)
-> Show (PacketType BrokenPacket)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [PacketType BrokenPacket] -> ShowS
$cshowList :: [PacketType BrokenPacket] -> ShowS
show :: PacketType BrokenPacket -> String
$cshow :: PacketType BrokenPacket -> String
showsPrec :: Int -> PacketType BrokenPacket -> ShowS
$cshowsPrec :: Int -> PacketType BrokenPacket -> ShowS
Show, PacketType BrokenPacket -> PacketType BrokenPacket -> Bool
(PacketType BrokenPacket -> PacketType BrokenPacket -> Bool)
-> (PacketType BrokenPacket -> PacketType BrokenPacket -> Bool)
-> Eq (PacketType BrokenPacket)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: PacketType BrokenPacket -> PacketType BrokenPacket -> Bool
$c/= :: PacketType BrokenPacket -> PacketType BrokenPacket -> Bool
== :: PacketType BrokenPacket -> PacketType BrokenPacket -> Bool
$c== :: PacketType BrokenPacket -> PacketType BrokenPacket -> Bool
Eq)
  packetType :: BrokenPacket -> PacketType BrokenPacket
packetType _ = PacketType BrokenPacket
BrokenPacketType
  packetCode :: PacketType BrokenPacket -> PacketVersion
packetCode _ = PacketVersion
forall a. HasCallStack => a
undefined
  toPkt :: BrokenPacket -> Pkt
toPkt (BrokenPacket a :: String
a b :: PacketVersion
b c :: ByteString
c) = String -> PacketVersion -> ByteString -> Pkt
BrokenPacketPkt String
a PacketVersion
b ByteString
c
  fromPkt :: Pkt -> BrokenPacket
fromPkt (BrokenPacketPkt a :: String
a b :: PacketVersion
b c :: ByteString
c) = String -> PacketVersion -> ByteString -> BrokenPacket
BrokenPacket String
a PacketVersion
b ByteString
c
  fromPkt _ = String -> BrokenPacket
forall a. HasCallStack => String -> a
error "Cannot coerce non-BrokenPacket packet"

instance Pretty BrokenPacket where
  pretty :: BrokenPacket -> Doc ann
pretty = Pkt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Pkt -> Doc ann)
-> (BrokenPacket -> Pkt) -> BrokenPacket -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. BrokenPacket -> Pkt
forall a. Packet a => a -> Pkt
toPkt

$(makeLenses ''PKESK)

$(makeLenses ''Signature)

$(makeLenses ''SKESK)

$(makeLenses ''OnePassSignature)

$(makeLenses ''SecretKey)

$(makeLenses ''PKPayload)

$(makeLenses ''PublicKey)

$(makeLenses ''SecretSubkey)

$(makeLenses ''CompressedData)

$(makeLenses ''SymEncData)

$(makeLenses ''Marker)

$(makeLenses ''LiteralData)

$(makeLenses ''Trust)

$(makeLenses ''UserId)

$(makeLenses ''PublicSubkey)

$(makeLenses ''UserAttribute)

$(makeLenses ''SymEncIntegrityProtectedData)

$(makeLenses ''ModificationDetectionCode)

$(makeLenses ''OtherPacket)

$(makeLenses ''BrokenPacket)