{-# 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.WebKit2.Structs.SecurityOrigin
    ( 

-- * Exported types
    SecurityOrigin(..)                      ,
    noSecurityOrigin                        ,


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

#if defined(ENABLE_OVERLOADING)
    ResolveSecurityOriginMethod             ,
#endif


-- ** getHost #method:getHost#

#if defined(ENABLE_OVERLOADING)
    SecurityOriginGetHostMethodInfo         ,
#endif
    securityOriginGetHost                   ,


-- ** getPort #method:getPort#

#if defined(ENABLE_OVERLOADING)
    SecurityOriginGetPortMethodInfo         ,
#endif
    securityOriginGetPort                   ,


-- ** getProtocol #method:getProtocol#

#if defined(ENABLE_OVERLOADING)
    SecurityOriginGetProtocolMethodInfo     ,
#endif
    securityOriginGetProtocol               ,


-- ** isOpaque #method:isOpaque#

#if defined(ENABLE_OVERLOADING)
    SecurityOriginIsOpaqueMethodInfo        ,
#endif
    securityOriginIsOpaque                  ,


-- ** new #method:new#

    securityOriginNew                       ,


-- ** newForUri #method:newForUri#

    securityOriginNewForUri                 ,


-- ** ref #method:ref#

#if defined(ENABLE_OVERLOADING)
    SecurityOriginRefMethodInfo             ,
#endif
    securityOriginRef                       ,


-- ** toString #method:toString#

#if defined(ENABLE_OVERLOADING)
    SecurityOriginToStringMethodInfo        ,
#endif
    securityOriginToString                  ,


-- ** unref #method:unref#

#if defined(ENABLE_OVERLOADING)
    SecurityOriginUnrefMethodInfo           ,
#endif
    securityOriginUnref                     ,




    ) 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


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

instance BoxedObject SecurityOrigin where
    boxedType :: SecurityOrigin -> IO GType
boxedType _ = IO GType
c_webkit_security_origin_get_type

-- | Convert 'SecurityOrigin' to and from 'Data.GI.Base.GValue.GValue' with 'Data.GI.Base.GValue.toGValue' and 'Data.GI.Base.GValue.fromGValue'.
instance B.GValue.IsGValue SecurityOrigin where
    toGValue :: SecurityOrigin -> IO GValue
toGValue o :: SecurityOrigin
o = do
        GType
gtype <- IO GType
c_webkit_security_origin_get_type
        SecurityOrigin -> (Ptr SecurityOrigin -> IO GValue) -> IO GValue
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr SecurityOrigin
o (GType
-> (GValue -> Ptr SecurityOrigin -> IO ())
-> Ptr SecurityOrigin
-> IO GValue
forall a. GType -> (GValue -> a -> IO ()) -> a -> IO GValue
B.GValue.buildGValue GType
gtype GValue -> Ptr SecurityOrigin -> IO ()
forall a. GValue -> Ptr a -> IO ()
B.GValue.set_boxed)
        
    fromGValue :: GValue -> IO SecurityOrigin
fromGValue gv :: GValue
gv = do
        Ptr SecurityOrigin
ptr <- GValue -> IO (Ptr SecurityOrigin)
forall b. GValue -> IO (Ptr b)
B.GValue.get_boxed GValue
gv :: IO (Ptr SecurityOrigin)
        (ManagedPtr SecurityOrigin -> SecurityOrigin)
-> Ptr SecurityOrigin -> IO SecurityOrigin
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
B.ManagedPtr.newBoxed ManagedPtr SecurityOrigin -> SecurityOrigin
SecurityOrigin Ptr SecurityOrigin
ptr
        
    

-- | A convenience alias for `Nothing` :: `Maybe` `SecurityOrigin`.
noSecurityOrigin :: Maybe SecurityOrigin
noSecurityOrigin :: Maybe SecurityOrigin
noSecurityOrigin = Maybe SecurityOrigin
forall a. Maybe a
Nothing


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

-- method SecurityOrigin::new
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "protocol"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The protocol for the new origin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "host"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The host for the new origin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "port"
--           , argType = TBasicType TUInt16
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText =
--                     Just
--                       "The port number for the new origin, or 0 to indicate the\n       default port for @protocol"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "WebKit2" , name = "SecurityOrigin" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_security_origin_new" webkit_security_origin_new :: 
    CString ->                              -- protocol : TBasicType TUTF8
    CString ->                              -- host : TBasicType TUTF8
    Word16 ->                               -- port : TBasicType TUInt16
    IO (Ptr SecurityOrigin)

-- | Create a new security origin from the provided protocol, host and
-- port.
-- 
-- /Since: 2.16/
securityOriginNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@protocol@/: The protocol for the new origin
    -> T.Text
    -- ^ /@host@/: The host for the new origin
    -> Word16
    -- ^ /@port@/: The port number for the new origin, or 0 to indicate the
    --        default port for /@protocol@/
    -> m SecurityOrigin
    -- ^ __Returns:__ A t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'.
securityOriginNew :: Text -> Text -> Word16 -> m SecurityOrigin
securityOriginNew protocol :: Text
protocol host :: Text
host port :: Word16
port = IO SecurityOrigin -> m SecurityOrigin
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SecurityOrigin -> m SecurityOrigin)
-> IO SecurityOrigin -> m SecurityOrigin
forall a b. (a -> b) -> a -> b
$ do
    CString
