-- ------------------------------------------------------------

{- |
   Module     : Text.XML.HXT.Arrow.XmlState.TypeDefs
   Copyright  : Copyright (C) 2010 Uwe Schmidt
   License    : MIT

   Maintainer : Uwe Schmidt (uwe@fh-wedel.de)
   Stability  : stable
   Portability: portable

   the basic state arrows for XML processing

   A state is needed for global processing options,
   like encoding options, document base URI, trace levels
   and error message handling

   The state is separated into a user defined state
   and a system state. The system state contains variables
   for error message handling, for tracing, for the document base
   for accessing XML documents with relative references, e.g. DTDs,
   and a global key value store. This assoc list has strings as keys
   and lists of XmlTrees as values. It is used to store arbitrary
   XML and text values, e.g. user defined global options.

   The user defined part of the store is in the default case empty, defined as ().
   It can be extended with an arbitray data type

-}

-- ------------------------------------------------------------

module Text.XML.HXT.Arrow.XmlState.TypeDefs
    ( module Text.XML.HXT.Arrow.XmlState.TypeDefs
    , Selector(..)
    , chgS
    , idS
    , (.&&&.)
    )
where

import           Control.Arrow
import           Control.Arrow.ArrowList
import           Control.Arrow.IOStateListArrow
import           Control.DeepSeq

import           Data.ByteString.Lazy           (ByteString)
import           Data.Char                      (isDigit)
import           Data.Function.Selector         (Selector (..), chgS, idS,
                                                 (.&&&.))
import qualified Data.Map                       as M

import           Text.XML.HXT.DOM.Interface

-- ------------------------------------------------------------
{- datatypes -}

-- |
-- state datatype consists of a system state and a user state
-- the user state is not fixed

data XIOState us        = XIOState { XIOState us -> XIOSysState
xioSysState  :: !XIOSysState
                                   , XIOState us -> us
xioUserState :: !us
                                   }

instance (NFData us) => NFData (XIOState us) where
    rnf :: XIOState us -> ()
rnf (XIOState XIOSysState
sys us
usr)      = XIOSysState -> ()
forall a. NFData a => a -> ()
rnf XIOSysState
sys () -> () -> ()
`seq` us -> ()
forall a. NFData a => a -> ()
rnf us
usr

-- |
-- The arrow type for stateful arrows

type IOStateArrow s b c = IOSLA (XIOState s) b c

-- |
-- The arrow for stateful arrows with no user defined state

type IOSArrow b c       = IOStateArrow () b c

-- ------------------------------------------------------------

-- user state functions

-- | read the user defined part of the state

getUserState    :: IOStateArrow s b s
getUserState :: IOStateArrow s b s
getUserState
    = (XIOState s -> b -> IO (XIOState s, [s])) -> IOStateArrow s b s
forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
IOSLA ((XIOState s -> b -> IO (XIOState s, [s])) -> IOStateArrow s b s)
-> (XIOState s -> b -> IO (XIOState s, [s])) -> IOStateArrow s b s
forall a b. (a -> b) -> a -> b
$ \ XIOState s
s b
_ ->
      (XIOState s, [s]) -> IO (XIOState s, [s])
forall (m :: * -> *) a. Monad m => a -> m a
return (XIOState s
s, [XIOState s -> s
forall us. XIOState us -> us
xioUserState XIOState s
s])

-- | change the user defined part of the state

changeUserState         :: (b -> s -> s) -> IOStateArrow s b b
changeUserState :: (b -> s -> s) -> IOStateArrow s b b
changeUserState b -> s -> s
cf
    = (XIOState s -> b -> IO (XIOState s, [b])) -> IOStateArrow s b b
forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
IOSLA ((XIOState s -> b -> IO (XIOState s, [b])) -> IOStateArrow s b b)
-> (XIOState s -> b -> IO (XIOState s, [b])) -> IOStateArrow s b b
forall a b. (a -> b) -> a -> b
$ \ XIOState s
s b
v ->
      let s' :: XIOState s
s' = XIOState s
s { xioUserState :: s
xioUserState = b -> s -> s
cf b
v (XIOState s -> s
forall us. XIOState us -> us
xioUserState XIOState s
s) }
      in (XIOState s, [b]) -> IO (XIOState s, [b])
forall (m :: * -> *) a. Monad m => a -> m a
return (XIOState s
s', [b
v])

-- | set the user defined part of the state

setUserState            :: IOStateArrow s s s
setUserState :: IOStateArrow s s s
setUserState
    = (s -> s -> s) -> IOStateArrow s s s
forall b s. (b -> s -> s) -> IOStateArrow s b b
changeUserState s -> s -> s
forall a b. a -> b -> a
const

-- | extend user state
--
-- Run an arrow with an extended user state component, The old component
-- is stored together with a new one in a pair, the arrow is executed with this
-- extended state, and the augmented state component is removed form the state
-- when the arrow has finished its execution

withExtendedUserState   :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c
withExtendedUserState :: s1 -> IOStateArrow (s1, s0) b c -> IOStateArrow s0 b c
withExtendedUserState s1
initS1 IOStateArrow (s1, s0) b c
f
    = (XIOState s0 -> b -> IO (XIOState s0, [c])) -> IOStateArrow s0 b c
forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
IOSLA ((XIOState s0 -> b -> IO (XIOState s0, [c]))
 -> IOStateArrow s0 b c)
-> (XIOState s0 -> b -> IO (XIOState s0, [c]))
-> IOStateArrow s0 b c
forall a b. (a -> b) -> a -> b
$ \ XIOState s0
s0 b
x ->
      do
      ~(XIOState (s1, s0)
finalS, [c]
res) <- IOStateArrow (s1, s0) b c
-> XIOState (s1, s0) -> b -> IO (XIOState (s1, s0), [c])
forall s a b. IOSLA s a b -> s -> a -> IO (s, [b])
runIOSLA IOStateArrow (s1, s0) b c
f ( XIOState :: forall us. XIOSysState -> us -> XIOState us
XIOState { xioSysState :: XIOSysState
xioSysState  =          XIOState s0 -> XIOSysState
forall us. XIOState us -> XIOSysState
xioSysState  XIOState s0
s0
                                              , xioUserState :: (s1, s0)
xioUserState = (s1
initS1, XIOState s0 -> s0
forall us. XIOState us -> us
xioUserState XIOState s0
s0)
                                              }
                                   ) b
x
      (XIOState s0, [c]) -> IO (XIOState s0, [c])
forall (m :: * -> *) a. Monad m => a -> m a
return ( XIOState :: forall us. XIOSysState -> us -> XIOState us
XIOState { xioSysState :: XIOSysState
xioSysState  =      XIOState (s1, s0) -> XIOSysState
forall us. XIOState us -> XIOSysState
xioSysState  XIOState (s1, s0)
finalS
                        , xioUserState :: s0
xioUserState = (s1, s0) -> s0
forall a b. (a, b) -> b
snd (XIOState (s1, s0) -> (s1, s0)
forall us. XIOState us -> us
xioUserState XIOState (s1, s0)
finalS)
                        }
             , [c]
res
             )

-- | change the type of user state
--
-- This conversion is useful, when running a state arrow with another
-- structure of the user state, e.g. with () when executing some IO arrows

withOtherUserState      :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
withOtherUserState :: s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
withOtherUserState s1
s1 IOStateArrow s1 b c
f
    = (XIOState s0 -> b -> IO (XIOState s0, [c])) -> IOStateArrow s0 b c
forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
IOSLA ((XIOState s0 -> b -> IO (XIOState s0, [c]))
 -> IOStateArrow s0 b c)
-> (XIOState s0 -> b -> IO (XIOState s0, [c]))
-> IOStateArrow s0 b c
forall a b. (a -> b) -> a -> b
$ \ XIOState s0
s b
x ->
      do
      (XIOState s1
s', [c]
res) <- IOStateArrow s1 b c -> XIOState s1 -> b -> IO (XIOState s1, [c])
forall s a b. IOSLA s a b -> s -> a -> IO (s, [b])
runIOSLA IOStateArrow s1 b c
f ( XIOState :: forall us. XIOSysState -> us -> XIOState us
XIOState { xioSysState :: XIOSysState
xioSysState  = XIOState s0 -> XIOSysState
forall us. XIOState us -> XIOSysState
xioSysState XIOState s0
s
                                         , xioUserState :: s1
xioUserState = s1
s1
                                         }
                              ) b
x
      (XIOState s0, [c]) -> IO (XIOState s0, [c])
forall (m :: * -> *) a. Monad m => a -> m a
return ( XIOState :: forall us. XIOSysState -> us -> XIOState us
XIOState { xioSysState :: XIOSysState
xioSysState  = XIOState s1 -> XIOSysState
forall us. XIOState us -> XIOSysState
xioSysState  XIOState s1
s'
                        , xioUserState :: s0
xioUserState = XIOState s0 -> s0
forall us. XIOState us -> us
xioUserState XIOState s0
s
                        }
             , [c]
res
             )

withoutUserState      :: IOSArrow b c -> IOStateArrow s0 b c
withoutUserState :: IOSArrow b c -> IOStateArrow s0 b c
withoutUserState      = () -> IOSArrow b c -> IOStateArrow s0 b c
forall s1 b c s0. s1 -> IOStateArrow s1 b c -> IOStateArrow s0 b c
withOtherUserState ()

-- ------------------------------------------------------------

-- system state structure and acces functions

-- |
-- predefined system state data type with all components for the
-- system functions, like trace, error handling, ...

data XIOSysState        = XIOSys  { XIOSysState -> XIOSysWriter
xioSysWriter :: !XIOSysWriter
                                  , XIOSysState -> XIOSysEnv
xioSysEnv    :: !XIOSysEnv
                                  }

