{-# 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' :: (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 (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 (f :: * -> *) a. Applicative f => a -> f a
pure ((b -> s) -> f b -> f s
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 (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 :: (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 (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 :: (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 (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 (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> a
f)

newtype Collect a b = Collect {Collect a b -> [a]
getCollection :: [a]} deriving (a -> b) -> Collect a a -> Collect a b
(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
<$ :: a -> Collect a b -> Collect a a
$c<$ :: forall a a b. a -> Collect a b -> Collect a a
fmap :: (a -> b) -> Collect a a -> Collect a b
$cfmap :: forall a a b. (a -> b) -> Collect a a -> Collect a b
Functor

instance Applicative (Collect a) where
    pure :: a -> Collect a a
pure a
_ = [a] -> Collect a a
forall a b. [a] -> Collect a b
Collect []
    Collect [a]
xs <*> :: 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 :: 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 (f :: * -> *) a. Applicative f => a -> f a
pure)

{-# DEPRECATED modify "use over (lens-family, lens)" #-}
modify :: Traversal a b -> (b -> b) -> a -> a
modify :: 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 :: p Jid (f Jid) -> p Text (f Text)
_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 :: p Jid (f Jid) -> p Jid (f 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 :: p Jid (f Jid) -> p Jid (f 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 :: p Stanza (f Stanza) -> p XmppElement (f XmppElement)
_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 :: p Element (f Element) -> p XmppElement (f XmppElement)
_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 :: (a -> f a) -> [a] -> f [a]
traverseList a -> f a
_inj [] = [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 (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> (a -> f a) -> [a] -> f [a]
forall a. Traversal [a] a
traverseList a -> f a
inj [a]
xs

instance IsStanza Message where
    from :: (Maybe Jid -> f (Maybe Jid)) -> Message -> f Message
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 :: Maybe Jid
messageFrom = Maybe Jid
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 :: (Maybe Jid -> f (Maybe Jid)) -> Message -> f Message
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 :: Maybe Jid
messageTo = Maybe Jid
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 :: (Maybe LangTag -> f (Maybe LangTag)) -> Message -> f Message
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 :: Maybe LangTag
messageLangTag = Maybe LangTag
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 :: (Maybe Text -> f (Maybe Text)) -> Message -> f Message
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 :: Maybe Text
messageID = Maybe Text
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 :: (Element -> f Element) -> Message -> f Message
payloadT Element -> f Element
inj m :: Message
m@(Message{messagePayload :: Message -> [Element]
messagePayload=[Element]
pl}) =
        (\[Element]
pl' -> Message
m{messagePayload :: [Element]
messagePayload=[Element]
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. Traversal [a] a
traverseList Element -> f Element
inj [Element]
pl


instance IsStanza MessageError where
    from :: (Maybe Jid -> f (Maybe Jid)) -> MessageError -> f MessageError
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 :: Maybe Jid
messageErrorFrom = Maybe Jid
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 :: (Maybe Jid -> f (Maybe Jid)) -> MessageError -> f MessageError
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 :: Maybe Jid
messageErrorTo = Maybe Jid
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 :: (Maybe LangTag -> f (Maybe LangTag))
-> MessageError -> f MessageError
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 :: Maybe LangTag
messageErrorLangTag = Maybe LangTag
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 :: (Maybe Text -> f (Maybe Text)) -> MessageError -> f MessageError
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 :: Maybe Text
messageErrorID = Maybe Text
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 :: (Element -> f Element) -> MessageError -> f MessageError
payloadT Element -> f Element
inj m :: MessageError
m@(MessageError{messageErrorPayload :: MessageError -> [Element]
messageErrorPayload=[Element]
pl}) =
        (\[Element]
pl' -> MessageError
m{messageErrorPayload :: [Element]
messageErrorPayload=[Element]
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. Traversal [a] a
traverseList Element -> f Element
inj [Element]
pl

instance IsStanza Presence where
    from :: (Maybe Jid -> f (Maybe Jid)) -> Presence -> f Presence
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 :: Maybe Jid
presenceFrom = Maybe Jid
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 :: (Maybe Jid -> f (Maybe Jid)) -> Presence -> f Presence
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 :: Maybe Jid
presenceTo = Maybe Jid
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 :: (Maybe LangTag -> f (Maybe LangTag)) -> Presence -> f Presence
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 :: Maybe LangTag
presenceLangTag = Maybe LangTag
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 :: (Maybe Text -> f (Maybe Text)) -> Presence -> f Presence
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 :: Maybe Text
presenceID = Maybe Text
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 :: (Element -> f Element) -> Presence -> f Presence
payloadT Element -> f Element
inj m :: Presence
m@(Presence{presencePayload :: Presence -> [Element]
presencePayload=[Element]
pl}) =
        (\[Element]
pl' -> Presence
m{presencePayload :: [Element]
presencePayload=[Element]
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. Traversal [a] a
traverseList Element -> f Element
inj [Element]
pl

instance IsStanza PresenceError where
    from :: (Maybe Jid -> f (Maybe Jid)) -> PresenceError -> f PresenceError
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 :: Maybe Jid
presenceErrorFrom = Maybe Jid
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 :: (Maybe Jid -> f (Maybe Jid)) -> PresenceError -> f PresenceError
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 :: Maybe Jid
presenceErrorTo = Maybe Jid
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 :: (Maybe LangTag -> f (Maybe LangTag))
-> PresenceError -> f PresenceError
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 :: Maybe LangTag
presenceErrorLangTag = Maybe LangTag
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 :: (Maybe Text -> f (Maybe Text)) -> PresenceError -> f PresenceError
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 :: Maybe Text
presenceErrorID = Maybe Text
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 :: (Element -> f Element) -> PresenceError -> f PresenceError
payloadT Element -> f Element
inj m :: PresenceError
m@(PresenceError{presenceErrorPayload :: PresenceError -> [Element]
presenceErrorPayload=[Element]
pl}) =
        (\[Element]
pl' -> PresenceError
m{presenceErrorPayload :: [Element]
presenceErrorPayload=[Element]
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. Traversal [a] a
traverseList Element -> f Element
inj [Element]
pl

instance IsStanza IQRequest where
    from :: (Maybe Jid -> f (Maybe Jid)) -> IQRequest -> f IQRequest
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 :: Maybe Jid
iqRequestFrom = Maybe Jid
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 :: (Maybe Jid -> f (Maybe Jid)) -> IQRequest -> f IQRequest
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 :: Maybe Jid
iqRequestTo = Maybe Jid
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 :: (Maybe LangTag -> f (Maybe LangTag)) -> IQRequest -> f IQRequest
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 :: Maybe LangTag
iqRequestLangTag = Maybe LangTag
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 :: (Maybe Text -> f (Maybe Text)) -> IQRequest -> f IQRequest
sid Maybe Text -> f (Maybe Text)
inj m :: IQRequest
m@(IQRequest{iqRequestID :: IQRequest -> Text
iqRequestID = Text
i}) =
        ((\Text
i' -> IQRequest
m{iqRequestID :: Text
iqRequestID = Text
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 :: (Element -> f Element) -> IQRequest -> f IQRequest
payloadT Element -> f Element
inj m :: IQRequest
m@(IQRequest{iqRequestPayload :: IQRequest -> Element
iqRequestPayload=Element
pl}) =
        (\Element
pl' -> IQRequest
m{iqRequestPayload :: Element
iqRequestPayload=Element
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 :: (Maybe Jid -> f (Maybe Jid)) -> IQResult -> f IQResult
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 :: Maybe Jid
iqResultFrom = Maybe Jid
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 :: (Maybe Jid -> f (Maybe Jid)) -> IQResult -> f IQResult
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 :: Maybe Jid
iqResultTo = Maybe Jid
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 :: (Maybe LangTag -> f (Maybe LangTag)) -> IQResult -> f IQResult
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 :: Maybe LangTag
iqResultLangTag = Maybe LangTag
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 :: (Maybe Text -> f (Maybe Text)) -> IQResult -> f IQResult
sid Maybe Text -> f (Maybe Text)
inj m :: IQResult
m@(IQResult{iqResultID :: IQResult -> Text
iqResultID = Text
i}) =
        ((\Text
i' -> IQResult
m{iqResultID :: Text
iqResultID = Text
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 :: (Element -> f Element) -> IQResult -> f IQResult
payloadT Element -> f Element
inj m :: IQResult
m@(IQResult{iqResultPayload :: IQResult -> Maybe Element
iqResultPayload=Maybe Element
pl}) =
        (\Maybe Element
pl' -> IQResult
m{iqResultPayload :: Maybe Element
iqResultPayload=Maybe Element
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 (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Element
forall a. Maybe a
Nothing)
                                                   ((Element -> Maybe Element) -> f Element -> f (Maybe Element)
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 :: (Maybe Jid -> f (Maybe Jid)) -> IQError -> f IQError
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 :: Maybe Jid
iqErrorFrom = Maybe Jid
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 :: (Maybe Jid -> f (Maybe Jid)) -> IQError -> f IQError
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 :: Maybe Jid
iqErrorTo = Maybe Jid
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 :: (Maybe LangTag -> f (Maybe LangTag)) -> IQError -> f IQError
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 :: Maybe LangTag
iqErrorLangTag = Maybe LangTag
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 :: (Maybe Text -> f (Maybe Text)) -> IQError -> f IQError
sid Maybe Text -> f (Maybe Text)
inj m :: IQError
m@(IQError{iqErrorID :: IQError -> Text
iqErrorID = Text
i}) =
        ((\Text
i' -> IQError
m{iqErrorID :: Text
iqErrorID = Text
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 :: (Element -> f Element) -> IQError -> f IQError
payloadT Element -> f Element
inj m :: IQError
m@(IQError{iqErrorPayload :: IQError -> Maybe Element
iqErrorPayload=Maybe Element
pl}) =
        (\Maybe Element
pl' -> IQError
m{iqErrorPayload :: Maybe Element
iqErrorPayload=Maybe Element
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 (f :: * -> *) a. Applicative f => a -> f a
pure Maybe Element
forall a. Maybe a
Nothing)
                                                  ((Element -> Maybe Element) -> f Element -> f (Maybe Element)
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 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
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
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
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
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
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
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
f a -> f a
inj PresenceError
s

liftTraversal :: (forall s. IsStanza s => Traversal s a) -> Traversal Stanza a
liftTraversal :: (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
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
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
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
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
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
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
f a -> f a
inj PresenceError
s

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

maybeNonempty :: Lens Text (Maybe Text)
maybeNonempty :: (Maybe Text -> f (Maybe Text)) -> Text -> f 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 :: p IQRequest (f IQRequest) -> p Stanza (f Stanza)
_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 :: p IQResult (f IQResult) -> p Stanza (f Stanza)
_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 :: p IQError (f IQError) -> p Stanza (f Stanza)
_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 :: p Message (f Message) -> p Stanza (f Stanza)
_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 :: p MessageError (f MessageError) -> p Stanza (f Stanza)
_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 :: p Presence (f Presence) -> p Stanza (f Stanza)
_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 :: p PresenceError (f PresenceError) -> p Stanza (f Stanza)
_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 :: (StanzaError -> f StanzaError) -> IQError -> f IQError
stanzaError StanzaError -> f StanzaError
inj m :: IQError
m@IQError{iqErrorStanzaError :: IQError -> StanzaError
iqErrorStanzaError = StanzaError
i} =
        (\StanzaError
i' -> IQError
m{iqErrorStanzaError :: StanzaError
iqErrorStanzaError = StanzaError
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 :: (StanzaError -> f StanzaError) -> MessageError -> f MessageError
stanzaError StanzaError -> f StanzaError
inj m :: MessageError
m@MessageError{messageErrorStanzaError :: MessageError -> StanzaError
messageErrorStanzaError = StanzaError
i} =
        (\StanzaError
i' -> MessageError
m{messageErrorStanzaError :: StanzaError
messageErrorStanzaError = StanzaError
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 :: (StanzaError -> f StanzaError) -> PresenceError -> f PresenceError
stanzaError StanzaError -> f StanzaError
inj m :: PresenceError
m@PresenceError{presenceErrorStanzaError :: PresenceError -> StanzaError
presenceErrorStanzaError = StanzaError
i} =
        (\StanzaError
i' -> PresenceError
m{presenceErrorStanzaError :: StanzaError
presenceErrorStanzaError = StanzaError
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 :: (Element -> f Element) -> IQRequest -> f IQRequest
payload Element -> f Element
inj m :: IQRequest
m@IQRequest{iqRequestPayload :: IQRequest -> Element
iqRequestPayload = Element
i} =
        (\Element
i' -> IQRequest
m{iqRequestPayload :: Element
iqRequestPayload = Element
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 :: (Maybe Element -> f (Maybe Element)) -> IQResult -> f IQResult
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 :: Maybe Element
iqResultPayload = Maybe Element
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 :: (Maybe Element -> f (Maybe Element)) -> IQError -> f IQError
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 :: Maybe Element
iqErrorPayload = Maybe Element
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 :: ([Element] -> f [Element]) -> Message -> f Message
payload [Element] -> f [Element]
inj m :: Message
m@Message{messagePayload :: Message -> [Element]
messagePayload = [Element]
i} =
        (\[Element]
i' -> Message
m{messagePayload :: [Element]
messagePayload = [Element]
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 :: ([Element] -> f [Element]) -> MessageError -> f MessageError
payload [Element] -> f [Element]
inj m :: MessageError
m@MessageError{messageErrorPayload :: MessageError -> [Element]
messageErrorPayload = [Element]
i} =
        (\[Element]
i' -> MessageError
m{messageErrorPayload :: [Element]
messageErrorPayload = [Element]
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 :: ([Element] -> f [Element]) -> Presence -> f Presence
payload [Element] -> f [Element]
inj m :: Presence
m@Presence{presencePayload :: Presence -> [Element]
presencePayload = [Element]
i} =
        (\[Element]
i' -> Presence
m{presencePayload :: [Element]
presencePayload = [Element]
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 :: ([Element] -> f [Element]) -> PresenceError -> f PresenceError
payload [Element] -> f [Element]
inj m :: PresenceError
m@PresenceError{presenceErrorPayload :: PresenceError -> [Element]
presenceErrorPayload = [Element]
i} =
        (\[Element]
i' -> PresenceError
m{presenceErrorPayload :: [Element]
presenceErrorPayload = [Element]
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 :: (IQRequestType -> f IQRequestType) -> IQRequest -> f IQRequest
iqRequestTypeL IQRequestType -> f IQRequestType
inj p :: IQRequest
p@IQRequest{iqRequestType :: IQRequest -> IQRequestType
iqRequestType = IQRequestType
tp} =
    (\IQRequestType
tp' -> IQRequest
p{iqRequestType :: IQRequestType
iqRequestType = 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 :: (MessageType -> f MessageType) -> Message -> f Message
messageTypeL MessageType -> f MessageType
inj p :: Message
p@Message{messageType :: Message -> MessageType
messageType = MessageType
tp} =
    (\MessageType
tp' -> Message
p{messageType :: MessageType
messageType = 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 :: (PresenceType -> f PresenceType) -> Presence -> f Presence
presenceTypeL PresenceType -> f PresenceType
inj p :: Presence
p@Presence{presenceType :: Presence -> PresenceType
presenceType = PresenceType
tp} =
    (\PresenceType
tp' -> Presence
p{presenceType :: PresenceType
presenceType = 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 :: (StanzaErrorType -> f StanzaErrorType)
-> StanzaError -> f StanzaError
stanzaErrorTypeL StanzaErrorType -> f StanzaErrorType
inj se :: StanzaError
se@StanzaError{stanzaErrorType :: StanzaError -> StanzaErrorType
stanzaErrorType = StanzaErrorType
x} =
    (\StanzaErrorType
x' -> StanzaError
se{stanzaErrorType :: StanzaErrorType
stanzaErrorType = 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 :: (StanzaErrorCondition -> f StanzaErrorCondition)
-> StanzaError -> f StanzaError
stanzaErrorConditionL StanzaErrorCondition -> f StanzaErrorCondition
inj se :: StanzaError
se@StanzaError{stanzaErrorCondition :: StanzaError -> StanzaErrorCondition
stanzaErrorCondition = StanzaErrorCondition
x} =
    (\StanzaErrorCondition
x' -> StanzaError
se{stanzaErrorCondition :: StanzaErrorCondition
stanzaErrorCondition = 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 :: (Maybe (Maybe LangTag, NonemptyText)
 -> f (Maybe (Maybe LangTag, NonemptyText)))
-> StanzaError -> f StanzaError
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 :: Maybe (Maybe LangTag, NonemptyText)
stanzaErrorText = Maybe (Maybe LangTag, NonemptyText)
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 :: (Maybe Element -> f (Maybe Element))
-> StanzaError -> f StanzaError
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 :: Maybe Element
stanzaErrorApplicationSpecificCondition = Maybe Element
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 :: (Maybe LangTag -> f (Maybe LangTag))
-> StreamConfiguration -> f StreamConfiguration
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 :: Maybe LangTag
preferredLang = Maybe LangTag
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 :: (Maybe (Jid, Bool) -> f (Maybe (Jid, Bool)))
-> StreamConfiguration -> f StreamConfiguration
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 :: Maybe (Jid, Bool)
toJid = Maybe (Jid, Bool)
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 :: (ConnectionDetails -> f ConnectionDetails)
-> StreamConfiguration -> f StreamConfiguration
connectionDetailsL ConnectionDetails -> f ConnectionDetails
inj sc :: StreamConfiguration
sc@StreamConfiguration{connectionDetails :: StreamConfiguration -> ConnectionDetails
connectionDetails = ConnectionDetails
x}
    = (\ConnectionDetails
x' -> StreamConfiguration
sc{connectionDetails :: ConnectionDetails
connectionDetails = 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 :: (ResolvConf -> f ResolvConf)
-> StreamConfiguration -> f StreamConfiguration
resolvConfL ResolvConf -> f ResolvConf
inj sc :: StreamConfiguration
sc@StreamConfiguration{resolvConf :: StreamConfiguration -> ResolvConf
resolvConf = ResolvConf
x}
    = (\ResolvConf
x' -> StreamConfiguration
sc{resolvConf :: ResolvConf
resolvConf = 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 :: (TlsBehaviour -> f TlsBehaviour)
-> StreamConfiguration -> f StreamConfiguration
tlsBehaviourL TlsBehaviour -> f TlsBehaviour
inj sc :: StreamConfiguration
sc@StreamConfiguration{tlsBehaviour :: StreamConfiguration -> TlsBehaviour
tlsBehaviour = TlsBehaviour
x}
    = (\TlsBehaviour
x' -> StreamConfiguration
sc{tlsBehaviour :: TlsBehaviour
tlsBehaviour = 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 :: (ClientParams -> f ClientParams)
-> StreamConfiguration -> f StreamConfiguration
tlsParamsL ClientParams -> f ClientParams
inj sc :: StreamConfiguration
sc@StreamConfiguration{tlsParams :: StreamConfiguration -> ClientParams
tlsParams = ClientParams
x}
    = (\ClientParams
x' -> StreamConfiguration
sc{tlsParams :: ClientParams
tlsParams = ClientParams
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 :: ((String, ByteString) -> f (String, ByteString))
-> ClientParams -> f ClientParams
clientServerIdentificationL (String, ByteString) -> f (String, ByteString)
inj cp :: ClientParams
cp@ClientParams{clientServerIdentification :: ClientParams -> (String, ByteString)
clientServerIdentification = (String, ByteString)
x}
    = (\(String, ByteString)
x' -> ClientParams
cp{clientServerIdentification :: (String, ByteString)
clientServerIdentification = (String, ByteString)
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 (String, ByteString)
x

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

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

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

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

-- SessionConfiguration
-----------------------
streamConfigurationL :: Lens SessionConfiguration StreamConfiguration
streamConfigurationL :: (StreamConfiguration -> f StreamConfiguration)
-> SessionConfiguration -> f SessionConfiguration
streamConfigurationL StreamConfiguration -> f StreamConfiguration
inj sc :: SessionConfiguration
sc@SessionConfiguration{sessionStreamConfiguration :: SessionConfiguration -> StreamConfiguration
sessionStreamConfiguration = StreamConfiguration
x}
    = (\StreamConfiguration
x' -> SessionConfiguration
sc{sessionStreamConfiguration :: StreamConfiguration
sessionStreamConfiguration = StreamConfiguration
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 :: ((Session -> XmppFailure -> IO ())
 -> f (Session -> XmppFailure -> IO ()))
-> SessionConfiguration -> f SessionConfiguration
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 :: Session -> XmppFailure -> IO ()
onConnectionClosed = Session -> XmppFailure -> IO ()
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 :: (IO (IO Text) -> f (IO (IO Text)))
-> SessionConfiguration -> f SessionConfiguration
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 :: IO (IO Text)
sessionStanzaIDs = IO (IO Text)
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 :: (Bool -> f Bool) -> SessionConfiguration -> f SessionConfiguration
ensableRosterL Bool -> f Bool
inj sc :: SessionConfiguration
sc@SessionConfiguration{enableRoster :: SessionConfiguration -> Bool
enableRoster = Bool
x}
    = (\Bool
x' -> SessionConfiguration
sc{enableRoster :: Bool
enableRoster = Bool
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 :: (Maybe RosterPushCallback -> f (Maybe RosterPushCallback))
-> SessionConfiguration -> f SessionConfiguration
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 :: Maybe RosterPushCallback
onRosterPush = Maybe RosterPushCallback
orp})

pluginsL :: Lens SessionConfiguration [Plugin]
pluginsL :: ([Plugin] -> f [Plugin])
-> SessionConfiguration -> f SessionConfiguration
pluginsL [Plugin] -> f [Plugin]
inj sc :: SessionConfiguration
sc@SessionConfiguration{plugins :: SessionConfiguration -> [Plugin]
plugins = [Plugin]
x}
    = (\[Plugin]
x' -> SessionConfiguration
sc{plugins :: [Plugin]
plugins = [Plugin]
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 :: (Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
 -> f (Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())))
-> SessionConfiguration -> f SessionConfiguration
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 :: Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
onPresenceChange = Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
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 :: ((String, ByteString) -> f (String, ByteString))
-> SessionConfiguration -> f SessionConfiguration
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 :: (Bool -> f Bool) -> SessionConfiguration -> f SessionConfiguration
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 :: ([Cipher] -> f [Cipher])
-> SessionConfiguration -> f SessionConfiguration
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 :: ([Version] -> f [Version])
-> SessionConfiguration -> f SessionConfiguration
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 :: (Maybe Text -> f (Maybe Text)) -> Roster -> f Roster
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 :: Maybe Text
ver = Maybe Text
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 :: (Map Jid Item -> f (Map Jid Item)) -> Roster -> f Roster
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 :: Map Jid Item
items = Map Jid Item
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 :: (Bool -> f Bool) -> Item -> f Item
riApprovedL Bool -> f Bool
inj i :: Item
i@Item{riApproved :: Item -> Bool
riApproved = Bool
x} = (\Bool
x' -> Item
i{riApproved :: Bool
riApproved = Bool
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 :: (Bool -> f Bool) -> Item -> f Item
riAskL Bool -> f Bool
inj i :: Item
i@Item{riAsk :: Item -> Bool
riAsk = Bool
x} = (\Bool
x' -> Item
i{riAsk :: Bool
riAsk = Bool
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 :: (Jid -> f Jid) -> Item -> f Item
riJidL Jid -> f Jid
inj i :: Item
i@Item{riJid :: Item -> Jid
riJid = Jid
x} = (\Jid
x' -> Item
i{riJid :: Jid
riJid = Jid
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 :: (Maybe Text -> f (Maybe Text)) -> Item -> f Item
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 :: Maybe Text
riName = Maybe Text
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 :: (Subscription -> f Subscription) -> Item -> f Item
riSubscriptionL Subscription -> f Subscription
inj i :: Item
i@Item{riSubscription :: Item -> Subscription
riSubscription = Subscription
x} =
    (\Subscription
x' -> Item
i{riSubscription :: Subscription
riSubscription = Subscription
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 :: ([Text] -> f [Text]) -> Item -> f Item
riGroupsL [Text] -> f [Text]
inj i :: Item
i@Item{riGroups :: Item -> [Text]
riGroups = [Text]
x} = (\[Text]
x' -> Item
i{riGroups :: [Text]
riGroups = [Text]
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 :: p Jid (f Jid) -> p RosterUpdate (f RosterUpdate)
_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 :: p Item (f Item) -> p RosterUpdate (f RosterUpdate)
_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 :: (Maybe Bool -> f (Maybe Bool)) -> QueryItem -> f QueryItem
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 :: Maybe Bool
qiApproved = Maybe Bool
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 :: (Bool -> f Bool) -> QueryItem -> f QueryItem
qiAskL Bool -> f Bool
inj i :: QueryItem
i@QueryItem{qiAsk :: QueryItem -> Bool
qiAsk = Bool
x} = (\Bool
x' -> QueryItem
i{qiAsk :: Bool
qiAsk = Bool
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 :: (Jid -> f Jid) -> QueryItem -> f QueryItem
qiJidL Jid -> f Jid
inj i :: QueryItem
i@QueryItem{qiJid :: QueryItem -> Jid
qiJid = Jid
x} = (\Jid
x' -> QueryItem
i{qiJid :: Jid
qiJid = Jid
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 :: (Maybe Text -> f (Maybe Text)) -> QueryItem -> f QueryItem
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 :: Maybe Text
qiName = Maybe Text
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 :: (Maybe Subscription -> f (Maybe Subscription))
-> QueryItem -> f QueryItem
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 :: Maybe Subscription
qiSubscription = Maybe Subscription
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 :: ([Text] -> f [Text]) -> QueryItem -> f QueryItem
qiGroupsL [Text] -> f [Text]
inj i :: QueryItem
i@QueryItem{qiGroups :: QueryItem -> [Text]
qiGroups = [Text]
x} = (\[Text]
x' -> QueryItem
i{qiGroups :: [Text]
qiGroups = [Text]
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 :: (Maybe Text -> f (Maybe Text)) -> Query -> f Query
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 :: Maybe Text
queryVer = Maybe Text
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 :: ([QueryItem] -> f [QueryItem]) -> Query -> f Query
queryItemsL [QueryItem] -> f [QueryItem]
inj i :: Query
i@Query{queryItems :: Query -> [QueryItem]
queryItems = [QueryItem]
x} = (\[QueryItem]
x' -> Query
i{queryItems :: [QueryItem]
queryItems = [QueryItem]
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 :: (Maybe LangTag -> f (Maybe LangTag))
-> MessageBody -> f MessageBody
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 :: Maybe LangTag
bodyLang = Maybe LangTag
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 :: (Text -> f Text) -> MessageBody -> f MessageBody
bodyContentL Text -> f Text
inj m :: MessageBody
m@MessageBody{bodyContent :: MessageBody -> Text
bodyContent = Text
bc} =
    (\Text
bc' -> MessageBody
m{bodyContent :: Text
bodyContent = Text
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 :: (Text -> f Text) -> MessageThread -> f MessageThread
threadIdL Text -> f Text
inj m :: MessageThread
m@MessageThread{threadID :: MessageThread -> Text
threadID = Text
bc} =
    (\Text
bc' -> MessageThread
m{threadID :: Text
threadID = Text
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 :: (Maybe Text -> f (Maybe Text)) -> MessageThread -> f MessageThread
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 :: Maybe Text
threadParent = Maybe Text
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 :: (Maybe LangTag -> f (Maybe LangTag))
-> MessageSubject -> f MessageSubject
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 :: Maybe LangTag
subjectLang = Maybe LangTag
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 :: (Text -> f Text) -> MessageSubject -> f MessageSubject
subjectContentL Text -> f Text
inj m :: MessageSubject
m@MessageSubject{subjectContent :: MessageSubject -> Text
subjectContent = Text
bc} =
    (\Text
bc' -> MessageSubject
m{subjectContent :: Text
subjectContent = Text
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 :: (Maybe MessageThread -> f (Maybe MessageThread))
-> InstantMessage -> f InstantMessage
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 :: Maybe MessageThread
imThread = Maybe MessageThread
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 :: ([MessageSubject] -> f [MessageSubject])
-> InstantMessage -> f InstantMessage
imSubjectL [MessageSubject] -> f [MessageSubject]
inj m :: InstantMessage
m@InstantMessage{imSubject :: InstantMessage -> [MessageSubject]
imSubject = [MessageSubject]
bc} =
    (\[MessageSubject]
bc' -> InstantMessage
m{imSubject :: [MessageSubject]
imSubject = [MessageSubject]
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 :: ([MessageBody] -> f [MessageBody])
-> InstantMessage -> f InstantMessage
imBodyL [MessageBody] -> f [MessageBody]
inj m :: InstantMessage
m@InstantMessage{imBody :: InstantMessage -> [MessageBody]
imBody = [MessageBody]
bc} =
    (\[MessageBody]
bc' -> InstantMessage
m{imBody :: [MessageBody]
imBody = [MessageBody]
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 :: (Maybe ShowStatus -> f (Maybe ShowStatus))
-> IMPresence -> f IMPresence
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 :: Maybe ShowStatus
showStatus = Maybe 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 :: (Maybe Text -> f (Maybe Text)) -> IMPresence -> f IMPresence
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 :: Maybe Text
status = Maybe Text
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 :: (Maybe Int -> f (Maybe Int)) -> IMPresence -> f IMPresence
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 :: Maybe Int
priority = Maybe Int
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 :: (Maybe Bool -> f (Maybe Bool))
-> StreamFeatures -> f StreamFeatures
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 :: Maybe Bool
streamFeaturesTls = Maybe Bool
x})

featureMechanismsL :: Lens StreamFeatures [Text]
featureMechanismsL :: ([Text] -> f [Text]) -> StreamFeatures -> f StreamFeatures
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 :: [Text]
streamFeaturesMechanisms = [Text]
x})

featureRosterVerL :: Lens StreamFeatures (Maybe Bool)
featureRosterVerL :: (Maybe Bool -> f (Maybe Bool))
-> StreamFeatures -> f StreamFeatures
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 :: Maybe Bool
streamFeaturesRosterVer = Maybe Bool
x})

featurePreApprovalL :: Lens StreamFeatures Bool
featurePreApprovalL :: (Bool -> f Bool) -> StreamFeatures -> f StreamFeatures
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 :: Bool
streamFeaturesPreApproval = Bool
x})

featuresOtherL :: Lens StreamFeatures [Element]
featuresOtherL :: ([Element] -> f [Element]) -> StreamFeatures -> f StreamFeatures
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 :: [Element]
streamFeaturesOther = [Element]
x})