{- |
This name type preserves the characters case of its input
and divides the names into namespace and local identifier.
-}
module Text.XML.Basic.Name.Qualified where

import qualified Text.XML.Basic.Name as Name
import qualified Data.Accessor.Basic as Accessor


data T = Cons {T -> String
namespace_, T -> String
local_ :: String}
   deriving (Int -> T -> ShowS
[T] -> ShowS
T -> String
(Int -> T -> ShowS) -> (T -> String) -> ([T] -> ShowS) -> Show T
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> T -> ShowS
showsPrec :: Int -> T -> ShowS
$cshow :: T -> String
show :: T -> String
$cshowList :: [T] -> ShowS
showList :: [T] -> ShowS
Show, T -> T -> Bool
(T -> T -> Bool) -> (T -> T -> Bool) -> Eq T
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: T -> T -> Bool
== :: T -> T -> Bool
$c/= :: T -> T -> Bool
/= :: T -> T -> Bool
Eq, Eq T
Eq T =>
(T -> T -> Ordering)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> Bool)
-> (T -> T -> T)
-> (T -> T -> T)
-> Ord T
T -> T -> Bool
T -> T -> Ordering
T -> T -> T
forall a.
Eq a =>
(a -> a -> Ordering)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> Bool)
-> (a -> a -> a)
-> (a -> a -> a)
-> Ord a
$ccompare :: T -> T -> Ordering
compare :: T -> T -> Ordering
$c< :: T -> T -> Bool
< :: T -> T -> Bool
$c<= :: T -> T -> Bool
<= :: T -> T -> Bool
$c> :: T -> T -> Bool
> :: T -> T -> Bool
$c>= :: T -> T -> Bool
>= :: T -> T -> Bool
$cmax :: T -> T -> T
max :: T -> T -> T
$cmin :: T -> T -> T
min :: T -> T -> T
Ord)

namespace :: Accessor.T T String
namespace :: T T String
namespace = (String -> T -> T) -> (T -> String) -> T T String
forall a r. (a -> r -> r) -> (r -> a) -> T r a
Accessor.fromSetGet (\String
n T
p -> T
p{namespace_ = n}) T -> String
namespace_

local :: Accessor.T T String
local :: T T String
local = (String -> T -> T) -> (T -> String) -> T T String
forall a r. (a -> r -> r) -> (r -> a) -> T r a
Accessor.fromSetGet (\String
n T
p -> T
p{local_ = n}) T -> String
local_


fromString :: String -> T
fromString :: String -> T
fromString =
   (String -> String -> T) -> (String, String) -> T
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry String -> String -> T
Cons ((String, String) -> T)
-> (String -> (String, String)) -> String -> T
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   (\(String
n,String
pl) ->
       case String
pl of
          Char
':':String
l -> (String
n,String
l)
          String
_ -> (String
"",String
n)) ((String, String) -> (String, String))
-> (String -> (String, String)) -> String -> (String, String)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
   (Char -> Bool) -> String -> (String, String)
forall a. (a -> Bool) -> [a] -> ([a], [a])
break (Char
':'Char -> Char -> Bool
forall a. Eq a => a -> a -> Bool
==)

toString :: T -> String
toString :: T -> String
toString (Cons String
n String
l) =
   if String -> Bool
forall a. [a] -> Bool
forall (t :: * -> *) a. Foldable t => t a -> Bool
null String
n
     then String
l
     else String
n String -> ShowS
forall a. [a] -> [a] -> [a]
++ Char
':' Char -> ShowS
forall a. a -> [a] -> [a]
: String
l


instance Name.Tag T where
   tagFromString :: String -> T
tagFromString = String -> T
fromString
   tagToString :: T -> String
tagToString = T -> String
toString

instance Name.Attribute T where
   attributeFromString :: String -> T
attributeFromString = String -> T
fromString
   attributeToString :: T -> String
attributeToString = T -> String
toString