instance NFData XIOSysState where
    rnf :: XIOSysState -> ()
rnf XIOSysState
x = XIOSysState -> () -> ()
seq XIOSysState
x ()    -- all fields of interest are strict

data XIOSysWriter       = XIOwrt  { XIOSysWriter -> Int
xioErrorStatus     :: !Int
                                  , XIOSysWriter -> XmlTrees
xioErrorMsgList    :: !XmlTrees
                                  , XIOSysWriter -> IOSArrow XmlTree XmlTree
xioExpatErrors     ::  IOSArrow XmlTree XmlTree
                                  , XIOSysWriter -> Int
xioRelaxNoOfErrors :: !Int
                                  , XIOSysWriter -> Int
xioRelaxDefineId   :: !Int
                                  , XIOSysWriter -> AssocList String XmlTrees
xioRelaxAttrList   ::  AssocList String XmlTrees
                                  }

data XIOSysEnv          = XIOEnv  { XIOSysEnv -> Int
xioTraceLevel      :: !Int
                                  , XIOSysEnv -> Int -> String -> IO ()
xioTraceCmd        ::  Int -> String -> IO ()
                                  , XIOSysEnv -> String -> IO ()
xioErrorMsgHandler ::  String -> IO ()
                                  , XIOSysEnv -> Bool
xioErrorMsgCollect :: !Bool
                                  , XIOSysEnv -> String
xioBaseURI         :: !String
                                  , XIOSysEnv -> String
xioDefaultBaseURI  :: !String
                                  , XIOSysEnv -> Attributes
xioAttrList        :: !Attributes
                                  , XIOSysEnv -> XIOInputConfig
xioInputConfig     :: !XIOInputConfig
                                  , XIOSysEnv -> XIOParseConfig
xioParseConfig     :: !XIOParseConfig
                                  , XIOSysEnv -> XIOOutputConfig
xioOutputConfig    :: !XIOOutputConfig
                                  , XIOSysEnv -> XIORelaxConfig
xioRelaxConfig     :: !XIORelaxConfig
                                  , XIOSysEnv -> XIOXmlSchemaConfig
xioXmlSchemaConfig :: !XIOXmlSchemaConfig
                                  , XIOSysEnv -> XIOCacheConfig
xioCacheConfig     :: !XIOCacheConfig
                                  }

data XIOInputConfig     = XIOIcgf { XIOInputConfig -> Bool
xioStrictInput    :: !Bool
                                  , XIOInputConfig -> Bool
xioEncodingErrors :: !Bool
                                  , XIOInputConfig -> String
xioInputEncoding  ::  String
                                  , XIOInputConfig -> IOSArrow XmlTree XmlTree
xioHttpHandler    ::  IOSArrow XmlTree XmlTree
                                  , XIOInputConfig -> Attributes
xioInputOptions   :: !Attributes
                                  , XIOInputConfig -> Bool
xioRedirect       :: !Bool
                                  , XIOInputConfig -> String
xioProxy          ::  String
                                  }

data XIOParseConfig     = XIOPcfg { XIOParseConfig -> MimeTypeTable
xioMimeTypes             ::  MimeTypeTable
                                  , XIOParseConfig -> MimeTypeHandlers
xioMimeTypeHandlers      ::  MimeTypeHandlers
                                  , XIOParseConfig -> String
xioMimeTypeFile          ::  String
                                  , XIOParseConfig -> [String]
xioAcceptedMimeTypes     ::  [String]
                                  , XIOParseConfig -> String
xioFileMimeType          ::  String
                                  , XIOParseConfig -> Bool
xioWarnings              :: !Bool
                                  , XIOParseConfig -> Bool
xioRemoveWS              :: !Bool
                                  , XIOParseConfig -> Bool
xioParseByMimeType       :: !Bool
                                  , XIOParseConfig -> Bool
xioParseHTML             :: !Bool
                                  , XIOParseConfig -> Bool
xioLowerCaseNames        :: !Bool
                                  , XIOParseConfig -> Bool
xioPreserveComment       :: !Bool
                                  , XIOParseConfig -> Bool
xioValidate              :: !Bool
                                  , XIOParseConfig -> Bool
xioSubstDTDEntities      :: !Bool
                                  , XIOParseConfig -> Bool
xioSubstHTMLEntities     :: !Bool
                                  , XIOParseConfig -> Bool
xioCheckNamespaces       :: !Bool
                                  , XIOParseConfig -> Bool
xioCanonicalize          :: !Bool
                                  , XIOParseConfig -> Bool
xioIgnoreNoneXmlContents :: !Bool
                                  , XIOParseConfig -> Bool
xioTagSoup               :: !Bool
                                  , XIOParseConfig -> IOSArrow XmlTree XmlTree
xioTagSoupParser         ::  IOSArrow XmlTree XmlTree
                                  , XIOParseConfig -> Bool
xioExpat                 :: !Bool
                                  , XIOParseConfig -> IOSArrow XmlTree XmlTree
xioExpatParser           ::  IOSArrow XmlTree XmlTree
                                  }

data XIOOutputConfig    = XIOOcfg { XIOOutputConfig -> Bool
xioIndent         :: !Bool
                                  , XIOOutputConfig -> String
xioOutputEncoding :: !String
                                  , XIOOutputConfig -> XIOXoutConfig
xioOutputFmt      :: !XIOXoutConfig
                                  , XIOOutputConfig -> Bool
xioXmlPi          :: !Bool
                                  , XIOOutputConfig -> [String]
xioNoEmptyElemFor :: ![String]
                                  , XIOOutputConfig -> Bool
xioAddDefaultDTD  :: !Bool
                                  , XIOOutputConfig -> Bool
xioTextMode       :: !Bool
                                  , XIOOutputConfig -> Bool
xioShowTree       :: !Bool
                                  , XIOOutputConfig -> Bool
xioShowHaskell    :: !Bool
                                  }
data XIOXoutConfig      = XMLoutput | XHTMLoutput | HTMLoutput | PLAINoutput
                          deriving (XIOXoutConfig -> XIOXoutConfig -> Bool
(XIOXoutConfig -> XIOXoutConfig -> Bool)
-> (XIOXoutConfig -> XIOXoutConfig -> Bool) -> Eq XIOXoutConfig
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: XIOXoutConfig -> XIOXoutConfig -> Bool
$c/= :: XIOXoutConfig -> XIOXoutConfig -> Bool
== :: XIOXoutConfig -> XIOXoutConfig -> Bool
$c== :: XIOXoutConfig -> XIOXoutConfig -> Bool
Eq)

data XIORelaxConfig     = XIORxc  { XIORelaxConfig -> Bool
xioRelaxValidate        :: !Bool
                                  , XIORelaxConfig -> String
xioRelaxSchema          ::  String
                                  , XIORelaxConfig -> Bool
xioRelaxCheckRestr      :: !Bool
                                  , XIORelaxConfig -> Bool
xioRelaxValidateExtRef  :: !Bool
                                  , XIORelaxConfig -> Bool
xioRelaxValidateInclude :: !Bool
                                  , XIORelaxConfig -> Bool
xioRelaxCollectErrors   :: !Bool
                                  , XIORelaxConfig -> IOSArrow XmlTree XmlTree
xioRelaxValidator       ::  IOSArrow XmlTree XmlTree
                                  }

data XIOXmlSchemaConfig = XIOScc  { XIOXmlSchemaConfig -> Bool
xioXmlSchemaValidate  :: !Bool
                                  , XIOXmlSchemaConfig -> String
xioXmlSchemaSchema    ::  String
                                  , XIOXmlSchemaConfig -> IOSArrow XmlTree XmlTree
xioXmlSchemaValidator ::  IOSArrow XmlTree XmlTree
                                  }

data XIOCacheConfig     = XIOCch  { XIOCacheConfig -> CompressionFct
xioBinaryCompression   ::  CompressionFct
                                  , XIOCacheConfig -> CompressionFct
xioBinaryDeCompression ::  DeCompressionFct
                                  , XIOCacheConfig -> Bool
xioWithCache           :: !Bool
                                  , XIOCacheConfig -> String
xioCacheDir            :: !String
                                  , XIOCacheConfig -> Int
xioDocumentAge         :: !Int
                                  , XIOCacheConfig -> Bool
xioCache404Err         :: !Bool
                                  , XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree
xioCacheRead           ::  String -> IOSArrow XmlTree XmlTree
                                  , XIOCacheConfig -> Bool
xioStrictDeserialize   :: !Bool
                                  }

type MimeTypeHandlers   = M.Map String (IOSArrow XmlTree XmlTree)

type CompressionFct     = ByteString -> ByteString
type DeCompressionFct   = ByteString -> ByteString

type SysConfig          = XIOSysState -> XIOSysState
type SysConfigList      = [SysConfig]

-- ----------------------------------------

theSysState                     :: Selector (XIOState us) XIOSysState
theSysState :: Selector (XIOState us) XIOSysState
theSysState                     = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOState us -> XIOSysState
getS = XIOState us -> XIOSysState
forall us. XIOState us -> XIOSysState
xioSysState
                                    , setS :: XIOSysState -> XIOState us -> XIOState us
setS = \ XIOSysState
x XIOState us
s -> XIOState us
s { xioSysState :: XIOSysState
xioSysState = XIOSysState
x}
                                    }

theUserState                    :: Selector (XIOState us) us
theUserState :: Selector (XIOState us) us
theUserState                    = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOState us -> us
getS = XIOState us -> us
forall us. XIOState us -> us
xioUserState
                                    , setS :: us -> XIOState us -> XIOState us
