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

module GI.WebKit2.Structs.SecurityOrigin
    ( 

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


 -- * Methods
-- ** getHost #method:getHost#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    SecurityOriginGetHostMethodInfo         ,
#endif
    securityOriginGetHost                   ,


-- ** getPort #method:getPort#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    SecurityOriginGetPortMethodInfo         ,
#endif
    securityOriginGetPort                   ,


-- ** getProtocol #method:getProtocol#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    SecurityOriginGetProtocolMethodInfo     ,
#endif
    securityOriginGetProtocol               ,


-- ** isOpaque #method:isOpaque#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    SecurityOriginIsOpaqueMethodInfo        ,
#endif
    securityOriginIsOpaque                  ,


-- ** new #method:new#
    securityOriginNew                       ,


-- ** newForUri #method:newForUri#
    securityOriginNewForUri                 ,


-- ** ref #method:ref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    SecurityOriginRefMethodInfo             ,
#endif
    securityOriginRef                       ,


-- ** toString #method:toString#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    SecurityOriginToStringMethodInfo        ,
#endif
    securityOriginToString                  ,


-- ** unref #method:unref#
#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
    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.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


newtype SecurityOrigin = SecurityOrigin (ManagedPtr SecurityOrigin)
foreign import ccall "webkit_security_origin_get_type" c_webkit_security_origin_get_type :: 
    IO GType

instance BoxedObject SecurityOrigin where
    boxedType _ = c_webkit_security_origin_get_type

noSecurityOrigin :: Maybe SecurityOrigin
noSecurityOrigin = Nothing


#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'. -}
securityOriginNew protocol host port = liftIO $ do
    protocol' <- textToCString protocol
    host' <- textToCString host
    result <- webkit_security_origin_new protocol' host' port
    checkUnexpectedReturnNULL "securityOriginNew" result
    result' <- (wrapBoxed SecurityOrigin) result
    freeMem protocol'
    freeMem host'
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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
'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 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'. -}
securityOriginNewForUri uri = liftIO $ do
    uri' <- textToCString uri
    result <- webkit_security_origin_new_for_uri uri'
    checkUnexpectedReturnNULL "securityOriginNewForUri" result
    result' <- (wrapBoxed SecurityOrigin) result
    freeMem uri'
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
#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 '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 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ The host of the 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
securityOriginGetHost origin = liftIO $ do
    origin' <- unsafeManagedPtrGetPtr origin
    result <- webkit_security_origin_get_host origin'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr origin
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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
'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 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
    -> m Word16
    {- ^ __Returns:__ The port of the 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin'. -}
securityOriginGetPort origin = liftIO $ do
    origin' <- unsafeManagedPtrGetPtr origin
    result <- webkit_security_origin_get_port origin'
    touchManagedPtr origin
    return result

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'Nothing' if /@origin@/ is opaque.

@since 2.16
-}
securityOriginGetProtocol ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ The protocol of the 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
securityOriginGetProtocol origin = liftIO $ do
    origin' <- unsafeManagedPtrGetPtr origin
    result <- webkit_security_origin_get_protocol origin'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        return result''
    touchManagedPtr origin
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
    -> m Bool
    {- ^ __Returns:__ 'True' if /@origin@/ is opaque. -}
securityOriginIsOpaque origin = liftIO $ do
    origin' <- unsafeManagedPtrGetPtr origin
    result <- webkit_security_origin_is_opaque origin'
    let result' = (/= 0) result
    touchManagedPtr origin
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
    -> m SecurityOrigin
    {- ^ __Returns:__ The passed 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
securityOriginRef origin = liftIO $ do
    origin' <- unsafeManagedPtrGetPtr origin
    result <- webkit_security_origin_ref origin'
    checkUnexpectedReturnNULL "securityOriginRef" result
    result' <- (wrapBoxed SecurityOrigin) result
    touchManagedPtr origin
    return result'

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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 'Nothing', but usually only if /@origin@/ is opaque.

@since 2.16
-}
securityOriginToString ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    SecurityOrigin
    {- ^ /@origin@/: a 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
    -> m (Maybe T.Text)
    {- ^ __Returns:__ a URI representing /@origin@/. -}
securityOriginToString origin = liftIO $ do
    origin' <- unsafeManagedPtrGetPtr origin
    result <- webkit_security_origin_to_string origin'
    maybeResult <- convertIfNonNull result $ \result' -> do
        result'' <- cstringToText result'
        freeMem result'
        return result''
    touchManagedPtr origin
    return maybeResult

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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
'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 'GI.WebKit2.Structs.SecurityOrigin.SecurityOrigin' -}
    -> m ()
securityOriginUnref origin = liftIO $ do
    origin' <- unsafeManagedPtrGetPtr origin
    webkit_security_origin_unref origin'
    touchManagedPtr origin
    return ()

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

#endif

#if defined(ENABLE_OVERLOADING) && !defined(__HADDOCK_VERSION__)
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) => O.IsLabelProxy t (SecurityOrigin -> p) where
    fromLabelProxy _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)

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

#endif