-- |
-- Module: M.NBT.Internal.Types
-- Description: Core NBT type definitions
-- Copyright: (c) axionbuster, 2025
-- License: BSD-3-Clause
--
-- Internal type definitions for Named Binary Tag (NBT) format used in
-- Minecraft, including tag types and container types.
module M.NBT.Internal.Types (Ty (..), Tg (..), getty) where

import Control.DeepSeq
import Data.ByteString (ByteString)
import Data.Data
import Data.HashMap.Strict (HashMap)
import Data.Hashable
import Data.Int
import Data.String (IsString (..))
import Data.Text (Text)
import Data.Text qualified as T
import Data.Vector qualified as V
import Data.Vector.Unboxed qualified as VU
import Data.Word
import GHC.Generics
import Language.Haskell.TH.Syntax (Lift)
import M.Pack

-- | NBT tag types
data Ty
  = -- | special type for the end of a compound tag
    TEnd
  | TByte
  | TShort
  | TInt
  | TLong
  | TFloat
  | TDouble
  | TByteArray
  | TString
  | TList
  | TCompound
  | TIntArray
  | TLongArray
  deriving stock (Ty -> Ty -> Bool
(Ty -> Ty -> Bool) -> (Ty -> Ty -> Bool) -> Eq Ty
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Ty -> Ty -> Bool
== :: Ty -> Ty -> Bool
$c/= :: Ty -> Ty -> Bool
/= :: Ty -> Ty -> Bool
Eq, Eq Ty
Eq Ty =>
(Ty -> Ty -> Ordering)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Bool)
-> (Ty -> Ty -> Ty)
-> (Ty -> Ty -> Ty)
-> Ord Ty
Ty -> Ty -> Bool
Ty -> Ty -> Ordering
Ty -> Ty -> Ty
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 :: Ty -> Ty -> Ordering
compare :: Ty -> Ty -> Ordering
$c< :: Ty -> Ty -> Bool
< :: Ty -> Ty -> Bool
$c<= :: Ty -> Ty -> Bool
<= :: Ty -> Ty -> Bool
$c> :: Ty -> Ty -> Bool
> :: Ty -> Ty -> Bool
$c>= :: Ty -> Ty -> Bool
>= :: Ty -> Ty -> Bool
$cmax :: Ty -> Ty -> Ty
max :: Ty -> Ty -> Ty
$cmin :: Ty -> Ty -> Ty
min :: Ty -> Ty -> Ty
Ord, Int -> Ty -> ShowS
[Ty] -> ShowS
Ty -> String
(Int -> Ty -> ShowS)
-> (Ty -> String) -> ([Ty] -> ShowS) -> Show Ty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Ty -> ShowS
showsPrec :: Int -> Ty -> ShowS
$cshow :: Ty -> String
show :: Ty -> String
$cshowList :: [Ty] -> ShowS
showList :: [Ty] -> ShowS
Show, ReadPrec [Ty]
ReadPrec Ty
Int -> ReadS Ty
ReadS [Ty]
(Int -> ReadS Ty)
-> ReadS [Ty] -> ReadPrec Ty -> ReadPrec [Ty] -> Read Ty
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Ty
readsPrec :: Int -> ReadS Ty
$creadList :: ReadS [Ty]
readList :: ReadS [Ty]
$creadPrec :: ReadPrec Ty
readPrec :: ReadPrec Ty
$creadListPrec :: ReadPrec [Ty]
readListPrec :: ReadPrec [Ty]
Read, (forall x. Ty -> Rep Ty x)
-> (forall x. Rep Ty x -> Ty) -> Generic Ty
forall x. Rep Ty x -> Ty
forall x. Ty -> Rep Ty x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Ty -> Rep Ty x
from :: forall x. Ty -> Rep Ty x
$cto :: forall x. Rep Ty x -> Ty
to :: forall x. Rep Ty x -> Ty
Generic, Typeable, Typeable Ty
Typeable Ty =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Ty -> c Ty)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Ty)
-> (Ty -> Constr)
-> (Ty -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Ty))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty))
-> ((forall b. Data b => b -> b) -> Ty -> Ty)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r)
-> (forall u. (forall d. Data d => d -> u) -> Ty -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Ty -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Ty -> m Ty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ty -> m Ty)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Ty -> m Ty)
-> Data Ty
Ty -> Constr
Ty -> DataType
(forall b. Data b => b -> b) -> Ty -> Ty
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Ty -> u
forall u. (forall d. Data d => d -> u) -> Ty -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ty
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty -> c Ty
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ty)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty -> c Ty
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Ty -> c Ty
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ty
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Ty
$ctoConstr :: Ty -> Constr
toConstr :: Ty -> Constr
$cdataTypeOf :: Ty -> DataType
dataTypeOf :: Ty -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ty)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Ty)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Ty)
$cgmapT :: (forall b. Data b => b -> b) -> Ty -> Ty
gmapT :: (forall b. Data b => b -> b) -> Ty -> Ty
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Ty -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Ty -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Ty -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ty -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Ty -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Ty -> m Ty
Data, (forall (m :: * -> *). Quote m => Ty -> m Exp)
-> (forall (m :: * -> *). Quote m => Ty -> Code m Ty) -> Lift Ty
forall t.
(forall (m :: * -> *). Quote m => t -> m Exp)
-> (forall (m :: * -> *). Quote m => t -> Code m t) -> Lift t
forall (m :: * -> *). Quote m => Ty -> m Exp
forall (m :: * -> *). Quote m => Ty -> Code m Ty
$clift :: forall (m :: * -> *). Quote m => Ty -> m Exp
lift :: forall (m :: * -> *). Quote m => Ty -> m Exp
$cliftTyped :: forall (m :: * -> *). Quote m => Ty -> Code m Ty
liftTyped :: forall (m :: * -> *). Quote m => Ty -> Code m Ty
Lift)
  deriving stock (Int -> Ty
Ty -> Int
Ty -> [Ty]
Ty -> Ty
Ty -> Ty -> [Ty]
Ty -> Ty -> Ty -> [Ty]
(Ty -> Ty)
-> (Ty -> Ty)
-> (Int -> Ty)
-> (Ty -> Int)
-> (Ty -> [Ty])
-> (Ty -> Ty -> [Ty])
-> (Ty -> Ty -> [Ty])
-> (Ty -> Ty -> Ty -> [Ty])
-> Enum Ty
forall a.
(a -> a)
-> (a -> a)
-> (Int -> a)
-> (a -> Int)
-> (a -> [a])
-> (a -> a -> [a])
-> (a -> a -> [a])
-> (a -> a -> a -> [a])
-> Enum a
$csucc :: Ty -> Ty
succ :: Ty -> Ty
$cpred :: Ty -> Ty
pred :: Ty -> Ty
$ctoEnum :: Int -> Ty
toEnum :: Int -> Ty
$cfromEnum :: Ty -> Int
fromEnum :: Ty -> Int
$cenumFrom :: Ty -> [Ty]
enumFrom :: Ty -> [Ty]
$cenumFromThen :: Ty -> Ty -> [Ty]
enumFromThen :: Ty -> Ty -> [Ty]
$cenumFromTo :: Ty -> Ty -> [Ty]
enumFromTo :: Ty -> Ty -> [Ty]
$cenumFromThenTo :: Ty -> Ty -> Ty -> [Ty]
enumFromThenTo :: Ty -> Ty -> Ty -> [Ty]
Enum, Ty
Ty -> Ty -> Bounded Ty
forall a. a -> a -> Bounded a
$cminBound :: Ty
minBound :: Ty
$cmaxBound :: Ty
maxBound :: Ty
Bounded)
  deriving anyclass (Eq Ty
Eq Ty => (Int -> Ty -> Int) -> (Ty -> Int) -> Hashable Ty
Int -> Ty -> Int
Ty -> Int
forall a. Eq a => (Int -> a -> Int) -> (a -> Int) -> Hashable a
$chashWithSalt :: Int -> Ty -> Int
hashWithSalt :: Int -> Ty -> Int
$chash :: Ty -> Int
hash :: Ty -> Int
Hashable, Ty -> ()
(Ty -> ()) -> NFData Ty
forall a. (a -> ()) -> NFData a
$crnf :: Ty -> ()
rnf :: Ty -> ()
NFData)

