{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FunctionalDependencies #-}

-- | (More than just) Van Laarhoven lenses for XMPP types. The accessors in here
-- are designed to work with an optics library like lens or lens-family. This
-- module also provides a few simple functions ('view', 'modify', 'set' and
-- 'getAll') so you don't need to pull in another library to get some use out
-- of them.
--
-- * The name of the lenses corresponds to the field name of the data types with
-- an upper-case L appended. For documentation of the fields refer to the documentation of the data types (linked in the section header)
--
-- * Same goes for Traversals, except they are suffixed with a \'T\'
--
-- * Prism generally start with an underscore
--
-- /NB/ you do not need to import this module to get access to the optics
-- defined herein. They are also exported from Network.Xmpp. You only need to
-- import this module if you want to use the complementary accessor functions
-- without using an optics library like lens or lens-family

module Network.Xmpp.Lens
       ( Lens
       , Traversal
       , Prism
       , Iso
         -- * Accessors
         -- | Reimplementation of the basic lens functions so you don't have to
         -- bring in a lens library to use the optics

         -- ** Lenses
       , LF.view
       , modify
       , LF.set
         -- * Traversals
       , getAll
         -- * Prisms

         -- ** Construction
       , prism'
       , mkLens
       , mkIso
         -- * Lenses

         -- ** JID
       , _JidText
       , _isFull
       , _isBare

         -- ** Stanzas and Nonzas
       , _Stanza
       , _Nonza
       , _IQRequest
       , _IQResult
       , _IQError
       , _Message
       , _MessageError
       , _Presence
       , _PresenceError
       , IsStanza(..)
       , HasStanzaPayload(..)
       , IsErrorStanza(..)
       , messageTypeL
       , presenceTypeL
       , iqRequestTypeL
         -- *** 'StanzaError'
       , stanzaErrorTypeL
       , stanzaErrorConditionL
       , stanzaErrorTextL
       , stanzaErrorApplL
         -- ** Stream

         -- ** Stream Features
       , featureTlsL
       , featureMechanismsL
       , featureRosterVerL
       , featurePreApprovalL
       , featuresOtherL
         -- *** 'StreamConfiguration'
       , preferredLangL
       , toJidL
       , connectionDetailsL
       , resolvConfL
       , tlsBehaviourL
       , tlsParamsL
         -- **** TLS parameters
       , clientServerIdentificationL
       , tlsServerIdentificationL
       , clientSupportedL
       , supportedCiphersL
       , supportedVersionsL
       , tlsSupportedCiphersL
       , tlsSupportedVersionsL
       , clientUseServerNameIndicationL
       , tlsUseNameIndicationL
         -- *** 'SessionConfiguration'
       , streamConfigurationL
       , onConnectionClosedL
       , sessionStanzaIDsL
       , ensableRosterL
       , onRosterPushL
       , pluginsL
       , onPresenceChangeL
         -- ** IM
         -- *** Roster
         -- **** 'Roster'
       , verL
       , itemsL
         -- **** 'Item'
       , riApprovedL
       , riAskL
       , riJidL
       , riNameL
       , riSubscriptionL
       , riGroupsL
         -- **** 'QueryItem'
       , qiApprovedL
       , qiAskL
       , qiJidL
       , qiNameL
       , qiSubscriptionL
       , qiGroupsL
         -- **** 'Query'
       , queryVerL
       , queryItemsL
         -- ** IM Message
         -- *** 'MessageBody'
       , bodyLangL
       , bodyContentL
         -- *** 'MessageThread'
       , threadIdL
       , threadParentL
         -- *** 'MessageSubject'
       , subjectLangL
       , subjectContentL
         -- *** 'InstantMessage'
       , imThreadL
       , imSubjectL
       , imBodyL
         -- ** 'IMPresence'
       , showStatusL
       , statusL
       , priorityL

       )
       where

import           Control.Applicative
import qualified Data.ByteString as BS
import           Data.Functor.Identity (Identity(..))
import qualified Data.Map as Map
import           Data.Profunctor
import           Data.Text (Text)
import qualified Data.Text as Text
import           Data.XML.Types (Element)
import qualified Lens.Family2 as LF
import           Network.DNS (ResolvConf)
import           Network.TLS as TLS
import           Network.Xmpp.Concurrent.Types
import           Network.Xmpp.IM.Message
import           Network.Xmpp.IM.Presence
import           Network.Xmpp.IM.PresenceTracker.Types
import           Network.Xmpp.IM.Roster.Types
import           Network.Xmpp.Types

-- | Van-Laarhoven lenses.
{-# DEPRECATED Lens "Use Lens' from lens-family or lens" #-}
type Lens a b = forall f . Functor f => (b -> f b) -> a -> f a

{-# DEPRECATED Traversal "Use Traversal' from lens-family or lens" #-}
type Traversal a b = forall f . Applicative f => (b -> f b) -> a -> f a

type Prism a b = forall p f. (Choice p, Applicative f) => p b (f b) -> p a (f a)

type Iso a b = forall p f. (Profunctor p, Functor f) => p b (f b) -> p a (f a)

prism' :: (b -> s) -> (s -> Maybe b) -> Prism s b
prism' :: forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' b -> s
bs s -> Maybe b
sma = (s -> Either s b)
-> (Either s (f b) -> f s)
-> p (Either s b) (Either s (f b))
-> p s (f s)
forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap (\s
s -> Either s b -> (b -> Either s b) -> Maybe b -> Either s b
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (s -> Either s b
forall a b. a -> Either a b
Left s
s) b -> Either s b
forall a b. b -> Either a b
Right (s -> Maybe b
sma s
s))
                      ((s -> f s) -> (f b -> f s) -> Either s (f b) -> f s
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either s -> f s
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure ((b -> s) -> f b -> f s
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> s
bs)) (p (Either s b) (Either s (f b)) -> p s (f s))
-> (p b (f b) -> p (Either s b) (Either s (f b)))
-> p b (f b)
-> p s (f s)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. p b (f b) -> p (Either s b) (Either s (f b))
forall a b c. p a b -> p (Either c a) (Either c b)
forall (p :: * -> * -> *) a b c.
Choice p =>
p a b -> p (Either c a) (Either c b)
right'

mkLens :: (a -> b) -> (b -> a ->  a) -> Lens a b
mkLens :: forall a b. (a -> b) -> (b -> a -> a) -> Lens a b
mkLens a -> b
get b -> a -> a
set = \b -> f b
inj a
x -> (b -> a) -> f b -> f a
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap ((b -> a -> a) -> a -> b -> a
forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> a -> a
set a
x) (b -> f b
inj (b -> f b) -> b -> f b
forall a b. (a -> b) -> a -> b
$ a -> b
get a
x)

mkIso :: (a -> b) -> (b -> a) -> Iso a b
mkIso :: forall a b. (a -> b) -> (b -> a) -> Iso a b
mkIso a -> b
t b -> a
f = (a -> b) -> (f b -> f a) -> p b (f b) -> p a (f a)
forall a b c d. (a -> b) -> (c -> d) -> p b c -> p a d
forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap a -> b
t ((b -> a) -> f b -> f a
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> a
f)

newtype Collect a b = Collect {forall a b. Collect a b -> [a]
getCollection :: [a]} deriving (forall a b. (a -> b) -> Collect a a -> Collect a b)
-> (forall a b. a -> Collect a b -> Collect a a)
-> Functor (Collect a)
forall a b. a -> Collect a b -> Collect a a
forall a b. (a -> b) -> Collect a a -> Collect a b
forall a a b. a -> Collect a b -> Collect a a
forall a a b. (a -> b) -> Collect a a -> Collect a b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall a a b. (a -> b) -> Collect a a -> Collect a b
fmap :: forall a b. (a -> b) -> Collect a a -> Collect a b
$c<$ :: forall a a b. a -> Collect a b -> Collect a a
<$ :: forall a b. a -> Collect a b -> Collect a a
Functor

instance Applicative (Collect a) where
    pure :: forall a. a -> Collect a a
pure a
_ = [a] -> Collect a a
forall a b. [a] -> Collect a b
Collect []
    Collect [a]
xs <*> :: forall a b. Collect a (a -> b) -> Collect a a -> Collect a b
<*> Collect [a]
ys = [a] -> Collect a b
forall a b. [a] -> Collect a b
Collect ([a] -> Collect a b) -> [a] -> Collect a b
forall a b. (a -> b) -> a -> b
$ [a]
xs [a] -> [a] -> [a]
forall a. [a] -> [a] -> [a]
++ [a]
ys

{-# DEPRECATED getAll "use toListOf (lens-family), partsOf (lens) or similar" #-}
-- | Return all the values a Traversal is pointing to in a list
getAll :: Traversal a b -> a -> [b]
getAll :: forall a b. Traversal a b -> a -> [b]
getAll Traversal a b
t = Collect b a -> [b]
forall a b. Collect a b -> [a]
getCollection (Collect b a -> [b]) -> (a -> Collect b a) -> a -> [b]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> Collect b b) -> a -> Collect b a
Traversal a b
t ([b] -> Collect b b
forall a b. [a] -> Collect a b
Collect ([b] -> Collect b b) -> (b -> [b]) -> b -> Collect b b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> [b]
forall a. a -> [a]
forall (f :: * -> *) a. Applicative f => a -> f a
pure)

{-# DEPRECATED modify "use over (lens-family, lens)" #-}
modify :: Traversal a b -> (b -> b) -> a -> a
modify :: forall a b. Traversal a b -> (b -> b) -> a -> a
modify Traversal a b
t b -> b
f = Identity a -> a
forall a. Identity a -> a
runIdentity (Identity a -> a) -> (a -> Identity a) -> a -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (b -> Identity b) -> a -> Identity a
Traversal a b
t (b -> Identity b
forall a. a -> Identity a
Identity (b -> Identity b) -> (b -> b) -> b -> Identity b
forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> b
f)

-- Xmpp Lenses
--------------------

_JidText :: Prism Text Jid
_JidText :: Prism Text Jid
_JidText = (Jid -> Text) -> (Text -> Maybe Jid) -> Prism Text Jid
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Jid -> Text
jidToText Text -> Maybe Jid
jidFromText

_isFull :: Prism Jid Jid
_isFull :: Prism Jid Jid
_isFull = (Jid -> Jid) -> (Jid -> Maybe Jid) -> Prism Jid Jid
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Jid -> Jid
forall a. a -> a
id (\Jid
j -> if Jid -> Bool
isFull Jid
j then Jid -> Maybe Jid
forall a. a -> Maybe a
Just Jid
j else Maybe Jid
forall a. Maybe a
Nothing)

_isBare :: Prism Jid Jid
_isBare :: Prism Jid Jid
_isBare = (Jid -> Jid) -> (Jid -> Maybe Jid) -> Prism Jid Jid
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Jid -> Jid
toBare (\Jid
j -> if Jid -> Bool
isBare Jid
j then Jid -> Maybe Jid
forall a. a -> Maybe a
Just Jid
j else Maybe Jid
forall a. Maybe a
Nothing)

_Stanza :: Prism XmppElement Stanza
_Stanza :: Prism XmppElement Stanza
_Stanza = (Stanza -> XmppElement)
-> (XmppElement -> Maybe Stanza) -> Prism XmppElement Stanza
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Stanza -> XmppElement
XmppStanza (\XmppElement
v -> case XmppElement
v of
                                    XmppStanza Stanza
s -> Stanza -> Maybe Stanza
forall a. a -> Maybe a
Just Stanza
s
                                    XmppElement
_ -> Maybe Stanza
forall a. Maybe a
Nothing)

_Nonza :: Prism XmppElement Element
_Nonza :: Prism XmppElement Element
_Nonza = (Element -> XmppElement)
-> (XmppElement -> Maybe Element) -> Prism XmppElement Element
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Element -> XmppElement
XmppNonza (\XmppElement
v -> case XmppElement
v of
                                  XmppNonza Element
n -> Element -> Maybe Element
forall a. a -> Maybe a
Just Element
n
                                  XmppElement
_ -> Maybe Element
forall a. Maybe a
Nothing)


class IsStanza s where
    -- | From-attribute of the stanza
    from :: Lens s (Maybe Jid)
    -- | To-attribute of the stanza
    to   :: Lens s (Maybe Jid)
    -- | Langtag of the stanza
    lang :: Lens s (Maybe LangTag)
    -- | Stanza ID. Setting this to /Nothing/ for IQ* stanzas will set the id to
    -- the empty Text.
    sid :: Lens s (Maybe Text)
    -- | Traversal over the payload elements.
    payloadT :: Traversal s Element

traverseList :: Traversal [a] a
traverseList :: forall a (f :: * -> *). Applicative f => (a -> f a) -> [a] -> f [a]
traverseList a -> f a
_inj [] = [a] -> f [a]
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure []
traverseList a -> f a
inj  (a
x:[a]
xs) = (:) (a -> [a] -> [a]) -> f a -> f ([a] -> [a])
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a
inj a
x f ([a] -> [a]) -> f [a] -> f [a]
forall a b. f (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (a -> f a) -> [a] -> f [a]
forall a (f :: * -> *). Applicative f => (a -> f a) -> [a] -> f [a]
traverseList a -> f a
inj [a]
xs

instance IsStanza Message where
    from :: Lens Message (Maybe Jid)
from Maybe Jid -> f (Maybe Jid)
inj m :: Message
m@(Message{messageFrom :: Message -> Maybe Jid
messageFrom=Maybe Jid
f}) = (\Maybe Jid
f' -> Message
m{messageFrom = f'}) (Maybe Jid -> Message) -> f (Maybe Jid) -> f Message
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
f
    to :: Lens Message (Maybe Jid)
to Maybe Jid -> f (Maybe Jid)
inj m :: Message
m@(Message{messageTo :: Message -> Maybe Jid
messageTo=Maybe Jid
t}) = (\Maybe Jid
t' -> Message
m{messageTo = t'}) (Maybe Jid -> Message) -> f (Maybe Jid) -> f Message
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
t
    lang :: Lens Message (Maybe LangTag)
lang Maybe LangTag -> f (Maybe LangTag)
inj m :: Message
m@(Message{messageLangTag :: Message -> Maybe LangTag
messageLangTag=Maybe LangTag
t}) =
        (\Maybe LangTag
t' -> Message
m{messageLangTag = t'}) (Maybe LangTag -> Message) -> f (Maybe LangTag) -> f Message
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
t
    sid :: Lens Message (Maybe Text)
sid Maybe Text -> f (Maybe Text)
inj m :: Message
m@(Message{messageID :: Message -> Maybe Text
messageID = Maybe Text
i}) =
        ((\Maybe Text
i' -> Message
m{messageID = i'}) (Maybe Text -> Message) -> f (Maybe Text) -> f Message
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
i)
    payloadT :: Traversal Message Element
payloadT Element -> f Element
inj m :: Message
m@(Message{messagePayload :: Message -> [Element]
messagePayload=[Element]
pl}) =
        (\[Element]
pl' -> Message
m{messagePayload=pl'}) ([Element] -> Message) -> f [Element] -> f Message
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Element -> f Element) -> [Element] -> f [Element]
forall a (f :: * -> *). Applicative f => (a -> f a) -> [a] -> f [a]
traverseList Element -> f Element
inj [Element]
pl


instance IsStanza MessageError where
    from :: Lens MessageError (Maybe Jid)
from Maybe Jid -> f (Maybe Jid)
inj m :: MessageError
m@(MessageError{messageErrorFrom :: MessageError -> Maybe Jid
messageErrorFrom=Maybe Jid
f}) =
        (\Maybe Jid
f' -> MessageError
m{messageErrorFrom = f'}) (Maybe Jid -> MessageError) -> f (Maybe Jid) -> f MessageError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
f
    to :: Lens MessageError (Maybe Jid)
to Maybe Jid -> f (Maybe Jid)
inj m :: MessageError
m@(MessageError{messageErrorTo :: MessageError -> Maybe Jid
messageErrorTo=Maybe Jid
t}) =
        (\Maybe Jid
t' -> MessageError
m{messageErrorTo = t'}) (Maybe Jid -> MessageError) -> f (Maybe Jid) -> f MessageError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
t
    lang :: Lens MessageError (Maybe LangTag)
lang Maybe LangTag -> f (Maybe LangTag)
inj m :: MessageError
m@(MessageError{messageErrorLangTag :: MessageError -> Maybe LangTag
messageErrorLangTag=Maybe LangTag
t}) =
        (\Maybe LangTag
t' -> MessageError
m{messageErrorLangTag = t'}) (Maybe LangTag -> MessageError)
-> f (Maybe LangTag) -> f MessageError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
t
    sid :: Lens MessageError (Maybe Text)
sid Maybe Text -> f (Maybe Text)
inj m :: MessageError
m@(MessageError{messageErrorID :: MessageError -> Maybe Text
messageErrorID = Maybe Text
i}) =
        ((\Maybe Text
i' -> MessageError
m{messageErrorID = i'}) (Maybe Text -> MessageError) -> f (Maybe Text) -> f MessageError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
i)
    payloadT :: Traversal MessageError Element
payloadT Element -> f Element
inj m :: MessageError
m@(MessageError{messageErrorPayload :: MessageError -> [Element]
messageErrorPayload=[Element]
pl}) =
        (\[Element]
pl' -> MessageError
m{messageErrorPayload=pl'}) ([Element] -> MessageError) -> f [Element] -> f MessageError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Element -> f Element) -> [Element] -> f [Element]
forall a (f :: * -> *). Applicative f => (a -> f a) -> [a] -> f [a]
traverseList Element -> f Element
inj [Element]
pl

instance IsStanza Presence where
    from :: Lens Presence (Maybe Jid)
from Maybe Jid -> f (Maybe Jid)
inj m :: Presence
m@(Presence{presenceFrom :: Presence -> Maybe Jid
presenceFrom=Maybe Jid
f}) = (\Maybe Jid
f' -> Presence
m{presenceFrom = f'}) (Maybe Jid -> Presence) -> f (Maybe Jid) -> f Presence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
f
    to :: Lens Presence (Maybe Jid)
to Maybe Jid -> f (Maybe Jid)
inj m :: Presence
m@(Presence{presenceTo :: Presence -> Maybe Jid
presenceTo=Maybe Jid
t}) = (\Maybe Jid
t' -> Presence
m{presenceTo = t'}) (Maybe Jid -> Presence) -> f (Maybe Jid) -> f Presence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
t
    lang :: Lens Presence (Maybe LangTag)
lang Maybe LangTag -> f (Maybe LangTag)
inj m :: Presence
m@(Presence{presenceLangTag :: Presence -> Maybe LangTag
presenceLangTag=Maybe LangTag
t}) =
        (\Maybe LangTag
t' -> Presence
m{presenceLangTag = t'}) (Maybe LangTag -> Presence) -> f (Maybe LangTag) -> f Presence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
t
    sid :: Lens Presence (Maybe Text)
sid Maybe Text -> f (Maybe Text)
inj m :: Presence
m@(Presence{presenceID :: Presence -> Maybe Text
presenceID = Maybe Text
i}) =
        ((\Maybe Text
i' -> Presence
m{presenceID = i'}) (Maybe Text -> Presence) -> f (Maybe Text) -> f Presence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
i)
    payloadT :: Traversal Presence Element
payloadT Element -> f Element
inj m :: Presence
m@(Presence{presencePayload :: Presence -> [Element]
presencePayload=[Element]
pl}) =
        (\[Element]
pl' -> Presence
m{presencePayload=pl'}) ([Element] -> Presence) -> f [Element] -> f Presence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Element -> f Element) -> [Element] -> f [Element]
forall a (f :: * -> *). Applicative f => (a -> f a) -> [a] -> f [a]
traverseList Element -> f Element
inj [Element]
pl

instance IsStanza PresenceError where
    from :: Lens PresenceError (Maybe Jid)
from Maybe Jid -> f (Maybe Jid)
inj m :: PresenceError
m@(PresenceError{presenceErrorFrom :: PresenceError -> Maybe Jid
presenceErrorFrom=Maybe Jid
f}) =
        (\Maybe Jid
f' -> PresenceError
m{presenceErrorFrom = f'}) (Maybe Jid -> PresenceError) -> f (Maybe Jid) -> f PresenceError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
f
    to :: Lens PresenceError (Maybe Jid)
to Maybe Jid -> f (Maybe Jid)
inj m :: PresenceError
m@(PresenceError{presenceErrorTo :: PresenceError -> Maybe Jid
presenceErrorTo=Maybe Jid
t}) =
        (\Maybe Jid
t' -> PresenceError
m{presenceErrorTo = t'}) (Maybe Jid -> PresenceError) -> f (Maybe Jid) -> f PresenceError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
t
    lang :: Lens PresenceError (Maybe LangTag)
lang Maybe LangTag -> f (Maybe LangTag)
inj m :: PresenceError
m@(PresenceError{presenceErrorLangTag :: PresenceError -> Maybe LangTag
presenceErrorLangTag=Maybe LangTag
t}) =
        (\Maybe LangTag
t' -> PresenceError
m{presenceErrorLangTag = t'}) (Maybe LangTag -> PresenceError)
-> f (Maybe LangTag) -> f PresenceError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
t
    sid :: Lens PresenceError (Maybe Text)
sid Maybe Text -> f (Maybe Text)
inj m :: PresenceError
m@(PresenceError{presenceErrorID :: PresenceError -> Maybe Text
presenceErrorID = Maybe Text
i}) =
        ((\Maybe Text
i' -> PresenceError
m{presenceErrorID = i'}) (Maybe Text -> PresenceError) -> f (Maybe Text) -> f PresenceError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
i)
    payloadT :: Traversal PresenceError Element
payloadT Element -> f Element
inj m :: PresenceError
m@(PresenceError{presenceErrorPayload :: PresenceError -> [Element]
presenceErrorPayload=[Element]
pl}) =
        (\[Element]
pl' -> PresenceError
m{presenceErrorPayload=pl'}) ([Element] -> PresenceError) -> f [Element] -> f PresenceError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Element -> f Element) -> [Element] -> f [Element]
forall a (f :: * -> *). Applicative f => (a -> f a) -> [a] -> f [a]
traverseList Element -> f Element
inj [Element]
pl

instance IsStanza IQRequest where
    from :: Lens IQRequest (Maybe Jid)
from Maybe Jid -> f (Maybe Jid)
inj m :: IQRequest
m@(IQRequest{iqRequestFrom :: IQRequest -> Maybe Jid
iqRequestFrom=Maybe Jid
f}) =
        (\Maybe Jid
f' -> IQRequest
m{iqRequestFrom = f'}) (Maybe Jid -> IQRequest) -> f (Maybe Jid) -> f IQRequest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
f
    to :: Lens IQRequest (Maybe Jid)
to Maybe Jid -> f (Maybe Jid)
inj m :: IQRequest
m@(IQRequest{iqRequestTo :: IQRequest -> Maybe Jid
iqRequestTo=Maybe Jid
t}) =
        (\Maybe Jid
t' -> IQRequest
m{iqRequestTo = t'}) (Maybe Jid -> IQRequest) -> f (Maybe Jid) -> f IQRequest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
t
    lang :: Lens IQRequest (Maybe LangTag)
lang Maybe LangTag -> f (Maybe LangTag)
inj m :: IQRequest
m@(IQRequest{iqRequestLangTag :: IQRequest -> Maybe LangTag
iqRequestLangTag=Maybe LangTag
t}) =
        (\Maybe LangTag
t' -> IQRequest
m{iqRequestLangTag = t'}) (Maybe LangTag -> IQRequest) -> f (Maybe LangTag) -> f IQRequest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
t
    sid :: Lens IQRequest (Maybe Text)
sid Maybe Text -> f (Maybe Text)
inj m :: IQRequest
m@(IQRequest{iqRequestID :: IQRequest -> Text
iqRequestID = Text
i}) =
        ((\Text
i' -> IQRequest
m{iqRequestID = i'}) (Text -> IQRequest) -> f Text -> f IQRequest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe Text -> f (Maybe Text)) -> Text -> f Text
Lens Text (Maybe Text)
maybeNonempty Maybe Text -> f (Maybe Text)
inj Text
i)
    payloadT :: Traversal IQRequest Element
payloadT Element -> f Element
inj m :: IQRequest
m@(IQRequest{iqRequestPayload :: IQRequest -> Element
iqRequestPayload=Element
pl}) =
        (\Element
pl' -> IQRequest
m{iqRequestPayload=pl'}) (Element -> IQRequest) -> f Element -> f IQRequest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Element -> f Element
inj Element
pl

instance IsStanza IQResult where
    from :: Lens IQResult (Maybe Jid)
from Maybe Jid -> f (Maybe Jid)
inj m :: IQResult
m@(IQResult{iqResultFrom :: IQResult -> Maybe Jid
iqResultFrom=Maybe Jid
f}) =
        (\Maybe Jid
f' -> IQResult
m{iqResultFrom = f'}) (Maybe Jid -> IQResult) -> f (Maybe Jid) -> f IQResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
f
    to :: Lens IQResult (Maybe Jid)
to Maybe Jid -> f (Maybe Jid)
inj m :: IQResult
m@(IQResult{iqResultTo :: IQResult -> Maybe Jid
iqResultTo=Maybe Jid
t}) =
        (\Maybe Jid
t' -> IQResult
m{iqResultTo = t'}) (Maybe Jid -> IQResult) -> f (Maybe Jid) -> f IQResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
t
    lang :: Lens IQResult (Maybe LangTag)
lang Maybe LangTag -> f (Maybe LangTag)
inj m :: IQResult
m@(IQResult{iqResultLangTag :: IQResult -> Maybe LangTag
iqResultLangTag=Maybe LangTag
t}) =
        (\Maybe LangTag
t' -> IQResult
m{iqResultLangTag = t'}) (Maybe LangTag -> IQResult) -> f (Maybe LangTag) -> f IQResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
t
    sid :: Lens IQResult (Maybe Text)
sid Maybe Text -> f (Maybe Text)
inj m :: IQResult
m@(IQResult{iqResultID :: IQResult -> Text
iqResultID = Text
i}) =
        ((\Text
i' -> IQResult
m{iqResultID = i'}) (Text -> IQResult) -> f Text -> f IQResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe Text -> f (Maybe Text)) -> Text -> f Text
Lens Text (Maybe Text)
maybeNonempty Maybe Text -> f (Maybe Text)
inj Text
i)
    payloadT :: Traversal IQResult Element
payloadT Element -> f Element
inj m :: IQResult
m@(IQResult{iqResultPayload :: IQResult -> Maybe Element
iqResultPayload=Maybe Element
pl}) =
        (\Maybe Element
pl' -> IQResult
m{iqResultPayload=pl'}) (Maybe Element -> IQResult) -> f (Maybe Element) -> f IQResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (Maybe Element)
-> (Element -> f (Maybe Element))
-> Maybe Element
-> f (Maybe Element)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe Element -> f (Maybe Element)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Element
forall a. Maybe a
Nothing)
                                                   ((Element -> Maybe Element) -> f Element -> f (Maybe Element)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Element -> Maybe Element
forall a. a -> Maybe a
Just (f Element -> f (Maybe Element))
-> (Element -> f Element) -> Element -> f (Maybe Element)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element -> f Element
inj) Maybe Element
pl

instance IsStanza IQError where
    from :: Lens IQError (Maybe Jid)
from Maybe Jid -> f (Maybe Jid)
inj m :: IQError
m@(IQError{iqErrorFrom :: IQError -> Maybe Jid
iqErrorFrom=Maybe Jid
f}) =
        (\Maybe Jid
f' -> IQError
m{iqErrorFrom = f'}) (Maybe Jid -> IQError) -> f (Maybe Jid) -> f IQError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
f
    to :: Lens IQError (Maybe Jid)
to Maybe Jid -> f (Maybe Jid)
inj m :: IQError
m@(IQError{iqErrorTo :: IQError -> Maybe Jid
iqErrorTo=Maybe Jid
t}) =
        (\Maybe Jid
t' -> IQError
m{iqErrorTo = t'}) (Maybe Jid -> IQError) -> f (Maybe Jid) -> f IQError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Jid -> f (Maybe Jid)
inj Maybe Jid
t
    lang :: Lens IQError (Maybe LangTag)
lang Maybe LangTag -> f (Maybe LangTag)
inj m :: IQError
m@(IQError{iqErrorLangTag :: IQError -> Maybe LangTag
iqErrorLangTag=Maybe LangTag
t}) =
        (\Maybe LangTag
t' -> IQError
m{iqErrorLangTag = t'}) (Maybe LangTag -> IQError) -> f (Maybe LangTag) -> f IQError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
t
    sid :: Lens IQError (Maybe Text)
sid Maybe Text -> f (Maybe Text)
inj m :: IQError
m@(IQError{iqErrorID :: IQError -> Text
iqErrorID = Text
i}) =
        ((\Text
i' -> IQError
m{iqErrorID = i'}) (Text -> IQError) -> f Text -> f IQError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Maybe Text -> f (Maybe Text)) -> Text -> f Text
Lens Text (Maybe Text)
maybeNonempty Maybe Text -> f (Maybe Text)
inj Text
i)
    payloadT :: Traversal IQError Element
payloadT Element -> f Element
inj m :: IQError
m@(IQError{iqErrorPayload :: IQError -> Maybe Element
iqErrorPayload=Maybe Element
pl}) =
        (\Maybe Element
pl' -> IQError
m{iqErrorPayload=pl'}) (Maybe Element -> IQError) -> f (Maybe Element) -> f IQError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> f (Maybe Element)
-> (Element -> f (Maybe Element))
-> Maybe Element
-> f (Maybe Element)
forall b a. b -> (a -> b) -> Maybe a -> b
maybe (Maybe Element -> f (Maybe Element)
forall a. a -> f a
forall (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Element
forall a. Maybe a
Nothing)
                                                  ((Element -> Maybe Element) -> f Element -> f (Maybe Element)
forall a b. (a -> b) -> f a -> f b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Element -> Maybe Element
forall a. a -> Maybe a
Just (f Element -> f (Maybe Element))
-> (Element -> f Element) -> Element -> f (Maybe Element)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Element -> f Element
inj) Maybe Element
pl

liftLens :: (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens :: forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens forall s. IsStanza s => Lens s a
f a -> f a
inj (IQRequestS     IQRequest
s) = IQRequest -> Stanza
IQRequestS     (IQRequest -> Stanza) -> f IQRequest -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> IQRequest -> f IQRequest
forall s. IsStanza s => Lens s a
Lens IQRequest a
f a -> f a
inj IQRequest
s
liftLens forall s. IsStanza s => Lens s a
f a -> f a
inj (IQResultS      IQResult
s) = IQResult -> Stanza
IQResultS      (IQResult -> Stanza) -> f IQResult -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> IQResult -> f IQResult
forall s. IsStanza s => Lens s a
Lens IQResult a
f a -> f a
inj IQResult
s
liftLens forall s. IsStanza s => Lens s a
f a -> f a
inj (IQErrorS       IQError
s) = IQError -> Stanza
IQErrorS       (IQError -> Stanza) -> f IQError -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> IQError -> f IQError
forall s. IsStanza s => Lens s a
Lens IQError a
f a -> f a
inj IQError
s
liftLens forall s. IsStanza s => Lens s a
f a -> f a
inj (MessageS       Message
s) = Message -> Stanza
MessageS       (Message -> Stanza) -> f Message -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> Message -> f Message
forall s. IsStanza s => Lens s a
Lens Message a
f a -> f a
inj Message
s
liftLens forall s. IsStanza s => Lens s a
f a -> f a
inj (MessageErrorS  MessageError
s) = MessageError -> Stanza
MessageErrorS  (MessageError -> Stanza) -> f MessageError -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> MessageError -> f MessageError
forall s. IsStanza s => Lens s a
Lens MessageError a
f a -> f a
inj MessageError
s
liftLens forall s. IsStanza s => Lens s a
f a -> f a
inj (PresenceS      Presence
s) = Presence -> Stanza
PresenceS      (Presence -> Stanza) -> f Presence -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> Presence -> f Presence
forall s. IsStanza s => Lens s a
Lens Presence a
f a -> f a
inj Presence
s
liftLens forall s. IsStanza s => Lens s a
f a -> f a
inj (PresenceErrorS PresenceError
s) = PresenceError -> Stanza
PresenceErrorS (PresenceError -> Stanza) -> f PresenceError -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> PresenceError -> f PresenceError
forall s. IsStanza s => Lens s a
Lens PresenceError a
f a -> f a
inj PresenceError
s

liftTraversal :: (forall s. IsStanza s => Traversal s a) -> Traversal Stanza a
liftTraversal :: forall a.
(forall s. IsStanza s => Traversal s a) -> Traversal Stanza a
liftTraversal forall s. IsStanza s => Traversal s a
f a -> f a
inj (IQRequestS     IQRequest
s) = IQRequest -> Stanza
IQRequestS     (IQRequest -> Stanza) -> f IQRequest -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> IQRequest -> f IQRequest
forall s. IsStanza s => Traversal s a
Traversal IQRequest a
f a -> f a
inj IQRequest
s
liftTraversal forall s. IsStanza s => Traversal s a
f a -> f a
inj (IQResultS      IQResult
s) = IQResult -> Stanza
IQResultS      (IQResult -> Stanza) -> f IQResult -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> IQResult -> f IQResult
forall s. IsStanza s => Traversal s a
Traversal IQResult a
f a -> f a
inj IQResult
s
liftTraversal forall s. IsStanza s => Traversal s a
f a -> f a
inj (IQErrorS       IQError
s) = IQError -> Stanza
IQErrorS       (IQError -> Stanza) -> f IQError -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> IQError -> f IQError
forall s. IsStanza s => Traversal s a
Traversal IQError a
f a -> f a
inj IQError
s
liftTraversal forall s. IsStanza s => Traversal s a
f a -> f a
inj (MessageS       Message
s) = Message -> Stanza
MessageS       (Message -> Stanza) -> f Message -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> Message -> f Message
forall s. IsStanza s => Traversal s a
Traversal Message a
f a -> f a
inj Message
s
liftTraversal forall s. IsStanza s => Traversal s a
f a -> f a
inj (MessageErrorS  MessageError
s) = MessageError -> Stanza
MessageErrorS  (MessageError -> Stanza) -> f MessageError -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> MessageError -> f MessageError
forall s. IsStanza s => Traversal s a
Traversal MessageError a
f a -> f a
inj MessageError
s
liftTraversal forall s. IsStanza s => Traversal s a
f a -> f a
inj (PresenceS      Presence
s) = Presence -> Stanza
PresenceS      (Presence -> Stanza) -> f Presence -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> Presence -> f Presence
forall s. IsStanza s => Traversal s a
Traversal Presence a
f a -> f a
inj Presence
s
liftTraversal forall s. IsStanza s => Traversal s a
f a -> f a
inj (PresenceErrorS PresenceError
s) = PresenceError -> Stanza
PresenceErrorS (PresenceError -> Stanza) -> f PresenceError -> f Stanza
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (a -> f a) -> PresenceError -> f PresenceError
forall s. IsStanza s => Traversal s a
Traversal PresenceError a
f a -> f a
inj PresenceError
s

instance IsStanza Stanza where
    from :: Lens Stanza (Maybe Jid)
from     = (forall s. IsStanza s => Lens s (Maybe Jid))
-> Lens Stanza (Maybe Jid)
forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens (Maybe Jid -> f (Maybe Jid)) -> s -> f s
forall s. IsStanza s => Lens s (Maybe Jid)
Lens s (Maybe Jid)
from
    to :: Lens Stanza (Maybe Jid)
to       = (forall s. IsStanza s => Lens s (Maybe Jid))
-> Lens Stanza (Maybe Jid)
forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens (Maybe Jid -> f (Maybe Jid)) -> s -> f s
forall s. IsStanza s => Lens s (Maybe Jid)
Lens s (Maybe Jid)
to
    lang :: Lens Stanza (Maybe LangTag)
lang     = (forall s. IsStanza s => Lens s (Maybe LangTag))
-> Lens Stanza (Maybe LangTag)
forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens (Maybe LangTag -> f (Maybe LangTag)) -> s -> f s
forall s. IsStanza s => Lens s (Maybe LangTag)
Lens s (Maybe LangTag)
lang
    sid :: Lens Stanza (Maybe Text)
sid      = (forall s. IsStanza s => Lens s (Maybe Text))
-> Lens Stanza (Maybe Text)
forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens (Maybe Text -> f (Maybe Text)) -> s -> f s
forall s. IsStanza s => Lens s (Maybe Text)
Lens s (Maybe Text)
sid
    payloadT :: Traversal Stanza Element
payloadT = (forall s. IsStanza s => Traversal s Element)
-> Traversal Stanza Element
forall a.
(forall s. IsStanza s => Traversal s a) -> Traversal Stanza a
liftTraversal (Element -> f Element) -> s -> f s
forall s. IsStanza s => Traversal s Element
Traversal s Element
payloadT

maybeNonempty :: Lens Text (Maybe Text)
maybeNonempty :: Lens Text (Maybe Text)
maybeNonempty Maybe Text -> f (Maybe Text)
inj Text
x = (Text -> (Text -> Text) -> Maybe Text -> Text
forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
Text.empty Text -> Text
forall a. a -> a
id)
                      (Maybe Text -> Text) -> f (Maybe Text) -> f Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj (if Text -> Bool
Text.null Text
x then Maybe Text
forall a. Maybe a
Nothing else Text -> Maybe Text
forall a. a -> Maybe a
Just Text
x)


_IQRequest :: Prism Stanza IQRequest
_IQRequest :: Prism Stanza IQRequest
_IQRequest = (IQRequest -> Stanza)
-> (Stanza -> Maybe IQRequest) -> Prism Stanza IQRequest
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' IQRequest -> Stanza
IQRequestS Stanza -> Maybe IQRequest
fromIQRequestS
  where
    fromIQRequestS :: Stanza -> Maybe IQRequest
fromIQRequestS (IQRequestS IQRequest
s) = IQRequest -> Maybe IQRequest
forall a. a -> Maybe a
Just IQRequest
s
    fromIQRequestS Stanza
_ = Maybe IQRequest
forall a. Maybe a
Nothing

_IQResult :: Prism Stanza IQResult
_IQResult :: Prism Stanza IQResult
_IQResult = (IQResult -> Stanza)
-> (Stanza -> Maybe IQResult) -> Prism Stanza IQResult
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' IQResult -> Stanza
IQResultS Stanza -> Maybe IQResult
fromIQResultS
  where
    fromIQResultS :: Stanza -> Maybe IQResult
fromIQResultS (IQResultS IQResult
s) = IQResult -> Maybe IQResult
forall a. a -> Maybe a
Just IQResult
s
    fromIQResultS Stanza
_ = Maybe IQResult
forall a. Maybe a
Nothing

_IQError :: Prism Stanza IQError
_IQError :: Prism Stanza IQError
_IQError = (IQError -> Stanza)
-> (Stanza -> Maybe IQError) -> Prism Stanza IQError
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' IQError -> Stanza
IQErrorS Stanza -> Maybe IQError
fromIQErrorS
  where
    fromIQErrorS :: Stanza -> Maybe IQError
fromIQErrorS (IQErrorS IQError
s) = IQError -> Maybe IQError
forall a. a -> Maybe a
Just IQError
s
    fromIQErrorS Stanza
_ = Maybe IQError
forall a. Maybe a
Nothing

_Message :: Prism Stanza Message
_Message :: Prism Stanza Message
_Message = (Message -> Stanza)
-> (Stanza -> Maybe Message) -> Prism Stanza Message
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Message -> Stanza
MessageS Stanza -> Maybe Message
fromMessageS
  where
    fromMessageS :: Stanza -> Maybe Message
fromMessageS (MessageS Message
s) = Message -> Maybe Message
forall a. a -> Maybe a
Just Message
s
    fromMessageS Stanza
_ = Maybe Message
forall a. Maybe a
Nothing

_MessageError :: Prism Stanza MessageError
_MessageError :: Prism Stanza MessageError
_MessageError = (MessageError -> Stanza)
-> (Stanza -> Maybe MessageError) -> Prism Stanza MessageError
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' MessageError -> Stanza
MessageErrorS Stanza -> Maybe MessageError
fromMessageErrorS
  where
    fromMessageErrorS :: Stanza -> Maybe MessageError
fromMessageErrorS (MessageErrorS MessageError
s) = MessageError -> Maybe MessageError
forall a. a -> Maybe a
Just MessageError
s
    fromMessageErrorS Stanza
_ = Maybe MessageError
forall a. Maybe a
Nothing

_Presence :: Prism Stanza Presence
_Presence :: Prism Stanza Presence
_Presence = (Presence -> Stanza)
-> (Stanza -> Maybe Presence) -> Prism Stanza Presence
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Presence -> Stanza
PresenceS Stanza -> Maybe Presence
fromPresenceS
  where
    fromPresenceS :: Stanza -> Maybe Presence
fromPresenceS (PresenceS Presence
s) = Presence -> Maybe Presence
forall a. a -> Maybe a
Just Presence
s
    fromPresenceS Stanza
_ = Maybe Presence
forall a. Maybe a
Nothing

_PresenceError :: Prism Stanza PresenceError
_PresenceError :: Prism Stanza PresenceError
_PresenceError = (PresenceError -> Stanza)
-> (Stanza -> Maybe PresenceError) -> Prism Stanza PresenceError
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' PresenceError -> Stanza
PresenceErrorS Stanza -> Maybe PresenceError
fromPresenceErrorS
  where
    fromPresenceErrorS :: Stanza -> Maybe PresenceError
fromPresenceErrorS (PresenceErrorS PresenceError
s) = PresenceError -> Maybe PresenceError
forall a. a -> Maybe a
Just PresenceError
s
    fromPresenceErrorS Stanza
_ = Maybe PresenceError
forall a. Maybe a
Nothing

class IsErrorStanza s where
    -- | Error element of the stanza
    stanzaError :: Lens s StanzaError

instance IsErrorStanza IQError where
    stanzaError :: Lens IQError StanzaError
stanzaError StanzaError -> f StanzaError
inj m :: IQError
m@IQError{iqErrorStanzaError :: IQError -> StanzaError
iqErrorStanzaError = StanzaError
i} =
        (\StanzaError
i' -> IQError
m{iqErrorStanzaError = i'}) (StanzaError -> IQError) -> f StanzaError -> f IQError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StanzaError -> f StanzaError
inj StanzaError
i

instance IsErrorStanza MessageError where
    stanzaError :: Lens MessageError StanzaError
stanzaError StanzaError -> f StanzaError
inj m :: MessageError
m@MessageError{messageErrorStanzaError :: MessageError -> StanzaError
messageErrorStanzaError = StanzaError
i} =
        (\StanzaError
i' -> MessageError
m{messageErrorStanzaError = i'}) (StanzaError -> MessageError) -> f StanzaError -> f MessageError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StanzaError -> f StanzaError
inj StanzaError
i

instance IsErrorStanza PresenceError where
    stanzaError :: Lens PresenceError StanzaError
stanzaError StanzaError -> f StanzaError
inj m :: PresenceError
m@PresenceError{presenceErrorStanzaError :: PresenceError -> StanzaError
presenceErrorStanzaError = StanzaError
i} =
        (\StanzaError
i' -> PresenceError
m{presenceErrorStanzaError = i'}) (StanzaError -> PresenceError) -> f StanzaError -> f PresenceError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StanzaError -> f StanzaError
inj StanzaError
i

class HasStanzaPayload s p | s -> p where
    -- | Payload element(s) of the stanza. Since the amount of elements possible
    -- in a stanza vary by type, this lens can't be used with a general
    -- 'Stanza'. There is, however, a more general Traversable that works with
    -- all stanzas (including 'Stanza'): 'payloadT'
    payload :: Lens s p

instance HasStanzaPayload IQRequest Element where
    payload :: Lens IQRequest Element
payload Element -> f Element
inj m :: IQRequest
m@IQRequest{iqRequestPayload :: IQRequest -> Element
iqRequestPayload = Element
i} =
        (\Element
i' -> IQRequest
m{iqRequestPayload = i'}) (Element -> IQRequest) -> f Element -> f IQRequest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Element -> f Element
inj Element
i

instance HasStanzaPayload IQResult (Maybe Element) where
    payload :: Lens IQResult (Maybe Element)
payload Maybe Element -> f (Maybe Element)
inj m :: IQResult
m@IQResult{iqResultPayload :: IQResult -> Maybe Element
iqResultPayload = Maybe Element
i} =
        (\Maybe Element
i' -> IQResult
m{iqResultPayload = i'}) (Maybe Element -> IQResult) -> f (Maybe Element) -> f IQResult
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Element -> f (Maybe Element)
inj Maybe Element
i

instance HasStanzaPayload IQError (Maybe Element) where
    payload :: Lens IQError (Maybe Element)
payload Maybe Element -> f (Maybe Element)
inj m :: IQError
m@IQError{iqErrorPayload :: IQError -> Maybe Element
iqErrorPayload = Maybe Element
i} =
        (\Maybe Element
i' -> IQError
m{iqErrorPayload = i'}) (Maybe Element -> IQError) -> f (Maybe Element) -> f IQError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Element -> f (Maybe Element)
inj Maybe Element
i

instance HasStanzaPayload Message [Element] where
    payload :: Lens Message [Element]
payload [Element] -> f [Element]
inj m :: Message
m@Message{messagePayload :: Message -> [Element]
messagePayload = [Element]
i} =
        (\[Element]
i' -> Message
m{messagePayload = i'}) ([Element] -> Message) -> f [Element] -> f Message
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Element] -> f [Element]
inj [Element]
i

instance HasStanzaPayload MessageError [Element] where
    payload :: Lens MessageError [Element]
payload [Element] -> f [Element]
inj m :: MessageError
m@MessageError{messageErrorPayload :: MessageError -> [Element]
messageErrorPayload = [Element]
i} =
        (\[Element]
i' -> MessageError
m{messageErrorPayload = i'}) ([Element] -> MessageError) -> f [Element] -> f MessageError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Element] -> f [Element]
inj [Element]
i

instance HasStanzaPayload Presence [Element] where
    payload :: Lens Presence [Element]
payload [Element] -> f [Element]
inj m :: Presence
m@Presence{presencePayload :: Presence -> [Element]
presencePayload = [Element]
i} =
        (\[Element]
i' -> Presence
m{presencePayload = i'}) ([Element] -> Presence) -> f [Element] -> f Presence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Element] -> f [Element]
inj [Element]
i

instance HasStanzaPayload PresenceError [Element] where
    payload :: Lens PresenceError [Element]
payload [Element] -> f [Element]
inj m :: PresenceError
m@PresenceError{presenceErrorPayload :: PresenceError -> [Element]
presenceErrorPayload = [Element]
i} =
        (\[Element]
i' -> PresenceError
m{presenceErrorPayload = i'}) ([Element] -> PresenceError) -> f [Element] -> f PresenceError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Element] -> f [Element]
inj [Element]
i

iqRequestTypeL :: Lens IQRequest IQRequestType
iqRequestTypeL :: Lens IQRequest IQRequestType
iqRequestTypeL IQRequestType -> f IQRequestType
inj p :: IQRequest
p@IQRequest{iqRequestType :: IQRequest -> IQRequestType
iqRequestType = IQRequestType
tp} =
    (\IQRequestType
tp' -> IQRequest
p{iqRequestType = tp'}) (IQRequestType -> IQRequest) -> f IQRequestType -> f IQRequest
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IQRequestType -> f IQRequestType
inj IQRequestType
tp


messageTypeL :: Lens Message MessageType
messageTypeL :: Lens Message MessageType
messageTypeL MessageType -> f MessageType
inj p :: Message
p@Message{messageType :: Message -> MessageType
messageType = MessageType
tp} =
    (\MessageType
tp' -> Message
p{messageType = tp'}) (MessageType -> Message) -> f MessageType -> f Message
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> MessageType -> f MessageType
inj MessageType
tp

presenceTypeL :: Lens Presence PresenceType
presenceTypeL :: Lens Presence PresenceType
presenceTypeL PresenceType -> f PresenceType
inj p :: Presence
p@Presence{presenceType :: Presence -> PresenceType
presenceType = PresenceType
tp} =
    (\PresenceType
tp' -> Presence
p{presenceType = tp'}) (PresenceType -> Presence) -> f PresenceType -> f Presence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> PresenceType -> f PresenceType
inj PresenceType
tp


-- StanzaError
-----------------------

stanzaErrorTypeL :: Lens StanzaError StanzaErrorType
stanzaErrorTypeL :: Lens StanzaError StanzaErrorType
stanzaErrorTypeL StanzaErrorType -> f StanzaErrorType
inj se :: StanzaError
se@StanzaError{stanzaErrorType :: StanzaError -> StanzaErrorType
stanzaErrorType = StanzaErrorType
x} =
    (\StanzaErrorType
x' -> StanzaError
se{stanzaErrorType = x'}) (StanzaErrorType -> StanzaError)
-> f StanzaErrorType -> f StanzaError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StanzaErrorType -> f StanzaErrorType
inj StanzaErrorType
x

stanzaErrorConditionL :: Lens StanzaError StanzaErrorCondition
stanzaErrorConditionL :: Lens StanzaError StanzaErrorCondition
stanzaErrorConditionL StanzaErrorCondition -> f StanzaErrorCondition
inj se :: StanzaError
se@StanzaError{stanzaErrorCondition :: StanzaError -> StanzaErrorCondition
stanzaErrorCondition = StanzaErrorCondition
x} =
    (\StanzaErrorCondition
x' -> StanzaError
se{stanzaErrorCondition = x'}) (StanzaErrorCondition -> StanzaError)
-> f StanzaErrorCondition -> f StanzaError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StanzaErrorCondition -> f StanzaErrorCondition
inj StanzaErrorCondition
x

stanzaErrorTextL :: Lens StanzaError (Maybe (Maybe LangTag, NonemptyText))
stanzaErrorTextL :: Lens StanzaError (Maybe (Maybe LangTag, NonemptyText))
stanzaErrorTextL Maybe (Maybe LangTag, NonemptyText)
-> f (Maybe (Maybe LangTag, NonemptyText))
inj se :: StanzaError
se@StanzaError{stanzaErrorText :: StanzaError -> Maybe (Maybe LangTag, NonemptyText)
stanzaErrorText = Maybe (Maybe LangTag, NonemptyText)
x} =
    (\Maybe (Maybe LangTag, NonemptyText)
x' -> StanzaError
se{stanzaErrorText = x'}) (Maybe (Maybe LangTag, NonemptyText) -> StanzaError)
-> f (Maybe (Maybe LangTag, NonemptyText)) -> f StanzaError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Maybe LangTag, NonemptyText)
-> f (Maybe (Maybe LangTag, NonemptyText))
inj Maybe (Maybe LangTag, NonemptyText)
x

stanzaErrorApplL  :: Lens StanzaError (Maybe Element)
stanzaErrorApplL :: Lens StanzaError (Maybe Element)
stanzaErrorApplL Maybe Element -> f (Maybe Element)
inj se :: StanzaError
se@StanzaError{stanzaErrorApplicationSpecificCondition :: StanzaError -> Maybe Element
stanzaErrorApplicationSpecificCondition = Maybe Element
x} =
    (\Maybe Element
x' -> StanzaError
se{stanzaErrorApplicationSpecificCondition = x'}) (Maybe Element -> StanzaError)
-> f (Maybe Element) -> f StanzaError
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Element -> f (Maybe Element)
inj Maybe Element
x


-- StreamConfiguration
-----------------------

preferredLangL :: Lens StreamConfiguration (Maybe LangTag)
preferredLangL :: Lens StreamConfiguration (Maybe LangTag)
preferredLangL Maybe LangTag -> f (Maybe LangTag)
inj sc :: StreamConfiguration
sc@StreamConfiguration{preferredLang :: StreamConfiguration -> Maybe LangTag
preferredLang = Maybe LangTag
x}
    = (\Maybe LangTag
x' -> StreamConfiguration
sc{preferredLang = x'}) (Maybe LangTag -> StreamConfiguration)
-> f (Maybe LangTag) -> f StreamConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
x

toJidL :: Lens StreamConfiguration (Maybe (Jid, Bool))
toJidL :: Lens StreamConfiguration (Maybe (Jid, Bool))
toJidL Maybe (Jid, Bool) -> f (Maybe (Jid, Bool))
inj sc :: StreamConfiguration
sc@StreamConfiguration{toJid :: StreamConfiguration -> Maybe (Jid, Bool)
toJid = Maybe (Jid, Bool)
x}
    = (\Maybe (Jid, Bool)
x' -> StreamConfiguration
sc{toJid = x'}) (Maybe (Jid, Bool) -> StreamConfiguration)
-> f (Maybe (Jid, Bool)) -> f StreamConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Jid, Bool) -> f (Maybe (Jid, Bool))
inj Maybe (Jid, Bool)
x

connectionDetailsL :: Lens StreamConfiguration ConnectionDetails
connectionDetailsL :: Lens StreamConfiguration ConnectionDetails
connectionDetailsL ConnectionDetails -> f ConnectionDetails
inj sc :: StreamConfiguration
sc@StreamConfiguration{connectionDetails :: StreamConfiguration -> ConnectionDetails
connectionDetails = ConnectionDetails
x}
    = (\ConnectionDetails
x' -> StreamConfiguration
sc{connectionDetails = x'}) (ConnectionDetails -> StreamConfiguration)
-> f ConnectionDetails -> f StreamConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ConnectionDetails -> f ConnectionDetails
inj ConnectionDetails
x

resolvConfL :: Lens StreamConfiguration ResolvConf
resolvConfL :: Lens StreamConfiguration ResolvConf
resolvConfL ResolvConf -> f ResolvConf
inj sc :: StreamConfiguration
sc@StreamConfiguration{resolvConf :: StreamConfiguration -> ResolvConf
resolvConf = ResolvConf
x}
    = (\ResolvConf
x' -> StreamConfiguration
sc{resolvConf = x'}) (ResolvConf -> StreamConfiguration)
-> f ResolvConf -> f StreamConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ResolvConf -> f ResolvConf
inj ResolvConf
x

tlsBehaviourL :: Lens StreamConfiguration TlsBehaviour
tlsBehaviourL :: Lens StreamConfiguration TlsBehaviour
tlsBehaviourL TlsBehaviour -> f TlsBehaviour
inj sc :: StreamConfiguration
sc@StreamConfiguration{tlsBehaviour :: StreamConfiguration -> TlsBehaviour
tlsBehaviour = TlsBehaviour
x}
    = (\TlsBehaviour
x' -> StreamConfiguration
sc{tlsBehaviour = x'}) (TlsBehaviour -> StreamConfiguration)
-> f TlsBehaviour -> f StreamConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TlsBehaviour -> f TlsBehaviour
inj TlsBehaviour
x


tlsParamsL :: Lens StreamConfiguration ClientParams
tlsParamsL :: Lens StreamConfiguration ClientParams
tlsParamsL ClientParams -> f ClientParams
inj sc :: StreamConfiguration
sc@StreamConfiguration{tlsParams :: StreamConfiguration -> ClientParams
tlsParams = ClientParams
x}
    = (\ClientParams
x' -> StreamConfiguration
sc{tlsParams = x'}) (ClientParams -> StreamConfiguration)
-> f ClientParams -> f StreamConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> ClientParams -> f ClientParams
inj ClientParams
x

-- TLS parameters
-----------------

clientServerIdentificationL  :: Lens ClientParams (String, BS.ByteString)
clientServerIdentificationL :: Lens ClientParams (String, ByteString)
clientServerIdentificationL (String, ByteString) -> f (String, ByteString)
inj ClientParams
cp
    = (\(String, ByteString)
x' -> ClientParams
cp{clientServerIdentification = x'}) ((String, ByteString) -> ClientParams)
-> f (String, ByteString) -> f ClientParams
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (String, ByteString) -> f (String, ByteString)
inj (ClientParams -> (String, ByteString)
clientServerIdentification ClientParams
cp)

clientSupportedL  :: Lens ClientParams Supported
clientSupportedL :: Lens ClientParams Supported
clientSupportedL Supported -> f Supported
inj ClientParams
cp
    = (\Supported
x' -> ClientParams
cp{clientSupported = x'}) (Supported -> ClientParams) -> f Supported -> f ClientParams
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Supported -> f Supported
inj (ClientParams -> Supported
clientSupported ClientParams
cp)

clientUseServerNameIndicationL  :: Lens ClientParams Bool
clientUseServerNameIndicationL :: Lens ClientParams Bool
clientUseServerNameIndicationL Bool -> f Bool
inj ClientParams
cp
    = (\Bool
x' -> ClientParams
cp{clientUseServerNameIndication = x'}) (Bool -> ClientParams) -> f Bool -> f ClientParams
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> f Bool
inj (ClientParams -> Bool
clientUseServerNameIndication ClientParams
cp)

supportedCiphersL :: Lens Supported [Cipher]
supportedCiphersL :: Lens Supported [Cipher]
supportedCiphersL [Cipher] -> f [Cipher]
inj Supported
s
    = (\[Cipher]
x' -> Supported
s{supportedCiphers = x'}) ([Cipher] -> Supported) -> f [Cipher] -> f Supported
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Cipher] -> f [Cipher]
inj (Supported -> [Cipher]
supportedCiphers Supported
s)

supportedVersionsL :: Lens Supported [TLS.Version]
supportedVersionsL :: Lens Supported [Version]
supportedVersionsL [Version] -> f [Version]
inj Supported
s
    = (\[Version]
x' -> Supported
s{supportedVersions = x'}) ([Version] -> Supported) -> f [Version] -> f Supported
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Version] -> f [Version]
inj (Supported -> [Version]
supportedVersions Supported
s)

-- SessionConfiguration
-----------------------
streamConfigurationL :: Lens SessionConfiguration StreamConfiguration
streamConfigurationL :: Lens SessionConfiguration StreamConfiguration
streamConfigurationL StreamConfiguration -> f StreamConfiguration
inj sc :: SessionConfiguration
sc@SessionConfiguration{sessionStreamConfiguration :: SessionConfiguration -> StreamConfiguration
sessionStreamConfiguration = StreamConfiguration
x}
    = (\StreamConfiguration
x' -> SessionConfiguration
sc{sessionStreamConfiguration = x'}) (StreamConfiguration -> SessionConfiguration)
-> f StreamConfiguration -> f SessionConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StreamConfiguration -> f StreamConfiguration
inj StreamConfiguration
x

onConnectionClosedL :: Lens SessionConfiguration (Session -> XmppFailure -> IO ())
onConnectionClosedL :: Lens SessionConfiguration (Session -> XmppFailure -> IO ())
onConnectionClosedL (Session -> XmppFailure -> IO ())
-> f (Session -> XmppFailure -> IO ())
inj sc :: SessionConfiguration
sc@SessionConfiguration{onConnectionClosed :: SessionConfiguration -> Session -> XmppFailure -> IO ()
onConnectionClosed = Session -> XmppFailure -> IO ()
x}
    = (\Session -> XmppFailure -> IO ()
x' -> SessionConfiguration
sc{onConnectionClosed = x'}) ((Session -> XmppFailure -> IO ()) -> SessionConfiguration)
-> f (Session -> XmppFailure -> IO ()) -> f SessionConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (Session -> XmppFailure -> IO ())
-> f (Session -> XmppFailure -> IO ())
inj Session -> XmppFailure -> IO ()
x

sessionStanzaIDsL :: Lens SessionConfiguration (IO (IO Text))
sessionStanzaIDsL :: Lens SessionConfiguration (IO (IO Text))
sessionStanzaIDsL IO (IO Text) -> f (IO (IO Text))
inj sc :: SessionConfiguration
sc@SessionConfiguration{sessionStanzaIDs :: SessionConfiguration -> IO (IO Text)
sessionStanzaIDs = IO (IO Text)
x}
    = (\IO (IO Text)
x' -> SessionConfiguration
sc{sessionStanzaIDs = x'}) (IO (IO Text) -> SessionConfiguration)
-> f (IO (IO Text)) -> f SessionConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO (IO Text) -> f (IO (IO Text))
inj IO (IO Text)
x

ensableRosterL :: Lens SessionConfiguration Bool
ensableRosterL :: Lens SessionConfiguration Bool
ensableRosterL Bool -> f Bool
inj sc :: SessionConfiguration
sc@SessionConfiguration{enableRoster :: SessionConfiguration -> Bool
enableRoster = Bool
x}
    = (\Bool
x' -> SessionConfiguration
sc{enableRoster = x'}) (Bool -> SessionConfiguration) -> f Bool -> f SessionConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> f Bool
inj Bool
x

onRosterPushL :: Lens SessionConfiguration (Maybe RosterPushCallback)
onRosterPushL :: Lens SessionConfiguration (Maybe RosterPushCallback)
onRosterPushL = (SessionConfiguration -> Maybe RosterPushCallback)
-> (Maybe RosterPushCallback
    -> SessionConfiguration -> SessionConfiguration)
-> Lens SessionConfiguration (Maybe RosterPushCallback)
forall a b. (a -> b) -> (b -> a -> a) -> Lens a b
mkLens SessionConfiguration -> Maybe RosterPushCallback
onRosterPush (\Maybe RosterPushCallback
orp SessionConfiguration
x -> SessionConfiguration
x{onRosterPush = orp})

pluginsL :: Lens SessionConfiguration [Plugin]
pluginsL :: Lens SessionConfiguration [Plugin]
pluginsL [Plugin] -> f [Plugin]
inj sc :: SessionConfiguration
sc@SessionConfiguration{plugins :: SessionConfiguration -> [Plugin]
plugins = [Plugin]
x}
    = (\[Plugin]
x' -> SessionConfiguration
sc{plugins = x'}) ([Plugin] -> SessionConfiguration)
-> f [Plugin] -> f SessionConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Plugin] -> f [Plugin]
inj [Plugin]
x

onPresenceChangeL :: Lens SessionConfiguration (Maybe ( Jid -> PeerStatus
                                                        -> PeerStatus -> IO ()))
onPresenceChangeL :: Lens
  SessionConfiguration
  (Maybe (Jid -> PeerStatus -> PeerStatus -> IO ()))
onPresenceChangeL Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
-> f (Maybe (Jid -> PeerStatus -> PeerStatus -> IO ()))
inj sc :: SessionConfiguration
sc@SessionConfiguration{onPresenceChange :: SessionConfiguration
-> Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
onPresenceChange = Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
x}
    = (\Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
x' -> SessionConfiguration
sc{onPresenceChange = x'}) (Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
 -> SessionConfiguration)
-> f (Maybe (Jid -> PeerStatus -> PeerStatus -> IO ()))
-> f SessionConfiguration
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
-> f (Maybe (Jid -> PeerStatus -> PeerStatus -> IO ()))
inj Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
x

-- | Access clientServerIdentification inside tlsParams inside streamConfiguration
tlsServerIdentificationL  :: Lens SessionConfiguration (String, BS.ByteString)
tlsServerIdentificationL :: Lens SessionConfiguration (String, ByteString)
tlsServerIdentificationL = (StreamConfiguration -> f StreamConfiguration)
-> SessionConfiguration -> f SessionConfiguration
Lens SessionConfiguration StreamConfiguration
streamConfigurationL
                         ((StreamConfiguration -> f StreamConfiguration)
 -> SessionConfiguration -> f SessionConfiguration)
-> (((String, ByteString) -> f (String, ByteString))
    -> StreamConfiguration -> f StreamConfiguration)
-> ((String, ByteString) -> f (String, ByteString))
-> SessionConfiguration
-> f SessionConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClientParams -> f ClientParams)
-> StreamConfiguration -> f StreamConfiguration
Lens StreamConfiguration ClientParams
tlsParamsL
                         ((ClientParams -> f ClientParams)
 -> StreamConfiguration -> f StreamConfiguration)
-> (((String, ByteString) -> f (String, ByteString))
    -> ClientParams -> f ClientParams)
-> ((String, ByteString) -> f (String, ByteString))
-> StreamConfiguration
-> f StreamConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ((String, ByteString) -> f (String, ByteString))
-> ClientParams -> f ClientParams
Lens ClientParams (String, ByteString)
clientServerIdentificationL

-- | Access clientUseServerNameIndication inside tlsParams
tlsUseNameIndicationL :: Lens SessionConfiguration Bool
tlsUseNameIndicationL :: Lens SessionConfiguration Bool
tlsUseNameIndicationL = (StreamConfiguration -> f StreamConfiguration)
-> SessionConfiguration -> f SessionConfiguration
Lens SessionConfiguration StreamConfiguration
streamConfigurationL
                      ((StreamConfiguration -> f StreamConfiguration)
 -> SessionConfiguration -> f SessionConfiguration)
-> ((Bool -> f Bool)
    -> StreamConfiguration -> f StreamConfiguration)
-> (Bool -> f Bool)
-> SessionConfiguration
-> f SessionConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClientParams -> f ClientParams)
-> StreamConfiguration -> f StreamConfiguration
Lens StreamConfiguration ClientParams
tlsParamsL
                      ((ClientParams -> f ClientParams)
 -> StreamConfiguration -> f StreamConfiguration)
-> ((Bool -> f Bool) -> ClientParams -> f ClientParams)
-> (Bool -> f Bool)
-> StreamConfiguration
-> f StreamConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Bool -> f Bool) -> ClientParams -> f ClientParams
Lens ClientParams Bool
clientUseServerNameIndicationL

-- | Access supportedCiphers inside clientSupported inside tlsParams
tlsSupportedCiphersL :: Lens SessionConfiguration [Cipher]
tlsSupportedCiphersL :: Lens SessionConfiguration [Cipher]
tlsSupportedCiphersL =  (StreamConfiguration -> f StreamConfiguration)
-> SessionConfiguration -> f SessionConfiguration
Lens SessionConfiguration StreamConfiguration
streamConfigurationL
                     ((StreamConfiguration -> f StreamConfiguration)
 -> SessionConfiguration -> f SessionConfiguration)
-> (([Cipher] -> f [Cipher])
    -> StreamConfiguration -> f StreamConfiguration)
-> ([Cipher] -> f [Cipher])
-> SessionConfiguration
-> f SessionConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
.  (ClientParams -> f ClientParams)
-> StreamConfiguration -> f StreamConfiguration
Lens StreamConfiguration ClientParams
tlsParamsL ((ClientParams -> f ClientParams)
 -> StreamConfiguration -> f StreamConfiguration)
-> (([Cipher] -> f [Cipher]) -> ClientParams -> f ClientParams)
-> ([Cipher] -> f [Cipher])
-> StreamConfiguration
-> f StreamConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Supported -> f Supported) -> ClientParams -> f ClientParams
Lens ClientParams Supported
clientSupportedL ((Supported -> f Supported) -> ClientParams -> f ClientParams)
-> (([Cipher] -> f [Cipher]) -> Supported -> f Supported)
-> ([Cipher] -> f [Cipher])
-> ClientParams
-> f ClientParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Cipher] -> f [Cipher]) -> Supported -> f Supported
Lens Supported [Cipher]
supportedCiphersL

-- | Access supportedVersions inside clientSupported inside tlsParams
tlsSupportedVersionsL :: Lens SessionConfiguration [TLS.Version]
tlsSupportedVersionsL :: Lens SessionConfiguration [Version]
tlsSupportedVersionsL = (StreamConfiguration -> f StreamConfiguration)
-> SessionConfiguration -> f SessionConfiguration
Lens SessionConfiguration StreamConfiguration
streamConfigurationL
                      ((StreamConfiguration -> f StreamConfiguration)
 -> SessionConfiguration -> f SessionConfiguration)
-> (([Version] -> f [Version])
    -> StreamConfiguration -> f StreamConfiguration)
-> ([Version] -> f [Version])
-> SessionConfiguration
-> f SessionConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ClientParams -> f ClientParams)
-> StreamConfiguration -> f StreamConfiguration
Lens StreamConfiguration ClientParams
tlsParamsL ((ClientParams -> f ClientParams)
 -> StreamConfiguration -> f StreamConfiguration)
-> (([Version] -> f [Version]) -> ClientParams -> f ClientParams)
-> ([Version] -> f [Version])
-> StreamConfiguration
-> f StreamConfiguration
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Supported -> f Supported) -> ClientParams -> f ClientParams
Lens ClientParams Supported
clientSupportedL ((Supported -> f Supported) -> ClientParams -> f ClientParams)
-> (([Version] -> f [Version]) -> Supported -> f Supported)
-> ([Version] -> f [Version])
-> ClientParams
-> f ClientParams
forall b c a. (b -> c) -> (a -> b) -> a -> c
. ([Version] -> f [Version]) -> Supported -> f Supported
Lens Supported [Version]
supportedVersionsL


-- Roster
------------------

verL :: Lens Roster (Maybe Text)
verL :: Lens Roster (Maybe Text)
verL Maybe Text -> f (Maybe Text)
inj r :: Roster
r@Roster{ver :: Roster -> Maybe Text
ver = Maybe Text
x} = (\Maybe Text
x' -> Roster
r{ver = x'}) (Maybe Text -> Roster) -> f (Maybe Text) -> f Roster
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
x

itemsL :: Lens Roster (Map.Map Jid Item)
itemsL :: Lens Roster (Map Jid Item)
itemsL Map Jid Item -> f (Map Jid Item)
inj r :: Roster
r@Roster{items :: Roster -> Map Jid Item
items = Map Jid Item
x} = (\Map Jid Item
x' -> Roster
r{items = x'}) (Map Jid Item -> Roster) -> f (Map Jid Item) -> f Roster
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Map Jid Item -> f (Map Jid Item)
inj Map Jid Item
x

-- Item
------------------

riApprovedL :: Lens Item Bool
riApprovedL :: Lens Item Bool
riApprovedL Bool -> f Bool
inj i :: Item
i@Item{riApproved :: Item -> Bool
riApproved = Bool
x} = (\Bool
x' -> Item
i{riApproved = x'}) (Bool -> Item) -> f Bool -> f Item
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> f Bool
inj Bool
x

riAskL :: Lens Item Bool
riAskL :: Lens Item Bool
riAskL Bool -> f Bool
inj i :: Item
i@Item{riAsk :: Item -> Bool
riAsk = Bool
x} = (\Bool
x' -> Item
i{riAsk = x'}) (Bool -> Item) -> f Bool -> f Item
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> f Bool
inj Bool
x

riJidL :: Lens Item Jid
riJidL :: Lens Item Jid
riJidL Jid -> f Jid
inj i :: Item
i@Item{riJid :: Item -> Jid
riJid = Jid
x} = (\Jid
x' -> Item
i{riJid = x'}) (Jid -> Item) -> f Jid -> f Item
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Jid -> f Jid
inj Jid
x

riNameL :: Lens Item (Maybe Text)
riNameL :: Lens Item (Maybe Text)
riNameL Maybe Text -> f (Maybe Text)
inj i :: Item
i@Item{riName :: Item -> Maybe Text
riName = Maybe Text
x} = (\Maybe Text
x' -> Item
i{riName = x'}) (Maybe Text -> Item) -> f (Maybe Text) -> f Item
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
x

riSubscriptionL :: Lens Item Subscription
riSubscriptionL :: Lens Item Subscription
riSubscriptionL Subscription -> f Subscription
inj i :: Item
i@Item{riSubscription :: Item -> Subscription
riSubscription = Subscription
x} =
    (\Subscription
x' -> Item
i{riSubscription = x'}) (Subscription -> Item) -> f Subscription -> f Item
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Subscription -> f Subscription
inj Subscription
x

riGroupsL :: Lens Item [Text]
riGroupsL :: Lens Item [Text]
riGroupsL [Text] -> f [Text]
inj i :: Item
i@Item{riGroups :: Item -> [Text]
riGroups = [Text]
x} = (\[Text]
x' -> Item
i{riGroups = x'}) ([Text] -> Item) -> f [Text] -> f Item
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Text] -> f [Text]
inj [Text]
x

-- Roster Update
-------------------

_RosterUpdateRemove :: Prism RosterUpdate Jid
_RosterUpdateRemove :: Prism RosterUpdate Jid
_RosterUpdateRemove = (Jid -> RosterUpdate)
-> (RosterUpdate -> Maybe Jid) -> Prism RosterUpdate Jid
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Jid -> RosterUpdate
RosterUpdateRemove RosterUpdate -> Maybe Jid
fromRosterUpdateRemove
  where
    fromRosterUpdateRemove :: RosterUpdate -> Maybe Jid
fromRosterUpdateRemove (RosterUpdateRemove Jid
jid) = Jid -> Maybe Jid
forall a. a -> Maybe a
Just Jid
jid
    fromRosterUpdateRemove RosterUpdateAdd{} = Maybe Jid
forall a. Maybe a
Nothing

_RosterUpdateAdd :: Prism RosterUpdate Item
_RosterUpdateAdd :: Prism RosterUpdate Item
_RosterUpdateAdd = (Item -> RosterUpdate)
-> (RosterUpdate -> Maybe Item) -> Prism RosterUpdate Item
forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Item -> RosterUpdate
RosterUpdateAdd RosterUpdate -> Maybe Item
fromRosterUpdateAdd
  where
    fromRosterUpdateAdd :: RosterUpdate -> Maybe Item
fromRosterUpdateAdd RosterUpdateRemove{} = Maybe Item
forall a. Maybe a
Nothing
    fromRosterUpdateAdd (RosterUpdateAdd Item
item) = Item -> Maybe Item
forall a. a -> Maybe a
Just Item
item


-- QueryItem
-------------------
qiApprovedL :: Lens QueryItem (Maybe Bool)
qiApprovedL :: Lens QueryItem (Maybe Bool)
qiApprovedL Maybe Bool -> f (Maybe Bool)
inj i :: QueryItem
i@QueryItem{qiApproved :: QueryItem -> Maybe Bool
qiApproved = Maybe Bool
x} =
    (\Maybe Bool
x' -> QueryItem
i{qiApproved = x'}) (Maybe Bool -> QueryItem) -> f (Maybe Bool) -> f QueryItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Bool -> f (Maybe Bool)
inj Maybe Bool
x

qiAskL :: Lens QueryItem Bool
qiAskL :: Lens QueryItem Bool
qiAskL Bool -> f Bool
inj i :: QueryItem
i@QueryItem{qiAsk :: QueryItem -> Bool
qiAsk = Bool
x} = (\Bool
x' -> QueryItem
i{qiAsk = x'}) (Bool -> QueryItem) -> f Bool -> f QueryItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Bool -> f Bool
inj Bool
x

qiJidL :: Lens QueryItem Jid
qiJidL :: Lens QueryItem Jid
qiJidL Jid -> f Jid
inj i :: QueryItem
i@QueryItem{qiJid :: QueryItem -> Jid
qiJid = Jid
x} = (\Jid
x' -> QueryItem
i{qiJid = x'}) (Jid -> QueryItem) -> f Jid -> f QueryItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Jid -> f Jid
inj Jid
x

qiNameL :: Lens QueryItem (Maybe Text)
qiNameL :: Lens QueryItem (Maybe Text)
qiNameL Maybe Text -> f (Maybe Text)
inj i :: QueryItem
i@QueryItem{qiName :: QueryItem -> Maybe Text
qiName = Maybe Text
x} = (\Maybe Text
x' -> QueryItem
i{qiName = x'}) (Maybe Text -> QueryItem) -> f (Maybe Text) -> f QueryItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
x

qiSubscriptionL :: Lens QueryItem (Maybe Subscription)
qiSubscriptionL :: Lens QueryItem (Maybe Subscription)
qiSubscriptionL Maybe Subscription -> f (Maybe Subscription)
inj i :: QueryItem
i@QueryItem{qiSubscription :: QueryItem -> Maybe Subscription
qiSubscription = Maybe Subscription
x} =
    (\Maybe Subscription
x' -> QueryItem
i{qiSubscription = x'}) (Maybe Subscription -> QueryItem)
-> f (Maybe Subscription) -> f QueryItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Subscription -> f (Maybe Subscription)
inj Maybe Subscription
x

qiGroupsL :: Lens QueryItem [Text]
qiGroupsL :: Lens QueryItem [Text]
qiGroupsL [Text] -> f [Text]
inj i :: QueryItem
i@QueryItem{qiGroups :: QueryItem -> [Text]
qiGroups = [Text]
x} = (\[Text]
x' -> QueryItem
i{qiGroups = x'}) ([Text] -> QueryItem) -> f [Text] -> f QueryItem
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [Text] -> f [Text]
inj [Text]
x

queryVerL :: Lens Query (Maybe Text)
queryVerL :: Lens Query (Maybe Text)
queryVerL Maybe Text -> f (Maybe Text)
inj i :: Query
i@Query{queryVer :: Query -> Maybe Text
queryVer = Maybe Text
x} = (\Maybe Text
x' -> Query
i{queryVer = x'}) (Maybe Text -> Query) -> f (Maybe Text) -> f Query
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
x

queryItemsL :: Lens Query [QueryItem]
queryItemsL :: Lens Query [QueryItem]
queryItemsL [QueryItem] -> f [QueryItem]
inj i :: Query
i@Query{queryItems :: Query -> [QueryItem]
queryItems = [QueryItem]
x} = (\[QueryItem]
x' -> Query
i{queryItems = x'}) ([QueryItem] -> Query) -> f [QueryItem] -> f Query
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [QueryItem] -> f [QueryItem]
inj [QueryItem]
x


-- IM
-------------------


bodyLangL :: Lens MessageBody (Maybe LangTag)
bodyLangL :: Lens MessageBody (Maybe LangTag)
bodyLangL Maybe LangTag -> f (Maybe LangTag)
inj m :: MessageBody
m@MessageBody{bodyLang :: MessageBody -> Maybe LangTag
bodyLang = Maybe LangTag
bl} = (\Maybe LangTag
bl' -> MessageBody
m{bodyLang = bl'}) (Maybe LangTag -> MessageBody)
-> f (Maybe LangTag) -> f MessageBody
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
bl

bodyContentL :: Lens MessageBody Text
bodyContentL :: Lens MessageBody Text
bodyContentL Text -> f Text
inj m :: MessageBody
m@MessageBody{bodyContent :: MessageBody -> Text
bodyContent = Text
bc} =
    (\Text
bc' -> MessageBody
m{bodyContent = bc'}) (Text -> MessageBody) -> f Text -> f MessageBody
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> f Text
inj Text
bc

threadIdL :: Lens MessageThread Text
threadIdL :: Lens MessageThread Text
threadIdL Text -> f Text
inj m :: MessageThread
m@MessageThread{threadID :: MessageThread -> Text
threadID = Text
bc} =
    (\Text
bc' -> MessageThread
m{threadID = bc'}) (Text -> MessageThread) -> f Text -> f MessageThread
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> f Text
inj Text
bc

threadParentL :: Lens MessageThread (Maybe Text)
threadParentL :: Lens MessageThread (Maybe Text)
threadParentL Maybe Text -> f (Maybe Text)
inj m :: MessageThread
m@MessageThread{threadParent :: MessageThread -> Maybe Text
threadParent = Maybe Text
bc} =
    (\Maybe Text
bc' -> MessageThread
m{threadParent = bc'}) (Maybe Text -> MessageThread) -> f (Maybe Text) -> f MessageThread
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
bc

subjectLangL :: Lens MessageSubject (Maybe LangTag)
subjectLangL :: Lens MessageSubject (Maybe LangTag)
subjectLangL Maybe LangTag -> f (Maybe LangTag)
inj m :: MessageSubject
m@MessageSubject{subjectLang :: MessageSubject -> Maybe LangTag
subjectLang = Maybe LangTag
bc} =
    (\Maybe LangTag
bc' -> MessageSubject
m{subjectLang = bc'}) (Maybe LangTag -> MessageSubject)
-> f (Maybe LangTag) -> f MessageSubject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe LangTag -> f (Maybe LangTag)
inj Maybe LangTag
bc

subjectContentL :: Lens MessageSubject Text
subjectContentL :: Lens MessageSubject Text
subjectContentL Text -> f Text
inj m :: MessageSubject
m@MessageSubject{subjectContent :: MessageSubject -> Text
subjectContent = Text
bc} =
    (\Text
bc' -> MessageSubject
m{subjectContent = bc'}) (Text -> MessageSubject) -> f Text -> f MessageSubject
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Text -> f Text
inj Text
bc

imThreadL :: Lens InstantMessage (Maybe MessageThread)
imThreadL :: Lens InstantMessage (Maybe MessageThread)
imThreadL Maybe MessageThread -> f (Maybe MessageThread)
inj m :: InstantMessage
m@InstantMessage{imThread :: InstantMessage -> Maybe MessageThread
imThread = Maybe MessageThread
bc} =
    (\Maybe MessageThread
bc' -> InstantMessage
m{imThread = bc'}) (Maybe MessageThread -> InstantMessage)
-> f (Maybe MessageThread) -> f InstantMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe MessageThread -> f (Maybe MessageThread)
inj Maybe MessageThread
bc

imSubjectL :: Lens InstantMessage [MessageSubject]
imSubjectL :: Lens InstantMessage [MessageSubject]
imSubjectL [MessageSubject] -> f [MessageSubject]
inj m :: InstantMessage
m@InstantMessage{imSubject :: InstantMessage -> [MessageSubject]
imSubject = [MessageSubject]
bc} =
    (\[MessageSubject]
bc' -> InstantMessage
m{imSubject = bc'}) ([MessageSubject] -> InstantMessage)
-> f [MessageSubject] -> f InstantMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [MessageSubject] -> f [MessageSubject]
inj [MessageSubject]
bc

imBodyL :: Lens InstantMessage [MessageBody]
imBodyL :: Lens InstantMessage [MessageBody]
imBodyL [MessageBody] -> f [MessageBody]
inj m :: InstantMessage
m@InstantMessage{imBody :: InstantMessage -> [MessageBody]
imBody = [MessageBody]
bc} =
    (\[MessageBody]
bc' -> InstantMessage
m{imBody = bc'}) ([MessageBody] -> InstantMessage)
-> f [MessageBody] -> f InstantMessage
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> [MessageBody] -> f [MessageBody]
inj [MessageBody]
bc

-- IM Presence
------------------

showStatusL :: Lens IMPresence (Maybe ShowStatus)
showStatusL :: Lens IMPresence (Maybe ShowStatus)
showStatusL Maybe ShowStatus -> f (Maybe ShowStatus)
inj m :: IMPresence
m@IMP{showStatus :: IMPresence -> Maybe ShowStatus
showStatus = Maybe ShowStatus
bc} =
    (\Maybe ShowStatus
bc' -> IMPresence
m{showStatus = bc'}) (Maybe ShowStatus -> IMPresence)
-> f (Maybe ShowStatus) -> f IMPresence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe ShowStatus -> f (Maybe ShowStatus)
inj Maybe ShowStatus
bc

statusL :: Lens IMPresence (Maybe Text)
statusL :: Lens IMPresence (Maybe Text)
statusL Maybe Text -> f (Maybe Text)
inj m :: IMPresence
m@IMP{status :: IMPresence -> Maybe Text
status = Maybe Text
bc} =
    (\Maybe Text
bc' -> IMPresence
m{status = bc'}) (Maybe Text -> IMPresence) -> f (Maybe Text) -> f IMPresence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Text -> f (Maybe Text)
inj Maybe Text
bc

priorityL :: Lens IMPresence (Maybe Int)
priorityL :: Lens IMPresence (Maybe Int)
priorityL Maybe Int -> f (Maybe Int)
inj m :: IMPresence
m@IMP{priority :: IMPresence -> Maybe Int
priority = Maybe Int
bc} =
    (\Maybe Int
bc' -> IMPresence
m{priority = bc'}) (Maybe Int -> IMPresence) -> f (Maybe Int) -> f IMPresence
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Maybe Int -> f (Maybe Int)
inj Maybe Int
bc

-- StreamFeatures
-------------------

featureTlsL :: Lens StreamFeatures (Maybe Bool)
featureTlsL :: Lens StreamFeatures (Maybe Bool)
featureTlsL = (StreamFeatures -> Maybe Bool)
-> (Maybe Bool -> StreamFeatures -> StreamFeatures)
-> Lens StreamFeatures (Maybe Bool)
forall a b. (a -> b) -> (b -> a -> a) -> Lens a b
mkLens StreamFeatures -> Maybe Bool
streamFeaturesTls (\Maybe Bool
x StreamFeatures
sf -> StreamFeatures
sf{streamFeaturesTls = x})

featureMechanismsL :: Lens StreamFeatures [Text]
featureMechanismsL :: Lens StreamFeatures [Text]
featureMechanismsL =
    (StreamFeatures -> [Text])
-> ([Text] -> StreamFeatures -> StreamFeatures)
-> Lens StreamFeatures [Text]
forall a b. (a -> b) -> (b -> a -> a) -> Lens a b
mkLens StreamFeatures -> [Text]
streamFeaturesMechanisms (\[Text]
x StreamFeatures
sf -> StreamFeatures
sf{streamFeaturesMechanisms = x})

featureRosterVerL :: Lens StreamFeatures (Maybe Bool)
featureRosterVerL :: Lens StreamFeatures (Maybe Bool)
featureRosterVerL =
    (StreamFeatures -> Maybe Bool)
-> (Maybe Bool -> StreamFeatures -> StreamFeatures)
-> Lens StreamFeatures (Maybe Bool)
forall a b. (a -> b) -> (b -> a -> a) -> Lens a b
mkLens StreamFeatures -> Maybe Bool
streamFeaturesRosterVer (\Maybe Bool
x StreamFeatures
sf -> StreamFeatures
sf{streamFeaturesRosterVer = x})

featurePreApprovalL :: Lens StreamFeatures Bool
featurePreApprovalL :: Lens StreamFeatures Bool
featurePreApprovalL =
    (StreamFeatures -> Bool)
-> (Bool -> StreamFeatures -> StreamFeatures)
-> Lens StreamFeatures Bool
forall a b. (a -> b) -> (b -> a -> a) -> Lens a b
mkLens StreamFeatures -> Bool
streamFeaturesPreApproval (\Bool
x StreamFeatures
sf -> StreamFeatures
sf{streamFeaturesPreApproval = x})

featuresOtherL :: Lens StreamFeatures [Element]
featuresOtherL :: Lens StreamFeatures [Element]
featuresOtherL =
    (StreamFeatures -> [Element])
-> ([Element] -> StreamFeatures -> StreamFeatures)
-> Lens StreamFeatures [Element]
forall a b. (a -> b) -> (b -> a -> a) -> Lens a b
mkLens StreamFeatures -> [Element]
streamFeaturesOther (\[Element]
x StreamFeatures
sf -> StreamFeatures
sf{streamFeaturesOther = x})