UDisksPartition

## UDisksPartition UDisksPartition — Generated C code for the org.freedesktop.UDisks2.Partition D-Bus interface |

## Synopsis

                        UDisksPartition;
    struct              UDisksPartitionIface;
    GDBusInterfaceInfo * udisks_partition_interface_info    (void);
    guint               udisks_partition_override_properties
                                                            (GObjectClass *klass,
                                                             guint property_id_begin);
    void                udisks_partition_call_delete        (UDisksPartition *proxy,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            udisks_partition_call_delete_finish (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            udisks_partition_call_delete_sync   (UDisksPartition *proxy,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                udisks_partition_complete_delete    (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);
    void                udisks_partition_call_set_type      (UDisksPartition *proxy,
                                                             const gchar *arg_type,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            udisks_partition_call_set_type_finish
                                                            (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            udisks_partition_call_set_type_sync (UDisksPartition *proxy,
                                                             const gchar *arg_type,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                udisks_partition_complete_set_type  (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);
    void                udisks_partition_call_set_name      (UDisksPartition *proxy,
                                                             const gchar *arg_name,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            udisks_partition_call_set_name_finish
                                                            (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            udisks_partition_call_set_name_sync (UDisksPartition *proxy,
                                                             const gchar *arg_name,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                udisks_partition_complete_set_name  (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);
    void                udisks_partition_call_set_flags     (UDisksPartition *proxy,
                                                             guint64 arg_flags,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    gboolean            udisks_partition_call_set_flags_finish
                                                            (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);
    gboolean            udisks_partition_call_set_flags_sync
                                                            (UDisksPartition *proxy,
                                                             guint64 arg_flags,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                udisks_partition_complete_set_flags (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);
    guint               udisks_partition_get_number         (UDisksPartition *object);
    const gchar *       udisks_partition_get_type_          (UDisksPartition *object);
    guint64             udisks_partition_get_offset         (UDisksPartition *object);
    guint64             udisks_partition_get_size           (UDisksPartition *object);
    guint64             udisks_partition_get_flags          (UDisksPartition *object);
    const gchar *       udisks_partition_get_name           (UDisksPartition *object);
    const gchar *       udisks_partition_get_uuid           (UDisksPartition *object);
    const gchar *       udisks_partition_get_table          (UDisksPartition *object);
    gboolean            udisks_partition_get_is_container   (UDisksPartition *object);
    gboolean            udisks_partition_get_is_contained   (UDisksPartition *object);
    gchar *             udisks_partition_dup_type_          (UDisksPartition *object);
    gchar *             udisks_partition_dup_name           (UDisksPartition *object);
    gchar *             udisks_partition_dup_uuid           (UDisksPartition *object);
    gchar *             udisks_partition_dup_table          (UDisksPartition *object);
    void                udisks_partition_set_number         (UDisksPartition *object,
                                                             guint value);
    void                udisks_partition_set_type_          (UDisksPartition *object,
                                                             const gchar *value);
    void                udisks_partition_set_offset         (UDisksPartition *object,
                                                             guint64 value);
    void                udisks_partition_set_size           (UDisksPartition *object,
                                                             guint64 value);
    void                udisks_partition_set_flags          (UDisksPartition *object,
                                                             guint64 value);
    void                udisks_partition_set_name           (UDisksPartition *object,
                                                             const gchar *value);
    void                udisks_partition_set_uuid           (UDisksPartition *object,
                                                             const gchar *value);
    void                udisks_partition_set_table          (UDisksPartition *object,
                                                             const gchar *value);
    void                udisks_partition_set_is_container   (UDisksPartition *object,
                                                             gboolean value);
    void                udisks_partition_set_is_contained   (UDisksPartition *object,
                                                             gboolean value);
    struct              UDisksPartitionProxy;
    struct              UDisksPartitionProxyClass;
    void                udisks_partition_proxy_new          (GDBusConnection *connection,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    UDisksPartition *   udisks_partition_proxy_new_finish   (GAsyncResult *res,
                                                             GError **error);
    UDisksPartition *   udisks_partition_proxy_new_sync     (GDBusConnection *connection,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GError **error);
    void                udisks_partition_proxy_new_for_bus  (GBusType bus_type,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);
    UDisksPartition *   udisks_partition_proxy_new_for_bus_finish
                                                            (GAsyncResult *res,
                                                             GError **error);
    UDisksPartition *   udisks_partition_proxy_new_for_bus_sync
                                                            (GBusType bus_type,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GError **error);
    struct              UDisksPartitionSkeleton;
    struct              UDisksPartitionSkeletonClass;
    UDisksPartition *   udisks_partition_skeleton_new       (void);

## Object Hierarchy

      GInterface
       +----UDisksPartition

      GObject
       +----GDBusInterfaceSkeleton
             +----UDisksPartitionSkeleton
                   +----UDisksLinuxPartition

## Prerequisites

UDisksPartition requires GObject.

## Implemented Interfaces

UDisksPartitionSkeleton implements GDBusInterface and UDisksPartition.

## Known Implementations

UDisksPartition is implemented by UDisksLinuxPartition and UDisksPartitionSkeleton.

## Description

This section contains code for working with the org.freedesktop.UDisks2.Partition D-Bus interface in C.

## Details

### UDisksPartition

    typedef struct _UDisksPartition UDisksPartition;

Abstract interface type for the D-Bus interface org.freedesktop.UDisks2.Partition.

### struct UDisksPartitionIface

    struct UDisksPartitionIface {
      GTypeInterface parent_iface;

      gboolean (*handle_delete) (
        UDisksPartition *object,
        GDBusMethodInvocation *invocation,
        GVariant *arg_options);

      gboolean (*handle_set_flags) (
        UDisksPartition *object,
        GDBusMethodInvocation *invocation,
        guint64 arg_flags,
        GVariant *arg_options);

      gboolean (*handle_set_name) (
        UDisksPartition *object,
        GDBusMethodInvocation *invocation,
        const gchar *arg_name,
        GVariant *arg_options);

      gboolean (*handle_set_type) (
        UDisksPartition *object,
        GDBusMethodInvocation *invocation,
        const gchar *arg_type,
        GVariant *arg_options);

      guint64  (*get_flags) (UDisksPartition *object);

      gboolean  (*get_is_contained) (UDisksPartition *object);

      gboolean  (*get_is_container) (UDisksPartition *object);

      const gchar * (*get_name) (UDisksPartition *object);

      guint  (*get_number) (UDisksPartition *object);

      guint64  (*get_offset) (UDisksPartition *object);

      guint64  (*get_size) (UDisksPartition *object);

      const gchar * (*get_table) (UDisksPartition *object);

      const gchar * (*get_type_) (UDisksPartition *object);

      const gchar * (*get_uuid) (UDisksPartition *object);
    };

Virtual table for the D-Bus interface org.freedesktop.UDisks2.Partition.

GTypeInterface `parent_iface`; | The parent interface.
`handle_delete` () | Handler for the "handle-delete" signal.
`handle_set_flags` () | Handler for the "handle-set-flags" signal.
`handle_set_name` () | Handler for the "handle-set-name" signal.
`handle_set_type` () | Handler for the "handle-set-type" signal.
`get_flags` () | Getter for the "flags" property.
`get_is_contained` () | Getter for the "is-contained" property.
`get_is_container` () | Getter for the "is-container" property.
`get_name` () | Getter for the "name" property.
`get_number` () | Getter for the "number" property.
`get_offset` () | Getter for the "offset" property.
`get_size` () | Getter for the "size" property.
`get_table` () | Getter for the "table" property.
`get_type_` () | Getter for the "type"- property.
`get_uuid` () | Getter for the "uuid" property.

### udisks_partition_interface_info ()

    GDBusInterfaceInfo * udisks_partition_interface_info    (void);

Gets a machine-readable description of the org.freedesktop.UDisks2.Partition D-Bus interface.

Returns : | A GDBusInterfaceInfo. Do not free. [transfer none]

### udisks_partition_override_properties ()

    guint               udisks_partition_override_properties
                                                            (GObjectClass *klass,
                                                             guint property_id_begin);

Overrides all GObject properties in the UDisksPartition interface for a concrete class. The properties are overridden in the order they are defined.

`klass` : | The class structure for a GObject-derived class.
`property_id_begin` : | The property id to assign to the first overridden property.
Returns : | The last property id.

### udisks_partition_call_delete ()

    void                udisks_partition_call_delete        (UDisksPartition *proxy,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously invokes the `Delete()` D-Bus method on `proxy`. When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call `udisks_partition_call_delete_finish()` to get the result of the operation.

See `udisks_partition_call_delete_sync()` for the synchronous, blocking version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL`.
`user_data` : | User data to pass to `callback`.

### udisks_partition_call_delete_finish ()

    gboolean            udisks_partition_call_delete_finish (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `udisks_partition_call_delete()`.

`proxy` : | A UDisksPartitionProxy.
`res` : | The GAsyncResult obtained from the GAsyncReadyCallback passed to `udisks_partition_call_delete()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_call_delete_sync ()

    gboolean            udisks_partition_call_delete_sync   (UDisksPartition *proxy,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);

Synchronously invokes the `Delete()` D-Bus method on `proxy`. The calling thread is blocked until a reply is received.

See `udisks_partition_call_delete()` for the asynchronous version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_complete_delete ()

    void                udisks_partition_complete_delete    (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the `Delete()` D-Bus method. If you instead want to finish handling an invocation by returning an error, use `g_dbus_method_invocation_return_error()` or similar.

This method will free `invocation`, you cannot use it afterwards.

`object` : | A UDisksPartition.
`invocation` : | A GDBusMethodInvocation. [transfer full]

### udisks_partition_call_set_type ()

    void                udisks_partition_call_set_type      (UDisksPartition *proxy,
                                                             const gchar *arg_type,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously invokes the `SetType()` D-Bus method on `proxy`. When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call `udisks_partition_call_set_type_finish()` to get the result of the operation.

See `udisks_partition_call_set_type_sync()` for the synchronous, blocking version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_type` : | Argument to pass with the method invocation.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL`.
`user_data` : | User data to pass to `callback`.

### udisks_partition_call_set_type_finish ()

    gboolean            udisks_partition_call_set_type_finish
                                                            (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `udisks_partition_call_set_type()`.

`proxy` : | A UDisksPartitionProxy.
`res` : | The GAsyncResult obtained from the GAsyncReadyCallback passed to `udisks_partition_call_set_type()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_call_set_type_sync ()

    gboolean            udisks_partition_call_set_type_sync (UDisksPartition *proxy,
                                                             const gchar *arg_type,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);

Synchronously invokes the `SetType()` D-Bus method on `proxy`. The calling thread is blocked until a reply is received.

See `udisks_partition_call_set_type()` for the asynchronous version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_type` : | Argument to pass with the method invocation.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_complete_set_type ()

    void                udisks_partition_complete_set_type  (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the `SetType()` D-Bus method. If you instead want to finish handling an invocation by returning an error, use `g_dbus_method_invocation_return_error()` or similar.

This method will free `invocation`, you cannot use it afterwards.

`object` : | A UDisksPartition.
`invocation` : | A GDBusMethodInvocation. [transfer full]

### udisks_partition_call_set_name ()

    void                udisks_partition_call_set_name      (UDisksPartition *proxy,
                                                             const gchar *arg_name,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously invokes the `SetName()` D-Bus method on `proxy`. When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call `udisks_partition_call_set_name_finish()` to get the result of the operation.

See `udisks_partition_call_set_name_sync()` for the synchronous, blocking version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_name` : | Argument to pass with the method invocation.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL`.
`user_data` : | User data to pass to `callback`.

### udisks_partition_call_set_name_finish ()

    gboolean            udisks_partition_call_set_name_finish
                                                            (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `udisks_partition_call_set_name()`.

`proxy` : | A UDisksPartitionProxy.
`res` : | The GAsyncResult obtained from the GAsyncReadyCallback passed to `udisks_partition_call_set_name()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_call_set_name_sync ()

    gboolean            udisks_partition_call_set_name_sync (UDisksPartition *proxy,
                                                             const gchar *arg_name,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);

Synchronously invokes the `SetName()` D-Bus method on `proxy`. The calling thread is blocked until a reply is received.

See `udisks_partition_call_set_name()` for the asynchronous version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_name` : | Argument to pass with the method invocation.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_complete_set_name ()

    void                udisks_partition_complete_set_name  (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the `SetName()` D-Bus method. If you instead want to finish handling an invocation by returning an error, use `g_dbus_method_invocation_return_error()` or similar.

This method will free `invocation`, you cannot use it afterwards.

`object` : | A UDisksPartition.
`invocation` : | A GDBusMethodInvocation. [transfer full]

### udisks_partition_call_set_flags ()

    void                udisks_partition_call_set_flags     (UDisksPartition *proxy,
                                                             guint64 arg_flags,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously invokes the `SetFlags()` D-Bus method on `proxy`. When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call `udisks_partition_call_set_flags_finish()` to get the result of the operation.

See `udisks_partition_call_set_flags_sync()` for the synchronous, blocking version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_flags` : | Argument to pass with the method invocation.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`callback` : | A GAsyncReadyCallback to call when the request is satisfied or `NULL`.
`user_data` : | User data to pass to `callback`.

### udisks_partition_call_set_flags_finish ()

    gboolean            udisks_partition_call_set_flags_finish
                                                            (UDisksPartition *proxy,
                                                             GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `udisks_partition_call_set_flags()`.

`proxy` : | A UDisksPartitionProxy.
`res` : | The GAsyncResult obtained from the GAsyncReadyCallback passed to `udisks_partition_call_set_flags()`.
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_call_set_flags_sync ()

    gboolean            udisks_partition_call_set_flags_sync
                                                            (UDisksPartition *proxy,
                                                             guint64 arg_flags,
                                                             GVariant *arg_options,
                                                             GCancellable *cancellable,
                                                             GError **error);

Synchronously invokes the `SetFlags()` D-Bus method on `proxy`. The calling thread is blocked until a reply is received.

See `udisks_partition_call_set_flags()` for the asynchronous version of this method.

`proxy` : | A UDisksPartitionProxy.
`arg_flags` : | Argument to pass with the method invocation.
`arg_options` : | Argument to pass with the method invocation.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`error` : | Return location for error or `NULL`.
Returns : | `TRUE` if the call succeded, `FALSE` if `error` is set. [skip]

### udisks_partition_complete_set_flags ()

    void                udisks_partition_complete_set_flags (UDisksPartition *object,
                                                             GDBusMethodInvocation *invocation);

Helper function used in service implementations to finish handling invocations of the `SetFlags()` D-Bus method. If you instead want to finish handling an invocation by returning an error, use `g_dbus_method_invocation_return_error()` or similar.

This method will free `invocation`, you cannot use it afterwards.

`object` : | A UDisksPartition.
`invocation` : | A GDBusMethodInvocation. [transfer full]

### udisks_partition_get_number ()

    guint               udisks_partition_get_number         (UDisksPartition *object);

Gets the value of the "Number" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value.

### udisks_partition_get_type_ ()

    const gchar *       udisks_partition_get_type_          (UDisksPartition *object);

Gets the value of the "Type" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

### Warning

The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where `object` was constructed. Use `udisks_partition_dup_type_()` if on another thread.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. Do not free the returned value, it belongs to `object`. [transfer none]

### udisks_partition_get_offset ()

    guint64             udisks_partition_get_offset         (UDisksPartition *object);

Gets the value of the "Offset" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value.

### udisks_partition_get_size ()

    guint64             udisks_partition_get_size           (UDisksPartition *object);

Gets the value of the "Size" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value.

### udisks_partition_get_flags ()

    guint64             udisks_partition_get_flags          (UDisksPartition *object);

Gets the value of the "Flags" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value.

### udisks_partition_get_name ()

    const gchar *       udisks_partition_get_name           (UDisksPartition *object);

Gets the value of the "Name" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

### Warning

The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where `object` was constructed. Use `udisks_partition_dup_name()` if on another thread.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. Do not free the returned value, it belongs to `object`. [transfer none]

### udisks_partition_get_uuid ()

    const gchar *       udisks_partition_get_uuid           (UDisksPartition *object);

Gets the value of the "UUID" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

### Warning

The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where `object` was constructed. Use `udisks_partition_dup_uuid()` if on another thread.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. Do not free the returned value, it belongs to `object`. [transfer none]

### udisks_partition_get_table ()

    const gchar *       udisks_partition_get_table          (UDisksPartition *object);

Gets the value of the "Table" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

### Warning

The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where `object` was constructed. Use `udisks_partition_dup_table()` if on another thread.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. Do not free the returned value, it belongs to `object`. [transfer none]

### udisks_partition_get_is_container ()

    gboolean            udisks_partition_get_is_container   (UDisksPartition *object);

Gets the value of the "IsContainer" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value.

### udisks_partition_get_is_contained ()

    gboolean            udisks_partition_get_is_contained   (UDisksPartition *object);

Gets the value of the "IsContained" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value.

### udisks_partition_dup_type_ ()

    gchar *             udisks_partition_dup_type_          (UDisksPartition *object);

Gets a copy of the "Type" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. The returned value should be freed with `g_free()`. [transfer full]

### udisks_partition_dup_name ()

    gchar *             udisks_partition_dup_name           (UDisksPartition *object);

Gets a copy of the "Name" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. The returned value should be freed with `g_free()`. [transfer full]

### udisks_partition_dup_uuid ()

    gchar *             udisks_partition_dup_uuid           (UDisksPartition *object);

Gets a copy of the "UUID" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. The returned value should be freed with `g_free()`. [transfer full]

### udisks_partition_dup_table ()

    gchar *             udisks_partition_dup_table          (UDisksPartition *object);

Gets a copy of the "Table" D-Bus property.

Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.

`object` : | A UDisksPartition.
Returns : | The property value or `NULL` if the property is not set. The returned value should be freed with `g_free()`. [transfer full]

### udisks_partition_set_number ()

    void                udisks_partition_set_number         (UDisksPartition *object,
                                                             guint value);

Sets the "Number" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_type_ ()

    void                udisks_partition_set_type_          (UDisksPartition *object,
                                                             const gchar *value);

Sets the "Type" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_offset ()

    void                udisks_partition_set_offset         (UDisksPartition *object,
                                                             guint64 value);

Sets the "Offset" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_size ()

    void                udisks_partition_set_size           (UDisksPartition *object,
                                                             guint64 value);

Sets the "Size" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_flags ()

    void                udisks_partition_set_flags          (UDisksPartition *object,
                                                             guint64 value);

Sets the "Flags" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_name ()

    void                udisks_partition_set_name           (UDisksPartition *object,
                                                             const gchar *value);

Sets the "Name" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_uuid ()

    void                udisks_partition_set_uuid           (UDisksPartition *object,
                                                             const gchar *value);

Sets the "UUID" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_table ()

    void                udisks_partition_set_table          (UDisksPartition *object,
                                                             const gchar *value);

Sets the "Table" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_is_container ()

    void                udisks_partition_set_is_container   (UDisksPartition *object,
                                                             gboolean value);

Sets the "IsContainer" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### udisks_partition_set_is_contained ()

    void                udisks_partition_set_is_contained   (UDisksPartition *object,
                                                             gboolean value);

Sets the "IsContained" D-Bus property to `value`.

Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.

`object` : | A UDisksPartition.
`value` : | The value to set.

### struct UDisksPartitionProxy

    struct UDisksPartitionProxy {
    };

The UDisksPartitionProxy structure contains only private data and should only be accessed using the provided API.

### struct UDisksPartitionProxyClass

    struct UDisksPartitionProxyClass {
      GDBusProxyClass parent_class;
    };

Class structure for UDisksPartitionProxy.

GDBusProxyClass `parent_class`; | The parent class.

### udisks_partition_proxy_new ()

    void                udisks_partition_proxy_new          (GDBusConnection *connection,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Asynchronously creates a proxy for the D-Bus interface org.freedesktop.UDisks2.Partition. See `g_dbus_proxy_new()` for more details.

When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call `udisks_partition_proxy_new_finish()` to get the result of the operation.

See `udisks_partition_proxy_new_sync()` for the synchronous, blocking version of this constructor.

`connection` : | A GDBusConnection.
`flags` : | Flags from the GDBusProxyFlags enumeration.
`name` : | A bus name (well-known or unique) or `NULL` if `connection` is not a message bus connection. [allow-none]
`object_path` : | An object path.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`callback` : | A GAsyncReadyCallback to call when the request is satisfied.
`user_data` : | User data to pass to `callback`.

### udisks_partition_proxy_new_finish ()

    UDisksPartition *   udisks_partition_proxy_new_finish   (GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `udisks_partition_proxy_new()`.

`res` : | The GAsyncResult obtained from the GAsyncReadyCallback passed to `udisks_partition_proxy_new()`.
`error` : | Return location for error or `NULL`
Returns : | The constructed proxy object or `NULL` if `error` is set. [transfer full][type UDisksPartitionProxy]

### udisks_partition_proxy_new_sync ()

    UDisksPartition *   udisks_partition_proxy_new_sync     (GDBusConnection *connection,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GError **error);

Synchronously creates a proxy for the D-Bus interface org.freedesktop.UDisks2.Partition. See `g_dbus_proxy_new_sync()` for more details.

The calling thread is blocked until a reply is received.

See `udisks_partition_proxy_new()` for the asynchronous version of this constructor.

`connection` : | A GDBusConnection.
`flags` : | Flags from the GDBusProxyFlags enumeration.
`name` : | A bus name (well-known or unique) or `NULL` if `connection` is not a message bus connection. [allow-none]
`object_path` : | An object path.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`error` : | Return location for error or `NULL`
Returns : | The constructed proxy object or `NULL` if `error` is set. [transfer full][type UDisksPartitionProxy]

### udisks_partition_proxy_new_for_bus ()

    void                udisks_partition_proxy_new_for_bus  (GBusType bus_type,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GAsyncReadyCallback callback,
                                                             gpointer user_data);

Like `udisks_partition_proxy_new()` but takes a GBusType instead of a GDBusConnection.

When the operation is finished, `callback` will be invoked in the thread-default main loop of the thread you are calling this method from. You can then call `udisks_partition_proxy_new_for_bus_finish()` to get the result of the operation.

See `udisks_partition_proxy_new_for_bus_sync()` for the synchronous, blocking version of this constructor.

`bus_type` : | A GBusType.
`flags` : | Flags from the GDBusProxyFlags enumeration.
`name` : | A bus name (well-known or unique).
`object_path` : | An object path.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`callback` : | A GAsyncReadyCallback to call when the request is satisfied.
`user_data` : | User data to pass to `callback`.

### udisks_partition_proxy_new_for_bus_finish ()

    UDisksPartition *   udisks_partition_proxy_new_for_bus_finish
                                                            (GAsyncResult *res,
                                                             GError **error);

Finishes an operation started with `udisks_partition_proxy_new_for_bus()`.

`res` : | The GAsyncResult obtained from the GAsyncReadyCallback passed to `udisks_partition_proxy_new_for_bus()`.
`error` : | Return location for error or `NULL`
Returns : | The constructed proxy object or `NULL` if `error` is set. [transfer full][type UDisksPartitionProxy]

### udisks_partition_proxy_new_for_bus_sync ()

    UDisksPartition *   udisks_partition_proxy_new_for_bus_sync
                                                            (GBusType bus_type,
                                                             GDBusProxyFlags flags,
                                                             const gchar *name,
                                                             const gchar *object_path,
                                                             GCancellable *cancellable,
                                                             GError **error);

Like `udisks_partition_proxy_new_sync()` but takes a GBusType instead of a GDBusConnection.

The calling thread is blocked until a reply is received.

See `udisks_partition_proxy_new_for_bus()` for the asynchronous version of this constructor.

`bus_type` : | A GBusType.
`flags` : | Flags from the GDBusProxyFlags enumeration.
`name` : | A bus name (well-known or unique).
`object_path` : | An object path.
`cancellable` : | A GCancellable or `NULL`. [allow-none]
`error` : | Return location for error or `NULL`
Returns : | The constructed proxy object or `NULL` if `error` is set. [transfer full][type UDisksPartitionProxy]

### struct UDisksPartitionSkeleton

    struct UDisksPartitionSkeleton;

The UDisksPartitionSkeleton structure contains only private data and should only be accessed using the provided API.

### struct UDisksPartitionSkeletonClass

    struct UDisksPartitionSkeletonClass {
      GDBusInterfaceSkeletonClass parent_class;
    };

Class structure for UDisksPartitionSkeleton.

GDBusInterfaceSkeletonClass `parent_class`; | The parent class.

### udisks_partition_skeleton_new ()

    UDisksPartition *   udisks_partition_skeleton_new       (void);

Creates a skeleton object for the D-Bus interface org.freedesktop.UDisks2.Partition.

Returns : | The skeleton object. [transfer full][type UDisksPartitionSkeleton]