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

'GI.WebKit.Objects.WebDatabase.WebDatabase' is a representation of a Web Database database. The
proposed Web Database standard introduces support for SQL databases that web
sites can create and access on a local computer through JavaScript.

To get access to all databases defined by a security origin, use
@/webkit_security_origin_get_databases/@. Each database has a canonical
name, as well as a user-friendly display name.

WebKit uses SQLite to create and access the local SQL databases. The location
of a 'GI.WebKit.Objects.WebDatabase.WebDatabase' can be accessed wth @/webkit_web_database_get_filename/@.
You can configure the location of all databases with
@/webkit_set_database_directory_path/@.

For each database the web site can define an estimated size which can be
accessed with @/webkit_web_database_get_expected_size/@. The current size of the
database in bytes is returned by @/webkit_web_database_get_size/@.

For more information refer to the Web Database specification proposal at
http:\/\/dev.w3.org\/html5\/webdatabase
-}

module GI.WebKit.Objects.WebDatabase
    ( 

-- * Exported types
    WebDatabase(..)                         ,
    IsWebDatabase                           ,
    toWebDatabase                           ,
    noWebDatabase                           ,


 -- * Methods
-- ** getDisplayName #method:getDisplayName#
    WebDatabaseGetDisplayNameMethodInfo     ,
    webDatabaseGetDisplayName               ,


-- ** getExpectedSize #method:getExpectedSize#
    WebDatabaseGetExpectedSizeMethodInfo    ,
    webDatabaseGetExpectedSize              ,


-- ** getFilename #method:getFilename#
    WebDatabaseGetFilenameMethodInfo        ,
    webDatabaseGetFilename                  ,


-- ** getName #method:getName#
    WebDatabaseGetNameMethodInfo            ,
    webDatabaseGetName                      ,


-- ** getSecurityOrigin #method:getSecurityOrigin#
    WebDatabaseGetSecurityOriginMethodInfo  ,
    webDatabaseGetSecurityOrigin            ,


-- ** getSize #method:getSize#
    WebDatabaseGetSizeMethodInfo            ,
    webDatabaseGetSize                      ,


-- ** remove #method:remove#
    WebDatabaseRemoveMethodInfo             ,
    webDatabaseRemove                       ,




 -- * Properties
-- ** displayName #attr:displayName#
    WebDatabaseDisplayNamePropertyInfo      ,
    getWebDatabaseDisplayName               ,
    webDatabaseDisplayName                  ,


-- ** expectedSize #attr:expectedSize#
    WebDatabaseExpectedSizePropertyInfo     ,
    getWebDatabaseExpectedSize              ,
    webDatabaseExpectedSize                 ,


-- ** filename #attr:filename#
    WebDatabaseFilenamePropertyInfo         ,
    getWebDatabaseFilename                  ,
    webDatabaseFilename                     ,


-- ** name #attr:name#
    WebDatabaseNamePropertyInfo             ,
    constructWebDatabaseName                ,
    getWebDatabaseName                      ,
    webDatabaseName                         ,


-- ** securityOrigin #attr:securityOrigin#
    WebDatabaseSecurityOriginPropertyInfo   ,
    constructWebDatabaseSecurityOrigin      ,
    getWebDatabaseSecurityOrigin            ,
    webDatabaseSecurityOrigin               ,


-- ** size #attr:size#
    WebDatabaseSizePropertyInfo             ,
    getWebDatabaseSize                      ,
    webDatabaseSize                         ,




    ) 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.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
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 GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.WebKit.Objects.SecurityOrigin as WebKit.SecurityOrigin

newtype WebDatabase = WebDatabase (ManagedPtr WebDatabase)
foreign import ccall "webkit_web_database_get_type"
    c_webkit_web_database_get_type :: IO GType

instance GObject WebDatabase where
    gobjectType _ = c_webkit_web_database_get_type
    

