{-# LANGUAGE TypeApplications #-}
#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif
module GI.Vips.Structs.RefString
(
RefString(..) ,
newZeroRefString ,
#if defined(ENABLE_OVERLOADING)
ResolveRefStringMethod ,
#endif
#if defined(ENABLE_OVERLOADING)
RefStringGetMethodInfo ,
#endif
refStringGet ,
refStringNew ,
getRefStringArea ,
#if defined(ENABLE_OVERLOADING)
refString_area ,
#endif
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.BasicTypes as B.Types
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GArray as B.GArray
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.GI.Base.Signals as B.Signals
import qualified Control.Monad.IO.Class as MIO
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GHC.Records as R
import {-# SOURCE #-} qualified GI.Vips.Structs.Area as Vips.Area
newtype RefString = RefString (SP.ManagedPtr RefString)
deriving (RefString -> RefString -> Bool
(RefString -> RefString -> Bool)
-> (RefString -> RefString -> Bool) -> Eq RefString
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: RefString -> RefString -> Bool
$c/= :: RefString -> RefString -> Bool
== :: RefString -> RefString -> Bool
$c== :: RefString -> RefString -> Bool
Eq)
instance SP.ManagedPtrNewtype RefString where
toManagedPtr :: RefString -> ManagedPtr RefString
toManagedPtr (RefString ManagedPtr RefString
p) = ManagedPtr RefString
p
foreign import ccall "vips_ref_string_get_type" c_vips_ref_string_get_type ::
IO GType
type instance O.ParentTypes RefString = '[]
instance O.HasParentTypes RefString
instance B.Types.TypedObject RefString where
glibType :: IO GType
glibType = IO GType
c_vips_ref_string_get_type
instance B.Types.GBoxed RefString
instance B.GValue.IsGValue (Maybe RefString) where
gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_vips_ref_string_get_type
gvalueSet_ :: Ptr GValue -> Maybe RefString -> IO ()
gvalueSet_ Ptr GValue
gv Maybe RefString
P.Nothing = Ptr GValue -> Ptr RefString -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv (Ptr RefString
forall a. Ptr a
FP.nullPtr :: FP.Ptr RefString)
gvalueSet_ Ptr GValue
gv (P.Just RefString
obj) = RefString -> (Ptr RefString -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr RefString
obj (Ptr GValue -> Ptr RefString -> IO ()
forall a. Ptr GValue -> Ptr a -> IO ()
B.GValue.set_boxed Ptr GValue
gv)
gvalueGet_ :: Ptr GValue -> IO (Maybe RefString)
gvalueGet_ Ptr GValue
gv = do
Ptr RefString
ptr <- Ptr GValue -> IO (Ptr RefString)
forall b. Ptr GValue -> IO (Ptr b)
B.GValue.get_boxed Ptr GValue
gv :: IO (Ptr RefString)
if Ptr RefString
ptr Ptr RefString -> Ptr RefString -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr RefString
forall a. Ptr a
FP.nullPtr
then RefString -> Maybe RefString
forall a. a -> Maybe a
P.Just (RefString -> Maybe RefString)
-> IO RefString -> IO (Maybe RefString)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr RefString -> RefString)
-> Ptr RefString -> IO RefString
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr RefString -> RefString
RefString Ptr RefString
ptr
else Maybe RefString -> IO (Maybe RefString)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe RefString
forall a. Maybe a
P.Nothing
newZeroRefString :: MonadIO m => m RefString
newZeroRefString :: forall (m :: * -> *). MonadIO m => m RefString
newZeroRefString = IO RefString -> m RefString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RefString -> m RefString) -> IO RefString -> m RefString
forall a b. (a -> b) -> a -> b
$ Int -> IO (Ptr RefString)
forall a. GBoxed a => Int -> IO (Ptr a)
callocBoxedBytes Int
64 IO (Ptr RefString)
-> (Ptr RefString -> IO RefString) -> IO RefString
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= (ManagedPtr RefString -> RefString)
-> Ptr RefString -> IO RefString
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RefString -> RefString
RefString
instance tag ~ 'AttrSet => Constructible RefString tag where
new :: forall (m :: * -> *).
MonadIO m =>
(ManagedPtr RefString -> RefString)
-> [AttrOp RefString tag] -> m RefString
new ManagedPtr RefString -> RefString
_ [AttrOp RefString tag]
attrs = do
RefString
o <- m RefString
forall (m :: * -> *). MonadIO m => m RefString
newZeroRefString
RefString -> [AttrOp RefString 'AttrSet] -> m ()
forall o (m :: * -> *).
MonadIO m =>
o -> [AttrOp o 'AttrSet] -> m ()
GI.Attributes.set RefString
o [AttrOp RefString tag]
[AttrOp RefString 'AttrSet]
attrs
RefString -> m RefString
forall (m :: * -> *) a. Monad m => a -> m a
return RefString
o
getRefStringArea :: MonadIO m => RefString -> m Vips.Area.Area
getRefStringArea :: forall (m :: * -> *). MonadIO m => RefString -> m Area
getRefStringArea RefString
s = IO Area -> m Area
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Area -> m Area) -> IO Area -> m Area
forall a b. (a -> b) -> a -> b
$ RefString -> (Ptr RefString -> IO Area) -> IO Area
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
withManagedPtr RefString
s ((Ptr RefString -> IO Area) -> IO Area)
-> (Ptr RefString -> IO Area) -> IO Area
forall a b. (a -> b) -> a -> b
$ \Ptr RefString
ptr -> do
let val :: Ptr Area
val = Ptr RefString
ptr Ptr RefString -> Int -> Ptr Area
forall a b. Ptr a -> Int -> Ptr b
`plusPtr` Int
0 :: (Ptr Vips.Area.Area)
Area
val' <- ((ManagedPtr Area -> Area) -> Ptr Area -> IO Area
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
newBoxed ManagedPtr Area -> Area
Vips.Area.Area) Ptr Area
val
Area -> IO Area
forall (m :: * -> *) a. Monad m => a -> m a
return Area
val'
#if defined(ENABLE_OVERLOADING)
data RefStringAreaFieldInfo
instance AttrInfo RefStringAreaFieldInfo where
type AttrBaseTypeConstraint RefStringAreaFieldInfo = (~) RefString
type AttrAllowedOps RefStringAreaFieldInfo = '[ 'AttrGet]
type AttrSetTypeConstraint RefStringAreaFieldInfo = (~) (Ptr Vips.Area.Area)
type AttrTransferTypeConstraint RefStringAreaFieldInfo = (~)(Ptr Vips.Area.Area)
type AttrTransferType RefStringAreaFieldInfo = (Ptr Vips.Area.Area)
type AttrGetType RefStringAreaFieldInfo = Vips.Area.Area
type AttrLabel RefStringAreaFieldInfo = "area"
type AttrOrigin RefStringAreaFieldInfo = RefString
attrGet = getRefStringArea
attrSet = undefined
attrConstruct = undefined
attrClear = undefined
attrTransfer = undefined
refString_area :: AttrLabelProxy "area"
refString_area = AttrLabelProxy
#endif
#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList RefString
type instance O.AttributeList RefString = RefStringAttributeList
type RefStringAttributeList = ('[ '("area", RefStringAreaFieldInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "vips_ref_string_new" vips_ref_string_new ::
CString ->
IO (Ptr RefString)
refStringNew ::
(B.CallStack.HasCallStack, MonadIO m) =>
T.Text
-> m RefString
refStringNew :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
Text -> m RefString
refStringNew Text
str = IO RefString -> m RefString
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO RefString -> m RefString) -> IO RefString -> m RefString
forall a b. (a -> b) -> a -> b
$ do
CString
str' <- Text -> IO CString
textToCString Text
str
Ptr RefString
result <- CString -> IO (Ptr RefString)
vips_ref_string_new CString
str'
Text -> Ptr RefString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"refStringNew" Ptr RefString
result
RefString
result' <- ((ManagedPtr RefString -> RefString)
-> Ptr RefString -> IO RefString
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr RefString -> RefString
RefString) Ptr RefString
result
CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
str'
RefString -> IO RefString
forall (m :: * -> *) a. Monad m => a -> m a
return RefString
result'
#if defined(ENABLE_OVERLOADING)
#endif
foreign import ccall "vips_ref_string_get" vips_ref_string_get ::
Ptr RefString ->
Word64 ->
IO CString
refStringGet ::
(B.CallStack.HasCallStack, MonadIO m) =>
RefString
-> Word64
-> m T.Text
refStringGet :: forall (m :: * -> *).
(HasCallStack, MonadIO m) =>
RefString -> Word64 -> m Text
refStringGet RefString
refstr Word64
length_ = IO Text -> m Text
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Text -> m Text) -> IO Text -> m Text
forall a b. (a -> b) -> a -> b
$ do
Ptr RefString
refstr' <- RefString -> IO (Ptr RefString)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr RefString
refstr
CString
result <- Ptr RefString -> Word64 -> IO CString
vips_ref_string_get Ptr RefString
refstr' Word64
length_
Text -> CString -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"refStringGet" CString
result
Text
result' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result
RefString -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr RefString
refstr
Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result'
#if defined(ENABLE_OVERLOADING)
data RefStringGetMethodInfo
instance (signature ~ (Word64 -> m T.Text), MonadIO m) => O.OverloadedMethod RefStringGetMethodInfo RefString signature where
overloadedMethod = refStringGet
instance O.OverloadedMethodInfo RefStringGetMethodInfo RefString where
overloadedMethodInfo = O.MethodInfo {
O.overloadedMethodName = "GI.Vips.Structs.RefString.refStringGet",
O.overloadedMethodURL = "https://hackage.haskell.org/package/gi-vips-8.0.1/docs/GI-Vips-Structs-RefString.html#v:refStringGet"
}
#endif
#if defined(ENABLE_OVERLOADING)
type family ResolveRefStringMethod (t :: Symbol) (o :: *) :: * where
ResolveRefStringMethod "get" o = RefStringGetMethodInfo
ResolveRefStringMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveRefStringMethod t RefString, O.OverloadedMethod info RefString p) => OL.IsLabel t (RefString -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod @info
#else
fromLabel _ = O.overloadedMethod @info
#endif
#if MIN_VERSION_base(4,13,0)
instance (info ~ ResolveRefStringMethod t RefString, O.OverloadedMethod info RefString p, R.HasField t RefString p) => R.HasField t RefString p where
getField = O.overloadedMethod @info
#endif
instance (info ~ ResolveRefStringMethod t RefString, O.OverloadedMethodInfo info RefString) => OL.IsLabel t (O.MethodProxy info RefString) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.MethodProxy
#else
fromLabel _ = O.MethodProxy
#endif
#endif