TokenValue.hs


{- |
Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License    : LGPL-2.1
Maintainer : Iñaki García Etxebarria (garetxe@gmail.com)
-}

module GI.GLib.Unions.TokenValue
    ( 

-- * Exported types
    TokenValue(..)                          ,
    newZeroTokenValue                       ,
    noTokenValue                            ,


 -- * Properties
-- ** VBinary
    tokenValueReadVBinary                   ,


-- ** VChar
    tokenValueReadVChar                     ,


-- ** VComment
    tokenValueReadVComment                  ,


-- ** VError
    tokenValueReadVError                    ,


-- ** VFloat
    tokenValueReadVFloat                    ,


-- ** VHex
    tokenValueReadVHex                      ,


-- ** VIdentifier
    tokenValueReadVIdentifier               ,


-- ** VInt
    tokenValueReadVInt                      ,


-- ** VInt64
    tokenValueReadVInt64                    ,


-- ** VOctal
    tokenValueReadVOctal                    ,


-- ** VString
    tokenValueReadVString                   ,


-- ** VSymbol
    tokenValueReadVSymbol                   ,




    ) where

import Prelude ()
import Data.GI.Base.ShortPrelude

import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map

import GI.GLib.Types
import GI.GLib.Callbacks

newtype TokenValue = TokenValue (ForeignPtr TokenValue)
-- | Construct a `TokenValue` struct initialized to zero.
newZeroTokenValue :: MonadIO m => m TokenValue
newZeroTokenValue = liftIO $ callocBytes 8 >>= wrapPtr TokenValue

noTokenValue :: Maybe TokenValue
noTokenValue = Nothing

tokenValueReadVSymbol :: TokenValue -> IO (Ptr ())
tokenValueReadVSymbol s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO (Ptr ())
    return val

tokenValueReadVIdentifier :: TokenValue -> IO T.Text
tokenValueReadVIdentifier s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    val' <- cstringToText val
    return val'

tokenValueReadVBinary :: TokenValue -> IO Word64
tokenValueReadVBinary s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

tokenValueReadVOctal :: TokenValue -> IO Word64
tokenValueReadVOctal s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

tokenValueReadVInt :: TokenValue -> IO Word64
tokenValueReadVInt s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

tokenValueReadVInt64 :: TokenValue -> IO Word64
tokenValueReadVInt64 s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

tokenValueReadVFloat :: TokenValue -> IO Double
tokenValueReadVFloat s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CDouble
    let val' = realToFrac val
    return val'

tokenValueReadVHex :: TokenValue -> IO Word64
tokenValueReadVHex s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word64
    return val

tokenValueReadVString :: TokenValue -> IO T.Text
tokenValueReadVString s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    val' <- cstringToText val
    return val'

tokenValueReadVComment :: TokenValue -> IO T.Text
tokenValueReadVComment s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO CString
    val' <- cstringToText val
    return val'

tokenValueReadVChar :: TokenValue -> IO Word8
tokenValueReadVChar s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word8
    return val

tokenValueReadVError :: TokenValue -> IO Word32
tokenValueReadVError s = withManagedPtr s $ \ptr -> do
    val <- peek (ptr `plusPtr` 0) :: IO Word32
    return val

type family ResolveTokenValueMethod (t :: Symbol) (o :: *) :: * where
    ResolveTokenValueMethod l o = MethodResolutionFailed l o

instance (info ~ ResolveTokenValueMethod t TokenValue, MethodInfo info TokenValue p) => IsLabelProxy t (TokenValue -> p) where
    fromLabelProxy _ = overloadedMethod (MethodProxy :: MethodProxy info)

#if MIN_VERSION_base(4,9,0)
instance (info ~ ResolveTokenValueMethod t TokenValue, MethodInfo info TokenValue p) => IsLabel t (TokenValue -> p) where
    fromLabel _ = overloadedMethod (MethodProxy :: MethodProxy info)
#endif