{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson, Iñaki García Etxebarria and Jonas Platte
-- 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.JavaScriptCore.Objects.VirtualMachine
    ( 

-- * Exported types
    VirtualMachine(..)                      ,
    IsVirtualMachine                        ,
    toVirtualMachine                        ,
    noVirtualMachine                        ,


 -- * Methods
-- ** Overloaded methods #method:Overloaded methods#

#if defined(ENABLE_OVERLOADING)
    ResolveVirtualMachineMethod             ,
#endif


-- ** new #method:new#

    virtualMachineNew                       ,




    ) 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.ManagedPtr as B.ManagedPtr
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 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 GI.GObject.Objects.Object as GObject.Object

-- | Memory-managed wrapper type.
newtype VirtualMachine = VirtualMachine (ManagedPtr VirtualMachine)
    deriving (VirtualMachine -> VirtualMachine -> Bool
(VirtualMachine -> VirtualMachine -> Bool)
-> (VirtualMachine -> VirtualMachine -> Bool) -> Eq VirtualMachine
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
/= :: VirtualMachine -> VirtualMachine -> Bool
$c/= :: VirtualMachine -> VirtualMachine -> Bool
== :: VirtualMachine -> VirtualMachine -> Bool
$c== :: VirtualMachine -> VirtualMachine -> Bool
Eq)
foreign import ccall "jsc_virtual_machine_get_type"
    c_jsc_virtual_machine_get_type :: IO GType

instance GObject VirtualMachine where
    gobjectType :: IO GType
gobjectType = IO GType
c_jsc_virtual_machine_get_type
    

-- | Convert 'VirtualMachine' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue VirtualMachine where
    toGValue :: VirtualMachine -> IO GValue
toGValue o :: VirtualMachine
o = do
        GType
gtype <- IO GType
c_jsc_virtual_machine_get_type
        VirtualMachine -> (Ptr VirtualMachine -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr VirtualMachine
o (GType
-> (GValue -> Ptr VirtualMachine -> IO ())
-> Ptr VirtualMachine
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr VirtualMachine -> IO ()
forall a. GObject a => GValue -> Ptr a -> IO ()
B.GValue.set_object)
        
    fromGValue :: GValue -> IO VirtualMachine
fromGValue gv :: GValue
gv = do
        Ptr VirtualMachine
ptr <- GValue -> IO (Ptr VirtualMachine)
forall b. GObject b => GValue -> IO (Ptr b)
B.GValue.get_object GValue
gv :: IO (Ptr VirtualMachine)
        (ManagedPtr VirtualMachine -> VirtualMachine)
-> Ptr VirtualMachine -> IO VirtualMachine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr VirtualMachine -> VirtualMachine
VirtualMachine Ptr VirtualMachine
ptr
        
    

-- | Type class for types which can be safely cast to `VirtualMachine`, for instance with `toVirtualMachine`.
class (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o
instance (GObject o, O.IsDescendantOf VirtualMachine o) => IsVirtualMachine o

instance O.HasParentTypes VirtualMachine
type instance O.ParentTypes VirtualMachine = '[GObject.Object.Object]

-- | Cast to `VirtualMachine`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toVirtualMachine :: (MonadIO m, IsVirtualMachine o) => o -> m VirtualMachine
toVirtualMachine :: o -> m VirtualMachine
toVirtualMachine = IO VirtualMachine -> m VirtualMachine
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VirtualMachine -> m VirtualMachine)
-> (o -> IO VirtualMachine) -> o -> m VirtualMachine
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr VirtualMachine -> VirtualMachine)
-> o -> IO VirtualMachine
forall o o'.
(HasCallStack, GObject o, GObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
unsafeCastTo ManagedPtr VirtualMachine -> VirtualMachine
VirtualMachine

-- | A convenience alias for `Nothing` :: `Maybe` `VirtualMachine`.
noVirtualMachine :: Maybe VirtualMachine
noVirtualMachine :: Maybe VirtualMachine
noVirtualMachine = Maybe VirtualMachine
forall a. Maybe a
Nothing

#if defined(ENABLE_OVERLOADING)
type family ResolveVirtualMachineMethod (t :: Symbol) (o :: *) :: * where
    ResolveVirtualMachineMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveVirtualMachineMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveVirtualMachineMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveVirtualMachineMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveVirtualMachineMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveVirtualMachineMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveVirtualMachineMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveVirtualMachineMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveVirtualMachineMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveVirtualMachineMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveVirtualMachineMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveVirtualMachineMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveVirtualMachineMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveVirtualMachineMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveVirtualMachineMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveVirtualMachineMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveVirtualMachineMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveVirtualMachineMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveVirtualMachineMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveVirtualMachineMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveVirtualMachineMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveVirtualMachineMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveVirtualMachineMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveVirtualMachineMethod t VirtualMachine, O.MethodInfo info VirtualMachine p) => OL.IsLabel t (VirtualMachine -> p) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.overloadedMethod @info
#else
    fromLabel _ = O.overloadedMethod @info
#endif

#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList VirtualMachine
type instance O.AttributeList VirtualMachine = VirtualMachineAttributeList
type VirtualMachineAttributeList = ('[ ] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
#endif

#if defined(ENABLE_OVERLOADING)
type instance O.SignalList VirtualMachine = VirtualMachineSignalList
type VirtualMachineSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

#endif

-- method VirtualMachine::new
-- method type : Constructor
-- Args: []
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "JavaScriptCore" , name = "VirtualMachine" })
-- throws : False
-- Skip return : False

foreign import ccall "jsc_virtual_machine_new" jsc_virtual_machine_new :: 
    IO (Ptr VirtualMachine)

-- | Create a new t'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'.
virtualMachineNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m VirtualMachine
    -- ^ __Returns:__ the newly created t'GI.JavaScriptCore.Objects.VirtualMachine.VirtualMachine'.
virtualMachineNew :: m VirtualMachine
virtualMachineNew  = IO VirtualMachine -> m VirtualMachine
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO VirtualMachine -> m VirtualMachine)
-> IO VirtualMachine -> m VirtualMachine
forall a b. (a -> b) -> a -> b
$ do
    Ptr VirtualMachine
result <- IO (Ptr VirtualMachine)
jsc_virtual_machine_new
    Text -> Ptr VirtualMachine -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "virtualMachineNew" Ptr VirtualMachine
result
    VirtualMachine
result' <- ((ManagedPtr VirtualMachine -> VirtualMachine)
-> Ptr VirtualMachine -> IO VirtualMachine
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr VirtualMachine -> VirtualMachine
VirtualMachine) Ptr VirtualMachine
result
    VirtualMachine -> IO VirtualMachine
forall (m :: * -> *) a. Monad m => a -> m a
return VirtualMachine
result'

#if defined(ENABLE_OVERLOADING)
#endif