{-# LANGUAGE ExistentialQuantification #-}
module Data.Encoding.Base where
import Data.Encoding.Exception
import Data.Encoding.ByteSource
import Data.Encoding.ByteSink
import Control.Throws
import Data.Array.Unboxed as Array
import Data.Map as Map hiding ((!))
import Data.Word
import Data.Char
import Data.Typeable
class Encoding enc where
decodeChar :: ByteSource m => enc -> m Char
encodeChar :: ByteSink m => enc -> Char -> m ()
decode :: ByteSource m => enc -> m String
decode enc
e = forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
untilM forall (m :: * -> *). ByteSource m => m Bool
sourceEmpty (forall enc (m :: * -> *).
(Encoding enc, ByteSource m) =>
enc -> m Char
decodeChar enc
e)
encode :: ByteSink m => enc -> String -> m ()
encode enc
e = forall (t :: * -> *) (m :: * -> *) a b.
(Foldable t, Monad m) =>
(a -> m b) -> t a -> m ()
mapM_ (forall enc (m :: * -> *).
(Encoding enc, ByteSink m) =>
enc -> Char -> m ()
encodeChar enc
e)
encodeable :: enc -> Char -> Bool
data DynEncoding = forall enc. (Encoding enc,Eq enc,Typeable enc,Show enc) => DynEncoding enc
instance Show DynEncoding where
show :: DynEncoding -> String
show (DynEncoding enc
enc) = forall a. Show a => a -> String
show enc
enc
instance Encoding DynEncoding where
decodeChar :: forall (m :: * -> *). ByteSource m => DynEncoding -> m Char
decodeChar (DynEncoding enc
e) = forall enc (m :: * -> *).
(Encoding enc, ByteSource m) =>
enc -> m Char
decodeChar enc
e
encodeChar :: forall (m :: * -> *). ByteSink m => DynEncoding -> Char -> m ()
encodeChar (DynEncoding enc
e) = forall enc (m :: * -> *).
(Encoding enc, ByteSink m) =>
enc -> Char -> m ()
encodeChar enc
e
decode :: forall (m :: * -> *). ByteSource m => DynEncoding -> m String
decode (DynEncoding enc
e) = forall enc (m :: * -> *).
(Encoding enc, ByteSource m) =>
enc -> m String
decode enc
e
encode :: forall (m :: * -> *). ByteSink m => DynEncoding -> String -> m ()
encode (DynEncoding enc
e) = forall enc (m :: * -> *).
(Encoding enc, ByteSink m) =>
enc -> String -> m ()
encode enc
e
encodeable :: DynEncoding -> Char -> Bool
encodeable (DynEncoding enc
e) = forall enc. Encoding enc => enc -> Char -> Bool
encodeable enc
e
instance Eq DynEncoding where
(DynEncoding enc
e1) == :: DynEncoding -> DynEncoding -> Bool
== (DynEncoding enc
e2) = case forall a b. (Typeable a, Typeable b) => a -> Maybe b
cast enc
e2 of
Maybe enc
Nothing -> Bool
False
Just enc
e2' -> enc
e1forall a. Eq a => a -> a -> Bool
==enc
e2'
untilM :: Monad m => m Bool -> m a -> m [a]
untilM :: forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
untilM m Bool
check m a
act = do
Bool
end <- m Bool
check
if Bool
end
then forall (m :: * -> *) a. Monad m => a -> m a
return []
else (do
a
x <- m a
act
[a]
xs <- forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
untilM m Bool
check m a
act
forall (m :: * -> *) a. Monad m => a -> m a
return (a
xforall a. a -> [a] -> [a]
:[a]
xs)
)
untilM_ :: Monad m => m Bool -> m a -> m ()
untilM_ :: forall (m :: * -> *) a. Monad m => m Bool -> m a -> m ()
untilM_ m Bool
check m a
act = forall (m :: * -> *) a. Monad m => m Bool -> m a -> m [a]
untilM m Bool
check m a
act forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> forall (m :: * -> *) a. Monad m => a -> m a
return ()
encodeWithMap :: ByteSink m => Map Char Word8 -> Char -> m ()
encodeWithMap :: forall (m :: * -> *). ByteSink m => Map Char Word8 -> Char -> m ()
encodeWithMap Map Char Word8
mp Char
c = case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Char
c Map Char Word8
mp of
Maybe Word8
Nothing -> forall e (m :: * -> *) a. Throws e m => e -> m a
throwException forall a b. (a -> b) -> a -> b
$ Char -> EncodingException
HasNoRepresentation Char
c
Just Word8
v -> forall (m :: * -> *). ByteSink m => Word8 -> m ()
pushWord8 Word8
v
encodeWithMap2 :: ByteSink m => Map Char (Word8,Word8) -> Char -> m ()
encodeWithMap2 :: forall (m :: * -> *).
ByteSink m =>
Map Char (Word8, Word8) -> Char -> m ()
encodeWithMap2 Map Char (Word8, Word8)
mp Char
c = case forall k a. Ord k => k -> Map k a -> Maybe a
Map.lookup Char
c Map Char (Word8, Word8)
mp of
Maybe (Word8, Word8)
Nothing -> forall e (m :: * -> *) a. Throws e m => e -> m a
throwException forall a b. (a -> b) -> a -> b
$ Char -> EncodingException
HasNoRepresentation Char
c
Just (Word8
w1,Word8
w2) -> do
forall (m :: * -> *). ByteSink m => Word8 -> m ()
pushWord8 Word8
w1
forall (m :: * -> *). ByteSink m => Word8 -> m ()
pushWord8 Word8
w2
encodeableWithMap :: Map Char a -> Char -> Bool
encodeableWithMap :: forall a. Map Char a -> Char -> Bool
encodeableWithMap = forall a b c. (a -> b -> c) -> b -> a -> c
flip forall k a. Ord k => k -> Map k a -> Bool
Map.member
decodeWithArray :: ByteSource m => UArray Word8 Int -> m Char
decodeWithArray :: forall (m :: * -> *). ByteSource m => UArray Word8 Int -> m Char
decodeWithArray UArray Word8 Int
arr = do
Word8
w <- forall (m :: * -> *). ByteSource m => m Word8
fetchWord8
let res :: Int
res = UArray Word8 Int
arrforall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
!Word8
w
if Int
res forall a. Ord a => a -> a -> Bool
< Int
0
then forall e (m :: * -> *) a. Throws e m => e -> m a
throwException forall a b. (a -> b) -> a -> b
$ Word8 -> DecodingException
IllegalCharacter Word8
w
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
res
decodeWithArray2 :: ByteSource m => UArray (Word8,Word8) Int -> m Char
decodeWithArray2 :: forall (m :: * -> *).
ByteSource m =>
UArray (Word8, Word8) Int -> m Char
decodeWithArray2 UArray (Word8, Word8) Int
arr = do
Word8
w1 <- forall (m :: * -> *). ByteSource m => m Word8
fetchWord8
Word8
w2 <- forall (m :: * -> *). ByteSource m => m Word8
fetchWord8
if forall a. Ix a => (a, a) -> a -> Bool
inRange (forall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> (i, i)
bounds UArray (Word8, Word8) Int
arr) (Word8
w1,Word8
w2)
then (do
let res :: Int
res = UArray (Word8, Word8) Int
arrforall (a :: * -> * -> *) e i.
(IArray a e, Ix i) =>
a i e -> i -> e
!(Word8
w1,Word8
w2)
if Int
res forall a. Ord a => a -> a -> Bool
< Int
0
then forall e (m :: * -> *) a. Throws e m => e -> m a
throwException forall a b. (a -> b) -> a -> b
$ Word8 -> DecodingException
IllegalCharacter Word8
w1
else forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ Int -> Char
chr Int
res
)
else forall e (m :: * -> *) a. Throws e m => e -> m a
throwException forall a b. (a -> b) -> a -> b
$ Word8 -> DecodingException
IllegalCharacter Word8
w1