{-# LANGUAGE TypeApplications #-}


-- | Copyright  : Will Thompson and Iñaki García Etxebarria
-- License    : LGPL-2.1
-- Maintainer : Iñaki García Etxebarria
-- 
-- @JsonBuilder@ provides an object for generating a JSON tree.
-- 
-- The root of the JSON tree can be either a [struct/@json@/.Object] or a [struct/@json@/.Array].
-- Thus the first call must necessarily be either
-- 'GI.Json.Objects.Builder.builderBeginObject' or 'GI.Json.Objects.Builder.builderBeginArray'.
-- 
-- For convenience to language bindings, most @JsonBuilder@ method return the
-- instance, making it easy to chain function calls.
-- 
-- == Using @JsonBuilder@
-- 
-- 
-- === /c code/
-- >g_autoptr(JsonBuilder) builder = json_builder_new ();
-- >
-- >json_builder_begin_object (builder);
-- >
-- >json_builder_set_member_name (builder, "url");
-- >json_builder_add_string_value (builder, "http://www.gnome.org/img/flash/two-thirty.png");
-- >
-- >json_builder_set_member_name (builder, "size");
-- >json_builder_begin_array (builder);
-- >json_builder_add_int_value (builder, 652);
-- >json_builder_add_int_value (builder, 242);
-- >json_builder_end_array (builder);
-- >
-- >json_builder_end_object (builder);
-- >
-- >g_autoptr(JsonNode) root root = json_builder_get_root (builder);
-- >
-- >g_autoptr(JsonGenerator) gen = json_generator_new ();
-- >json_generator_set_root (gen, root);
-- >g_autofree char *str = json_generator_to_data (gen, NULL);
-- >
-- >// str now contains the following JSON data
-- >// { "url" : "http://www.gnome.org/img/flash/two-thirty.png", "size" : [ 652, 242 ] }
-- 

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

module GI.Json.Objects.Builder
    ( 

-- * Exported types
    Builder(..)                             ,
    IsBuilder                               ,
    toBuilder                               ,


 -- * Methods
-- | 
-- 
--  === __Click to display all available methods, including inherited ones__
-- ==== Methods
-- [addBooleanValue]("GI.Json.Objects.Builder#g:method:addBooleanValue"), [addDoubleValue]("GI.Json.Objects.Builder#g:method:addDoubleValue"), [addIntValue]("GI.Json.Objects.Builder#g:method:addIntValue"), [addNullValue]("GI.Json.Objects.Builder#g:method:addNullValue"), [addStringValue]("GI.Json.Objects.Builder#g:method:addStringValue"), [addValue]("GI.Json.Objects.Builder#g:method:addValue"), [beginArray]("GI.Json.Objects.Builder#g:method:beginArray"), [beginObject]("GI.Json.Objects.Builder#g:method:beginObject"), [bindProperty]("GI.GObject.Objects.Object#g:method:bindProperty"), [bindPropertyFull]("GI.GObject.Objects.Object#g:method:bindPropertyFull"), [endArray]("GI.Json.Objects.Builder#g:method:endArray"), [endObject]("GI.Json.Objects.Builder#g:method:endObject"), [forceFloating]("GI.GObject.Objects.Object#g:method:forceFloating"), [freezeNotify]("GI.GObject.Objects.Object#g:method:freezeNotify"), [getv]("GI.GObject.Objects.Object#g:method:getv"), [isFloating]("GI.GObject.Objects.Object#g:method:isFloating"), [notify]("GI.GObject.Objects.Object#g:method:notify"), [notifyByPspec]("GI.GObject.Objects.Object#g:method:notifyByPspec"), [ref]("GI.GObject.Objects.Object#g:method:ref"), [refSink]("GI.GObject.Objects.Object#g:method:refSink"), [reset]("GI.Json.Objects.Builder#g:method:reset"), [runDispose]("GI.GObject.Objects.Object#g:method:runDispose"), [stealData]("GI.GObject.Objects.Object#g:method:stealData"), [stealQdata]("GI.GObject.Objects.Object#g:method:stealQdata"), [thawNotify]("GI.GObject.Objects.Object#g:method:thawNotify"), [unref]("GI.GObject.Objects.Object#g:method:unref"), [watchClosure]("GI.GObject.Objects.Object#g:method:watchClosure").
-- 
-- ==== Getters
-- [getData]("GI.GObject.Objects.Object#g:method:getData"), [getProperty]("GI.GObject.Objects.Object#g:method:getProperty"), [getQdata]("GI.GObject.Objects.Object#g:method:getQdata"), [getRoot]("GI.Json.Objects.Builder#g:method:getRoot").
-- 
-- ==== Setters
-- [setData]("GI.GObject.Objects.Object#g:method:setData"), [setDataFull]("GI.GObject.Objects.Object#g:method:setDataFull"), [setMemberName]("GI.Json.Objects.Builder#g:method:setMemberName"), [setProperty]("GI.GObject.Objects.Object#g:method:setProperty").

#if defined(ENABLE_OVERLOADING)
    ResolveBuilderMethod                    ,
#endif

-- ** addBooleanValue #method:addBooleanValue#

#if defined(ENABLE_OVERLOADING)
    BuilderAddBooleanValueMethodInfo        ,
#endif
    builderAddBooleanValue                  ,


-- ** addDoubleValue #method:addDoubleValue#

#if defined(ENABLE_OVERLOADING)
    BuilderAddDoubleValueMethodInfo         ,
#endif
    builderAddDoubleValue                   ,


-- ** addIntValue #method:addIntValue#

#if defined(ENABLE_OVERLOADING)
    BuilderAddIntValueMethodInfo            ,
#endif
    builderAddIntValue                      ,


-- ** addNullValue #method:addNullValue#

#if defined(ENABLE_OVERLOADING)
    BuilderAddNullValueMethodInfo           ,
#endif
    builderAddNullValue                     ,


-- ** addStringValue #method:addStringValue#

#if defined(ENABLE_OVERLOADING)
    BuilderAddStringValueMethodInfo         ,
#endif
    builderAddStringValue                   ,


-- ** addValue #method:addValue#

#if defined(ENABLE_OVERLOADING)
    BuilderAddValueMethodInfo               ,
#endif
    builderAddValue                         ,


-- ** beginArray #method:beginArray#

#if defined(ENABLE_OVERLOADING)
    BuilderBeginArrayMethodInfo             ,
#endif
    builderBeginArray                       ,


-- ** beginObject #method:beginObject#

#if defined(ENABLE_OVERLOADING)
    BuilderBeginObjectMethodInfo            ,
#endif
    builderBeginObject                      ,


-- ** endArray #method:endArray#

#if defined(ENABLE_OVERLOADING)
    BuilderEndArrayMethodInfo               ,
#endif
    builderEndArray                         ,


-- ** endObject #method:endObject#

#if defined(ENABLE_OVERLOADING)
    BuilderEndObjectMethodInfo              ,
#endif
    builderEndObject                        ,


-- ** getRoot #method:getRoot#

#if defined(ENABLE_OVERLOADING)
    BuilderGetRootMethodInfo                ,
#endif
    builderGetRoot                          ,


-- ** new #method:new#

    builderNew                              ,


-- ** newImmutable #method:newImmutable#

    builderNewImmutable                     ,


-- ** reset #method:reset#

#if defined(ENABLE_OVERLOADING)
    BuilderResetMethodInfo                  ,
#endif
    builderReset                            ,


-- ** setMemberName #method:setMemberName#

#if defined(ENABLE_OVERLOADING)
    BuilderSetMemberNameMethodInfo          ,
#endif
    builderSetMemberName                    ,




 -- * Properties


-- ** immutable #attr:immutable#
-- | Whether the tree should be immutable when created.
-- 
-- Making the output immutable on creation avoids the expense
-- of traversing it to make it immutable later.
-- 
-- /Since: 1.2/

#if defined(ENABLE_OVERLOADING)
    BuilderImmutablePropertyInfo            ,
#endif
#if defined(ENABLE_OVERLOADING)
    builderImmutable                        ,
#endif
    constructBuilderImmutable               ,
    getBuilderImmutable                     ,




    ) 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.GHashTable as B.GHT
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.Coerce as Coerce
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 qualified GI.GObject.Objects.Object as GObject.Object
import {-# SOURCE #-} qualified GI.Json.Structs.Node as Json.Node

-- | Memory-managed wrapper type.
newtype Builder = Builder (SP.ManagedPtr Builder)
    deriving (Builder -> Builder -> Bool
(Builder -> Builder -> Bool)
-> (Builder -> Builder -> Bool) -> Eq Builder
forall a. (a -> a -> Bool) -> (a -> a -> Bool) -> Eq a
$c== :: Builder -> Builder -> Bool
== :: Builder -> Builder -> Bool
$c/= :: Builder -> Builder -> Bool
/= :: Builder -> Builder -> Bool
Eq)

instance SP.ManagedPtrNewtype Builder where
    toManagedPtr :: Builder -> ManagedPtr Builder
toManagedPtr (Builder ManagedPtr Builder
p) = ManagedPtr Builder
p

foreign import ccall "json_builder_get_type"
    c_json_builder_get_type :: IO B.Types.GType

instance B.Types.TypedObject Builder where
    glibType :: IO GType
glibType = IO GType
c_json_builder_get_type

instance B.Types.GObject Builder

-- | Type class for types which can be safely cast to `Builder`, for instance with `toBuilder`.
class (SP.GObject o, O.IsDescendantOf Builder o) => IsBuilder o
instance (SP.GObject o, O.IsDescendantOf Builder o) => IsBuilder o

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

-- | Cast to `Builder`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toBuilder :: (MIO.MonadIO m, IsBuilder o) => o -> m Builder
toBuilder :: forall (m :: * -> *) o. (MonadIO m, IsBuilder o) => o -> m Builder
toBuilder = IO Builder -> m Builder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Builder -> m Builder) -> (o -> IO Builder) -> o -> m Builder
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (ManagedPtr Builder -> Builder) -> o -> IO Builder
forall o o'.
(HasCallStack, ManagedPtrNewtype o, TypedObject o,
 ManagedPtrNewtype o', TypedObject o') =>
(ManagedPtr o' -> o') -> o -> IO o'
B.ManagedPtr.unsafeCastTo ManagedPtr Builder -> Builder
Builder

-- | Convert 'Builder' 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 Builder) where
    gvalueGType_ :: IO GType
