{-# 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 = forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap (\s
s -> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a b. a -> Either a b
Left s
s) forall a b. b -> Either a b
Right (s -> Maybe b
sma s
s))
                      (forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either forall (f :: * -> *) a. Applicative f => a -> f a
pure (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap b -> s
bs)) forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 -> forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (forall a b c. (a -> b -> c) -> b -> a -> c
flip b -> a -> a
set a
x) (b -> f b
inj 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 = forall (p :: * -> * -> *) a b c d.
Profunctor p =>
(a -> b) -> (c -> d) -> p b c -> p a d
dimap a -> b
t (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 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
<$ :: forall a b. a -> Collect a b -> Collect a a
$c<$ :: forall a a b. a -> Collect a b -> Collect a a
fmap :: forall a b. (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 :: forall a. a -> Collect a a
pure 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 = forall a b. [a] -> Collect a b
Collect forall a b. (a -> b) -> a -> b
$ [a]
xs 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 = forall a b. Collect a b -> [a]
getCollection forall b c a. (b -> c) -> (a -> b) -> a -> c
. Traversal a b
t (forall a b. [a] -> Collect a b
Collect forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 = forall a. Identity a -> a
runIdentity forall b c a. (b -> c) -> (a -> b) -> a -> c
. Traversal a b
t (forall a. a -> Identity a
Identity forall b c a. (b -> c) -> (a -> b) -> a -> c
. b -> b
f)

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

_JidText :: Prism Text Jid
_JidText :: Prism Text Jid
_JidText = 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 = forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' forall a. a -> a
id (\Jid
j -> if Jid -> Bool
isFull Jid
j then forall a. a -> Maybe a
Just Jid
j else forall a. Maybe a
Nothing)

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

_Stanza :: Prism XmppElement Stanza
_Stanza :: Prism XmppElement Stanza
_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 -> forall a. a -> Maybe a
Just Stanza
s
                                    XmppElement
_ -> forall a. Maybe a
Nothing)

_Nonza :: Prism XmppElement Element
_Nonza :: Prism XmppElement Element
_Nonza = forall b s. (b -> s) -> (s -> Maybe b) -> Prism s b
prism' Element -> XmppElement
XmppNonza (\XmppElement
v -> case XmppElement
v of
                                  XmppNonza Element
n -> forall a. a -> Maybe a
Just Element
n
                                  XmppElement
_ -> 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. Traversal [a] a
traverseList a -> f a
_inj [] = forall (f :: * -> *) a. Applicative f => a -> f a
pure []
traverseList a -> f a
inj  (a
x:[a]
xs) = (:) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> f a
inj a
x forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> forall a. Traversal [a] 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 :: Maybe Jid
messageFrom = Maybe Jid
f'}) 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 :: Maybe Jid
messageTo = Maybe Jid
t'}) 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 :: Maybe LangTag
messageLangTag = Maybe LangTag
t'}) 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 :: Maybe Text
messageID = Maybe Text
i'}) 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 :: [Element]
messagePayload=[Element]
pl'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Traversal [a] 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 :: Maybe Jid
messageErrorFrom = Maybe Jid
f'}) 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 :: Maybe Jid
messageErrorTo = Maybe Jid
t'}) 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 :: Maybe LangTag
messageErrorLangTag = Maybe LangTag
t'}) 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 :: Maybe Text
messageErrorID = Maybe Text
i'}) 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 :: [Element]
messageErrorPayload=[Element]
pl'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Traversal [a] 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 :: Maybe Jid
presenceFrom = Maybe Jid
f'}) 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 :: Maybe Jid
presenceTo = Maybe Jid
t'}) 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 :: Maybe LangTag
presenceLangTag = Maybe LangTag
t'}) 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 :: Maybe Text
presenceID = Maybe Text
i'}) 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 :: [Element]
presencePayload=[Element]
pl'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Traversal [a] 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 :: Maybe Jid
presenceErrorFrom = Maybe Jid
f'}) 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 :: Maybe Jid
presenceErrorTo = Maybe Jid
t'}) 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 :: Maybe LangTag
presenceErrorLangTag = Maybe LangTag
t'}) 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 :: Maybe Text
presenceErrorID = Maybe Text
i'}) 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 :: [Element]
presenceErrorPayload=[Element]
pl'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. Traversal [a] 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 :: Maybe Jid
iqRequestFrom = Maybe Jid
f'}) 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 :: Maybe Jid
iqRequestTo = Maybe Jid
t'}) 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 :: Maybe LangTag
iqRequestLangTag = Maybe LangTag
t'}) 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 :: Text
iqRequestID = Text
i'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 :: Element
iqRequestPayload=Element
pl'}) 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 :: Maybe Jid
iqResultFrom = Maybe Jid
f'}) 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 :: Maybe Jid
iqResultTo = Maybe Jid
t'}) 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 :: Maybe LangTag
iqResultLangTag = Maybe LangTag
t'}) 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 :: Text
iqResultID = Text
i'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 :: Maybe Element
iqResultPayload=Maybe Element
pl'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing)
                                                   (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just 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 :: Maybe Jid
iqErrorFrom = Maybe Jid
f'}) 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 :: Maybe Jid
iqErrorTo = Maybe Jid
t'}) 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 :: Maybe LangTag
iqErrorLangTag = Maybe LangTag
t'}) 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 :: Text
iqErrorID = Text
i'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 :: Maybe Element
iqErrorPayload=Maybe Element
pl'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall (f :: * -> *) a. Applicative f => a -> f a
pure forall a. Maybe a
Nothing)
                                                  (forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap forall a. a -> Maybe a
Just 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     forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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       forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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       forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 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     forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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       forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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       forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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  forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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      forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> 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 forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall s. IsStanza s => Traversal s a
f a -> f a
inj PresenceError
s

instance IsStanza Stanza where
    from :: Lens Stanza (Maybe Jid)
from     = forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens forall s. IsStanza s => Lens s (Maybe Jid)
from
    to :: Lens Stanza (Maybe Jid)
to       = forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens forall s. IsStanza s => Lens s (Maybe Jid)
to
    lang :: Lens Stanza (Maybe LangTag)
lang     = forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens forall s. IsStanza s => Lens s (Maybe LangTag)
lang
    sid :: Lens Stanza (Maybe Text)
sid      = forall a. (forall s. IsStanza s => Lens s a) -> Lens Stanza a
liftLens forall s. IsStanza s => Lens s (Maybe Text)
sid
    payloadT :: Traversal Stanza Element
payloadT = 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 :: Lens Text (Maybe Text)
maybeNonempty Maybe Text -> f (Maybe Text)
inj Text
x = (forall b a. b -> (a -> b) -> Maybe a -> b
maybe Text
Text.empty forall a. a -> a
id)
                      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 forall a. Maybe a
Nothing else forall a. a -> Maybe a
Just Text
x)


_IQRequest :: Prism Stanza IQRequest
_IQRequest :: Prism Stanza IQRequest
_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) = forall a. a -> Maybe a
Just IQRequest
s
    fromIQRequestS Stanza
_ = forall a. Maybe a
Nothing

_IQResult :: Prism Stanza IQResult
_IQResult :: Prism Stanza IQResult
_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) = forall a. a -> Maybe a
Just IQResult
s
    fromIQResultS Stanza
_ = forall a. Maybe a
Nothing

_IQError :: Prism Stanza IQError
_IQError :: Prism Stanza IQError
_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) = forall a. a -> Maybe a
Just IQError
s
    fromIQErrorS Stanza
_ = forall a. Maybe a
Nothing

_Message :: Prism Stanza Message
_Message :: Prism Stanza Message
_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) = forall a. a -> Maybe a
Just Message
s
    fromMessageS Stanza