class GObject o => IsWebDatabase o
#if MIN_VERSION_base(4,9,0)
instance {-# OVERLAPPABLE #-} (GObject a, O.UnknownAncestorError WebDatabase a) =>
    IsWebDatabase a
#endif
instance IsWebDatabase WebDatabase
instance GObject.Object.IsObject WebDatabase

toWebDatabase :: IsWebDatabase o => o -> IO WebDatabase
toWebDatabase = unsafeCastTo WebDatabase

noWebDatabase :: Maybe WebDatabase
noWebDatabase = Nothing

type family ResolveWebDatabaseMethod (t :: Symbol) (o :: *) :: * where
    ResolveWebDatabaseMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveWebDatabaseMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveWebDatabaseMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveWebDatabaseMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveWebDatabaseMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveWebDatabaseMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveWebDatabaseMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveWebDatabaseMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveWebDatabaseMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveWebDatabaseMethod "remove" o = WebDatabaseRemoveMethodInfo
    ResolveWebDatabaseMethod "replaceData" o = GObject.Object.ObjectReplaceDataMethodInfo
    ResolveWebDatabaseMethod "replaceQdata" o = GObject.Object.ObjectReplaceQdataMethodInfo
    ResolveWebDatabaseMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveWebDatabaseMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveWebDatabaseMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveWebDatabaseMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveWebDatabaseMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveWebDatabaseMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveWebDatabaseMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveWebDatabaseMethod "getDisplayName" o = WebDatabaseGetDisplayNameMethodInfo
    ResolveWebDatabaseMethod "getExpectedSize" o = WebDatabaseGetExpectedSizeMethodInfo
    ResolveWebDatabaseMethod "getFilename" o = WebDatabaseGetFilenameMethodInfo
    ResolveWebDatabaseMethod "getName" o = WebDatabaseGetNameMethodInfo
    ResolveWebDatabaseMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveWebDatabaseMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveWebDatabaseMethod "getSecurityOrigin" o = WebDatabaseGetSecurityOriginMethodInfo
    ResolveWebDatabaseMethod "getSize" o = WebDatabaseGetSizeMethodInfo
    ResolveWebDatabaseMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveWebDatabaseMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveWebDatabaseMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveWebDatabaseMethod t WebDatabase, O.MethodInfo info WebDatabase p) => O.IsLabelProxy t (WebDatabase -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

-- VVV Prop "display-name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebDatabaseDisplayName :: (MonadIO m, IsWebDatabase o) => o -> m T.Text
getWebDatabaseDisplayName obj = liftIO $ checkUnexpectedNothing "getWebDatabaseDisplayName" $ getObjectPropertyString obj "display-name"

data WebDatabaseDisplayNamePropertyInfo
instance AttrInfo WebDatabaseDisplayNamePropertyInfo where
    type AttrAllowedOps WebDatabaseDisplayNamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebDatabaseDisplayNamePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebDatabaseDisplayNamePropertyInfo = IsWebDatabase
    type AttrGetType WebDatabaseDisplayNamePropertyInfo = T.Text
    type AttrLabel WebDatabaseDisplayNamePropertyInfo = "display-name"
    type AttrOrigin WebDatabaseDisplayNamePropertyInfo = WebDatabase
    attrGet _ = getWebDatabaseDisplayName
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "expected-size"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebDatabaseExpectedSize :: (MonadIO m, IsWebDatabase o) => o -> m Word64
getWebDatabaseExpectedSize obj = liftIO $ getObjectPropertyUInt64 obj "expected-size"

data WebDatabaseExpectedSizePropertyInfo
instance AttrInfo WebDatabaseExpectedSizePropertyInfo where
    type AttrAllowedOps WebDatabaseExpectedSizePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebDatabaseExpectedSizePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebDatabaseExpectedSizePropertyInfo = IsWebDatabase
    type AttrGetType WebDatabaseExpectedSizePropertyInfo = Word64
    type AttrLabel WebDatabaseExpectedSizePropertyInfo = "expected-size"
    type AttrOrigin WebDatabaseExpectedSizePropertyInfo = WebDatabase
    attrGet _ = getWebDatabaseExpectedSize
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "filename"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebDatabaseFilename :: (MonadIO m, IsWebDatabase o) => o -> m T.Text
getWebDatabaseFilename obj = liftIO $ checkUnexpectedNothing "getWebDatabaseFilename" $ getObjectPropertyString obj "filename"

data WebDatabaseFilenamePropertyInfo
instance AttrInfo WebDatabaseFilenamePropertyInfo where
    type AttrAllowedOps WebDatabaseFilenamePropertyInfo = '[ 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebDatabaseFilenamePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebDatabaseFilenamePropertyInfo = IsWebDatabase
    type AttrGetType WebDatabaseFilenamePropertyInfo = T.Text
    type AttrLabel WebDatabaseFilenamePropertyInfo = "filename"
    type AttrOrigin WebDatabaseFilenamePropertyInfo = WebDatabase
    attrGet _ = getWebDatabaseFilename
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

-- VVV Prop "name"
   -- Type: TBasicType TUTF8
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getWebDatabaseName :: (MonadIO m, IsWebDatabase o) => o -> m T.Text
getWebDatabaseName obj = liftIO $ checkUnexpectedNothing "getWebDatabaseName" $ getObjectPropertyString obj "name"

constructWebDatabaseName :: (IsWebDatabase o) => T.Text -> IO (GValueConstruct o)
constructWebDatabaseName val = constructObjectPropertyString "name" (Just val)

data WebDatabaseNamePropertyInfo
instance AttrInfo WebDatabaseNamePropertyInfo where
    type AttrAllowedOps WebDatabaseNamePropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebDatabaseNamePropertyInfo = (~) T.Text
    type AttrBaseTypeConstraint WebDatabaseNamePropertyInfo = IsWebDatabase
    type AttrGetType WebDatabaseNamePropertyInfo = T.Text
    type AttrLabel WebDatabaseNamePropertyInfo = "name"
    type AttrOrigin WebDatabaseNamePropertyInfo = WebDatabase
    attrGet _ = getWebDatabaseName
    attrSet _ = undefined
    attrConstruct _ = constructWebDatabaseName
    attrClear _ = undefined

-- VVV Prop "security-origin"
   -- Type: TInterface (Name {namespace = "WebKit", name = "SecurityOrigin"})
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Just False,Nothing)