protocol' <- Text -> IO CString
textToCString Text
protocol
    CString
host' <- Text -> IO CString
textToCString Text
host
    Ptr SecurityOrigin
result <- CString -> CString -> Word16 -> IO (Ptr SecurityOrigin)
webkit_security_origin_new CString
protocol' CString
host' Word16
port
    Text -> Ptr SecurityOrigin -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "securityOriginNew" Ptr SecurityOrigin
result
    SecurityOrigin
result' <- ((ManagedPtr SecurityOrigin -> SecurityOrigin)
-> Ptr SecurityOrigin -> IO SecurityOrigin
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SecurityOrigin -> SecurityOrigin
SecurityOrigin) Ptr SecurityOrigin
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
protocol'
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
host'
    SecurityOrigin -> IO SecurityOrigin
forall (m :: * -> *) a. Monad m => a -> m a
return SecurityOrigin
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SecurityOrigin::new_for_uri
-- method type : Constructor
-- Args: [ Arg
--           { argCName = "uri"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "The URI for the new origin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just
--               (TInterface
--                  Name { namespace = "WebKit2" , name = "SecurityOrigin" })
-- throws : False
-- Skip return : False

foreign import ccall "webkit_security_origin_new_for_uri" webkit_security_origin_new_for_uri :: 
    CString ->                              -- uri : TBasicType TUTF8
    IO (Ptr SecurityOrigin)

-- | Create a new security origin from the provided URI. Components of
-- /@uri@/ other than protocol, host, and port do not affect the created
-- t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'.
-- 
-- /Since: 2.16/
securityOriginNewForUri ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    T.Text
    -- ^ /@uri@/: The URI for the new origin
    -> m SecurityOrigin
    -- ^ __Returns:__ A t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'.
securityOriginNewForUri :: Text -> m SecurityOrigin
securityOriginNewForUri uri :: Text
uri = IO SecurityOrigin -> m SecurityOrigin
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SecurityOrigin -> m SecurityOrigin)
-> IO SecurityOrigin -> m SecurityOrigin
forall a b. (a -> b) -> a -> b
$ do
    CString
uri' <- Text -> IO CString
textToCString Text
uri
    Ptr SecurityOrigin
result <- CString -> IO (Ptr SecurityOrigin)
webkit_security_origin_new_for_uri CString
uri'
    Text -> Ptr SecurityOrigin -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "securityOriginNewForUri" Ptr SecurityOrigin
result
    SecurityOrigin
result' <- ((ManagedPtr SecurityOrigin -> SecurityOrigin)
-> Ptr SecurityOrigin -> IO SecurityOrigin
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SecurityOrigin -> SecurityOrigin
SecurityOrigin) Ptr SecurityOrigin
result
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
uri'
    SecurityOrigin -> IO SecurityOrigin