gvalueGType_ = IO GType
c_json_builder_get_type
    gvalueSet_ :: Ptr GValue -> Maybe Builder -> IO ()
gvalueSet_ Ptr GValue
gv Maybe Builder
P.Nothing = Ptr GValue -> Ptr Builder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv (Ptr Builder
forall a. Ptr a
FP.nullPtr :: FP.Ptr Builder)
    gvalueSet_ Ptr GValue
gv (P.Just Builder
obj) = Builder -> (Ptr Builder -> IO ()) -> IO ()
forall a c.
(HasCallStack, ManagedPtrNewtype a) =>
a -> (Ptr a -> IO c) -> IO c
B.ManagedPtr.withManagedPtr Builder
obj (Ptr GValue -> Ptr Builder -> IO ()
forall a. GObject a => Ptr GValue -> Ptr a -> IO ()
B.GValue.set_object Ptr GValue
gv)
    gvalueGet_ :: Ptr GValue -> IO (Maybe Builder)
gvalueGet_ Ptr GValue
gv = do
        Ptr Builder
ptr <- Ptr GValue -> IO (Ptr Builder)
forall a. GObject a => Ptr GValue -> IO (Ptr a)
B.GValue.get_object Ptr GValue
gv :: IO (FP.Ptr Builder)
        if Ptr Builder