_ = forall a. Maybe a
Nothing

_MessageError :: Prism Stanza MessageError
_MessageError :: Prism Stanza MessageError
_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) = forall a. a -> Maybe a
Just MessageError
s
    fromMessageErrorS Stanza
_ = forall a. Maybe a
Nothing

_Presence :: Prism Stanza Presence
_Presence :: Prism Stanza Presence
_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) = forall a. a -> Maybe a
Just Presence
s
    fromPresenceS Stanza
_ = forall a. Maybe a
Nothing

_PresenceError :: Prism Stanza PresenceError
_PresenceError :: Prism Stanza PresenceError
_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) = forall a. a -> Maybe a
Just PresenceError
s
    fromPresenceErrorS Stanza
_ = 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 :: StanzaError
iqErrorStanzaError = StanzaError
i'}) 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 :: StanzaError
messageErrorStanzaError = StanzaError
i'}) 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 :: StanzaError
presenceErrorStanzaError = StanzaError
i'}) 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 :: Element
iqRequestPayload = Element
i'}) 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 :: Maybe Element
iqResultPayload = Maybe Element
i'}) 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 :: Maybe Element
iqErrorPayload = Maybe Element
i'}) 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 :: [Element]
messagePayload = [Element]
i'}) 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 :: [Element]
messageErrorPayload = [Element]
i'}) 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 :: [Element]
presencePayload = [Element]
i'}) 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 :: [Element]
presenceErrorPayload = [Element]
i'}) 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 :: IQRequestType
iqRequestType = IQRequestType
tp'}) 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 :: MessageType
messageType = MessageType
tp'}) 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 :: PresenceType
presenceType = PresenceType
tp'}) 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 :: StanzaErrorType
stanzaErrorType = StanzaErrorType
x'}) 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 :: StanzaErrorCondition
stanzaErrorCondition = StanzaErrorCondition
x'}) 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 :: Maybe (Maybe LangTag, NonemptyText)
stanzaErrorText = Maybe (Maybe LangTag, NonemptyText)
x'}) 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 :: Maybe Element
stanzaErrorApplicationSpecificCondition = Maybe Element
x'}) 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 :: Maybe LangTag
preferredLang = Maybe LangTag
x'}) 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 :: Maybe (Jid, Bool)
toJid = Maybe (Jid, Bool)
x'}) 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 :: ConnectionDetails
connectionDetails = ConnectionDetails
x'}) 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 :: ResolvConf
resolvConf = ResolvConf
x'}) 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 :: TlsBehaviour
tlsBehaviour = TlsBehaviour
x'}) 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 :: ClientParams
tlsParams = ClientParams
x'}) 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 cp :: ClientParams
cp@ClientParams{clientServerIdentification :: ClientParams -> (String, ByteString)
clientServerIdentification = (String, ByteString)
x}
    = (\(String, ByteString)
x' -> ClientParams
cp{clientServerIdentification :: (String, ByteString)
clientServerIdentification = (String, ByteString)
x'}) 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 :: Lens ClientParams Supported
clientSupportedL Supported -> f Supported
inj cp :: ClientParams
cp@ClientParams{clientSupported :: ClientParams -> Supported
clientSupported = Supported
x}
    = (\Supported
x' -> ClientParams
cp{clientSupported :: Supported
clientSupported = Supported
x'}) forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Supported -> f Supported
inj Supported
x

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

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

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

-- 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 :: StreamConfiguration
sessionStreamConfiguration = StreamConfiguration
x'}) 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 :: Session -> XmppFailure -> IO ()
onConnectionClosed = Session -> XmppFailure -> IO ()
x'}) 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 :: IO (IO Text)
sessionStanzaIDs = IO (IO Text)
x'}) 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 :: Bool
enableRoster = Bool
x'}) 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 = 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 :: Lens SessionConfiguration [Plugin]
pluginsL [Plugin] -> f [Plugin]
inj sc :: SessionConfiguration
sc@SessionConfiguration{plugins :: SessionConfiguration -> [Plugin]
plugins = [Plugin]
x}
    = (\[Plugin]
x' -> SessionConfiguration
sc{plugins :: [Plugin]
plugins = [Plugin]
x'}) 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 :: Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
onPresenceChange = Maybe (Jid -> PeerStatus -> PeerStatus -> IO ())
x'}) 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 = Lens SessionConfiguration StreamConfiguration
streamConfigurationL
                         forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens StreamConfiguration ClientParams
tlsParamsL
                         forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens ClientParams (String, ByteString)
clientServerIdentificationL

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

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

-- | Access supportedVersions inside clientSupported inside tlsParams
tlsSupportedVersionsL :: Lens SessionConfiguration [TLS.Version]
tlsSupportedVersionsL :: Lens SessionConfiguration [Version]
tlsSupportedVersionsL = Lens SessionConfiguration StreamConfiguration
streamConfigurationL
                      forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens StreamConfiguration ClientParams
tlsParamsL forall b c a. (b -> c) -> (a -> b) -> a -> c
. Lens ClientParams Supported
clientSupportedL forall b c a. (b -> c) -> (a -> b) -> a -> c
. 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 :: Maybe Text
ver = Maybe Text
x'}) 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 :: Map Jid Item
items = Map Jid Item
x'}) 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 :: Bool
riApproved = Bool
x'}) 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 :: Bool
riAsk = Bool
x'}) 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 :: Jid
riJid = Jid
x'}) 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 :: Maybe Text
riName = Maybe Text
x'}) 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 :: Subscription
riSubscription = Subscription
x'}) 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 :: [Text]
riGroups = [Text]
x'}) 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 = 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) = forall a. a -> Maybe a
Just Jid
jid
    fromRosterUpdateRemove RosterUpdateAdd{} = forall a. Maybe a
Nothing

_RosterUpdateAdd :: Prism RosterUpdate Item
_RosterUpdateAdd :: Prism RosterUpdate Item
_RosterUpdateAdd = 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{} = forall a. Maybe a
Nothing
    fromRosterUpdateAdd (RosterUpdateAdd Item
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 :: Maybe Bool
qiApproved = Maybe Bool
x'}) 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 :: Bool
qiAsk = Bool
x'}) 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 :: Jid
qiJid = Jid
x'}) 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 :: Maybe Text
qiName = Maybe Text
x'}) 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 :: Maybe Subscription
qiSubscription = Maybe Subscription
x'}) 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 :: [Text]
qiGroups = [Text]
x'}) 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 :: Maybe Text
queryVer = Maybe Text
x'}) 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 :: [QueryItem]
queryItems = [QueryItem]
x'}) 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 :: Maybe LangTag
bodyLang = Maybe LangTag
bl'}) 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 :: Text
bodyContent = Text
bc'}) 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 :: Text
threadID = Text
bc'}) 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 :: Maybe Text
threadParent = Maybe Text
bc'}) 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 :: Maybe LangTag
subjectLang = Maybe LangTag
bc'}) 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 :: Text
subjectContent = Text
bc'}) 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 :: Maybe MessageThread
imThread = Maybe MessageThread
bc'}) 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 :: [MessageSubject]
imSubject = [MessageSubject]
bc'}) 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 :: [MessageBody]
imBody = [MessageBody]
bc'}) 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 :: Maybe ShowStatus
showStatus = Maybe ShowStatus
bc'}) 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 :: Maybe Text
status = Maybe Text
bc'}) 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 :: Maybe Int
priority = Maybe Int
bc'}) 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 = 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 :: Lens StreamFeatures [Text]
featureMechanismsL =
    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 :: Lens StreamFeatures (Maybe Bool)
featureRosterVerL =
    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 :: Lens StreamFeatures Bool
featurePreApprovalL =
    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 :: Lens StreamFeatures [Element]
featuresOtherL =
    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})