forall (m :: * -> *) a. Monad m => a -> m a
return SecurityOrigin
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method SecurityOrigin::get_host
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "origin"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "SecurityOrigin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitSecurityOrigin"
--                 , 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_security_origin_get_host" webkit_security_origin_get_host :: 
    Ptr SecurityOrigin ->                   -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})
    IO CString

-- | Gets the hostname of /@origin@/, or 'P.Nothing' if /@origin@/ is opaque or if its
-- protocol does not require a host component.
-- 
-- /Since: 2.16/
securityOriginGetHost ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    -- ^ /@origin@/: a t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ The host of the t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
securityOriginGetHost :: SecurityOrigin -> m (Maybe Text)
securityOriginGetHost origin :: SecurityOrigin
origin = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SecurityOrigin
origin' <- SecurityOrigin -> IO (Ptr SecurityOrigin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SecurityOrigin
origin
    CString
result <- Ptr SecurityOrigin -> IO CString
webkit_security_origin_get_host Ptr SecurityOrigin
origin'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    SecurityOrigin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SecurityOrigin
origin
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data SecurityOriginGetHostMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SecurityOriginGetHostMethodInfo SecurityOrigin signature where
    overloadedMethod = securityOriginGetHost

#endif

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

foreign import ccall "webkit_security_origin_get_port" webkit_security_origin_get_port :: 
    Ptr SecurityOrigin ->                   -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})
    IO Word16

-- | Gets the port of /@origin@/. This function will always return 0 if the
-- port is the default port for the given protocol. For example,
-- http:\/\/example.com has the same security origin as
-- http:\/\/example.com:80, and this function will return 0 for a
-- t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' constructed from either URI. It will also
-- return 0 if /@origin@/ is opaque.
-- 
-- /Since: 2.16/
securityOriginGetPort ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    -- ^ /@origin@/: a t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
    -> m Word16
    -- ^ __Returns:__ The port of the t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'.
securityOriginGetPort :: SecurityOrigin -> m Word16
securityOriginGetPort origin :: SecurityOrigin
origin = IO Word16 -> m Word16
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Word16 -> m Word16) -> IO Word16 -> m Word16
forall a b. (a -> b) -> a -> b
$ do
    Ptr SecurityOrigin
origin' <- SecurityOrigin -> IO (Ptr SecurityOrigin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SecurityOrigin
origin
    Word16
result <- Ptr SecurityOrigin -> IO Word16
webkit_security_origin_get_port Ptr SecurityOrigin
origin'
    SecurityOrigin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SecurityOrigin
origin
    Word16 -> IO Word16
forall (m :: * -> *) a. Monad m => a -> m a
return Word16
result

#if defined(ENABLE_OVERLOADING)
data SecurityOriginGetPortMethodInfo
instance (signature ~ (m Word16), MonadIO m) => O.MethodInfo SecurityOriginGetPortMethodInfo SecurityOrigin signature where
    overloadedMethod = securityOriginGetPort

#endif

-- method SecurityOrigin::get_protocol
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "origin"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "SecurityOrigin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitSecurityOrigin"
--                 , 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_security_origin_get_protocol" webkit_security_origin_get_protocol :: 
    Ptr SecurityOrigin ->                   -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})
    IO CString

-- | Gets the protocol of /@origin@/, or 'P.Nothing' if /@origin@/ is opaque.
-- 
-- /Since: 2.16/
securityOriginGetProtocol ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    -- ^ /@origin@/: a t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ The protocol of the t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
securityOriginGetProtocol :: SecurityOrigin -> m (Maybe Text)
securityOriginGetProtocol origin :: SecurityOrigin
origin = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SecurityOrigin
origin' <- SecurityOrigin -> IO (Ptr SecurityOrigin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SecurityOrigin
origin
    CString
result <- Ptr SecurityOrigin -> IO CString
webkit_security_origin_get_protocol Ptr SecurityOrigin
origin'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    SecurityOrigin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SecurityOrigin
origin
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data SecurityOriginGetProtocolMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SecurityOriginGetProtocolMethodInfo SecurityOrigin signature where
    overloadedMethod = securityOriginGetProtocol

#endif

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

foreign import ccall "webkit_security_origin_is_opaque" webkit_security_origin_is_opaque :: 
    Ptr SecurityOrigin ->                   -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})
    IO CInt

