{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- /No description available in the introspection data./

#if (MIN_VERSION_haskell_gi_overloading(1,0,0) && !defined(__HADDOCK_VERSION__))
#define ENABLE_OVERLOADING
#endif

module GI.Vips.Structs.RefString
    ( 

-- * Exported types
    RefString(..)                           ,
    newZeroRefString                        ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [get]("GI.Vips.Structs.RefString#g:method:get").
-- 
-- ==== Getters
-- /None/.
-- 
-- ==== Setters
-- /None/.

#if defined(ENABLE_OVERLOADING)
    ResolveRefStringMethod                  ,
#endif

-- ** get #method:get#

#if defined(ENABLE_OVERLOADING)
    RefStringGetMethodInfo                  ,
#endif
    refStringGet                            ,


-- ** new #method:new#

    refStringNew                            ,




 -- * Properties


-- ** area #attr:area#
-- | /No description available in the introspection data./

    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

-- | Memory-managed wrapper type.
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

-- | Convert 'RefString' to and from 'Data.GI.Base.GValue.GValue'. See 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
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
        
    

-- | Construct a `RefString` struct initialized to zero.
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


-- | Get the value of the “@area@” field.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' refString #area
-- @
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

-- method RefString::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "str"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "string to store" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Vips" , name = "RefString" })
-- throws : False
-- Skip return : False

foreign import ccall "vips_ref_string_new" vips_ref_string_new :: 
    CString ->                              -- str : TBasicType TUTF8
    IO (Ptr RefString)

-- | Create a new refstring. These are reference-counted immutable strings, used
-- to store string data in vips image metadata.
-- 
-- Strings must be valid utf-8; use blob for binary data.
-- 
-- See also: 'GI.Vips.Structs.Area.areaUnref'.
refStringNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@str@/: string to store
    -> m RefString
    -- ^ __Returns:__ the new t'GI.Vips.Structs.RefString.RefString', or NULL on error.
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

-- method RefString::get
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "refstr"
--           , argType =
--               TInterface Name { namespace = "Vips" , name = "RefString" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the #VipsRefString to fetch from"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "length"
--           , argType = TBasicType TUInt64
--           , direction = DirectionIn
--           , mayBeNull = True
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "return length here, optionally"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False

foreign import ccall "vips_ref_string_get" vips_ref_string_get :: 
    Ptr RefString ->                        -- refstr : TInterface (Name {namespace = "Vips", name = "RefString"})
    Word64 ->                               -- length : TBasicType TUInt64
    IO CString

-- | Get a pointer to the private string inside a refstr. Handy for language
-- bindings.
-- 
-- See also: 'GI.Vips.Functions.valueGetRefString'.
refStringGet ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    RefString
    -- ^ /@refstr@/: the t'GI.Vips.Structs.RefString.RefString' to fetch from
    -> Word64
    -- ^ /@length@/: return length here, optionally
    -> m T.Text
    -- ^ __Returns:__ The C string held by /@refstr@/.
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