ptr Ptr Builder -> Ptr Builder -> Bool
forall a. Eq a => a -> a -> Bool
/= Ptr Builder
forall a. Ptr a
FP.nullPtr
        then Builder -> Maybe Builder
forall a. a -> Maybe a
P.Just (Builder -> Maybe Builder) -> IO Builder -> IO (Maybe Builder)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> (ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
B.ManagedPtr.newObject ManagedPtr Builder -> Builder
Builder Ptr Builder
ptr
        else Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
forall a. Maybe a
P.Nothing
        
    

#if defined(ENABLE_OVERLOADING)
type family ResolveBuilderMethod (t :: Symbol) (o :: *) :: * where
    ResolveBuilderMethod "addBooleanValue" o = BuilderAddBooleanValueMethodInfo
    ResolveBuilderMethod "addDoubleValue" o = BuilderAddDoubleValueMethodInfo
    ResolveBuilderMethod "addIntValue" o = BuilderAddIntValueMethodInfo
    ResolveBuilderMethod "addNullValue" o = BuilderAddNullValueMethodInfo
    ResolveBuilderMethod "addStringValue" o = BuilderAddStringValueMethodInfo
    ResolveBuilderMethod "addValue" o = BuilderAddValueMethodInfo
    ResolveBuilderMethod "beginArray" o = BuilderBeginArrayMethodInfo
    ResolveBuilderMethod "beginObject" o = BuilderBeginObjectMethodInfo
    ResolveBuilderMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
    ResolveBuilderMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
    ResolveBuilderMethod "endArray" o = BuilderEndArrayMethodInfo
    ResolveBuilderMethod "endObject" o = BuilderEndObjectMethodInfo
    ResolveBuilderMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
    ResolveBuilderMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
    ResolveBuilderMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
    ResolveBuilderMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
    ResolveBuilderMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
    ResolveBuilderMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
    ResolveBuilderMethod "ref" o = GObject.Object.ObjectRefMethodInfo
    ResolveBuilderMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
    ResolveBuilderMethod "reset" o = BuilderResetMethodInfo
    ResolveBuilderMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
    ResolveBuilderMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
    ResolveBuilderMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
    ResolveBuilderMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
    ResolveBuilderMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
    ResolveBuilderMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
    ResolveBuilderMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
    ResolveBuilderMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
    ResolveBuilderMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
    ResolveBuilderMethod "getRoot" o = BuilderGetRootMethodInfo
    ResolveBuilderMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
    ResolveBuilderMethod "setDataFull" o = GObject.Object.ObjectSetDataFullMethodInfo
    ResolveBuilderMethod "setMemberName" o = BuilderSetMemberNameMethodInfo
    ResolveBuilderMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
    ResolveBuilderMethod l o = O.MethodResolutionFailed l o

instance (info ~ ResolveBuilderMethod t Builder, O.OverloadedMethod info Builder p) => OL.IsLabel t (Builder -> 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 ~ ResolveBuilderMethod t Builder, O.OverloadedMethod info Builder p, R.HasField t Builder p) => R.HasField t Builder p where
    getField = O.overloadedMethod @info

#endif

instance (info ~ ResolveBuilderMethod t Builder, O.OverloadedMethodInfo info Builder) => OL.IsLabel t (O.MethodProxy info Builder) where
#if MIN_VERSION_base(4,10,0)
    fromLabel = O.MethodProxy
#else
    fromLabel _ = O.MethodProxy
#endif

#endif

-- VVV Prop "immutable"
   -- Type: TBasicType TBoolean
   -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
   -- Nullable: (Nothing,Nothing)

-- | Get the value of the “@immutable@” property.
-- When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
-- 
-- @
-- 'Data.GI.Base.Attributes.get' builder #immutable
-- @
getBuilderImmutable :: (MonadIO m, IsBuilder o) => o -> m Bool
getBuilderImmutable :: forall (m :: * -> *) o. (MonadIO m, IsBuilder o) => o -> m Bool
getBuilderImmutable o
obj = IO Bool -> m Bool
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO Bool -> m Bool) -> IO Bool -> m Bool
forall a b. (a -> b) -> a -> b
$ o -> String -> IO Bool
forall a. GObject a => a -> String -> IO Bool
B.Properties.getObjectPropertyBool o
obj String
"immutable"