getWebDatabaseSecurityOrigin :: (MonadIO m, IsWebDatabase o) => o -> m WebKit.SecurityOrigin.SecurityOrigin
getWebDatabaseSecurityOrigin obj = liftIO $ checkUnexpectedNothing "getWebDatabaseSecurityOrigin" $ getObjectPropertyObject obj "security-origin" WebKit.SecurityOrigin.SecurityOrigin

constructWebDatabaseSecurityOrigin :: (IsWebDatabase o, WebKit.SecurityOrigin.IsSecurityOrigin a) => a -> IO (GValueConstruct o)
constructWebDatabaseSecurityOrigin val = constructObjectPropertyObject "security-origin" (Just val)

data WebDatabaseSecurityOriginPropertyInfo
instance AttrInfo WebDatabaseSecurityOriginPropertyInfo where
    type AttrAllowedOps WebDatabaseSecurityOriginPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
    type AttrSetTypeConstraint WebDatabaseSecurityOriginPropertyInfo = WebKit.SecurityOrigin.IsSecurityOrigin
    type AttrBaseTypeConstraint WebDatabaseSecurityOriginPropertyInfo = IsWebDatabase
    type AttrGetType WebDatabaseSecurityOriginPropertyInfo = WebKit.SecurityOrigin.SecurityOrigin
    type AttrLabel WebDatabaseSecurityOriginPropertyInfo = "security-origin"
    type AttrOrigin WebDatabaseSecurityOriginPropertyInfo = WebDatabase
    attrGet _ = getWebDatabaseSecurityOrigin
    attrSet _ = undefined
    attrConstruct _ = constructWebDatabaseSecurityOrigin
    attrClear _ = undefined

-- VVV Prop "size"
   -- Type: TBasicType TUInt64
   -- Flags: [PropertyReadable]
   -- Nullable: (Just False,Nothing)