-- | Gets whether /@origin@/ is an opaque security origin, which does not
-- possess an associated protocol, host, or port.
-- 
-- /Since: 2.16/
securityOriginIsOpaque ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    -- ^ /@origin@/: a t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
    -> m Bool
    -- ^ __Returns:__ 'P.True' if /@origin@/ is opaque.
securityOriginIsOpaque :: SecurityOrigin -> m Bool
securityOriginIsOpaque origin :: SecurityOrigin
origin = IO Bool -> m Bool
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ do
    Ptr SecurityOrigin
origin' <- SecurityOrigin -> IO (Ptr SecurityOrigin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SecurityOrigin
origin
    CInt
result <- Ptr SecurityOrigin -> IO CInt
webkit_security_origin_is_opaque Ptr SecurityOrigin
origin'
    let result' :: Bool
result' = (CInt -> CInt -> Bool
forall a. Eq a => a -> a -> Bool
/= 0) CInt
result
    SecurityOrigin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SecurityOrigin
origin
    Bool -> IO Bool
forall (m :: * -> *) a. Monad m => a -> m a
return Bool
result'

#if defined(ENABLE_OVERLOADING)
data SecurityOriginIsOpaqueMethodInfo
instance (signature ~ (m Bool), MonadIO m) => O.MethodInfo SecurityOriginIsOpaqueMethodInfo SecurityOrigin signature where
    overloadedMethod = securityOriginIsOpaque

#endif

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

foreign import ccall "webkit_security_origin_ref" webkit_security_origin_ref :: 
    Ptr SecurityOrigin ->                   -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})
    IO (Ptr SecurityOrigin)

-- | Atomically increments the reference count of /@origin@/ by one.
-- This function is MT-safe and may be called from any thread.
-- 
-- /Since: 2.16/
securityOriginRef ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    -- ^ /@origin@/: a t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
    -> m SecurityOrigin
    -- ^ __Returns:__ The passed t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
securityOriginRef :: SecurityOrigin -> m SecurityOrigin
securityOriginRef origin :: SecurityOrigin
origin = IO SecurityOrigin -> m SecurityOrigin
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO SecurityOrigin -> m SecurityOrigin)
-> IO SecurityOrigin -> m SecurityOrigin
forall a b. (a -> b) -> a -> b
$ do
    Ptr SecurityOrigin
origin' <- SecurityOrigin -> IO (Ptr SecurityOrigin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SecurityOrigin
origin
    Ptr SecurityOrigin
result <- Ptr SecurityOrigin -> IO (Ptr SecurityOrigin)
webkit_security_origin_ref Ptr SecurityOrigin
origin'
    Text -> Ptr SecurityOrigin -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL "securityOriginRef" Ptr SecurityOrigin
result
    SecurityOrigin
result' <- ((ManagedPtr SecurityOrigin -> SecurityOrigin)
-> Ptr SecurityOrigin -> IO SecurityOrigin
forall a.
(HasCallStack, BoxedObject a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr SecurityOrigin -> SecurityOrigin
SecurityOrigin) Ptr SecurityOrigin
result
    SecurityOrigin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SecurityOrigin
origin
    SecurityOrigin -> IO SecurityOrigin
forall (m :: * -> *) a. Monad m => a -> m a
return SecurityOrigin
result'

#if defined(ENABLE_OVERLOADING)
data SecurityOriginRefMethodInfo
instance (signature ~ (m SecurityOrigin), MonadIO m) => O.MethodInfo SecurityOriginRefMethodInfo SecurityOrigin signature where
    overloadedMethod = securityOriginRef

#endif

-- method SecurityOrigin::to_string
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "origin"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "SecurityOrigin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a #WebKitSecurityOrigin"
--                 , 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_security_origin_to_string" webkit_security_origin_to_string :: 
    Ptr SecurityOrigin ->                   -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})
    IO CString

-- | Gets a string representation of /@origin@/. The string representation
-- is a valid URI with only protocol, host, and port components. It may
-- be 'P.Nothing', but usually only if /@origin@/ is opaque.
-- 
-- /Since: 2.16/
securityOriginToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    -- ^ /@origin@/: a t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
    -> m (Maybe T.Text)
    -- ^ __Returns:__ a URI representing /@origin@/.