-- | Construct a `GValueConstruct` with valid value for the “@immutable@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
constructBuilderImmutable :: (IsBuilder o, MIO.MonadIO m) => Bool -> m (GValueConstruct o)
constructBuilderImmutable :: forall o (m :: * -> *).
(IsBuilder o, MonadIO m) =>
Bool -> m (GValueConstruct o)
constructBuilderImmutable Bool
val = IO (GValueConstruct o) -> m (GValueConstruct o)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> m (GValueConstruct o))
-> IO (GValueConstruct o) -> m (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ do
    IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a. IO a -> IO a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
MIO.liftIO (IO (GValueConstruct o) -> IO (GValueConstruct o))
-> IO (GValueConstruct o) -> IO (GValueConstruct o)
forall a b. (a -> b) -> a -> b
$ String -> Bool -> IO (GValueConstruct o)
forall o. String -> Bool -> IO (GValueConstruct o)
B.Properties.constructObjectPropertyBool String
"immutable" Bool
val

#if defined(ENABLE_OVERLOADING)
data BuilderImmutablePropertyInfo
instance AttrInfo BuilderImmutablePropertyInfo where
    type AttrAllowedOps BuilderImmutablePropertyInfo = '[ 'AttrConstruct, 'AttrGet]
    type AttrBaseTypeConstraint BuilderImmutablePropertyInfo = IsBuilder
    type AttrSetTypeConstraint BuilderImmutablePropertyInfo = (~) Bool
    type AttrTransferTypeConstraint BuilderImmutablePropertyInfo = (~) Bool
    type AttrTransferType BuilderImmutablePropertyInfo = Bool
    type AttrGetType BuilderImmutablePropertyInfo = Bool
    type AttrLabel BuilderImmutablePropertyInfo = "immutable"
    type AttrOrigin BuilderImmutablePropertyInfo = Builder
    attrGet = getBuilderImmutable
    attrSet = undefined
    attrTransfer _ v = do
        return v
    attrConstruct = constructBuilderImmutable
    attrClear = undefined
    dbgAttrInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.immutable"
        , O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#g:attr:immutable"
        })
#endif

#if defined(ENABLE_OVERLOADING)
instance O.HasAttributeList Builder
type instance O.AttributeList Builder = BuilderAttributeList
type BuilderAttributeList = ('[ '("immutable", BuilderImmutablePropertyInfo)] :: [(Symbol, *)])
#endif

#if defined(ENABLE_OVERLOADING)
builderImmutable :: AttrLabelProxy "immutable"
builderImmutable = AttrLabelProxy

#endif

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

#endif

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

foreign import ccall "json_builder_new" json_builder_new :: 
    IO (Ptr Builder)

-- | Creates a new @JsonBuilder@.
-- 
-- You can use this object to generate a JSON tree and obtain the root node.
builderNew ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Builder
    -- ^ __Returns:__ the newly created builder instance
builderNew :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Builder
builderNew  = IO Builder -> m Builder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Builder -> m Builder) -> IO Builder -> m Builder
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
result <- IO (Ptr Builder)
json_builder_new
    Text -> Ptr Builder -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"builderNew" Ptr Builder
result
    Builder
result' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result
    Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result'

#if defined(ENABLE_OVERLOADING)
#endif

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

foreign import ccall "json_builder_new_immutable" json_builder_new_immutable :: 
    IO (Ptr Builder)

-- | Creates a new, immutable @JsonBuilder@ instance.
-- 
-- It is equivalent to setting the [Builder:immutable]("GI.Json.Objects.Builder#g:attr:immutable") property
-- set to @TRUE@ at construction time.
-- 
-- /Since: 1.2/
builderNewImmutable ::
    (B.CallStack.HasCallStack, MonadIO m) =>
    m Builder
    -- ^ __Returns:__ the newly create builder instance
