-- Base.hs: OpenPGP (RFC9580) data types
-- Copyright © 2012-2026  Clint Adams
-- This software is released under the terms of the Expat license.
-- (See the LICENSE file).

{-# LANGUAGE CPP #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE DataKinds #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE DeriveGeneric #-}
{-# LANGUAGE ExistentialQuantification #-}
{-# LANGUAGE GADTs #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE KindSignatures #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE PatternSynonyms #-}
{-# LANGUAGE StandaloneDeriving #-}
{-# LANGUAGE TemplateHaskell #-}

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

import GHC.Generics (Generic)

import Codec.Encryption.OpenPGP.Types.Internal.PrettyUtils (prettyLBS)
import Control.Applicative ((<|>))
import Control.Arrow ((***))
import Control.Lens (makeLenses, op, Wrapped)
import Control.Monad (mzero)
import Data.Bits ((.&.))
import Data.Aeson ((.=), object)
import qualified Data.Aeson as A
import qualified Data.Aeson.Key as AK
import qualified Data.Aeson.TH as ATH
import Data.ByteArray (ByteArrayAccess)
import qualified Data.ByteString as B
import qualified Data.ByteString.Base16.Lazy as B16L
import Data.ByteString.Lazy (ByteString)
import qualified Data.ByteString.Lazy as BL
import qualified Data.ByteString.Lazy.Char8 as BLC8
import Data.Char (toLower, toUpper)
import Data.Data (Data)
import Data.Hashable (Hashable(..))
import Data.Int (Int64)
import Data.Kind (Type)
import Data.List (unfoldr)
import Data.List.NonEmpty (NonEmpty)
import qualified Data.List.NonEmpty as NE
import Data.List.Split (chunksOf)
import Data.Maybe (fromMaybe)
import Data.Ord (comparing)
import Data.Set (Set)
import qualified Data.Set as Set
import Data.Text (Text)
import qualified Data.Text as T
import Data.Time.Clock.POSIX (posixSecondsToUTCTime)
import Data.Time.Format (formatTime)
import Data.Time.Locale.Compat (defaultTimeLocale)
import Data.Typeable (Typeable)
import Data.Word (Word16, Word32, Word8)
import Network.URI (URI(..), nullURI, parseURI, uriToString)
import Numeric (readHex)
import Prettyprinter (Pretty(..), (<+>), hsep, punctuate, space)
import Data.IORef (IORef, atomicModifyIORef', newIORef)
import System.IO.Unsafe (unsafePerformIO)

type Exportability = Bool

type TrustLevel = Word8

type TrustAmount = Word8

type AlmostPublicDomainRegex = ByteString

type Revocability = Bool

type RevocationReason = Text

type KeyServer = ByteString

type SignatureHash = ByteString

type PacketVersion = Word8

type V3Expiration = Word16

type CompressedDataPayload = ByteString

type FileName = ByteString

type ImageData = ByteString

type NestedFlag = Bool

-- | Phantom types for tracking subpacket classification and signature version
-- These types are never instantiated; they exist purely for compile-time type safety.

-- | Phantom marker for hashed subpackets (included in signature hash computation)
data Hashed

-- | Phantom marker for unhashed subpackets (not included in signature hash computation)
data Unhashed

-- | Phantom marker for v4 signatures (8-octet issuer, no salt)
data V4Sig

-- | Phantom marker for v6 signatures (fingerprint issuer, requires salt)
data V6Sig

data ByteRange =
  ByteRange
    { ByteRange -> Int64
_rangeOffset :: Int64
    , ByteRange -> Int64
_rangeLength :: Int64
    }
  deriving (Typeable ByteRange
Typeable ByteRange =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ByteRange -> c ByteRange)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ByteRange)
-> (ByteRange -> Constr)
-> (ByteRange -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ByteRange))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteRange))
-> ((forall b. Data b => b -> b) -> ByteRange -> ByteRange)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteRange -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ByteRange -> r)
-> (forall u. (forall d. Data d => d -> u) -> ByteRange -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ByteRange -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ByteRange -> m ByteRange)
-> Data ByteRange
ByteRange -> Constr
ByteRange -> DataType
(forall b. Data b => b -> b) -> ByteRange -> ByteRange
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) -> ByteRange -> u
forall u. (forall d. Data d => d -> u) -> ByteRange -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ByteRange -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ByteRange -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ByteRange
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ByteRange -> c ByteRange
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ByteRange)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteRange)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ByteRange -> c ByteRange
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ByteRange -> c ByteRange
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ByteRange
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ByteRange
$ctoConstr :: ByteRange -> Constr
toConstr :: ByteRange -> Constr
$cdataTypeOf :: ByteRange -> DataType
dataTypeOf :: ByteRange -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ByteRange)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ByteRange)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteRange)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ByteRange)
$cgmapT :: (forall b. Data b => b -> b) -> ByteRange -> ByteRange
gmapT :: (forall b. Data b => b -> b) -> ByteRange -> ByteRange
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ByteRange -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ByteRange -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ByteRange -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ByteRange -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ByteRange -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ByteRange -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ByteRange -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ByteRange -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ByteRange -> m ByteRange
Data, ByteRange -> ByteRange -> Bool
(ByteRange -> ByteRange -> Bool)
-> (ByteRange -> ByteRange -> Bool) -> Eq ByteRange
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ByteRange -> ByteRange -> Bool
== :: ByteRange -> ByteRange -> Bool
$c/= :: ByteRange -> ByteRange -> Bool
/= :: ByteRange -> ByteRange -> Bool
Eq, (forall x. ByteRange -> Rep ByteRange x)
-> (forall x. Rep ByteRange x -> ByteRange) -> Generic ByteRange
forall x. Rep ByteRange x -> ByteRange
forall x. ByteRange -> Rep ByteRange x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ByteRange -> Rep ByteRange x
from :: forall x. ByteRange -> Rep ByteRange x
$cto :: forall x. Rep ByteRange x -> ByteRange
to :: forall x. Rep ByteRange x -> ByteRange
Generic, Eq ByteRange
Eq ByteRange =>
(ByteRange -> ByteRange -> Ordering)
-> (ByteRange -> ByteRange -> Bool)
-> (ByteRange -> ByteRange -> Bool)
-> (ByteRange -> ByteRange -> Bool)
-> (ByteRange -> ByteRange -> Bool)
-> (ByteRange -> ByteRange -> ByteRange)
-> (ByteRange -> ByteRange -> ByteRange)
-> Ord ByteRange
ByteRange -> ByteRange -> Bool
ByteRange -> ByteRange -> Ordering
ByteRange -> ByteRange -> ByteRange
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ByteRange -> ByteRange -> Ordering
compare :: ByteRange -> ByteRange -> Ordering
$c< :: ByteRange -> ByteRange -> Bool
< :: ByteRange -> ByteRange -> Bool
$c<= :: ByteRange -> ByteRange -> Bool
<= :: ByteRange -> ByteRange -> Bool
$c> :: ByteRange -> ByteRange -> Bool
> :: ByteRange -> ByteRange -> Bool
$c>= :: ByteRange -> ByteRange -> Bool
>= :: ByteRange -> ByteRange -> Bool
$cmax :: ByteRange -> ByteRange -> ByteRange
max :: ByteRange -> ByteRange -> ByteRange
$cmin :: ByteRange -> ByteRange -> ByteRange
min :: ByteRange -> ByteRange -> ByteRange
Ord, Int -> ByteRange -> ShowS
[ByteRange] -> ShowS
ByteRange -> String
(Int -> ByteRange -> ShowS)
-> (ByteRange -> String)
-> ([ByteRange] -> ShowS)
-> Show ByteRange
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ByteRange -> ShowS
showsPrec :: Int -> ByteRange -> ShowS
$cshow :: ByteRange -> String
show :: ByteRange -> String
$cshowList :: [ByteRange] -> ShowS
showList :: [ByteRange] -> ShowS
Show, Typeable)

newtype WireRepSourceId =
  WireRepSourceId
    { WireRepSourceId -> Int64
_unWireRepSourceId :: Int64
    }
  deriving (Typeable WireRepSourceId
Typeable WireRepSourceId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> WireRepSourceId -> c WireRepSourceId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WireRepSourceId)
-> (WireRepSourceId -> Constr)
-> (WireRepSourceId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WireRepSourceId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c WireRepSourceId))
-> ((forall b. Data b => b -> b)
    -> WireRepSourceId -> WireRepSourceId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> WireRepSourceId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> WireRepSourceId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> WireRepSourceId -> m WireRepSourceId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WireRepSourceId -> m WireRepSourceId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> WireRepSourceId -> m WireRepSourceId)
-> Data WireRepSourceId
WireRepSourceId -> Constr
WireRepSourceId -> DataType
(forall b. Data b => b -> b) -> WireRepSourceId -> WireRepSourceId
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) -> WireRepSourceId -> u
forall u. (forall d. Data d => d -> u) -> WireRepSourceId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireRepSourceId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireRepSourceId -> c WireRepSourceId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireRepSourceId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WireRepSourceId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireRepSourceId -> c WireRepSourceId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireRepSourceId -> c WireRepSourceId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireRepSourceId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireRepSourceId
$ctoConstr :: WireRepSourceId -> Constr
toConstr :: WireRepSourceId -> Constr
$cdataTypeOf :: WireRepSourceId -> DataType
dataTypeOf :: WireRepSourceId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireRepSourceId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireRepSourceId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WireRepSourceId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c WireRepSourceId)
$cgmapT :: (forall b. Data b => b -> b) -> WireRepSourceId -> WireRepSourceId
gmapT :: (forall b. Data b => b -> b) -> WireRepSourceId -> WireRepSourceId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepSourceId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WireRepSourceId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> WireRepSourceId -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> WireRepSourceId -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> WireRepSourceId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> WireRepSourceId -> m WireRepSourceId
Data, WireRepSourceId -> WireRepSourceId -> Bool
(WireRepSourceId -> WireRepSourceId -> Bool)
-> (WireRepSourceId -> WireRepSourceId -> Bool)
-> Eq WireRepSourceId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WireRepSourceId -> WireRepSourceId -> Bool
== :: WireRepSourceId -> WireRepSourceId -> Bool
$c/= :: WireRepSourceId -> WireRepSourceId -> Bool
/= :: WireRepSourceId -> WireRepSourceId -> Bool
Eq, (forall x. WireRepSourceId -> Rep WireRepSourceId x)
-> (forall x. Rep WireRepSourceId x -> WireRepSourceId)
-> Generic WireRepSourceId
forall x. Rep WireRepSourceId x -> WireRepSourceId
forall x. WireRepSourceId -> Rep WireRepSourceId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WireRepSourceId -> Rep WireRepSourceId x
from :: forall x. WireRepSourceId -> Rep WireRepSourceId x
$cto :: forall x. Rep WireRepSourceId x -> WireRepSourceId
to :: forall x. Rep WireRepSourceId x -> WireRepSourceId
Generic, Eq WireRepSourceId
Eq WireRepSourceId =>
(WireRepSourceId -> WireRepSourceId -> Ordering)
-> (WireRepSourceId -> WireRepSourceId -> Bool)
-> (WireRepSourceId -> WireRepSourceId -> Bool)
-> (WireRepSourceId -> WireRepSourceId -> Bool)
-> (WireRepSourceId -> WireRepSourceId -> Bool)
-> (WireRepSourceId -> WireRepSourceId -> WireRepSourceId)
-> (WireRepSourceId -> WireRepSourceId -> WireRepSourceId)
-> Ord WireRepSourceId
WireRepSourceId -> WireRepSourceId -> Bool
WireRepSourceId -> WireRepSourceId -> Ordering
WireRepSourceId -> WireRepSourceId -> WireRepSourceId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: WireRepSourceId -> WireRepSourceId -> Ordering
compare :: WireRepSourceId -> WireRepSourceId -> Ordering
$c< :: WireRepSourceId -> WireRepSourceId -> Bool
< :: WireRepSourceId -> WireRepSourceId -> Bool
$c<= :: WireRepSourceId -> WireRepSourceId -> Bool
<= :: WireRepSourceId -> WireRepSourceId -> Bool
$c> :: WireRepSourceId -> WireRepSourceId -> Bool
> :: WireRepSourceId -> WireRepSourceId -> Bool
$c>= :: WireRepSourceId -> WireRepSourceId -> Bool
>= :: WireRepSourceId -> WireRepSourceId -> Bool
$cmax :: WireRepSourceId -> WireRepSourceId -> WireRepSourceId
max :: WireRepSourceId -> WireRepSourceId -> WireRepSourceId
$cmin :: WireRepSourceId -> WireRepSourceId -> WireRepSourceId
min :: WireRepSourceId -> WireRepSourceId -> WireRepSourceId
Ord, Int -> WireRepSourceId -> ShowS
[WireRepSourceId] -> ShowS
WireRepSourceId -> String
(Int -> WireRepSourceId -> ShowS)
-> (WireRepSourceId -> String)
-> ([WireRepSourceId] -> ShowS)
-> Show WireRepSourceId
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WireRepSourceId -> ShowS
showsPrec :: Int -> WireRepSourceId -> ShowS
$cshow :: WireRepSourceId -> String
show :: WireRepSourceId -> String
$cshowList :: [WireRepSourceId] -> ShowS
showList :: [WireRepSourceId] -> ShowS
Show, Typeable)

data WireRepRef =
  WireRepRef
    { WireRepRef -> WireRepSourceId
_wireRepSourceId :: WireRepSourceId
    , WireRepRef -> Int64
_wireRepLength :: Int64
    , WireRepRef -> Maybe Text
_wireRepName :: Maybe Text
    , WireRepRef -> Bool
_wireRepWasOriginallyArmored :: Bool
    }
  deriving (Typeable WireRepRef
Typeable WireRepRef =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> WireRepRef -> c WireRepRef)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c WireRepRef)
-> (WireRepRef -> Constr)
-> (WireRepRef -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c WireRepRef))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c WireRepRef))
-> ((forall b. Data b => b -> b) -> WireRepRef -> WireRepRef)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> WireRepRef -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> WireRepRef -> r)
-> (forall u. (forall d. Data d => d -> u) -> WireRepRef -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> WireRepRef -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef)
-> Data WireRepRef
WireRepRef -> Constr
WireRepRef -> DataType
(forall b. Data b => b -> b) -> WireRepRef -> WireRepRef
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) -> WireRepRef -> u
forall u. (forall d. Data d => d -> u) -> WireRepRef -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepRef -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepRef -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireRepRef
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireRepRef -> c WireRepRef
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireRepRef)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireRepRef)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireRepRef -> c WireRepRef
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> WireRepRef -> c WireRepRef
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireRepRef
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c WireRepRef
$ctoConstr :: WireRepRef -> Constr
toConstr :: WireRepRef -> Constr
$cdataTypeOf :: WireRepRef -> DataType
dataTypeOf :: WireRepRef -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireRepRef)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c WireRepRef)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireRepRef)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c WireRepRef)
$cgmapT :: (forall b. Data b => b -> b) -> WireRepRef -> WireRepRef
gmapT :: (forall b. Data b => b -> b) -> WireRepRef -> WireRepRef
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepRef -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepRef -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepRef -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> WireRepRef -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> WireRepRef -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> WireRepRef -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WireRepRef -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> WireRepRef -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> WireRepRef -> m WireRepRef
Data, WireRepRef -> WireRepRef -> Bool
(WireRepRef -> WireRepRef -> Bool)
-> (WireRepRef -> WireRepRef -> Bool) -> Eq WireRepRef
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: WireRepRef -> WireRepRef -> Bool
== :: WireRepRef -> WireRepRef -> Bool
$c/= :: WireRepRef -> WireRepRef -> Bool
/= :: WireRepRef -> WireRepRef -> Bool
Eq, (forall x. WireRepRef -> Rep WireRepRef x)
-> (forall x. Rep WireRepRef x -> WireRepRef) -> Generic WireRepRef
forall x. Rep WireRepRef x -> WireRepRef
forall x. WireRepRef -> Rep WireRepRef x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. WireRepRef -> Rep WireRepRef x
from :: forall x. WireRepRef -> Rep WireRepRef x
$cto :: forall x. Rep WireRepRef x -> WireRepRef
to :: forall x. Rep WireRepRef x -> WireRepRef
Generic, Eq WireRepRef
Eq WireRepRef =>
(WireRepRef -> WireRepRef -> Ordering)
-> (WireRepRef -> WireRepRef -> Bool)
-> (WireRepRef -> WireRepRef -> Bool)
-> (WireRepRef -> WireRepRef -> Bool)
-> (WireRepRef -> WireRepRef -> Bool)
-> (WireRepRef -> WireRepRef -> WireRepRef)
-> (WireRepRef -> WireRepRef -> WireRepRef)
-> Ord WireRepRef
WireRepRef -> WireRepRef -> Bool
WireRepRef -> WireRepRef -> Ordering
WireRepRef -> WireRepRef -> WireRepRef
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: WireRepRef -> WireRepRef -> Ordering
compare :: WireRepRef -> WireRepRef -> Ordering
$c< :: WireRepRef -> WireRepRef -> Bool
< :: WireRepRef -> WireRepRef -> Bool
$c<= :: WireRepRef -> WireRepRef -> Bool
<= :: WireRepRef -> WireRepRef -> Bool
$c> :: WireRepRef -> WireRepRef -> Bool
> :: WireRepRef -> WireRepRef -> Bool
$c>= :: WireRepRef -> WireRepRef -> Bool
>= :: WireRepRef -> WireRepRef -> Bool
$cmax :: WireRepRef -> WireRepRef -> WireRepRef
max :: WireRepRef -> WireRepRef -> WireRepRef
$cmin :: WireRepRef -> WireRepRef -> WireRepRef
min :: WireRepRef -> WireRepRef -> WireRepRef
Ord, Int -> WireRepRef -> ShowS
[WireRepRef] -> ShowS
WireRepRef -> String
(Int -> WireRepRef -> ShowS)
-> (WireRepRef -> String)
-> ([WireRepRef] -> ShowS)
-> Show WireRepRef
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> WireRepRef -> ShowS
showsPrec :: Int -> WireRepRef -> ShowS
$cshow :: WireRepRef -> String
show :: WireRepRef -> String
$cshowList :: [WireRepRef] -> ShowS
showList :: [WireRepRef] -> ShowS
Show, Typeable)

type WireRepRefs = NonEmpty WireRepRef

wireRepRef :: ByteString -> WireRepRef
wireRepRef :: ByteString -> WireRepRef
wireRepRef = Maybe Text -> Bool -> Int64 -> WireRepRef
mkWireRepRefWithLength Maybe Text
forall a. Maybe a
Nothing Bool
False (Int64 -> WireRepRef)
-> (ByteString -> Int64) -> ByteString -> WireRepRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
BL.length

namedWireRepRef :: Text -> ByteString -> WireRepRef
namedWireRepRef :: Text -> ByteString -> WireRepRef
namedWireRepRef Text
name = Maybe Text -> Bool -> Int64 -> WireRepRef
mkWireRepRefWithLength (Text -> Maybe Text
forall a. a -> Maybe a
Just Text
name) Bool
False (Int64 -> WireRepRef)
-> (ByteString -> Int64) -> ByteString -> WireRepRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
BL.length

mkWireRepRefWithLength ::
     Maybe Text -> Bool -> Int64 -> WireRepRef
mkWireRepRefWithLength :: Maybe Text -> Bool -> Int64 -> WireRepRef
mkWireRepRefWithLength Maybe Text
mname Bool
wasOriginallyArmored Int64
payloadLen =
  WireRepRef
    { _wireRepSourceId :: WireRepSourceId
_wireRepSourceId = Int64 -> WireRepSourceId
freshWireRepSourceId Int64
payloadLen
    , _wireRepLength :: Int64
_wireRepLength = Int64
payloadLen
    , _wireRepName :: Maybe Text
_wireRepName = Maybe Text
mname
    , _wireRepWasOriginallyArmored :: Bool
_wireRepWasOriginallyArmored = Bool
wasOriginallyArmored
    }

mkWireRepRef :: Maybe Text -> Bool -> ByteString -> WireRepRef
mkWireRepRef :: Maybe Text -> Bool -> ByteString -> WireRepRef
mkWireRepRef Maybe Text
mname Bool
wasOriginallyArmored =
  Maybe Text -> Bool -> Int64 -> WireRepRef
mkWireRepRefWithLength Maybe Text
mname Bool
wasOriginallyArmored (Int64 -> WireRepRef)
-> (ByteString -> Int64) -> ByteString -> WireRepRef
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> Int64
BL.length

wireRepSourceCounter :: IORef Int64
wireRepSourceCounter :: IORef Int64
wireRepSourceCounter = IO (IORef Int64) -> IORef Int64
forall a. IO a -> a
unsafePerformIO (Int64 -> IO (IORef Int64)
forall a. a -> IO (IORef a)
newIORef Int64
0)
{-# NOINLINE wireRepSourceCounter #-}

freshWireRepSourceId :: Int64 -> WireRepSourceId
freshWireRepSourceId :: Int64 -> WireRepSourceId
freshWireRepSourceId !Int64
_ =
  IO WireRepSourceId -> WireRepSourceId
forall a. IO a -> a
unsafePerformIO (IO WireRepSourceId -> WireRepSourceId)
-> IO WireRepSourceId -> WireRepSourceId
forall a b. (a -> b) -> a -> b
$
    IORef Int64
-> (Int64 -> (Int64, WireRepSourceId)) -> IO WireRepSourceId
forall a b. IORef a -> (a -> (a, b)) -> IO b
atomicModifyIORef' IORef Int64
wireRepSourceCounter (\Int64
n -> let n' :: Int64
n' = Int64
n Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ Int64
1 in (Int64
n', Int64 -> WireRepSourceId
WireRepSourceId Int64
n'))
{-# NOINLINE freshWireRepSourceId #-}

rangeEnd :: ByteRange -> Int64
rangeEnd :: ByteRange -> Int64
rangeEnd ByteRange
r = ByteRange -> Int64
_rangeOffset ByteRange
r Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
+ ByteRange -> Int64
_rangeLength ByteRange
r

spanByteRanges :: [ByteRange] -> Maybe ByteRange
spanByteRanges :: [ByteRange] -> Maybe ByteRange
spanByteRanges [] = Maybe ByteRange
forall a. Maybe a
Nothing
spanByteRanges (ByteRange
r:[ByteRange]
rs) =
  let start :: Int64
start = [Int64] -> Int64
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
minimum (ByteRange -> Int64
_rangeOffset (ByteRange -> Int64) -> [ByteRange] -> [Int64]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ByteRange
r ByteRange -> [ByteRange] -> [ByteRange]
forall a. a -> [a] -> [a]
: [ByteRange]
rs))
      ending :: Int64
ending = [Int64] -> Int64
forall a. Ord a => [a] -> a
forall (t :: * -> *) a. (Foldable t, Ord a) => t a -> a
maximum (ByteRange -> Int64
rangeEnd (ByteRange -> Int64) -> [ByteRange] -> [Int64]
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ByteRange
r ByteRange -> [ByteRange] -> [ByteRange]
forall a. a -> [a] -> [a]
: [ByteRange]
rs))
   in ByteRange -> Maybe ByteRange
forall a. a -> Maybe a
Just (Int64 -> Int64 -> ByteRange
ByteRange Int64
start (Int64
ending Int64 -> Int64 -> Int64
forall a. Num a => a -> a -> a
- Int64
start))

$(makeLenses ''ByteRange)
$(makeLenses ''WireRepRef)

class (Eq a, Ord a) =>
      FutureFlag a
  where
  fromFFlag :: a -> Int
  toFFlag :: Int -> a

class (Eq a, Ord a) =>
      FutureVal a
  where
  fromFVal :: a -> Word8
  toFVal :: Word8 -> a

data SymmetricAlgorithm
  = Plaintext
  | IDEA
  | TripleDES
  | CAST5
  | Blowfish
  | ReservedSAFER
  | ReservedDES
  | AES128
  | AES192
  | AES256
  | Twofish
  | Camellia128
  | Camellia192
  | Camellia256
  | OtherSA Word8
  deriving (Typeable SymmetricAlgorithm
Typeable SymmetricAlgorithm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SymmetricAlgorithm
 -> c SymmetricAlgorithm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SymmetricAlgorithm)
-> (SymmetricAlgorithm -> Constr)
-> (SymmetricAlgorithm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SymmetricAlgorithm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SymmetricAlgorithm))
-> ((forall b. Data b => b -> b)
    -> SymmetricAlgorithm -> SymmetricAlgorithm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SymmetricAlgorithm -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SymmetricAlgorithm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SymmetricAlgorithm -> m SymmetricAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SymmetricAlgorithm -> m SymmetricAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SymmetricAlgorithm -> m SymmetricAlgorithm)
-> Data SymmetricAlgorithm
SymmetricAlgorithm -> Constr
SymmetricAlgorithm -> DataType
(forall b. Data b => b -> b)
-> SymmetricAlgorithm -> SymmetricAlgorithm
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) -> SymmetricAlgorithm -> u
forall u. (forall d. Data d => d -> u) -> SymmetricAlgorithm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymmetricAlgorithm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SymmetricAlgorithm
-> c SymmetricAlgorithm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymmetricAlgorithm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymmetricAlgorithm)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SymmetricAlgorithm
-> c SymmetricAlgorithm
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SymmetricAlgorithm
-> c SymmetricAlgorithm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymmetricAlgorithm
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SymmetricAlgorithm
$ctoConstr :: SymmetricAlgorithm -> Constr
toConstr :: SymmetricAlgorithm -> Constr
$cdataTypeOf :: SymmetricAlgorithm -> DataType
dataTypeOf :: SymmetricAlgorithm -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymmetricAlgorithm)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SymmetricAlgorithm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymmetricAlgorithm)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SymmetricAlgorithm)
$cgmapT :: (forall b. Data b => b -> b)
-> SymmetricAlgorithm -> SymmetricAlgorithm
gmapT :: (forall b. Data b => b -> b)
-> SymmetricAlgorithm -> SymmetricAlgorithm
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SymmetricAlgorithm -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SymmetricAlgorithm -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SymmetricAlgorithm -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SymmetricAlgorithm -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SymmetricAlgorithm -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SymmetricAlgorithm -> m SymmetricAlgorithm
Data, (forall x. SymmetricAlgorithm -> Rep SymmetricAlgorithm x)
-> (forall x. Rep SymmetricAlgorithm x -> SymmetricAlgorithm)
-> Generic SymmetricAlgorithm
forall x. Rep SymmetricAlgorithm x -> SymmetricAlgorithm
forall x. SymmetricAlgorithm -> Rep SymmetricAlgorithm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SymmetricAlgorithm -> Rep SymmetricAlgorithm x
from :: forall x. SymmetricAlgorithm -> Rep SymmetricAlgorithm x
$cto :: forall x. Rep SymmetricAlgorithm x -> SymmetricAlgorithm
to :: forall x. Rep SymmetricAlgorithm x -> SymmetricAlgorithm
Generic, Int -> SymmetricAlgorithm -> ShowS
[SymmetricAlgorithm] -> ShowS
SymmetricAlgorithm -> String
(Int -> SymmetricAlgorithm -> ShowS)
-> (SymmetricAlgorithm -> String)
-> ([SymmetricAlgorithm] -> ShowS)
-> Show SymmetricAlgorithm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SymmetricAlgorithm -> ShowS
showsPrec :: Int -> SymmetricAlgorithm -> ShowS
$cshow :: SymmetricAlgorithm -> String
show :: SymmetricAlgorithm -> String
$cshowList :: [SymmetricAlgorithm] -> ShowS
showList :: [SymmetricAlgorithm] -> ShowS
Show, Typeable)

instance Eq SymmetricAlgorithm where
  == :: SymmetricAlgorithm -> SymmetricAlgorithm -> Bool
(==) SymmetricAlgorithm
a SymmetricAlgorithm
b = SymmetricAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal SymmetricAlgorithm
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== SymmetricAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal SymmetricAlgorithm
b

instance Ord SymmetricAlgorithm where
  compare :: SymmetricAlgorithm -> SymmetricAlgorithm -> Ordering
compare = (SymmetricAlgorithm -> Word8)
-> SymmetricAlgorithm -> SymmetricAlgorithm -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing SymmetricAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal SymmetricAlgorithm where
  fromFVal :: SymmetricAlgorithm -> Word8
fromFVal SymmetricAlgorithm
Plaintext = Word8
0
  fromFVal SymmetricAlgorithm
IDEA = Word8
1
  fromFVal SymmetricAlgorithm
TripleDES = Word8
2
  fromFVal SymmetricAlgorithm
CAST5 = Word8
3
  fromFVal SymmetricAlgorithm
Blowfish = Word8
4
  fromFVal SymmetricAlgorithm
ReservedSAFER = Word8
5
  fromFVal SymmetricAlgorithm
ReservedDES = Word8
6
  fromFVal SymmetricAlgorithm
AES128 = Word8
7
  fromFVal SymmetricAlgorithm
AES192 = Word8
8
  fromFVal SymmetricAlgorithm
AES256 = Word8
9
  fromFVal SymmetricAlgorithm
Twofish = Word8
10
  fromFVal SymmetricAlgorithm
Camellia128 = Word8
11
  fromFVal SymmetricAlgorithm
Camellia192 = Word8
12
  fromFVal SymmetricAlgorithm
Camellia256 = Word8
13
  fromFVal (OtherSA Word8
o) = Word8
o
  toFVal :: Word8 -> SymmetricAlgorithm
toFVal Word8
0 = SymmetricAlgorithm
Plaintext
  toFVal Word8
1 = SymmetricAlgorithm
IDEA
  toFVal Word8
2 = SymmetricAlgorithm
TripleDES
  toFVal Word8
3 = SymmetricAlgorithm
CAST5
  toFVal Word8
4 = SymmetricAlgorithm
Blowfish
  toFVal Word8
5 = SymmetricAlgorithm
ReservedSAFER
  toFVal Word8
6 = SymmetricAlgorithm
ReservedDES
  toFVal Word8
7 = SymmetricAlgorithm
AES128
  toFVal Word8
8 = SymmetricAlgorithm
AES192
  toFVal Word8
9 = SymmetricAlgorithm
AES256
  toFVal Word8
10 = SymmetricAlgorithm
Twofish
  toFVal Word8
11 = SymmetricAlgorithm
Camellia128
  toFVal Word8
12 = SymmetricAlgorithm
Camellia192
  toFVal Word8
13 = SymmetricAlgorithm
Camellia256
  toFVal Word8
o = Word8 -> SymmetricAlgorithm
OtherSA Word8
o

instance Hashable SymmetricAlgorithm

instance Pretty SymmetricAlgorithm where
  pretty :: forall ann. SymmetricAlgorithm -> Doc ann
pretty SymmetricAlgorithm
Plaintext = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"plaintext"
  pretty SymmetricAlgorithm
IDEA = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"IDEA"
  pretty SymmetricAlgorithm
TripleDES = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"3DES"
  pretty SymmetricAlgorithm
CAST5 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"CAST-128"
  pretty SymmetricAlgorithm
Blowfish = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Blowfish"
  pretty SymmetricAlgorithm
ReservedSAFER = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"(reserved) SAFER"
  pretty SymmetricAlgorithm
ReservedDES = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"(reserved) DES"
  pretty SymmetricAlgorithm
AES128 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"AES-128"
  pretty SymmetricAlgorithm
AES192 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"AES-192"
  pretty SymmetricAlgorithm
AES256 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"AES-256"
  pretty SymmetricAlgorithm
Twofish = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Twofish"
  pretty SymmetricAlgorithm
Camellia128 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Camellia-128"
  pretty SymmetricAlgorithm
Camellia192 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Camellia-192"
  pretty SymmetricAlgorithm
Camellia256 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Camellia-256"
  pretty (OtherSA Word8
sa) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown symmetric algorithm" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
sa

$(ATH.deriveJSON ATH.defaultOptions ''SymmetricAlgorithm)

data NotationFlag
  = HumanReadable
  | OtherNF Word8
  deriving (Typeable NotationFlag
Typeable NotationFlag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NotationFlag -> c NotationFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NotationFlag)
-> (NotationFlag -> Constr)
-> (NotationFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NotationFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NotationFlag))
-> ((forall b. Data b => b -> b) -> NotationFlag -> NotationFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NotationFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NotationFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> NotationFlag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NotationFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag)
-> Data NotationFlag
NotationFlag -> Constr
NotationFlag -> DataType
(forall b. Data b => b -> b) -> NotationFlag -> NotationFlag
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) -> NotationFlag -> u
forall u. (forall d. Data d => d -> u) -> NotationFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationFlag -> c NotationFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationFlag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationFlag -> c NotationFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationFlag -> c NotationFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationFlag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationFlag
$ctoConstr :: NotationFlag -> Constr
toConstr :: NotationFlag -> Constr
$cdataTypeOf :: NotationFlag -> DataType
dataTypeOf :: NotationFlag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationFlag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationFlag)
$cgmapT :: (forall b. Data b => b -> b) -> NotationFlag -> NotationFlag
gmapT :: (forall b. Data b => b -> b) -> NotationFlag -> NotationFlag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationFlag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationFlag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NotationFlag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NotationFlag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NotationFlag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NotationFlag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationFlag -> m NotationFlag
Data, (forall x. NotationFlag -> Rep NotationFlag x)
-> (forall x. Rep NotationFlag x -> NotationFlag)
-> Generic NotationFlag
forall x. Rep NotationFlag x -> NotationFlag
forall x. NotationFlag -> Rep NotationFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NotationFlag -> Rep NotationFlag x
from :: forall x. NotationFlag -> Rep NotationFlag x
$cto :: forall x. Rep NotationFlag x -> NotationFlag
to :: forall x. Rep NotationFlag x -> NotationFlag
Generic, Int -> NotationFlag -> ShowS
[NotationFlag] -> ShowS
NotationFlag -> String
(Int -> NotationFlag -> ShowS)
-> (NotationFlag -> String)
-> ([NotationFlag] -> ShowS)
-> Show NotationFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NotationFlag -> ShowS
showsPrec :: Int -> NotationFlag -> ShowS
$cshow :: NotationFlag -> String
show :: NotationFlag -> String
$cshowList :: [NotationFlag] -> ShowS
showList :: [NotationFlag] -> ShowS
Show, Typeable)

mkNotationFlag :: Word8 -> NotationFlag
mkNotationFlag :: Word8 -> NotationFlag
mkNotationFlag Word8
o
  | Word8
o' Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0 = NotationFlag
HumanReadable
  | Bool
otherwise = Word8 -> NotationFlag
OtherNF Word8
o'
  where
    o' :: Word8
o' = Word8
o Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f

instance Eq NotationFlag where
  == :: NotationFlag -> NotationFlag -> Bool
(==) NotationFlag
a NotationFlag
b = NotationFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag NotationFlag
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== NotationFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag NotationFlag
b

instance Ord NotationFlag where
  compare :: NotationFlag -> NotationFlag -> Ordering
compare = (NotationFlag -> Int) -> NotationFlag -> NotationFlag -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing NotationFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag

instance FutureFlag NotationFlag where
  fromFFlag :: NotationFlag -> Int
fromFFlag NotationFlag
HumanReadable = Int
0
  fromFFlag (OtherNF Word8
o) = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
o Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x0f)
  toFFlag :: Int -> NotationFlag
toFFlag Int
0 = NotationFlag
HumanReadable
  toFFlag Int
o = Word8 -> NotationFlag
mkNotationFlag (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
o)

instance Hashable NotationFlag

instance Pretty NotationFlag where
  pretty :: forall ann. NotationFlag -> Doc ann
pretty NotationFlag
HumanReadable = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"human-readable"
  pretty (OtherNF Word8
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown notation flag type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
o

$(ATH.deriveJSON ATH.defaultOptions ''NotationFlag)

newtype ThirtyTwoBitTimeStamp =
  ThirtyTwoBitTimeStamp
    { ThirtyTwoBitTimeStamp -> Word32
unThirtyTwoBitTimeStamp :: Word32
    }
  deriving ( ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> Bounded ThirtyTwoBitTimeStamp
forall a. a -> a -> Bounded a
$cminBound :: ThirtyTwoBitTimeStamp
minBound :: ThirtyTwoBitTimeStamp
$cmaxBound :: ThirtyTwoBitTimeStamp
maxBound :: ThirtyTwoBitTimeStamp
Bounded
           , Typeable ThirtyTwoBitTimeStamp
Typeable ThirtyTwoBitTimeStamp =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ThirtyTwoBitTimeStamp
 -> c ThirtyTwoBitTimeStamp)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp -> Constr)
-> (ThirtyTwoBitTimeStamp -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitTimeStamp))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ThirtyTwoBitTimeStamp))
-> ((forall b. Data b => b -> b)
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ThirtyTwoBitTimeStamp
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> ThirtyTwoBitTimeStamp
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp)
-> Data ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp -> Constr
ThirtyTwoBitTimeStamp -> DataType
(forall b. Data b => b -> b)
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
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) -> ThirtyTwoBitTimeStamp -> u
forall u.
(forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitTimeStamp
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ThirtyTwoBitTimeStamp
-> c ThirtyTwoBitTimeStamp
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitTimeStamp)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ThirtyTwoBitTimeStamp)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ThirtyTwoBitTimeStamp
-> c ThirtyTwoBitTimeStamp
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ThirtyTwoBitTimeStamp
-> c ThirtyTwoBitTimeStamp
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitTimeStamp
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitTimeStamp
$ctoConstr :: ThirtyTwoBitTimeStamp -> Constr
toConstr :: ThirtyTwoBitTimeStamp -> Constr
$cdataTypeOf :: ThirtyTwoBitTimeStamp -> DataType
dataTypeOf :: ThirtyTwoBitTimeStamp -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitTimeStamp)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitTimeStamp)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ThirtyTwoBitTimeStamp)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ThirtyTwoBitTimeStamp)
$cgmapT :: (forall b. Data b => b -> b)
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
gmapT :: (forall b. Data b => b -> b)
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitTimeStamp -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitTimeStamp -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitTimeStamp -> m ThirtyTwoBitTimeStamp
Data
           , Int -> ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp -> Int
ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> [ThirtyTwoBitTimeStamp]
(ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (Int -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp -> Int)
-> (ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp])
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp])
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp])
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp
    -> [ThirtyTwoBitTimeStamp])
-> Enum ThirtyTwoBitTimeStamp
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
succ :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cpred :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
pred :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$ctoEnum :: Int -> ThirtyTwoBitTimeStamp
toEnum :: Int -> ThirtyTwoBitTimeStamp
$cfromEnum :: ThirtyTwoBitTimeStamp -> Int
fromEnum :: ThirtyTwoBitTimeStamp -> Int
$cenumFrom :: ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
enumFrom :: ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
$cenumFromThen :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
enumFromThen :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
$cenumFromTo :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
enumFromTo :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> [ThirtyTwoBitTimeStamp]
$cenumFromThenTo :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> [ThirtyTwoBitTimeStamp]
enumFromThenTo :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> [ThirtyTwoBitTimeStamp]
Enum
           , ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
(ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool)
-> Eq ThirtyTwoBitTimeStamp
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
== :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
$c/= :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
/= :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
Eq
           , (forall x. ThirtyTwoBitTimeStamp -> Rep ThirtyTwoBitTimeStamp x)
-> (forall x. Rep ThirtyTwoBitTimeStamp x -> ThirtyTwoBitTimeStamp)
-> Generic ThirtyTwoBitTimeStamp
forall x. Rep ThirtyTwoBitTimeStamp x -> ThirtyTwoBitTimeStamp
forall x. ThirtyTwoBitTimeStamp -> Rep ThirtyTwoBitTimeStamp x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ThirtyTwoBitTimeStamp -> Rep ThirtyTwoBitTimeStamp x
from :: forall x. ThirtyTwoBitTimeStamp -> Rep ThirtyTwoBitTimeStamp x
$cto :: forall x. Rep ThirtyTwoBitTimeStamp x -> ThirtyTwoBitTimeStamp
to :: forall x. Rep ThirtyTwoBitTimeStamp x -> ThirtyTwoBitTimeStamp
Generic
           , Eq ThirtyTwoBitTimeStamp
Eq ThirtyTwoBitTimeStamp =>
(Int -> ThirtyTwoBitTimeStamp -> Int)
-> (ThirtyTwoBitTimeStamp -> Int) -> Hashable ThirtyTwoBitTimeStamp
Int -> ThirtyTwoBitTimeStamp -> Int
ThirtyTwoBitTimeStamp -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ThirtyTwoBitTimeStamp -> Int
hashWithSalt :: Int -> ThirtyTwoBitTimeStamp -> Int
$chash :: ThirtyTwoBitTimeStamp -> Int
hash :: ThirtyTwoBitTimeStamp -> Int
Hashable
           , Enum ThirtyTwoBitTimeStamp
Real ThirtyTwoBitTimeStamp
(Real ThirtyTwoBitTimeStamp, Enum ThirtyTwoBitTimeStamp) =>
(ThirtyTwoBitTimeStamp
 -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp
    -> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp))
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp
    -> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp))
-> (ThirtyTwoBitTimeStamp -> Integer)
-> Integral ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp -> Integer
ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp)
ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
quot :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$crem :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
rem :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cdiv :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
div :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cmod :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
mod :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cquotRem :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp)
quotRem :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp)
$cdivMod :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp)
divMod :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp
-> (ThirtyTwoBitTimeStamp, ThirtyTwoBitTimeStamp)
$ctoInteger :: ThirtyTwoBitTimeStamp -> Integer
toInteger :: ThirtyTwoBitTimeStamp -> Integer
Integral
           , Integer -> ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
(ThirtyTwoBitTimeStamp
 -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (Integer -> ThirtyTwoBitTimeStamp)
-> Num ThirtyTwoBitTimeStamp
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
+ :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$c- :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
- :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$c* :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
* :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cnegate :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
negate :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cabs :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
abs :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$csignum :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
signum :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cfromInteger :: Integer -> ThirtyTwoBitTimeStamp
fromInteger :: Integer -> ThirtyTwoBitTimeStamp
Num
           , Eq ThirtyTwoBitTimeStamp
Eq ThirtyTwoBitTimeStamp =>
(ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Ordering)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool)
-> (ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> (ThirtyTwoBitTimeStamp
    -> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp)
-> Ord ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Ordering
ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Ordering
compare :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Ordering
$c< :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
< :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
$c<= :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
<= :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
$c> :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
> :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
$c>= :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
>= :: ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Bool
$cmax :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
max :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
$cmin :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
min :: ThirtyTwoBitTimeStamp
-> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp
Ord
           , Num ThirtyTwoBitTimeStamp
Ord ThirtyTwoBitTimeStamp
(Num ThirtyTwoBitTimeStamp, Ord ThirtyTwoBitTimeStamp) =>
(ThirtyTwoBitTimeStamp -> Rational) -> Real ThirtyTwoBitTimeStamp
ThirtyTwoBitTimeStamp -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ThirtyTwoBitTimeStamp -> Rational
toRational :: ThirtyTwoBitTimeStamp -> Rational
Real
           , Int -> ThirtyTwoBitTimeStamp -> ShowS
[ThirtyTwoBitTimeStamp] -> ShowS
ThirtyTwoBitTimeStamp -> String
(Int -> ThirtyTwoBitTimeStamp -> ShowS)
-> (ThirtyTwoBitTimeStamp -> String)
-> ([ThirtyTwoBitTimeStamp] -> ShowS)
-> Show ThirtyTwoBitTimeStamp
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ThirtyTwoBitTimeStamp -> ShowS
showsPrec :: Int -> ThirtyTwoBitTimeStamp -> ShowS
$cshow :: ThirtyTwoBitTimeStamp -> String
show :: ThirtyTwoBitTimeStamp -> String
$cshowList :: [ThirtyTwoBitTimeStamp] -> ShowS
showList :: [ThirtyTwoBitTimeStamp] -> ShowS
Show
           , Typeable
           )

instance Wrapped ThirtyTwoBitTimeStamp

instance Pretty ThirtyTwoBitTimeStamp where
  pretty :: forall ann. ThirtyTwoBitTimeStamp -> Doc ann
pretty =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann)
-> (ThirtyTwoBitTimeStamp -> String)
-> ThirtyTwoBitTimeStamp
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    TimeLocale -> String -> UTCTime -> String
forall t. FormatTime t => TimeLocale -> String -> t -> String
formatTime TimeLocale
defaultTimeLocale String
"%Y%m%d-%H%M%S" (UTCTime -> String)
-> (ThirtyTwoBitTimeStamp -> UTCTime)
-> ThirtyTwoBitTimeStamp
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    POSIXTime -> UTCTime
posixSecondsToUTCTime (POSIXTime -> UTCTime)
-> (ThirtyTwoBitTimeStamp -> POSIXTime)
-> ThirtyTwoBitTimeStamp
-> UTCTime
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ThirtyTwoBitTimeStamp -> POSIXTime
forall a b. (Real a, Fractional b) => a -> b
realToFrac

$(ATH.deriveJSON ATH.defaultOptions ''ThirtyTwoBitTimeStamp)

durU :: (Integral a, Show a) => a -> Maybe (String, a)
durU :: forall a. (Integral a, Show a) => a -> Maybe (String, a)
durU a
x
  | a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
31557600 = (String, a) -> Maybe (String, a)
forall a. a -> Maybe a
Just ((String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"y") ShowS -> (a -> String) -> a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show (a -> String) -> a -> String
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> a
forall a. Integral a => a -> a -> a
`div` a
31557600, a
x a -> a -> a
forall a. Integral a => a -> a -> a
`mod` a
31557600)
  | a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
2629800 = (String, a) -> Maybe (String, a)
forall a. a -> Maybe a
Just ((String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"m") ShowS -> (a -> String) -> a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show (a -> String) -> a -> String
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> a
forall a. Integral a => a -> a -> a
`div` a
2629800, a
x a -> a -> a
forall a. Integral a => a -> a -> a
`mod` a
2629800)
  | a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
>= a
86400 = (String, a) -> Maybe (String, a)
forall a. a -> Maybe a
Just ((String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"d") ShowS -> (a -> String) -> a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show (a -> String) -> a -> String
forall a b. (a -> b) -> a -> b
$ a
x a -> a -> a
forall a. Integral a => a -> a -> a
`div` a
86400, a
x a -> a -> a
forall a. Integral a => a -> a -> a
`mod` a
86400)
  | a
x a -> a -> Bool
forall a. Ord a => a -> a -> Bool
> a
0 = (String, a) -> Maybe (String, a)
forall a. a -> Maybe a
Just ((String -> ShowS
forall a. [a] -> [a] -> [a]
++ String
"s") ShowS -> (a -> String) -> a -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> String
forall a. Show a => a -> String
show (a -> String) -> a -> String
forall a b. (a -> b) -> a -> b
$ a
x, a
0)
  | Bool
otherwise = Maybe (String, a)
forall a. Maybe a
Nothing

newtype ThirtyTwoBitDuration =
  ThirtyTwoBitDuration
    { ThirtyTwoBitDuration -> Word32
unThirtyTwoBitDuration :: Word32
    }
  deriving ( ThirtyTwoBitDuration
ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> Bounded ThirtyTwoBitDuration
forall a. a -> a -> Bounded a
$cminBound :: ThirtyTwoBitDuration
minBound :: ThirtyTwoBitDuration
$cmaxBound :: ThirtyTwoBitDuration
maxBound :: ThirtyTwoBitDuration
Bounded
           , Typeable ThirtyTwoBitDuration
Typeable ThirtyTwoBitDuration =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> ThirtyTwoBitDuration
 -> c ThirtyTwoBitDuration)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration -> Constr)
-> (ThirtyTwoBitDuration -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitDuration))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ThirtyTwoBitDuration))
-> ((forall b. Data b => b -> b)
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration)
-> Data ThirtyTwoBitDuration
ThirtyTwoBitDuration -> Constr
ThirtyTwoBitDuration -> DataType
(forall b. Data b => b -> b)
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
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) -> ThirtyTwoBitDuration -> u
forall u.
(forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitDuration
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ThirtyTwoBitDuration
-> c ThirtyTwoBitDuration
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitDuration)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ThirtyTwoBitDuration)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ThirtyTwoBitDuration
-> c ThirtyTwoBitDuration
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> ThirtyTwoBitDuration
-> c ThirtyTwoBitDuration
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitDuration
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ThirtyTwoBitDuration
$ctoConstr :: ThirtyTwoBitDuration -> Constr
toConstr :: ThirtyTwoBitDuration -> Constr
$cdataTypeOf :: ThirtyTwoBitDuration -> DataType
dataTypeOf :: ThirtyTwoBitDuration -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitDuration)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ThirtyTwoBitDuration)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ThirtyTwoBitDuration)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ThirtyTwoBitDuration)
$cgmapT :: (forall b. Data b => b -> b)
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
gmapT :: (forall b. Data b => b -> b)
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ThirtyTwoBitDuration -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> ThirtyTwoBitDuration -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> ThirtyTwoBitDuration -> m ThirtyTwoBitDuration
Data
           , Int -> ThirtyTwoBitDuration
ThirtyTwoBitDuration -> Int
ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
ThirtyTwoBitDuration -> ThirtyTwoBitDuration
ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> [ThirtyTwoBitDuration]
(ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (Int -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration -> Int)
-> (ThirtyTwoBitDuration -> [ThirtyTwoBitDuration])
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration])
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration])
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration
    -> [ThirtyTwoBitDuration])
-> Enum ThirtyTwoBitDuration
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
succ :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cpred :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
pred :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$ctoEnum :: Int -> ThirtyTwoBitDuration
toEnum :: Int -> ThirtyTwoBitDuration
$cfromEnum :: ThirtyTwoBitDuration -> Int
fromEnum :: ThirtyTwoBitDuration -> Int
$cenumFrom :: ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
enumFrom :: ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
$cenumFromThen :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
enumFromThen :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
$cenumFromTo :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
enumFromTo :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> [ThirtyTwoBitDuration]
$cenumFromThenTo :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> [ThirtyTwoBitDuration]
enumFromThenTo :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> [ThirtyTwoBitDuration]
Enum
           , ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
(ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool)
-> Eq ThirtyTwoBitDuration
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
== :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
$c/= :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
/= :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
Eq
           , (forall x. ThirtyTwoBitDuration -> Rep ThirtyTwoBitDuration x)
-> (forall x. Rep ThirtyTwoBitDuration x -> ThirtyTwoBitDuration)
-> Generic ThirtyTwoBitDuration
forall x. Rep ThirtyTwoBitDuration x -> ThirtyTwoBitDuration
forall x. ThirtyTwoBitDuration -> Rep ThirtyTwoBitDuration x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ThirtyTwoBitDuration -> Rep ThirtyTwoBitDuration x
from :: forall x. ThirtyTwoBitDuration -> Rep ThirtyTwoBitDuration x
$cto :: forall x. Rep ThirtyTwoBitDuration x -> ThirtyTwoBitDuration
to :: forall x. Rep ThirtyTwoBitDuration x -> ThirtyTwoBitDuration
Generic
           , Eq ThirtyTwoBitDuration
Eq ThirtyTwoBitDuration =>
(Int -> ThirtyTwoBitDuration -> Int)
-> (ThirtyTwoBitDuration -> Int) -> Hashable ThirtyTwoBitDuration
Int -> ThirtyTwoBitDuration -> Int
ThirtyTwoBitDuration -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> ThirtyTwoBitDuration -> Int
hashWithSalt :: Int -> ThirtyTwoBitDuration -> Int
$chash :: ThirtyTwoBitDuration -> Int
hash :: ThirtyTwoBitDuration -> Int
Hashable
           , Enum ThirtyTwoBitDuration
Real ThirtyTwoBitDuration
(Real ThirtyTwoBitDuration, Enum ThirtyTwoBitDuration) =>
(ThirtyTwoBitDuration
 -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration
    -> (ThirtyTwoBitDuration, ThirtyTwoBitDuration))
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration
    -> (ThirtyTwoBitDuration, ThirtyTwoBitDuration))
-> (ThirtyTwoBitDuration -> Integer)
-> Integral ThirtyTwoBitDuration
ThirtyTwoBitDuration -> Integer
ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> (ThirtyTwoBitDuration, ThirtyTwoBitDuration)
ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
quot :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$crem :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
rem :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cdiv :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
div :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cmod :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
mod :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cquotRem :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> (ThirtyTwoBitDuration, ThirtyTwoBitDuration)
quotRem :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> (ThirtyTwoBitDuration, ThirtyTwoBitDuration)
$cdivMod :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> (ThirtyTwoBitDuration, ThirtyTwoBitDuration)
divMod :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration
-> (ThirtyTwoBitDuration, ThirtyTwoBitDuration)
$ctoInteger :: ThirtyTwoBitDuration -> Integer
toInteger :: ThirtyTwoBitDuration -> Integer
Integral
           , Integer -> ThirtyTwoBitDuration
ThirtyTwoBitDuration -> ThirtyTwoBitDuration
ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
(ThirtyTwoBitDuration
 -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (Integer -> ThirtyTwoBitDuration)
-> Num ThirtyTwoBitDuration
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
+ :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$c- :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
- :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$c* :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
* :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cnegate :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
negate :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cabs :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
abs :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$csignum :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
signum :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cfromInteger :: Integer -> ThirtyTwoBitDuration
fromInteger :: Integer -> ThirtyTwoBitDuration
Num
           , Eq ThirtyTwoBitDuration
Eq ThirtyTwoBitDuration =>
(ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Ordering)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool)
-> (ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> (ThirtyTwoBitDuration
    -> ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> Ord ThirtyTwoBitDuration
ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Ordering
ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Ordering
compare :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Ordering
$c< :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
< :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
$c<= :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
<= :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
$c> :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
> :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
$c>= :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
>= :: ThirtyTwoBitDuration -> ThirtyTwoBitDuration -> Bool
$cmax :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
max :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
$cmin :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
min :: ThirtyTwoBitDuration
-> ThirtyTwoBitDuration -> ThirtyTwoBitDuration
Ord
           , Num ThirtyTwoBitDuration
Ord ThirtyTwoBitDuration
(Num ThirtyTwoBitDuration, Ord ThirtyTwoBitDuration) =>
(ThirtyTwoBitDuration -> Rational) -> Real ThirtyTwoBitDuration
ThirtyTwoBitDuration -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: ThirtyTwoBitDuration -> Rational
toRational :: ThirtyTwoBitDuration -> Rational
Real
           , Int -> ThirtyTwoBitDuration -> ShowS
[ThirtyTwoBitDuration] -> ShowS
ThirtyTwoBitDuration -> String
(Int -> ThirtyTwoBitDuration -> ShowS)
-> (ThirtyTwoBitDuration -> String)
-> ([ThirtyTwoBitDuration] -> ShowS)
-> Show ThirtyTwoBitDuration
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ThirtyTwoBitDuration -> ShowS
showsPrec :: Int -> ThirtyTwoBitDuration -> ShowS
$cshow :: ThirtyTwoBitDuration -> String
show :: ThirtyTwoBitDuration -> String
$cshowList :: [ThirtyTwoBitDuration] -> ShowS
showList :: [ThirtyTwoBitDuration] -> ShowS
Show
           , Typeable
           )

instance Wrapped ThirtyTwoBitDuration

instance Pretty ThirtyTwoBitDuration where
  pretty :: forall ann. ThirtyTwoBitDuration -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann)
-> (ThirtyTwoBitDuration -> String)
-> ThirtyTwoBitDuration
-> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat ([String] -> String)
-> (ThirtyTwoBitDuration -> [String])
-> ThirtyTwoBitDuration
-> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Word32 -> Maybe (String, Word32)) -> Word32 -> [String]
forall b a. (b -> Maybe (a, b)) -> b -> [a]
unfoldr Word32 -> Maybe (String, Word32)
forall a. (Integral a, Show a) => a -> Maybe (String, a)
durU (Word32 -> [String])
-> (ThirtyTwoBitDuration -> Word32)
-> ThirtyTwoBitDuration
-> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped ThirtyTwoBitDuration -> ThirtyTwoBitDuration)
-> ThirtyTwoBitDuration -> Unwrapped ThirtyTwoBitDuration
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op Word32 -> ThirtyTwoBitDuration
Unwrapped ThirtyTwoBitDuration -> ThirtyTwoBitDuration
ThirtyTwoBitDuration

$(ATH.deriveJSON ATH.defaultOptions ''ThirtyTwoBitDuration)

data RevocationClass
  = SensitiveRK
  | RClOther Word8
  deriving (Typeable RevocationClass
Typeable RevocationClass =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RevocationClass -> c RevocationClass)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RevocationClass)
-> (RevocationClass -> Constr)
-> (RevocationClass -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RevocationClass))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RevocationClass))
-> ((forall b. Data b => b -> b)
    -> RevocationClass -> RevocationClass)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RevocationClass -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RevocationClass -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> RevocationClass -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RevocationClass -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RevocationClass -> m RevocationClass)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RevocationClass -> m RevocationClass)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RevocationClass -> m RevocationClass)
-> Data RevocationClass
RevocationClass -> Constr
RevocationClass -> DataType
(forall b. Data b => b -> b) -> RevocationClass -> RevocationClass
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) -> RevocationClass -> u
forall u. (forall d. Data d => d -> u) -> RevocationClass -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationClass -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationClass -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RevocationClass
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RevocationClass -> c RevocationClass
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RevocationClass)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RevocationClass)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RevocationClass -> c RevocationClass
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RevocationClass -> c RevocationClass
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RevocationClass
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RevocationClass
$ctoConstr :: RevocationClass -> Constr
toConstr :: RevocationClass -> Constr
$cdataTypeOf :: RevocationClass -> DataType
dataTypeOf :: RevocationClass -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RevocationClass)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RevocationClass)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RevocationClass)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RevocationClass)
$cgmapT :: (forall b. Data b => b -> b) -> RevocationClass -> RevocationClass
gmapT :: (forall b. Data b => b -> b) -> RevocationClass -> RevocationClass
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationClass -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationClass -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationClass -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationClass -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RevocationClass -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RevocationClass -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RevocationClass -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RevocationClass -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationClass -> m RevocationClass
Data, (forall x. RevocationClass -> Rep RevocationClass x)
-> (forall x. Rep RevocationClass x -> RevocationClass)
-> Generic RevocationClass
forall x. Rep RevocationClass x -> RevocationClass
forall x. RevocationClass -> Rep RevocationClass x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RevocationClass -> Rep RevocationClass x
from :: forall x. RevocationClass -> Rep RevocationClass x
$cto :: forall x. Rep RevocationClass x -> RevocationClass
to :: forall x. Rep RevocationClass x -> RevocationClass
Generic, Int -> RevocationClass -> ShowS
[RevocationClass] -> ShowS
RevocationClass -> String
(Int -> RevocationClass -> ShowS)
-> (RevocationClass -> String)
-> ([RevocationClass] -> ShowS)
-> Show RevocationClass
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RevocationClass -> ShowS
showsPrec :: Int -> RevocationClass -> ShowS
$cshow :: RevocationClass -> String
show :: RevocationClass -> String
$cshowList :: [RevocationClass] -> ShowS
showList :: [RevocationClass] -> ShowS
Show, Typeable)

mkRevocationClass :: Word8 -> RevocationClass
mkRevocationClass :: Word8 -> RevocationClass
mkRevocationClass Word8
i
  | Word8
i' Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
1 = RevocationClass
SensitiveRK
  | Bool
otherwise = Word8 -> RevocationClass
RClOther Word8
i'
  where
    i' :: Word8
i' = Word8
i Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07

instance Eq RevocationClass where
  == :: RevocationClass -> RevocationClass -> Bool
(==) RevocationClass
a RevocationClass
b = RevocationClass -> Int
forall a. FutureFlag a => a -> Int
fromFFlag RevocationClass
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== RevocationClass -> Int
forall a. FutureFlag a => a -> Int
fromFFlag RevocationClass
b

instance Ord RevocationClass where
  compare :: RevocationClass -> RevocationClass -> Ordering
compare = (RevocationClass -> Int)
-> RevocationClass -> RevocationClass -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing RevocationClass -> Int
forall a. FutureFlag a => a -> Int
fromFFlag

instance FutureFlag RevocationClass where
  fromFFlag :: RevocationClass -> Int
fromFFlag RevocationClass
SensitiveRK = Int
1
  fromFFlag (RClOther Word8
i) = Word8 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8
i Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x07)
  toFFlag :: Int -> RevocationClass
toFFlag Int
1 = RevocationClass
SensitiveRK
  toFFlag Int
i = Word8 -> RevocationClass
mkRevocationClass (Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)

instance Hashable RevocationClass

instance Pretty RevocationClass where
  pretty :: forall ann. RevocationClass -> Doc ann
pretty RevocationClass
SensitiveRK = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"sensitive"
  pretty (RClOther Word8
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown revocation class" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
o

$(ATH.deriveJSON ATH.defaultOptions ''RevocationClass)

data PubKeyAlgorithm
  = RSA
  | DeprecatedRSAEncryptOnly
  | DeprecatedRSASignOnly
  | ElgamalEncryptOnly
  | DSA
  | ECDH
  | ECDSA
  | ForbiddenElgamal
  | DH
  | EdDSA
  | X25519
  | X448
  | Ed25519
  | Ed448
  | OtherPKA Word8
  deriving (Int -> PubKeyAlgorithm -> ShowS
[PubKeyAlgorithm] -> ShowS
PubKeyAlgorithm -> String
(Int -> PubKeyAlgorithm -> ShowS)
-> (PubKeyAlgorithm -> String)
-> ([PubKeyAlgorithm] -> ShowS)
-> Show PubKeyAlgorithm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> PubKeyAlgorithm -> ShowS
showsPrec :: Int -> PubKeyAlgorithm -> ShowS
$cshow :: PubKeyAlgorithm -> String
show :: PubKeyAlgorithm -> String
$cshowList :: [PubKeyAlgorithm] -> ShowS
showList :: [PubKeyAlgorithm] -> ShowS
Show, Typeable PubKeyAlgorithm
Typeable PubKeyAlgorithm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> PubKeyAlgorithm -> c PubKeyAlgorithm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c PubKeyAlgorithm)
-> (PubKeyAlgorithm -> Constr)
-> (PubKeyAlgorithm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c PubKeyAlgorithm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c PubKeyAlgorithm))
-> ((forall b. Data b => b -> b)
    -> PubKeyAlgorithm -> PubKeyAlgorithm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> PubKeyAlgorithm -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> PubKeyAlgorithm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> PubKeyAlgorithm -> m PubKeyAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PubKeyAlgorithm -> m PubKeyAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> PubKeyAlgorithm -> m PubKeyAlgorithm)
-> Data PubKeyAlgorithm
PubKeyAlgorithm -> Constr
PubKeyAlgorithm -> DataType
(forall b. Data b => b -> b) -> PubKeyAlgorithm -> PubKeyAlgorithm
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) -> PubKeyAlgorithm -> u
forall u. (forall d. Data d => d -> u) -> PubKeyAlgorithm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PubKeyAlgorithm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PubKeyAlgorithm -> c PubKeyAlgorithm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PubKeyAlgorithm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PubKeyAlgorithm)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PubKeyAlgorithm -> c PubKeyAlgorithm
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> PubKeyAlgorithm -> c PubKeyAlgorithm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PubKeyAlgorithm
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c PubKeyAlgorithm
$ctoConstr :: PubKeyAlgorithm -> Constr
toConstr :: PubKeyAlgorithm -> Constr
$cdataTypeOf :: PubKeyAlgorithm -> DataType
dataTypeOf :: PubKeyAlgorithm -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PubKeyAlgorithm)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c PubKeyAlgorithm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PubKeyAlgorithm)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c PubKeyAlgorithm)
$cgmapT :: (forall b. Data b => b -> b) -> PubKeyAlgorithm -> PubKeyAlgorithm
gmapT :: (forall b. Data b => b -> b) -> PubKeyAlgorithm -> PubKeyAlgorithm
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> PubKeyAlgorithm -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> PubKeyAlgorithm -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> PubKeyAlgorithm -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PubKeyAlgorithm -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> PubKeyAlgorithm -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> PubKeyAlgorithm -> m PubKeyAlgorithm
Data, (forall x. PubKeyAlgorithm -> Rep PubKeyAlgorithm x)
-> (forall x. Rep PubKeyAlgorithm x -> PubKeyAlgorithm)
-> Generic PubKeyAlgorithm
forall x. Rep PubKeyAlgorithm x -> PubKeyAlgorithm
forall x. PubKeyAlgorithm -> Rep PubKeyAlgorithm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. PubKeyAlgorithm -> Rep PubKeyAlgorithm x
from :: forall x. PubKeyAlgorithm -> Rep PubKeyAlgorithm x
$cto :: forall x. Rep PubKeyAlgorithm x -> PubKeyAlgorithm
to :: forall x. Rep PubKeyAlgorithm x -> PubKeyAlgorithm
Generic, Typeable)

instance Eq PubKeyAlgorithm where
  == :: PubKeyAlgorithm -> PubKeyAlgorithm -> Bool
(==) PubKeyAlgorithm
a PubKeyAlgorithm
b = PubKeyAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal PubKeyAlgorithm
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== PubKeyAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal PubKeyAlgorithm
b

instance Ord PubKeyAlgorithm where
  compare :: PubKeyAlgorithm -> PubKeyAlgorithm -> Ordering
compare = (PubKeyAlgorithm -> Word8)
-> PubKeyAlgorithm -> PubKeyAlgorithm -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing PubKeyAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal PubKeyAlgorithm where
  fromFVal :: PubKeyAlgorithm -> Word8
fromFVal PubKeyAlgorithm
RSA = Word8
1
  fromFVal PubKeyAlgorithm
DeprecatedRSAEncryptOnly = Word8
2
  fromFVal PubKeyAlgorithm
DeprecatedRSASignOnly = Word8
3
  fromFVal PubKeyAlgorithm
ElgamalEncryptOnly = Word8
16
  fromFVal PubKeyAlgorithm
DSA = Word8
17
  fromFVal PubKeyAlgorithm
ECDH = Word8
18
  fromFVal PubKeyAlgorithm
ECDSA = Word8
19
  fromFVal PubKeyAlgorithm
ForbiddenElgamal = Word8
20
  fromFVal PubKeyAlgorithm
DH = Word8
21
  fromFVal PubKeyAlgorithm
EdDSA = Word8
22
  fromFVal PubKeyAlgorithm
X25519 = Word8
25
  fromFVal PubKeyAlgorithm
X448 = Word8
26
  fromFVal PubKeyAlgorithm
Ed25519 = Word8
27
  fromFVal PubKeyAlgorithm
Ed448 = Word8
28
  fromFVal (OtherPKA Word8
o) = Word8
o
  toFVal :: Word8 -> PubKeyAlgorithm
toFVal Word8
1 = PubKeyAlgorithm
RSA
  toFVal Word8
2 = PubKeyAlgorithm
DeprecatedRSAEncryptOnly
  toFVal Word8
3 = PubKeyAlgorithm
DeprecatedRSASignOnly
  toFVal Word8
16 = PubKeyAlgorithm
ElgamalEncryptOnly
  toFVal Word8
17 = PubKeyAlgorithm
DSA
  toFVal Word8
18 = PubKeyAlgorithm
ECDH
  toFVal Word8
19 = PubKeyAlgorithm
ECDSA
  toFVal Word8
20 = PubKeyAlgorithm
ForbiddenElgamal
  toFVal Word8
21 = PubKeyAlgorithm
DH
  toFVal Word8
22 = PubKeyAlgorithm
EdDSA
  toFVal Word8
25 = PubKeyAlgorithm
X25519
  toFVal Word8
26 = PubKeyAlgorithm
X448
  toFVal Word8
27 = PubKeyAlgorithm
Ed25519
  toFVal Word8
28 = PubKeyAlgorithm
Ed448
  toFVal Word8
o = Word8 -> PubKeyAlgorithm
OtherPKA Word8
o

instance Hashable PubKeyAlgorithm

instance Pretty PubKeyAlgorithm where
  pretty :: forall ann. PubKeyAlgorithm -> Doc ann
pretty PubKeyAlgorithm
RSA = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"RSA"
  pretty PubKeyAlgorithm
DeprecatedRSAEncryptOnly = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"(deprecated) RSA encrypt-only"
  pretty PubKeyAlgorithm
DeprecatedRSASignOnly = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"(deprecated) RSA sign-only"
  pretty PubKeyAlgorithm
ElgamalEncryptOnly = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Elgamal encrypt-only"
  pretty PubKeyAlgorithm
DSA = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"DSA"
  pretty PubKeyAlgorithm
ECDH = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"ECDH"
  pretty PubKeyAlgorithm
ECDSA = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"ECDSA"
  pretty PubKeyAlgorithm
ForbiddenElgamal = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"(forbidden) Elgamal"
  pretty PubKeyAlgorithm
DH = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"DH"
  pretty PubKeyAlgorithm
EdDSA = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"EdDSA"
  pretty PubKeyAlgorithm
X25519 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"X25519"
  pretty PubKeyAlgorithm
X448 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"X448"
  pretty PubKeyAlgorithm
Ed25519 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Ed25519"
  pretty PubKeyAlgorithm
Ed448 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Ed448"
  pretty (OtherPKA Word8
pka) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown pubkey algorithm type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
pka

$(ATH.deriveJSON ATH.defaultOptions ''PubKeyAlgorithm)

-- | An OpenPGP fingerprint.  Length depends on key version:
-- 16 bytes (v3/MD5), 20 bytes (v4/SHA-1), or 32 bytes (v6/SHA-256).
newtype Fingerprint =
  Fingerprint
    { Fingerprint -> ByteString
unFingerprint :: ByteString
    }
  deriving (Typeable Fingerprint
Typeable Fingerprint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Fingerprint -> c Fingerprint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Fingerprint)
-> (Fingerprint -> Constr)
-> (Fingerprint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Fingerprint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c Fingerprint))
-> ((forall b. Data b => b -> b) -> Fingerprint -> Fingerprint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Fingerprint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Fingerprint -> r)
-> (forall u. (forall d. Data d => d -> u) -> Fingerprint -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> Fingerprint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint)
-> Data Fingerprint
Fingerprint -> Constr
Fingerprint -> DataType
(forall b. Data b => b -> b) -> Fingerprint -> Fingerprint
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) -> Fingerprint -> u
forall u. (forall d. Data d => d -> u) -> Fingerprint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fingerprint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fingerprint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fingerprint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fingerprint -> c Fingerprint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fingerprint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Fingerprint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fingerprint -> c Fingerprint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Fingerprint -> c Fingerprint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fingerprint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Fingerprint
$ctoConstr :: Fingerprint -> Constr
toConstr :: Fingerprint -> Constr
$cdataTypeOf :: Fingerprint -> DataType
dataTypeOf :: Fingerprint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fingerprint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Fingerprint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Fingerprint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c Fingerprint)
$cgmapT :: (forall b. Data b => b -> b) -> Fingerprint -> Fingerprint
gmapT :: (forall b. Data b => b -> b) -> Fingerprint -> Fingerprint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fingerprint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> Fingerprint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fingerprint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> Fingerprint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Fingerprint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Fingerprint -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fingerprint -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Fingerprint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Fingerprint -> m Fingerprint
Data, Fingerprint -> Fingerprint -> Bool
(Fingerprint -> Fingerprint -> Bool)
-> (Fingerprint -> Fingerprint -> Bool) -> Eq Fingerprint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Fingerprint -> Fingerprint -> Bool
== :: Fingerprint -> Fingerprint -> Bool
$c/= :: Fingerprint -> Fingerprint -> Bool
/= :: Fingerprint -> Fingerprint -> Bool
Eq, (forall x. Fingerprint -> Rep Fingerprint x)
-> (forall x. Rep Fingerprint x -> Fingerprint)
-> Generic Fingerprint
forall x. Rep Fingerprint x -> Fingerprint
forall x. Fingerprint -> Rep Fingerprint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Fingerprint -> Rep Fingerprint x
from :: forall x. Fingerprint -> Rep Fingerprint x
$cto :: forall x. Rep Fingerprint x -> Fingerprint
to :: forall x. Rep Fingerprint x -> Fingerprint
Generic, Eq Fingerprint
Eq Fingerprint =>
(Fingerprint -> Fingerprint -> Ordering)
-> (Fingerprint -> Fingerprint -> Bool)
-> (Fingerprint -> Fingerprint -> Bool)
-> (Fingerprint -> Fingerprint -> Bool)
-> (Fingerprint -> Fingerprint -> Bool)
-> (Fingerprint -> Fingerprint -> Fingerprint)
-> (Fingerprint -> Fingerprint -> Fingerprint)
-> Ord Fingerprint
Fingerprint -> Fingerprint -> Bool
Fingerprint -> Fingerprint -> Ordering
Fingerprint -> Fingerprint -> Fingerprint
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: Fingerprint -> Fingerprint -> Ordering
compare :: Fingerprint -> Fingerprint -> Ordering
$c< :: Fingerprint -> Fingerprint -> Bool
< :: Fingerprint -> Fingerprint -> Bool
$c<= :: Fingerprint -> Fingerprint -> Bool
<= :: Fingerprint -> Fingerprint -> Bool
$c> :: Fingerprint -> Fingerprint -> Bool
> :: Fingerprint -> Fingerprint -> Bool
$c>= :: Fingerprint -> Fingerprint -> Bool
>= :: Fingerprint -> Fingerprint -> Bool
$cmax :: Fingerprint -> Fingerprint -> Fingerprint
max :: Fingerprint -> Fingerprint -> Fingerprint
$cmin :: Fingerprint -> Fingerprint -> Fingerprint
min :: Fingerprint -> Fingerprint -> Fingerprint
Ord, Int -> Fingerprint -> ShowS
[Fingerprint] -> ShowS
Fingerprint -> String
(Int -> Fingerprint -> ShowS)
-> (Fingerprint -> String)
-> ([Fingerprint] -> ShowS)
-> Show Fingerprint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Fingerprint -> ShowS
showsPrec :: Int -> Fingerprint -> ShowS
$cshow :: Fingerprint -> String
show :: Fingerprint -> String
$cshowList :: [Fingerprint] -> ShowS
showList :: [Fingerprint] -> ShowS
Show, Typeable)

instance Wrapped Fingerprint

instance Read Fingerprint where
  readsPrec :: Int -> ReadS Fingerprint
readsPrec Int
_ String
s =
    let ws :: [(Word8, String)]
ws = ReadS Word8
hexToW8s ((Char -> Bool) -> ShowS
forall a. (a -> Bool) -> [a] -> [a]
filter (Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
/= Char
' ') String
s)
    in if [(Word8, String)] -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null [(Word8, String)]
ws
         then []
         else [(ByteString -> Fingerprint
Fingerprint ([Word8] -> ByteString
BL.pack (((Word8, String) -> Word8) -> [(Word8, String)] -> [Word8]
forall a b. (a -> b) -> [a] -> [b]
map (Word8, String) -> Word8
forall a b. (a, b) -> a
fst [(Word8, String)]
ws)), (Word8, String) -> String
forall a b. (a, b) -> b
snd ([(Word8, String)] -> (Word8, String)
forall a. HasCallStack => [a] -> a
last [(Word8, String)]
ws))]

instance Hashable Fingerprint

instance Pretty Fingerprint where
  pretty :: forall ann. Fingerprint -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann)
-> (Fingerprint -> String) -> Fingerprint -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
bsToHexUpper (ByteString -> String)
-> (Fingerprint -> ByteString) -> Fingerprint -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fingerprint -> ByteString
unFingerprint

key :: String -> AK.Key
key :: String -> Key
key = Text -> Key
AK.fromText (Text -> Key) -> (String -> Text) -> String -> Key
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

instance A.ToJSON Fingerprint where
  toJSON :: Fingerprint -> Value
toJSON Fingerprint
e = [Pair] -> Value
object [String -> Key
key String
"fpr" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (String -> Value
forall a. ToJSON a => a -> Value
A.toJSON (String -> Value)
-> (Fingerprint -> String) -> Fingerprint -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Doc (ZonkAny 0) -> String
forall a. Show a => a -> String
show (Doc (ZonkAny 0) -> String)
-> (Fingerprint -> Doc (ZonkAny 0)) -> Fingerprint -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fingerprint -> Doc (ZonkAny 0)
forall a ann. Pretty a => a -> Doc ann
forall ann. Fingerprint -> Doc ann
pretty) Fingerprint
e]

instance A.FromJSON Fingerprint where
  parseJSON :: Value -> Parser Fingerprint
parseJSON (A.Object Object
v) = ByteString -> Fingerprint
Fingerprint (ByteString -> Fingerprint)
-> (String -> ByteString) -> String -> Fingerprint
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
forall a. Read a => String -> a
read (String -> Fingerprint) -> Parser String -> Parser Fingerprint
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"fpr"
  parseJSON Value
_ = Parser Fingerprint
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

newtype SpacedFingerprint =
  SpacedFingerprint
    { SpacedFingerprint -> Fingerprint
unSpacedFingerprint :: Fingerprint
    }
  deriving (Typeable SpacedFingerprint
Typeable SpacedFingerprint =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SpacedFingerprint
 -> c SpacedFingerprint)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SpacedFingerprint)
-> (SpacedFingerprint -> Constr)
-> (SpacedFingerprint -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SpacedFingerprint))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SpacedFingerprint))
-> ((forall b. Data b => b -> b)
    -> SpacedFingerprint -> SpacedFingerprint)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SpacedFingerprint -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SpacedFingerprint -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SpacedFingerprint -> m SpacedFingerprint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpacedFingerprint -> m SpacedFingerprint)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SpacedFingerprint -> m SpacedFingerprint)
-> Data SpacedFingerprint
SpacedFingerprint -> Constr
SpacedFingerprint -> DataType
(forall b. Data b => b -> b)
-> SpacedFingerprint -> SpacedFingerprint
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) -> SpacedFingerprint -> u
forall u. (forall d. Data d => d -> u) -> SpacedFingerprint -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpacedFingerprint
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpacedFingerprint -> c SpacedFingerprint
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpacedFingerprint)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpacedFingerprint)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpacedFingerprint -> c SpacedFingerprint
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SpacedFingerprint -> c SpacedFingerprint
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpacedFingerprint
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SpacedFingerprint
$ctoConstr :: SpacedFingerprint -> Constr
toConstr :: SpacedFingerprint -> Constr
$cdataTypeOf :: SpacedFingerprint -> DataType
dataTypeOf :: SpacedFingerprint -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpacedFingerprint)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SpacedFingerprint)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpacedFingerprint)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SpacedFingerprint)
$cgmapT :: (forall b. Data b => b -> b)
-> SpacedFingerprint -> SpacedFingerprint
gmapT :: (forall b. Data b => b -> b)
-> SpacedFingerprint -> SpacedFingerprint
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SpacedFingerprint -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SpacedFingerprint -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SpacedFingerprint -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SpacedFingerprint -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SpacedFingerprint -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SpacedFingerprint -> m SpacedFingerprint
Data, SpacedFingerprint -> SpacedFingerprint -> Bool
(SpacedFingerprint -> SpacedFingerprint -> Bool)
-> (SpacedFingerprint -> SpacedFingerprint -> Bool)
-> Eq SpacedFingerprint
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SpacedFingerprint -> SpacedFingerprint -> Bool
== :: SpacedFingerprint -> SpacedFingerprint -> Bool
$c/= :: SpacedFingerprint -> SpacedFingerprint -> Bool
/= :: SpacedFingerprint -> SpacedFingerprint -> Bool
Eq, (forall x. SpacedFingerprint -> Rep SpacedFingerprint x)
-> (forall x. Rep SpacedFingerprint x -> SpacedFingerprint)
-> Generic SpacedFingerprint
forall x. Rep SpacedFingerprint x -> SpacedFingerprint
forall x. SpacedFingerprint -> Rep SpacedFingerprint x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SpacedFingerprint -> Rep SpacedFingerprint x
from :: forall x. SpacedFingerprint -> Rep SpacedFingerprint x
$cto :: forall x. Rep SpacedFingerprint x -> SpacedFingerprint
to :: forall x. Rep SpacedFingerprint x -> SpacedFingerprint
Generic, Eq SpacedFingerprint
Eq SpacedFingerprint =>
(SpacedFingerprint -> SpacedFingerprint -> Ordering)
-> (SpacedFingerprint -> SpacedFingerprint -> Bool)
-> (SpacedFingerprint -> SpacedFingerprint -> Bool)
-> (SpacedFingerprint -> SpacedFingerprint -> Bool)
-> (SpacedFingerprint -> SpacedFingerprint -> Bool)
-> (SpacedFingerprint -> SpacedFingerprint -> SpacedFingerprint)
-> (SpacedFingerprint -> SpacedFingerprint -> SpacedFingerprint)
-> Ord SpacedFingerprint
SpacedFingerprint -> SpacedFingerprint -> Bool
SpacedFingerprint -> SpacedFingerprint -> Ordering
SpacedFingerprint -> SpacedFingerprint -> SpacedFingerprint
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SpacedFingerprint -> SpacedFingerprint -> Ordering
compare :: SpacedFingerprint -> SpacedFingerprint -> Ordering
$c< :: SpacedFingerprint -> SpacedFingerprint -> Bool
< :: SpacedFingerprint -> SpacedFingerprint -> Bool
$c<= :: SpacedFingerprint -> SpacedFingerprint -> Bool
<= :: SpacedFingerprint -> SpacedFingerprint -> Bool
$c> :: SpacedFingerprint -> SpacedFingerprint -> Bool
> :: SpacedFingerprint -> SpacedFingerprint -> Bool
$c>= :: SpacedFingerprint -> SpacedFingerprint -> Bool
>= :: SpacedFingerprint -> SpacedFingerprint -> Bool
$cmax :: SpacedFingerprint -> SpacedFingerprint -> SpacedFingerprint
max :: SpacedFingerprint -> SpacedFingerprint -> SpacedFingerprint
$cmin :: SpacedFingerprint -> SpacedFingerprint -> SpacedFingerprint
min :: SpacedFingerprint -> SpacedFingerprint -> SpacedFingerprint
Ord, Int -> SpacedFingerprint -> ShowS
[SpacedFingerprint] -> ShowS
SpacedFingerprint -> String
(Int -> SpacedFingerprint -> ShowS)
-> (SpacedFingerprint -> String)
-> ([SpacedFingerprint] -> ShowS)
-> Show SpacedFingerprint
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SpacedFingerprint -> ShowS
showsPrec :: Int -> SpacedFingerprint -> ShowS
$cshow :: SpacedFingerprint -> String
show :: SpacedFingerprint -> String
$cshowList :: [SpacedFingerprint] -> ShowS
showList :: [SpacedFingerprint] -> ShowS
Show, Typeable)

instance Wrapped SpacedFingerprint

instance Pretty SpacedFingerprint where
  pretty :: forall ann. SpacedFingerprint -> Doc ann
pretty =
    [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([Doc ann] -> Doc ann)
-> (SpacedFingerprint -> [Doc ann]) -> SpacedFingerprint -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Doc ann -> [Doc ann] -> [Doc ann]
forall ann. Doc ann -> [Doc ann] -> [Doc ann]
punctuate Doc ann
forall ann. Doc ann
space ([Doc ann] -> [Doc ann])
-> (SpacedFingerprint -> [Doc ann])
-> SpacedFingerprint
-> [Doc ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    ([Doc ann] -> Doc ann) -> [[Doc ann]] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map [Doc ann] -> Doc ann
forall ann. [Doc ann] -> Doc ann
hsep ([[Doc ann]] -> [Doc ann])
-> (SpacedFingerprint -> [[Doc ann]])
-> SpacedFingerprint
-> [Doc ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    Int -> [Doc ann] -> [[Doc ann]]
forall e. Int -> [e] -> [[e]]
chunksOf Int
5 ([Doc ann] -> [[Doc ann]])
-> (SpacedFingerprint -> [Doc ann])
-> SpacedFingerprint
-> [[Doc ann]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
    (String -> Doc ann) -> [String] -> [Doc ann]
forall a b. (a -> b) -> [a] -> [b]
map String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ([String] -> [Doc ann])
-> (SpacedFingerprint -> [String])
-> SpacedFingerprint
-> [Doc ann]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> [String]
forall e. Int -> [e] -> [[e]]
chunksOf Int
4 (String -> [String])
-> (SpacedFingerprint -> String) -> SpacedFingerprint -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
bsToHexUpper (ByteString -> String)
-> (SpacedFingerprint -> ByteString) -> SpacedFingerprint -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Fingerprint -> ByteString
unFingerprint (Fingerprint -> ByteString)
-> (SpacedFingerprint -> Fingerprint)
-> SpacedFingerprint
-> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped SpacedFingerprint -> SpacedFingerprint)
-> SpacedFingerprint -> Unwrapped SpacedFingerprint
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op Unwrapped SpacedFingerprint -> SpacedFingerprint
Fingerprint -> SpacedFingerprint
SpacedFingerprint

bsToHexUpper :: ByteString -> String
bsToHexUpper :: ByteString -> String
bsToHexUpper = (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toUpper ShowS -> (ByteString -> String) -> ByteString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
BLC8.unpack (ByteString -> String)
-> (ByteString -> ByteString) -> ByteString -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
B16L.encode

hexToW8s :: ReadS Word8
hexToW8s :: ReadS Word8
hexToW8s = ReadS Word8 -> [String] -> [(Word8, String)]
forall (t :: * -> *) a b. Foldable t => (a -> [b]) -> t a -> [b]
concatMap ReadS Word8
forall a. (Eq a, Num a) => ReadS a
readHex ([String] -> [(Word8, String)])
-> (String -> [String]) -> ReadS Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> String -> [String]
forall e. Int -> [e] -> [[e]]
chunksOf Int
2 (String -> [String]) -> ShowS -> String -> [String]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Char -> Char) -> ShowS
forall a b. (a -> b) -> [a] -> [b]
map Char -> Char
toLower

newtype EightOctetKeyId =
  EightOctetKeyId
    { EightOctetKeyId -> ByteString
unEOKI :: ByteString
    }
  deriving (Typeable EightOctetKeyId
Typeable EightOctetKeyId =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> EightOctetKeyId -> c EightOctetKeyId)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c EightOctetKeyId)
-> (EightOctetKeyId -> Constr)
-> (EightOctetKeyId -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c EightOctetKeyId))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c EightOctetKeyId))
-> ((forall b. Data b => b -> b)
    -> EightOctetKeyId -> EightOctetKeyId)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> EightOctetKeyId -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> EightOctetKeyId -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> EightOctetKeyId -> m EightOctetKeyId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EightOctetKeyId -> m EightOctetKeyId)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> EightOctetKeyId -> m EightOctetKeyId)
-> Data EightOctetKeyId
EightOctetKeyId -> Constr
EightOctetKeyId -> DataType
(forall b. Data b => b -> b) -> EightOctetKeyId -> EightOctetKeyId
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) -> EightOctetKeyId -> u
forall u. (forall d. Data d => d -> u) -> EightOctetKeyId -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EightOctetKeyId
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EightOctetKeyId -> c EightOctetKeyId
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EightOctetKeyId)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EightOctetKeyId)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EightOctetKeyId -> c EightOctetKeyId
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> EightOctetKeyId -> c EightOctetKeyId
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EightOctetKeyId
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c EightOctetKeyId
$ctoConstr :: EightOctetKeyId -> Constr
toConstr :: EightOctetKeyId -> Constr
$cdataTypeOf :: EightOctetKeyId -> DataType
dataTypeOf :: EightOctetKeyId -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EightOctetKeyId)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c EightOctetKeyId)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EightOctetKeyId)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c EightOctetKeyId)
$cgmapT :: (forall b. Data b => b -> b) -> EightOctetKeyId -> EightOctetKeyId
gmapT :: (forall b. Data b => b -> b) -> EightOctetKeyId -> EightOctetKeyId
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> EightOctetKeyId -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> EightOctetKeyId -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> EightOctetKeyId -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EightOctetKeyId -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> EightOctetKeyId -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> EightOctetKeyId -> m EightOctetKeyId
Data, EightOctetKeyId -> EightOctetKeyId -> Bool
(EightOctetKeyId -> EightOctetKeyId -> Bool)
-> (EightOctetKeyId -> EightOctetKeyId -> Bool)
-> Eq EightOctetKeyId
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: EightOctetKeyId -> EightOctetKeyId -> Bool
== :: EightOctetKeyId -> EightOctetKeyId -> Bool
$c/= :: EightOctetKeyId -> EightOctetKeyId -> Bool
/= :: EightOctetKeyId -> EightOctetKeyId -> Bool
Eq, (forall x. EightOctetKeyId -> Rep EightOctetKeyId x)
-> (forall x. Rep EightOctetKeyId x -> EightOctetKeyId)
-> Generic EightOctetKeyId
forall x. Rep EightOctetKeyId x -> EightOctetKeyId
forall x. EightOctetKeyId -> Rep EightOctetKeyId x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. EightOctetKeyId -> Rep EightOctetKeyId x
from :: forall x. EightOctetKeyId -> Rep EightOctetKeyId x
$cto :: forall x. Rep EightOctetKeyId x -> EightOctetKeyId
to :: forall x. Rep EightOctetKeyId x -> EightOctetKeyId
Generic, Eq EightOctetKeyId
Eq EightOctetKeyId =>
(EightOctetKeyId -> EightOctetKeyId -> Ordering)
-> (EightOctetKeyId -> EightOctetKeyId -> Bool)
-> (EightOctetKeyId -> EightOctetKeyId -> Bool)
-> (EightOctetKeyId -> EightOctetKeyId -> Bool)
-> (EightOctetKeyId -> EightOctetKeyId -> Bool)
-> (EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId)
-> (EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId)
-> Ord EightOctetKeyId
EightOctetKeyId -> EightOctetKeyId -> Bool
EightOctetKeyId -> EightOctetKeyId -> Ordering
EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: EightOctetKeyId -> EightOctetKeyId -> Ordering
compare :: EightOctetKeyId -> EightOctetKeyId -> Ordering
$c< :: EightOctetKeyId -> EightOctetKeyId -> Bool
< :: EightOctetKeyId -> EightOctetKeyId -> Bool
$c<= :: EightOctetKeyId -> EightOctetKeyId -> Bool
<= :: EightOctetKeyId -> EightOctetKeyId -> Bool
$c> :: EightOctetKeyId -> EightOctetKeyId -> Bool
> :: EightOctetKeyId -> EightOctetKeyId -> Bool
$c>= :: EightOctetKeyId -> EightOctetKeyId -> Bool
>= :: EightOctetKeyId -> EightOctetKeyId -> Bool
$cmax :: EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId
max :: EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId
$cmin :: EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId
min :: EightOctetKeyId -> EightOctetKeyId -> EightOctetKeyId
Ord, Typeable)

instance Wrapped EightOctetKeyId

instance Pretty EightOctetKeyId where
  pretty :: forall ann. EightOctetKeyId -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann)
-> (EightOctetKeyId -> String) -> EightOctetKeyId -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
bsToHexUpper (ByteString -> String)
-> (EightOctetKeyId -> ByteString) -> EightOctetKeyId -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped EightOctetKeyId -> EightOctetKeyId)
-> EightOctetKeyId -> Unwrapped EightOctetKeyId
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> EightOctetKeyId
Unwrapped EightOctetKeyId -> EightOctetKeyId
EightOctetKeyId

instance Show EightOctetKeyId where
  show :: EightOctetKeyId -> String
show = ByteString -> String
bsToHexUpper (ByteString -> String)
-> (EightOctetKeyId -> ByteString) -> EightOctetKeyId -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped EightOctetKeyId -> EightOctetKeyId)
-> EightOctetKeyId -> Unwrapped EightOctetKeyId
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> EightOctetKeyId
Unwrapped EightOctetKeyId -> EightOctetKeyId
EightOctetKeyId

instance Read EightOctetKeyId where
  readsPrec :: Int -> ReadS EightOctetKeyId
readsPrec Int
_ =
    ([(Word8, String)] -> (EightOctetKeyId, String))
-> [[(Word8, String)]] -> [(EightOctetKeyId, String)]
forall a b. (a -> b) -> [a] -> [b]
map ((ByteString -> EightOctetKeyId
EightOctetKeyId (ByteString -> EightOctetKeyId)
-> ([Word8] -> ByteString) -> [Word8] -> EightOctetKeyId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> ByteString
BL.pack ([Word8] -> EightOctetKeyId)
-> ([String] -> String)
-> ([Word8], [String])
-> (EightOctetKeyId, String)
forall b c b' c'. (b -> c) -> (b' -> c') -> (b, b') -> (c, c')
forall (a :: * -> * -> *) b c b' c'.
Arrow a =>
a b c -> a b' c' -> a (b, b') (c, c')
*** [String] -> String
forall (t :: * -> *) a. Foldable t => t [a] -> [a]
concat) (([Word8], [String]) -> (EightOctetKeyId, String))
-> ([(Word8, String)] -> ([Word8], [String]))
-> [(Word8, String)]
-> (EightOctetKeyId, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [(Word8, String)] -> ([Word8], [String])
forall a b. [(a, b)] -> ([a], [b])
unzip) ([[(Word8, String)]] -> [(EightOctetKeyId, String)])
-> (String -> [[(Word8, String)]]) -> ReadS EightOctetKeyId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> [(Word8, String)] -> [[(Word8, String)]]
forall e. Int -> [e] -> [[e]]
chunksOf Int
8 ([(Word8, String)] -> [[(Word8, String)]])
-> ReadS Word8 -> String -> [[(Word8, String)]]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ReadS Word8
hexToW8s

instance Hashable EightOctetKeyId

instance A.ToJSON EightOctetKeyId where
  toJSON :: EightOctetKeyId -> Value
toJSON EightOctetKeyId
e = [Pair] -> Value
object [String -> Key
key String
"eoki" Key -> String -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (ByteString -> String
bsToHexUpper (ByteString -> String)
-> (EightOctetKeyId -> ByteString) -> EightOctetKeyId -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped EightOctetKeyId -> EightOctetKeyId)
-> EightOctetKeyId -> Unwrapped EightOctetKeyId
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> EightOctetKeyId
Unwrapped EightOctetKeyId -> EightOctetKeyId
EightOctetKeyId) EightOctetKeyId
e]

instance A.FromJSON EightOctetKeyId where
  parseJSON :: Value -> Parser EightOctetKeyId
parseJSON (A.Object Object
v) = ByteString -> EightOctetKeyId
EightOctetKeyId (ByteString -> EightOctetKeyId)
-> (String -> ByteString) -> String -> EightOctetKeyId
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
forall a. Read a => String -> a
read (String -> EightOctetKeyId)
-> Parser String -> Parser EightOctetKeyId
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"eoki"
  parseJSON Value
_ = Parser EightOctetKeyId
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

data KeyIdentifier
  = KeyIdentifierWildcard
  | KeyIdentifierEightOctet EightOctetKeyId
  | KeyIdentifierFingerprint Fingerprint
  deriving (Typeable KeyIdentifier
Typeable KeyIdentifier =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> KeyIdentifier -> c KeyIdentifier)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KeyIdentifier)
-> (KeyIdentifier -> Constr)
-> (KeyIdentifier -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KeyIdentifier))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c KeyIdentifier))
-> ((forall b. Data b => b -> b) -> KeyIdentifier -> KeyIdentifier)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r)
-> (forall u. (forall d. Data d => d -> u) -> KeyIdentifier -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> KeyIdentifier -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier)
-> Data KeyIdentifier
KeyIdentifier -> Constr
KeyIdentifier -> DataType
(forall b. Data b => b -> b) -> KeyIdentifier -> KeyIdentifier
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) -> KeyIdentifier -> u
forall u. (forall d. Data d => d -> u) -> KeyIdentifier -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyIdentifier
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyIdentifier -> c KeyIdentifier
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyIdentifier)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c KeyIdentifier)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyIdentifier -> c KeyIdentifier
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyIdentifier -> c KeyIdentifier
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyIdentifier
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyIdentifier
$ctoConstr :: KeyIdentifier -> Constr
toConstr :: KeyIdentifier -> Constr
$cdataTypeOf :: KeyIdentifier -> DataType
dataTypeOf :: KeyIdentifier -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyIdentifier)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyIdentifier)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c KeyIdentifier)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c KeyIdentifier)
$cgmapT :: (forall b. Data b => b -> b) -> KeyIdentifier -> KeyIdentifier
gmapT :: (forall b. Data b => b -> b) -> KeyIdentifier -> KeyIdentifier
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyIdentifier -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> KeyIdentifier -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> KeyIdentifier -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyIdentifier -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyIdentifier -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyIdentifier -> m KeyIdentifier
Data, KeyIdentifier -> KeyIdentifier -> Bool
(KeyIdentifier -> KeyIdentifier -> Bool)
-> (KeyIdentifier -> KeyIdentifier -> Bool) -> Eq KeyIdentifier
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyIdentifier -> KeyIdentifier -> Bool
== :: KeyIdentifier -> KeyIdentifier -> Bool
$c/= :: KeyIdentifier -> KeyIdentifier -> Bool
/= :: KeyIdentifier -> KeyIdentifier -> Bool
Eq, (forall x. KeyIdentifier -> Rep KeyIdentifier x)
-> (forall x. Rep KeyIdentifier x -> KeyIdentifier)
-> Generic KeyIdentifier
forall x. Rep KeyIdentifier x -> KeyIdentifier
forall x. KeyIdentifier -> Rep KeyIdentifier x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KeyIdentifier -> Rep KeyIdentifier x
from :: forall x. KeyIdentifier -> Rep KeyIdentifier x
$cto :: forall x. Rep KeyIdentifier x -> KeyIdentifier
to :: forall x. Rep KeyIdentifier x -> KeyIdentifier
Generic, Eq KeyIdentifier
Eq KeyIdentifier =>
(KeyIdentifier -> KeyIdentifier -> Ordering)
-> (KeyIdentifier -> KeyIdentifier -> Bool)
-> (KeyIdentifier -> KeyIdentifier -> Bool)
-> (KeyIdentifier -> KeyIdentifier -> Bool)
-> (KeyIdentifier -> KeyIdentifier -> Bool)
-> (KeyIdentifier -> KeyIdentifier -> KeyIdentifier)
-> (KeyIdentifier -> KeyIdentifier -> KeyIdentifier)
-> Ord KeyIdentifier
KeyIdentifier -> KeyIdentifier -> Bool
KeyIdentifier -> KeyIdentifier -> Ordering
KeyIdentifier -> KeyIdentifier -> KeyIdentifier
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KeyIdentifier -> KeyIdentifier -> Ordering
compare :: KeyIdentifier -> KeyIdentifier -> Ordering
$c< :: KeyIdentifier -> KeyIdentifier -> Bool
< :: KeyIdentifier -> KeyIdentifier -> Bool
$c<= :: KeyIdentifier -> KeyIdentifier -> Bool
<= :: KeyIdentifier -> KeyIdentifier -> Bool
$c> :: KeyIdentifier -> KeyIdentifier -> Bool
> :: KeyIdentifier -> KeyIdentifier -> Bool
$c>= :: KeyIdentifier -> KeyIdentifier -> Bool
>= :: KeyIdentifier -> KeyIdentifier -> Bool
$cmax :: KeyIdentifier -> KeyIdentifier -> KeyIdentifier
max :: KeyIdentifier -> KeyIdentifier -> KeyIdentifier
$cmin :: KeyIdentifier -> KeyIdentifier -> KeyIdentifier
min :: KeyIdentifier -> KeyIdentifier -> KeyIdentifier
Ord, Int -> KeyIdentifier -> ShowS
[KeyIdentifier] -> ShowS
KeyIdentifier -> String
(Int -> KeyIdentifier -> ShowS)
-> (KeyIdentifier -> String)
-> ([KeyIdentifier] -> ShowS)
-> Show KeyIdentifier
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyIdentifier -> ShowS
showsPrec :: Int -> KeyIdentifier -> ShowS
$cshow :: KeyIdentifier -> String
show :: KeyIdentifier -> String
$cshowList :: [KeyIdentifier] -> ShowS
showList :: [KeyIdentifier] -> ShowS
Show, Typeable)

instance Pretty KeyIdentifier where
  pretty :: forall ann. KeyIdentifier -> Doc ann
pretty KeyIdentifier
KeyIdentifierWildcard = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"wildcard"
  pretty (KeyIdentifierEightOctet EightOctetKeyId
kid) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"key-id" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> EightOctetKeyId -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. EightOctetKeyId -> Doc ann
pretty EightOctetKeyId
kid
  pretty (KeyIdentifierFingerprint Fingerprint
fp) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"fingerprint" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Fingerprint -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Fingerprint -> Doc ann
pretty Fingerprint
fp

instance A.ToJSON KeyIdentifier where
  toJSON :: KeyIdentifier -> Value
toJSON KeyIdentifier
KeyIdentifierWildcard = [Pair] -> Value
object [String -> Key
key String
"wildcard" Key -> Value -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool -> Value
A.Bool Bool
True]
  toJSON (KeyIdentifierEightOctet EightOctetKeyId
kid) = [Pair] -> Value
object [String -> Key
key String
"keyId" Key -> EightOctetKeyId -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= EightOctetKeyId
kid]
  toJSON (KeyIdentifierFingerprint Fingerprint
fp) = [Pair] -> Value
object [String -> Key
key String
"fingerprint" Key -> Fingerprint -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Fingerprint
fp]

instance A.FromJSON KeyIdentifier where
  parseJSON :: Value -> Parser KeyIdentifier
parseJSON (A.Object Object
v) =
    ((Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"wildcard") Parser Bool
-> (Bool -> Parser KeyIdentifier) -> Parser KeyIdentifier
forall a b. Parser a -> (a -> Parser b) -> Parser b
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Bool
isWildcard ->
      if Bool
isWildcard then KeyIdentifier -> Parser KeyIdentifier
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure KeyIdentifier
KeyIdentifierWildcard else Parser KeyIdentifier
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero)
    Parser KeyIdentifier
-> Parser KeyIdentifier -> Parser KeyIdentifier
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (EightOctetKeyId -> KeyIdentifier
KeyIdentifierEightOctet (EightOctetKeyId -> KeyIdentifier)
-> Parser EightOctetKeyId -> Parser KeyIdentifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser EightOctetKeyId
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"keyId")
    Parser KeyIdentifier
-> Parser KeyIdentifier -> Parser KeyIdentifier
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|> (Fingerprint -> KeyIdentifier
KeyIdentifierFingerprint (Fingerprint -> KeyIdentifier)
-> Parser Fingerprint -> Parser KeyIdentifier
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Fingerprint
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"fingerprint")
  parseJSON Value
_ = Parser KeyIdentifier
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

newtype NotationName =
  NotationName
    { NotationName -> ByteString
unNotationName :: ByteString
    }
  deriving (Typeable NotationName
Typeable NotationName =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NotationName -> c NotationName)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NotationName)
-> (NotationName -> Constr)
-> (NotationName -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NotationName))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NotationName))
-> ((forall b. Data b => b -> b) -> NotationName -> NotationName)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NotationName -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NotationName -> r)
-> (forall u. (forall d. Data d => d -> u) -> NotationName -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NotationName -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NotationName -> m NotationName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NotationName -> m NotationName)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NotationName -> m NotationName)
-> Data NotationName
NotationName -> Constr
NotationName -> DataType
(forall b. Data b => b -> b) -> NotationName -> NotationName
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) -> NotationName -> u
forall u. (forall d. Data d => d -> u) -> NotationName -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationName -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationName -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationName
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationName -> c NotationName
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationName)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationName)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationName -> c NotationName
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationName -> c NotationName
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationName
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationName
$ctoConstr :: NotationName -> Constr
toConstr :: NotationName -> Constr
$cdataTypeOf :: NotationName -> DataType
dataTypeOf :: NotationName -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationName)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationName)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationName)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationName)
$cgmapT :: (forall b. Data b => b -> b) -> NotationName -> NotationName
gmapT :: (forall b. Data b => b -> b) -> NotationName -> NotationName
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationName -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationName -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationName -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationName -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NotationName -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NotationName -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NotationName -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NotationName -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationName -> m NotationName
Data, NotationName -> NotationName -> Bool
(NotationName -> NotationName -> Bool)
-> (NotationName -> NotationName -> Bool) -> Eq NotationName
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NotationName -> NotationName -> Bool
== :: NotationName -> NotationName -> Bool
$c/= :: NotationName -> NotationName -> Bool
/= :: NotationName -> NotationName -> Bool
Eq, (forall x. NotationName -> Rep NotationName x)
-> (forall x. Rep NotationName x -> NotationName)
-> Generic NotationName
forall x. Rep NotationName x -> NotationName
forall x. NotationName -> Rep NotationName x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NotationName -> Rep NotationName x
from :: forall x. NotationName -> Rep NotationName x
$cto :: forall x. Rep NotationName x -> NotationName
to :: forall x. Rep NotationName x -> NotationName
Generic, Eq NotationName
Eq NotationName =>
(Int -> NotationName -> Int)
-> (NotationName -> Int) -> Hashable NotationName
Int -> NotationName -> Int
NotationName -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> NotationName -> Int
hashWithSalt :: Int -> NotationName -> Int
$chash :: NotationName -> Int
hash :: NotationName -> Int
Hashable, Eq NotationName
Eq NotationName =>
(NotationName -> NotationName -> Ordering)
-> (NotationName -> NotationName -> Bool)
-> (NotationName -> NotationName -> Bool)
-> (NotationName -> NotationName -> Bool)
-> (NotationName -> NotationName -> Bool)
-> (NotationName -> NotationName -> NotationName)
-> (NotationName -> NotationName -> NotationName)
-> Ord NotationName
NotationName -> NotationName -> Bool
NotationName -> NotationName -> Ordering
NotationName -> NotationName -> NotationName
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NotationName -> NotationName -> Ordering
compare :: NotationName -> NotationName -> Ordering
$c< :: NotationName -> NotationName -> Bool
< :: NotationName -> NotationName -> Bool
$c<= :: NotationName -> NotationName -> Bool
<= :: NotationName -> NotationName -> Bool
$c> :: NotationName -> NotationName -> Bool
> :: NotationName -> NotationName -> Bool
$c>= :: NotationName -> NotationName -> Bool
>= :: NotationName -> NotationName -> Bool
$cmax :: NotationName -> NotationName -> NotationName
max :: NotationName -> NotationName -> NotationName
$cmin :: NotationName -> NotationName -> NotationName
min :: NotationName -> NotationName -> NotationName
Ord, Int -> NotationName -> ShowS
[NotationName] -> ShowS
NotationName -> String
(Int -> NotationName -> ShowS)
-> (NotationName -> String)
-> ([NotationName] -> ShowS)
-> Show NotationName
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NotationName -> ShowS
showsPrec :: Int -> NotationName -> ShowS
$cshow :: NotationName -> String
show :: NotationName -> String
$cshowList :: [NotationName] -> ShowS
showList :: [NotationName] -> ShowS
Show, Typeable)

instance Pretty NotationName where
  pretty :: forall ann. NotationName -> Doc ann
pretty = ByteString -> Doc ann
forall ann. ByteString -> Doc ann
prettyLBS (ByteString -> Doc ann)
-> (NotationName -> ByteString) -> NotationName -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NotationName -> ByteString
unNotationName

instance Wrapped NotationName

instance A.ToJSON NotationName where
  toJSON :: NotationName -> Value
toJSON NotationName
nn = [Pair] -> Value
object [String -> Key
key String
"notationname" Key -> String -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ByteString -> String
forall a. Show a => a -> String
show ((Unwrapped NotationName -> NotationName)
-> NotationName -> Unwrapped NotationName
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> NotationName
Unwrapped NotationName -> NotationName
NotationName NotationName
nn)]

instance A.FromJSON NotationName where
  parseJSON :: Value -> Parser NotationName
parseJSON (A.Object Object
v) = ByteString -> NotationName
NotationName (ByteString -> NotationName)
-> (String -> ByteString) -> String -> NotationName
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
forall a. Read a => String -> a
read (String -> NotationName) -> Parser String -> Parser NotationName
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"notationname"
  parseJSON Value
_ = Parser NotationName
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

newtype NotationValue =
  NotationValue
    { NotationValue -> ByteString
unNotationValue :: ByteString
    }
  deriving (Typeable NotationValue
Typeable NotationValue =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> NotationValue -> c NotationValue)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c NotationValue)
-> (NotationValue -> Constr)
-> (NotationValue -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c NotationValue))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c NotationValue))
-> ((forall b. Data b => b -> b) -> NotationValue -> NotationValue)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> NotationValue -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> NotationValue -> r)
-> (forall u. (forall d. Data d => d -> u) -> NotationValue -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> NotationValue -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> NotationValue -> m NotationValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NotationValue -> m NotationValue)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> NotationValue -> m NotationValue)
-> Data NotationValue
NotationValue -> Constr
NotationValue -> DataType
(forall b. Data b => b -> b) -> NotationValue -> NotationValue
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) -> NotationValue -> u
forall u. (forall d. Data d => d -> u) -> NotationValue -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationValue -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationValue -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationValue
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationValue -> c NotationValue
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationValue)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationValue)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationValue -> c NotationValue
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> NotationValue -> c NotationValue
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationValue
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c NotationValue
$ctoConstr :: NotationValue -> Constr
toConstr :: NotationValue -> Constr
$cdataTypeOf :: NotationValue -> DataType
dataTypeOf :: NotationValue -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationValue)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c NotationValue)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationValue)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c NotationValue)
$cgmapT :: (forall b. Data b => b -> b) -> NotationValue -> NotationValue
gmapT :: (forall b. Data b => b -> b) -> NotationValue -> NotationValue
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationValue -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> NotationValue -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationValue -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> NotationValue -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> NotationValue -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> NotationValue -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NotationValue -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> NotationValue -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> NotationValue -> m NotationValue
Data, NotationValue -> NotationValue -> Bool
(NotationValue -> NotationValue -> Bool)
-> (NotationValue -> NotationValue -> Bool) -> Eq NotationValue
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: NotationValue -> NotationValue -> Bool
== :: NotationValue -> NotationValue -> Bool
$c/= :: NotationValue -> NotationValue -> Bool
/= :: NotationValue -> NotationValue -> Bool
Eq, (forall x. NotationValue -> Rep NotationValue x)
-> (forall x. Rep NotationValue x -> NotationValue)
-> Generic NotationValue
forall x. Rep NotationValue x -> NotationValue
forall x. NotationValue -> Rep NotationValue x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. NotationValue -> Rep NotationValue x
from :: forall x. NotationValue -> Rep NotationValue x
$cto :: forall x. Rep NotationValue x -> NotationValue
to :: forall x. Rep NotationValue x -> NotationValue
Generic, Eq NotationValue
Eq NotationValue =>
(Int -> NotationValue -> Int)
-> (NotationValue -> Int) -> Hashable NotationValue
Int -> NotationValue -> Int
NotationValue -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> NotationValue -> Int
hashWithSalt :: Int -> NotationValue -> Int
$chash :: NotationValue -> Int
hash :: NotationValue -> Int
Hashable, Eq NotationValue
Eq NotationValue =>
(NotationValue -> NotationValue -> Ordering)
-> (NotationValue -> NotationValue -> Bool)
-> (NotationValue -> NotationValue -> Bool)
-> (NotationValue -> NotationValue -> Bool)
-> (NotationValue -> NotationValue -> Bool)
-> (NotationValue -> NotationValue -> NotationValue)
-> (NotationValue -> NotationValue -> NotationValue)
-> Ord NotationValue
NotationValue -> NotationValue -> Bool
NotationValue -> NotationValue -> Ordering
NotationValue -> NotationValue -> NotationValue
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: NotationValue -> NotationValue -> Ordering
compare :: NotationValue -> NotationValue -> Ordering
$c< :: NotationValue -> NotationValue -> Bool
< :: NotationValue -> NotationValue -> Bool
$c<= :: NotationValue -> NotationValue -> Bool
<= :: NotationValue -> NotationValue -> Bool
$c> :: NotationValue -> NotationValue -> Bool
> :: NotationValue -> NotationValue -> Bool
$c>= :: NotationValue -> NotationValue -> Bool
>= :: NotationValue -> NotationValue -> Bool
$cmax :: NotationValue -> NotationValue -> NotationValue
max :: NotationValue -> NotationValue -> NotationValue
$cmin :: NotationValue -> NotationValue -> NotationValue
min :: NotationValue -> NotationValue -> NotationValue
Ord, Int -> NotationValue -> ShowS
[NotationValue] -> ShowS
NotationValue -> String
(Int -> NotationValue -> ShowS)
-> (NotationValue -> String)
-> ([NotationValue] -> ShowS)
-> Show NotationValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> NotationValue -> ShowS
showsPrec :: Int -> NotationValue -> ShowS
$cshow :: NotationValue -> String
show :: NotationValue -> String
$cshowList :: [NotationValue] -> ShowS
showList :: [NotationValue] -> ShowS
Show, Typeable)

instance Pretty NotationValue where
  pretty :: forall ann. NotationValue -> Doc ann
pretty = ByteString -> Doc ann
forall ann. ByteString -> Doc ann
prettyLBS (ByteString -> Doc ann)
-> (NotationValue -> ByteString) -> NotationValue -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NotationValue -> ByteString
unNotationValue

instance Wrapped NotationValue

instance A.ToJSON NotationValue where
  toJSON :: NotationValue -> Value
toJSON NotationValue
nv = [Pair] -> Value
object [String -> Key
key String
"notationvalue" Key -> String -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ByteString -> String
forall a. Show a => a -> String
show ((Unwrapped NotationValue -> NotationValue)
-> NotationValue -> Unwrapped NotationValue
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> NotationValue
Unwrapped NotationValue -> NotationValue
NotationValue NotationValue
nv)]

instance A.FromJSON NotationValue where
  parseJSON :: Value -> Parser NotationValue
parseJSON (A.Object Object
v) =
    ByteString -> NotationValue
NotationValue (ByteString -> NotationValue)
-> (String -> ByteString) -> String -> NotationValue
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> ByteString
forall a. Read a => String -> a
read (String -> NotationValue) -> Parser String -> Parser NotationValue
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"notationvalue"
  parseJSON Value
_ = Parser NotationValue
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

data HashAlgorithm
  = DeprecatedMD5
  | SHA1
  | RIPEMD160
  | SHA256
  | SHA384
  | SHA512
  | SHA224
  | SHA3_256
  | SHA3_512
  | OtherHA Word8
  deriving (Typeable HashAlgorithm
Typeable HashAlgorithm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> HashAlgorithm -> c HashAlgorithm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c HashAlgorithm)
-> (HashAlgorithm -> Constr)
-> (HashAlgorithm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c HashAlgorithm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c HashAlgorithm))
-> ((forall b. Data b => b -> b) -> HashAlgorithm -> HashAlgorithm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r)
-> (forall u. (forall d. Data d => d -> u) -> HashAlgorithm -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> HashAlgorithm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm)
-> Data HashAlgorithm
HashAlgorithm -> Constr
HashAlgorithm -> DataType
(forall b. Data b => b -> b) -> HashAlgorithm -> HashAlgorithm
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) -> HashAlgorithm -> u
forall u. (forall d. Data d => d -> u) -> HashAlgorithm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HashAlgorithm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HashAlgorithm -> c HashAlgorithm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HashAlgorithm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HashAlgorithm)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HashAlgorithm -> c HashAlgorithm
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> HashAlgorithm -> c HashAlgorithm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HashAlgorithm
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c HashAlgorithm
$ctoConstr :: HashAlgorithm -> Constr
toConstr :: HashAlgorithm -> Constr
$cdataTypeOf :: HashAlgorithm -> DataType
dataTypeOf :: HashAlgorithm -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HashAlgorithm)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c HashAlgorithm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HashAlgorithm)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c HashAlgorithm)
$cgmapT :: (forall b. Data b => b -> b) -> HashAlgorithm -> HashAlgorithm
gmapT :: (forall b. Data b => b -> b) -> HashAlgorithm -> HashAlgorithm
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> HashAlgorithm -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> HashAlgorithm -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> HashAlgorithm -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HashAlgorithm -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> HashAlgorithm -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> HashAlgorithm -> m HashAlgorithm
Data, (forall x. HashAlgorithm -> Rep HashAlgorithm x)
-> (forall x. Rep HashAlgorithm x -> HashAlgorithm)
-> Generic HashAlgorithm
forall x. Rep HashAlgorithm x -> HashAlgorithm
forall x. HashAlgorithm -> Rep HashAlgorithm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. HashAlgorithm -> Rep HashAlgorithm x
from :: forall x. HashAlgorithm -> Rep HashAlgorithm x
$cto :: forall x. Rep HashAlgorithm x -> HashAlgorithm
to :: forall x. Rep HashAlgorithm x -> HashAlgorithm
Generic, Int -> HashAlgorithm -> ShowS
[HashAlgorithm] -> ShowS
HashAlgorithm -> String
(Int -> HashAlgorithm -> ShowS)
-> (HashAlgorithm -> String)
-> ([HashAlgorithm] -> ShowS)
-> Show HashAlgorithm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> HashAlgorithm -> ShowS
showsPrec :: Int -> HashAlgorithm -> ShowS
$cshow :: HashAlgorithm -> String
show :: HashAlgorithm -> String
$cshowList :: [HashAlgorithm] -> ShowS
showList :: [HashAlgorithm] -> ShowS
Show, Typeable)

instance Eq HashAlgorithm where
  == :: HashAlgorithm -> HashAlgorithm -> Bool
(==) HashAlgorithm
a HashAlgorithm
b = HashAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal HashAlgorithm
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== HashAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal HashAlgorithm
b

instance Ord HashAlgorithm where
  compare :: HashAlgorithm -> HashAlgorithm -> Ordering
compare = (HashAlgorithm -> Word8)
-> HashAlgorithm -> HashAlgorithm -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing HashAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal HashAlgorithm where
  fromFVal :: HashAlgorithm -> Word8
fromFVal HashAlgorithm
DeprecatedMD5 = Word8
1
  fromFVal HashAlgorithm
SHA1 = Word8
2
  fromFVal HashAlgorithm
RIPEMD160 = Word8
3
  fromFVal HashAlgorithm
SHA256 = Word8
8
  fromFVal HashAlgorithm
SHA384 = Word8
9
  fromFVal HashAlgorithm
SHA512 = Word8
10
  fromFVal HashAlgorithm
SHA224 = Word8
11
  fromFVal HashAlgorithm
SHA3_256 = Word8
12
  fromFVal HashAlgorithm
SHA3_512 = Word8
14
  fromFVal (OtherHA Word8
o) = Word8
o
  toFVal :: Word8 -> HashAlgorithm
toFVal Word8
1 = HashAlgorithm
DeprecatedMD5
  toFVal Word8
2 = HashAlgorithm
SHA1
  toFVal Word8
3 = HashAlgorithm
RIPEMD160
  toFVal Word8
8 = HashAlgorithm
SHA256
  toFVal Word8
9 = HashAlgorithm
SHA384
  toFVal Word8
10 = HashAlgorithm
SHA512
  toFVal Word8
11 = HashAlgorithm
SHA224
  toFVal Word8
12 = HashAlgorithm
SHA3_256
  toFVal Word8
14 = HashAlgorithm
SHA3_512
  toFVal Word8
o = Word8 -> HashAlgorithm
OtherHA Word8
o

instance Hashable HashAlgorithm

instance Pretty HashAlgorithm where
  pretty :: forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
DeprecatedMD5 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"(deprecated) MD5"
  pretty HashAlgorithm
SHA1 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"SHA-1"
  pretty HashAlgorithm
RIPEMD160 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"RIPEMD-160"
  pretty HashAlgorithm
SHA256 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"SHA-256"
  pretty HashAlgorithm
SHA384 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"SHA-384"
  pretty HashAlgorithm
SHA512 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"SHA-512"
  pretty HashAlgorithm
SHA224 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"SHA-224"
  pretty HashAlgorithm
SHA3_256 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"SHA3-256"
  pretty HashAlgorithm
SHA3_512 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"SHA3-512"
  pretty (OtherHA Word8
ha) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown hash algorithm type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
ha

$(ATH.deriveJSON ATH.defaultOptions ''HashAlgorithm)

data CompressionAlgorithm
  = Uncompressed
  | ZIP
  | ZLIB
  | BZip2
  | OtherCA Word8
  deriving (Int -> CompressionAlgorithm -> ShowS
[CompressionAlgorithm] -> ShowS
CompressionAlgorithm -> String
(Int -> CompressionAlgorithm -> ShowS)
-> (CompressionAlgorithm -> String)
-> ([CompressionAlgorithm] -> ShowS)
-> Show CompressionAlgorithm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> CompressionAlgorithm -> ShowS
showsPrec :: Int -> CompressionAlgorithm -> ShowS
$cshow :: CompressionAlgorithm -> String
show :: CompressionAlgorithm -> String
$cshowList :: [CompressionAlgorithm] -> ShowS
showList :: [CompressionAlgorithm] -> ShowS
Show, Typeable CompressionAlgorithm
Typeable CompressionAlgorithm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> CompressionAlgorithm
 -> c CompressionAlgorithm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c CompressionAlgorithm)
-> (CompressionAlgorithm -> Constr)
-> (CompressionAlgorithm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c CompressionAlgorithm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c CompressionAlgorithm))
-> ((forall b. Data b => b -> b)
    -> CompressionAlgorithm -> CompressionAlgorithm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> CompressionAlgorithm -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> CompressionAlgorithm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> CompressionAlgorithm -> m CompressionAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompressionAlgorithm -> m CompressionAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> CompressionAlgorithm -> m CompressionAlgorithm)
-> Data CompressionAlgorithm
CompressionAlgorithm -> Constr
CompressionAlgorithm -> DataType
(forall b. Data b => b -> b)
-> CompressionAlgorithm -> CompressionAlgorithm
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) -> CompressionAlgorithm -> u
forall u.
(forall d. Data d => d -> u) -> CompressionAlgorithm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompressionAlgorithm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompressionAlgorithm
-> c CompressionAlgorithm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompressionAlgorithm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompressionAlgorithm)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompressionAlgorithm
-> c CompressionAlgorithm
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> CompressionAlgorithm
-> c CompressionAlgorithm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompressionAlgorithm
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c CompressionAlgorithm
$ctoConstr :: CompressionAlgorithm -> Constr
toConstr :: CompressionAlgorithm -> Constr
$cdataTypeOf :: CompressionAlgorithm -> DataType
dataTypeOf :: CompressionAlgorithm -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompressionAlgorithm)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c CompressionAlgorithm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompressionAlgorithm)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c CompressionAlgorithm)
$cgmapT :: (forall b. Data b => b -> b)
-> CompressionAlgorithm -> CompressionAlgorithm
gmapT :: (forall b. Data b => b -> b)
-> CompressionAlgorithm -> CompressionAlgorithm
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> CompressionAlgorithm -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> CompressionAlgorithm -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> CompressionAlgorithm -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompressionAlgorithm -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> CompressionAlgorithm -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> CompressionAlgorithm -> m CompressionAlgorithm
Data, (forall x. CompressionAlgorithm -> Rep CompressionAlgorithm x)
-> (forall x. Rep CompressionAlgorithm x -> CompressionAlgorithm)
-> Generic CompressionAlgorithm
forall x. Rep CompressionAlgorithm x -> CompressionAlgorithm
forall x. CompressionAlgorithm -> Rep CompressionAlgorithm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. CompressionAlgorithm -> Rep CompressionAlgorithm x
from :: forall x. CompressionAlgorithm -> Rep CompressionAlgorithm x
$cto :: forall x. Rep CompressionAlgorithm x -> CompressionAlgorithm
to :: forall x. Rep CompressionAlgorithm x -> CompressionAlgorithm
Generic, Typeable)

instance Eq CompressionAlgorithm where
  == :: CompressionAlgorithm -> CompressionAlgorithm -> Bool
(==) CompressionAlgorithm
a CompressionAlgorithm
b = CompressionAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal CompressionAlgorithm
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== CompressionAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal CompressionAlgorithm
b

instance Ord CompressionAlgorithm where
  compare :: CompressionAlgorithm -> CompressionAlgorithm -> Ordering
compare = (CompressionAlgorithm -> Word8)
-> CompressionAlgorithm -> CompressionAlgorithm -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing CompressionAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal CompressionAlgorithm where
  fromFVal :: CompressionAlgorithm -> Word8
fromFVal CompressionAlgorithm
Uncompressed = Word8
0
  fromFVal CompressionAlgorithm
ZIP = Word8
1
  fromFVal CompressionAlgorithm
ZLIB = Word8
2
  fromFVal CompressionAlgorithm
BZip2 = Word8
3
  fromFVal (OtherCA Word8
o) = Word8
o
  toFVal :: Word8 -> CompressionAlgorithm
toFVal Word8
0 = CompressionAlgorithm
Uncompressed
  toFVal Word8
1 = CompressionAlgorithm
ZIP
  toFVal Word8
2 = CompressionAlgorithm
ZLIB
  toFVal Word8
3 = CompressionAlgorithm
BZip2
  toFVal Word8
o = Word8 -> CompressionAlgorithm
OtherCA Word8
o

instance Hashable CompressionAlgorithm

instance Pretty CompressionAlgorithm where
  pretty :: forall ann. CompressionAlgorithm -> Doc ann
pretty CompressionAlgorithm
Uncompressed = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"uncompressed"
  pretty CompressionAlgorithm
ZIP = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"ZIP"
  pretty CompressionAlgorithm
ZLIB = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"zlib"
  pretty CompressionAlgorithm
BZip2 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"bzip2"
  pretty (OtherCA Word8
ca) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown compression algorithm type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
ca

$(ATH.deriveJSON ATH.defaultOptions ''CompressionAlgorithm)

data AEADAlgorithm
  = EAX
  | OCB
  | GCM
  | OtherAEADAlgo Word8
  deriving (Int -> AEADAlgorithm -> ShowS
[AEADAlgorithm] -> ShowS
AEADAlgorithm -> String
(Int -> AEADAlgorithm -> ShowS)
-> (AEADAlgorithm -> String)
-> ([AEADAlgorithm] -> ShowS)
-> Show AEADAlgorithm
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> AEADAlgorithm -> ShowS
showsPrec :: Int -> AEADAlgorithm -> ShowS
$cshow :: AEADAlgorithm -> String
show :: AEADAlgorithm -> String
$cshowList :: [AEADAlgorithm] -> ShowS
showList :: [AEADAlgorithm] -> ShowS
Show, Typeable AEADAlgorithm
Typeable AEADAlgorithm =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> AEADAlgorithm -> c AEADAlgorithm)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c AEADAlgorithm)
-> (AEADAlgorithm -> Constr)
-> (AEADAlgorithm -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c AEADAlgorithm))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c AEADAlgorithm))
-> ((forall b. Data b => b -> b) -> AEADAlgorithm -> AEADAlgorithm)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r)
-> (forall u. (forall d. Data d => d -> u) -> AEADAlgorithm -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> AEADAlgorithm -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm)
-> Data AEADAlgorithm
AEADAlgorithm -> Constr
AEADAlgorithm -> DataType
(forall b. Data b => b -> b) -> AEADAlgorithm -> AEADAlgorithm
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) -> AEADAlgorithm -> u
forall u. (forall d. Data d => d -> u) -> AEADAlgorithm -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AEADAlgorithm
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AEADAlgorithm -> c AEADAlgorithm
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AEADAlgorithm)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AEADAlgorithm)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AEADAlgorithm -> c AEADAlgorithm
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> AEADAlgorithm -> c AEADAlgorithm
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AEADAlgorithm
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c AEADAlgorithm
$ctoConstr :: AEADAlgorithm -> Constr
toConstr :: AEADAlgorithm -> Constr
$cdataTypeOf :: AEADAlgorithm -> DataType
dataTypeOf :: AEADAlgorithm -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AEADAlgorithm)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c AEADAlgorithm)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AEADAlgorithm)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c AEADAlgorithm)
$cgmapT :: (forall b. Data b => b -> b) -> AEADAlgorithm -> AEADAlgorithm
gmapT :: (forall b. Data b => b -> b) -> AEADAlgorithm -> AEADAlgorithm
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> AEADAlgorithm -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> AEADAlgorithm -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> AEADAlgorithm -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AEADAlgorithm -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> AEADAlgorithm -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> AEADAlgorithm -> m AEADAlgorithm
Data, (forall x. AEADAlgorithm -> Rep AEADAlgorithm x)
-> (forall x. Rep AEADAlgorithm x -> AEADAlgorithm)
-> Generic AEADAlgorithm
forall x. Rep AEADAlgorithm x -> AEADAlgorithm
forall x. AEADAlgorithm -> Rep AEADAlgorithm x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. AEADAlgorithm -> Rep AEADAlgorithm x
from :: forall x. AEADAlgorithm -> Rep AEADAlgorithm x
$cto :: forall x. Rep AEADAlgorithm x -> AEADAlgorithm
to :: forall x. Rep AEADAlgorithm x -> AEADAlgorithm
Generic, Typeable)

instance Eq AEADAlgorithm where
  == :: AEADAlgorithm -> AEADAlgorithm -> Bool
(==) AEADAlgorithm
a AEADAlgorithm
b = AEADAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal AEADAlgorithm
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== AEADAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal AEADAlgorithm
b

instance Ord AEADAlgorithm where
  compare :: AEADAlgorithm -> AEADAlgorithm -> Ordering
compare = (AEADAlgorithm -> Word8)
-> AEADAlgorithm -> AEADAlgorithm -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing AEADAlgorithm -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal AEADAlgorithm where
  fromFVal :: AEADAlgorithm -> Word8
fromFVal AEADAlgorithm
EAX = Word8
1
  fromFVal AEADAlgorithm
OCB = Word8
2
  fromFVal AEADAlgorithm
GCM = Word8
3
  fromFVal (OtherAEADAlgo Word8
o) = Word8
o
  toFVal :: Word8 -> AEADAlgorithm
toFVal Word8
1 = AEADAlgorithm
EAX
  toFVal Word8
2 = AEADAlgorithm
OCB
  toFVal Word8
3 = AEADAlgorithm
GCM
  toFVal Word8
o = Word8 -> AEADAlgorithm
OtherAEADAlgo Word8
o

instance Hashable AEADAlgorithm

instance Pretty AEADAlgorithm where
  pretty :: forall ann. AEADAlgorithm -> Doc ann
pretty AEADAlgorithm
EAX = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"EAX"
  pretty AEADAlgorithm
OCB = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"OCB"
  pretty AEADAlgorithm
GCM = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"GCM"
  pretty (OtherAEADAlgo Word8
aa) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown AEAD algorithm type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
aa

$(ATH.deriveJSON ATH.defaultOptions ''AEADAlgorithm)

data KSPFlag
  = NoModify
  | KSPOther Int
  deriving (Typeable KSPFlag
Typeable KSPFlag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> KSPFlag -> c KSPFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KSPFlag)
-> (KSPFlag -> Constr)
-> (KSPFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KSPFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KSPFlag))
-> ((forall b. Data b => b -> b) -> KSPFlag -> KSPFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KSPFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KSPFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> KSPFlag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> KSPFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag)
-> Data KSPFlag
KSPFlag -> Constr
KSPFlag -> DataType
(forall b. Data b => b -> b) -> KSPFlag -> KSPFlag
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) -> KSPFlag -> u
forall u. (forall d. Data d => d -> u) -> KSPFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KSPFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KSPFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KSPFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KSPFlag -> c KSPFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KSPFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KSPFlag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KSPFlag -> c KSPFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KSPFlag -> c KSPFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KSPFlag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KSPFlag
$ctoConstr :: KSPFlag -> Constr
toConstr :: KSPFlag -> Constr
$cdataTypeOf :: KSPFlag -> DataType
dataTypeOf :: KSPFlag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KSPFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KSPFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KSPFlag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KSPFlag)
$cgmapT :: (forall b. Data b => b -> b) -> KSPFlag -> KSPFlag
gmapT :: (forall b. Data b => b -> b) -> KSPFlag -> KSPFlag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KSPFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KSPFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KSPFlag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KSPFlag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> KSPFlag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> KSPFlag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KSPFlag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KSPFlag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KSPFlag -> m KSPFlag
Data, (forall x. KSPFlag -> Rep KSPFlag x)
-> (forall x. Rep KSPFlag x -> KSPFlag) -> Generic KSPFlag
forall x. Rep KSPFlag x -> KSPFlag
forall x. KSPFlag -> Rep KSPFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KSPFlag -> Rep KSPFlag x
from :: forall x. KSPFlag -> Rep KSPFlag x
$cto :: forall x. Rep KSPFlag x -> KSPFlag
to :: forall x. Rep KSPFlag x -> KSPFlag
Generic, Int -> KSPFlag -> ShowS
[KSPFlag] -> ShowS
KSPFlag -> String
(Int -> KSPFlag -> ShowS)
-> (KSPFlag -> String) -> ([KSPFlag] -> ShowS) -> Show KSPFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KSPFlag -> ShowS
showsPrec :: Int -> KSPFlag -> ShowS
$cshow :: KSPFlag -> String
show :: KSPFlag -> String
$cshowList :: [KSPFlag] -> ShowS
showList :: [KSPFlag] -> ShowS
Show, Typeable)

instance Eq KSPFlag where
  == :: KSPFlag -> KSPFlag -> Bool
(==) KSPFlag
a KSPFlag
b = KSPFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag KSPFlag
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== KSPFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag KSPFlag
b

instance Ord KSPFlag where
  compare :: KSPFlag -> KSPFlag -> Ordering
compare = (KSPFlag -> Int) -> KSPFlag -> KSPFlag -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing KSPFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag

instance FutureFlag KSPFlag where
  fromFFlag :: KSPFlag -> Int
fromFFlag KSPFlag
NoModify = Int
0
  fromFFlag (KSPOther Int
i) = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i
  toFFlag :: Int -> KSPFlag
toFFlag Int
0 = KSPFlag
NoModify
  toFFlag Int
i = Int -> KSPFlag
KSPOther (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)

instance Hashable KSPFlag

instance Pretty KSPFlag where
  pretty :: forall ann. KSPFlag -> Doc ann
pretty KSPFlag
NoModify = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"no-modify"
  pretty (KSPOther Int
o) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown keyserver preference flag type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
o

$(ATH.deriveJSON ATH.defaultOptions ''KSPFlag)

data KeyFlag
  = GroupKey
  | AuthKey
  | SplitKey
  | EncryptStorageKey
  | EncryptCommunicationsKey
  | SignDataKey
  | CertifyKeysKey
  | KFOther Int
  deriving (Typeable KeyFlag
Typeable KeyFlag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> KeyFlag -> c KeyFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KeyFlag)
-> (KeyFlag -> Constr)
-> (KeyFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KeyFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyFlag))
-> ((forall b. Data b => b -> b) -> KeyFlag -> KeyFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> KeyFlag -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> KeyFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag)
-> Data KeyFlag
KeyFlag -> Constr
KeyFlag -> DataType
(forall b. Data b => b -> b) -> KeyFlag -> KeyFlag
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) -> KeyFlag -> u
forall u. (forall d. Data d => d -> u) -> KeyFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyFlag -> c KeyFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyFlag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyFlag -> c KeyFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyFlag -> c KeyFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyFlag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyFlag
$ctoConstr :: KeyFlag -> Constr
toConstr :: KeyFlag -> Constr
$cdataTypeOf :: KeyFlag -> DataType
dataTypeOf :: KeyFlag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyFlag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyFlag)
$cgmapT :: (forall b. Data b => b -> b) -> KeyFlag -> KeyFlag
gmapT :: (forall b. Data b => b -> b) -> KeyFlag -> KeyFlag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyFlag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyFlag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> KeyFlag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> KeyFlag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyFlag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyFlag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyFlag -> m KeyFlag
Data, (forall x. KeyFlag -> Rep KeyFlag x)
-> (forall x. Rep KeyFlag x -> KeyFlag) -> Generic KeyFlag
forall x. Rep KeyFlag x -> KeyFlag
forall x. KeyFlag -> Rep KeyFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KeyFlag -> Rep KeyFlag x
from :: forall x. KeyFlag -> Rep KeyFlag x
$cto :: forall x. Rep KeyFlag x -> KeyFlag
to :: forall x. Rep KeyFlag x -> KeyFlag
Generic, Int -> KeyFlag -> ShowS
[KeyFlag] -> ShowS
KeyFlag -> String
(Int -> KeyFlag -> ShowS)
-> (KeyFlag -> String) -> ([KeyFlag] -> ShowS) -> Show KeyFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyFlag -> ShowS
showsPrec :: Int -> KeyFlag -> ShowS
$cshow :: KeyFlag -> String
show :: KeyFlag -> String
$cshowList :: [KeyFlag] -> ShowS
showList :: [KeyFlag] -> ShowS
Show, Typeable)

instance Eq KeyFlag where
  == :: KeyFlag -> KeyFlag -> Bool
(==) KeyFlag
a KeyFlag
b = KeyFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag KeyFlag
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== KeyFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag KeyFlag
b

instance Ord KeyFlag where
  compare :: KeyFlag -> KeyFlag -> Ordering
compare = (KeyFlag -> Int) -> KeyFlag -> KeyFlag -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing KeyFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag

instance FutureFlag KeyFlag where
  fromFFlag :: KeyFlag -> Int
fromFFlag KeyFlag
GroupKey = Int
0
  fromFFlag KeyFlag
AuthKey = Int
2
  fromFFlag KeyFlag
SplitKey = Int
3
  fromFFlag KeyFlag
EncryptStorageKey = Int
4
  fromFFlag KeyFlag
EncryptCommunicationsKey = Int
5
  fromFFlag KeyFlag
SignDataKey = Int
6
  fromFFlag KeyFlag
CertifyKeysKey = Int
7
  fromFFlag (KFOther Int
i) = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i
  toFFlag :: Int -> KeyFlag
toFFlag Int
0 = KeyFlag
GroupKey
  toFFlag Int
2 = KeyFlag
AuthKey
  toFFlag Int
3 = KeyFlag
SplitKey
  toFFlag Int
4 = KeyFlag
EncryptStorageKey
  toFFlag Int
5 = KeyFlag
EncryptCommunicationsKey
  toFFlag Int
6 = KeyFlag
SignDataKey
  toFFlag Int
7 = KeyFlag
CertifyKeysKey
  toFFlag Int
i = Int -> KeyFlag
KFOther (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)

instance Hashable KeyFlag

instance Pretty KeyFlag where
  pretty :: forall ann. KeyFlag -> Doc ann
pretty KeyFlag
GroupKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"group"
  pretty KeyFlag
AuthKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"auth"
  pretty KeyFlag
SplitKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"split"
  pretty KeyFlag
EncryptStorageKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"encrypt-storage"
  pretty KeyFlag
EncryptCommunicationsKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"encrypt-communications"
  pretty KeyFlag
SignDataKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"sign-data"
  pretty KeyFlag
CertifyKeysKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"certify-keys"
  pretty (KFOther Int
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown key flag type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
o

$(ATH.deriveJSON ATH.defaultOptions ''KeyFlag)

data RevocationCode
  = NoReason
  | KeySuperseded
  | KeyMaterialCompromised
  | KeyRetiredAndNoLongerUsed
  | UserIdInfoNoLongerValid
  | RCoOther Word8
  deriving (Typeable RevocationCode
Typeable RevocationCode =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> RevocationCode -> c RevocationCode)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c RevocationCode)
-> (RevocationCode -> Constr)
-> (RevocationCode -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c RevocationCode))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c RevocationCode))
-> ((forall b. Data b => b -> b)
    -> RevocationCode -> RevocationCode)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> RevocationCode -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> RevocationCode -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> RevocationCode -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> RevocationCode -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> RevocationCode -> m RevocationCode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RevocationCode -> m RevocationCode)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> RevocationCode -> m RevocationCode)
-> Data RevocationCode
RevocationCode -> Constr
RevocationCode -> DataType
(forall b. Data b => b -> b) -> RevocationCode -> RevocationCode
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) -> RevocationCode -> u
forall u. (forall d. Data d => d -> u) -> RevocationCode -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationCode -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationCode -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RevocationCode
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RevocationCode -> c RevocationCode
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RevocationCode)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RevocationCode)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RevocationCode -> c RevocationCode
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> RevocationCode -> c RevocationCode
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RevocationCode
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c RevocationCode
$ctoConstr :: RevocationCode -> Constr
toConstr :: RevocationCode -> Constr
$cdataTypeOf :: RevocationCode -> DataType
dataTypeOf :: RevocationCode -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RevocationCode)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c RevocationCode)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RevocationCode)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c RevocationCode)
$cgmapT :: (forall b. Data b => b -> b) -> RevocationCode -> RevocationCode
gmapT :: (forall b. Data b => b -> b) -> RevocationCode -> RevocationCode
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationCode -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationCode -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationCode -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> RevocationCode -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> RevocationCode -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> RevocationCode -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RevocationCode -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> RevocationCode -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> RevocationCode -> m RevocationCode
Data, (forall x. RevocationCode -> Rep RevocationCode x)
-> (forall x. Rep RevocationCode x -> RevocationCode)
-> Generic RevocationCode
forall x. Rep RevocationCode x -> RevocationCode
forall x. RevocationCode -> Rep RevocationCode x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. RevocationCode -> Rep RevocationCode x
from :: forall x. RevocationCode -> Rep RevocationCode x
$cto :: forall x. Rep RevocationCode x -> RevocationCode
to :: forall x. Rep RevocationCode x -> RevocationCode
Generic, Int -> RevocationCode -> ShowS
[RevocationCode] -> ShowS
RevocationCode -> String
(Int -> RevocationCode -> ShowS)
-> (RevocationCode -> String)
-> ([RevocationCode] -> ShowS)
-> Show RevocationCode
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> RevocationCode -> ShowS
showsPrec :: Int -> RevocationCode -> ShowS
$cshow :: RevocationCode -> String
show :: RevocationCode -> String
$cshowList :: [RevocationCode] -> ShowS
showList :: [RevocationCode] -> ShowS
Show, Typeable)

instance Eq RevocationCode where
  == :: RevocationCode -> RevocationCode -> Bool
(==) RevocationCode
a RevocationCode
b = RevocationCode -> Word8
forall a. FutureVal a => a -> Word8
fromFVal RevocationCode
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== RevocationCode -> Word8
forall a. FutureVal a => a -> Word8
fromFVal RevocationCode
b

instance Ord RevocationCode where
  compare :: RevocationCode -> RevocationCode -> Ordering
compare = (RevocationCode -> Word8)
-> RevocationCode -> RevocationCode -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing RevocationCode -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal RevocationCode where
  fromFVal :: RevocationCode -> Word8
fromFVal RevocationCode
NoReason = Word8
0
  fromFVal RevocationCode
KeySuperseded = Word8
1
  fromFVal RevocationCode
KeyMaterialCompromised = Word8
2
  fromFVal RevocationCode
KeyRetiredAndNoLongerUsed = Word8
3
  fromFVal RevocationCode
UserIdInfoNoLongerValid = Word8
32
  fromFVal (RCoOther Word8
o) = Word8
o
  toFVal :: Word8 -> RevocationCode
toFVal Word8
0 = RevocationCode
NoReason
  toFVal Word8
1 = RevocationCode
KeySuperseded
  toFVal Word8
2 = RevocationCode
KeyMaterialCompromised
  toFVal Word8
3 = RevocationCode
KeyRetiredAndNoLongerUsed
  toFVal Word8
32 = RevocationCode
UserIdInfoNoLongerValid
  toFVal Word8
o = Word8 -> RevocationCode
RCoOther Word8
o

instance Hashable RevocationCode

instance Pretty RevocationCode where
  pretty :: forall ann. RevocationCode -> Doc ann
pretty RevocationCode
NoReason = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"no reason"
  pretty RevocationCode
KeySuperseded = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"key superseded"
  pretty RevocationCode
KeyMaterialCompromised = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"key material compromised"
  pretty RevocationCode
KeyRetiredAndNoLongerUsed = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"key retired and no longer used"
  pretty RevocationCode
UserIdInfoNoLongerValid = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"user-ID info no longer valid"
  pretty (RCoOther Word8
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown revocation code" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
o

$(ATH.deriveJSON ATH.defaultOptions ''RevocationCode)

data FeatureFlag
  = FeatureSEIPDv1
  | FeatureSEIPDv2
  | FeatureOther Int
  deriving (Typeable FeatureFlag
Typeable FeatureFlag =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> FeatureFlag -> c FeatureFlag)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c FeatureFlag)
-> (FeatureFlag -> Constr)
-> (FeatureFlag -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c FeatureFlag))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c FeatureFlag))
-> ((forall b. Data b => b -> b) -> FeatureFlag -> FeatureFlag)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r)
-> (forall u. (forall d. Data d => d -> u) -> FeatureFlag -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> FeatureFlag -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag)
-> Data FeatureFlag
FeatureFlag -> Constr
FeatureFlag -> DataType
(forall b. Data b => b -> b) -> FeatureFlag -> FeatureFlag
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) -> FeatureFlag -> u
forall u. (forall d. Data d => d -> u) -> FeatureFlag -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FeatureFlag
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FeatureFlag -> c FeatureFlag
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FeatureFlag)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FeatureFlag)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FeatureFlag -> c FeatureFlag
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> FeatureFlag -> c FeatureFlag
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FeatureFlag
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c FeatureFlag
$ctoConstr :: FeatureFlag -> Constr
toConstr :: FeatureFlag -> Constr
$cdataTypeOf :: FeatureFlag -> DataType
dataTypeOf :: FeatureFlag -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FeatureFlag)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c FeatureFlag)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FeatureFlag)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c FeatureFlag)
$cgmapT :: (forall b. Data b => b -> b) -> FeatureFlag -> FeatureFlag
gmapT :: (forall b. Data b => b -> b) -> FeatureFlag -> FeatureFlag
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> FeatureFlag -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> FeatureFlag -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> FeatureFlag -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FeatureFlag -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> FeatureFlag -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> FeatureFlag -> m FeatureFlag
Data, (forall x. FeatureFlag -> Rep FeatureFlag x)
-> (forall x. Rep FeatureFlag x -> FeatureFlag)
-> Generic FeatureFlag
forall x. Rep FeatureFlag x -> FeatureFlag
forall x. FeatureFlag -> Rep FeatureFlag x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. FeatureFlag -> Rep FeatureFlag x
from :: forall x. FeatureFlag -> Rep FeatureFlag x
$cto :: forall x. Rep FeatureFlag x -> FeatureFlag
to :: forall x. Rep FeatureFlag x -> FeatureFlag
Generic, Int -> FeatureFlag -> ShowS
[FeatureFlag] -> ShowS
FeatureFlag -> String
(Int -> FeatureFlag -> ShowS)
-> (FeatureFlag -> String)
-> ([FeatureFlag] -> ShowS)
-> Show FeatureFlag
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> FeatureFlag -> ShowS
showsPrec :: Int -> FeatureFlag -> ShowS
$cshow :: FeatureFlag -> String
show :: FeatureFlag -> String
$cshowList :: [FeatureFlag] -> ShowS
showList :: [FeatureFlag] -> ShowS
Show, Typeable)

instance Eq FeatureFlag where
  == :: FeatureFlag -> FeatureFlag -> Bool
(==) FeatureFlag
a FeatureFlag
b = FeatureFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag FeatureFlag
a Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== FeatureFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag FeatureFlag
b

instance Ord FeatureFlag where
  compare :: FeatureFlag -> FeatureFlag -> Ordering
compare = (FeatureFlag -> Int) -> FeatureFlag -> FeatureFlag -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing FeatureFlag -> Int
forall a. FutureFlag a => a -> Int
fromFFlag

instance FutureFlag FeatureFlag where
  fromFFlag :: FeatureFlag -> Int
fromFFlag FeatureFlag
FeatureSEIPDv1 = Int
7
  fromFFlag FeatureFlag
FeatureSEIPDv2 = Int
4
  fromFFlag (FeatureOther Int
i) = Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i
  toFFlag :: Int -> FeatureFlag
toFFlag Int
7 = FeatureFlag
FeatureSEIPDv1
  toFFlag Int
4 = FeatureFlag
FeatureSEIPDv2
  toFFlag Int
i = Int -> FeatureFlag
FeatureOther (Int -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Int
i)

instance Hashable FeatureFlag

instance Pretty FeatureFlag where
  pretty :: forall ann. FeatureFlag -> Doc ann
pretty FeatureFlag
FeatureSEIPDv1 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"seipd-v1"
  pretty FeatureFlag
FeatureSEIPDv2 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"seipd-v2"
  pretty (FeatureOther Int
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown feature flag type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Int
o

$(ATH.deriveJSON ATH.defaultOptions ''FeatureFlag)

newtype URL =
  URL
    { URL -> URI
unURL :: URI
    }
  deriving (Typeable URL
Typeable URL =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> URL -> c URL)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c URL)
-> (URL -> Constr)
-> (URL -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c URL))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL))
-> ((forall b. Data b => b -> b) -> URL -> URL)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r)
-> (forall u. (forall d. Data d => d -> u) -> URL -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> URL -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> URL -> m URL)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> URL -> m URL)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> URL -> m URL)
-> Data URL
URL -> Constr
URL -> DataType
(forall b. Data b => b -> b) -> URL -> URL
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) -> URL -> u
forall u. (forall d. Data d => d -> u) -> URL -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> URL -> m URL
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> URL -> m URL
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c URL
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> URL -> c URL
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c URL)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> URL -> c URL
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> URL -> c URL
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c URL
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c URL
$ctoConstr :: URL -> Constr
toConstr :: URL -> Constr
$cdataTypeOf :: URL -> DataType
dataTypeOf :: URL -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c URL)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c URL)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c URL)
$cgmapT :: (forall b. Data b => b -> b) -> URL -> URL
gmapT :: (forall b. Data b => b -> b) -> URL -> URL
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> URL -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> URL -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> URL -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> URL -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> URL -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> URL -> m URL
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> URL -> m URL
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> URL -> m URL
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> URL -> m URL
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> URL -> m URL
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> URL -> m URL
Data, URL -> URL -> Bool
(URL -> URL -> Bool) -> (URL -> URL -> Bool) -> Eq URL
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: URL -> URL -> Bool
== :: URL -> URL -> Bool
$c/= :: URL -> URL -> Bool
/= :: URL -> URL -> Bool
Eq, (forall x. URL -> Rep URL x)
-> (forall x. Rep URL x -> URL) -> Generic URL
forall x. Rep URL x -> URL
forall x. URL -> Rep URL x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. URL -> Rep URL x
from :: forall x. URL -> Rep URL x
$cto :: forall x. Rep URL x -> URL
to :: forall x. Rep URL x -> URL
Generic, Eq URL
Eq URL =>
(URL -> URL -> Ordering)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> Bool)
-> (URL -> URL -> URL)
-> (URL -> URL -> URL)
-> Ord URL
URL -> URL -> Bool
URL -> URL -> Ordering
URL -> URL -> URL
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: URL -> URL -> Ordering
compare :: URL -> URL -> Ordering
$c< :: URL -> URL -> Bool
< :: URL -> URL -> Bool
$c<= :: URL -> URL -> Bool
<= :: URL -> URL -> Bool
$c> :: URL -> URL -> Bool
> :: URL -> URL -> Bool
$c>= :: URL -> URL -> Bool
>= :: URL -> URL -> Bool
$cmax :: URL -> URL -> URL
max :: URL -> URL -> URL
$cmin :: URL -> URL -> URL
min :: URL -> URL -> URL
Ord, Int -> URL -> ShowS
[URL] -> ShowS
URL -> String
(Int -> URL -> ShowS)
-> (URL -> String) -> ([URL] -> ShowS) -> Show URL
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> URL -> ShowS
showsPrec :: Int -> URL -> ShowS
$cshow :: URL -> String
show :: URL -> String
$cshowList :: [URL] -> ShowS
showList :: [URL] -> ShowS
Show, Typeable)

instance Wrapped URL

instance Hashable URL where
  hashWithSalt :: Int -> URL -> Int
hashWithSalt Int
salt (URL (URI String
s Maybe URIAuth
a String
p String
q String
f)) =
    Int
salt Int -> String -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` String
s Int -> String -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` Maybe URIAuth -> String
forall a. Show a => a -> String
show Maybe URIAuth
a Int -> String -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt` String
p Int -> String -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt`
    String
q Int -> String -> Int
forall a. Hashable a => Int -> a -> Int
`hashWithSalt`
    String
f

instance Pretty URL where
  pretty :: forall ann. URL -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> (URL -> String) -> URL -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\URI
uri -> ShowS -> URI -> ShowS
uriToString ShowS
forall a. a -> a
id URI
uri String
"") (URI -> String) -> (URL -> URI) -> URL -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped URL -> URL) -> URL -> Unwrapped URL
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op Unwrapped URL -> URL
URI -> URL
URL

instance A.ToJSON URL where
  toJSON :: URL -> Value
toJSON URL
u = [Pair] -> Value
object [String -> Key
key String
"uri" Key -> String -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (\URI
uri -> ShowS -> URI -> ShowS
uriToString ShowS
forall a. a -> a
id URI
uri String
"") ((Unwrapped URL -> URL) -> URL -> Unwrapped URL
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op Unwrapped URL -> URL
URI -> URL
URL URL
u)]

instance A.FromJSON URL where
  parseJSON :: Value -> Parser URL
parseJSON (A.Object Object
v) =
    URI -> URL
URL (URI -> URL) -> (String -> URI) -> String -> URL
forall b c a. (b -> c) -> (a -> b) -> a -> c
. URI -> Maybe URI -> URI
forall a. a -> Maybe a -> a
fromMaybe URI
nullURI (Maybe URI -> URI) -> (String -> Maybe URI) -> String -> URI
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Maybe URI
parseURI (String -> URL) -> Parser String -> Parser URL
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser String
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"uri"
  parseJSON Value
_ = Parser URL
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

data SigType
  = BinarySig
  | CanonicalTextSig
  | StandaloneSig
  | GenericCert
  | PersonaCert
  | CasualCert
  | PositiveCert
  | SubkeyBindingSig
  | PrimaryKeyBindingSig
  | SignatureDirectlyOnAKey
  | KeyRevocationSig
  | SubkeyRevocationSig
  | CertRevocationSig
  | TimestampSig
  | ThirdPartyConfirmationSig
  | OtherSig Word8
  deriving (Typeable SigType
Typeable SigType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SigType -> c SigType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SigType)
-> (SigType -> Constr)
-> (SigType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SigType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigType))
-> ((forall b. Data b => b -> b) -> SigType -> SigType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SigType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SigType -> r)
-> (forall u. (forall d. Data d => d -> u) -> SigType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> SigType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SigType -> m SigType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SigType -> m SigType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SigType -> m SigType)
-> Data SigType
SigType -> Constr
SigType -> DataType
(forall b. Data b => b -> b) -> SigType -> SigType
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) -> SigType -> u
forall u. (forall d. Data d => d -> u) -> SigType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigType -> c SigType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigType -> c SigType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigType -> c SigType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigType
$ctoConstr :: SigType -> Constr
toConstr :: SigType -> Constr
$cdataTypeOf :: SigType -> DataType
dataTypeOf :: SigType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SigType)
$cgmapT :: (forall b. Data b => b -> b) -> SigType -> SigType
gmapT :: (forall b. Data b => b -> b) -> SigType -> SigType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SigType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SigType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SigType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SigType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigType -> m SigType
Data, (forall x. SigType -> Rep SigType x)
-> (forall x. Rep SigType x -> SigType) -> Generic SigType
forall x. Rep SigType x -> SigType
forall x. SigType -> Rep SigType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SigType -> Rep SigType x
from :: forall x. SigType -> Rep SigType x
$cto :: forall x. Rep SigType x -> SigType
to :: forall x. Rep SigType x -> SigType
Generic, Int -> SigType -> ShowS
[SigType] -> ShowS
SigType -> String
(Int -> SigType -> ShowS)
-> (SigType -> String) -> ([SigType] -> ShowS) -> Show SigType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SigType -> ShowS
showsPrec :: Int -> SigType -> ShowS
$cshow :: SigType -> String
show :: SigType -> String
$cshowList :: [SigType] -> ShowS
showList :: [SigType] -> ShowS
Show, Typeable)

instance Eq SigType where
  == :: SigType -> SigType -> Bool
(==) SigType
a SigType
b = SigType -> Word8
forall a. FutureVal a => a -> Word8
fromFVal SigType
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== SigType -> Word8
forall a. FutureVal a => a -> Word8
fromFVal SigType
b

instance Ord SigType where
  compare :: SigType -> SigType -> Ordering
compare = (SigType -> Word8) -> SigType -> SigType -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing SigType -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal SigType where
  fromFVal :: SigType -> Word8
fromFVal SigType
BinarySig = Word8
0x00
  fromFVal SigType
CanonicalTextSig = Word8
0x01
  fromFVal SigType
StandaloneSig = Word8
0x02
  fromFVal SigType
GenericCert = Word8
0x10
  fromFVal SigType
PersonaCert = Word8
0x11
  fromFVal SigType
CasualCert = Word8
0x12
  fromFVal SigType
PositiveCert = Word8
0x13
  fromFVal SigType
SubkeyBindingSig = Word8
0x18
  fromFVal SigType
PrimaryKeyBindingSig = Word8
0x19
  fromFVal SigType
SignatureDirectlyOnAKey = Word8
0x1F
  fromFVal SigType
KeyRevocationSig = Word8
0x20
  fromFVal SigType
SubkeyRevocationSig = Word8
0x28
  fromFVal SigType
CertRevocationSig = Word8
0x30
  fromFVal SigType
TimestampSig = Word8
0x40
  fromFVal SigType
ThirdPartyConfirmationSig = Word8
0x50
  fromFVal (OtherSig Word8
o) = Word8
o
  toFVal :: Word8 -> SigType
toFVal Word8
0x00 = SigType
BinarySig
  toFVal Word8
0x01 = SigType
CanonicalTextSig
  toFVal Word8
0x02 = SigType
StandaloneSig
  toFVal Word8
0x10 = SigType
GenericCert
  toFVal Word8
0x11 = SigType
PersonaCert
  toFVal Word8
0x12 = SigType
CasualCert
  toFVal Word8
0x13 = SigType
PositiveCert
  toFVal Word8
0x18 = SigType
SubkeyBindingSig
  toFVal Word8
0x19 = SigType
PrimaryKeyBindingSig
  toFVal Word8
0x1F = SigType
SignatureDirectlyOnAKey
  toFVal Word8
0x20 = SigType
KeyRevocationSig
  toFVal Word8
0x28 = SigType
SubkeyRevocationSig
  toFVal Word8
0x30 = SigType
CertRevocationSig
  toFVal Word8
0x40 = SigType
TimestampSig
  toFVal Word8
0x50 = SigType
ThirdPartyConfirmationSig
  toFVal Word8
o = Word8 -> SigType
OtherSig Word8
o

instance Hashable SigType

instance Pretty SigType where
  pretty :: forall ann. SigType -> Doc ann
pretty SigType
BinarySig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"binary"
  pretty SigType
CanonicalTextSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"canonical-pretty"
  pretty SigType
StandaloneSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"standalone"
  pretty SigType
GenericCert = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"generic"
  pretty SigType
PersonaCert = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"persona"
  pretty SigType
CasualCert = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"casual"
  pretty SigType
PositiveCert = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"positive"
  pretty SigType
SubkeyBindingSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"subkey-binding"
  pretty SigType
PrimaryKeyBindingSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"primary-key-binding"
  pretty SigType
SignatureDirectlyOnAKey = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"signature directly on a key"
  pretty SigType
KeyRevocationSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"key-revocation"
  pretty SigType
SubkeyRevocationSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"subkey-revocation"
  pretty SigType
CertRevocationSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"cert-revocation"
  pretty SigType
TimestampSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"timestamp"
  pretty SigType
ThirdPartyConfirmationSig = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"third-party-confirmation"
  pretty (OtherSig Word8
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown signature type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
o

$(ATH.deriveJSON ATH.defaultOptions ''SigType)

newtype MPI =
  MPI
    { MPI -> Integer
unMPI :: Integer
    }
  deriving (Typeable MPI
Typeable MPI =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> MPI -> c MPI)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c MPI)
-> (MPI -> Constr)
-> (MPI -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c MPI))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MPI))
-> ((forall b. Data b => b -> b) -> MPI -> MPI)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r)
-> (forall u. (forall d. Data d => d -> u) -> MPI -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> MPI -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> MPI -> m MPI)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MPI -> m MPI)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> MPI -> m MPI)
-> Data MPI
MPI -> Constr
MPI -> DataType
(forall b. Data b => b -> b) -> MPI -> MPI
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) -> MPI -> u
forall u. (forall d. Data d => d -> u) -> MPI -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MPI
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MPI -> c MPI
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MPI)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MPI)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MPI -> c MPI
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> MPI -> c MPI
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MPI
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c MPI
$ctoConstr :: MPI -> Constr
toConstr :: MPI -> Constr
$cdataTypeOf :: MPI -> DataType
dataTypeOf :: MPI -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MPI)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c MPI)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MPI)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c MPI)
$cgmapT :: (forall b. Data b => b -> b) -> MPI -> MPI
gmapT :: (forall b. Data b => b -> b) -> MPI -> MPI
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> MPI -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> MPI -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> MPI -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MPI -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> MPI -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> MPI -> m MPI
Data, MPI -> MPI -> Bool
(MPI -> MPI -> Bool) -> (MPI -> MPI -> Bool) -> Eq MPI
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: MPI -> MPI -> Bool
== :: MPI -> MPI -> Bool
$c/= :: MPI -> MPI -> Bool
/= :: MPI -> MPI -> Bool
Eq, (forall x. MPI -> Rep MPI x)
-> (forall x. Rep MPI x -> MPI) -> Generic MPI
forall x. Rep MPI x -> MPI
forall x. MPI -> Rep MPI x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. MPI -> Rep MPI x
from :: forall x. MPI -> Rep MPI x
$cto :: forall x. Rep MPI x -> MPI
to :: forall x. Rep MPI x -> MPI
Generic, Int -> MPI -> ShowS
[MPI] -> ShowS
MPI -> String
(Int -> MPI -> ShowS)
-> (MPI -> String) -> ([MPI] -> ShowS) -> Show MPI
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> MPI -> ShowS
showsPrec :: Int -> MPI -> ShowS
$cshow :: MPI -> String
show :: MPI -> String
$cshowList :: [MPI] -> ShowS
showList :: [MPI] -> ShowS
Show, Typeable)

instance Wrapped MPI

instance Ord MPI where
  compare :: MPI -> MPI -> Ordering
compare (MPI Integer
a) (MPI Integer
b) = Integer -> Integer -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Integer
a Integer
b

instance Hashable MPI

instance Pretty MPI where
  pretty :: forall ann. MPI -> Doc ann
pretty = Integer -> Doc ann
forall ann. Integer -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Integer -> Doc ann) -> (MPI -> Integer) -> MPI -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped MPI -> MPI) -> MPI -> Unwrapped MPI
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op Integer -> MPI
Unwrapped MPI -> MPI
MPI

$(ATH.deriveJSON ATH.defaultOptions ''MPI)

newtype SignatureSalt =
  SignatureSalt
    { SignatureSalt -> ByteString
unSignatureSalt :: ByteString
    }
  deriving (Typeable SignatureSalt
Typeable SignatureSalt =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SignatureSalt -> c SignatureSalt)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SignatureSalt)
-> (SignatureSalt -> Constr)
-> (SignatureSalt -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SignatureSalt))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SignatureSalt))
-> ((forall b. Data b => b -> b) -> SignatureSalt -> SignatureSalt)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r)
-> (forall u. (forall d. Data d => d -> u) -> SignatureSalt -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SignatureSalt -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt)
-> Data SignatureSalt
SignatureSalt -> Constr
SignatureSalt -> DataType
(forall b. Data b => b -> b) -> SignatureSalt -> SignatureSalt
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) -> SignatureSalt -> u
forall u. (forall d. Data d => d -> u) -> SignatureSalt -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignatureSalt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignatureSalt -> c SignatureSalt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignatureSalt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignatureSalt)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignatureSalt -> c SignatureSalt
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignatureSalt -> c SignatureSalt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignatureSalt
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignatureSalt
$ctoConstr :: SignatureSalt -> Constr
toConstr :: SignatureSalt -> Constr
$cdataTypeOf :: SignatureSalt -> DataType
dataTypeOf :: SignatureSalt -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignatureSalt)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignatureSalt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignatureSalt)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignatureSalt)
$cgmapT :: (forall b. Data b => b -> b) -> SignatureSalt -> SignatureSalt
gmapT :: (forall b. Data b => b -> b) -> SignatureSalt -> SignatureSalt
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignatureSalt -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SignatureSalt -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SignatureSalt -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SignatureSalt -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SignatureSalt -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SignatureSalt -> m SignatureSalt
Data, SignatureSalt -> SignatureSalt -> Bool
(SignatureSalt -> SignatureSalt -> Bool)
-> (SignatureSalt -> SignatureSalt -> Bool) -> Eq SignatureSalt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SignatureSalt -> SignatureSalt -> Bool
== :: SignatureSalt -> SignatureSalt -> Bool
$c/= :: SignatureSalt -> SignatureSalt -> Bool
/= :: SignatureSalt -> SignatureSalt -> Bool
Eq, (forall x. SignatureSalt -> Rep SignatureSalt x)
-> (forall x. Rep SignatureSalt x -> SignatureSalt)
-> Generic SignatureSalt
forall x. Rep SignatureSalt x -> SignatureSalt
forall x. SignatureSalt -> Rep SignatureSalt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SignatureSalt -> Rep SignatureSalt x
from :: forall x. SignatureSalt -> Rep SignatureSalt x
$cto :: forall x. Rep SignatureSalt x -> SignatureSalt
to :: forall x. Rep SignatureSalt x -> SignatureSalt
Generic, Int -> SignatureSalt -> ShowS
[SignatureSalt] -> ShowS
SignatureSalt -> String
(Int -> SignatureSalt -> ShowS)
-> (SignatureSalt -> String)
-> ([SignatureSalt] -> ShowS)
-> Show SignatureSalt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SignatureSalt -> ShowS
showsPrec :: Int -> SignatureSalt -> ShowS
$cshow :: SignatureSalt -> String
show :: SignatureSalt -> String
$cshowList :: [SignatureSalt] -> ShowS
showList :: [SignatureSalt] -> ShowS
Show, Typeable)

instance Ord SignatureSalt where
  compare :: SignatureSalt -> SignatureSalt -> Ordering
compare (SignatureSalt ByteString
a) (SignatureSalt ByteString
b) = ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
a ByteString
b

instance Hashable SignatureSalt

instance Pretty SignatureSalt where
  pretty :: forall ann. SignatureSalt -> Doc ann
pretty (SignatureSalt ByteString
bs) = ByteString -> Doc ann
forall ann. ByteString -> Doc ann
prettyLBS ByteString
bs

instance A.ToJSON SignatureSalt where
  toJSON :: SignatureSalt -> Value
toJSON (SignatureSalt ByteString
bs) = [Word8] -> Value
forall a. ToJSON a => a -> Value
A.toJSON (ByteString -> [Word8]
BL.unpack ByteString
bs)

data SignaturePayloadVersion
  = SigPayloadV3
  | SigPayloadV4
  | SigPayloadV6
  | SigPayloadVOther
  deriving (Typeable SignaturePayloadVersion
Typeable SignaturePayloadVersion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SignaturePayloadVersion
 -> c SignaturePayloadVersion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SignaturePayloadVersion)
-> (SignaturePayloadVersion -> Constr)
-> (SignaturePayloadVersion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SignaturePayloadVersion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SignaturePayloadVersion))
-> ((forall b. Data b => b -> b)
    -> SignaturePayloadVersion -> SignaturePayloadVersion)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SignaturePayloadVersion
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SignaturePayloadVersion
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SignaturePayloadVersion -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> SignaturePayloadVersion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SignaturePayloadVersion -> m SignaturePayloadVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SignaturePayloadVersion -> m SignaturePayloadVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SignaturePayloadVersion -> m SignaturePayloadVersion)
-> Data SignaturePayloadVersion
SignaturePayloadVersion -> Constr
SignaturePayloadVersion -> DataType
(forall b. Data b => b -> b)
-> SignaturePayloadVersion -> SignaturePayloadVersion
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) -> SignaturePayloadVersion -> u
forall u.
(forall d. Data d => d -> u) -> SignaturePayloadVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SignaturePayloadVersion
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SignaturePayloadVersion
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignaturePayloadVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignaturePayloadVersion
-> c SignaturePayloadVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignaturePayloadVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignaturePayloadVersion)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignaturePayloadVersion
-> c SignaturePayloadVersion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SignaturePayloadVersion
-> c SignaturePayloadVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignaturePayloadVersion
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignaturePayloadVersion
$ctoConstr :: SignaturePayloadVersion -> Constr
toConstr :: SignaturePayloadVersion -> Constr
$cdataTypeOf :: SignaturePayloadVersion -> DataType
dataTypeOf :: SignaturePayloadVersion -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignaturePayloadVersion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignaturePayloadVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignaturePayloadVersion)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignaturePayloadVersion)
$cgmapT :: (forall b. Data b => b -> b)
-> SignaturePayloadVersion -> SignaturePayloadVersion
gmapT :: (forall b. Data b => b -> b)
-> SignaturePayloadVersion -> SignaturePayloadVersion
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SignaturePayloadVersion
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SignaturePayloadVersion
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SignaturePayloadVersion
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SignaturePayloadVersion
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> SignaturePayloadVersion -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> SignaturePayloadVersion -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SignaturePayloadVersion -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SignaturePayloadVersion -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayloadVersion -> m SignaturePayloadVersion
Data, SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
(SignaturePayloadVersion -> SignaturePayloadVersion -> Bool)
-> (SignaturePayloadVersion -> SignaturePayloadVersion -> Bool)
-> Eq SignaturePayloadVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
== :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
$c/= :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
/= :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
Eq, (forall x.
 SignaturePayloadVersion -> Rep SignaturePayloadVersion x)
-> (forall x.
    Rep SignaturePayloadVersion x -> SignaturePayloadVersion)
-> Generic SignaturePayloadVersion
forall x. Rep SignaturePayloadVersion x -> SignaturePayloadVersion
forall x. SignaturePayloadVersion -> Rep SignaturePayloadVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SignaturePayloadVersion -> Rep SignaturePayloadVersion x
from :: forall x. SignaturePayloadVersion -> Rep SignaturePayloadVersion x
$cto :: forall x. Rep SignaturePayloadVersion x -> SignaturePayloadVersion
to :: forall x. Rep SignaturePayloadVersion x -> SignaturePayloadVersion
Generic, Eq SignaturePayloadVersion
Eq SignaturePayloadVersion =>
(SignaturePayloadVersion -> SignaturePayloadVersion -> Ordering)
-> (SignaturePayloadVersion -> SignaturePayloadVersion -> Bool)
-> (SignaturePayloadVersion -> SignaturePayloadVersion -> Bool)
-> (SignaturePayloadVersion -> SignaturePayloadVersion -> Bool)
-> (SignaturePayloadVersion -> SignaturePayloadVersion -> Bool)
-> (SignaturePayloadVersion
    -> SignaturePayloadVersion -> SignaturePayloadVersion)
-> (SignaturePayloadVersion
    -> SignaturePayloadVersion -> SignaturePayloadVersion)
-> Ord SignaturePayloadVersion
SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
SignaturePayloadVersion -> SignaturePayloadVersion -> Ordering
SignaturePayloadVersion
-> SignaturePayloadVersion -> SignaturePayloadVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SignaturePayloadVersion -> SignaturePayloadVersion -> Ordering
compare :: SignaturePayloadVersion -> SignaturePayloadVersion -> Ordering
$c< :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
< :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
$c<= :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
<= :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
$c> :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
> :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
$c>= :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
>= :: SignaturePayloadVersion -> SignaturePayloadVersion -> Bool
$cmax :: SignaturePayloadVersion
-> SignaturePayloadVersion -> SignaturePayloadVersion
max :: SignaturePayloadVersion
-> SignaturePayloadVersion -> SignaturePayloadVersion
$cmin :: SignaturePayloadVersion
-> SignaturePayloadVersion -> SignaturePayloadVersion
min :: SignaturePayloadVersion
-> SignaturePayloadVersion -> SignaturePayloadVersion
Ord, Int -> SignaturePayloadVersion -> ShowS
[SignaturePayloadVersion] -> ShowS
SignaturePayloadVersion -> String
(Int -> SignaturePayloadVersion -> ShowS)
-> (SignaturePayloadVersion -> String)
-> ([SignaturePayloadVersion] -> ShowS)
-> Show SignaturePayloadVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SignaturePayloadVersion -> ShowS
showsPrec :: Int -> SignaturePayloadVersion -> ShowS
$cshow :: SignaturePayloadVersion -> String
show :: SignaturePayloadVersion -> String
$cshowList :: [SignaturePayloadVersion] -> ShowS
showList :: [SignaturePayloadVersion] -> ShowS
Show, Typeable)

instance Hashable SignaturePayloadVersion

data SignaturePayloadV (v :: SignaturePayloadVersion) where
  SigPayloadV3Data ::
       SigType
    -> ThirtyTwoBitTimeStamp
    -> EightOctetKeyId
    -> PubKeyAlgorithm
    -> HashAlgorithm
    -> Word16
    -> NonEmpty MPI
    -> SignaturePayloadV 'SigPayloadV3
  SigPayloadV4Data ::
       SigType
    -> PubKeyAlgorithm
    -> HashAlgorithm
    -> [SigSubPacket]
    -> [SigSubPacket]
    -> Word16
    -> NonEmpty MPI
    -> SignaturePayloadV 'SigPayloadV4
  SigPayloadV6Data ::
       SigType
    -> PubKeyAlgorithm
    -> HashAlgorithm
    -> SignatureSalt
    -> [SigSubPacket]
    -> [SigSubPacket]
    -> Word16
    -> NonEmpty MPI
    -> SignaturePayloadV 'SigPayloadV6
  SigPayloadOtherData ::
       Word8
    -> ByteString
    -> SignaturePayloadV 'SigPayloadVOther

deriving instance Eq (SignaturePayloadV v)
deriving instance Show (SignaturePayloadV v)

data SomeSignaturePayload where
  SomeSignaturePayload :: SignaturePayloadV v -> SomeSignaturePayload

toSignaturePayload :: SignaturePayloadV v -> SignaturePayload
toSignaturePayload :: forall (v :: SignaturePayloadVersion).
SignaturePayloadV v -> SignaturePayload
toSignaturePayload (SigPayloadV3Data SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis) =
  SigType
-> ThirtyTwoBitTimeStamp
-> EightOctetKeyId
-> PubKeyAlgorithm
-> HashAlgorithm
-> Word16
-> NonEmpty MPI
-> SignaturePayload
SigV3 SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis
toSignaturePayload (SigPayloadV4Data SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
  SigType
-> PubKeyAlgorithm
-> HashAlgorithm
-> [SigSubPacket]
-> [SigSubPacket]
-> Word16
-> NonEmpty MPI
-> SignaturePayload
SigV4 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis
toSignaturePayload (SigPayloadV6Data SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
  SigType
-> PubKeyAlgorithm
-> HashAlgorithm
-> SignatureSalt
-> [SigSubPacket]
-> [SigSubPacket]
-> Word16
-> NonEmpty MPI
-> SignaturePayload
SigV6 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis
toSignaturePayload (SigPayloadOtherData Word8
v ByteString
bs) =
  Word8 -> ByteString -> SignaturePayload
SigVOther Word8
v ByteString
bs

toSomeSignaturePayload :: SignaturePayload -> SomeSignaturePayload
toSomeSignaturePayload :: SignaturePayload -> SomeSignaturePayload
toSomeSignaturePayload (SigV3 SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis) =
  SignaturePayloadV 'SigPayloadV3 -> SomeSignaturePayload
forall (v :: SignaturePayloadVersion).
SignaturePayloadV v -> SomeSignaturePayload
SomeSignaturePayload (SigType
-> ThirtyTwoBitTimeStamp
-> EightOctetKeyId
-> PubKeyAlgorithm
-> HashAlgorithm
-> Word16
-> NonEmpty MPI
-> SignaturePayloadV 'SigPayloadV3
SigPayloadV3Data SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis)
toSomeSignaturePayload (SigV4 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
  SignaturePayloadV 'SigPayloadV4 -> SomeSignaturePayload
forall (v :: SignaturePayloadVersion).
SignaturePayloadV v -> SomeSignaturePayload
SomeSignaturePayload (SigType
-> PubKeyAlgorithm
-> HashAlgorithm
-> [SigSubPacket]
-> [SigSubPacket]
-> Word16
-> NonEmpty MPI
-> SignaturePayloadV 'SigPayloadV4
SigPayloadV4Data SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis)
toSomeSignaturePayload (SigV6 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
  SignaturePayloadV 'SigPayloadV6 -> SomeSignaturePayload
forall (v :: SignaturePayloadVersion).
SignaturePayloadV v -> SomeSignaturePayload
SomeSignaturePayload (SigType
-> PubKeyAlgorithm
-> HashAlgorithm
-> SignatureSalt
-> [SigSubPacket]
-> [SigSubPacket]
-> Word16
-> NonEmpty MPI
-> SignaturePayloadV 'SigPayloadV6
SigPayloadV6Data SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis)
toSomeSignaturePayload (SigVOther Word8
v ByteString
bs) =
  SignaturePayloadV 'SigPayloadVOther -> SomeSignaturePayload
forall (v :: SignaturePayloadVersion).
SignaturePayloadV v -> SomeSignaturePayload
SomeSignaturePayload (Word8 -> ByteString -> SignaturePayloadV 'SigPayloadVOther
SigPayloadOtherData Word8
v ByteString
bs)

signaturePayloadVersion :: SignaturePayload -> SignaturePayloadVersion
signaturePayloadVersion :: SignaturePayload -> SignaturePayloadVersion
signaturePayloadVersion (SigV3 SigType
_ ThirtyTwoBitTimeStamp
_ EightOctetKeyId
_ PubKeyAlgorithm
_ HashAlgorithm
_ Word16
_ NonEmpty MPI
_) = SignaturePayloadVersion
SigPayloadV3
signaturePayloadVersion (SigV4 SigType
_ PubKeyAlgorithm
_ HashAlgorithm
_ [SigSubPacket]
_ [SigSubPacket]
_ Word16
_ NonEmpty MPI
_) = SignaturePayloadVersion
SigPayloadV4
signaturePayloadVersion (SigV6 SigType
_ PubKeyAlgorithm
_ HashAlgorithm
_ SignatureSalt
_ [SigSubPacket]
_ [SigSubPacket]
_ Word16
_ NonEmpty MPI
_) = SignaturePayloadVersion
SigPayloadV6
signaturePayloadVersion (SigVOther Word8
_ ByteString
_) = SignaturePayloadVersion
SigPayloadVOther

asSignaturePayloadV3 :: SignaturePayload -> Either String (SignaturePayloadV 'SigPayloadV3)
asSignaturePayloadV3 :: SignaturePayload -> Either String (SignaturePayloadV 'SigPayloadV3)
asSignaturePayloadV3 (SigV3 SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis) =
  SignaturePayloadV 'SigPayloadV3
-> Either String (SignaturePayloadV 'SigPayloadV3)
forall a b. b -> Either a b
Right (SigType
-> ThirtyTwoBitTimeStamp
-> EightOctetKeyId
-> PubKeyAlgorithm
-> HashAlgorithm
-> Word16
-> NonEmpty MPI
-> SignaturePayloadV 'SigPayloadV3
SigPayloadV3Data SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis)
asSignaturePayloadV3 SignaturePayload
_ =
  String -> Either String (SignaturePayloadV 'SigPayloadV3)
forall a b. a -> Either a b
Left String
"Cannot coerce non-v3 SignaturePayload to SignaturePayloadV3"

asSignaturePayloadV4 :: SignaturePayload -> Either String (SignaturePayloadV 'SigPayloadV4)
asSignaturePayloadV4 :: SignaturePayload -> Either String (SignaturePayloadV 'SigPayloadV4)
asSignaturePayloadV4 (SigV4 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
  SignaturePayloadV 'SigPayloadV4
-> Either String (SignaturePayloadV 'SigPayloadV4)
forall a b. b -> Either a b
Right (SigType
-> PubKeyAlgorithm
-> HashAlgorithm
-> [SigSubPacket]
-> [SigSubPacket]
-> Word16
-> NonEmpty MPI
-> SignaturePayloadV 'SigPayloadV4
SigPayloadV4Data SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis)
asSignaturePayloadV4 SignaturePayload
_ =
  String -> Either String (SignaturePayloadV 'SigPayloadV4)
forall a b. a -> Either a b
Left String
"Cannot coerce non-v4 SignaturePayload to SignaturePayloadV4"

asSignaturePayloadV6 :: SignaturePayload -> Either String (SignaturePayloadV 'SigPayloadV6)
asSignaturePayloadV6 :: SignaturePayload -> Either String (SignaturePayloadV 'SigPayloadV6)
asSignaturePayloadV6 (SigV6 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
  SignaturePayloadV 'SigPayloadV6
-> Either String (SignaturePayloadV 'SigPayloadV6)
forall a b. b -> Either a b
Right (SigType
-> PubKeyAlgorithm
-> HashAlgorithm
-> SignatureSalt
-> [SigSubPacket]
-> [SigSubPacket]
-> Word16
-> NonEmpty MPI
-> SignaturePayloadV 'SigPayloadV6
SigPayloadV6Data SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis)
asSignaturePayloadV6 SignaturePayload
_ =
  String -> Either String (SignaturePayloadV 'SigPayloadV6)
forall a b. a -> Either a b
Left String
"Cannot coerce non-v6 SignaturePayload to SignaturePayloadV6"

asSignaturePayloadOther :: SignaturePayload -> Either String (SignaturePayloadV 'SigPayloadVOther)
asSignaturePayloadOther :: SignaturePayload
-> Either String (SignaturePayloadV 'SigPayloadVOther)
asSignaturePayloadOther (SigVOther Word8
v ByteString
bs) =
  SignaturePayloadV 'SigPayloadVOther
-> Either String (SignaturePayloadV 'SigPayloadVOther)
forall a b. b -> Either a b
Right (Word8 -> ByteString -> SignaturePayloadV 'SigPayloadVOther
SigPayloadOtherData Word8
v ByteString
bs)
asSignaturePayloadOther SignaturePayload
_ =
  String -> Either String (SignaturePayloadV 'SigPayloadVOther)
forall a b. a -> Either a b
Left String
"Cannot coerce known-version SignaturePayload to SignaturePayloadVOther"

data SignaturePayload
  = SigV3
      SigType
      ThirtyTwoBitTimeStamp
      EightOctetKeyId
      PubKeyAlgorithm
      HashAlgorithm
      Word16
      (NonEmpty MPI)
  | SigV4
      SigType
      PubKeyAlgorithm
      HashAlgorithm
      [SigSubPacket]
      [SigSubPacket]
      Word16
      (NonEmpty MPI)
  | SigV6
      SigType
      PubKeyAlgorithm
      HashAlgorithm
      SignatureSalt
      [SigSubPacket]
      [SigSubPacket]
      Word16
      (NonEmpty MPI)
  | SigVOther Word8 ByteString
  deriving (Typeable SignaturePayload
Typeable SignaturePayload =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SignaturePayload -> c SignaturePayload)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SignaturePayload)
-> (SignaturePayload -> Constr)
-> (SignaturePayload -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SignaturePayload))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SignaturePayload))
-> ((forall b. Data b => b -> b)
    -> SignaturePayload -> SignaturePayload)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SignaturePayload -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SignaturePayload -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SignaturePayload -> m SignaturePayload)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SignaturePayload -> m SignaturePayload)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SignaturePayload -> m SignaturePayload)
-> Data SignaturePayload
SignaturePayload -> Constr
SignaturePayload -> DataType
(forall b. Data b => b -> b)
-> SignaturePayload -> SignaturePayload
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) -> SignaturePayload -> u
forall u. (forall d. Data d => d -> u) -> SignaturePayload -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignaturePayload
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignaturePayload -> c SignaturePayload
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignaturePayload)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignaturePayload)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignaturePayload -> c SignaturePayload
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SignaturePayload -> c SignaturePayload
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignaturePayload
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SignaturePayload
$ctoConstr :: SignaturePayload -> Constr
toConstr :: SignaturePayload -> Constr
$cdataTypeOf :: SignaturePayload -> DataType
dataTypeOf :: SignaturePayload -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignaturePayload)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SignaturePayload)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignaturePayload)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SignaturePayload)
$cgmapT :: (forall b. Data b => b -> b)
-> SignaturePayload -> SignaturePayload
gmapT :: (forall b. Data b => b -> b)
-> SignaturePayload -> SignaturePayload
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SignaturePayload -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SignaturePayload -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SignaturePayload -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SignaturePayload -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SignaturePayload -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SignaturePayload -> m SignaturePayload
Data, SignaturePayload -> SignaturePayload -> Bool
(SignaturePayload -> SignaturePayload -> Bool)
-> (SignaturePayload -> SignaturePayload -> Bool)
-> Eq SignaturePayload
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SignaturePayload -> SignaturePayload -> Bool
== :: SignaturePayload -> SignaturePayload -> Bool
$c/= :: SignaturePayload -> SignaturePayload -> Bool
/= :: SignaturePayload -> SignaturePayload -> Bool
Eq, (forall x. SignaturePayload -> Rep SignaturePayload x)
-> (forall x. Rep SignaturePayload x -> SignaturePayload)
-> Generic SignaturePayload
forall x. Rep SignaturePayload x -> SignaturePayload
forall x. SignaturePayload -> Rep SignaturePayload x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SignaturePayload -> Rep SignaturePayload x
from :: forall x. SignaturePayload -> Rep SignaturePayload x
$cto :: forall x. Rep SignaturePayload x -> SignaturePayload
to :: forall x. Rep SignaturePayload x -> SignaturePayload
Generic, Int -> SignaturePayload -> ShowS
[SignaturePayload] -> ShowS
SignaturePayload -> String
(Int -> SignaturePayload -> ShowS)
-> (SignaturePayload -> String)
-> ([SignaturePayload] -> ShowS)
-> Show SignaturePayload
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SignaturePayload -> ShowS
showsPrec :: Int -> SignaturePayload -> ShowS
$cshow :: SignaturePayload -> String
show :: SignaturePayload -> String
$cshowList :: [SignaturePayload] -> ShowS
showList :: [SignaturePayload] -> ShowS
Show, Typeable)

instance Hashable SignaturePayload

instance Ord SignaturePayload where
  compare :: SignaturePayload -> SignaturePayload -> Ordering
compare (SigV3 SigType
st1 ThirtyTwoBitTimeStamp
ts1 EightOctetKeyId
eoki1 PubKeyAlgorithm
pka1 HashAlgorithm
ha1 Word16
w161 NonEmpty MPI
mpis1)
          (SigV3 SigType
st2 ThirtyTwoBitTimeStamp
ts2 EightOctetKeyId
eoki2 PubKeyAlgorithm
pka2 HashAlgorithm
ha2 Word16
w162 NonEmpty MPI
mpis2) =
    SigType -> SigType -> Ordering
forall a. Ord a => a -> a -> Ordering
compare SigType
st1 SigType
st2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> ThirtyTwoBitTimeStamp -> ThirtyTwoBitTimeStamp -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ThirtyTwoBitTimeStamp
ts1 ThirtyTwoBitTimeStamp
ts2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> EightOctetKeyId -> EightOctetKeyId -> Ordering
forall a. Ord a => a -> a -> Ordering
compare EightOctetKeyId
eoki1 EightOctetKeyId
eoki2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<>
    PubKeyAlgorithm -> PubKeyAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare PubKeyAlgorithm
pka1 PubKeyAlgorithm
pka2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> HashAlgorithm -> HashAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare HashAlgorithm
ha1 HashAlgorithm
ha2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Word16 -> Word16 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word16
w161 Word16
w162 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<>
    [MPI] -> [MPI] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis1) (NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis2)
  compare (SigV4 SigType
st1 PubKeyAlgorithm
pka1 HashAlgorithm
ha1 [SigSubPacket]
hsp1 [SigSubPacket]
usp1 Word16
w161 NonEmpty MPI
mpis1)
          (SigV4 SigType
st2 PubKeyAlgorithm
pka2 HashAlgorithm
ha2 [SigSubPacket]
hsp2 [SigSubPacket]
usp2 Word16
w162 NonEmpty MPI
mpis2) =
    SigType -> SigType -> Ordering
forall a. Ord a => a -> a -> Ordering
compare SigType
st1 SigType
st2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> PubKeyAlgorithm -> PubKeyAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare PubKeyAlgorithm
pka1 PubKeyAlgorithm
pka2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> HashAlgorithm -> HashAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare HashAlgorithm
ha1 HashAlgorithm
ha2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<>
    [SigSubPacket] -> [SigSubPacket] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare [SigSubPacket]
hsp1 [SigSubPacket]
hsp2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> [SigSubPacket] -> [SigSubPacket] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare [SigSubPacket]
usp1 [SigSubPacket]
usp2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Word16 -> Word16 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word16
w161 Word16
w162 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<>
    [MPI] -> [MPI] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis1) (NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis2)
  compare (SigV6 SigType
st1 PubKeyAlgorithm
pka1 HashAlgorithm
ha1 SignatureSalt
salt1 [SigSubPacket]
hsp1 [SigSubPacket]
usp1 Word16
w161 NonEmpty MPI
mpis1)
          (SigV6 SigType
st2 PubKeyAlgorithm
pka2 HashAlgorithm
ha2 SignatureSalt
salt2 [SigSubPacket]
hsp2 [SigSubPacket]
usp2 Word16
w162 NonEmpty MPI
mpis2) =
    SigType -> SigType -> Ordering
forall a. Ord a => a -> a -> Ordering
compare SigType
st1 SigType
st2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> PubKeyAlgorithm -> PubKeyAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare PubKeyAlgorithm
pka1 PubKeyAlgorithm
pka2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> HashAlgorithm -> HashAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare HashAlgorithm
ha1 HashAlgorithm
ha2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<>
    SignatureSalt -> SignatureSalt -> Ordering
forall a. Ord a => a -> a -> Ordering
compare SignatureSalt
salt1 SignatureSalt
salt2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> [SigSubPacket] -> [SigSubPacket] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare [SigSubPacket]
hsp1 [SigSubPacket]
hsp2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> [SigSubPacket] -> [SigSubPacket] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare [SigSubPacket]
usp1 [SigSubPacket]
usp2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<>
    Word16 -> Word16 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word16
w161 Word16
w162 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> [MPI] -> [MPI] -> Ordering
forall a. Ord a => a -> a -> Ordering
compare (NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis1) (NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis2)
  compare (SigVOther Word8
t1 ByteString
bs1) (SigVOther Word8
t2 ByteString
bs2) = Word8 -> Word8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word8
t1 Word8
t2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
bs1 ByteString
bs2
  compare SigV3 {} SigV4 {} = Ordering
LT
  compare SigV3 {} SigV6 {} = Ordering
LT
  compare SigV3 {} SigVOther {} = Ordering
LT
  compare SigV4 {} SigV3 {} = Ordering
GT
  compare SigV4 {} SigV6 {} = Ordering
LT
  compare SigV4 {} SigVOther {} = Ordering
LT
  compare SigV6 {} SigV3 {} = Ordering
GT
  compare SigV6 {} SigV4 {} = Ordering
GT
  compare SigV6 {} SigVOther {} = Ordering
LT
  compare SigVOther {} SigV3 {} = Ordering
GT
  compare SigVOther {} SigV4 {} = Ordering
GT
  compare SigVOther {} SigV6 {} = Ordering
GT

instance Pretty SignaturePayload where
  pretty :: forall ann. SignaturePayload -> Doc ann
pretty (SigV3 SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"signature v3" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
':' Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    SigType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. SigType -> Doc ann
pretty SigType
st Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    ThirtyTwoBitTimeStamp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ThirtyTwoBitTimeStamp -> Doc ann
pretty ThirtyTwoBitTimeStamp
ts Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    EightOctetKeyId -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. EightOctetKeyId -> Doc ann
pretty EightOctetKeyId
eoki Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    PubKeyAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. PubKeyAlgorithm -> Doc ann
pretty PubKeyAlgorithm
pka Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
ha Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word16 -> Doc ann
forall ann. Word16 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word16
w16 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ([MPI] -> Doc ann
forall ann. [MPI] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ([MPI] -> Doc ann)
-> (NonEmpty MPI -> [MPI]) -> NonEmpty MPI -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList) NonEmpty MPI
mpis
  pretty (SigV4 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"signature v4" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
':' Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    SigType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. SigType -> Doc ann
pretty SigType
st Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    PubKeyAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. PubKeyAlgorithm -> Doc ann
pretty PubKeyAlgorithm
pka Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
ha Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    [SigSubPacket] -> Doc ann
forall ann. [SigSubPacket] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [SigSubPacket]
hsps Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [SigSubPacket] -> Doc ann
forall ann. [SigSubPacket] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [SigSubPacket]
usps Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word16 -> Doc ann
forall ann. Word16 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word16
w16 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ([MPI] -> Doc ann
forall ann. [MPI] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ([MPI] -> Doc ann)
-> (NonEmpty MPI -> [MPI]) -> NonEmpty MPI -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList) NonEmpty MPI
mpis
  pretty (SigV6 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"signature v6" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
':' Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    SigType -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. SigType -> Doc ann
pretty SigType
st Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    PubKeyAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. PubKeyAlgorithm -> Doc ann
pretty PubKeyAlgorithm
pka Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
ha Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    SignatureSalt -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. SignatureSalt -> Doc ann
pretty SignatureSalt
salt Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    [SigSubPacket] -> Doc ann
forall ann. [SigSubPacket] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [SigSubPacket]
hsps Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [SigSubPacket] -> Doc ann
forall ann. [SigSubPacket] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [SigSubPacket]
usps Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word16 -> Doc ann
forall ann. Word16 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word16
w16 Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ([MPI] -> Doc ann
forall ann. [MPI] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty ([MPI] -> Doc ann)
-> (NonEmpty MPI -> [MPI]) -> NonEmpty MPI -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList) NonEmpty MPI
mpis
  pretty (SigVOther Word8
t ByteString
bs) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown signature v" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
t Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
':' Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    [Word8] -> Doc ann
forall ann. [Word8] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> [Word8]
BL.unpack ByteString
bs)

instance A.ToJSON SignaturePayload where
  toJSON :: SignaturePayload -> Value
toJSON (SigV3 SigType
st ThirtyTwoBitTimeStamp
ts EightOctetKeyId
eoki PubKeyAlgorithm
pka HashAlgorithm
ha Word16
w16 NonEmpty MPI
mpis) =
    (SigType, ThirtyTwoBitTimeStamp, EightOctetKeyId, PubKeyAlgorithm,
 HashAlgorithm, Word16, [MPI])
-> Value
forall a. ToJSON a => a -> Value
A.toJSON (SigType
st, ThirtyTwoBitTimeStamp
ts, EightOctetKeyId
eoki, PubKeyAlgorithm
pka, HashAlgorithm
ha, Word16
w16, NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis)
  toJSON (SigV4 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
    (SigType, PubKeyAlgorithm, HashAlgorithm, [SigSubPacket],
 [SigSubPacket], Word16, [MPI])
-> Value
forall a. ToJSON a => a -> Value
A.toJSON (SigType
st, PubKeyAlgorithm
pka, HashAlgorithm
ha, [SigSubPacket]
hsps, [SigSubPacket]
usps, Word16
w16, NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis)
  toJSON (SigV6 SigType
st PubKeyAlgorithm
pka HashAlgorithm
ha SignatureSalt
salt [SigSubPacket]
hsps [SigSubPacket]
usps Word16
w16 NonEmpty MPI
mpis) =
    (SigType, PubKeyAlgorithm, HashAlgorithm, SignatureSalt,
 [SigSubPacket], [SigSubPacket], Word16, [MPI])
-> Value
forall a. ToJSON a => a -> Value
A.toJSON (SigType
st, PubKeyAlgorithm
pka, HashAlgorithm
ha, SignatureSalt
salt, [SigSubPacket]
hsps, [SigSubPacket]
usps, Word16
w16, NonEmpty MPI -> [MPI]
forall a. NonEmpty a -> [a]
NE.toList NonEmpty MPI
mpis)
  toJSON (SigVOther Word8
t ByteString
bs) = (Word8, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Word8
t, ByteString -> [Word8]
BL.unpack ByteString
bs)

data IssuerFingerprintVersion
  = IssuerFingerprintV4
  | IssuerFingerprintV6
  deriving (Typeable IssuerFingerprintVersion
Typeable IssuerFingerprintVersion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> IssuerFingerprintVersion
 -> c IssuerFingerprintVersion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IssuerFingerprintVersion)
-> (IssuerFingerprintVersion -> Constr)
-> (IssuerFingerprintVersion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c IssuerFingerprintVersion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IssuerFingerprintVersion))
-> ((forall b. Data b => b -> b)
    -> IssuerFingerprintVersion -> IssuerFingerprintVersion)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> IssuerFingerprintVersion
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> IssuerFingerprintVersion
    -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> IssuerFingerprintVersion -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u) -> IssuerFingerprintVersion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IssuerFingerprintVersion -> m IssuerFingerprintVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IssuerFingerprintVersion -> m IssuerFingerprintVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IssuerFingerprintVersion -> m IssuerFingerprintVersion)
-> Data IssuerFingerprintVersion
IssuerFingerprintVersion -> Constr
IssuerFingerprintVersion -> DataType
(forall b. Data b => b -> b)
-> IssuerFingerprintVersion -> IssuerFingerprintVersion
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) -> IssuerFingerprintVersion -> u
forall u.
(forall d. Data d => d -> u) -> IssuerFingerprintVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> IssuerFingerprintVersion
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> IssuerFingerprintVersion
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IssuerFingerprintVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> IssuerFingerprintVersion
-> c IssuerFingerprintVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IssuerFingerprintVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IssuerFingerprintVersion)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> IssuerFingerprintVersion
-> c IssuerFingerprintVersion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> IssuerFingerprintVersion
-> c IssuerFingerprintVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IssuerFingerprintVersion
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IssuerFingerprintVersion
$ctoConstr :: IssuerFingerprintVersion -> Constr
toConstr :: IssuerFingerprintVersion -> Constr
$cdataTypeOf :: IssuerFingerprintVersion -> DataType
dataTypeOf :: IssuerFingerprintVersion -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IssuerFingerprintVersion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IssuerFingerprintVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IssuerFingerprintVersion)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IssuerFingerprintVersion)
$cgmapT :: (forall b. Data b => b -> b)
-> IssuerFingerprintVersion -> IssuerFingerprintVersion
gmapT :: (forall b. Data b => b -> b)
-> IssuerFingerprintVersion -> IssuerFingerprintVersion
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> IssuerFingerprintVersion
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> IssuerFingerprintVersion
-> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> IssuerFingerprintVersion
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> IssuerFingerprintVersion
-> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> IssuerFingerprintVersion -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> IssuerFingerprintVersion -> [u]
$cgmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> IssuerFingerprintVersion -> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u) -> IssuerFingerprintVersion -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IssuerFingerprintVersion -> m IssuerFingerprintVersion
Data, IssuerFingerprintVersion -> IssuerFingerprintVersion -> Bool
(IssuerFingerprintVersion -> IssuerFingerprintVersion -> Bool)
-> (IssuerFingerprintVersion -> IssuerFingerprintVersion -> Bool)
-> Eq IssuerFingerprintVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IssuerFingerprintVersion -> IssuerFingerprintVersion -> Bool
== :: IssuerFingerprintVersion -> IssuerFingerprintVersion -> Bool
$c/= :: IssuerFingerprintVersion -> IssuerFingerprintVersion -> Bool
/= :: IssuerFingerprintVersion -> IssuerFingerprintVersion -> Bool
Eq, (forall x.
 IssuerFingerprintVersion -> Rep IssuerFingerprintVersion x)
-> (forall x.
    Rep IssuerFingerprintVersion x -> IssuerFingerprintVersion)
-> Generic IssuerFingerprintVersion
forall x.
Rep IssuerFingerprintVersion x -> IssuerFingerprintVersion
forall x.
IssuerFingerprintVersion -> Rep IssuerFingerprintVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x.
IssuerFingerprintVersion -> Rep IssuerFingerprintVersion x
from :: forall x.
IssuerFingerprintVersion -> Rep IssuerFingerprintVersion x
$cto :: forall x.
Rep IssuerFingerprintVersion x -> IssuerFingerprintVersion
to :: forall x.
Rep IssuerFingerprintVersion x -> IssuerFingerprintVersion
Generic, Int -> IssuerFingerprintVersion -> ShowS
[IssuerFingerprintVersion] -> ShowS
IssuerFingerprintVersion -> String
(Int -> IssuerFingerprintVersion -> ShowS)
-> (IssuerFingerprintVersion -> String)
-> ([IssuerFingerprintVersion] -> ShowS)
-> Show IssuerFingerprintVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IssuerFingerprintVersion -> ShowS
showsPrec :: Int -> IssuerFingerprintVersion -> ShowS
$cshow :: IssuerFingerprintVersion -> String
show :: IssuerFingerprintVersion -> String
$cshowList :: [IssuerFingerprintVersion] -> ShowS
showList :: [IssuerFingerprintVersion] -> ShowS
Show, Typeable)

instance Ord IssuerFingerprintVersion where
  IssuerFingerprintVersion
IssuerFingerprintV4 compare :: IssuerFingerprintVersion -> IssuerFingerprintVersion -> Ordering
`compare` IssuerFingerprintVersion
IssuerFingerprintV4 = Ordering
EQ
  IssuerFingerprintVersion
IssuerFingerprintV4 `compare` IssuerFingerprintVersion
IssuerFingerprintV6 = Ordering
LT
  IssuerFingerprintVersion
IssuerFingerprintV6 `compare` IssuerFingerprintVersion
IssuerFingerprintV4 = Ordering
GT
  IssuerFingerprintVersion
IssuerFingerprintV6 `compare` IssuerFingerprintVersion
IssuerFingerprintV6 = Ordering
EQ

instance Hashable IssuerFingerprintVersion

instance Pretty IssuerFingerprintVersion where
  pretty :: forall ann. IssuerFingerprintVersion -> Doc ann
pretty IssuerFingerprintVersion
IssuerFingerprintV4 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"4"
  pretty IssuerFingerprintVersion
IssuerFingerprintV6 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"6"

instance A.ToJSON IssuerFingerprintVersion where
  toJSON :: IssuerFingerprintVersion -> Value
toJSON IssuerFingerprintVersion
IssuerFingerprintV4 = Word8 -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Word8
4 :: Word8)
  toJSON IssuerFingerprintVersion
IssuerFingerprintV6 = Word8 -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Word8
6 :: Word8)

instance A.FromJSON IssuerFingerprintVersion where
  parseJSON :: Value -> Parser IssuerFingerprintVersion
parseJSON (A.Number Scientific
n) = case Scientific -> Integer
forall b. Integral b => Scientific -> b
forall a b. (RealFrac a, Integral b) => a -> b
round Scientific
n of
   Integer
4 -> IssuerFingerprintVersion -> Parser IssuerFingerprintVersion
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure IssuerFingerprintVersion
IssuerFingerprintV4
   Integer
6 -> IssuerFingerprintVersion -> Parser IssuerFingerprintVersion
forall a. a -> Parser a
forall (f :: * -> *) a. Applicative f => a -> f a
pure IssuerFingerprintVersion
IssuerFingerprintV6
   Integer
_ -> Parser IssuerFingerprintVersion
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero
  parseJSON Value
_ = Parser IssuerFingerprintVersion
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

issuerFingerprintVersionToPacketVersion :: IssuerFingerprintVersion -> PacketVersion
issuerFingerprintVersionToPacketVersion :: IssuerFingerprintVersion -> Word8
issuerFingerprintVersionToPacketVersion IssuerFingerprintVersion
IssuerFingerprintV4 = Word8
4
issuerFingerprintVersionToPacketVersion IssuerFingerprintVersion
IssuerFingerprintV6 = Word8
6

packetVersionToIssuerFingerprintVersion :: PacketVersion -> Maybe IssuerFingerprintVersion
packetVersionToIssuerFingerprintVersion :: Word8 -> Maybe IssuerFingerprintVersion
packetVersionToIssuerFingerprintVersion Word8
4 = IssuerFingerprintVersion -> Maybe IssuerFingerprintVersion
forall a. a -> Maybe a
Just IssuerFingerprintVersion
IssuerFingerprintV4
packetVersionToIssuerFingerprintVersion Word8
6 = IssuerFingerprintVersion -> Maybe IssuerFingerprintVersion
forall a. a -> Maybe a
Just IssuerFingerprintVersion
IssuerFingerprintV6
packetVersionToIssuerFingerprintVersion Word8
_ = Maybe IssuerFingerprintVersion
forall a. Maybe a
Nothing

data SigSubPacketPayload
  = SigCreationTime ThirtyTwoBitTimeStamp
  | SigExpirationTime ThirtyTwoBitDuration
  | ExportableCertification Exportability
  | TrustSignature TrustLevel TrustAmount
  | RegularExpression AlmostPublicDomainRegex
  | Revocable Revocability
  | KeyExpirationTime ThirtyTwoBitDuration
  | PreferredSymmetricAlgorithms [SymmetricAlgorithm]
  | RevocationKey (Set RevocationClass) PubKeyAlgorithm Fingerprint
  | Issuer EightOctetKeyId
  | NotationData (Set NotationFlag) NotationName NotationValue
  | PreferredHashAlgorithms [HashAlgorithm]
  | PreferredCompressionAlgorithms [CompressionAlgorithm]
  | KeyServerPreferences (Set KSPFlag)
  | PreferredKeyServer KeyServer
  | PrimaryUserId Bool
  | PolicyURL URL
  | KeyFlags (Set KeyFlag)
  | SignersUserId Text
  | ReasonForRevocation RevocationCode RevocationReason
  | Features (Set FeatureFlag)
  | SignatureTarget PubKeyAlgorithm HashAlgorithm SignatureHash
  | EmbeddedSignature SignaturePayload
  | IssuerFingerprint IssuerFingerprintVersion Fingerprint
  | UserDefinedSigSub Word8 ByteString
  | OtherSigSub Word8 ByteString
  deriving (Typeable SigSubPacketPayload
Typeable SigSubPacketPayload =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SigSubPacketPayload
 -> c SigSubPacketPayload)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SigSubPacketPayload)
-> (SigSubPacketPayload -> Constr)
-> (SigSubPacketPayload -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SigSubPacketPayload))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SigSubPacketPayload))
-> ((forall b. Data b => b -> b)
    -> SigSubPacketPayload -> SigSubPacketPayload)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> SigSubPacketPayload -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SigSubPacketPayload -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SigSubPacketPayload -> m SigSubPacketPayload)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SigSubPacketPayload -> m SigSubPacketPayload)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SigSubPacketPayload -> m SigSubPacketPayload)
-> Data SigSubPacketPayload
SigSubPacketPayload -> Constr
SigSubPacketPayload -> DataType
(forall b. Data b => b -> b)
-> SigSubPacketPayload -> SigSubPacketPayload
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) -> SigSubPacketPayload -> u
forall u.
(forall d. Data d => d -> u) -> SigSubPacketPayload -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigSubPacketPayload
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SigSubPacketPayload
-> c SigSubPacketPayload
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigSubPacketPayload)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SigSubPacketPayload)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SigSubPacketPayload
-> c SigSubPacketPayload
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SigSubPacketPayload
-> c SigSubPacketPayload
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigSubPacketPayload
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigSubPacketPayload
$ctoConstr :: SigSubPacketPayload -> Constr
toConstr :: SigSubPacketPayload -> Constr
$cdataTypeOf :: SigSubPacketPayload -> DataType
dataTypeOf :: SigSubPacketPayload -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigSubPacketPayload)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigSubPacketPayload)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SigSubPacketPayload)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SigSubPacketPayload)
$cgmapT :: (forall b. Data b => b -> b)
-> SigSubPacketPayload -> SigSubPacketPayload
gmapT :: (forall b. Data b => b -> b)
-> SigSubPacketPayload -> SigSubPacketPayload
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacketPayload -> r
$cgmapQ :: forall u.
(forall d. Data d => d -> u) -> SigSubPacketPayload -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u) -> SigSubPacketPayload -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SigSubPacketPayload -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> SigSubPacketPayload -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SigSubPacketPayload -> m SigSubPacketPayload
Data, SigSubPacketPayload -> SigSubPacketPayload -> Bool
(SigSubPacketPayload -> SigSubPacketPayload -> Bool)
-> (SigSubPacketPayload -> SigSubPacketPayload -> Bool)
-> Eq SigSubPacketPayload
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
== :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
$c/= :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
/= :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
Eq, (forall x. SigSubPacketPayload -> Rep SigSubPacketPayload x)
-> (forall x. Rep SigSubPacketPayload x -> SigSubPacketPayload)
-> Generic SigSubPacketPayload
forall x. Rep SigSubPacketPayload x -> SigSubPacketPayload
forall x. SigSubPacketPayload -> Rep SigSubPacketPayload x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SigSubPacketPayload -> Rep SigSubPacketPayload x
from :: forall x. SigSubPacketPayload -> Rep SigSubPacketPayload x
$cto :: forall x. Rep SigSubPacketPayload x -> SigSubPacketPayload
to :: forall x. Rep SigSubPacketPayload x -> SigSubPacketPayload
Generic, Eq SigSubPacketPayload
Eq SigSubPacketPayload =>
(SigSubPacketPayload -> SigSubPacketPayload -> Ordering)
-> (SigSubPacketPayload -> SigSubPacketPayload -> Bool)
-> (SigSubPacketPayload -> SigSubPacketPayload -> Bool)
-> (SigSubPacketPayload -> SigSubPacketPayload -> Bool)
-> (SigSubPacketPayload -> SigSubPacketPayload -> Bool)
-> (SigSubPacketPayload
    -> SigSubPacketPayload -> SigSubPacketPayload)
-> (SigSubPacketPayload
    -> SigSubPacketPayload -> SigSubPacketPayload)
-> Ord SigSubPacketPayload
SigSubPacketPayload -> SigSubPacketPayload -> Bool
SigSubPacketPayload -> SigSubPacketPayload -> Ordering
SigSubPacketPayload -> SigSubPacketPayload -> SigSubPacketPayload
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: SigSubPacketPayload -> SigSubPacketPayload -> Ordering
compare :: SigSubPacketPayload -> SigSubPacketPayload -> Ordering
$c< :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
< :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
$c<= :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
<= :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
$c> :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
> :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
$c>= :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
>= :: SigSubPacketPayload -> SigSubPacketPayload -> Bool
$cmax :: SigSubPacketPayload -> SigSubPacketPayload -> SigSubPacketPayload
max :: SigSubPacketPayload -> SigSubPacketPayload -> SigSubPacketPayload
$cmin :: SigSubPacketPayload -> SigSubPacketPayload -> SigSubPacketPayload
min :: SigSubPacketPayload -> SigSubPacketPayload -> SigSubPacketPayload
Ord, Int -> SigSubPacketPayload -> ShowS
[SigSubPacketPayload] -> ShowS
SigSubPacketPayload -> String
(Int -> SigSubPacketPayload -> ShowS)
-> (SigSubPacketPayload -> String)
-> ([SigSubPacketPayload] -> ShowS)
-> Show SigSubPacketPayload
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SigSubPacketPayload -> ShowS
showsPrec :: Int -> SigSubPacketPayload -> ShowS
$cshow :: SigSubPacketPayload -> String
show :: SigSubPacketPayload -> String
$cshowList :: [SigSubPacketPayload] -> ShowS
showList :: [SigSubPacketPayload] -> ShowS
Show, Typeable)

instance Hashable SigSubPacketPayload

instance Pretty SigSubPacketPayload where
  pretty :: forall ann. SigSubPacketPayload -> Doc ann
pretty (SigCreationTime ThirtyTwoBitTimeStamp
ts) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"creation-time" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ThirtyTwoBitTimeStamp -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ThirtyTwoBitTimeStamp -> Doc ann
pretty ThirtyTwoBitTimeStamp
ts
  pretty (SigExpirationTime ThirtyTwoBitDuration
d) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"sig expiration time" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ThirtyTwoBitDuration -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ThirtyTwoBitDuration -> Doc ann
pretty ThirtyTwoBitDuration
d
  pretty (ExportableCertification Bool
e) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"exportable certification" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Bool -> Doc ann
forall ann. Bool -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Bool
e
  pretty (TrustSignature Word8
tl Word8
ta) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"trust signature" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
tl Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
ta
  pretty (RegularExpression ByteString
apdre) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"regular expression" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ByteString -> Doc ann
forall ann. ByteString -> Doc ann
prettyLBS ByteString
apdre
  pretty (Revocable Bool
r) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"revocable" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Bool -> Doc ann
forall ann. Bool -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Bool
r
  pretty (KeyExpirationTime ThirtyTwoBitDuration
d) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"key expiration time" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ThirtyTwoBitDuration -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ThirtyTwoBitDuration -> Doc ann
pretty ThirtyTwoBitDuration
d
  pretty (PreferredSymmetricAlgorithms [SymmetricAlgorithm]
sas) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"preferred symmetric algorithms" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [SymmetricAlgorithm] -> Doc ann
forall ann. [SymmetricAlgorithm] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [SymmetricAlgorithm]
sas
  pretty (RevocationKey Set RevocationClass
rcs PubKeyAlgorithm
pka Fingerprint
tof) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"revocation key" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    [RevocationClass] -> Doc ann
forall ann. [RevocationClass] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Set RevocationClass -> [RevocationClass]
forall a. Set a -> [a]
Set.toList Set RevocationClass
rcs) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> PubKeyAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. PubKeyAlgorithm -> Doc ann
pretty PubKeyAlgorithm
pka Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Fingerprint -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Fingerprint -> Doc ann
pretty Fingerprint
tof
  pretty (Issuer EightOctetKeyId
eoki) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"issuer" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> EightOctetKeyId -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. EightOctetKeyId -> Doc ann
pretty EightOctetKeyId
eoki
  pretty (NotationData Set NotationFlag
nfs NotationName
nn NotationValue
nv) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"notation data" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    [NotationFlag] -> Doc ann
forall ann. [NotationFlag] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Set NotationFlag -> [NotationFlag]
forall a. Set a -> [a]
Set.toList Set NotationFlag
nfs) Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> NotationName -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. NotationName -> Doc ann
pretty NotationName
nn Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> NotationValue -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. NotationValue -> Doc ann
pretty NotationValue
nv
  pretty (PreferredHashAlgorithms [HashAlgorithm]
phas) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"preferred hash algorithms" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [HashAlgorithm] -> Doc ann
forall ann. [HashAlgorithm] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [HashAlgorithm]
phas
  pretty (PreferredCompressionAlgorithms [CompressionAlgorithm]
pcas) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"preferred compression algorithms" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [CompressionAlgorithm] -> Doc ann
forall ann. [CompressionAlgorithm] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty [CompressionAlgorithm]
pcas
  pretty (KeyServerPreferences Set KSPFlag
kspfs) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"keyserver preferences" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [KSPFlag] -> Doc ann
forall ann. [KSPFlag] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Set KSPFlag -> [KSPFlag]
forall a. Set a -> [a]
Set.toList Set KSPFlag
kspfs)
  pretty (PreferredKeyServer ByteString
ks) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"preferred keyserver" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ByteString -> Doc ann
forall ann. ByteString -> Doc ann
prettyLBS ByteString
ks
  pretty (PrimaryUserId Bool
p) =
    (if Bool
p
       then Doc ann
forall a. Monoid a => a
mempty
       else String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"NOT ") Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"primary user-ID"
  pretty (PolicyURL URL
u) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"policy URL" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> URL -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. URL -> Doc ann
pretty URL
u
  pretty (KeyFlags Set KeyFlag
kfs) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"key flags" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [KeyFlag] -> Doc ann
forall ann. [KeyFlag] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Set KeyFlag -> [KeyFlag]
forall a. Set a -> [a]
Set.toList Set KeyFlag
kfs)
  pretty (SignersUserId Text
u) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"signer's user-ID" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Text
u
  pretty (ReasonForRevocation RevocationCode
rc Text
rr) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"reason for revocation" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> RevocationCode -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. RevocationCode -> Doc ann
pretty RevocationCode
rc Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Text -> Doc ann
forall ann. Text -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Text
rr
  pretty (Features Set FeatureFlag
ffs) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"features" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [FeatureFlag] -> Doc ann
forall ann. [FeatureFlag] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Set FeatureFlag -> [FeatureFlag]
forall a. Set a -> [a]
Set.toList Set FeatureFlag
ffs)
  pretty (SignatureTarget PubKeyAlgorithm
pka HashAlgorithm
ha ByteString
sh) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"signature target" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> PubKeyAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. PubKeyAlgorithm -> Doc ann
pretty PubKeyAlgorithm
pka Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
ha Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ByteString -> Doc ann
forall ann. ByteString -> Doc ann
prettyLBS ByteString
sh
  pretty (EmbeddedSignature SignaturePayload
sp) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"embedded signature" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> SignaturePayload -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. SignaturePayload -> Doc ann
pretty SignaturePayload
sp
  pretty (IssuerFingerprint IssuerFingerprintVersion
kv Fingerprint
ifp) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"issuer fingerprint (v" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> IssuerFingerprintVersion -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. IssuerFingerprintVersion -> Doc ann
pretty IssuerFingerprintVersion
kv Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
")" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Fingerprint -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Fingerprint -> Doc ann
pretty Fingerprint
ifp
  pretty (UserDefinedSigSub Word8
t ByteString
bs) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"user-defined signature subpacket type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Word8] -> Doc ann
forall ann. [Word8] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> [Word8]
BL.unpack ByteString
bs)
  pretty (OtherSigSub Word8
t ByteString
bs) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown signature subpacket type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ByteString -> Doc ann
forall ann. ByteString -> Doc ann
prettyLBS ByteString
bs

instance A.ToJSON SigSubPacketPayload where
  toJSON :: SigSubPacketPayload -> Value
toJSON (SigCreationTime ThirtyTwoBitTimeStamp
ts) = [Pair] -> Value
object [String -> Key
key String
"sigCreationTime" Key -> ThirtyTwoBitTimeStamp -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ThirtyTwoBitTimeStamp
ts]
  toJSON (SigExpirationTime ThirtyTwoBitDuration
d) = [Pair] -> Value
object [String -> Key
key String
"sigExpirationTime" Key -> ThirtyTwoBitDuration -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ThirtyTwoBitDuration
d]
  toJSON (ExportableCertification Bool
e) =
    [Pair] -> Value
object [String -> Key
key String
"exportableCertification" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool
e]
  toJSON (TrustSignature Word8
tl Word8
ta) = [Pair] -> Value
object [String -> Key
key String
"trustSignature" Key -> (Word8, Word8) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Word8
tl, Word8
ta)]
  toJSON (RegularExpression ByteString
apdre) =
    [Pair] -> Value
object [String -> Key
key String
"regularExpression" Key -> [Word8] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ByteString -> [Word8]
BL.unpack ByteString
apdre]
  toJSON (Revocable Bool
r) = [Pair] -> Value
object [String -> Key
key String
"revocable" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool
r]
  toJSON (KeyExpirationTime ThirtyTwoBitDuration
d) = [Pair] -> Value
object [String -> Key
key String
"keyExpirationTime" Key -> ThirtyTwoBitDuration -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ThirtyTwoBitDuration
d]
  toJSON (PreferredSymmetricAlgorithms [SymmetricAlgorithm]
sas) =
    [Pair] -> Value
object [String -> Key
key String
"preferredSymmetricAlgorithms" Key -> [SymmetricAlgorithm] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [SymmetricAlgorithm]
sas]
  toJSON (RevocationKey Set RevocationClass
rcs PubKeyAlgorithm
pka Fingerprint
tof) =
    [Pair] -> Value
object [String -> Key
key String
"revocationKey" Key -> (Set RevocationClass, PubKeyAlgorithm, Fingerprint) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Set RevocationClass
rcs, PubKeyAlgorithm
pka, Fingerprint
tof)]
  toJSON (Issuer EightOctetKeyId
eoki) = [Pair] -> Value
object [String -> Key
key String
"issuer" Key -> EightOctetKeyId -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= EightOctetKeyId
eoki]
  toJSON (NotationData Set NotationFlag
nfs (NotationName ByteString
nn) (NotationValue ByteString
nv)) =
    [Pair] -> Value
object [String -> Key
key String
"notationData" Key -> (Set NotationFlag, [Word8], [Word8]) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Set NotationFlag
nfs, ByteString -> [Word8]
BL.unpack ByteString
nn, ByteString -> [Word8]
BL.unpack ByteString
nv)]
  toJSON (PreferredHashAlgorithms [HashAlgorithm]
phas) =
    [Pair] -> Value
object [String -> Key
key String
"preferredHashAlgorithms" Key -> [HashAlgorithm] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [HashAlgorithm]
phas]
  toJSON (PreferredCompressionAlgorithms [CompressionAlgorithm]
pcas) =
    [Pair] -> Value
object [String -> Key
key String
"preferredCompressionAlgorithms" Key -> [CompressionAlgorithm] -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= [CompressionAlgorithm]
pcas]
  toJSON (KeyServerPreferences Set KSPFlag
kspfs) =
    [Pair] -> Value
object [String -> Key
key String
"keyServerPreferences" Key -> Set KSPFlag -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Set KSPFlag
kspfs]
  toJSON (PreferredKeyServer ByteString
ks) =
    [Pair] -> Value
object [String -> Key
key String
"preferredKeyServer" Key -> String -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= ByteString -> String
forall a. Show a => a -> String
show ByteString
ks]
  toJSON (PrimaryUserId Bool
p) = [Pair] -> Value
object [String -> Key
key String
"primaryUserId" Key -> Bool -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Bool
p]
  toJSON (PolicyURL URL
u) = [Pair] -> Value
object [String -> Key
key String
"policyURL" Key -> URL -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= URL
u]
  toJSON (KeyFlags Set KeyFlag
kfs) = [Pair] -> Value
object [String -> Key
key String
"keyFlags" Key -> Set KeyFlag -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Set KeyFlag
kfs]
  toJSON (SignersUserId Text
u) = [Pair] -> Value
object [String -> Key
key String
"signersUserId" Key -> Text -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Text
u]
  toJSON (ReasonForRevocation RevocationCode
rc Text
rr) =
    [Pair] -> Value
object [String -> Key
key String
"reasonForRevocation" Key -> (RevocationCode, Text) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (RevocationCode
rc, Text
rr)]
  toJSON (Features Set FeatureFlag
ffs) = [Pair] -> Value
object [String -> Key
key String
"features" Key -> Set FeatureFlag -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= Set FeatureFlag
ffs]
  toJSON (SignatureTarget PubKeyAlgorithm
pka HashAlgorithm
ha ByteString
sh) =
    [Pair] -> Value
object [String -> Key
key String
"signatureTarget" Key -> (PubKeyAlgorithm, HashAlgorithm, [Word8]) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (PubKeyAlgorithm
pka, HashAlgorithm
ha, ByteString -> [Word8]
BL.unpack ByteString
sh)]
  toJSON (EmbeddedSignature SignaturePayload
sp) = [Pair] -> Value
object [String -> Key
key String
"embeddedSignature" Key -> SignaturePayload -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= SignaturePayload
sp]
  toJSON (IssuerFingerprint IssuerFingerprintVersion
kv Fingerprint
ifp) =
    [Pair] -> Value
object [String -> Key
key String
"issuerFingerprint" Key -> (IssuerFingerprintVersion, Fingerprint) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (IssuerFingerprintVersion
kv, Fingerprint
ifp)]
  toJSON (UserDefinedSigSub Word8
t ByteString
bs) =
    [Pair] -> Value
object [String -> Key
key String
"userDefinedSigSub" Key -> (Word8, [Word8]) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Word8
t, ByteString -> [Word8]
BL.unpack ByteString
bs)]
  toJSON (OtherSigSub Word8
t ByteString
bs) = [Pair] -> Value
object [String -> Key
key String
"otherSigSub" Key -> (Word8, [Word8]) -> Pair
forall v. ToJSON v => Key -> v -> Pair
forall e kv v. (KeyValue e kv, ToJSON v) => Key -> v -> kv
.= (Word8
t, ByteString -> [Word8]
BL.unpack ByteString
bs)]

uc3 :: (a -> b -> c -> d) -> (a, b, c) -> d
uc3 :: forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
uc3 a -> b -> c -> d
f ~(a
a, b
b, c
c) = a -> b -> c -> d
f a
a b
b c
c

instance A.FromJSON SigSubPacketPayload where
  parseJSON :: Value -> Parser SigSubPacketPayload
parseJSON (A.Object Object
v) =
    (ThirtyTwoBitTimeStamp -> SigSubPacketPayload
SigCreationTime (ThirtyTwoBitTimeStamp -> SigSubPacketPayload)
-> Parser ThirtyTwoBitTimeStamp -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser ThirtyTwoBitTimeStamp
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"sigCreationTime") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (ThirtyTwoBitDuration -> SigSubPacketPayload
SigExpirationTime (ThirtyTwoBitDuration -> SigSubPacketPayload)
-> Parser ThirtyTwoBitDuration -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser ThirtyTwoBitDuration
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"sigExpirationTime") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (Bool -> SigSubPacketPayload
ExportableCertification (Bool -> SigSubPacketPayload)
-> Parser Bool -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"exportableCertification") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ((Word8 -> Word8 -> SigSubPacketPayload)
-> (Word8, Word8) -> SigSubPacketPayload
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry Word8 -> Word8 -> SigSubPacketPayload
TrustSignature ((Word8, Word8) -> SigSubPacketPayload)
-> Parser (Word8, Word8) -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser (Word8, Word8)
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"trustSignature") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (ByteString -> SigSubPacketPayload
RegularExpression (ByteString -> SigSubPacketPayload)
-> ([Word8] -> ByteString) -> [Word8] -> SigSubPacketPayload
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [Word8] -> ByteString
BL.pack ([Word8] -> SigSubPacketPayload)
-> Parser [Word8] -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser [Word8]
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"regularExpression") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (Bool -> SigSubPacketPayload
Revocable (Bool -> SigSubPacketPayload)
-> Parser Bool -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser Bool
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"revocable") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (ThirtyTwoBitDuration -> SigSubPacketPayload
KeyExpirationTime (ThirtyTwoBitDuration -> SigSubPacketPayload)
-> Parser ThirtyTwoBitDuration -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser ThirtyTwoBitDuration
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"keyExpirationTime") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ([SymmetricAlgorithm] -> SigSubPacketPayload
PreferredSymmetricAlgorithms ([SymmetricAlgorithm] -> SigSubPacketPayload)
-> Parser [SymmetricAlgorithm] -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$>
     Object
v Object -> Key -> Parser [SymmetricAlgorithm]
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"preferredSymmetricAlgorithms") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ((Set RevocationClass
 -> PubKeyAlgorithm -> Fingerprint -> SigSubPacketPayload)
-> (Set RevocationClass, PubKeyAlgorithm, Fingerprint)
-> SigSubPacketPayload
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
uc3 Set RevocationClass
-> PubKeyAlgorithm -> Fingerprint -> SigSubPacketPayload
RevocationKey ((Set RevocationClass, PubKeyAlgorithm, Fingerprint)
 -> SigSubPacketPayload)
-> Parser (Set RevocationClass, PubKeyAlgorithm, Fingerprint)
-> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object
-> Key
-> Parser (Set RevocationClass, PubKeyAlgorithm, Fingerprint)
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"revocationKey") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    (EightOctetKeyId -> SigSubPacketPayload
Issuer (EightOctetKeyId -> SigSubPacketPayload)
-> Parser EightOctetKeyId -> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object -> Key -> Parser EightOctetKeyId
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"issuer") Parser SigSubPacketPayload
-> Parser SigSubPacketPayload -> Parser SigSubPacketPayload
forall a. Parser a -> Parser a -> Parser a
forall (f :: * -> *) a. Alternative f => f a -> f a -> f a
<|>
    ((Set NotationFlag
 -> NotationName -> NotationValue -> SigSubPacketPayload)
-> (Set NotationFlag, NotationName, NotationValue)
-> SigSubPacketPayload
forall a b c d. (a -> b -> c -> d) -> (a, b, c) -> d
uc3 Set NotationFlag
-> NotationName -> NotationValue -> SigSubPacketPayload
NotationData ((Set NotationFlag, NotationName, NotationValue)
 -> SigSubPacketPayload)
-> Parser (Set NotationFlag, NotationName, NotationValue)
-> Parser SigSubPacketPayload
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Object
v Object
-> Key -> Parser (Set NotationFlag, NotationName, NotationValue)
forall a. FromJSON a => Object -> Key -> Parser a
A..: String -> Key
key String
"notationData")
  parseJSON Value
_ = Parser SigSubPacketPayload
forall a. Parser a
forall (m :: * -> *) a. MonadPlus m => m a
mzero

data SigSubPacket =
  SigSubPacket
    { SigSubPacket -> Bool
_sspCriticality :: Bool
    , SigSubPacket -> SigSubPacketPayload
_sspPayload :: SigSubPacketPayload
    }
  deriving (Typeable SigSubPacket
Typeable SigSubPacket =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SigSubPacket -> c SigSubPacket)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SigSubPacket)
-> (SigSubPacket -> Constr)
-> (SigSubPacket -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SigSubPacket))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SigSubPacket))
-> ((forall b. Data b => b -> b) -> SigSubPacket -> SigSubPacket)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r)
-> (forall u. (forall d. Data d => d -> u) -> SigSubPacket -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SigSubPacket -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket)
-> Data SigSubPacket
SigSubPacket -> Constr
SigSubPacket -> DataType
(forall b. Data b => b -> b) -> SigSubPacket -> SigSubPacket
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) -> SigSubPacket -> u
forall u. (forall d. Data d => d -> u) -> SigSubPacket -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigSubPacket
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigSubPacket -> c SigSubPacket
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigSubPacket)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SigSubPacket)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigSubPacket -> c SigSubPacket
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SigSubPacket -> c SigSubPacket
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigSubPacket
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SigSubPacket
$ctoConstr :: SigSubPacket -> Constr
toConstr :: SigSubPacket -> Constr
$cdataTypeOf :: SigSubPacket -> DataType
dataTypeOf :: SigSubPacket -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigSubPacket)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SigSubPacket)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SigSubPacket)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c SigSubPacket)
$cgmapT :: (forall b. Data b => b -> b) -> SigSubPacket -> SigSubPacket
gmapT :: (forall b. Data b => b -> b) -> SigSubPacket -> SigSubPacket
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SigSubPacket -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SigSubPacket -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SigSubPacket -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SigSubPacket -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SigSubPacket -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SigSubPacket -> m SigSubPacket
Data, SigSubPacket -> SigSubPacket -> Bool
(SigSubPacket -> SigSubPacket -> Bool)
-> (SigSubPacket -> SigSubPacket -> Bool) -> Eq SigSubPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SigSubPacket -> SigSubPacket -> Bool
== :: SigSubPacket -> SigSubPacket -> Bool
$c/= :: SigSubPacket -> SigSubPacket -> Bool
/= :: SigSubPacket -> SigSubPacket -> Bool
Eq, (forall x. SigSubPacket -> Rep SigSubPacket x)
-> (forall x. Rep SigSubPacket x -> SigSubPacket)
-> Generic SigSubPacket
forall x. Rep SigSubPacket x -> SigSubPacket
forall x. SigSubPacket -> Rep SigSubPacket x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SigSubPacket -> Rep SigSubPacket x
from :: forall x. SigSubPacket -> Rep SigSubPacket x
$cto :: forall x. Rep SigSubPacket x -> SigSubPacket
to :: forall x. Rep SigSubPacket x -> SigSubPacket
Generic, Int -> SigSubPacket -> ShowS
[SigSubPacket] -> ShowS
SigSubPacket -> String
(Int -> SigSubPacket -> ShowS)
-> (SigSubPacket -> String)
-> ([SigSubPacket] -> ShowS)
-> Show SigSubPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SigSubPacket -> ShowS
showsPrec :: Int -> SigSubPacket -> ShowS
$cshow :: SigSubPacket -> String
show :: SigSubPacket -> String
$cshowList :: [SigSubPacket] -> ShowS
showList :: [SigSubPacket] -> ShowS
Show, Typeable)

instance Ord SigSubPacket where
  compare :: SigSubPacket -> SigSubPacket -> Ordering
compare (SigSubPacket Bool
crit1 SigSubPacketPayload
payload1) (SigSubPacket Bool
crit2 SigSubPacketPayload
payload2) =
    Bool -> Bool -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Bool
crit1 Bool
crit2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> SigSubPacketPayload -> SigSubPacketPayload -> Ordering
forall a. Ord a => a -> a -> Ordering
compare SigSubPacketPayload
payload1 SigSubPacketPayload
payload2

instance Pretty SigSubPacket where
  pretty :: forall ann. SigSubPacket -> Doc ann
pretty SigSubPacket
x =
    (if SigSubPacket -> Bool
_sspCriticality SigSubPacket
x
       then Char -> Doc ann
forall ann. Char -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Char
'*'
       else Doc ann
forall a. Monoid a => a
mempty) Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<>
    (SigSubPacketPayload -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. SigSubPacketPayload -> Doc ann
pretty (SigSubPacketPayload -> Doc ann)
-> (SigSubPacket -> SigSubPacketPayload) -> SigSubPacket -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. SigSubPacket -> SigSubPacketPayload
_sspPayload) SigSubPacket
x

instance Hashable SigSubPacket

instance A.ToJSON SigSubPacket
instance A.FromJSON SigSubPacket

$(makeLenses ''SigSubPacket)

-- | Type-safe subpacket list with phantom types to distinguish hashed vs unhashed
-- and signature version constraints (v4 vs v6).
-- The type parameters erase at runtime; they exist purely for compile-time safety.
newtype SubpacketList (hashedness :: Type) (version :: Type) = SubpacketList [SigSubPacket]
  deriving (Int -> SubpacketList hashedness version -> ShowS
[SubpacketList hashedness version] -> ShowS
SubpacketList hashedness version -> String
(Int -> SubpacketList hashedness version -> ShowS)
-> (SubpacketList hashedness version -> String)
-> ([SubpacketList hashedness version] -> ShowS)
-> Show (SubpacketList hashedness version)
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
forall hashedness version.
Int -> SubpacketList hashedness version -> ShowS
forall hashedness version.
[SubpacketList hashedness version] -> ShowS
forall hashedness version.
SubpacketList hashedness version -> String
$cshowsPrec :: forall hashedness version.
Int -> SubpacketList hashedness version -> ShowS
showsPrec :: Int -> SubpacketList hashedness version -> ShowS
$cshow :: forall hashedness version.
SubpacketList hashedness version -> String
show :: SubpacketList hashedness version -> String
$cshowList :: forall hashedness version.
[SubpacketList hashedness version] -> ShowS
showList :: [SubpacketList hashedness version] -> ShowS
Show, SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
(SubpacketList hashedness version
 -> SubpacketList hashedness version -> Bool)
-> (SubpacketList hashedness version
    -> SubpacketList hashedness version -> Bool)
-> Eq (SubpacketList hashedness version)
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
$c== :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
== :: SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
$c/= :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
/= :: SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
Eq, Eq (SubpacketList hashedness version)
Eq (SubpacketList hashedness version) =>
(SubpacketList hashedness version
 -> SubpacketList hashedness version -> Ordering)
-> (SubpacketList hashedness version
    -> SubpacketList hashedness version -> Bool)
-> (SubpacketList hashedness version
    -> SubpacketList hashedness version -> Bool)
-> (SubpacketList hashedness version
    -> SubpacketList hashedness version -> Bool)
-> (SubpacketList hashedness version
    -> SubpacketList hashedness version -> Bool)
-> (SubpacketList hashedness version
    -> SubpacketList hashedness version
    -> SubpacketList hashedness version)
-> (SubpacketList hashedness version
    -> SubpacketList hashedness version
    -> SubpacketList hashedness version)
-> Ord (SubpacketList hashedness version)
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
SubpacketList hashedness version
-> SubpacketList hashedness version -> Ordering
SubpacketList hashedness version
-> SubpacketList hashedness version
-> SubpacketList hashedness version
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
forall hashedness version. Eq (SubpacketList hashedness version)
forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Ordering
forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version
-> SubpacketList hashedness version
$ccompare :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Ordering
compare :: SubpacketList hashedness version
-> SubpacketList hashedness version -> Ordering
$c< :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
< :: SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
$c<= :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
<= :: SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
$c> :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
> :: SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
$c>= :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
>= :: SubpacketList hashedness version
-> SubpacketList hashedness version -> Bool
$cmax :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version
-> SubpacketList hashedness version
max :: SubpacketList hashedness version
-> SubpacketList hashedness version
-> SubpacketList hashedness version
$cmin :: forall hashedness version.
SubpacketList hashedness version
-> SubpacketList hashedness version
-> SubpacketList hashedness version
min :: SubpacketList hashedness version
-> SubpacketList hashedness version
-> SubpacketList hashedness version
Ord, (forall x.
 SubpacketList hashedness version
 -> Rep (SubpacketList hashedness version) x)
-> (forall x.
    Rep (SubpacketList hashedness version) x
    -> SubpacketList hashedness version)
-> Generic (SubpacketList hashedness version)
forall x.
Rep (SubpacketList hashedness version) x
-> SubpacketList hashedness version
forall x.
SubpacketList hashedness version
-> Rep (SubpacketList hashedness version) x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
forall hashedness version x.
Rep (SubpacketList hashedness version) x
-> SubpacketList hashedness version
forall hashedness version x.
SubpacketList hashedness version
-> Rep (SubpacketList hashedness version) x
$cfrom :: forall hashedness version x.
SubpacketList hashedness version
-> Rep (SubpacketList hashedness version) x
from :: forall x.
SubpacketList hashedness version
-> Rep (SubpacketList hashedness version) x
$cto :: forall hashedness version x.
Rep (SubpacketList hashedness version) x
-> SubpacketList hashedness version
to :: forall x.
Rep (SubpacketList hashedness version) x
-> SubpacketList hashedness version
Generic, Typeable (SubpacketList hashedness version)
Typeable (SubpacketList hashedness version) =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> SubpacketList hashedness version
 -> c (SubpacketList hashedness version))
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r)
    -> Constr
    -> c (SubpacketList hashedness version))
-> (SubpacketList hashedness version -> Constr)
-> (SubpacketList hashedness version -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d))
    -> Maybe (c (SubpacketList hashedness version)))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c (SubpacketList hashedness version)))
-> ((forall b. Data b => b -> b)
    -> SubpacketList hashedness version
    -> SubpacketList hashedness version)
-> (forall r r'.
    (r -> r' -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SubpacketList hashedness version
    -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r
    -> (forall d. Data d => d -> r')
    -> SubpacketList hashedness version
    -> r)
-> (forall u.
    (forall d. Data d => d -> u)
    -> SubpacketList hashedness version -> [u])
-> (forall u.
    Int
    -> (forall d. Data d => d -> u)
    -> SubpacketList hashedness version
    -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> SubpacketList hashedness version
    -> m (SubpacketList hashedness version))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SubpacketList hashedness version
    -> m (SubpacketList hashedness version))
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> SubpacketList hashedness version
    -> m (SubpacketList hashedness version))
-> Data (SubpacketList hashedness version)
SubpacketList hashedness version -> Constr
SubpacketList hashedness version -> DataType
(forall b. Data b => b -> b)
-> SubpacketList hashedness version
-> SubpacketList hashedness version
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)
-> SubpacketList hashedness version
-> u
forall u.
(forall d. Data d => d -> u)
-> SubpacketList hashedness version -> [u]
forall hashedness version.
(Data hashedness, Data version) =>
Typeable (SubpacketList hashedness version)
forall hashedness version.
(Data hashedness, Data version) =>
SubpacketList hashedness version -> Constr
forall hashedness version.
(Data hashedness, Data version) =>
SubpacketList hashedness version -> DataType
forall hashedness version.
(Data hashedness, Data version) =>
(forall b. Data b => b -> b)
-> SubpacketList hashedness version
-> SubpacketList hashedness version
forall hashedness version u.
(Data hashedness, Data version) =>
Int
-> (forall d. Data d => d -> u)
-> SubpacketList hashedness version
-> u
forall hashedness version u.
(Data hashedness, Data version) =>
(forall d. Data d => d -> u)
-> SubpacketList hashedness version -> [u]
forall hashedness version r r'.
(Data hashedness, Data version) =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
forall hashedness version r r'.
(Data hashedness, Data version) =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
forall hashedness version (m :: * -> *).
(Data hashedness, Data version, Monad m) =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
forall hashedness version (m :: * -> *).
(Data hashedness, Data version, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
forall hashedness version (c :: * -> *).
(Data hashedness, Data version) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (SubpacketList hashedness version)
forall hashedness version (c :: * -> *).
(Data hashedness, Data version) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SubpacketList hashedness version
-> c (SubpacketList hashedness version)
forall hashedness version (t :: * -> *) (c :: * -> *).
(Data hashedness, Data version, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (SubpacketList hashedness version))
forall hashedness version (t :: * -> * -> *) (c :: * -> *).
(Data hashedness, Data version, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SubpacketList hashedness version))
forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (SubpacketList hashedness version)
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SubpacketList hashedness version
-> c (SubpacketList hashedness version)
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (SubpacketList hashedness version))
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SubpacketList hashedness version))
$cgfoldl :: forall hashedness version (c :: * -> *).
(Data hashedness, Data version) =>
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SubpacketList hashedness version
-> c (SubpacketList hashedness version)
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g)
-> SubpacketList hashedness version
-> c (SubpacketList hashedness version)
$cgunfold :: forall hashedness version (c :: * -> *).
(Data hashedness, Data version) =>
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (SubpacketList hashedness version)
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r)
-> Constr
-> c (SubpacketList hashedness version)
$ctoConstr :: forall hashedness version.
(Data hashedness, Data version) =>
SubpacketList hashedness version -> Constr
toConstr :: SubpacketList hashedness version -> Constr
$cdataTypeOf :: forall hashedness version.
(Data hashedness, Data version) =>
SubpacketList hashedness version -> DataType
dataTypeOf :: SubpacketList hashedness version -> DataType
$cdataCast1 :: forall hashedness version (t :: * -> *) (c :: * -> *).
(Data hashedness, Data version, Typeable t) =>
(forall d. Data d => c (t d))
-> Maybe (c (SubpacketList hashedness version))
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d))
-> Maybe (c (SubpacketList hashedness version))
$cdataCast2 :: forall hashedness version (t :: * -> * -> *) (c :: * -> *).
(Data hashedness, Data version, Typeable t) =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SubpacketList hashedness version))
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c (SubpacketList hashedness version))
$cgmapT :: forall hashedness version.
(Data hashedness, Data version) =>
(forall b. Data b => b -> b)
-> SubpacketList hashedness version
-> SubpacketList hashedness version
gmapT :: (forall b. Data b => b -> b)
-> SubpacketList hashedness version
-> SubpacketList hashedness version
$cgmapQl :: forall hashedness version r r'.
(Data hashedness, Data version) =>
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
$cgmapQr :: forall hashedness version r r'.
(Data hashedness, Data version) =>
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r
-> (forall d. Data d => d -> r')
-> SubpacketList hashedness version
-> r
$cgmapQ :: forall hashedness version u.
(Data hashedness, Data version) =>
(forall d. Data d => d -> u)
-> SubpacketList hashedness version -> [u]
gmapQ :: forall u.
(forall d. Data d => d -> u)
-> SubpacketList hashedness version -> [u]
$cgmapQi :: forall hashedness version u.
(Data hashedness, Data version) =>
Int
-> (forall d. Data d => d -> u)
-> SubpacketList hashedness version
-> u
gmapQi :: forall u.
Int
-> (forall d. Data d => d -> u)
-> SubpacketList hashedness version
-> u
$cgmapM :: forall hashedness version (m :: * -> *).
(Data hashedness, Data version, Monad m) =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
$cgmapMp :: forall hashedness version (m :: * -> *).
(Data hashedness, Data version, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
$cgmapMo :: forall hashedness version (m :: * -> *).
(Data hashedness, Data version, MonadPlus m) =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> SubpacketList hashedness version
-> m (SubpacketList hashedness version)
Data, Typeable)

instance Functor (SubpacketList h) where
  fmap :: forall a b. (a -> b) -> SubpacketList h a -> SubpacketList h b
fmap a -> b
_ (SubpacketList [SigSubPacket]
sps) = [SigSubPacket] -> SubpacketList h b
forall hashedness version.
[SigSubPacket] -> SubpacketList hashedness version
SubpacketList [SigSubPacket]
sps

-- | Extract the underlying list from a phantom-typed SubpacketList
-- This is typically used internally during serialization/deserialization
fromSubpacketList :: SubpacketList h v -> [SigSubPacket]
fromSubpacketList :: forall h v. SubpacketList h v -> [SigSubPacket]
fromSubpacketList (SubpacketList [SigSubPacket]
sps) = [SigSubPacket]
sps

-- | Wrap a plain list into a phantom-typed SubpacketList
-- Warning: This circumvents type safety; use only for trusted sources (e.g., parsing)
toSubpacketList :: [SigSubPacket] -> SubpacketList h v
toSubpacketList :: forall hashedness version.
[SigSubPacket] -> SubpacketList hashedness version
toSubpacketList = [SigSubPacket] -> SubpacketList h v
forall hashedness version.
[SigSubPacket] -> SubpacketList hashedness version
SubpacketList

-- | Create an empty hashed subpacket list for a given signature version
emptyHashedSubpackets :: SubpacketList Hashed v
emptyHashedSubpackets :: forall v. SubpacketList Hashed v
emptyHashedSubpackets = [SigSubPacket] -> SubpacketList Hashed v
forall hashedness version.
[SigSubPacket] -> SubpacketList hashedness version
SubpacketList []

-- | Create an empty unhashed subpacket list for a given signature version
emptyUnhashedSubpackets :: SubpacketList Unhashed v
emptyUnhashedSubpackets :: forall v. SubpacketList Unhashed v
emptyUnhashedSubpackets = [SigSubPacket] -> SubpacketList Unhashed v
forall hashedness version.
[SigSubPacket] -> SubpacketList hashedness version
SubpacketList []

-- | Append a subpacket to a hashed list, preserving phantom type
consHashedSubpacket :: SigSubPacket -> SubpacketList Hashed v -> SubpacketList Hashed v
consHashedSubpacket :: forall v.
SigSubPacket -> SubpacketList Hashed v -> SubpacketList Hashed v
consHashedSubpacket SigSubPacket
sp (SubpacketList [SigSubPacket]
sps) = [SigSubPacket] -> SubpacketList Hashed v
forall hashedness version.
[SigSubPacket] -> SubpacketList hashedness version
SubpacketList (SigSubPacket
sp SigSubPacket -> [SigSubPacket] -> [SigSubPacket]
forall a. a -> [a] -> [a]
: [SigSubPacket]
sps)

-- | Append a subpacket to an unhashed list, preserving phantom type
consUnhashedSubpacket :: SigSubPacket -> SubpacketList Unhashed v -> SubpacketList Unhashed v
consUnhashedSubpacket :: forall v.
SigSubPacket
-> SubpacketList Unhashed v -> SubpacketList Unhashed v
consUnhashedSubpacket SigSubPacket
sp (SubpacketList [SigSubPacket]
sps) = [SigSubPacket] -> SubpacketList Unhashed v
forall hashedness version.
[SigSubPacket] -> SubpacketList hashedness version
SubpacketList (SigSubPacket
sp SigSubPacket -> [SigSubPacket] -> [SigSubPacket]
forall a. a -> [a] -> [a]
: [SigSubPacket]
sps)

data KeyVersion
  = DeprecatedV3
  | V4
  | V6
  deriving (Typeable KeyVersion
Typeable KeyVersion =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> KeyVersion -> c KeyVersion)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c KeyVersion)
-> (KeyVersion -> Constr)
-> (KeyVersion -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c KeyVersion))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c KeyVersion))
-> ((forall b. Data b => b -> b) -> KeyVersion -> KeyVersion)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyVersion -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> KeyVersion -> r)
-> (forall u. (forall d. Data d => d -> u) -> KeyVersion -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> KeyVersion -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion)
-> Data KeyVersion
KeyVersion -> Constr
KeyVersion -> DataType
(forall b. Data b => b -> b) -> KeyVersion -> KeyVersion
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) -> KeyVersion -> u
forall u. (forall d. Data d => d -> u) -> KeyVersion -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyVersion -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyVersion -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyVersion
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyVersion -> c KeyVersion
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyVersion)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyVersion)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyVersion -> c KeyVersion
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> KeyVersion -> c KeyVersion
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyVersion
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c KeyVersion
$ctoConstr :: KeyVersion -> Constr
toConstr :: KeyVersion -> Constr
$cdataTypeOf :: KeyVersion -> DataType
dataTypeOf :: KeyVersion -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyVersion)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c KeyVersion)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyVersion)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c KeyVersion)
$cgmapT :: (forall b. Data b => b -> b) -> KeyVersion -> KeyVersion
gmapT :: (forall b. Data b => b -> b) -> KeyVersion -> KeyVersion
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyVersion -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> KeyVersion -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyVersion -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> KeyVersion -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> KeyVersion -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> KeyVersion -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyVersion -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> KeyVersion -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> KeyVersion -> m KeyVersion
Data, KeyVersion -> KeyVersion -> Bool
(KeyVersion -> KeyVersion -> Bool)
-> (KeyVersion -> KeyVersion -> Bool) -> Eq KeyVersion
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: KeyVersion -> KeyVersion -> Bool
== :: KeyVersion -> KeyVersion -> Bool
$c/= :: KeyVersion -> KeyVersion -> Bool
/= :: KeyVersion -> KeyVersion -> Bool
Eq, (forall x. KeyVersion -> Rep KeyVersion x)
-> (forall x. Rep KeyVersion x -> KeyVersion) -> Generic KeyVersion
forall x. Rep KeyVersion x -> KeyVersion
forall x. KeyVersion -> Rep KeyVersion x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. KeyVersion -> Rep KeyVersion x
from :: forall x. KeyVersion -> Rep KeyVersion x
$cto :: forall x. Rep KeyVersion x -> KeyVersion
to :: forall x. Rep KeyVersion x -> KeyVersion
Generic, Eq KeyVersion
Eq KeyVersion =>
(KeyVersion -> KeyVersion -> Ordering)
-> (KeyVersion -> KeyVersion -> Bool)
-> (KeyVersion -> KeyVersion -> Bool)
-> (KeyVersion -> KeyVersion -> Bool)
-> (KeyVersion -> KeyVersion -> Bool)
-> (KeyVersion -> KeyVersion -> KeyVersion)
-> (KeyVersion -> KeyVersion -> KeyVersion)
-> Ord KeyVersion
KeyVersion -> KeyVersion -> Bool
KeyVersion -> KeyVersion -> Ordering
KeyVersion -> KeyVersion -> KeyVersion
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: KeyVersion -> KeyVersion -> Ordering
compare :: KeyVersion -> KeyVersion -> Ordering
$c< :: KeyVersion -> KeyVersion -> Bool
< :: KeyVersion -> KeyVersion -> Bool
$c<= :: KeyVersion -> KeyVersion -> Bool
<= :: KeyVersion -> KeyVersion -> Bool
$c> :: KeyVersion -> KeyVersion -> Bool
> :: KeyVersion -> KeyVersion -> Bool
$c>= :: KeyVersion -> KeyVersion -> Bool
>= :: KeyVersion -> KeyVersion -> Bool
$cmax :: KeyVersion -> KeyVersion -> KeyVersion
max :: KeyVersion -> KeyVersion -> KeyVersion
$cmin :: KeyVersion -> KeyVersion -> KeyVersion
min :: KeyVersion -> KeyVersion -> KeyVersion
Ord, Int -> KeyVersion -> ShowS
[KeyVersion] -> ShowS
KeyVersion -> String
(Int -> KeyVersion -> ShowS)
-> (KeyVersion -> String)
-> ([KeyVersion] -> ShowS)
-> Show KeyVersion
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> KeyVersion -> ShowS
showsPrec :: Int -> KeyVersion -> ShowS
$cshow :: KeyVersion -> String
show :: KeyVersion -> String
$cshowList :: [KeyVersion] -> ShowS
showList :: [KeyVersion] -> ShowS
Show, Typeable)

instance Hashable KeyVersion

instance Pretty KeyVersion where
  pretty :: forall ann. KeyVersion -> Doc ann
pretty KeyVersion
DeprecatedV3 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"(deprecated) v3"
  pretty KeyVersion
V4 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"v4"
  pretty KeyVersion
V6 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"v6"

$(ATH.deriveJSON ATH.defaultOptions ''KeyVersion)

newtype IV =
  IV
    { IV -> ByteString
unIV :: B.ByteString
    }
  deriving ( IV -> Int
(IV -> Int)
-> (forall p a. IV -> (Ptr p -> IO a) -> IO a)
-> (forall p. IV -> Ptr p -> IO ())
-> ByteArrayAccess IV
forall p. IV -> Ptr p -> IO ()
forall ba.
(ba -> Int)
-> (forall p a. ba -> (Ptr p -> IO a) -> IO a)
-> (forall p. ba -> Ptr p -> IO ())
-> ByteArrayAccess ba
forall p a. IV -> (Ptr p -> IO a) -> IO a
$clength :: IV -> Int
length :: IV -> Int
$cwithByteArray :: forall p a. IV -> (Ptr p -> IO a) -> IO a
withByteArray :: forall p a. IV -> (Ptr p -> IO a) -> IO a
$ccopyByteArrayToPtr :: forall p. IV -> Ptr p -> IO ()
copyByteArrayToPtr :: forall p. IV -> Ptr p -> IO ()
ByteArrayAccess
           , Typeable IV
Typeable IV =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IV -> c IV)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IV)
-> (IV -> Constr)
-> (IV -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IV))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IV))
-> ((forall b. Data b => b -> b) -> IV -> IV)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r)
-> (forall u. (forall d. Data d => d -> u) -> IV -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> IV -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> IV -> m IV)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IV -> m IV)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> IV -> m IV)
-> Data IV
IV -> Constr
IV -> DataType
(forall b. Data b => b -> b) -> IV -> IV
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) -> IV -> u
forall u. (forall d. Data d => d -> u) -> IV -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IV -> m IV
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IV -> m IV
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IV
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IV -> c IV
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IV)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IV)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IV -> c IV
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IV -> c IV
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IV
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IV
$ctoConstr :: IV -> Constr
toConstr :: IV -> Constr
$cdataTypeOf :: IV -> DataType
dataTypeOf :: IV -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IV)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IV)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IV)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c IV)
$cgmapT :: (forall b. Data b => b -> b) -> IV -> IV
gmapT :: (forall b. Data b => b -> b) -> IV -> IV
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> IV -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IV -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IV -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IV -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> IV -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IV -> m IV
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> IV -> m IV
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IV -> m IV
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IV -> m IV
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IV -> m IV
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> IV -> m IV
Data
           , IV -> IV -> Bool
(IV -> IV -> Bool) -> (IV -> IV -> Bool) -> Eq IV
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IV -> IV -> Bool
== :: IV -> IV -> Bool
$c/= :: IV -> IV -> Bool
/= :: IV -> IV -> Bool
Eq
           , (forall x. IV -> Rep IV x)
-> (forall x. Rep IV x -> IV) -> Generic IV
forall x. Rep IV x -> IV
forall x. IV -> Rep IV x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IV -> Rep IV x
from :: forall x. IV -> Rep IV x
$cto :: forall x. Rep IV x -> IV
to :: forall x. Rep IV x -> IV
Generic
           , Eq IV
Eq IV => (Int -> IV -> Int) -> (IV -> Int) -> Hashable IV
Int -> IV -> Int
IV -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> IV -> Int
hashWithSalt :: Int -> IV -> Int
$chash :: IV -> Int
hash :: IV -> Int
Hashable
           , NonEmpty IV -> IV
IV -> IV -> IV
(IV -> IV -> IV)
-> (NonEmpty IV -> IV)
-> (forall b. Integral b => b -> IV -> IV)
-> Semigroup IV
forall b. Integral b => b -> IV -> IV
forall a.
(a -> a -> a)
-> (NonEmpty a -> a)
-> (forall b. Integral b => b -> a -> a)
-> Semigroup a
$c<> :: IV -> IV -> IV
<> :: IV -> IV -> IV
$csconcat :: NonEmpty IV -> IV
sconcat :: NonEmpty IV -> IV
$cstimes :: forall b. Integral b => b -> IV -> IV
stimes :: forall b. Integral b => b -> IV -> IV
Semigroup
           , Semigroup IV
IV
Semigroup IV => IV -> (IV -> IV -> IV) -> ([IV] -> IV) -> Monoid IV
[IV] -> IV
IV -> IV -> IV
forall a.
Semigroup a =>
a -> (a -> a -> a) -> ([a] -> a) -> Monoid a
$cmempty :: IV
mempty :: IV
$cmappend :: IV -> IV -> IV
mappend :: IV -> IV -> IV
$cmconcat :: [IV] -> IV
mconcat :: [IV] -> IV
Monoid
           , Int -> IV -> ShowS
[IV] -> ShowS
IV -> String
(Int -> IV -> ShowS)
-> (IV -> String) -> ([IV] -> ShowS) -> Show IV
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IV -> ShowS
showsPrec :: Int -> IV -> ShowS
$cshow :: IV -> String
show :: IV -> String
$cshowList :: [IV] -> ShowS
showList :: [IV] -> ShowS
Show
           , Typeable
           )

instance Wrapped IV

instance Ord IV where
  compare :: IV -> IV -> Ordering
compare (IV ByteString
b1) (IV ByteString
b2) = ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
b1 ByteString
b2

instance Pretty IV where
  pretty :: forall ann. IV -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> (IV -> String) -> IV -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"iv:" String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> (IV -> String) -> IV -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
bsToHexUpper (ByteString -> String) -> (IV -> ByteString) -> IV -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BL.fromStrict (ByteString -> ByteString)
-> (IV -> ByteString) -> IV -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped IV -> IV) -> IV -> Unwrapped IV
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> IV
Unwrapped IV -> IV
IV

instance A.ToJSON IV where
  toJSON :: IV -> Value
toJSON = String -> Value
forall a. ToJSON a => a -> Value
A.toJSON (String -> Value) -> (IV -> String) -> IV -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
forall a. Show a => a -> String
show (ByteString -> String) -> (IV -> ByteString) -> IV -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped IV -> IV) -> IV -> Unwrapped IV
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> IV
Unwrapped IV -> IV
IV

data DataType
  = BinaryData
  | TextData
  | UTF8Data
  | OtherData Word8
  deriving (Int -> DataType -> ShowS
[DataType] -> ShowS
DataType -> String
(Int -> DataType -> ShowS)
-> (DataType -> String) -> ([DataType] -> ShowS) -> Show DataType
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> DataType -> ShowS
showsPrec :: Int -> DataType -> ShowS
$cshow :: DataType -> String
show :: DataType -> String
$cshowList :: [DataType] -> ShowS
showList :: [DataType] -> ShowS
Show, Typeable DataType
Typeable DataType =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> DataType -> c DataType)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c DataType)
-> (DataType -> Constr)
-> (DataType -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c DataType))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataType))
-> ((forall b. Data b => b -> b) -> DataType -> DataType)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> DataType -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> DataType -> r)
-> (forall u. (forall d. Data d => d -> u) -> DataType -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> DataType -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> DataType -> m DataType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataType -> m DataType)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> DataType -> m DataType)
-> Data DataType
DataType -> Constr
DataType -> DataType
(forall b. Data b => b -> b) -> DataType -> DataType
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) -> DataType -> u
forall u. (forall d. Data d => d -> u) -> DataType -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataType -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataType -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataType
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataType -> c DataType
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataType)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataType)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataType -> c DataType
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> DataType -> c DataType
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataType
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c DataType
$ctoConstr :: DataType -> Constr
toConstr :: DataType -> Constr
$cdataTypeOf :: DataType -> DataType
dataTypeOf :: DataType -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataType)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c DataType)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataType)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c DataType)
$cgmapT :: (forall b. Data b => b -> b) -> DataType -> DataType
gmapT :: (forall b. Data b => b -> b) -> DataType -> DataType
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataType -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> DataType -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataType -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> DataType -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> DataType -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> DataType -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataType -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> DataType -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> DataType -> m DataType
Data, (forall x. DataType -> Rep DataType x)
-> (forall x. Rep DataType x -> DataType) -> Generic DataType
forall x. Rep DataType x -> DataType
forall x. DataType -> Rep DataType x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. DataType -> Rep DataType x
from :: forall x. DataType -> Rep DataType x
$cto :: forall x. Rep DataType x -> DataType
to :: forall x. Rep DataType x -> DataType
Generic, Typeable)

instance Hashable DataType

instance Eq DataType where
  == :: DataType -> DataType -> Bool
(==) DataType
a DataType
b = DataType -> Word8
forall a. FutureVal a => a -> Word8
fromFVal DataType
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== DataType -> Word8
forall a. FutureVal a => a -> Word8
fromFVal DataType
b

instance Ord DataType where
  compare :: DataType -> DataType -> Ordering
compare = (DataType -> Word8) -> DataType -> DataType -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing DataType -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal DataType where
  fromFVal :: DataType -> Word8
fromFVal DataType
BinaryData = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum (Char -> Word8) -> Char -> Word8
forall a b. (a -> b) -> a -> b
$ Char
'b'
  fromFVal DataType
TextData = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum (Char -> Word8) -> Char -> Word8
forall a b. (a -> b) -> a -> b
$ Char
't'
  fromFVal DataType
UTF8Data = Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Char -> Int) -> Char -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Char -> Int
forall a. Enum a => a -> Int
fromEnum (Char -> Word8) -> Char -> Word8
forall a b. (a -> b) -> a -> b
$ Char
'u'
  fromFVal (OtherData Word8
o) = Word8
o
  toFVal :: Word8 -> DataType
toFVal Word8
0x62 = DataType
BinaryData
  toFVal Word8
0x74 = DataType
TextData
  toFVal Word8
0x75 = DataType
UTF8Data
  toFVal Word8
o = Word8 -> DataType
OtherData Word8
o

instance Pretty DataType where
  pretty :: forall ann. DataType -> Doc ann
pretty DataType
BinaryData = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"binary"
  pretty DataType
TextData = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"text"
  pretty DataType
UTF8Data = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"UTF-8"
  pretty (OtherData Word8
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"other data type " Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
o

$(ATH.deriveJSON ATH.defaultOptions ''DataType)

newtype SessionKey =
  SessionKey
    { SessionKey -> ByteString
unSessionKey :: B.ByteString
    }
  deriving (Typeable SessionKey
Typeable SessionKey =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> SessionKey -> c SessionKey)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c SessionKey)
-> (SessionKey -> Constr)
-> (SessionKey -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c SessionKey))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c SessionKey))
-> ((forall b. Data b => b -> b) -> SessionKey -> SessionKey)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> SessionKey -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> SessionKey -> r)
-> (forall u. (forall d. Data d => d -> u) -> SessionKey -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> SessionKey -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> SessionKey -> m SessionKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SessionKey -> m SessionKey)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> SessionKey -> m SessionKey)
-> Data SessionKey
SessionKey -> Constr
SessionKey -> DataType
(forall b. Data b => b -> b) -> SessionKey -> SessionKey
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) -> SessionKey -> u
forall u. (forall d. Data d => d -> u) -> SessionKey -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SessionKey -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SessionKey -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SessionKey
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SessionKey -> c SessionKey
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SessionKey)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SessionKey)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SessionKey -> c SessionKey
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> SessionKey -> c SessionKey
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SessionKey
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c SessionKey
$ctoConstr :: SessionKey -> Constr
toConstr :: SessionKey -> Constr
$cdataTypeOf :: SessionKey -> DataType
dataTypeOf :: SessionKey -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SessionKey)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c SessionKey)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SessionKey)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c SessionKey)
$cgmapT :: (forall b. Data b => b -> b) -> SessionKey -> SessionKey
gmapT :: (forall b. Data b => b -> b) -> SessionKey -> SessionKey
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SessionKey -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> SessionKey -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SessionKey -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> SessionKey -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> SessionKey -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> SessionKey -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SessionKey -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> SessionKey -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> SessionKey -> m SessionKey
Data, SessionKey -> SessionKey -> Bool
(SessionKey -> SessionKey -> Bool)
-> (SessionKey -> SessionKey -> Bool) -> Eq SessionKey
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: SessionKey -> SessionKey -> Bool
== :: SessionKey -> SessionKey -> Bool
$c/= :: SessionKey -> SessionKey -> Bool
/= :: SessionKey -> SessionKey -> Bool
Eq, (forall x. SessionKey -> Rep SessionKey x)
-> (forall x. Rep SessionKey x -> SessionKey) -> Generic SessionKey
forall x. Rep SessionKey x -> SessionKey
forall x. SessionKey -> Rep SessionKey x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. SessionKey -> Rep SessionKey x
from :: forall x. SessionKey -> Rep SessionKey x
$cto :: forall x. Rep SessionKey x -> SessionKey
to :: forall x. Rep SessionKey x -> SessionKey
Generic, Eq SessionKey
Eq SessionKey =>
(Int -> SessionKey -> Int)
-> (SessionKey -> Int) -> Hashable SessionKey
Int -> SessionKey -> Int
SessionKey -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> SessionKey -> Int
hashWithSalt :: Int -> SessionKey -> Int
$chash :: SessionKey -> Int
hash :: SessionKey -> Int
Hashable, Int -> SessionKey -> ShowS
[SessionKey] -> ShowS
SessionKey -> String
(Int -> SessionKey -> ShowS)
-> (SessionKey -> String)
-> ([SessionKey] -> ShowS)
-> Show SessionKey
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> SessionKey -> ShowS
showsPrec :: Int -> SessionKey -> ShowS
$cshow :: SessionKey -> String
show :: SessionKey -> String
$cshowList :: [SessionKey] -> ShowS
showList :: [SessionKey] -> ShowS
Show, Typeable)

instance Wrapped SessionKey

instance Ord SessionKey where
  compare :: SessionKey -> SessionKey -> Ordering
compare (SessionKey ByteString
b1) (SessionKey ByteString
b2) = ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
b1 ByteString
b2

newtype Salt =
  Salt
    { Salt -> ByteString
unSalt :: B.ByteString
    }
  deriving (Typeable Salt
Typeable Salt =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Salt -> c Salt)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Salt)
-> (Salt -> Constr)
-> (Salt -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Salt))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt))
-> ((forall b. Data b => b -> b) -> Salt -> Salt)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r)
-> (forall u. (forall d. Data d => d -> u) -> Salt -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Salt -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Salt -> m Salt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Salt -> m Salt)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Salt -> m Salt)
-> Data Salt
Salt -> Constr
Salt -> DataType
(forall b. Data b => b -> b) -> Salt -> Salt
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) -> Salt -> u
forall u. (forall d. Data d => d -> u) -> Salt -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt -> c Salt
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt -> c Salt
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt -> c Salt
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt
$ctoConstr :: Salt -> Constr
toConstr :: Salt -> Constr
$cdataTypeOf :: Salt -> DataType
dataTypeOf :: Salt -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt)
$cgmapT :: (forall b. Data b => b -> b) -> Salt -> Salt
gmapT :: (forall b. Data b => b -> b) -> Salt -> Salt
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Salt -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Salt -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Salt -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Salt -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt -> m Salt
Data, Salt -> Salt -> Bool
(Salt -> Salt -> Bool) -> (Salt -> Salt -> Bool) -> Eq Salt
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Salt -> Salt -> Bool
== :: Salt -> Salt -> Bool
$c/= :: Salt -> Salt -> Bool
/= :: Salt -> Salt -> Bool
Eq, (forall x. Salt -> Rep Salt x)
-> (forall x. Rep Salt x -> Salt) -> Generic Salt
forall x. Rep Salt x -> Salt
forall x. Salt -> Rep Salt x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Salt -> Rep Salt x
from :: forall x. Salt -> Rep Salt x
$cto :: forall x. Rep Salt x -> Salt
to :: forall x. Rep Salt x -> Salt
Generic, Eq Salt
Eq Salt => (Int -> Salt -> Int) -> (Salt -> Int) -> Hashable Salt
Int -> Salt -> Int
Salt -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Salt -> Int
hashWithSalt :: Int -> Salt -> Int
$chash :: Salt -> Int
hash :: Salt -> Int
Hashable, Int -> Salt -> ShowS
[Salt] -> ShowS
Salt -> String
(Int -> Salt -> ShowS)
-> (Salt -> String) -> ([Salt] -> ShowS) -> Show Salt
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Salt -> ShowS
showsPrec :: Int -> Salt -> ShowS
$cshow :: Salt -> String
show :: Salt -> String
$cshowList :: [Salt] -> ShowS
showList :: [Salt] -> ShowS
Show, Typeable)

instance Wrapped Salt

instance Ord Salt where
  compare :: Salt -> Salt -> Ordering
compare (Salt ByteString
b1) (Salt ByteString
b2) = ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
b1 ByteString
b2

instance Pretty Salt where
  pretty :: forall ann. Salt -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> (Salt -> String) -> Salt -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"salt:" String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> (Salt -> String) -> Salt -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
bsToHexUpper (ByteString -> String) -> (Salt -> ByteString) -> Salt -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BL.fromStrict (ByteString -> ByteString)
-> (Salt -> ByteString) -> Salt -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Salt -> Salt) -> Salt -> Unwrapped Salt
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> Salt
Unwrapped Salt -> Salt
Salt

instance A.ToJSON Salt where
  toJSON :: Salt -> Value
toJSON = String -> Value
forall a. ToJSON a => a -> Value
A.toJSON (String -> Value) -> (Salt -> String) -> Salt -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
forall a. Show a => a -> String
show (ByteString -> String) -> (Salt -> ByteString) -> Salt -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Salt -> Salt) -> Salt -> Unwrapped Salt
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> Salt
Unwrapped Salt -> Salt
Salt

newtype Salt8 =
  Salt8
    { Salt8 -> ByteString
unSalt8 :: B.ByteString
    }
  deriving (Typeable Salt8
Typeable Salt8 =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Salt8 -> c Salt8)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Salt8)
-> (Salt8 -> Constr)
-> (Salt8 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Salt8))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt8))
-> ((forall b. Data b => b -> b) -> Salt8 -> Salt8)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Salt8 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Salt8 -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Salt8 -> m Salt8)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Salt8 -> m Salt8)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Salt8 -> m Salt8)
-> Data Salt8
Salt8 -> Constr
Salt8 -> DataType
(forall b. Data b => b -> b) -> Salt8 -> Salt8
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) -> Salt8 -> u
forall u. (forall d. Data d => d -> u) -> Salt8 -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt8
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt8 -> c Salt8
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt8)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt8)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt8 -> c Salt8
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt8 -> c Salt8
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt8
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt8
$ctoConstr :: Salt8 -> Constr
toConstr :: Salt8 -> Constr
$cdataTypeOf :: Salt8 -> DataType
dataTypeOf :: Salt8 -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt8)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt8)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt8)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt8)
$cgmapT :: (forall b. Data b => b -> b) -> Salt8 -> Salt8
gmapT :: (forall b. Data b => b -> b) -> Salt8 -> Salt8
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt8 -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Salt8 -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Salt8 -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Salt8 -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Salt8 -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt8 -> m Salt8
Data, Salt8 -> Salt8 -> Bool
(Salt8 -> Salt8 -> Bool) -> (Salt8 -> Salt8 -> Bool) -> Eq Salt8
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Salt8 -> Salt8 -> Bool
== :: Salt8 -> Salt8 -> Bool
$c/= :: Salt8 -> Salt8 -> Bool
/= :: Salt8 -> Salt8 -> Bool
Eq, (forall x. Salt8 -> Rep Salt8 x)
-> (forall x. Rep Salt8 x -> Salt8) -> Generic Salt8
forall x. Rep Salt8 x -> Salt8
forall x. Salt8 -> Rep Salt8 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Salt8 -> Rep Salt8 x
from :: forall x. Salt8 -> Rep Salt8 x
$cto :: forall x. Rep Salt8 x -> Salt8
to :: forall x. Rep Salt8 x -> Salt8
Generic, Eq Salt8
Eq Salt8 =>
(Int -> Salt8 -> Int) -> (Salt8 -> Int) -> Hashable Salt8
Int -> Salt8 -> Int
Salt8 -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Salt8 -> Int
hashWithSalt :: Int -> Salt8 -> Int
$chash :: Salt8 -> Int
hash :: Salt8 -> Int
Hashable, Int -> Salt8 -> ShowS
[Salt8] -> ShowS
Salt8 -> String
(Int -> Salt8 -> ShowS)
-> (Salt8 -> String) -> ([Salt8] -> ShowS) -> Show Salt8
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Salt8 -> ShowS
showsPrec :: Int -> Salt8 -> ShowS
$cshow :: Salt8 -> String
show :: Salt8 -> String
$cshowList :: [Salt8] -> ShowS
showList :: [Salt8] -> ShowS
Show, Typeable)

instance Wrapped Salt8

instance Ord Salt8 where
  compare :: Salt8 -> Salt8 -> Ordering
compare (Salt8 ByteString
b1) (Salt8 ByteString
b2) = ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
b1 ByteString
b2

instance Pretty Salt8 where
  pretty :: forall ann. Salt8 -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> (Salt8 -> String) -> Salt8 -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"salt8:" String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> (Salt8 -> String) -> Salt8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
bsToHexUpper (ByteString -> String) -> (Salt8 -> ByteString) -> Salt8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BL.fromStrict (ByteString -> ByteString)
-> (Salt8 -> ByteString) -> Salt8 -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Salt8 -> Salt8) -> Salt8 -> Unwrapped Salt8
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> Salt8
Unwrapped Salt8 -> Salt8
Salt8

instance A.ToJSON Salt8 where
  toJSON :: Salt8 -> Value
toJSON = String -> Value
forall a. ToJSON a => a -> Value
A.toJSON (String -> Value) -> (Salt8 -> String) -> Salt8 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
forall a. Show a => a -> String
show (ByteString -> String) -> (Salt8 -> ByteString) -> Salt8 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Salt8 -> Salt8) -> Salt8 -> Unwrapped Salt8
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> Salt8
Unwrapped Salt8 -> Salt8
Salt8

newtype Salt16 =
  Salt16
    { Salt16 -> ByteString
unSalt16 :: B.ByteString
    }
  deriving (Typeable Salt16
Typeable Salt16 =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Salt16 -> c Salt16)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Salt16)
-> (Salt16 -> Constr)
-> (Salt16 -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Salt16))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt16))
-> ((forall b. Data b => b -> b) -> Salt16 -> Salt16)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> Salt16 -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> Salt16 -> r)
-> (forall u. (forall d. Data d => d -> u) -> Salt16 -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Salt16 -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Salt16 -> m Salt16)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Salt16 -> m Salt16)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Salt16 -> m Salt16)
-> Data Salt16
Salt16 -> Constr
Salt16 -> DataType
(forall b. Data b => b -> b) -> Salt16 -> Salt16
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) -> Salt16 -> u
forall u. (forall d. Data d => d -> u) -> Salt16 -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt16 -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt16 -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt16
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt16 -> c Salt16
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt16)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt16)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt16 -> c Salt16
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Salt16 -> c Salt16
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt16
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Salt16
$ctoConstr :: Salt16 -> Constr
toConstr :: Salt16 -> Constr
$cdataTypeOf :: Salt16 -> DataType
dataTypeOf :: Salt16 -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt16)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Salt16)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt16)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Salt16)
$cgmapT :: (forall b. Data b => b -> b) -> Salt16 -> Salt16
gmapT :: (forall b. Data b => b -> b) -> Salt16 -> Salt16
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt16 -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Salt16 -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt16 -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Salt16 -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Salt16 -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Salt16 -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Salt16 -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Salt16 -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Salt16 -> m Salt16
Data, Salt16 -> Salt16 -> Bool
(Salt16 -> Salt16 -> Bool)
-> (Salt16 -> Salt16 -> Bool) -> Eq Salt16
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Salt16 -> Salt16 -> Bool
== :: Salt16 -> Salt16 -> Bool
$c/= :: Salt16 -> Salt16 -> Bool
/= :: Salt16 -> Salt16 -> Bool
Eq, (forall x. Salt16 -> Rep Salt16 x)
-> (forall x. Rep Salt16 x -> Salt16) -> Generic Salt16
forall x. Rep Salt16 x -> Salt16
forall x. Salt16 -> Rep Salt16 x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Salt16 -> Rep Salt16 x
from :: forall x. Salt16 -> Rep Salt16 x
$cto :: forall x. Rep Salt16 x -> Salt16
to :: forall x. Rep Salt16 x -> Salt16
Generic, Eq Salt16
Eq Salt16 =>
(Int -> Salt16 -> Int) -> (Salt16 -> Int) -> Hashable Salt16
Int -> Salt16 -> Int
Salt16 -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Salt16 -> Int
hashWithSalt :: Int -> Salt16 -> Int
$chash :: Salt16 -> Int
hash :: Salt16 -> Int
Hashable, Int -> Salt16 -> ShowS
[Salt16] -> ShowS
Salt16 -> String
(Int -> Salt16 -> ShowS)
-> (Salt16 -> String) -> ([Salt16] -> ShowS) -> Show Salt16
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Salt16 -> ShowS
showsPrec :: Int -> Salt16 -> ShowS
$cshow :: Salt16 -> String
show :: Salt16 -> String
$cshowList :: [Salt16] -> ShowS
showList :: [Salt16] -> ShowS
Show, Typeable)

instance Wrapped Salt16

instance Ord Salt16 where
  compare :: Salt16 -> Salt16 -> Ordering
compare (Salt16 ByteString
b1) (Salt16 ByteString
b2) = ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
b1 ByteString
b2

instance Pretty Salt16 where
  pretty :: forall ann. Salt16 -> Doc ann
pretty = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (String -> Doc ann) -> (Salt16 -> String) -> Salt16 -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (String
"salt16:" String -> ShowS
forall a. [a] -> [a] -> [a]
++) ShowS -> (Salt16 -> String) -> Salt16 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
bsToHexUpper (ByteString -> String)
-> (Salt16 -> ByteString) -> Salt16 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> ByteString
BL.fromStrict (ByteString -> ByteString)
-> (Salt16 -> ByteString) -> Salt16 -> ByteString
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Salt16 -> Salt16) -> Salt16 -> Unwrapped Salt16
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> Salt16
Unwrapped Salt16 -> Salt16
Salt16

instance A.ToJSON Salt16 where
  toJSON :: Salt16 -> Value
toJSON = String -> Value
forall a. ToJSON a => a -> Value
A.toJSON (String -> Value) -> (Salt16 -> String) -> Salt16 -> Value
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ByteString -> String
forall a. Show a => a -> String
show (ByteString -> String)
-> (Salt16 -> ByteString) -> Salt16 -> String
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped Salt16 -> Salt16) -> Salt16 -> Unwrapped Salt16
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op ByteString -> Salt16
Unwrapped Salt16 -> Salt16
Salt16

salt8FromSalt :: Salt -> Maybe Salt8
salt8FromSalt :: Salt -> Maybe Salt8
salt8FromSalt (Salt ByteString
bs)
  | ByteString -> Int
B.length ByteString
bs Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
8 = Salt8 -> Maybe Salt8
forall a. a -> Maybe a
Just (ByteString -> Salt8
Salt8 ByteString
bs)
  | Bool
otherwise = Maybe Salt8
forall a. Maybe a
Nothing

salt16FromSalt :: Salt -> Maybe Salt16
salt16FromSalt :: Salt -> Maybe Salt16
salt16FromSalt (Salt ByteString
bs)
  | ByteString -> Int
B.length ByteString
bs Int -> Int -> Bool
forall a. Eq a => a -> a -> Bool
== Int
16 = Salt16 -> Maybe Salt16
forall a. a -> Maybe a
Just (ByteString -> Salt16
Salt16 ByteString
bs)
  | Bool
otherwise = Maybe Salt16
forall a. Maybe a
Nothing

saltFromSalt8 :: Salt8 -> Salt
saltFromSalt8 :: Salt8 -> Salt
saltFromSalt8 (Salt8 ByteString
bs) = ByteString -> Salt
Salt ByteString
bs

saltFromSalt16 :: Salt16 -> Salt
saltFromSalt16 :: Salt16 -> Salt
saltFromSalt16 (Salt16 ByteString
bs) = ByteString -> Salt
Salt ByteString
bs

newtype IterationCount =
  IterationCount
    { IterationCount -> Int
unIterationCount :: Int
    }
  deriving ( IterationCount
IterationCount -> IterationCount -> Bounded IterationCount
forall a. a -> a -> Bounded a
$cminBound :: IterationCount
minBound :: IterationCount
$cmaxBound :: IterationCount
maxBound :: IterationCount
Bounded
           , Typeable IterationCount
Typeable IterationCount =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> IterationCount -> c IterationCount)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c IterationCount)
-> (IterationCount -> Constr)
-> (IterationCount -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c IterationCount))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c IterationCount))
-> ((forall b. Data b => b -> b)
    -> IterationCount -> IterationCount)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> IterationCount -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> IterationCount -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> IterationCount -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> IterationCount -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> IterationCount -> m IterationCount)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IterationCount -> m IterationCount)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> IterationCount -> m IterationCount)
-> Data IterationCount
IterationCount -> Constr
IterationCount -> DataType
(forall b. Data b => b -> b) -> IterationCount -> IterationCount
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) -> IterationCount -> u
forall u. (forall d. Data d => d -> u) -> IterationCount -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IterationCount -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IterationCount -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IterationCount
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IterationCount -> c IterationCount
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IterationCount)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IterationCount)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IterationCount -> c IterationCount
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> IterationCount -> c IterationCount
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IterationCount
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c IterationCount
$ctoConstr :: IterationCount -> Constr
toConstr :: IterationCount -> Constr
$cdataTypeOf :: IterationCount -> DataType
dataTypeOf :: IterationCount -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IterationCount)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c IterationCount)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IterationCount)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c IterationCount)
$cgmapT :: (forall b. Data b => b -> b) -> IterationCount -> IterationCount
gmapT :: (forall b. Data b => b -> b) -> IterationCount -> IterationCount
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IterationCount -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> IterationCount -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IterationCount -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> IterationCount -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> IterationCount -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> IterationCount -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IterationCount -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> IterationCount -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> IterationCount -> m IterationCount
Data
           , Int -> IterationCount
IterationCount -> Int
IterationCount -> [IterationCount]
IterationCount -> IterationCount
IterationCount -> IterationCount -> [IterationCount]
IterationCount
-> IterationCount -> IterationCount -> [IterationCount]
(IterationCount -> IterationCount)
-> (IterationCount -> IterationCount)
-> (Int -> IterationCount)
-> (IterationCount -> Int)
-> (IterationCount -> [IterationCount])
-> (IterationCount -> IterationCount -> [IterationCount])
-> (IterationCount -> IterationCount -> [IterationCount])
-> (IterationCount
    -> IterationCount -> IterationCount -> [IterationCount])
-> Enum IterationCount
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: IterationCount -> IterationCount
succ :: IterationCount -> IterationCount
$cpred :: IterationCount -> IterationCount
pred :: IterationCount -> IterationCount
$ctoEnum :: Int -> IterationCount
toEnum :: Int -> IterationCount
$cfromEnum :: IterationCount -> Int
fromEnum :: IterationCount -> Int
$cenumFrom :: IterationCount -> [IterationCount]
enumFrom :: IterationCount -> [IterationCount]
$cenumFromThen :: IterationCount -> IterationCount -> [IterationCount]
enumFromThen :: IterationCount -> IterationCount -> [IterationCount]
$cenumFromTo :: IterationCount -> IterationCount -> [IterationCount]
enumFromTo :: IterationCount -> IterationCount -> [IterationCount]
$cenumFromThenTo :: IterationCount
-> IterationCount -> IterationCount -> [IterationCount]
enumFromThenTo :: IterationCount
-> IterationCount -> IterationCount -> [IterationCount]
Enum
           , IterationCount -> IterationCount -> Bool
(IterationCount -> IterationCount -> Bool)
-> (IterationCount -> IterationCount -> Bool) -> Eq IterationCount
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: IterationCount -> IterationCount -> Bool
== :: IterationCount -> IterationCount -> Bool
$c/= :: IterationCount -> IterationCount -> Bool
/= :: IterationCount -> IterationCount -> Bool
Eq
           , (forall x. IterationCount -> Rep IterationCount x)
-> (forall x. Rep IterationCount x -> IterationCount)
-> Generic IterationCount
forall x. Rep IterationCount x -> IterationCount
forall x. IterationCount -> Rep IterationCount x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. IterationCount -> Rep IterationCount x
from :: forall x. IterationCount -> Rep IterationCount x
$cto :: forall x. Rep IterationCount x -> IterationCount
to :: forall x. Rep IterationCount x -> IterationCount
Generic
           , Eq IterationCount
Eq IterationCount =>
(Int -> IterationCount -> Int)
-> (IterationCount -> Int) -> Hashable IterationCount
Int -> IterationCount -> Int
IterationCount -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> IterationCount -> Int
hashWithSalt :: Int -> IterationCount -> Int
$chash :: IterationCount -> Int
hash :: IterationCount -> Int
Hashable
           , Enum IterationCount
Real IterationCount
(Real IterationCount, Enum IterationCount) =>
(IterationCount -> IterationCount -> IterationCount)
-> (IterationCount -> IterationCount -> IterationCount)
-> (IterationCount -> IterationCount -> IterationCount)
-> (IterationCount -> IterationCount -> IterationCount)
-> (IterationCount
    -> IterationCount -> (IterationCount, IterationCount))
-> (IterationCount
    -> IterationCount -> (IterationCount, IterationCount))
-> (IterationCount -> Integer)
-> Integral IterationCount
IterationCount -> Integer
IterationCount
-> IterationCount -> (IterationCount, IterationCount)
IterationCount -> IterationCount -> IterationCount
forall a.
(Real a, Enum a) =>
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> (a, a))
-> (a -> a -> (a, a))
-> (a -> Integer)
-> Integral a
$cquot :: IterationCount -> IterationCount -> IterationCount
quot :: IterationCount -> IterationCount -> IterationCount
$crem :: IterationCount -> IterationCount -> IterationCount
rem :: IterationCount -> IterationCount -> IterationCount
$cdiv :: IterationCount -> IterationCount -> IterationCount
div :: IterationCount -> IterationCount -> IterationCount
$cmod :: IterationCount -> IterationCount -> IterationCount
mod :: IterationCount -> IterationCount -> IterationCount
$cquotRem :: IterationCount
-> IterationCount -> (IterationCount, IterationCount)
quotRem :: IterationCount
-> IterationCount -> (IterationCount, IterationCount)
$cdivMod :: IterationCount
-> IterationCount -> (IterationCount, IterationCount)
divMod :: IterationCount
-> IterationCount -> (IterationCount, IterationCount)
$ctoInteger :: IterationCount -> Integer
toInteger :: IterationCount -> Integer
Integral
           , Integer -> IterationCount
IterationCount -> IterationCount
IterationCount -> IterationCount -> IterationCount
(IterationCount -> IterationCount -> IterationCount)
-> (IterationCount -> IterationCount -> IterationCount)
-> (IterationCount -> IterationCount -> IterationCount)
-> (IterationCount -> IterationCount)
-> (IterationCount -> IterationCount)
-> (IterationCount -> IterationCount)
-> (Integer -> IterationCount)
-> Num IterationCount
forall a.
(a -> a -> a)
-> (a -> a -> a)
-> (a -> a -> a)
-> (a -> a)
-> (a -> a)
-> (a -> a)
-> (Integer -> a)
-> Num a
$c+ :: IterationCount -> IterationCount -> IterationCount
+ :: IterationCount -> IterationCount -> IterationCount
$c- :: IterationCount -> IterationCount -> IterationCount
- :: IterationCount -> IterationCount -> IterationCount
$c* :: IterationCount -> IterationCount -> IterationCount
* :: IterationCount -> IterationCount -> IterationCount
$cnegate :: IterationCount -> IterationCount
negate :: IterationCount -> IterationCount
$cabs :: IterationCount -> IterationCount
abs :: IterationCount -> IterationCount
$csignum :: IterationCount -> IterationCount
signum :: IterationCount -> IterationCount
$cfromInteger :: Integer -> IterationCount
fromInteger :: Integer -> IterationCount
Num
           , Eq IterationCount
Eq IterationCount =>
(IterationCount -> IterationCount -> Ordering)
-> (IterationCount -> IterationCount -> Bool)
-> (IterationCount -> IterationCount -> Bool)
-> (IterationCount -> IterationCount -> Bool)
-> (IterationCount -> IterationCount -> Bool)
-> (IterationCount -> IterationCount -> IterationCount)
-> (IterationCount -> IterationCount -> IterationCount)
-> Ord IterationCount
IterationCount -> IterationCount -> Bool
IterationCount -> IterationCount -> Ordering
IterationCount -> IterationCount -> IterationCount
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: IterationCount -> IterationCount -> Ordering
compare :: IterationCount -> IterationCount -> Ordering
$c< :: IterationCount -> IterationCount -> Bool
< :: IterationCount -> IterationCount -> Bool
$c<= :: IterationCount -> IterationCount -> Bool
<= :: IterationCount -> IterationCount -> Bool
$c> :: IterationCount -> IterationCount -> Bool
> :: IterationCount -> IterationCount -> Bool
$c>= :: IterationCount -> IterationCount -> Bool
>= :: IterationCount -> IterationCount -> Bool
$cmax :: IterationCount -> IterationCount -> IterationCount
max :: IterationCount -> IterationCount -> IterationCount
$cmin :: IterationCount -> IterationCount -> IterationCount
min :: IterationCount -> IterationCount -> IterationCount
Ord
           , Num IterationCount
Ord IterationCount
(Num IterationCount, Ord IterationCount) =>
(IterationCount -> Rational) -> Real IterationCount
IterationCount -> Rational
forall a. (Num a, Ord a) => (a -> Rational) -> Real a
$ctoRational :: IterationCount -> Rational
toRational :: IterationCount -> Rational
Real
           , Int -> IterationCount -> ShowS
[IterationCount] -> ShowS
IterationCount -> String
(Int -> IterationCount -> ShowS)
-> (IterationCount -> String)
-> ([IterationCount] -> ShowS)
-> Show IterationCount
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> IterationCount -> ShowS
showsPrec :: Int -> IterationCount -> ShowS
$cshow :: IterationCount -> String
show :: IterationCount -> String
$cshowList :: [IterationCount] -> ShowS
showList :: [IterationCount] -> ShowS
Show
           , Typeable
           )

instance Wrapped IterationCount

instance Pretty IterationCount where
  pretty :: forall ann. IterationCount -> Doc ann
pretty = Int -> Doc ann
forall ann. Int -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (Int -> Doc ann)
-> (IterationCount -> Int) -> IterationCount -> Doc ann
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Unwrapped IterationCount -> IterationCount)
-> IterationCount -> Unwrapped IterationCount
forall s. Wrapped s => (Unwrapped s -> s) -> s -> Unwrapped s
op Int -> IterationCount
Unwrapped IterationCount -> IterationCount
IterationCount

$(ATH.deriveJSON ATH.defaultOptions ''IterationCount)

data S2K
  = Simple HashAlgorithm
  | Salted HashAlgorithm Salt8
  | IteratedSalted HashAlgorithm Salt8 IterationCount
  | Argon2 Salt16 Word8 Word8 Word8
  | OtherS2K Word8 ByteString
  deriving (Typeable S2K
Typeable S2K =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> S2K -> c S2K)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c S2K)
-> (S2K -> Constr)
-> (S2K -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c S2K))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c S2K))
-> ((forall b. Data b => b -> b) -> S2K -> S2K)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r)
-> (forall u. (forall d. Data d => d -> u) -> S2K -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> S2K -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> S2K -> m S2K)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> S2K -> m S2K)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> S2K -> m S2K)
-> Data S2K
S2K -> Constr
S2K -> DataType
(forall b. Data b => b -> b) -> S2K -> S2K
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) -> S2K -> u
forall u. (forall d. Data d => d -> u) -> S2K -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c S2K
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> S2K -> c S2K
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c S2K)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c S2K)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> S2K -> c S2K
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> S2K -> c S2K
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c S2K
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c S2K
$ctoConstr :: S2K -> Constr
toConstr :: S2K -> Constr
$cdataTypeOf :: S2K -> DataType
dataTypeOf :: S2K -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c S2K)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c S2K)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c S2K)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c S2K)
$cgmapT :: (forall b. Data b => b -> b) -> S2K -> S2K
gmapT :: (forall b. Data b => b -> b) -> S2K -> S2K
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> S2K -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> S2K -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> S2K -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> S2K -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> S2K -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> S2K -> m S2K
Data, S2K -> S2K -> Bool
(S2K -> S2K -> Bool) -> (S2K -> S2K -> Bool) -> Eq S2K
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: S2K -> S2K -> Bool
== :: S2K -> S2K -> Bool
$c/= :: S2K -> S2K -> Bool
/= :: S2K -> S2K -> Bool
Eq, (forall x. S2K -> Rep S2K x)
-> (forall x. Rep S2K x -> S2K) -> Generic S2K
forall x. Rep S2K x -> S2K
forall x. S2K -> Rep S2K x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. S2K -> Rep S2K x
from :: forall x. S2K -> Rep S2K x
$cto :: forall x. Rep S2K x -> S2K
to :: forall x. Rep S2K x -> S2K
Generic, Int -> S2K -> ShowS
[S2K] -> ShowS
S2K -> String
(Int -> S2K -> ShowS)
-> (S2K -> String) -> ([S2K] -> ShowS) -> Show S2K
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> S2K -> ShowS
showsPrec :: Int -> S2K -> ShowS
$cshow :: S2K -> String
show :: S2K -> String
$cshowList :: [S2K] -> ShowS
showList :: [S2K] -> ShowS
Show, Typeable)

instance Hashable S2K

instance Ord S2K where
  compare :: S2K -> S2K -> Ordering
compare (Simple HashAlgorithm
ha1) (Simple HashAlgorithm
ha2) = HashAlgorithm -> HashAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare HashAlgorithm
ha1 HashAlgorithm
ha2
  compare (Salted HashAlgorithm
ha1 Salt8
s1) (Salted HashAlgorithm
ha2 Salt8
s2) = HashAlgorithm -> HashAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare HashAlgorithm
ha1 HashAlgorithm
ha2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Salt8 -> Salt8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Salt8
s1 Salt8
s2
  compare (IteratedSalted HashAlgorithm
ha1 Salt8
s1 IterationCount
ic1) (IteratedSalted HashAlgorithm
ha2 Salt8
s2 IterationCount
ic2) =
    HashAlgorithm -> HashAlgorithm -> Ordering
forall a. Ord a => a -> a -> Ordering
compare HashAlgorithm
ha1 HashAlgorithm
ha2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Salt8 -> Salt8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Salt8
s1 Salt8
s2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> IterationCount -> IterationCount -> Ordering
forall a. Ord a => a -> a -> Ordering
compare IterationCount
ic1 IterationCount
ic2
  compare (Argon2 Salt16
salt1 Word8
t1 Word8
p1 Word8
em1) (Argon2 Salt16
salt2 Word8
t2 Word8
p2 Word8
em2) =
    Salt16 -> Salt16 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Salt16
salt1 Salt16
salt2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Word8 -> Word8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word8
t1 Word8
t2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Word8 -> Word8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word8
p1 Word8
p2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> Word8 -> Word8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word8
em1 Word8
em2
  compare (OtherS2K Word8
t1 ByteString
bs1) (OtherS2K Word8
t2 ByteString
bs2) = Word8 -> Word8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word8
t1 Word8
t2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
bs1 ByteString
bs2
  compare Simple {} Salted {} = Ordering
LT
  compare Simple {} IteratedSalted {} = Ordering
LT
  compare Simple {} Argon2 {} = Ordering
LT
  compare Simple {} OtherS2K {} = Ordering
LT
  compare Salted {} Simple {} = Ordering
GT
  compare Salted {} IteratedSalted {} = Ordering
LT
  compare Salted {} Argon2 {} = Ordering
LT
  compare Salted {} OtherS2K {} = Ordering
LT
  compare IteratedSalted {} Simple {} = Ordering
GT
  compare IteratedSalted {} Salted {} = Ordering
GT
  compare IteratedSalted {} Argon2 {} = Ordering
LT
  compare IteratedSalted {} OtherS2K {} = Ordering
LT
  compare Argon2 {} Simple {} = Ordering
GT
  compare Argon2 {} Salted {} = Ordering
GT
  compare Argon2 {} IteratedSalted {} = Ordering
GT
  compare Argon2 {} OtherS2K {} = Ordering
LT
  compare OtherS2K {} S2K
_ = Ordering
GT

instance Pretty S2K where
  pretty :: forall ann. S2K -> Doc ann
pretty (Simple HashAlgorithm
ha) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"simple S2K," Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
ha
  pretty (Salted HashAlgorithm
ha Salt8
salt) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"salted S2K," Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
ha Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Salt8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Salt8 -> Doc ann
pretty Salt8
salt
  pretty (IteratedSalted HashAlgorithm
ha Salt8
salt IterationCount
icount) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"iterated-salted S2K," Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    HashAlgorithm -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. HashAlgorithm -> Doc ann
pretty HashAlgorithm
ha Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Salt8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Salt8 -> Doc ann
pretty Salt8
salt Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> IterationCount -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. IterationCount -> Doc ann
pretty IterationCount
icount
  pretty (Argon2 Salt16
salt Word8
t Word8
p Word8
em) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Argon2 S2K," Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+>
    Salt16 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. Salt16 -> Doc ann
pretty Salt16
salt Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
p Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
em
  pretty (OtherS2K Word8
t ByteString
bs) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown S2K type" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> String
bsToHexUpper ByteString
bs)

instance A.ToJSON S2K where
  toJSON :: S2K -> Value
toJSON (Simple HashAlgorithm
ha) = HashAlgorithm -> Value
forall a. ToJSON a => a -> Value
A.toJSON HashAlgorithm
ha
  toJSON (Salted HashAlgorithm
ha Salt8
salt) = (HashAlgorithm, Salt8) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (HashAlgorithm
ha, Salt8
salt)
  toJSON (IteratedSalted HashAlgorithm
ha Salt8
salt IterationCount
icount) = (HashAlgorithm, Salt8, IterationCount) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (HashAlgorithm
ha, Salt8
salt, IterationCount
icount)
  toJSON (Argon2 Salt16
salt Word8
t Word8
p Word8
em) = (Salt16, Word8, Word8, Word8) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Salt16
salt, Word8
t, Word8
p, Word8
em)
  toJSON (OtherS2K Word8
t ByteString
bs) = (Word8, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Word8
t, ByteString -> [Word8]
BL.unpack ByteString
bs)

data ImageFormat
  = JPEG
  | OtherImage Word8
  deriving (Typeable ImageFormat
Typeable ImageFormat =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ImageFormat -> c ImageFormat)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImageFormat)
-> (ImageFormat -> Constr)
-> (ImageFormat -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImageFormat))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImageFormat))
-> ((forall b. Data b => b -> b) -> ImageFormat -> ImageFormat)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImageFormat -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImageFormat -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImageFormat -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImageFormat -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat)
-> Data ImageFormat
ImageFormat -> Constr
ImageFormat -> DataType
(forall b. Data b => b -> b) -> ImageFormat -> ImageFormat
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) -> ImageFormat -> u
forall u. (forall d. Data d => d -> u) -> ImageFormat -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImageFormat -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImageFormat -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImageFormat
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImageFormat -> c ImageFormat
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImageFormat)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImageFormat)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImageFormat -> c ImageFormat
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImageFormat -> c ImageFormat
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImageFormat
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImageFormat
$ctoConstr :: ImageFormat -> Constr
toConstr :: ImageFormat -> Constr
$cdataTypeOf :: ImageFormat -> DataType
dataTypeOf :: ImageFormat -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImageFormat)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImageFormat)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImageFormat)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImageFormat)
$cgmapT :: (forall b. Data b => b -> b) -> ImageFormat -> ImageFormat
gmapT :: (forall b. Data b => b -> b) -> ImageFormat -> ImageFormat
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImageFormat -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImageFormat -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImageFormat -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImageFormat -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImageFormat -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImageFormat -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImageFormat -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImageFormat -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageFormat -> m ImageFormat
Data, (forall x. ImageFormat -> Rep ImageFormat x)
-> (forall x. Rep ImageFormat x -> ImageFormat)
-> Generic ImageFormat
forall x. Rep ImageFormat x -> ImageFormat
forall x. ImageFormat -> Rep ImageFormat x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImageFormat -> Rep ImageFormat x
from :: forall x. ImageFormat -> Rep ImageFormat x
$cto :: forall x. Rep ImageFormat x -> ImageFormat
to :: forall x. Rep ImageFormat x -> ImageFormat
Generic, Int -> ImageFormat -> ShowS
[ImageFormat] -> ShowS
ImageFormat -> String
(Int -> ImageFormat -> ShowS)
-> (ImageFormat -> String)
-> ([ImageFormat] -> ShowS)
-> Show ImageFormat
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImageFormat -> ShowS
showsPrec :: Int -> ImageFormat -> ShowS
$cshow :: ImageFormat -> String
show :: ImageFormat -> String
$cshowList :: [ImageFormat] -> ShowS
showList :: [ImageFormat] -> ShowS
Show, Typeable)

instance Eq ImageFormat where
  == :: ImageFormat -> ImageFormat -> Bool
(==) ImageFormat
a ImageFormat
b = ImageFormat -> Word8
forall a. FutureVal a => a -> Word8
fromFVal ImageFormat
a Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== ImageFormat -> Word8
forall a. FutureVal a => a -> Word8
fromFVal ImageFormat
b

instance Ord ImageFormat where
  compare :: ImageFormat -> ImageFormat -> Ordering
compare = (ImageFormat -> Word8) -> ImageFormat -> ImageFormat -> Ordering
forall a b. Ord a => (b -> a) -> b -> b -> Ordering
comparing ImageFormat -> Word8
forall a. FutureVal a => a -> Word8
fromFVal

instance FutureVal ImageFormat where
  fromFVal :: ImageFormat -> Word8
fromFVal ImageFormat
JPEG = Word8
1
  fromFVal (OtherImage Word8
o) = Word8
o
  toFVal :: Word8 -> ImageFormat
toFVal Word8
1 = ImageFormat
JPEG
  toFVal Word8
o = Word8 -> ImageFormat
OtherImage Word8
o

instance Hashable ImageFormat

instance Pretty ImageFormat where
  pretty :: forall ann. ImageFormat -> Doc ann
pretty ImageFormat
JPEG = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"JPEG"
  pretty (OtherImage Word8
o) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown image format" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
o

$(ATH.deriveJSON ATH.defaultOptions ''ImageFormat)

newtype ImageHeader =
  ImageHV1 ImageFormat
  deriving (Typeable ImageHeader
Typeable ImageHeader =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ImageHeader -> c ImageHeader)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ImageHeader)
-> (ImageHeader -> Constr)
-> (ImageHeader -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ImageHeader))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c ImageHeader))
-> ((forall b. Data b => b -> b) -> ImageHeader -> ImageHeader)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ImageHeader -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ImageHeader -> r)
-> (forall u. (forall d. Data d => d -> u) -> ImageHeader -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> ImageHeader -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader)
-> Data ImageHeader
ImageHeader -> Constr
ImageHeader -> DataType
(forall b. Data b => b -> b) -> ImageHeader -> ImageHeader
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) -> ImageHeader -> u
forall u. (forall d. Data d => d -> u) -> ImageHeader -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImageHeader -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImageHeader -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImageHeader
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImageHeader -> c ImageHeader
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImageHeader)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImageHeader)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImageHeader -> c ImageHeader
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ImageHeader -> c ImageHeader
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImageHeader
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ImageHeader
$ctoConstr :: ImageHeader -> Constr
toConstr :: ImageHeader -> Constr
$cdataTypeOf :: ImageHeader -> DataType
dataTypeOf :: ImageHeader -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImageHeader)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ImageHeader)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImageHeader)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c ImageHeader)
$cgmapT :: (forall b. Data b => b -> b) -> ImageHeader -> ImageHeader
gmapT :: (forall b. Data b => b -> b) -> ImageHeader -> ImageHeader
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImageHeader -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ImageHeader -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImageHeader -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ImageHeader -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ImageHeader -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ImageHeader -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImageHeader -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ImageHeader -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ImageHeader -> m ImageHeader
Data, ImageHeader -> ImageHeader -> Bool
(ImageHeader -> ImageHeader -> Bool)
-> (ImageHeader -> ImageHeader -> Bool) -> Eq ImageHeader
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ImageHeader -> ImageHeader -> Bool
== :: ImageHeader -> ImageHeader -> Bool
$c/= :: ImageHeader -> ImageHeader -> Bool
/= :: ImageHeader -> ImageHeader -> Bool
Eq, (forall x. ImageHeader -> Rep ImageHeader x)
-> (forall x. Rep ImageHeader x -> ImageHeader)
-> Generic ImageHeader
forall x. Rep ImageHeader x -> ImageHeader
forall x. ImageHeader -> Rep ImageHeader x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ImageHeader -> Rep ImageHeader x
from :: forall x. ImageHeader -> Rep ImageHeader x
$cto :: forall x. Rep ImageHeader x -> ImageHeader
to :: forall x. Rep ImageHeader x -> ImageHeader
Generic, Int -> ImageHeader -> ShowS
[ImageHeader] -> ShowS
ImageHeader -> String
(Int -> ImageHeader -> ShowS)
-> (ImageHeader -> String)
-> ([ImageHeader] -> ShowS)
-> Show ImageHeader
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ImageHeader -> ShowS
showsPrec :: Int -> ImageHeader -> ShowS
$cshow :: ImageHeader -> String
show :: ImageHeader -> String
$cshowList :: [ImageHeader] -> ShowS
showList :: [ImageHeader] -> ShowS
Show, Typeable)

instance Ord ImageHeader where
  compare :: ImageHeader -> ImageHeader -> Ordering
compare (ImageHV1 ImageFormat
a) (ImageHV1 ImageFormat
b) = ImageFormat -> ImageFormat -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ImageFormat
a ImageFormat
b

instance Hashable ImageHeader

instance Pretty ImageHeader where
  pretty :: forall ann. ImageHeader -> Doc ann
pretty (ImageHV1 ImageFormat
f) = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"imghdr v1" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ImageFormat -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ImageFormat -> Doc ann
pretty ImageFormat
f

$(ATH.deriveJSON ATH.defaultOptions ''ImageHeader)

data UserAttrSubPacket
  = ImageAttribute ImageHeader ImageData
  | OtherUASub Word8 ByteString
  deriving (Typeable UserAttrSubPacket
Typeable UserAttrSubPacket =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g)
 -> UserAttrSubPacket
 -> c UserAttrSubPacket)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c UserAttrSubPacket)
-> (UserAttrSubPacket -> Constr)
-> (UserAttrSubPacket -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c UserAttrSubPacket))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e))
    -> Maybe (c UserAttrSubPacket))
-> ((forall b. Data b => b -> b)
    -> UserAttrSubPacket -> UserAttrSubPacket)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r)
-> (forall u.
    (forall d. Data d => d -> u) -> UserAttrSubPacket -> [u])
-> (forall u.
    Int -> (forall d. Data d => d -> u) -> UserAttrSubPacket -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d)
    -> UserAttrSubPacket -> m UserAttrSubPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UserAttrSubPacket -> m UserAttrSubPacket)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d)
    -> UserAttrSubPacket -> m UserAttrSubPacket)
-> Data UserAttrSubPacket
UserAttrSubPacket -> Constr
UserAttrSubPacket -> DataType
(forall b. Data b => b -> b)
-> UserAttrSubPacket -> UserAttrSubPacket
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) -> UserAttrSubPacket -> u
forall u. (forall d. Data d => d -> u) -> UserAttrSubPacket -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserAttrSubPacket
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserAttrSubPacket -> c UserAttrSubPacket
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UserAttrSubPacket)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UserAttrSubPacket)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserAttrSubPacket -> c UserAttrSubPacket
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> UserAttrSubPacket -> c UserAttrSubPacket
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserAttrSubPacket
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c UserAttrSubPacket
$ctoConstr :: UserAttrSubPacket -> Constr
toConstr :: UserAttrSubPacket -> Constr
$cdataTypeOf :: UserAttrSubPacket -> DataType
dataTypeOf :: UserAttrSubPacket -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UserAttrSubPacket)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c UserAttrSubPacket)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UserAttrSubPacket)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e))
-> Maybe (c UserAttrSubPacket)
$cgmapT :: (forall b. Data b => b -> b)
-> UserAttrSubPacket -> UserAttrSubPacket
gmapT :: (forall b. Data b => b -> b)
-> UserAttrSubPacket -> UserAttrSubPacket
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> UserAttrSubPacket -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> UserAttrSubPacket -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> UserAttrSubPacket -> [u]
$cgmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> UserAttrSubPacket -> u
gmapQi :: forall u.
Int -> (forall d. Data d => d -> u) -> UserAttrSubPacket -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d)
-> UserAttrSubPacket -> m UserAttrSubPacket
Data, UserAttrSubPacket -> UserAttrSubPacket -> Bool
(UserAttrSubPacket -> UserAttrSubPacket -> Bool)
-> (UserAttrSubPacket -> UserAttrSubPacket -> Bool)
-> Eq UserAttrSubPacket
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: UserAttrSubPacket -> UserAttrSubPacket -> Bool
== :: UserAttrSubPacket -> UserAttrSubPacket -> Bool
$c/= :: UserAttrSubPacket -> UserAttrSubPacket -> Bool
/= :: UserAttrSubPacket -> UserAttrSubPacket -> Bool
Eq, (forall x. UserAttrSubPacket -> Rep UserAttrSubPacket x)
-> (forall x. Rep UserAttrSubPacket x -> UserAttrSubPacket)
-> Generic UserAttrSubPacket
forall x. Rep UserAttrSubPacket x -> UserAttrSubPacket
forall x. UserAttrSubPacket -> Rep UserAttrSubPacket x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. UserAttrSubPacket -> Rep UserAttrSubPacket x
from :: forall x. UserAttrSubPacket -> Rep UserAttrSubPacket x
$cto :: forall x. Rep UserAttrSubPacket x -> UserAttrSubPacket
to :: forall x. Rep UserAttrSubPacket x -> UserAttrSubPacket
Generic, Int -> UserAttrSubPacket -> ShowS
[UserAttrSubPacket] -> ShowS
UserAttrSubPacket -> String
(Int -> UserAttrSubPacket -> ShowS)
-> (UserAttrSubPacket -> String)
-> ([UserAttrSubPacket] -> ShowS)
-> Show UserAttrSubPacket
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> UserAttrSubPacket -> ShowS
showsPrec :: Int -> UserAttrSubPacket -> ShowS
$cshow :: UserAttrSubPacket -> String
show :: UserAttrSubPacket -> String
$cshowList :: [UserAttrSubPacket] -> ShowS
showList :: [UserAttrSubPacket] -> ShowS
Show, Typeable)

instance Hashable UserAttrSubPacket

instance Ord UserAttrSubPacket where
  compare :: UserAttrSubPacket -> UserAttrSubPacket -> Ordering
compare (ImageAttribute ImageHeader
h1 ByteString
d1) (ImageAttribute ImageHeader
h2 ByteString
d2) =
    ImageHeader -> ImageHeader -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ImageHeader
h1 ImageHeader
h2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
d1 ByteString
d2
  compare (ImageAttribute ImageHeader
_ ByteString
_) (OtherUASub Word8
_ ByteString
_) = Ordering
LT
  compare (OtherUASub Word8
_ ByteString
_) (ImageAttribute ImageHeader
_ ByteString
_) = Ordering
GT
  compare (OtherUASub Word8
t1 ByteString
b1) (OtherUASub Word8
t2 ByteString
b2) = Word8 -> Word8 -> Ordering
forall a. Ord a => a -> a -> Ordering
compare Word8
t1 Word8
t2 Ordering -> Ordering -> Ordering
forall a. Semigroup a => a -> a -> a
<> ByteString -> ByteString -> Ordering
forall a. Ord a => a -> a -> Ordering
compare ByteString
b1 ByteString
b2

instance Pretty UserAttrSubPacket where
  pretty :: forall ann. UserAttrSubPacket -> Doc ann
pretty (ImageAttribute ImageHeader
ih ByteString
d) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"image-attribute" Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> ImageHeader -> Doc ann
forall a ann. Pretty a => a -> Doc ann
forall ann. ImageHeader -> Doc ann
pretty ImageHeader
ih Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Word8] -> Doc ann
forall ann. [Word8] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> [Word8]
BL.unpack ByteString
d)
  pretty (OtherUASub Word8
t ByteString
bs) =
    String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"unknown attribute type" Doc ann -> Doc ann -> Doc ann
forall a. Semigroup a => a -> a -> a
<> Word8 -> Doc ann
forall ann. Word8 -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty Word8
t Doc ann -> Doc ann -> Doc ann
forall ann. Doc ann -> Doc ann -> Doc ann
<+> [Word8] -> Doc ann
forall ann. [Word8] -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty (ByteString -> [Word8]
BL.unpack ByteString
bs)

instance A.ToJSON UserAttrSubPacket where
  toJSON :: UserAttrSubPacket -> Value
toJSON (ImageAttribute ImageHeader
ih ByteString
d) = (ImageHeader, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (ImageHeader
ih, ByteString -> [Word8]
BL.unpack ByteString
d)
  toJSON (OtherUASub Word8
t ByteString
bs) = (Word8, [Word8]) -> Value
forall a. ToJSON a => a -> Value
A.toJSON (Word8
t, ByteString -> [Word8]
BL.unpack ByteString
bs)

data ECCCurve
  = NISTP256
  | NISTP384
  | NISTP521
  | Curve25519
  | Curve448
  deriving (Typeable ECCCurve
Typeable ECCCurve =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> ECCCurve -> c ECCCurve)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c ECCCurve)
-> (ECCCurve -> Constr)
-> (ECCCurve -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c ECCCurve))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ECCCurve))
-> ((forall b. Data b => b -> b) -> ECCCurve -> ECCCurve)
-> (forall r r'.
    (r -> r' -> r)
    -> r -> (forall d. Data d => d -> r') -> ECCCurve -> r)
-> (forall r r'.
    (r' -> r -> r)
    -> r -> (forall d. Data d => d -> r') -> ECCCurve -> r)
-> (forall u. (forall d. Data d => d -> u) -> ECCCurve -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> ECCCurve -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve)
-> Data ECCCurve
ECCCurve -> Constr
ECCCurve -> DataType
(forall b. Data b => b -> b) -> ECCCurve -> ECCCurve
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) -> ECCCurve -> u
forall u. (forall d. Data d => d -> u) -> ECCCurve -> [u]
forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ECCCurve -> r
forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ECCCurve -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ECCCurve
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ECCCurve -> c ECCCurve
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ECCCurve)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ECCCurve)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ECCCurve -> c ECCCurve
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> ECCCurve -> c ECCCurve
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ECCCurve
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c ECCCurve
$ctoConstr :: ECCCurve -> Constr
toConstr :: ECCCurve -> Constr
$cdataTypeOf :: ECCCurve -> DataType
dataTypeOf :: ECCCurve -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ECCCurve)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c ECCCurve)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ECCCurve)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c ECCCurve)
$cgmapT :: (forall b. Data b => b -> b) -> ECCCurve -> ECCCurve
gmapT :: (forall b. Data b => b -> b) -> ECCCurve -> ECCCurve
$cgmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ECCCurve -> r
gmapQl :: forall r r'.
(r -> r' -> r)
-> r -> (forall d. Data d => d -> r') -> ECCCurve -> r
$cgmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ECCCurve -> r
gmapQr :: forall r r'.
(r' -> r -> r)
-> r -> (forall d. Data d => d -> r') -> ECCCurve -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> ECCCurve -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> ECCCurve -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ECCCurve -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> ECCCurve -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> ECCCurve -> m ECCCurve
Data, ECCCurve -> ECCCurve -> Bool
(ECCCurve -> ECCCurve -> Bool)
-> (ECCCurve -> ECCCurve -> Bool) -> Eq ECCCurve
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: ECCCurve -> ECCCurve -> Bool
== :: ECCCurve -> ECCCurve -> Bool
$c/= :: ECCCurve -> ECCCurve -> Bool
/= :: ECCCurve -> ECCCurve -> Bool
Eq, (forall x. ECCCurve -> Rep ECCCurve x)
-> (forall x. Rep ECCCurve x -> ECCCurve) -> Generic ECCCurve
forall x. Rep ECCCurve x -> ECCCurve
forall x. ECCCurve -> Rep ECCCurve x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. ECCCurve -> Rep ECCCurve x
from :: forall x. ECCCurve -> Rep ECCCurve x
$cto :: forall x. Rep ECCCurve x -> ECCCurve
to :: forall x. Rep ECCCurve x -> ECCCurve
Generic, Eq ECCCurve
Eq ECCCurve =>
(ECCCurve -> ECCCurve -> Ordering)
-> (ECCCurve -> ECCCurve -> Bool)
-> (ECCCurve -> ECCCurve -> Bool)
-> (ECCCurve -> ECCCurve -> Bool)
-> (ECCCurve -> ECCCurve -> Bool)
-> (ECCCurve -> ECCCurve -> ECCCurve)
-> (ECCCurve -> ECCCurve -> ECCCurve)
-> Ord ECCCurve
ECCCurve -> ECCCurve -> Bool
ECCCurve -> ECCCurve -> Ordering
ECCCurve -> ECCCurve -> ECCCurve
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: ECCCurve -> ECCCurve -> Ordering
compare :: ECCCurve -> ECCCurve -> Ordering
$c< :: ECCCurve -> ECCCurve -> Bool
< :: ECCCurve -> ECCCurve -> Bool
$c<= :: ECCCurve -> ECCCurve -> Bool
<= :: ECCCurve -> ECCCurve -> Bool
$c> :: ECCCurve -> ECCCurve -> Bool
> :: ECCCurve -> ECCCurve -> Bool
$c>= :: ECCCurve -> ECCCurve -> Bool
>= :: ECCCurve -> ECCCurve -> Bool
$cmax :: ECCCurve -> ECCCurve -> ECCCurve
max :: ECCCurve -> ECCCurve -> ECCCurve
$cmin :: ECCCurve -> ECCCurve -> ECCCurve
min :: ECCCurve -> ECCCurve -> ECCCurve
Ord, Int -> ECCCurve -> ShowS
[ECCCurve] -> ShowS
ECCCurve -> String
(Int -> ECCCurve -> ShowS)
-> (ECCCurve -> String) -> ([ECCCurve] -> ShowS) -> Show ECCCurve
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> ECCCurve -> ShowS
showsPrec :: Int -> ECCCurve -> ShowS
$cshow :: ECCCurve -> String
show :: ECCCurve -> String
$cshowList :: [ECCCurve] -> ShowS
showList :: [ECCCurve] -> ShowS
Show, Typeable)

instance Pretty ECCCurve where
  pretty :: forall ann. ECCCurve -> Doc ann
pretty ECCCurve
NISTP256 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"NIST P-256"
  pretty ECCCurve
NISTP384 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"NIST P-384"
  pretty ECCCurve
NISTP521 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"NIST P-521"
  pretty ECCCurve
Curve25519 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Curve25519"
  pretty ECCCurve
Curve448 = String -> Doc ann
forall ann. String -> Doc ann
forall a ann. Pretty a => a -> Doc ann
pretty String
"Curve448"

instance Hashable ECCCurve

-- Packet stream wrapper used to provide an EOF-delimited Binary instance.
newtype Block a =
  Block
    { forall a. Block a -> [a]
unBlock :: [a]
    } -- intentionally not encoded as a list length prefix
  deriving (Int -> Block a -> ShowS
[Block a] -> ShowS
Block a -> String
(Int -> Block a -> ShowS)
-> (Block a -> String) -> ([Block a] -> ShowS) -> Show (Block a)
forall a. Show a => Int -> Block a -> ShowS
forall a. Show a => [Block a] -> ShowS
forall a. Show a => Block a -> String
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: forall a. Show a => Int -> Block a -> ShowS
showsPrec :: Int -> Block a -> ShowS
$cshow :: forall a. Show a => Block a -> String
show :: Block a -> String
$cshowList :: forall a. Show a => [Block a] -> ShowS
showList :: [Block a] -> ShowS
Show, Block a -> Block a -> Bool
(Block a -> Block a -> Bool)
-> (Block a -> Block a -> Bool) -> Eq (Block a)
forall a. Eq a => Block a -> Block a -> Bool
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: forall a. Eq a => Block a -> Block a -> Bool
== :: Block a -> Block a -> Bool
$c/= :: forall a. Eq a => Block a -> Block a -> Bool
/= :: Block a -> Block a -> Bool
Eq)