setS = \ us
x XIOState us
s -> XIOState us
s { xioUserState :: us
xioUserState = us
x}
                                    }

-- ----------------------------------------

theSysWriter                    :: Selector XIOSysState XIOSysWriter
theSysWriter :: Selector XIOSysState XIOSysWriter
theSysWriter                    = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysState -> XIOSysWriter
getS = XIOSysState -> XIOSysWriter
xioSysWriter
                                    , setS :: XIOSysWriter -> XIOSysState -> XIOSysState
setS = \ XIOSysWriter
x XIOSysState
s -> XIOSysState
s { xioSysWriter :: XIOSysWriter
xioSysWriter = XIOSysWriter
x}
                                    }

theErrorStatus                  :: Selector XIOSysState Int
theErrorStatus :: Selector XIOSysState Int
theErrorStatus                  = Selector XIOSysState XIOSysWriter
theSysWriter
                                  Selector XIOSysState XIOSysWriter
-> Selector XIOSysWriter Int -> Selector XIOSysState Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysWriter -> Int
getS = XIOSysWriter -> Int
xioErrorStatus
                                    , setS :: Int -> XIOSysWriter -> XIOSysWriter
setS = \ Int
x XIOSysWriter
s -> XIOSysWriter
s { xioErrorStatus :: Int
xioErrorStatus = Int
x }
                                    }

theErrorMsgList                 :: Selector XIOSysState XmlTrees
theErrorMsgList :: Selector XIOSysState XmlTrees
theErrorMsgList                 = Selector XIOSysState XIOSysWriter
theSysWriter
                                  Selector XIOSysState XIOSysWriter
-> Selector XIOSysWriter XmlTrees -> Selector XIOSysState XmlTrees
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysWriter -> XmlTrees
getS = XIOSysWriter -> XmlTrees
xioErrorMsgList
                                    , setS :: XmlTrees -> XIOSysWriter -> XIOSysWriter
setS = \ XmlTrees
x XIOSysWriter
s -> XIOSysWriter
s { xioErrorMsgList :: XmlTrees
xioErrorMsgList = XmlTrees
x }
                                    }

theRelaxNoOfErrors              :: Selector XIOSysState Int
theRelaxNoOfErrors :: Selector XIOSysState Int
theRelaxNoOfErrors              = Selector XIOSysState XIOSysWriter
theSysWriter
                                  Selector XIOSysState XIOSysWriter
-> Selector XIOSysWriter Int -> Selector XIOSysState Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysWriter -> Int
getS = XIOSysWriter -> Int
xioRelaxNoOfErrors
                                    , setS :: Int -> XIOSysWriter -> XIOSysWriter
setS = \ Int
x XIOSysWriter
s -> XIOSysWriter
s { xioRelaxNoOfErrors :: Int
xioRelaxNoOfErrors = Int
x}
                                    }

theRelaxDefineId                :: Selector XIOSysState Int
theRelaxDefineId :: Selector XIOSysState Int
theRelaxDefineId                = Selector XIOSysState XIOSysWriter
theSysWriter
                                  Selector XIOSysState XIOSysWriter
-> Selector XIOSysWriter Int -> Selector XIOSysState Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysWriter -> Int
getS = XIOSysWriter -> Int
xioRelaxDefineId
                                    , setS :: Int -> XIOSysWriter -> XIOSysWriter
setS = \ Int
x XIOSysWriter
s -> XIOSysWriter
s { xioRelaxDefineId :: Int
xioRelaxDefineId = Int
x}
                                    }

theRelaxAttrList                :: Selector XIOSysState (AssocList String XmlTrees)
theRelaxAttrList :: Selector XIOSysState (AssocList String XmlTrees)
theRelaxAttrList                = Selector XIOSysState XIOSysWriter
theSysWriter
                                  Selector XIOSysState XIOSysWriter
-> Selector XIOSysWriter (AssocList String XmlTrees)
-> Selector XIOSysState (AssocList String XmlTrees)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysWriter -> AssocList String XmlTrees
getS = XIOSysWriter -> AssocList String XmlTrees
xioRelaxAttrList
                                    , setS :: AssocList String XmlTrees -> XIOSysWriter -> XIOSysWriter
setS = \ AssocList String XmlTrees
x XIOSysWriter
s -> XIOSysWriter
s { xioRelaxAttrList :: AssocList String XmlTrees
xioRelaxAttrList = AssocList String XmlTrees
x}
                                    }

-- ----------------------------------------

theSysEnv                       :: Selector XIOSysState XIOSysEnv
theSysEnv :: Selector XIOSysState XIOSysEnv
theSysEnv                       = S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysState -> XIOSysEnv
getS = XIOSysState -> XIOSysEnv
xioSysEnv
                                    , setS :: XIOSysEnv -> XIOSysState -> XIOSysState
setS = \ XIOSysEnv
x XIOSysState
s -> XIOSysState
s { xioSysEnv :: XIOSysEnv
xioSysEnv = XIOSysEnv
x}
                                    }

theInputConfig                  :: Selector XIOSysState XIOInputConfig
theInputConfig :: Selector XIOSysState XIOInputConfig
theInputConfig                  = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv XIOInputConfig
-> Selector XIOSysState XIOInputConfig
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> XIOInputConfig
getS = XIOSysEnv -> XIOInputConfig
xioInputConfig
                                    , setS :: XIOInputConfig -> XIOSysEnv -> XIOSysEnv
setS = \ XIOInputConfig
x XIOSysEnv
s -> XIOSysEnv
s { xioInputConfig :: XIOInputConfig
xioInputConfig = XIOInputConfig
x}
                                    }

theStrictInput                  :: Selector XIOSysState Bool
theStrictInput :: Selector XIOSysState Bool
theStrictInput                  = Selector XIOSysState XIOInputConfig
theInputConfig
                                  Selector XIOSysState XIOInputConfig
-> Selector XIOInputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOInputConfig -> Bool
getS = XIOInputConfig -> Bool
xioStrictInput
                                    , setS :: Bool -> XIOInputConfig -> XIOInputConfig
setS = \ Bool
x XIOInputConfig
s -> XIOInputConfig
s { xioStrictInput :: Bool
xioStrictInput = Bool
x}
                                    }

theEncodingErrors               :: Selector XIOSysState Bool
theEncodingErrors :: Selector XIOSysState Bool
theEncodingErrors               = Selector XIOSysState XIOInputConfig
theInputConfig
                                  Selector XIOSysState XIOInputConfig
-> Selector XIOInputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOInputConfig -> Bool
getS = XIOInputConfig -> Bool
xioEncodingErrors
                                    , setS :: Bool -> XIOInputConfig -> XIOInputConfig
setS = \ Bool
x XIOInputConfig
s -> XIOInputConfig
s { xioEncodingErrors :: Bool
xioEncodingErrors = Bool
x}
                                    }

theInputEncoding                :: Selector XIOSysState String
theInputEncoding :: Selector XIOSysState String
theInputEncoding                = Selector XIOSysState XIOInputConfig
theInputConfig
                                  Selector XIOSysState XIOInputConfig
-> Selector XIOInputConfig String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOInputConfig -> String
getS = XIOInputConfig -> String
xioInputEncoding
                                    , setS :: String -> XIOInputConfig -> XIOInputConfig
setS = \ String
x XIOInputConfig
s -> XIOInputConfig
s { xioInputEncoding :: String
xioInputEncoding = String
x}
                                    }

theHttpHandler                  :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theHttpHandler :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theHttpHandler                  = Selector XIOSysState XIOInputConfig
theInputConfig
                                  Selector XIOSysState XIOInputConfig
-> Selector XIOInputConfig (IOSArrow XmlTree XmlTree)
-> Selector XIOSysState (IOSArrow XmlTree XmlTree)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOInputConfig -> IOSArrow XmlTree XmlTree
getS = XIOInputConfig -> IOSArrow XmlTree XmlTree
xioHttpHandler
                                    , setS :: IOSArrow XmlTree XmlTree -> XIOInputConfig -> XIOInputConfig
setS = \ IOSArrow XmlTree XmlTree
x XIOInputConfig
s -> XIOInputConfig
s { xioHttpHandler :: IOSArrow XmlTree XmlTree
xioHttpHandler = IOSArrow XmlTree XmlTree
x}
                                    }

theInputOptions                 :: Selector XIOSysState Attributes
theInputOptions :: Selector XIOSysState Attributes
theInputOptions                 = Selector XIOSysState XIOInputConfig
theInputConfig
                                  Selector XIOSysState XIOInputConfig
-> Selector XIOInputConfig Attributes
-> Selector XIOSysState Attributes
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOInputConfig -> Attributes
getS = XIOInputConfig -> Attributes
xioInputOptions
                                    , setS :: Attributes -> XIOInputConfig -> XIOInputConfig
setS = \ Attributes
x XIOInputConfig
s -> XIOInputConfig
s { xioInputOptions :: Attributes
xioInputOptions = Attributes
x}
                                    }

theRedirect                     :: Selector XIOSysState Bool
theRedirect :: Selector XIOSysState Bool
theRedirect                     = Selector XIOSysState XIOInputConfig
theInputConfig
                                  Selector XIOSysState XIOInputConfig
-> Selector XIOInputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOInputConfig -> Bool
getS = XIOInputConfig -> Bool
xioRedirect
                                    , setS :: Bool -> XIOInputConfig -> XIOInputConfig
setS = \ Bool
x XIOInputConfig
s -> XIOInputConfig
s { xioRedirect :: Bool
xioRedirect = Bool
x}
                                    }

theProxy                        :: Selector XIOSysState String
theProxy :: Selector XIOSysState String
theProxy                        = Selector XIOSysState XIOInputConfig
theInputConfig
                                  Selector XIOSysState XIOInputConfig