builderNewImmutable :: forall (m :: * -> *). (HasCallStack, MonadIO m) => m Builder
builderNewImmutable  = IO Builder -> m Builder
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO Builder -> m Builder) -> IO Builder -> m Builder
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
result <- IO (Ptr Builder)
json_builder_new_immutable
    Text -> Ptr Builder -> IO ()
forall a. HasCallStack => Text -> Ptr a -> IO ()
checkUnexpectedReturnNULL Text
"builderNewImmutable" Ptr Builder
result
    Builder
result' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
wrapObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result
    Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result'

#if defined(ENABLE_OVERLOADING)
#endif

-- method Builder::add_boolean_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Builder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TBoolean
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the member or element"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Builder" })
-- throws : False
-- Skip return : False

foreign import ccall "json_builder_add_boolean_value" json_builder_add_boolean_value :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    CInt ->                                 -- value : TBasicType TBoolean
    IO (Ptr Builder)

-- | Adds a boolean value to the currently open object member or array.
-- 
-- If called after 'GI.Json.Objects.Builder.builderSetMemberName', sets the given value
-- as the value of the current member in the open object; otherwise, the value
-- is appended to the elements of the open array.
-- 
-- See also: 'GI.Json.Objects.Builder.builderAddValue'
builderAddBooleanValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> Bool
    -- ^ /@value@/: the value of the member or element
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderAddBooleanValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> Bool -> m (Maybe Builder)
builderAddBooleanValue a
builder Bool
value = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    let value' :: CInt
value' = (Int -> CInt
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Int -> CInt) -> (Bool -> Int) -> Bool -> CInt
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Bool -> Int
forall a. Enum a => a -> Int
fromEnum) Bool
value
    Ptr Builder
result <- Ptr Builder -> CInt -> IO (Ptr Builder)
json_builder_add_boolean_value Ptr Builder
builder' CInt
value'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderAddBooleanValueMethodInfo
instance (signature ~ (Bool -> m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderAddBooleanValueMethodInfo a signature where
    overloadedMethod = builderAddBooleanValue

instance O.OverloadedMethodInfo BuilderAddBooleanValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderAddBooleanValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderAddBooleanValue"
        })


#endif

-- method Builder::add_double_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Builder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TDouble
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the member or element"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Builder" })
-- throws : False
-- Skip return : False

foreign import ccall "json_builder_add_double_value" json_builder_add_double_value :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    CDouble ->                              -- value : TBasicType TDouble
    IO (Ptr Builder)

-- | Adds a floating point value to the currently open object member or array.
-- 
-- If called after 'GI.Json.Objects.Builder.builderSetMemberName', sets the given value
-- as the value of the current member in the open object; otherwise, the value
-- is appended to the elements of the open array.
-- 
-- See also: 'GI.Json.Objects.Builder.builderAddValue'
builderAddDoubleValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> Double
    -- ^ /@value@/: the value of the member or element
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderAddDoubleValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> Double -> m (Maybe Builder)
builderAddDoubleValue a
builder Double
value = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    let value' :: CDouble
value' = Double -> CDouble
forall a b. (Real a, Fractional b) => a -> b
realToFrac Double
value
    Ptr Builder
result <- Ptr Builder -> CDouble -> IO (Ptr Builder)
json_builder_add_double_value Ptr Builder
builder' CDouble
value'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderAddDoubleValueMethodInfo
instance (signature ~ (Double -> m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderAddDoubleValueMethodInfo a signature where
    overloadedMethod = builderAddDoubleValue

instance O.OverloadedMethodInfo BuilderAddDoubleValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderAddDoubleValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderAddDoubleValue"
        })


#endif

-- method Builder::add_int_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Builder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TInt64
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the member or element"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Builder" })
-- throws : False
-- Skip return : False

foreign import ccall "json_builder_add_int_value" json_builder_add_int_value :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    Int64 ->                                -- value : TBasicType TInt64
    IO (Ptr Builder)

-- | Adds an integer value to the currently open object member or array.
-- 
-- If called after 'GI.Json.Objects.Builder.builderSetMemberName', sets the given value
-- as the value of the current member in the open object; otherwise, the value
-- is appended to the elements of the open array.
-- 
-- See also: 'GI.Json.Objects.Builder.builderAddValue'
builderAddIntValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> Int64
    -- ^ /@value@/: the value of the member or element
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderAddIntValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> Int64 -> m (Maybe Builder)
builderAddIntValue a
builder Int64
value = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Builder
result <- Ptr Builder -> Int64 -> IO (Ptr Builder)
json_builder_add_int_value Ptr Builder
builder' Int64
value
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderAddIntValueMethodInfo
instance (signature ~ (Int64 -> m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderAddIntValueMethodInfo a signature where
    overloadedMethod = builderAddIntValue

instance O.OverloadedMethodInfo BuilderAddIntValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderAddIntValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderAddIntValue"
        })


