{-# language BangPatterns #-}
{-# language DataKinds #-}
{-# language MagicHash #-}
{-# language UnboxedTuples #-}

module Basics.ShortText
  ( -- Types
    T
  , T#
  , R
    -- Lifting
  , lift
  , unlift
    -- Array
  , read#
  , write#
  , index#
  , uninitialized#
  , initialized#
  , copy#
  , copyMutable#
  , set#
  , shrink#
  , eq#
  , neq#
    -- Encode
  , shows
  ) where

import Prelude hiding (shows)

import GHC.Exts hiding (setByteArray#)
import Data.ByteString.Short.Internal (ShortByteString(SBS))
import Data.Text.Short (ShortText)

import qualified Prelude
import qualified GHC.Exts as Exts
import qualified Data.Text.Short as TS
import qualified Data.Text.Short.Unsafe as TS

type T = ShortText
type T# = ByteArray#
type R = 'BoxedRep 'Unlifted

lift :: T# -> T
{-# inline lift #-}
lift :: T# -> T
lift T#
x = ShortByteString -> T
TS.fromShortByteStringUnsafe (T# -> ShortByteString
SBS T#
x)

unlift :: T -> T#
{-# inline unlift #-}
unlift :: T -> T#
unlift T
t = case T -> ShortByteString
TS.toShortByteString T
t of { SBS T#
x -> T#
x }

index# :: ArrayArray# -> Int# -> T#
{-# inline index# #-}
index# :: ArrayArray# -> Int# -> T#
index# = ArrayArray# -> Int# -> T#
Exts.indexByteArrayArray#

read# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s, T# #)
{-# inline read# #-}
read# :: forall s.
MutableArrayArray# s -> Int# -> State# s -> (# State# s, T# #)
read# = forall s.
MutableArrayArray# s -> Int# -> State# s -> (# State# s, T# #)
Exts.readByteArrayArray#

write# :: MutableArrayArray# s -> Int# -> T# -> State# s -> State# s
{-# inline write# #-}
write# :: forall s.
MutableArrayArray# s -> Int# -> T# -> State# s -> State# s
write# = forall s.
MutableArrayArray# s -> Int# -> T# -> State# s -> State# s
Exts.writeByteArrayArray#

set# :: MutableArrayArray# s -> Int# -> Int# -> T# -> State# s -> State# s
{-# inline set# #-}
set# :: forall s.
MutableArrayArray# s -> Int# -> Int# -> T# -> State# s -> State# s
set# MutableArrayArray# s
marr Int#
off Int#
len T#
x State# s
s = case Int#
len of
  Int#
0# -> State# s
s
  Int#
_ -> forall s.
MutableArrayArray# s -> Int# -> Int# -> T# -> State# s -> State# s
set# MutableArrayArray# s
marr (Int#
off Int# -> Int# -> Int#
+# Int#
1# ) (Int#
len Int# -> Int# -> Int#
-# Int#
1# ) T#
x (forall s.
MutableArrayArray# s -> Int# -> T# -> State# s -> State# s
write# MutableArrayArray# s
marr Int#
off T#
x State# s
s)

-- | This is very unsafe.
uninitialized# :: Int# -> State# s -> (# State# s, MutableArrayArray# s #)
{-# inline uninitialized# #-}
uninitialized# :: forall s. Int# -> State# s -> (# State# s, MutableArrayArray# s #)
uninitialized# = forall s. Int# -> State# s -> (# State# s, MutableArrayArray# s #)
Exts.newArrayArray#

initialized# ::
     Int# -> T# -> State# s
  -> (# State# s, MutableArrayArray# s #)
{-# inline initialized# #-}
initialized# :: forall s.
Int# -> T# -> State# s -> (# State# s, MutableArrayArray# s #)
initialized# Int#
n T#
e State# s
s0 = case forall s. Int# -> State# s -> (# State# s, MutableArrayArray# s #)
uninitialized# Int#
n State# s
s0 of
  (# State# s
s1, MutableArrayArray# s
a #) -> case forall s.
MutableArrayArray# s -> Int# -> Int# -> T# -> State# s -> State# s
set# MutableArrayArray# s
a Int#
0# Int#
n T#
e State# s
s1 of
    State# s
s2 -> (# State# s
s2, MutableArrayArray# s
a #)

copy# :: MutableArrayArray# s -> Int# -> ArrayArray# -> Int# -> Int# -> State# s -> State# s
{-# inline copy# #-}
copy# :: forall s.
MutableArrayArray# s
-> Int# -> ArrayArray# -> Int# -> Int# -> State# s -> State# s
copy# MutableArrayArray# s
dst Int#
doff ArrayArray#
src Int#
soff Int#
len =
  forall d.
ArrayArray#
-> Int#
-> MutableArrayArray# d
-> Int#
-> Int#
-> State# d
-> State# d
Exts.copyArrayArray# ArrayArray#
src Int#
soff MutableArrayArray# s
dst Int#
doff Int#
len

copyMutable# :: MutableArrayArray# s -> Int# -> MutableArrayArray# s -> Int# -> Int# -> State# s -> State# s
{-# inline copyMutable# #-}
copyMutable# :: forall s.
MutableArrayArray# s
-> Int#
-> MutableArrayArray# s
-> Int#
-> Int#
-> State# s
-> State# s
copyMutable# MutableArrayArray# s
dst Int#
doff MutableArrayArray# s
src Int#
soff Int#
len =
  forall s.
MutableArrayArray# s
-> Int#
-> MutableArrayArray# s
-> Int#
-> Int#
-> State# s
-> State# s
Exts.copyMutableArrayArray# MutableArrayArray# s
src Int#
soff MutableArrayArray# s
dst Int#
doff Int#
len

shrink# :: MutableArrayArray# s -> Int# -> State# s -> (# State# s, MutableArrayArray# s #)
{-# inline shrink# #-}
shrink# :: forall s.
MutableArrayArray# s
-> Int# -> State# s -> (# State# s, MutableArrayArray# s #)
shrink# MutableArrayArray# s
m Int#
sz State# s
s0 = case forall s. Int# -> State# s -> (# State# s, MutableArrayArray# s #)
uninitialized# Int#
sz State# s
s0 of
  (# State# s
s1, MutableArrayArray# s
dst #) -> case forall s.
MutableArrayArray# s
-> Int#
-> MutableArrayArray# s
-> Int#
-> Int#
-> State# s
-> State# s
copyMutable# MutableArrayArray# s
dst Int#
0# MutableArrayArray# s
m Int#
0# Int#
sz State# s
s1 of
    State# s
s2 -> (# State# s
s2, MutableArrayArray# s
dst #)

eq# :: ByteArray# -> ByteArray# -> Int#
{-# inline eq# #-}
eq# :: T# -> T# -> Int#
eq# T#
a T#
b = case Int#
lenA Int# -> Int# -> Int#
==# Int#
lenB of
  Int#
1# -> T# -> Int# -> T# -> Int# -> Int# -> Int#
Exts.compareByteArrays# T#
a Int#
0# T#
b Int#
0# Int#
lenA Int# -> Int# -> Int#
==# Int#
0#
  Int#
_ -> Int#
0#
  where
  !lenA :: Int#
lenA = T# -> Int#
Exts.sizeofByteArray# T#
a
  !lenB :: Int#
lenB = T# -> Int#
Exts.sizeofByteArray# T#
b

neq# :: ByteArray# -> ByteArray# -> Int#
{-# inline neq# #-}
neq# :: T# -> T# -> Int#
neq# T#
a T#
b = case Int#
lenA Int# -> Int# -> Int#
==# Int#
lenB of
  Int#
1# -> T# -> Int# -> T# -> Int# -> Int# -> Int#
Exts.compareByteArrays# T#
a Int#
0# T#
b Int#
0# Int#
lenA Int# -> Int# -> Int#
/=# Int#
0#
  Int#
_ -> Int#
1#
  where
  !lenA :: Int#
lenA = T# -> Int#
Exts.sizeofByteArray# T#
a
  !lenB :: Int#
lenB = T# -> Int#
Exts.sizeofByteArray# T#
b

shows :: T -> String -> String
shows :: T -> String -> String
shows = forall a. Show a => a -> String -> String
Prelude.shows