getWebDatabaseSize :: (MonadIO m, IsWebDatabase o) => o -> m Word64
getWebDatabaseSize obj = liftIO $ getObjectPropertyUInt64 obj "size"

data WebDatabaseSizePropertyInfo
instance AttrInfo WebDatabaseSizePropertyInfo where
    type AttrAllowedOps WebDatabaseSizePropertyInfo = '[ 'AttrGet]
    type AttrSetTypeConstraint WebDatabaseSizePropertyInfo = (~) ()
    type AttrBaseTypeConstraint WebDatabaseSizePropertyInfo = IsWebDatabase
    type AttrGetType WebDatabaseSizePropertyInfo = Word64
    type AttrLabel WebDatabaseSizePropertyInfo = "size"
    type AttrOrigin WebDatabaseSizePropertyInfo = WebDatabase
    attrGet _ = getWebDatabaseSize
    attrSet _ = undefined
    attrConstruct _ = undefined
    attrClear _ = undefined

instance O.HasAttributeList WebDatabase
type instance O.AttributeList WebDatabase = WebDatabaseAttributeList
type WebDatabaseAttributeList = ('[ '("displayName", WebDatabaseDisplayNamePropertyInfo), '("expectedSize", WebDatabaseExpectedSizePropertyInfo), '("filename", WebDatabaseFilenamePropertyInfo), '("name", WebDatabaseNamePropertyInfo), '("securityOrigin", WebDatabaseSecurityOriginPropertyInfo), '("size", WebDatabaseSizePropertyInfo)] :: [(Symbol, *)])

webDatabaseDisplayName :: AttrLabelProxy "displayName"
webDatabaseDisplayName = AttrLabelProxy

webDatabaseExpectedSize :: AttrLabelProxy "expectedSize"
webDatabaseExpectedSize = AttrLabelProxy

webDatabaseFilename :: AttrLabelProxy "filename"
webDatabaseFilename = AttrLabelProxy

webDatabaseName :: AttrLabelProxy "name"
webDatabaseName = AttrLabelProxy

webDatabaseSecurityOrigin :: AttrLabelProxy "securityOrigin"
webDatabaseSecurityOrigin = AttrLabelProxy

webDatabaseSize :: AttrLabelProxy "size"
webDatabaseSize = AttrLabelProxy

type instance O.SignalList WebDatabase = WebDatabaseSignalList
type WebDatabaseSignalList = ('[ '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])

-- method WebDatabase::get_display_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "webDatabase", argType = TInterface (Name {namespace = "WebKit", name = "WebDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebDatabase", 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 "webkit_web_database_get_display_name" webkit_web_database_get_display_name :: 
    Ptr WebDatabase ->                      -- webDatabase : TInterface (Name {namespace = "WebKit", name = "WebDatabase"})
    IO CString

{- |
Returns the name of the 'GI.WebKit.Objects.WebDatabase.WebDatabase' as seen by the user.

@since 1.1.14
-}
webDatabaseGetDisplayName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebDatabase a) =>
    a
    {- ^ /@webDatabase@/: a 'GI.WebKit.Objects.WebDatabase.WebDatabase' -}
    -> m T.Text
    {- ^ __Returns:__ the name of the database as seen by the user. -}
webDatabaseGetDisplayName webDatabase = liftIO $ do
    webDatabase' <- unsafeManagedPtrCastPtr webDatabase
    result <- webkit_web_database_get_display_name webDatabase'
    checkUnexpectedReturnNULL "webDatabaseGetDisplayName" result
    result' <- cstringToText result
    touchManagedPtr webDatabase
    return result'

data WebDatabaseGetDisplayNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebDatabase a) => O.MethodInfo WebDatabaseGetDisplayNameMethodInfo a signature where
    overloadedMethod _ = webDatabaseGetDisplayName