#endif

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

foreign import ccall "json_builder_add_null_value" json_builder_add_null_value :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    IO (Ptr Builder)

-- | Adds a null value to the currently open object member or array.
-- 
-- If called after 'GI.Json.Objects.Builder.builderSetMemberName', sets the given value
-- as the value of the current member in the open object; otherwise, the value
-- is appended to the elements of the open array.
-- 
-- See also: 'GI.Json.Objects.Builder.builderAddValue'
builderAddNullValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderAddNullValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> m (Maybe Builder)
builderAddNullValue a
builder = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Builder
result <- Ptr Builder -> IO (Ptr Builder)
json_builder_add_null_value Ptr Builder
builder'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderAddNullValueMethodInfo
instance (signature ~ (m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderAddNullValueMethodInfo a signature where
    overloadedMethod = builderAddNullValue

instance O.OverloadedMethodInfo BuilderAddNullValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderAddNullValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderAddNullValue"
        })


#endif

-- method Builder::add_string_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Builder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "value"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the member or element"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Builder" })
-- throws : False
-- Skip return : False

foreign import ccall "json_builder_add_string_value" json_builder_add_string_value :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    CString ->                              -- value : TBasicType TUTF8
    IO (Ptr Builder)

-- | Adds a boolean value to the currently open object member or array.
-- 
-- If called after 'GI.Json.Objects.Builder.builderSetMemberName', sets the given value
-- as the value of the current member in the open object; otherwise, the value
-- is appended to the elements of the open array.
-- 
-- See also: 'GI.Json.Objects.Builder.builderAddValue'
builderAddStringValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> T.Text
    -- ^ /@value@/: the value of the member or element
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderAddStringValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> Text -> m (Maybe Builder)
builderAddStringValue a
builder Text
value = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    CString
value' <- Text -> IO CString
textToCString Text
value
    Ptr Builder
result <- Ptr Builder -> CString -> IO (Ptr Builder)
json_builder_add_string_value Ptr Builder
builder' CString
value'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
value'
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderAddStringValueMethodInfo
instance (signature ~ (T.Text -> m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderAddStringValueMethodInfo a signature where
    overloadedMethod = builderAddStringValue

instance O.OverloadedMethodInfo BuilderAddStringValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderAddStringValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderAddStringValue"
        })


#endif