-> Selector XIOInputConfig String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOInputConfig -> String
getS = XIOInputConfig -> String
xioProxy
                                    , setS :: String -> XIOInputConfig -> XIOInputConfig
setS = \ String
x XIOInputConfig
s -> XIOInputConfig
s { xioProxy :: String
xioProxy = String
x}
                                    }

-- ----------------------------------------

theOutputConfig                 :: Selector XIOSysState XIOOutputConfig
theOutputConfig :: Selector XIOSysState XIOOutputConfig
theOutputConfig                 = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv XIOOutputConfig
-> Selector XIOSysState XIOOutputConfig
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> XIOOutputConfig
getS = XIOSysEnv -> XIOOutputConfig
xioOutputConfig
                                    , setS :: XIOOutputConfig -> XIOSysEnv -> XIOSysEnv
setS = \ XIOOutputConfig
x XIOSysEnv
s -> XIOSysEnv
s { xioOutputConfig :: XIOOutputConfig
xioOutputConfig = XIOOutputConfig
x}
                                    }

theIndent                       :: Selector XIOSysState Bool
theIndent :: Selector XIOSysState Bool
theIndent                       = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> Bool
getS = XIOOutputConfig -> Bool
xioIndent
                                    , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
setS = \ Bool
x XIOOutputConfig
s -> XIOOutputConfig
s { xioIndent :: Bool
xioIndent = Bool
x}
                                    }

theOutputEncoding               :: Selector XIOSysState String
theOutputEncoding :: Selector XIOSysState String
theOutputEncoding               = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> String
getS = XIOOutputConfig -> String
xioOutputEncoding
                                    , setS :: String -> XIOOutputConfig -> XIOOutputConfig
setS = \ String
x XIOOutputConfig
s -> XIOOutputConfig
s { xioOutputEncoding :: String
xioOutputEncoding = String
x}
                                    }

theOutputFmt                    :: Selector XIOSysState XIOXoutConfig
theOutputFmt :: Selector XIOSysState XIOXoutConfig
theOutputFmt                    = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig XIOXoutConfig
-> Selector XIOSysState XIOXoutConfig
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> XIOXoutConfig
getS = XIOOutputConfig -> XIOXoutConfig
xioOutputFmt
                                    , setS :: XIOXoutConfig -> XIOOutputConfig -> XIOOutputConfig
setS = \ XIOXoutConfig
x XIOOutputConfig
s -> XIOOutputConfig
s { xioOutputFmt :: XIOXoutConfig
xioOutputFmt = XIOXoutConfig
x}
                                    }

theXmlPi                        :: Selector XIOSysState Bool
theXmlPi :: Selector XIOSysState Bool
theXmlPi                        = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> Bool
getS = XIOOutputConfig -> Bool
xioXmlPi
                                    , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
setS = \ Bool
x XIOOutputConfig
s -> XIOOutputConfig
s { xioXmlPi :: Bool
xioXmlPi = Bool
x}
                                    }

theNoEmptyElemFor               :: Selector XIOSysState [String]
theNoEmptyElemFor :: Selector XIOSysState [String]
theNoEmptyElemFor               = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig [String]
-> Selector XIOSysState [String]
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> [String]
getS = XIOOutputConfig -> [String]
xioNoEmptyElemFor
                                    , setS :: [String] -> XIOOutputConfig -> XIOOutputConfig
setS = \ [String]
x XIOOutputConfig
s -> XIOOutputConfig
s { xioNoEmptyElemFor :: [String]
xioNoEmptyElemFor = [String]
x}
                                    }

theAddDefaultDTD                :: Selector XIOSysState Bool
theAddDefaultDTD :: Selector XIOSysState Bool
theAddDefaultDTD                = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> Bool
getS = XIOOutputConfig -> Bool
xioAddDefaultDTD
                                    , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
setS = \ Bool
x XIOOutputConfig
s -> XIOOutputConfig
s { xioAddDefaultDTD :: Bool
xioAddDefaultDTD = Bool
x}
                                    }

theTextMode                     :: Selector XIOSysState Bool
theTextMode :: Selector XIOSysState Bool
theTextMode                     = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> Bool
getS = XIOOutputConfig -> Bool
xioTextMode
                                    , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
setS = \ Bool
x XIOOutputConfig
s -> XIOOutputConfig
s { xioTextMode :: Bool
xioTextMode = Bool
x}
                                    }

theShowTree                     :: Selector XIOSysState Bool
theShowTree :: Selector XIOSysState Bool
theShowTree                     = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> Bool
getS = XIOOutputConfig -> Bool
xioShowTree
                                    , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
setS = \ Bool
x XIOOutputConfig
s -> XIOOutputConfig
s { xioShowTree :: Bool
xioShowTree = Bool
x}
                                    }

theShowHaskell                  :: Selector XIOSysState Bool
theShowHaskell :: Selector XIOSysState Bool
theShowHaskell                  = Selector XIOSysState XIOOutputConfig
theOutputConfig
                                  Selector XIOSysState XIOOutputConfig
-> Selector XIOOutputConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOOutputConfig -> Bool
getS = XIOOutputConfig -> Bool
xioShowHaskell
                                    , setS :: Bool -> XIOOutputConfig -> XIOOutputConfig
setS = \ Bool
x XIOOutputConfig
s -> XIOOutputConfig
s { xioShowHaskell :: Bool
xioShowHaskell = Bool
x}
                                    }

-- ----------------------------------------

theRelaxConfig                  :: Selector XIOSysState XIORelaxConfig
theRelaxConfig :: Selector XIOSysState XIORelaxConfig
theRelaxConfig                  = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv XIORelaxConfig
-> Selector XIOSysState XIORelaxConfig
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> XIORelaxConfig
getS = XIOSysEnv -> XIORelaxConfig
xioRelaxConfig
                                    , setS :: XIORelaxConfig -> XIOSysEnv -> XIOSysEnv
setS = \ XIORelaxConfig
x XIOSysEnv
s -> XIOSysEnv
s { xioRelaxConfig :: XIORelaxConfig
xioRelaxConfig = XIORelaxConfig
x}
                                    }

theRelaxValidate                :: Selector XIOSysState Bool
theRelaxValidate :: Selector XIOSysState Bool
theRelaxValidate                = Selector XIOSysState XIORelaxConfig
theRelaxConfig
                                  Selector XIOSysState XIORelaxConfig
-> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIORelaxConfig -> Bool
getS = XIORelaxConfig -> Bool
xioRelaxValidate
                                    , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
setS = \ Bool
x XIORelaxConfig
s -> XIORelaxConfig
s { xioRelaxValidate :: Bool
xioRelaxValidate = Bool
x}
                                    }

theRelaxSchema                  :: Selector XIOSysState String
theRelaxSchema :: Selector XIOSysState String
theRelaxSchema                  = Selector XIOSysState XIORelaxConfig
theRelaxConfig
                                  Selector XIOSysState XIORelaxConfig
-> Selector XIORelaxConfig String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIORelaxConfig -> String
getS = XIORelaxConfig -> String
xioRelaxSchema
                                    , setS :: String -> XIORelaxConfig -> XIORelaxConfig
setS = \ String
x XIORelaxConfig
s -> XIORelaxConfig
s { xioRelaxSchema :: String
xioRelaxSchema = String
x}
                                    }

theRelaxCheckRestr              :: Selector XIOSysState Bool
theRelaxCheckRestr :: Selector XIOSysState Bool
theRelaxCheckRestr              = Selector XIOSysState XIORelaxConfig
theRelaxConfig
                                  Selector XIOSysState XIORelaxConfig
-> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIORelaxConfig -> Bool
getS = XIORelaxConfig -> Bool
xioRelaxCheckRestr
                                    , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
setS = \ Bool
x XIORelaxConfig
s -> XIORelaxConfig
s { xioRelaxCheckRestr :: Bool
xioRelaxCheckRestr = Bool
x}
                                    }

theRelaxValidateExtRef          :: Selector XIOSysState Bool
theRelaxValidateExtRef :: Selector XIOSysState Bool
theRelaxValidateExtRef          = Selector XIOSysState XIORelaxConfig
theRelaxConfig
                                  Selector XIOSysState XIORelaxConfig
-> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIORelaxConfig -> Bool
getS = XIORelaxConfig -> Bool
xioRelaxValidateExtRef
                                    , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
setS = \ Bool
x XIORelaxConfig
s -> XIORelaxConfig
s { xioRelaxValidateExtRef :: Bool
xioRelaxValidateExtRef = Bool
x}
                                    }

theRelaxValidateInclude         :: Selector XIOSysState Bool
theRelaxValidateInclude :: Selector XIOSysState Bool
theRelaxValidateInclude         = Selector XIOSysState XIORelaxConfig
theRelaxConfig
                                  Selector XIOSysState XIORelaxConfig
-> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIORelaxConfig -> Bool
getS = XIORelaxConfig -> Bool
xioRelaxValidateInclude
                                    , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
setS = \ Bool
x XIORelaxConfig
s -> XIORelaxConfig
s { xioRelaxValidateInclude :: Bool
xioRelaxValidateInclude = Bool
x}
                                    }

theRelaxCollectErrors           :: Selector XIOSysState Bool
theRelaxCollectErrors :: Selector XIOSysState Bool
theRelaxCollectErrors           = Selector XIOSysState XIORelaxConfig
theRelaxConfig
                                  Selector XIOSysState XIORelaxConfig
-> Selector XIORelaxConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIORelaxConfig -> Bool
getS = XIORelaxConfig -> Bool
xioRelaxCollectErrors
                                    , setS :: Bool -> XIORelaxConfig -> XIORelaxConfig
