module Data.Settings.Section
(
empty
, singleton
, hasOpts
, hasSubs
, null
, member
, memberOpt
, memberSub
, lookup
, lookupOpt
, lookupSub
, insert
, deleteOpt
, deleteSub
, delete
)
where
import Data.Either (isRight)
import qualified Data.HashMap.Lazy as M
import Data.Settings.Types
import Prelude hiding (lookup, null)
empty :: Section m
empty = Section M.empty M.empty
singleton :: SecName -> Option m -> Section m
singleton name opt = Section (M.singleton name opt) M.empty
hasOpts :: Section m -> Bool
hasOpts = not . M.null . secOpts
hasSubs :: Section m -> Bool
hasSubs = not . M.null . secSubs
null :: Section m -> Bool
null s = not $ hasOpts s || hasSubs s
member :: OptRoute -> Section m -> (Bool, Bool)
member route sec =
case lookup route sec of
Nothing -> (False, False)
Just e -> (True, isRight e)
memberOpt :: OptRoute -> Section m -> Bool
memberOpt route sec =
let (m, o) = member route sec
in m && o
memberSub :: OptRoute -> Section m -> Bool
memberSub route sec =
let (m, o) = member route sec
in m && not o
lookup :: OptRoute -> Section m -> Maybe (Either (Section m) (Option m))
lookup [] sec = Just $ Left sec
lookup [name] sec =
case (M.lookup name $ secOpts sec, M.lookup name $ secSubs sec) of
(Just o, _) -> Just $ Right o
(Nothing, Just s) -> Just $ Left s
(Nothing, Nothing) -> Nothing
lookup (n:ns) sec =
case M.lookup n $ secSubs sec of
Just s -> lookup ns s
Nothing -> Nothing
lookupOpt :: [String] -> Section m -> Maybe (Option m)
lookupOpt path sec =
case lookup path sec of
Just (Right o) -> Just o
_ -> Nothing
lookupSub :: [String] -> Section m -> Maybe (Section m)
lookupSub path sec =
case lookup path sec of
Just (Left s) -> Just s
_ -> Nothing
insert :: [String] -> Option m -> Section m -> Section m
insert path opt s@(Section opts subs) =
case path of
[] -> s
[name] -> Section (M.insert name opt opts) subs
(n:ns) ->
let sub = M.lookupDefault empty n subs
sub' = insert ns opt sub
subs' = M.insert n sub' subs
in Section opts subs'
deleteImpl :: Bool -> Bool -> [String] -> Section m -> Section m
deleteImpl delO delS path sec = d path sec
where
d path sec@(Section opts subs) =
case path of
[] -> sec
[name] -> Section
(if delO then M.delete name opts else opts)
(if delS then M.delete name subs else subs)
(n:ns) -> Section opts $ M.adjust (d ns) n subs
deleteOpt :: [String] -> Section m -> Section m
deleteOpt = deleteImpl True False
deleteSub :: [String] -> Section m -> Section m
deleteSub = deleteImpl False True
delete :: [String] -> Section m -> Section m
delete = deleteImpl True True