-- method Builder::add_value
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Builder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "node"
--           , argType = TInterface Name { namespace = "Json" , name = "Node" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the value of the member or element"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferEverything
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Builder" })
-- throws : False
-- Skip return : False

foreign import ccall "json_builder_add_value" json_builder_add_value :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    Ptr Json.Node.Node ->                   -- node : TInterface (Name {namespace = "Json", name = "Node"})
    IO (Ptr Builder)

-- | Adds a value to the currently open object member or array.
-- 
-- If called after 'GI.Json.Objects.Builder.builderSetMemberName', sets the given node
-- as the value of the current member in the open object; otherwise, the node
-- is appended to the elements of the open array.
-- 
-- The builder will take ownership of the node.
builderAddValue ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> Json.Node.Node
    -- ^ /@node@/: the value of the member or element
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderAddValue :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> Node -> m (Maybe Builder)
builderAddValue a
builder Node
node = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Node
node' <- Node -> IO (Ptr Node)
forall a. (HasCallStack, GBoxed a) => a -> IO (Ptr a)
B.ManagedPtr.disownBoxed Node
node
    Ptr Builder
result <- Ptr Builder -> Ptr Node -> IO (Ptr Builder)
json_builder_add_value Ptr Builder
builder' Ptr Node
node'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Node -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr Node
node
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderAddValueMethodInfo
instance (signature ~ (Json.Node.Node -> m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderAddValueMethodInfo a signature where
    overloadedMethod = builderAddValue

instance O.OverloadedMethodInfo BuilderAddValueMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderAddValue",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderAddValue"
        })


#endif

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

foreign import ccall "json_builder_begin_array" json_builder_begin_array :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    IO (Ptr Builder)

-- | Opens an array inside the given builder.
-- 
-- You can add a new element to the array by using 'GI.Json.Objects.Builder.builderAddValue'.
-- 
-- Once you added all elements to the array, you must call
-- 'GI.Json.Objects.Builder.builderEndArray' to close the array.
builderBeginArray ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderBeginArray :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> m (Maybe Builder)
builderBeginArray a
builder = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Builder
result <- Ptr Builder -> IO (Ptr Builder)
json_builder_begin_array Ptr Builder
builder'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderBeginArrayMethodInfo
instance (signature ~ (m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderBeginArrayMethodInfo a signature where
    overloadedMethod = builderBeginArray

instance O.OverloadedMethodInfo BuilderBeginArrayMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderBeginArray",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderBeginArray"
        })


#endif

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

foreign import ccall "json_builder_begin_object" json_builder_begin_object :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    IO (Ptr Builder)

-- | Opens an object inside the given builder.
-- 
-- You can add a new member to the object by using 'GI.Json.Objects.Builder.builderSetMemberName',
-- followed by 'GI.Json.Objects.Builder.builderAddValue'.
-- 
-- Once you added all members to the object, you must call 'GI.Json.Objects.Builder.builderEndObject'
-- to close the object.
-- 
-- If the builder is in an inconsistent state, this function will return @NULL@.
builderBeginObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderBeginObject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> m (Maybe Builder)
builderBeginObject a
builder = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Builder
result <- Ptr Builder -> IO (Ptr Builder)
json_builder_begin_object Ptr Builder
builder'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderBeginObjectMethodInfo
instance (signature ~ (m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderBeginObjectMethodInfo a signature where
    overloadedMethod = builderBeginObject

instance O.OverloadedMethodInfo BuilderBeginObjectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderBeginObject",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderBeginObject"
        })


#endif

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

foreign import ccall "json_builder_end_array" json_builder_end_array :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    IO (Ptr Builder)

-- | Closes the array inside the given builder that was opened by the most
-- recent call to 'GI.Json.Objects.Builder.builderBeginArray'.
-- 
-- This function cannot be called after 'GI.Json.Objects.Builder.builderSetMemberName'.
builderEndArray ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderEndArray :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> m (Maybe Builder)
builderEndArray a
builder = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Builder
result <- Ptr Builder -> IO (Ptr Builder)
json_builder_end_array Ptr Builder
builder'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderEndArrayMethodInfo
instance (signature ~ (m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderEndArrayMethodInfo a signature where
    overloadedMethod = builderEndArray

instance O.OverloadedMethodInfo BuilderEndArrayMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderEndArray",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderEndArray"
        })


#endif

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

foreign import ccall "json_builder_end_object" json_builder_end_object :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    IO (Ptr Builder)

-- | Closes the object inside the given builder that was opened by the most
-- recent call to 'GI.Json.Objects.Builder.builderBeginObject'.
-- 
-- This function cannot be called after 'GI.Json.Objects.Builder.builderSetMemberName'.
builderEndObject ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderEndObject :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> m (Maybe Builder)
builderEndObject a
builder = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Builder
result <- Ptr Builder -> IO (Ptr Builder)
json_builder_end_object Ptr Builder
builder'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderEndObjectMethodInfo
instance (signature ~ (m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderEndObjectMethodInfo a signature where
    overloadedMethod = builderEndObject

instance O.OverloadedMethodInfo BuilderEndObjectMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderEndObject",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderEndObject"
        })


#endif

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

foreign import ccall "json_builder_get_root" json_builder_get_root :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    IO (Ptr Json.Node.Node)

-- | Returns the root of the currently constructed tree.
-- 
-- if the build is incomplete (ie: if there are any opened objects, or any
-- open object members and array elements) then this function will return
-- @NULL@.
builderGetRoot ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> m (Maybe Json.Node.Node)
    -- ^ __Returns:__ the root node
builderGetRoot :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> m (Maybe Node)
builderGetRoot a
builder = IO (Maybe Node) -> m (Maybe Node)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Node) -> m (Maybe Node))
-> IO (Maybe Node) -> m (Maybe Node)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Node
result <- Ptr Builder -> IO (Ptr Node)
json_builder_get_root Ptr Builder
builder'
    Maybe Node
maybeResult <- Ptr Node -> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Node
result ((Ptr Node -> IO Node) -> IO (Maybe Node))
-> (Ptr Node -> IO Node) -> IO (Maybe Node)
forall a b. (a -> b) -> a -> b
$ \Ptr Node
result' -> do
        Node
result'' <- ((ManagedPtr Node -> Node) -> Ptr Node -> IO Node
forall a.
(HasCallStack, GBoxed a) =>
(ManagedPtr a -> a) -> Ptr a -> IO a
wrapBoxed ManagedPtr Node -> Node
Json.Node.Node) Ptr Node
result'
        Node -> IO Node
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Node
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    Maybe Node -> IO (Maybe Node)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Node
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderGetRootMethodInfo
instance (signature ~ (m (Maybe Json.Node.Node)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderGetRootMethodInfo a signature where
    overloadedMethod = builderGetRoot

instance O.OverloadedMethodInfo BuilderGetRootMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderGetRoot",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderGetRoot"
        })


#endif

-- method Builder::reset
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Builder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Nothing
-- throws : False
-- Skip return : False

foreign import ccall "json_builder_reset" json_builder_reset :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    IO ()

-- | Resets the state of the builder back to its initial state.
builderReset ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> m ()
builderReset :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> m ()
builderReset a
builder = IO () -> m ()
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO () -> m ()) -> IO () -> m ()
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    Ptr Builder -> IO ()
json_builder_reset Ptr Builder
builder'
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    () -> IO ()
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return ()