setS = \ Bool
x XIORelaxConfig
s -> XIORelaxConfig
s { xioRelaxCollectErrors :: Bool
xioRelaxCollectErrors = Bool
x}
                                    }

theRelaxValidator               :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theRelaxValidator :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theRelaxValidator               = Selector XIOSysState XIORelaxConfig
theRelaxConfig
                                  Selector XIOSysState XIORelaxConfig
-> Selector XIORelaxConfig (IOSArrow XmlTree XmlTree)
-> Selector XIOSysState (IOSArrow XmlTree XmlTree)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIORelaxConfig -> IOSArrow XmlTree XmlTree
getS = XIORelaxConfig -> IOSArrow XmlTree XmlTree
xioRelaxValidator
                                    , setS :: IOSArrow XmlTree XmlTree -> XIORelaxConfig -> XIORelaxConfig
setS = \ IOSArrow XmlTree XmlTree
x XIORelaxConfig
s -> XIORelaxConfig
s { xioRelaxValidator :: IOSArrow XmlTree XmlTree
xioRelaxValidator = IOSArrow XmlTree XmlTree
x}
                                    }

-- ----------------------------------------

theXmlSchemaConfig              :: Selector XIOSysState XIOXmlSchemaConfig
theXmlSchemaConfig :: Selector XIOSysState XIOXmlSchemaConfig
theXmlSchemaConfig              = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv XIOXmlSchemaConfig
-> Selector XIOSysState XIOXmlSchemaConfig
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> XIOXmlSchemaConfig
getS = XIOSysEnv -> XIOXmlSchemaConfig
xioXmlSchemaConfig
                                    , setS :: XIOXmlSchemaConfig -> XIOSysEnv -> XIOSysEnv
setS = \ XIOXmlSchemaConfig
x XIOSysEnv
s -> XIOSysEnv
s { xioXmlSchemaConfig :: XIOXmlSchemaConfig
xioXmlSchemaConfig = XIOXmlSchemaConfig
x}
                                    }

theXmlSchemaValidate            :: Selector XIOSysState Bool
theXmlSchemaValidate :: Selector XIOSysState Bool
theXmlSchemaValidate            = Selector XIOSysState XIOXmlSchemaConfig
theXmlSchemaConfig
                                  Selector XIOSysState XIOXmlSchemaConfig
-> Selector XIOXmlSchemaConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOXmlSchemaConfig -> Bool
getS = XIOXmlSchemaConfig -> Bool
xioXmlSchemaValidate
                                    , setS :: Bool -> XIOXmlSchemaConfig -> XIOXmlSchemaConfig
setS = \ Bool
x XIOXmlSchemaConfig
s -> XIOXmlSchemaConfig
s { xioXmlSchemaValidate :: Bool
xioXmlSchemaValidate = Bool
x}
                                    }

theXmlSchemaSchema              :: Selector XIOSysState String
theXmlSchemaSchema :: Selector XIOSysState String
theXmlSchemaSchema              = Selector XIOSysState XIOXmlSchemaConfig
theXmlSchemaConfig
                                  Selector XIOSysState XIOXmlSchemaConfig
-> Selector XIOXmlSchemaConfig String
-> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOXmlSchemaConfig -> String
getS = XIOXmlSchemaConfig -> String
xioXmlSchemaSchema
                                    , setS :: String -> XIOXmlSchemaConfig -> XIOXmlSchemaConfig
setS = \ String
x XIOXmlSchemaConfig
s -> XIOXmlSchemaConfig
s { xioXmlSchemaSchema :: String
xioXmlSchemaSchema = String
x}
                                    }

theXmlSchemaValidator           :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theXmlSchemaValidator :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theXmlSchemaValidator           = Selector XIOSysState XIOXmlSchemaConfig
theXmlSchemaConfig
                                  Selector XIOSysState XIOXmlSchemaConfig
-> Selector XIOXmlSchemaConfig (IOSArrow XmlTree XmlTree)
-> Selector XIOSysState (IOSArrow XmlTree XmlTree)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOXmlSchemaConfig -> IOSArrow XmlTree XmlTree
getS = XIOXmlSchemaConfig -> IOSArrow XmlTree XmlTree
xioXmlSchemaValidator
                                    , setS :: IOSArrow XmlTree XmlTree
-> XIOXmlSchemaConfig -> XIOXmlSchemaConfig
setS = \ IOSArrow XmlTree XmlTree
x XIOXmlSchemaConfig
s -> XIOXmlSchemaConfig
s { xioXmlSchemaValidator :: IOSArrow XmlTree XmlTree
xioXmlSchemaValidator = IOSArrow XmlTree XmlTree
x}
                                    }

-- ----------------------------------------

theParseConfig                  :: Selector XIOSysState XIOParseConfig
theParseConfig :: Selector XIOSysState XIOParseConfig
theParseConfig                  = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv XIOParseConfig
-> Selector XIOSysState XIOParseConfig
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> XIOParseConfig
getS = XIOSysEnv -> XIOParseConfig
xioParseConfig
                                    , setS :: XIOParseConfig -> XIOSysEnv -> XIOSysEnv
setS = \ XIOParseConfig
x XIOSysEnv
s -> XIOSysEnv
s { xioParseConfig :: XIOParseConfig
xioParseConfig = XIOParseConfig
x}
                                    }

theErrorMsgHandler              :: Selector XIOSysState (String -> IO ())
theErrorMsgHandler :: Selector XIOSysState (String -> IO ())
theErrorMsgHandler              = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv (String -> IO ())
-> Selector XIOSysState (String -> IO ())
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> String -> IO ()
getS = XIOSysEnv -> String -> IO ()
xioErrorMsgHandler
                                    , setS :: (String -> IO ()) -> XIOSysEnv -> XIOSysEnv
setS = \ String -> IO ()
x XIOSysEnv
s -> XIOSysEnv
s { xioErrorMsgHandler :: String -> IO ()
xioErrorMsgHandler = String -> IO ()
x }
                                    }

theErrorMsgCollect              :: Selector XIOSysState Bool
theErrorMsgCollect :: Selector XIOSysState Bool
theErrorMsgCollect              = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> Bool
getS = XIOSysEnv -> Bool
xioErrorMsgCollect
                                    , setS :: Bool -> XIOSysEnv -> XIOSysEnv
setS = \ Bool
x XIOSysEnv
s -> XIOSysEnv
s { xioErrorMsgCollect :: Bool
xioErrorMsgCollect = Bool
x }
                                    }

theBaseURI                      :: Selector XIOSysState String
theBaseURI :: Selector XIOSysState String
theBaseURI                      = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> String
getS = XIOSysEnv -> String
xioBaseURI
                                    , setS :: String -> XIOSysEnv -> XIOSysEnv
setS = \ String
x XIOSysEnv
s -> XIOSysEnv
s { xioBaseURI :: String
xioBaseURI = String
x }
                                    }

theDefaultBaseURI               :: Selector XIOSysState String
theDefaultBaseURI :: Selector XIOSysState String
theDefaultBaseURI               = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> String
getS = XIOSysEnv -> String
xioDefaultBaseURI
                                    , setS :: String -> XIOSysEnv -> XIOSysEnv
setS = \ String
x XIOSysEnv
s -> XIOSysEnv
s { xioDefaultBaseURI :: String
xioDefaultBaseURI = String
x }
                                    }

theTraceLevel                   :: Selector XIOSysState Int
theTraceLevel :: Selector XIOSysState Int
theTraceLevel                   = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv Int -> Selector XIOSysState Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> Int
getS = XIOSysEnv -> Int
xioTraceLevel
                                    , setS :: Int -> XIOSysEnv -> XIOSysEnv
setS = \ Int
x XIOSysEnv
s -> XIOSysEnv
s { xioTraceLevel :: Int
xioTraceLevel = Int
x }
                                    }

theTraceCmd                     :: Selector XIOSysState (Int -> String -> IO ())
theTraceCmd :: Selector XIOSysState (Int -> String -> IO ())
theTraceCmd                     = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv (Int -> String -> IO ())
-> Selector XIOSysState (Int -> String -> IO ())
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> Int -> String -> IO ()
getS = XIOSysEnv -> Int -> String -> IO ()
xioTraceCmd
                                    , setS :: (Int -> String -> IO ()) -> XIOSysEnv -> XIOSysEnv
setS = \ Int -> String -> IO ()
x XIOSysEnv
s -> XIOSysEnv
s { xioTraceCmd :: Int -> String -> IO ()
xioTraceCmd = Int -> String -> IO ()
x }
                                    }

theTrace                        :: Selector XIOSysState (Int, Int -> String -> IO ())
theTrace :: Selector XIOSysState (Int, Int -> String -> IO ())
theTrace                        = Selector XIOSysState Int
theTraceLevel Selector XIOSysState Int
-> Selector XIOSysState (Int -> String -> IO ())
-> Selector XIOSysState (Int, Int -> String -> IO ())
forall s a b. Selector s a -> Selector s b -> Selector s (a, b)
.&&&. Selector XIOSysState (Int -> String -> IO ())
theTraceCmd

theAttrList                     :: Selector XIOSysState Attributes
theAttrList :: Selector XIOSysState Attributes
theAttrList                     = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv Attributes -> Selector XIOSysState Attributes
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> Attributes
getS = XIOSysEnv -> Attributes
xioAttrList
                                    , setS :: Attributes -> XIOSysEnv -> XIOSysEnv
setS = \ Attributes
x XIOSysEnv
s -> XIOSysEnv
s { xioAttrList :: Attributes
xioAttrList = Attributes
x }
                                    }