-- method WebDatabase::get_expected_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "webDatabase", argType = TInterface (Name {namespace = "WebKit", name = "WebDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_database_get_expected_size" webkit_web_database_get_expected_size :: 
    Ptr WebDatabase ->                      -- webDatabase : TInterface (Name {namespace = "WebKit", name = "WebDatabase"})
    IO Word64

{- |
Returns the expected size of the 'GI.WebKit.Objects.WebDatabase.WebDatabase' in bytes as defined by the
web author. The Web Database standard allows web authors to specify an expected
size of the database to optimize the user experience.

@since 1.1.14
-}
webDatabaseGetExpectedSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebDatabase a) =>
    a
    {- ^ /@webDatabase@/: a 'GI.WebKit.Objects.WebDatabase.WebDatabase' -}
    -> m Word64
    {- ^ __Returns:__ the expected size of the database in bytes -}
webDatabaseGetExpectedSize webDatabase = liftIO $ do
    webDatabase' <- unsafeManagedPtrCastPtr webDatabase
    result <- webkit_web_database_get_expected_size webDatabase'
    touchManagedPtr webDatabase
    return result

data WebDatabaseGetExpectedSizeMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsWebDatabase a) => O.MethodInfo WebDatabaseGetExpectedSizeMethodInfo a signature where
    overloadedMethod _ = webDatabaseGetExpectedSize

-- method WebDatabase::get_filename
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "webDatabase", argType = TInterface (Name {namespace = "WebKit", name = "WebDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebDatabase", 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 "webkit_web_database_get_filename" webkit_web_database_get_filename :: 
    Ptr WebDatabase ->                      -- webDatabase : TInterface (Name {namespace = "WebKit", name = "WebDatabase"})
    IO CString

{- |
Returns the absolute filename to the 'GI.WebKit.Objects.WebDatabase.WebDatabase' file on disk.

@since 1.1.14
-}
webDatabaseGetFilename ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebDatabase a) =>
    a
    {- ^ /@webDatabase@/: a 'GI.WebKit.Objects.WebDatabase.WebDatabase' -}
    -> m T.Text
    {- ^ __Returns:__ the absolute filename of the database -}
webDatabaseGetFilename webDatabase = liftIO $ do
    webDatabase' <- unsafeManagedPtrCastPtr webDatabase
    result <- webkit_web_database_get_filename webDatabase'
    checkUnexpectedReturnNULL "webDatabaseGetFilename" result
    result' <- cstringToText result
    touchManagedPtr webDatabase
    return result'

data WebDatabaseGetFilenameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebDatabase a) => O.MethodInfo WebDatabaseGetFilenameMethodInfo a signature where
    overloadedMethod _ = webDatabaseGetFilename