#if defined(ENABLE_OVERLOADING)
data BuilderResetMethodInfo
instance (signature ~ (m ()), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderResetMethodInfo a signature where
    overloadedMethod = builderReset

instance O.OverloadedMethodInfo BuilderResetMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderReset",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderReset"
        })


#endif

-- method Builder::set_member_name
-- method type : OrdinaryMethod
-- Args: [ Arg
--           { argCName = "builder"
--           , argType =
--               TInterface Name { namespace = "Json" , name = "Builder" }
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "a builder" , sinceVersion = Nothing }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       , Arg
--           { argCName = "member_name"
--           , argType = TBasicType TUTF8
--           , direction = DirectionIn
--           , mayBeNull = False
--           , argDoc =
--               Documentation
--                 { rawDocText = Just "the name of the member"
--                 , sinceVersion = Nothing
--                 }
--           , argScope = ScopeTypeInvalid
--           , argClosure = -1
--           , argDestroy = -1
--           , argCallerAllocates = False
--           , transfer = TransferNothing
--           }
--       ]
-- Lengths: []
-- returnType: Just (TInterface Name { namespace = "Json" , name = "Builder" })
-- throws : False
-- Skip return : False

foreign import ccall "json_builder_set_member_name" json_builder_set_member_name :: 
    Ptr Builder ->                          -- builder : TInterface (Name {namespace = "Json", name = "Builder"})
    CString ->                              -- member_name : TBasicType TUTF8
    IO (Ptr Builder)

-- | Sets the name of the member in an object.
-- 
-- This function must be followed by of these functions:
-- 
--  - 'GI.Json.Objects.Builder.builderAddValue', to add a scalar value to the member
--  - 'GI.Json.Objects.Builder.builderBeginObject', to add an object to the member
--  - 'GI.Json.Objects.Builder.builderBeginArray', to add an array to the member
-- 
-- This function can only be called within an open object.
builderSetMemberName ::
    (B.CallStack.HasCallStack, MonadIO m, IsBuilder a) =>
    a
    -- ^ /@builder@/: a builder
    -> T.Text
    -- ^ /@memberName@/: the name of the member
    -> m (Maybe Builder)
    -- ^ __Returns:__ the builder instance
builderSetMemberName :: forall (m :: * -> *) a.
(HasCallStack, MonadIO m, IsBuilder a) =>
a -> Text -> m (Maybe Builder)
builderSetMemberName a
builder Text
memberName = IO (Maybe Builder) -> m (Maybe Builder)
forall a. IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO (Maybe Builder) -> m (Maybe Builder))
-> IO (Maybe Builder) -> m (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ do
    Ptr Builder
builder' <- a -> IO (Ptr Builder)
forall a b. (HasCallStack, ManagedPtrNewtype a) => a -> IO (Ptr b)
unsafeManagedPtrCastPtr a
builder
    CString
memberName' <- Text -> IO CString
textToCString Text
memberName
    Ptr Builder
result <- Ptr Builder -> CString -> IO (Ptr Builder)
json_builder_set_member_name Ptr Builder
builder' CString
memberName'
    Maybe Builder
maybeResult <- Ptr Builder -> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. Ptr a -> (Ptr a -> IO b) -> IO (Maybe b)
convertIfNonNull Ptr Builder
result ((Ptr Builder -> IO Builder) -> IO (Maybe Builder))
-> (Ptr Builder -> IO Builder) -> IO (Maybe Builder)
forall a b. (a -> b) -> a -> b
$ \Ptr Builder
result' -> do
        Builder
result'' <- ((ManagedPtr Builder -> Builder) -> Ptr Builder -> IO Builder
forall a b.
(HasCallStack, GObject a, GObject b) =>
(ManagedPtr a -> a) -> Ptr b -> IO a
newObject ManagedPtr Builder -> Builder
Builder) Ptr Builder
result'
        Builder -> IO Builder
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Builder
result''
    a -> IO ()
forall a. ManagedPtrNewtype a => a -> IO ()
touchManagedPtr a
builder
    CString -> IO ()
forall a. Ptr a -> IO ()
freeMem CString
memberName'
    Maybe Builder -> IO (Maybe Builder)
forall a. a -> IO a
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Builder
maybeResult

#if defined(ENABLE_OVERLOADING)
data BuilderSetMemberNameMethodInfo
instance (signature ~ (T.Text -> m (Maybe Builder)), MonadIO m, IsBuilder a) => O.OverloadedMethod BuilderSetMemberNameMethodInfo a signature where
    overloadedMethod = builderSetMemberName

instance O.OverloadedMethodInfo BuilderSetMemberNameMethodInfo a where
    overloadedMethodInfo = P.Just (O.ResolvedSymbolInfo {
        O.resolvedSymbolName = "GI.Json.Objects.Builder.builderSetMemberName",
        O.resolvedSymbolURL = "https://hackage.haskell.org/package/gi-json-1.0.3/docs/GI-Json-Objects-Builder.html#v:builderSetMemberName"
        })


#endif