theMimeTypes                    :: Selector XIOSysState MimeTypeTable
theMimeTypes :: Selector XIOSysState MimeTypeTable
theMimeTypes                    = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig MimeTypeTable
-> Selector XIOSysState MimeTypeTable
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> MimeTypeTable
getS = XIOParseConfig -> MimeTypeTable
xioMimeTypes
                                    , setS :: MimeTypeTable -> XIOParseConfig -> XIOParseConfig
setS = \ MimeTypeTable
x XIOParseConfig
s -> XIOParseConfig
s { xioMimeTypes :: MimeTypeTable
xioMimeTypes = MimeTypeTable
x }
                                    }

theMimeTypeHandlers             :: Selector XIOSysState MimeTypeHandlers
theMimeTypeHandlers :: Selector XIOSysState MimeTypeHandlers
theMimeTypeHandlers             = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig MimeTypeHandlers
-> Selector XIOSysState MimeTypeHandlers
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> MimeTypeHandlers
getS = XIOParseConfig -> MimeTypeHandlers
xioMimeTypeHandlers
                                    , setS :: MimeTypeHandlers -> XIOParseConfig -> XIOParseConfig
setS = \ MimeTypeHandlers
x XIOParseConfig
s -> XIOParseConfig
s { xioMimeTypeHandlers :: MimeTypeHandlers
xioMimeTypeHandlers = MimeTypeHandlers
x }
                                    }

theMimeTypeFile                 :: Selector XIOSysState String
theMimeTypeFile :: Selector XIOSysState String
theMimeTypeFile                 = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> String
getS = XIOParseConfig -> String
xioMimeTypeFile
                                    , setS :: String -> XIOParseConfig -> XIOParseConfig
setS = \ String
x XIOParseConfig
s -> XIOParseConfig
s { xioMimeTypeFile :: String
xioMimeTypeFile = String
x }
                                    }

theAcceptedMimeTypes            :: Selector XIOSysState [String]
theAcceptedMimeTypes :: Selector XIOSysState [String]
theAcceptedMimeTypes            = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig [String]
-> Selector XIOSysState [String]
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> [String]
getS = XIOParseConfig -> [String]
xioAcceptedMimeTypes
                                    , setS :: [String] -> XIOParseConfig -> XIOParseConfig
setS = \ [String]
x XIOParseConfig
s -> XIOParseConfig
s { xioAcceptedMimeTypes :: [String]
xioAcceptedMimeTypes = [String]
x }
                                    }

theFileMimeType                 :: Selector XIOSysState String
theFileMimeType :: Selector XIOSysState String
theFileMimeType                 = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> String
getS = XIOParseConfig -> String
xioFileMimeType
                                    , setS :: String -> XIOParseConfig -> XIOParseConfig
setS = \ String
x XIOParseConfig
s -> XIOParseConfig
s { xioFileMimeType :: String
xioFileMimeType = String
x }
                                    }

theWarnings                     :: Selector XIOSysState Bool
theWarnings :: Selector XIOSysState Bool
theWarnings                     = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioWarnings
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioWarnings :: Bool
xioWarnings = Bool
x }
                                    }

theRemoveWS                     :: Selector XIOSysState Bool
theRemoveWS :: Selector XIOSysState Bool
theRemoveWS                     = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioRemoveWS
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioRemoveWS :: Bool
xioRemoveWS = Bool
x }
                                    }

thePreserveComment              :: Selector XIOSysState Bool
thePreserveComment :: Selector XIOSysState Bool
thePreserveComment              = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioPreserveComment
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioPreserveComment :: Bool
xioPreserveComment = Bool
x }
                                    }

theParseByMimeType              :: Selector XIOSysState Bool
theParseByMimeType :: Selector XIOSysState Bool
theParseByMimeType              = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioParseByMimeType
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioParseByMimeType :: Bool
xioParseByMimeType = Bool
x }
                                    }

theParseHTML                    :: Selector XIOSysState Bool
theParseHTML :: Selector XIOSysState Bool
theParseHTML                    = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioParseHTML
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioParseHTML :: Bool
xioParseHTML = Bool
x }
                                    }

theLowerCaseNames               :: Selector XIOSysState Bool
theLowerCaseNames :: Selector XIOSysState Bool
theLowerCaseNames               = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioLowerCaseNames
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioLowerCaseNames :: Bool
xioLowerCaseNames = Bool
x }
                                    }

theValidate                     :: Selector XIOSysState Bool
theValidate :: Selector XIOSysState Bool
theValidate                     = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioValidate
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioValidate :: Bool
xioValidate = Bool
x }
                                    }

theSubstDTDEntities            :: Selector XIOSysState Bool
theSubstDTDEntities :: Selector XIOSysState Bool
theSubstDTDEntities            = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioSubstDTDEntities
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioSubstDTDEntities :: Bool
xioSubstDTDEntities = Bool
x }
                                    }

theSubstHTMLEntities            :: Selector XIOSysState Bool
theSubstHTMLEntities :: Selector XIOSysState Bool
theSubstHTMLEntities            = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioSubstHTMLEntities
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioSubstHTMLEntities :: Bool
xioSubstHTMLEntities = Bool
x }
                                    }

theCheckNamespaces              :: Selector XIOSysState Bool
theCheckNamespaces :: Selector XIOSysState Bool
theCheckNamespaces              = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioCheckNamespaces
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioCheckNamespaces :: Bool
xioCheckNamespaces = Bool
x }
                                    }

theCanonicalize                 :: Selector XIOSysState Bool
theCanonicalize :: Selector XIOSysState Bool
theCanonicalize                 = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioCanonicalize
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioCanonicalize :: Bool
xioCanonicalize = Bool
x }
                                    }

theIgnoreNoneXmlContents        :: Selector XIOSysState Bool
theIgnoreNoneXmlContents :: Selector XIOSysState Bool
theIgnoreNoneXmlContents        = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioIgnoreNoneXmlContents
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioIgnoreNoneXmlContents :: Bool
xioIgnoreNoneXmlContents = Bool
x }
                                    }

theTagSoup                      :: Selector XIOSysState Bool
theTagSoup :: Selector XIOSysState Bool
theTagSoup                      = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioTagSoup
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioTagSoup :: Bool
xioTagSoup = Bool
x }
                                    }

theTagSoupParser                :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theTagSoupParser :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theTagSoupParser                = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig (IOSArrow XmlTree XmlTree)
-> Selector XIOSysState (IOSArrow XmlTree XmlTree)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> IOSArrow XmlTree XmlTree
getS = XIOParseConfig -> IOSArrow XmlTree XmlTree
xioTagSoupParser
                                    , setS :: IOSArrow XmlTree XmlTree -> XIOParseConfig -> XIOParseConfig
setS = \ IOSArrow XmlTree XmlTree
x XIOParseConfig
s -> XIOParseConfig
s { xioTagSoupParser :: IOSArrow XmlTree XmlTree
xioTagSoupParser = IOSArrow XmlTree XmlTree
x }
                                    }

theExpat                        :: Selector XIOSysState Bool
theExpat :: Selector XIOSysState Bool
theExpat                        = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> Bool
getS = XIOParseConfig -> Bool
xioExpat
                                    , setS :: Bool -> XIOParseConfig -> XIOParseConfig
setS = \ Bool
x XIOParseConfig
s -> XIOParseConfig
s { xioExpat :: Bool
xioExpat = Bool
x }
                                    }

theExpatParser                  :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theExpatParser :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theExpatParser                  = Selector XIOSysState XIOParseConfig
theParseConfig
                                  Selector XIOSysState XIOParseConfig
-> Selector XIOParseConfig (IOSArrow XmlTree XmlTree)
-> Selector XIOSysState (IOSArrow XmlTree XmlTree)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOParseConfig -> IOSArrow XmlTree XmlTree
getS = XIOParseConfig -> IOSArrow XmlTree XmlTree
xioExpatParser
                                    , setS :: IOSArrow XmlTree XmlTree -> XIOParseConfig -> XIOParseConfig
setS = \ IOSArrow XmlTree XmlTree
x XIOParseConfig
s -> XIOParseConfig
s { xioExpatParser :: IOSArrow XmlTree XmlTree
xioExpatParser = IOSArrow XmlTree XmlTree
x }
                                    }

theExpatErrors                  :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theExpatErrors :: Selector XIOSysState (IOSArrow XmlTree XmlTree)
theExpatErrors                  = Selector XIOSysState XIOSysWriter
theSysWriter
                                  Selector XIOSysState XIOSysWriter
-> Selector XIOSysWriter (IOSArrow XmlTree XmlTree)
-> Selector XIOSysState (IOSArrow XmlTree XmlTree)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysWriter -> IOSArrow XmlTree XmlTree
getS = XIOSysWriter -> IOSArrow XmlTree XmlTree
xioExpatErrors
                                    , setS :: IOSArrow XmlTree XmlTree -> XIOSysWriter -> XIOSysWriter
setS = \ IOSArrow XmlTree XmlTree
x XIOSysWriter
s -> XIOSysWriter
s { xioExpatErrors :: IOSArrow XmlTree XmlTree
xioExpatErrors = IOSArrow XmlTree XmlTree
x }
                                    }

-- ----------------------------------------

theCacheConfig                  :: Selector XIOSysState XIOCacheConfig
theCacheConfig :: Selector XIOSysState XIOCacheConfig
theCacheConfig                  = Selector XIOSysState XIOSysEnv
theSysEnv
                                  Selector XIOSysState XIOSysEnv