-- tag type serialization / deserialization is defined here

instance Pack Ty where
  pack :: Ty -> Builder
pack = forall a. Pack a => a -> Builder
pack @Word8 (Word8 -> Builder) -> (Ty -> Word8) -> Ty -> Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Int -> Word8
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> Word8) -> (Ty -> Int) -> Ty -> Word8
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Ty -> Int
forall a. Enum a => a -> Int
fromEnum
  {-# INLINE pack #-}

instance Unpack Ty where
  unpack :: forall (st :: ZeroBitType) r. Parser st r Ty
unpack = EnumIndex Word8 Ty -> Ty
forall {k} (i :: k) a. EnumIndex i a -> a
enumindex (EnumIndex Word8 Ty -> Ty)
-> ParserT st r ParseError (EnumIndex Word8 Ty)
-> ParserT st r ParseError Ty
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a (st :: ZeroBitType) r. Unpack a => Parser st r a
unpack @(EnumIndex Word8 Ty)
  {-# INLINE unpack #-}

-- | NBT tag
data Tg where
  -- | used for internal purposes only
  End :: Tg
  Byte :: Int8 %1 -> Tg
  Short :: Int16 %1 -> Tg
  Int :: Int32 %1 -> Tg
  Long :: Int64 %1 -> Tg
  Float :: Float %1 -> Tg
  Double :: Double %1 -> Tg
  ByteArray :: ByteString %1 -> Tg
  String :: Text %1 -> Tg
  -- | a homogeneous list of tags
  List :: Ty %1 -> (V.Vector Tg) %1 -> Tg
  Compound :: HashMap Text Tg %1 -> Tg
  IntArray :: (VU.Vector Int32) %1 -> Tg
  LongArray :: (VU.Vector Int64) %1 -> Tg
  deriving stock (Tg -> Tg -> Bool
(Tg -> Tg -> Bool) -> (Tg -> Tg -> Bool) -> Eq Tg
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Tg -> Tg -> Bool
== :: Tg -> Tg -> Bool
$c/= :: Tg -> Tg -> Bool
/= :: Tg -> Tg -> Bool
Eq, Eq Tg
Eq Tg =>
(Tg -> Tg -> Ordering)
-> (Tg -> Tg -> Bool)
-> (Tg -> Tg -> Bool)
-> (Tg -> Tg -> Bool)
-> (Tg -> Tg -> Bool)
-> (Tg -> Tg -> Tg)
-> (Tg -> Tg -> Tg)
-> Ord Tg
Tg -> Tg -> Bool
Tg -> Tg -> Ordering
Tg -> Tg -> Tg
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 :: Tg -> Tg -> Ordering
compare :: Tg -> Tg -> Ordering
$c< :: Tg -> Tg -> Bool
< :: Tg -> Tg -> Bool
$c<= :: Tg -> Tg -> Bool
<= :: Tg -> Tg -> Bool
$c> :: Tg -> Tg -> Bool
> :: Tg -> Tg -> Bool
$c>= :: Tg -> Tg -> Bool
>= :: Tg -> Tg -> Bool
$cmax :: Tg -> Tg -> Tg
max :: Tg -> Tg -> Tg
$cmin :: Tg -> Tg -> Tg
min :: Tg -> Tg -> Tg
Ord, Int -> Tg -> ShowS
[Tg] -> ShowS
Tg -> String
(Int -> Tg -> ShowS)
-> (Tg -> String) -> ([Tg] -> ShowS) -> Show Tg
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
$cshowsPrec :: Int -> Tg -> ShowS
showsPrec :: Int -> Tg -> ShowS
$cshow :: Tg -> String
show :: Tg -> String
$cshowList :: [Tg] -> ShowS
showList :: [Tg] -> ShowS
Show, ReadPrec [Tg]
ReadPrec Tg
Int -> ReadS Tg
ReadS [Tg]
(Int -> ReadS Tg)
-> ReadS [Tg] -> ReadPrec Tg -> ReadPrec [Tg] -> Read Tg
forall a.
(Int -> ReadS a)
-> ReadS [a] -> ReadPrec a -> ReadPrec [a] -> Read a
$creadsPrec :: Int -> ReadS Tg
readsPrec :: Int -> ReadS Tg
$creadList :: ReadS [Tg]
readList :: ReadS [Tg]
$creadPrec :: ReadPrec Tg
readPrec :: ReadPrec Tg
$creadListPrec :: ReadPrec [Tg]
readListPrec :: ReadPrec [Tg]
Read, (forall x. Tg -> Rep Tg x)
-> (forall x. Rep Tg x -> Tg) -> Generic Tg
forall x. Rep Tg x -> Tg
forall x. Tg -> Rep Tg x
forall a.
(forall x. a -> Rep a x) -> (forall x. Rep a x -> a) -> Generic a
$cfrom :: forall x. Tg -> Rep Tg x
from :: forall x. Tg -> Rep Tg x
$cto :: forall x. Rep Tg x -> Tg
to :: forall x. Rep Tg x -> Tg
Generic, Typeable, Typeable Tg
Typeable Tg =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> Tg -> c Tg)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c Tg)
-> (Tg -> Constr)
-> (Tg -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c Tg))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tg))
-> ((forall b. Data b => b -> b) -> Tg -> Tg)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r)
-> (forall u. (forall d. Data d => d -> u) -> Tg -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> Tg -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> Tg -> m Tg)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tg -> m Tg)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> Tg -> m Tg)
-> Data Tg
Tg -> Constr
Tg -> DataType
(forall b. Data b => b -> b) -> Tg -> Tg
forall a.
Typeable a =>
(forall (c :: * -> *).
 (forall d b. Data d => c (d -> b) -> d -> c b)
 -> (forall g. g -> c g) -> a -> c a)