-- method WebDatabase::get_name
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "webDatabase", argType = TInterface (Name {namespace = "WebKit", name = "WebDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebDatabase", 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 "webkit_web_database_get_name" webkit_web_database_get_name :: 
    Ptr WebDatabase ->                      -- webDatabase : TInterface (Name {namespace = "WebKit", name = "WebDatabase"})
    IO CString

{- |
Returns the canonical name of the 'GI.WebKit.Objects.WebDatabase.WebDatabase'.

@since 1.1.14
-}
webDatabaseGetName ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebDatabase a) =>
    a
    {- ^ /@webDatabase@/: a 'GI.WebKit.Objects.WebDatabase.WebDatabase' -}
    -> m T.Text
    {- ^ __Returns:__ the name of the database -}
webDatabaseGetName webDatabase = liftIO $ do
    webDatabase' <- unsafeManagedPtrCastPtr webDatabase
    result <- webkit_web_database_get_name webDatabase'
    checkUnexpectedReturnNULL "webDatabaseGetName" result
    result' <- cstringToText result
    touchManagedPtr webDatabase
    return result'

data WebDatabaseGetNameMethodInfo
instance (signature ~ (m T.Text), MonadIO m, IsWebDatabase a) => O.MethodInfo WebDatabaseGetNameMethodInfo a signature where
    overloadedMethod _ = webDatabaseGetName

-- method WebDatabase::get_security_origin
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "webDatabase", argType = TInterface (Name {namespace = "WebKit", name = "WebDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "WebKit", name = "SecurityOrigin"}))
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_database_get_security_origin" webkit_web_database_get_security_origin :: 
    Ptr WebDatabase ->                      -- webDatabase : TInterface (Name {namespace = "WebKit", name = "WebDatabase"})
    IO (Ptr WebKit.SecurityOrigin.SecurityOrigin)

{- |
Returns the security origin of the 'GI.WebKit.Objects.WebDatabase.WebDatabase'.

@since 1.1.14
-}
webDatabaseGetSecurityOrigin ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebDatabase a) =>
    a
    {- ^ /@webDatabase@/: a 'GI.WebKit.Objects.WebDatabase.WebDatabase' -}
    -> m WebKit.SecurityOrigin.SecurityOrigin
    {- ^ __Returns:__ the security origin of the database -}
webDatabaseGetSecurityOrigin webDatabase = liftIO $ do
    webDatabase' <- unsafeManagedPtrCastPtr webDatabase
    result <- webkit_web_database_get_security_origin webDatabase'
    checkUnexpectedReturnNULL "webDatabaseGetSecurityOrigin" result
    result' <- (newObject WebKit.SecurityOrigin.SecurityOrigin) result
    touchManagedPtr webDatabase
    return result'

data WebDatabaseGetSecurityOriginMethodInfo
instance (signature ~ (m WebKit.SecurityOrigin.SecurityOrigin), MonadIO m, IsWebDatabase a) => O.MethodInfo WebDatabaseGetSecurityOriginMethodInfo a signature where
    overloadedMethod _ = webDatabaseGetSecurityOrigin

-- method WebDatabase::get_size
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "webDatabase", argType = TInterface (Name {namespace = "WebKit", name = "WebDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUInt64)
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_database_get_size" webkit_web_database_get_size :: 
    Ptr WebDatabase ->                      -- webDatabase : TInterface (Name {namespace = "WebKit", name = "WebDatabase"})
    IO Word64

{- |
Returns the actual size of the 'GI.WebKit.Objects.WebDatabase.WebDatabase' space on disk in bytes.

@since 1.1.14
-}
webDatabaseGetSize ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebDatabase a) =>
    a
    {- ^ /@webDatabase@/: a 'GI.WebKit.Objects.WebDatabase.WebDatabase' -}
    -> m Word64
    {- ^ __Returns:__ the actual size of the database in bytes -}
webDatabaseGetSize webDatabase = liftIO $ do
    webDatabase' <- unsafeManagedPtrCastPtr webDatabase
    result <- webkit_web_database_get_size webDatabase'
    touchManagedPtr webDatabase
    return result

data WebDatabaseGetSizeMethodInfo
instance (signature ~ (m Word64), MonadIO m, IsWebDatabase a) => O.MethodInfo WebDatabaseGetSizeMethodInfo a signature where
    overloadedMethod _ = webDatabaseGetSize

-- method WebDatabase::remove
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "webDatabase", argType = TInterface (Name {namespace = "WebKit", name = "WebDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #WebKitWebDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_web_database_remove" webkit_web_database_remove :: 
    Ptr WebDatabase ->                      -- webDatabase : TInterface (Name {namespace = "WebKit", name = "WebDatabase"})
    IO ()

{- |
Removes the 'GI.WebKit.Objects.WebDatabase.WebDatabase' from its security origin and destroys all data
stored in the database.

@since 1.1.14
-}
webDatabaseRemove ::
    (B.CallStack.HasCallStack, MonadIO m, IsWebDatabase a) =>
    a
    {- ^ /@webDatabase@/: a 'GI.WebKit.Objects.WebDatabase.WebDatabase' -}
    -> m ()
webDatabaseRemove webDatabase = liftIO $ do
    webDatabase' <- unsafeManagedPtrCastPtr webDatabase
    webkit_web_database_remove webDatabase'
    touchManagedPtr webDatabase
    return ()

data WebDatabaseRemoveMethodInfo
instance (signature ~ (m ()), MonadIO m, IsWebDatabase a) => O.MethodInfo WebDatabaseRemoveMethodInfo a signature where
    overloadedMethod _ = webDatabaseRemove