-> Selector XIOSysEnv XIOCacheConfig
-> Selector XIOSysState XIOCacheConfig
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOSysEnv -> XIOCacheConfig
getS = XIOSysEnv -> XIOCacheConfig
xioCacheConfig
                                    , setS :: XIOCacheConfig -> XIOSysEnv -> XIOSysEnv
setS = \ XIOCacheConfig
x XIOSysEnv
s -> XIOSysEnv
s { xioCacheConfig :: XIOCacheConfig
xioCacheConfig = XIOCacheConfig
x}
                                    }

theBinaryCompression            :: Selector XIOSysState (ByteString -> ByteString)
theBinaryCompression :: Selector XIOSysState CompressionFct
theBinaryCompression            = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig CompressionFct
-> Selector XIOSysState CompressionFct
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> CompressionFct
getS = XIOCacheConfig -> CompressionFct
xioBinaryCompression
                                    , setS :: CompressionFct -> XIOCacheConfig -> XIOCacheConfig
setS = \ CompressionFct
x XIOCacheConfig
s -> XIOCacheConfig
s { xioBinaryCompression :: CompressionFct
xioBinaryCompression = CompressionFct
x}
                                    }

theBinaryDeCompression          :: Selector XIOSysState (ByteString -> ByteString)
theBinaryDeCompression :: Selector XIOSysState CompressionFct
theBinaryDeCompression          = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig CompressionFct
-> Selector XIOSysState CompressionFct
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> CompressionFct
getS = XIOCacheConfig -> CompressionFct
xioBinaryDeCompression
                                    , setS :: CompressionFct -> XIOCacheConfig -> XIOCacheConfig
setS = \ CompressionFct
x XIOCacheConfig
s -> XIOCacheConfig
s { xioBinaryDeCompression :: CompressionFct
xioBinaryDeCompression = CompressionFct
x}
                                    }

theWithCache                    :: Selector XIOSysState Bool
theWithCache :: Selector XIOSysState Bool
theWithCache                    = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> Bool
getS = XIOCacheConfig -> Bool
xioWithCache
                                    , setS :: Bool -> XIOCacheConfig -> XIOCacheConfig
setS = \ Bool
x XIOCacheConfig
s -> XIOCacheConfig
s { xioWithCache :: Bool
xioWithCache = Bool
x}
                                    }

theCacheDir                     :: Selector XIOSysState String
theCacheDir :: Selector XIOSysState String
theCacheDir                     = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig String -> Selector XIOSysState String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> String
getS = XIOCacheConfig -> String
xioCacheDir
                                    , setS :: String -> XIOCacheConfig -> XIOCacheConfig
setS = \ String
x XIOCacheConfig
s -> XIOCacheConfig
s { xioCacheDir :: String
xioCacheDir = String
x}
                                    }

theDocumentAge                  :: Selector XIOSysState Int
theDocumentAge :: Selector XIOSysState Int
theDocumentAge                  = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig Int -> Selector XIOSysState Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> Int
getS = XIOCacheConfig -> Int
xioDocumentAge
                                    , setS :: Int -> XIOCacheConfig -> XIOCacheConfig
setS = \ Int
x XIOCacheConfig
s -> XIOCacheConfig
s { xioDocumentAge :: Int
xioDocumentAge = Int
x}
                                    }

theCache404Err                  :: Selector XIOSysState Bool
theCache404Err :: Selector XIOSysState Bool
theCache404Err                  = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> Bool
getS = XIOCacheConfig -> Bool
xioCache404Err
                                    , setS :: Bool -> XIOCacheConfig -> XIOCacheConfig
setS = \ Bool
x XIOCacheConfig
s -> XIOCacheConfig
s { xioCache404Err :: Bool
xioCache404Err = Bool
x}
                                    }

theCacheRead                    :: Selector XIOSysState (String -> IOSArrow XmlTree XmlTree)
theCacheRead :: Selector XIOSysState (String -> IOSArrow XmlTree XmlTree)
theCacheRead                    = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig (String -> IOSArrow XmlTree XmlTree)
-> Selector XIOSysState (String -> IOSArrow XmlTree XmlTree)
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree
getS = XIOCacheConfig -> String -> IOSArrow XmlTree XmlTree
xioCacheRead
                                    , setS :: (String -> IOSArrow XmlTree XmlTree)
-> XIOCacheConfig -> XIOCacheConfig
setS = \ String -> IOSArrow XmlTree XmlTree
x XIOCacheConfig
s -> XIOCacheConfig
s { xioCacheRead :: String -> IOSArrow XmlTree XmlTree
xioCacheRead = String -> IOSArrow XmlTree XmlTree
x}
                                    }

theStrictDeserialize            :: Selector XIOSysState Bool
theStrictDeserialize :: Selector XIOSysState Bool
theStrictDeserialize            = Selector XIOSysState XIOCacheConfig
theCacheConfig
                                  Selector XIOSysState XIOCacheConfig
-> Selector XIOCacheConfig Bool -> Selector XIOSysState Bool
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  S :: forall s a. (s -> a) -> (a -> s -> s) -> Selector s a
S { getS :: XIOCacheConfig -> Bool
getS = XIOCacheConfig -> Bool
xioStrictDeserialize
                                    , setS :: Bool -> XIOCacheConfig -> XIOCacheConfig
setS = \ Bool
x XIOCacheConfig
s -> XIOCacheConfig
s { xioStrictDeserialize :: Bool
xioStrictDeserialize = Bool
x}
                                    }

-- ------------------------------------------------------------

getSysVar                       :: Selector XIOSysState c -> IOStateArrow s b c
getSysVar :: Selector XIOSysState c -> IOStateArrow s b c
getSysVar Selector XIOSysState c
sel                   = (XIOState s -> b -> IO (XIOState s, [c])) -> IOStateArrow s b c
forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
IOSLA ((XIOState s -> b -> IO (XIOState s, [c])) -> IOStateArrow s b c)
-> (XIOState s -> b -> IO (XIOState s, [c])) -> IOStateArrow s b c
forall a b. (a -> b) -> a -> b
$ \ XIOState s
s b
_x ->
                                  (XIOState s, [c]) -> IO (XIOState s, [c])
forall (m :: * -> *) a. Monad m => a -> m a
return (XIOState s
s, (c -> [c] -> [c]
forall a. a -> [a] -> [a]
:[]) (c -> [c]) -> (XIOState s -> c) -> XIOState s -> [c]
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Selector (XIOState s) c -> XIOState s -> c
forall s a. Selector s a -> s -> a
getS (Selector (XIOState s) XIOSysState
forall us. Selector (XIOState us) XIOSysState
theSysState Selector (XIOState s) XIOSysState
-> Selector XIOSysState c -> Selector (XIOState s) c
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Selector XIOSysState c
sel) (XIOState s -> [c]) -> XIOState s -> [c]
forall a b. (a -> b) -> a -> b
$ XIOState s
s)

setSysVar                       :: Selector XIOSysState c -> IOStateArrow s c c
setSysVar :: Selector XIOSysState c -> IOStateArrow s c c
setSysVar Selector XIOSysState c
sel                   = (\ c
v -> (XIOSysState -> XIOSysState) -> IOStateArrow s c c
forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s c c)
-> (XIOSysState -> XIOSysState) -> IOStateArrow s c c
forall a b. (a -> b) -> a -> b
$ Selector XIOSysState c -> c -> XIOSysState -> XIOSysState
forall s a. Selector s a -> a -> s -> s
setS Selector XIOSysState c
sel c
v) (c -> IOStateArrow s c c)
-> IOStateArrow s c c -> IOStateArrow s c c
forall (a :: * -> * -> *) c b d.
ArrowList a =>
(c -> a b d) -> a b c -> a b d
$< IOStateArrow s c c
forall (a :: * -> * -> *) b. ArrowList a => a b b
this

chgSysVar                       :: Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b
chgSysVar :: Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b
chgSysVar Selector XIOSysState c
sel b -> c -> c
op                = (\ b
v -> (XIOSysState -> XIOSysState) -> IOStateArrow s b b
forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s b b)
-> (XIOSysState -> XIOSysState) -> IOStateArrow s b b
forall a b. (a -> b) -> a -> b
$ Selector XIOSysState c -> (c -> c) -> XIOSysState -> XIOSysState
forall s a. Selector s a -> (a -> a) -> s -> s
chgS Selector XIOSysState c
sel (b -> c -> c
op b
v)) (b -> IOStateArrow s b b)
-> IOStateArrow s b b -> IOStateArrow s b b
forall (a :: * -> * -> *) c b d.
ArrowList a =>
(c -> a b d) -> a b c -> a b d
$< IOStateArrow s b b
forall (a :: * -> * -> *) b. ArrowList a => a b b
this

configSysVar                    :: SysConfig -> IOStateArrow s c c
configSysVar :: (XIOSysState -> XIOSysState) -> IOStateArrow s c c
configSysVar XIOSysState -> XIOSysState
cf                 = (XIOState s -> c -> IO (XIOState s, [c])) -> IOStateArrow s c c
forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
IOSLA ((XIOState s -> c -> IO (XIOState s, [c])) -> IOStateArrow s c c)
-> (XIOState s -> c -> IO (XIOState s, [c])) -> IOStateArrow s c c
forall a b. (a -> b) -> a -> b
$ \ XIOState s
s c
v ->
                                  (XIOState s, [c]) -> IO (XIOState s, [c])
forall (m :: * -> *) a. Monad m => a -> m a
return (Selector (XIOState s) XIOSysState
-> (XIOSysState -> XIOSysState) -> XIOState s -> XIOState s
forall s a. Selector s a -> (a -> a) -> s -> s
chgS Selector (XIOState s) XIOSysState
forall us. Selector (XIOState us) XIOSysState
theSysState XIOSysState -> XIOSysState
cf XIOState s
s, [c
v])