-> (forall (c :: * -> *).
    (forall b r. Data b => c (b -> r) -> c r)
    -> (forall r. r -> c r) -> Constr -> c a)
-> (a -> Constr)
-> (a -> DataType)
-> (forall (t :: * -> *) (c :: * -> *).
    Typeable t =>
    (forall d. Data d => c (t d)) -> Maybe (c a))
-> (forall (t :: * -> * -> *) (c :: * -> *).
    Typeable t =>
    (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c a))
-> ((forall b. Data b => b -> b) -> a -> a)
-> (forall r r'.
    (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall r r'.
    (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> a -> r)
-> (forall u. (forall d. Data d => d -> u) -> a -> [u])
-> (forall u. Int -> (forall d. Data d => d -> u) -> a -> u)
-> (forall (m :: * -> *).
    Monad m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> (forall (m :: * -> *).
    MonadPlus m =>
    (forall d. Data d => d -> m d) -> a -> m a)
-> Data a
forall u. Int -> (forall d. Data d => d -> u) -> Tg -> u
forall u. (forall d. Data d => d -> u) -> Tg -> [u]
forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r
forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r
forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tg
forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tg -> c Tg
forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tg)
forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tg)
$cgfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tg -> c Tg
gfoldl :: forall (c :: * -> *).
(forall d b. Data d => c (d -> b) -> d -> c b)
-> (forall g. g -> c g) -> Tg -> c Tg
$cgunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tg
gunfold :: forall (c :: * -> *).
(forall b r. Data b => c (b -> r) -> c r)
-> (forall r. r -> c r) -> Constr -> c Tg
$ctoConstr :: Tg -> Constr
toConstr :: Tg -> Constr
$cdataTypeOf :: Tg -> DataType
dataTypeOf :: Tg -> DataType
$cdataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tg)
dataCast1 :: forall (t :: * -> *) (c :: * -> *).
Typeable t =>
(forall d. Data d => c (t d)) -> Maybe (c Tg)
$cdataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tg)
dataCast2 :: forall (t :: * -> * -> *) (c :: * -> *).
Typeable t =>
(forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Tg)
$cgmapT :: (forall b. Data b => b -> b) -> Tg -> Tg
gmapT :: (forall b. Data b => b -> b) -> Tg -> Tg
$cgmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r
gmapQl :: forall r r'.
(r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r
$cgmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r
gmapQr :: forall r r'.
(r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Tg -> r
$cgmapQ :: forall u. (forall d. Data d => d -> u) -> Tg -> [u]
gmapQ :: forall u. (forall d. Data d => d -> u) -> Tg -> [u]
$cgmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tg -> u
gmapQi :: forall u. Int -> (forall d. Data d => d -> u) -> Tg -> u
$cgmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
gmapM :: forall (m :: * -> *).
Monad m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
$cgmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
gmapMp :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
$cgmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
gmapMo :: forall (m :: * -> *).
MonadPlus m =>
(forall d. Data d => d -> m d) -> Tg -> m Tg
Data)
  deriving anyclass (Tg -> ()
(Tg -> ()) -> NFData Tg
forall a. (a -> ()) -> NFData a
$crnf :: Tg -> ()
rnf :: Tg -> ()
NFData)

instance IsString Tg where
  fromString :: String -> Tg
fromString = Text -> Tg
String (Text -> Tg) -> (String -> Text) -> String -> Tg
forall b c a. (b -> c) -> (a -> b) -> a -> c
. String -> Text
T.pack

-- | get the type of a tag
getty :: Tg -> Ty
getty :: Tg -> Ty
getty Tg
End = Ty
TEnd
getty (Byte Int8
_) = Ty
TByte
getty (Short Int16
_) = Ty
TShort
getty (Int Int32
_) = Ty
TInt
getty (Long Int64
_) = Ty
TLong
getty (Float Float
_) = Ty
TFloat
getty (Double Double
_) = Ty
TDouble
getty (ByteArray ByteString
_) = Ty
TByteArray
getty (String Text
_) = Ty
TString
getty (List Ty
_ Vector Tg
_) = Ty
TList
getty (Compound HashMap Text Tg
_) = Ty
TCompound
getty (IntArray Vector Int32
_) = Ty
TIntArray
getty (LongArray Vector Int64
_) = Ty
TLongArray
{-# INLINE getty #-}