securityOriginToString :: SecurityOrigin -> m (Maybe Text)
securityOriginToString origin :: SecurityOrigin
origin = IO (Maybe Text) -> m (Maybe Text)
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Text) -> m (Maybe Text))
-> IO (Maybe Text) -> m (Maybe Text)
forall a b. (a -> b) -> a -> b
$ do
    Ptr SecurityOrigin
origin' <- SecurityOrigin -> IO (Ptr SecurityOrigin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SecurityOrigin
origin
    CString
result <- Ptr SecurityOrigin -> IO CString
webkit_security_origin_to_string Ptr SecurityOrigin
origin'
    Maybe Text
maybeResult <- CString -> (CString -> IO Text) -> IO (Maybe Text)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull CString
result ((CString -> IO Text) -> IO (Maybe Text))
-> (CString -> IO Text) -> IO (Maybe Text)
forall a b. (a -> b) -> a -> b
$ \result' :: CString
result' -> do
        Text
result'' <- HasCallStack => CString -> IO Text
CString -> IO Text
cstringToText CString
result'
        CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
result'
        Text -> IO Text
forall (m :: * -> *) a. Monad m => a -> m a
return Text
result''
    SecurityOrigin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SecurityOrigin
origin
    Maybe Text -> IO (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
maybeResult

#if defined(ENABLE_OVERLOADING)
data SecurityOriginToStringMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m) => O.MethodInfo SecurityOriginToStringMethodInfo SecurityOrigin signature where
    overloadedMethod = securityOriginToString

#endif

-- method SecurityOrigin::unref
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "origin"
--           , argType =
--               TInterface Name { namespace = "WebKit2" , name = "SecurityOrigin" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "A #WebKitSecurityOrigin"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "webkit_security_origin_unref" webkit_security_origin_unref :: 
    Ptr SecurityOrigin ->                   -- origin : TInterface (Name {namespace = "WebKit2", name = "SecurityOrigin"})
    IO ()

-- | Atomically decrements the reference count of /@origin@/ by one.
-- If the reference count drops to 0, all memory allocated by
-- t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' is released. This function is MT-safe and may be
-- called from any thread.
-- 
-- /Since: 2.16/
securityOriginUnref ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    -- ^ /@origin@/: A t'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'
    -> m ()
securityOriginUnref :: SecurityOrigin -> m ()
securityOriginUnref origin :: SecurityOrigin
origin = IO () -> m ()
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr SecurityOrigin
origin' <- SecurityOrigin -> IO (Ptr SecurityOrigin)
forall a. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr a)
unsafeManagedPtrGetPtr SecurityOrigin
origin
    Ptr SecurityOrigin -> IO ()
webkit_security_origin_unref Ptr SecurityOrigin
origin'
    SecurityOrigin -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr SecurityOrigin
origin
    () -> IO ()
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data SecurityOriginUnrefMethodInfo
instance (signature ~ (m ()), MonadIO m) => O.MethodInfo SecurityOriginUnrefMethodInfo SecurityOrigin signature where
    overloadedMethod = securityOriginUnref

#endif

#if defined(ENABLE_OVERLOADING)
type family ResolveSecurityOriginMethod (t :: Symbol) (o :: *) :: * where
    ResolveSecurityOriginMethod "isOpaque" o = SecurityOriginIsOpaqueMethodInfo
    ResolveSecurityOriginMethod "ref" o = SecurityOriginRefMethodInfo
    ResolveSecurityOriginMethod "toString" o = SecurityOriginToStringMethodInfo
    ResolveSecurityOriginMethod "unref" o = SecurityOriginUnrefMethodInfo
    ResolveSecurityOriginMethod "getHost" o = SecurityOriginGetHostMethodInfo
    ResolveSecurityOriginMethod "getPort" o = SecurityOriginGetPortMethodInfo
    ResolveSecurityOriginMethod "getProtocol" o = SecurityOriginGetProtocolMethodInfo
    ResolveSecurityOriginMethod l o = O.MethodResolutionFailed l o

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

#endif