configSysVars                   :: SysConfigList -> IOStateArrow s c c
configSysVars :: SysConfigList -> IOStateArrow s c c
configSysVars SysConfigList
cfs               = (XIOSysState -> XIOSysState) -> IOStateArrow s c c
forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s c c)
-> (XIOSysState -> XIOSysState) -> IOStateArrow s c c
forall a b. (a -> b) -> a -> b
$ ((XIOSysState -> XIOSysState)
 -> (XIOSysState -> XIOSysState) -> XIOSysState -> XIOSysState)
-> (XIOSysState -> XIOSysState)
-> SysConfigList
-> XIOSysState
-> XIOSysState
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr (XIOSysState -> XIOSysState)
-> (XIOSysState -> XIOSysState) -> XIOSysState -> XIOSysState
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
(>>>) XIOSysState -> XIOSysState
forall a. a -> a
id (SysConfigList -> XIOSysState -> XIOSysState)
-> SysConfigList -> XIOSysState -> XIOSysState
forall a b. (a -> b) -> a -> b
$ SysConfigList
cfs

localSysVar                     :: Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b
localSysVar :: Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b
localSysVar Selector XIOSysState c
sel IOStateArrow s a b
f               = (XIOState s -> a -> IO (XIOState s, [b])) -> IOStateArrow s a b
forall s a b. (s -> a -> IO (s, [b])) -> IOSLA s a b
IOSLA ((XIOState s -> a -> IO (XIOState s, [b])) -> IOStateArrow s a b)
-> (XIOState s -> a -> IO (XIOState s, [b])) -> IOStateArrow s a b
forall a b. (a -> b) -> a -> b
$ \ XIOState s
s0 a
v ->
                                  let sel' :: Selector (XIOState us) c
sel' = Selector (XIOState us) XIOSysState
forall us. Selector (XIOState us) XIOSysState
theSysState Selector (XIOState us) XIOSysState
-> Selector XIOSysState c -> Selector (XIOState us) c
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>> Selector XIOSysState c
sel in
                                  let c0 :: c
c0   = Selector (XIOState s) c -> XIOState s -> c
forall s a. Selector s a -> s -> a
getS Selector (XIOState s) c
forall us. Selector (XIOState us) c
sel' XIOState s
s0 in
                                  do
                                  (XIOState s
s1, [b]
res) <- IOStateArrow s a b -> XIOState s -> a -> IO (XIOState s, [b])
forall s a b. IOSLA s a b -> s -> a -> IO (s, [b])
runIOSLA IOStateArrow s a b
f XIOState s
s0 a
v
                                  (XIOState s, [b]) -> IO (XIOState s, [b])
forall (m :: * -> *) a. Monad m => a -> m a
return (Selector (XIOState s) c -> c -> XIOState s -> XIOState s
forall s a. Selector s a -> a -> s -> s
setS Selector (XIOState s) c
forall us. Selector (XIOState us) c
sel' c
c0 XIOState s
s1, [b]
res)

localSysEnv                     :: IOStateArrow s a b -> IOStateArrow s a b
localSysEnv :: IOStateArrow s a b -> IOStateArrow s a b
localSysEnv                     = Selector XIOSysState XIOSysEnv
-> IOStateArrow s a b -> IOStateArrow s a b
forall c s a b.
Selector XIOSysState c -> IOStateArrow s a b -> IOStateArrow s a b
localSysVar Selector XIOSysState XIOSysEnv
theSysEnv

incrSysVar                      :: Selector XIOSysState Int -> IOStateArrow s a Int
incrSysVar :: Selector XIOSysState Int -> IOStateArrow s a Int
incrSysVar Selector XIOSysState Int
cnt                  = Selector XIOSysState Int -> IOStateArrow s a Int
forall c s b. Selector XIOSysState c -> IOStateArrow s b c
getSysVar Selector XIOSysState Int
cnt
                                  IOStateArrow s a Int
-> IOSLA (XIOState s) Int Int -> IOStateArrow s a Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  (Int -> Int) -> IOSLA (XIOState s) Int Int
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (Int -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                                  IOSLA (XIOState s) Int Int
-> IOSLA (XIOState s) Int Int -> IOSLA (XIOState s) Int Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  Selector XIOSysState Int -> IOSLA (XIOState s) Int Int
forall c s. Selector XIOSysState c -> IOStateArrow s c c
setSysVar Selector XIOSysState Int
cnt
                                  IOSLA (XIOState s) Int Int
-> IOSLA (XIOState s) Int Int -> IOSLA (XIOState s) Int Int
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                  (Int -> Int) -> IOSLA (XIOState s) Int Int
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (\ Int
x -> Int
x Int -> Int -> Int
forall a. Num a => a -> a -> a
- Int
1)

-- ------------------------------

-- | store a string in global state under a given attribute name

setSysAttr              :: String -> IOStateArrow s String String
setSysAttr :: String -> IOStateArrow s String String
setSysAttr String
n            = Selector XIOSysState Attributes
-> (String -> Attributes -> Attributes)
-> IOStateArrow s String String
forall c b s.
Selector XIOSysState c -> (b -> c -> c) -> IOStateArrow s b b
chgSysVar Selector XIOSysState Attributes
theAttrList (String -> String -> Attributes -> Attributes
forall k v. Eq k => k -> v -> AssocList k v -> AssocList k v
addEntry String
n)

-- | remove an entry in global state, arrow input remains unchanged

unsetSysAttr            :: String -> IOStateArrow s b b
unsetSysAttr :: String -> IOStateArrow s b b
unsetSysAttr String
n            = (XIOSysState -> XIOSysState) -> IOStateArrow s b b
forall s c. (XIOSysState -> XIOSysState) -> IOStateArrow s c c
configSysVar ((XIOSysState -> XIOSysState) -> IOStateArrow s b b)
-> (XIOSysState -> XIOSysState) -> IOStateArrow s b b
forall a b. (a -> b) -> a -> b
$ Selector XIOSysState Attributes
-> (Attributes -> Attributes) -> XIOSysState -> XIOSysState
forall s a. Selector s a -> (a -> a) -> s -> s
chgS Selector XIOSysState Attributes
theAttrList (String -> Attributes -> Attributes
forall k v. Eq k => k -> AssocList k v -> AssocList k v
delEntry String
n)

-- | read an attribute value from global state

getSysAttr                :: String -> IOStateArrow s b String
getSysAttr :: String -> IOStateArrow s b String
getSysAttr String
n              = Selector XIOSysState Attributes -> IOStateArrow s b Attributes
forall c s b. Selector XIOSysState c -> IOStateArrow s b c
getSysVar Selector XIOSysState Attributes
theAttrList
                          IOStateArrow s b Attributes
-> (Attributes -> String) -> IOStateArrow s b String
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> (c -> d) -> a b d
>>^
                          String -> Attributes -> String
forall k e. Eq k => k -> AssocList k [e] -> [e]
lookup1 String
n

-- | read all attributes from global state

getAllSysAttrs            :: IOStateArrow s b Attributes
getAllSysAttrs :: IOStateArrow s b Attributes
getAllSysAttrs            = Selector XIOSysState Attributes -> IOStateArrow s b Attributes
forall c s b. Selector XIOSysState c -> IOStateArrow s b c
getSysVar Selector XIOSysState Attributes
theAttrList


setSysAttrString        :: String -> String -> IOStateArrow s b b
setSysAttrString :: String -> String -> IOStateArrow s b b
setSysAttrString String
n String
v    = IOSLA (XIOState s) b String -> IOStateArrow s b b
forall (a :: * -> * -> *) b c. ArrowList a => a b c -> a b b
perform ( String -> IOSLA (XIOState s) b String
forall (a :: * -> * -> *) c b. ArrowList a => c -> a b c
constA String
v
                                    IOSLA (XIOState s) b String
-> IOSLA (XIOState s) String String -> IOSLA (XIOState s) b String
forall k (cat :: k -> k -> *) (a :: k) (b :: k) (c :: k).
Category cat =>
cat a b -> cat b c -> cat a c
>>>
                                    String -> IOSLA (XIOState s) String String
forall s. String -> IOStateArrow s String String
setSysAttr String
n
                                  )

-- | store an int value in global state

setSysAttrInt           :: String -> Int -> IOStateArrow s b b
setSysAttrInt :: String -> Int -> IOStateArrow s b b
setSysAttrInt String
n Int
v       = String -> String -> IOStateArrow s b b
forall s b. String -> String -> IOStateArrow s b b
setSysAttrString String
n (Int -> String
forall a. Show a => a -> String
show Int
v)

-- | read an int value from global state
--
-- > getSysAttrInt 0 myIntAttr

getSysAttrInt           :: Int -> String -> IOStateArrow s b Int
getSysAttrInt :: Int -> String -> IOStateArrow s b Int
getSysAttrInt Int
def String
n     = String -> IOStateArrow s b String
forall s b. String -> IOStateArrow s b String
getSysAttr String
n
                          IOStateArrow s b String -> (String -> Int) -> IOStateArrow s b Int
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> (c -> d) -> a b d
>>^
                          Int -> String -> Int
toInt Int
def

toInt                   :: Int -> String -> Int
toInt :: Int -> String -> Int
toInt Int
def String
s
    | Bool -> Bool
not (String -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
s)
      Bool -> Bool -> Bool
&&
      (Char -> Bool) -> String -> Bool
forall (t :: * -> *) a. Foldable t => (a -> Bool) -> t a -> Bool
all Char -> Bool
isDigit String
s     = String -> Int
forall a. Read a => String -> a
read String
s
    | Bool
otherwise         = Int
def

-- ------------------------------------------------------------