{-# LANGUAGE ConstraintKinds, FlexibleContexts, FlexibleInstances,
DeriveDataTypeable, TypeFamilies, ScopedTypeVariables #-}
#if !MIN_VERSION_base(4,8,0)
{-# LANGUAGE OverlappingInstances #-}
#endif
#if MIN_VERSION_base(4,9,0)
{-# LANGUAGE DataKinds, TypeOperators, UndecidableInstances #-}
#endif
module Data.GI.Base.BasicTypes
(
module Data.GI.Base.GType
, ManagedPtr(..)
, ManagedPtrNewtype
, BoxedObject(..)
, BoxedEnum(..)
, BoxedFlags(..)
, GObject(..)
, WrappedPtr(..)
, UnexpectedNullPointerReturn(..)
, NullToNothing(..)
, GVariant(..)
, GParamSpec(..)
, GArray(..)
, GPtrArray(..)
, GByteArray(..)
, GHashTable(..)
, GList(..)
, g_list_free
, GSList(..)
, g_slist_free
, IsGFlag
, PtrWrapped(..)
, GDestroyNotify
) where
#if !MIN_VERSION_base(4,8,0)
import Control.Applicative ((<$>))
#endif
import Control.Exception (Exception, catch)
import Control.Monad.IO.Class (MonadIO(..))
import Data.Coerce (Coercible)
import Data.IORef (IORef)
import Data.Proxy (Proxy)
import qualified Data.Text as T
import Data.Typeable (Typeable)
import Foreign.Ptr (Ptr, FunPtr)
import Foreign.ForeignPtr (ForeignPtr)
import Data.GI.Base.CallStack (CallStack)
import Data.GI.Base.GType
data ManagedPtr a = ManagedPtr {
ManagedPtr a -> ForeignPtr a
managedForeignPtr :: ForeignPtr a
, ManagedPtr a -> Maybe CallStack
managedPtrAllocCallStack :: Maybe CallStack
, ManagedPtr a -> IORef (Maybe CallStack)
managedPtrIsDisowned :: IORef (Maybe CallStack)
}
type ManagedPtrNewtype a = Coercible a (ManagedPtr ())
class ManagedPtrNewtype a => BoxedObject a where
boxedType :: a -> IO GType
class BoxedEnum a where
boxedEnumType :: a -> IO GType
class BoxedFlags a where
boxedFlagsType :: Proxy a -> IO GType
class ManagedPtrNewtype a => WrappedPtr a where
wrappedPtrCalloc :: IO (Ptr a)
wrappedPtrCopy :: a -> IO a
wrappedPtrFree :: Maybe (FunPtr (Ptr a -> IO ()))
class ManagedPtrNewtype a => GObject a where
gobjectType :: a -> IO GType
data UnexpectedNullPointerReturn =
UnexpectedNullPointerReturn { UnexpectedNullPointerReturn -> Text
nullPtrErrorMsg :: T.Text }
deriving (Typeable)
instance Show UnexpectedNullPointerReturn where
show :: UnexpectedNullPointerReturn -> String
show r :: UnexpectedNullPointerReturn
r = Text -> String
T.unpack (UnexpectedNullPointerReturn -> Text
nullPtrErrorMsg UnexpectedNullPointerReturn
r)
instance Exception UnexpectedNullPointerReturn
type family UnMaybe a :: * where
UnMaybe (Maybe a) = a
UnMaybe a = a
{-# DEPRECATED nullToNothing ["This will be removed in future versions of haskell-gi.", "If you know of wrong introspection data in a binding please report it as an issue at", "http://github.com/haskell-gi/haskell-gi", "so that it can be fixed."] #-}
class NullToNothing a where
nullToNothing :: MonadIO m => IO a -> m (Maybe (UnMaybe a))
instance
#if MIN_VERSION_base(4,8,0)
{-# OVERLAPPABLE #-}
#endif
a ~ UnMaybe a => NullToNothing a where
nullToNothing :: IO a -> m (Maybe (UnMaybe a))
nullToNothing f :: IO a
f = IO (Maybe a) -> m (Maybe (UnMaybe a))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe a) -> m (Maybe (UnMaybe a)))
-> IO (Maybe a) -> m (Maybe (UnMaybe a))
forall a b. (a -> b) -> a -> b
$
(a -> Maybe a
forall a. a -> Maybe a
Just (a -> Maybe a) -> IO a -> IO (Maybe a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> IO a
f) IO (Maybe a)
-> (UnexpectedNullPointerReturn -> IO (Maybe a)) -> IO (Maybe a)
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
`catch` (\(UnexpectedNullPointerReturn
_::UnexpectedNullPointerReturn) -> Maybe a -> IO (Maybe a)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe a
forall a. Maybe a
Nothing)
instance NullToNothing (Maybe a) where
nullToNothing :: IO (Maybe a) -> m (Maybe (UnMaybe (Maybe a)))
nullToNothing = IO (Maybe a) -> m (Maybe (UnMaybe (Maybe a)))
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO
newtype GVariant = GVariant (ManagedPtr GVariant)
newtype GParamSpec = GParamSpec (ManagedPtr GParamSpec)
class Enum a => IsGFlag a
data GArray a = GArray (Ptr (GArray a))
data GPtrArray a = GPtrArray (Ptr (GPtrArray a))
data GByteArray = GByteArray (Ptr GByteArray)
data GHashTable a b = GHashTable (Ptr (GHashTable a b))
data GList a = GList (Ptr (GList a))
data GSList a = GSList (Ptr (GSList a))
newtype PtrWrapped a = PtrWrapped {PtrWrapped a -> Ptr a
unwrapPtr :: Ptr a}
type GDestroyNotify a = FunPtr (Ptr a -> IO ())
foreign import ccall "g_list_free" g_list_free ::
Ptr (GList a) -> IO ()
foreign import ccall "g_slist_free" g_slist_free ::
Ptr (GSList a) -> IO ()