mirror of
https://gitlab.gnome.org/GNOME/glib.git
synced 2024-11-15 05:46:15 +01:00
3bf4a720c3
Sub-directories inside gio/ already processed in a previous commit: - fam/ - gdbus-2.0/ (which contains only codegen/) - gvdb/ - inotify/ - tests/ - win32/ - xdgmime/ Other sub-directories inside gio/: - completion/: no license headers - kqueue/: not LGPL, BSD-style license https://bugzilla.gnome.org/show_bug.cgi?id=776504
2703 lines
69 KiB
C
2703 lines
69 KiB
C
/* GIO - GLib Input, Output and Streaming Library
|
|
*
|
|
* Copyright (C) 2006-2007 Red Hat, Inc.
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General
|
|
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
* Author: Alexander Larsson <alexl@redhat.com>
|
|
*/
|
|
|
|
/**
|
|
* SECTION:gfileinfo
|
|
* @short_description: File Information and Attributes
|
|
* @include: gio/gio.h
|
|
* @see_also: #GFile, [GFileAttribute][gio-GFileAttribute]
|
|
*
|
|
* Functionality for manipulating basic metadata for files. #GFileInfo
|
|
* implements methods for getting information that all files should
|
|
* contain, and allows for manipulation of extended attributes.
|
|
*
|
|
* See [GFileAttribute][gio-GFileAttribute] for more information on how
|
|
* GIO handles file attributes.
|
|
*
|
|
* To obtain a #GFileInfo for a #GFile, use g_file_query_info() (or its
|
|
* async variant). To obtain a #GFileInfo for a file input or output
|
|
* stream, use g_file_input_stream_query_info() or
|
|
* g_file_output_stream_query_info() (or their async variants).
|
|
*
|
|
* To change the actual attributes of a file, you should then set the
|
|
* attribute in the #GFileInfo and call g_file_set_attributes_from_info()
|
|
* or g_file_set_attributes_async() on a GFile.
|
|
*
|
|
* However, not all attributes can be changed in the file. For instance,
|
|
* the actual size of a file cannot be changed via g_file_info_set_size().
|
|
* You may call g_file_query_settable_attributes() and
|
|
* g_file_query_writable_namespaces() to discover the settable attributes
|
|
* of a particular file at runtime.
|
|
*
|
|
* #GFileAttributeMatcher allows for searching through a #GFileInfo for
|
|
* attributes.
|
|
**/
|
|
|
|
#include "config.h"
|
|
|
|
#include <string.h>
|
|
|
|
#include "gfileinfo.h"
|
|
#include "gfileinfo-priv.h"
|
|
#include "gfileattribute-priv.h"
|
|
#include "gicon.h"
|
|
#include "glibintl.h"
|
|
|
|
|
|
/* We use this nasty thing, because NULL is a valid attribute matcher (matches nothing) */
|
|
#define NO_ATTRIBUTE_MASK ((GFileAttributeMatcher *)1)
|
|
|
|
typedef struct {
|
|
guint32 attribute;
|
|
GFileAttributeValue value;
|
|
} GFileAttribute;
|
|
|
|
struct _GFileInfo
|
|
{
|
|
GObject parent_instance;
|
|
|
|
GArray *attributes;
|
|
GFileAttributeMatcher *mask;
|
|
};
|
|
|
|
struct _GFileInfoClass
|
|
{
|
|
GObjectClass parent_class;
|
|
};
|
|
|
|
|
|
G_DEFINE_TYPE (GFileInfo, g_file_info, G_TYPE_OBJECT)
|
|
|
|
typedef struct {
|
|
guint32 id;
|
|
guint32 attribute_id_counter;
|
|
} NSInfo;
|
|
|
|
G_LOCK_DEFINE_STATIC (attribute_hash);
|
|
static int namespace_id_counter = 0;
|
|
static GHashTable *ns_hash = NULL;
|
|
static GHashTable *attribute_hash = NULL;
|
|
static char ***attributes = NULL;
|
|
|
|
/* Attribute ids are 32bit, we split it up like this:
|
|
* |------------|--------------------|
|
|
* 12 bit 20 bit
|
|
* namespace attribute id
|
|
*
|
|
* This way the attributes gets sorted in namespace order
|
|
*/
|
|
|
|
#define NS_POS 20
|
|
#define NS_MASK ((guint32)((1<<12) - 1))
|
|
#define ID_POS 0
|
|
#define ID_MASK ((guint32)((1<<20) - 1))
|
|
|
|
#define GET_NS(_attr_id) \
|
|
(((guint32) (_attr_id) >> NS_POS) & NS_MASK)
|
|
#define GET_ID(_attr_id) \
|
|
(((guint32)(_attr_id) >> ID_POS) & ID_MASK)
|
|
|
|
#define MAKE_ATTR_ID(_ns, _id) \
|
|
( ((((guint32) _ns) & NS_MASK) << NS_POS) | \
|
|
((((guint32) _id) & ID_MASK) << ID_POS) )
|
|
|
|
static NSInfo *
|
|
_lookup_namespace (const char *namespace)
|
|
{
|
|
NSInfo *ns_info;
|
|
|
|
ns_info = g_hash_table_lookup (ns_hash, namespace);
|
|
if (ns_info == NULL)
|
|
{
|
|
ns_info = g_new0 (NSInfo, 1);
|
|
ns_info->id = ++namespace_id_counter;
|
|
g_hash_table_insert (ns_hash, g_strdup (namespace), ns_info);
|
|
attributes = g_realloc (attributes, (ns_info->id + 1) * sizeof (char **));
|
|
attributes[ns_info->id] = g_new (char *, 1);
|
|
attributes[ns_info->id][0] = g_strconcat (namespace, "::*", NULL);
|
|
}
|
|
return ns_info;
|
|
}
|
|
|
|
static guint32
|
|
_lookup_attribute (const char *attribute)
|
|
{
|
|
guint32 attr_id, id;
|
|
char *ns;
|
|
const char *colon;
|
|
NSInfo *ns_info;
|
|
|
|
attr_id = GPOINTER_TO_UINT (g_hash_table_lookup (attribute_hash, attribute));
|
|
|
|
if (attr_id != 0)
|
|
return attr_id;
|
|
|
|
colon = strstr (attribute, "::");
|
|
if (colon)
|
|
ns = g_strndup (attribute, colon - attribute);
|
|
else
|
|
ns = g_strdup ("");
|
|
|
|
ns_info = _lookup_namespace (ns);
|
|
g_free (ns);
|
|
|
|
id = ++ns_info->attribute_id_counter;
|
|
attributes[ns_info->id] = g_realloc (attributes[ns_info->id], (id + 1) * sizeof (char *));
|
|
attributes[ns_info->id][id] = g_strdup (attribute);
|
|
|
|
attr_id = MAKE_ATTR_ID (ns_info->id, id);
|
|
|
|
g_hash_table_insert (attribute_hash, attributes[ns_info->id][id], GUINT_TO_POINTER (attr_id));
|
|
|
|
return attr_id;
|
|
}
|
|
|
|
static void
|
|
ensure_attribute_hash (void)
|
|
{
|
|
if (attribute_hash != NULL)
|
|
return;
|
|
|
|
ns_hash = g_hash_table_new (g_str_hash, g_str_equal);
|
|
attribute_hash = g_hash_table_new (g_str_hash, g_str_equal);
|
|
|
|
#define REGISTER_ATTRIBUTE(name) G_STMT_START{\
|
|
guint _u = _lookup_attribute (G_FILE_ATTRIBUTE_ ## name); \
|
|
/* use for generating the ID: g_print ("#define G_FILE_ATTRIBUTE_ID_%s (%u + %u)\n", #name + 17, _u & ~ID_MASK, _u & ID_MASK); */ \
|
|
g_assert (_u == G_FILE_ATTRIBUTE_ID_ ## name); \
|
|
}G_STMT_END
|
|
|
|
REGISTER_ATTRIBUTE (STANDARD_TYPE);
|
|
REGISTER_ATTRIBUTE (STANDARD_IS_HIDDEN);
|
|
REGISTER_ATTRIBUTE (STANDARD_IS_BACKUP);
|
|
REGISTER_ATTRIBUTE (STANDARD_IS_SYMLINK);
|
|
REGISTER_ATTRIBUTE (STANDARD_IS_VIRTUAL);
|
|
REGISTER_ATTRIBUTE (STANDARD_NAME);
|
|
REGISTER_ATTRIBUTE (STANDARD_DISPLAY_NAME);
|
|
REGISTER_ATTRIBUTE (STANDARD_EDIT_NAME);
|
|
REGISTER_ATTRIBUTE (STANDARD_COPY_NAME);
|
|
REGISTER_ATTRIBUTE (STANDARD_DESCRIPTION);
|
|
REGISTER_ATTRIBUTE (STANDARD_ICON);
|
|
REGISTER_ATTRIBUTE (STANDARD_CONTENT_TYPE);
|
|
REGISTER_ATTRIBUTE (STANDARD_FAST_CONTENT_TYPE);
|
|
REGISTER_ATTRIBUTE (STANDARD_SIZE);
|
|
REGISTER_ATTRIBUTE (STANDARD_ALLOCATED_SIZE);
|
|
REGISTER_ATTRIBUTE (STANDARD_SYMLINK_TARGET);
|
|
REGISTER_ATTRIBUTE (STANDARD_TARGET_URI);
|
|
REGISTER_ATTRIBUTE (STANDARD_SORT_ORDER);
|
|
REGISTER_ATTRIBUTE (STANDARD_SYMBOLIC_ICON);
|
|
REGISTER_ATTRIBUTE (STANDARD_IS_VOLATILE);
|
|
REGISTER_ATTRIBUTE (ETAG_VALUE);
|
|
REGISTER_ATTRIBUTE (ID_FILE);
|
|
REGISTER_ATTRIBUTE (ID_FILESYSTEM);
|
|
REGISTER_ATTRIBUTE (ACCESS_CAN_READ);
|
|
REGISTER_ATTRIBUTE (ACCESS_CAN_WRITE);
|
|
REGISTER_ATTRIBUTE (ACCESS_CAN_EXECUTE);
|
|
REGISTER_ATTRIBUTE (ACCESS_CAN_DELETE);
|
|
REGISTER_ATTRIBUTE (ACCESS_CAN_TRASH);
|
|
REGISTER_ATTRIBUTE (ACCESS_CAN_RENAME);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_CAN_MOUNT);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_CAN_UNMOUNT);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_CAN_EJECT);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_UNIX_DEVICE);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_UNIX_DEVICE_FILE);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_HAL_UDI);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_CAN_START);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_CAN_START_DEGRADED);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_CAN_STOP);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_START_STOP_TYPE);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_CAN_POLL);
|
|
REGISTER_ATTRIBUTE (MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC);
|
|
REGISTER_ATTRIBUTE (TIME_MODIFIED);
|
|
REGISTER_ATTRIBUTE (TIME_MODIFIED_USEC);
|
|
REGISTER_ATTRIBUTE (TIME_ACCESS);
|
|
REGISTER_ATTRIBUTE (TIME_ACCESS_USEC);
|
|
REGISTER_ATTRIBUTE (TIME_CHANGED);
|
|
REGISTER_ATTRIBUTE (TIME_CHANGED_USEC);
|
|
REGISTER_ATTRIBUTE (TIME_CREATED);
|
|
REGISTER_ATTRIBUTE (TIME_CREATED_USEC);
|
|
REGISTER_ATTRIBUTE (UNIX_DEVICE);
|
|
REGISTER_ATTRIBUTE (UNIX_INODE);
|
|
REGISTER_ATTRIBUTE (UNIX_MODE);
|
|
REGISTER_ATTRIBUTE (UNIX_NLINK);
|
|
REGISTER_ATTRIBUTE (UNIX_UID);
|
|
REGISTER_ATTRIBUTE (UNIX_GID);
|
|
REGISTER_ATTRIBUTE (UNIX_RDEV);
|
|
REGISTER_ATTRIBUTE (UNIX_BLOCK_SIZE);
|
|
REGISTER_ATTRIBUTE (UNIX_BLOCKS);
|
|
REGISTER_ATTRIBUTE (UNIX_IS_MOUNTPOINT);
|
|
REGISTER_ATTRIBUTE (DOS_IS_ARCHIVE);
|
|
REGISTER_ATTRIBUTE (DOS_IS_SYSTEM);
|
|
REGISTER_ATTRIBUTE (OWNER_USER);
|
|
REGISTER_ATTRIBUTE (OWNER_USER_REAL);
|
|
REGISTER_ATTRIBUTE (OWNER_GROUP);
|
|
REGISTER_ATTRIBUTE (THUMBNAIL_PATH);
|
|
REGISTER_ATTRIBUTE (THUMBNAILING_FAILED);
|
|
REGISTER_ATTRIBUTE (THUMBNAIL_IS_VALID);
|
|
REGISTER_ATTRIBUTE (PREVIEW_ICON);
|
|
REGISTER_ATTRIBUTE (FILESYSTEM_SIZE);
|
|
REGISTER_ATTRIBUTE (FILESYSTEM_FREE);
|
|
REGISTER_ATTRIBUTE (FILESYSTEM_TYPE);
|
|
REGISTER_ATTRIBUTE (FILESYSTEM_READONLY);
|
|
REGISTER_ATTRIBUTE (FILESYSTEM_USE_PREVIEW);
|
|
REGISTER_ATTRIBUTE (GVFS_BACKEND);
|
|
REGISTER_ATTRIBUTE (SELINUX_CONTEXT);
|
|
REGISTER_ATTRIBUTE (TRASH_ITEM_COUNT);
|
|
REGISTER_ATTRIBUTE (TRASH_ORIG_PATH);
|
|
REGISTER_ATTRIBUTE (TRASH_DELETION_DATE);
|
|
|
|
#undef REGISTER_ATTRIBUTE
|
|
}
|
|
|
|
static guint32
|
|
lookup_namespace (const char *namespace)
|
|
{
|
|
NSInfo *ns_info;
|
|
guint32 id;
|
|
|
|
G_LOCK (attribute_hash);
|
|
|
|
ensure_attribute_hash ();
|
|
|
|
ns_info = _lookup_namespace (namespace);
|
|
id = 0;
|
|
if (ns_info)
|
|
id = ns_info->id;
|
|
|
|
G_UNLOCK (attribute_hash);
|
|
|
|
return id;
|
|
}
|
|
|
|
static char *
|
|
get_attribute_for_id (int attribute)
|
|
{
|
|
char *s;
|
|
G_LOCK (attribute_hash);
|
|
s = attributes[GET_NS(attribute)][GET_ID(attribute)];
|
|
G_UNLOCK (attribute_hash);
|
|
return s;
|
|
}
|
|
|
|
static guint32
|
|
lookup_attribute (const char *attribute)
|
|
{
|
|
guint32 attr_id;
|
|
|
|
G_LOCK (attribute_hash);
|
|
ensure_attribute_hash ();
|
|
|
|
attr_id = _lookup_attribute (attribute);
|
|
|
|
G_UNLOCK (attribute_hash);
|
|
|
|
return attr_id;
|
|
}
|
|
|
|
static void
|
|
g_file_info_finalize (GObject *object)
|
|
{
|
|
GFileInfo *info;
|
|
int i;
|
|
GFileAttribute *attrs;
|
|
|
|
info = G_FILE_INFO (object);
|
|
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
for (i = 0; i < info->attributes->len; i++)
|
|
_g_file_attribute_value_clear (&attrs[i].value);
|
|
g_array_free (info->attributes, TRUE);
|
|
|
|
if (info->mask != NO_ATTRIBUTE_MASK)
|
|
g_file_attribute_matcher_unref (info->mask);
|
|
|
|
G_OBJECT_CLASS (g_file_info_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
g_file_info_class_init (GFileInfoClass *klass)
|
|
{
|
|
GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
|
|
|
|
gobject_class->finalize = g_file_info_finalize;
|
|
}
|
|
|
|
static void
|
|
g_file_info_init (GFileInfo *info)
|
|
{
|
|
info->mask = NO_ATTRIBUTE_MASK;
|
|
info->attributes = g_array_new (FALSE, FALSE,
|
|
sizeof (GFileAttribute));
|
|
}
|
|
|
|
/**
|
|
* g_file_info_new:
|
|
*
|
|
* Creates a new file info structure.
|
|
*
|
|
* Returns: a #GFileInfo.
|
|
**/
|
|
GFileInfo *
|
|
g_file_info_new (void)
|
|
{
|
|
return g_object_new (G_TYPE_FILE_INFO, NULL);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_copy_into:
|
|
* @src_info: source to copy attributes from.
|
|
* @dest_info: destination to copy attributes to.
|
|
*
|
|
* First clears all of the [GFileAttribute][gio-GFileAttribute] of @dest_info,
|
|
* and then copies all of the file attributes from @src_info to @dest_info.
|
|
**/
|
|
void
|
|
g_file_info_copy_into (GFileInfo *src_info,
|
|
GFileInfo *dest_info)
|
|
{
|
|
GFileAttribute *source, *dest;
|
|
int i;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (src_info));
|
|
g_return_if_fail (G_IS_FILE_INFO (dest_info));
|
|
|
|
dest = (GFileAttribute *)dest_info->attributes->data;
|
|
for (i = 0; i < dest_info->attributes->len; i++)
|
|
_g_file_attribute_value_clear (&dest[i].value);
|
|
|
|
g_array_set_size (dest_info->attributes,
|
|
src_info->attributes->len);
|
|
|
|
source = (GFileAttribute *)src_info->attributes->data;
|
|
dest = (GFileAttribute *)dest_info->attributes->data;
|
|
|
|
for (i = 0; i < src_info->attributes->len; i++)
|
|
{
|
|
dest[i].attribute = source[i].attribute;
|
|
dest[i].value.type = G_FILE_ATTRIBUTE_TYPE_INVALID;
|
|
_g_file_attribute_value_set (&dest[i].value, &source[i].value);
|
|
}
|
|
|
|
if (dest_info->mask != NO_ATTRIBUTE_MASK)
|
|
g_file_attribute_matcher_unref (dest_info->mask);
|
|
|
|
if (src_info->mask == NO_ATTRIBUTE_MASK)
|
|
dest_info->mask = NO_ATTRIBUTE_MASK;
|
|
else
|
|
dest_info->mask = g_file_attribute_matcher_ref (src_info->mask);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_dup:
|
|
* @other: a #GFileInfo.
|
|
*
|
|
* Duplicates a file info structure.
|
|
*
|
|
* Returns: (transfer full): a duplicate #GFileInfo of @other.
|
|
**/
|
|
GFileInfo *
|
|
g_file_info_dup (GFileInfo *other)
|
|
{
|
|
GFileInfo *new;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (other), NULL);
|
|
|
|
new = g_file_info_new ();
|
|
g_file_info_copy_into (other, new);
|
|
return new;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_mask:
|
|
* @info: a #GFileInfo.
|
|
* @mask: a #GFileAttributeMatcher.
|
|
*
|
|
* Sets @mask on @info to match specific attribute types.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_mask (GFileInfo *info,
|
|
GFileAttributeMatcher *mask)
|
|
{
|
|
GFileAttribute *attr;
|
|
int i;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
if (mask != info->mask)
|
|
{
|
|
if (info->mask != NO_ATTRIBUTE_MASK)
|
|
g_file_attribute_matcher_unref (info->mask);
|
|
info->mask = g_file_attribute_matcher_ref (mask);
|
|
|
|
/* Remove non-matching attributes */
|
|
for (i = 0; i < info->attributes->len; i++)
|
|
{
|
|
attr = &g_array_index (info->attributes, GFileAttribute, i);
|
|
if (!_g_file_attribute_matcher_matches_id (mask,
|
|
attr->attribute))
|
|
{
|
|
_g_file_attribute_value_clear (&attr->value);
|
|
g_array_remove_index (info->attributes, i);
|
|
i--;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* g_file_info_unset_attribute_mask:
|
|
* @info: #GFileInfo.
|
|
*
|
|
* Unsets a mask set by g_file_info_set_attribute_mask(), if one
|
|
* is set.
|
|
**/
|
|
void
|
|
g_file_info_unset_attribute_mask (GFileInfo *info)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
if (info->mask != NO_ATTRIBUTE_MASK)
|
|
g_file_attribute_matcher_unref (info->mask);
|
|
info->mask = NO_ATTRIBUTE_MASK;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_clear_status:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Clears the status information from @info.
|
|
**/
|
|
void
|
|
g_file_info_clear_status (GFileInfo *info)
|
|
{
|
|
GFileAttribute *attrs;
|
|
int i;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
for (i = 0; i < info->attributes->len; i++)
|
|
attrs[i].value.status = G_FILE_ATTRIBUTE_STATUS_UNSET;
|
|
}
|
|
|
|
static int
|
|
g_file_info_find_place (GFileInfo *info,
|
|
guint32 attribute)
|
|
{
|
|
int min, max, med;
|
|
GFileAttribute *attrs;
|
|
/* Binary search for the place where attribute would be, if it's
|
|
in the array */
|
|
|
|
min = 0;
|
|
max = info->attributes->len;
|
|
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
|
|
while (min < max)
|
|
{
|
|
med = min + (max - min) / 2;
|
|
if (attrs[med].attribute == attribute)
|
|
{
|
|
min = med;
|
|
break;
|
|
}
|
|
else if (attrs[med].attribute < attribute)
|
|
min = med + 1;
|
|
else /* attrs[med].attribute > attribute */
|
|
max = med;
|
|
}
|
|
|
|
return min;
|
|
}
|
|
|
|
static GFileAttributeValue *
|
|
g_file_info_find_value (GFileInfo *info,
|
|
guint32 attr_id)
|
|
{
|
|
GFileAttribute *attrs;
|
|
int i;
|
|
|
|
i = g_file_info_find_place (info, attr_id);
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
if (i < info->attributes->len &&
|
|
attrs[i].attribute == attr_id)
|
|
return &attrs[i].value;
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static GFileAttributeValue *
|
|
g_file_info_find_value_by_name (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
guint32 attr_id;
|
|
|
|
attr_id = lookup_attribute (attribute);
|
|
return g_file_info_find_value (info, attr_id);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_has_attribute:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Checks if a file info structure has an attribute named @attribute.
|
|
*
|
|
* Returns: %TRUE if @Ginfo has an attribute named @attribute,
|
|
* %FALSE otherwise.
|
|
**/
|
|
gboolean
|
|
g_file_info_has_attribute (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return value != NULL;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_has_namespace:
|
|
* @info: a #GFileInfo.
|
|
* @name_space: a file attribute namespace.
|
|
*
|
|
* Checks if a file info structure has an attribute in the
|
|
* specified @name_space.
|
|
*
|
|
* Returns: %TRUE if @Ginfo has an attribute in @name_space,
|
|
* %FALSE otherwise.
|
|
*
|
|
* Since: 2.22
|
|
**/
|
|
gboolean
|
|
g_file_info_has_namespace (GFileInfo *info,
|
|
const char *name_space)
|
|
{
|
|
GFileAttribute *attrs;
|
|
guint32 ns_id;
|
|
int i;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
g_return_val_if_fail (name_space != NULL, FALSE);
|
|
|
|
ns_id = lookup_namespace (name_space);
|
|
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
for (i = 0; i < info->attributes->len; i++)
|
|
{
|
|
if (GET_NS (attrs[i].attribute) == ns_id)
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_list_attributes:
|
|
* @info: a #GFileInfo.
|
|
* @name_space: (nullable): a file attribute key's namespace, or %NULL to list
|
|
* all attributes.
|
|
*
|
|
* Lists the file info structure's attributes.
|
|
*
|
|
* Returns: (nullable) (array zero-terminated=1) (transfer full): a
|
|
* null-terminated array of strings of all of the possible attribute
|
|
* types for the given @name_space, or %NULL on error.
|
|
**/
|
|
char **
|
|
g_file_info_list_attributes (GFileInfo *info,
|
|
const char *name_space)
|
|
{
|
|
GPtrArray *names;
|
|
GFileAttribute *attrs;
|
|
guint32 attribute;
|
|
guint32 ns_id = (name_space) ? lookup_namespace (name_space) : 0;
|
|
int i;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
names = g_ptr_array_new ();
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
for (i = 0; i < info->attributes->len; i++)
|
|
{
|
|
attribute = attrs[i].attribute;
|
|
if (ns_id == 0 || GET_NS (attribute) == ns_id)
|
|
g_ptr_array_add (names, g_strdup (get_attribute_for_id (attribute)));
|
|
}
|
|
|
|
/* NULL terminate */
|
|
g_ptr_array_add (names, NULL);
|
|
|
|
return (char **)g_ptr_array_free (names, FALSE);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_type:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets the attribute type for an attribute key.
|
|
*
|
|
* Returns: a #GFileAttributeType for the given @attribute, or
|
|
* %G_FILE_ATTRIBUTE_TYPE_INVALID if the key is not set.
|
|
**/
|
|
GFileAttributeType
|
|
g_file_info_get_attribute_type (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), G_FILE_ATTRIBUTE_TYPE_INVALID);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', G_FILE_ATTRIBUTE_TYPE_INVALID);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
if (value)
|
|
return value->type;
|
|
else
|
|
return G_FILE_ATTRIBUTE_TYPE_INVALID;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_remove_attribute:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Removes all cases of @attribute from @info if it exists.
|
|
**/
|
|
void
|
|
g_file_info_remove_attribute (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
guint32 attr_id;
|
|
GFileAttribute *attrs;
|
|
int i;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
|
|
attr_id = lookup_attribute (attribute);
|
|
|
|
i = g_file_info_find_place (info, attr_id);
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
if (i < info->attributes->len &&
|
|
attrs[i].attribute == attr_id)
|
|
{
|
|
_g_file_attribute_value_clear (&attrs[i].value);
|
|
g_array_remove_index (info->attributes, i);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_data:
|
|
* @info: a #GFileInfo
|
|
* @attribute: a file attribute key
|
|
* @type: (out) (optional): return location for the attribute type, or %NULL
|
|
* @value_pp: (out) (optional) (not nullable): return location for the
|
|
* attribute value, or %NULL; the attribute value will not be %NULL
|
|
* @status: (out) (optional): return location for the attribute status, or %NULL
|
|
*
|
|
* Gets the attribute type, value and status for an attribute key.
|
|
*
|
|
* Returns: (transfer none): %TRUE if @info has an attribute named @attribute,
|
|
* %FALSE otherwise.
|
|
*/
|
|
gboolean
|
|
g_file_info_get_attribute_data (GFileInfo *info,
|
|
const char *attribute,
|
|
GFileAttributeType *type,
|
|
gpointer *value_pp,
|
|
GFileAttributeStatus *status)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
if (value == NULL)
|
|
return FALSE;
|
|
|
|
if (status)
|
|
*status = value->status;
|
|
|
|
if (type)
|
|
*type = value->type;
|
|
|
|
if (value_pp)
|
|
*value_pp = _g_file_attribute_value_peek_as_pointer (value);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_status:
|
|
* @info: a #GFileInfo
|
|
* @attribute: a file attribute key
|
|
*
|
|
* Gets the attribute status for an attribute key.
|
|
*
|
|
* Returns: a #GFileAttributeStatus for the given @attribute, or
|
|
* %G_FILE_ATTRIBUTE_STATUS_UNSET if the key is invalid.
|
|
*
|
|
*/
|
|
GFileAttributeStatus
|
|
g_file_info_get_attribute_status (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *val;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), 0);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', 0);
|
|
|
|
val = g_file_info_find_value_by_name (info, attribute);
|
|
if (val)
|
|
return val->status;
|
|
|
|
return G_FILE_ATTRIBUTE_STATUS_UNSET;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_status:
|
|
* @info: a #GFileInfo
|
|
* @attribute: a file attribute key
|
|
* @status: a #GFileAttributeStatus
|
|
*
|
|
* Sets the attribute status for an attribute key. This is only
|
|
* needed by external code that implement g_file_set_attributes_from_info()
|
|
* or similar functions.
|
|
*
|
|
* The attribute must exist in @info for this to work. Otherwise %FALSE
|
|
* is returned and @info is unchanged.
|
|
*
|
|
* Returns: %TRUE if the status was changed, %FALSE if the key was not set.
|
|
*
|
|
* Since: 2.22
|
|
*/
|
|
gboolean
|
|
g_file_info_set_attribute_status (GFileInfo *info,
|
|
const char *attribute,
|
|
GFileAttributeStatus status)
|
|
{
|
|
GFileAttributeValue *val;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
|
|
|
|
val = g_file_info_find_value_by_name (info, attribute);
|
|
if (val)
|
|
{
|
|
val->status = status;
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
GFileAttributeValue *
|
|
_g_file_info_get_attribute_value (GFileInfo *info,
|
|
const char *attribute)
|
|
|
|
{
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', NULL);
|
|
|
|
return g_file_info_find_value_by_name (info, attribute);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_as_string:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets the value of a attribute, formated as a string.
|
|
* This escapes things as needed to make the string valid
|
|
* utf8.
|
|
*
|
|
* Returns: a UTF-8 string associated with the given @attribute.
|
|
* When you're done with the string it must be freed with g_free().
|
|
**/
|
|
char *
|
|
g_file_info_get_attribute_as_string (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *val;
|
|
val = _g_file_info_get_attribute_value (info, attribute);
|
|
if (val)
|
|
return _g_file_attribute_value_as_string (val);
|
|
return NULL;
|
|
}
|
|
|
|
|
|
/**
|
|
* g_file_info_get_attribute_object:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets the value of a #GObject attribute. If the attribute does
|
|
* not contain a #GObject, %NULL will be returned.
|
|
*
|
|
* Returns: (transfer none): a #GObject associated with the given @attribute, or
|
|
* %NULL otherwise.
|
|
**/
|
|
GObject *
|
|
g_file_info_get_attribute_object (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', NULL);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_object (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_string:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets the value of a string attribute. If the attribute does
|
|
* not contain a string, %NULL will be returned.
|
|
*
|
|
* Returns: the contents of the @attribute value as a UTF-8 string, or
|
|
* %NULL otherwise.
|
|
**/
|
|
const char *
|
|
g_file_info_get_attribute_string (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', NULL);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_byte_string:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets the value of a byte string attribute. If the attribute does
|
|
* not contain a byte string, %NULL will be returned.
|
|
*
|
|
* Returns: the contents of the @attribute value as a byte string, or
|
|
* %NULL otherwise.
|
|
**/
|
|
const char *
|
|
g_file_info_get_attribute_byte_string (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', NULL);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_byte_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_stringv:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets the value of a stringv attribute. If the attribute does
|
|
* not contain a stringv, %NULL will be returned.
|
|
*
|
|
* Returns: (transfer none): the contents of the @attribute value as a stringv, or
|
|
* %NULL otherwise. Do not free. These returned strings are UTF-8.
|
|
*
|
|
* Since: 2.22
|
|
**/
|
|
char **
|
|
g_file_info_get_attribute_stringv (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', NULL);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_stringv (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_boolean:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets the value of a boolean attribute. If the attribute does not
|
|
* contain a boolean value, %FALSE will be returned.
|
|
*
|
|
* Returns: the boolean value contained within the attribute.
|
|
**/
|
|
gboolean
|
|
g_file_info_get_attribute_boolean (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_boolean (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_uint32:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets an unsigned 32-bit integer contained within the attribute. If the
|
|
* attribute does not contain an unsigned 32-bit integer, or is invalid,
|
|
* 0 will be returned.
|
|
*
|
|
* Returns: an unsigned 32-bit integer from the attribute.
|
|
**/
|
|
guint32
|
|
g_file_info_get_attribute_uint32 (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), 0);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', 0);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_uint32 (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_int32:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets a signed 32-bit integer contained within the attribute. If the
|
|
* attribute does not contain a signed 32-bit integer, or is invalid,
|
|
* 0 will be returned.
|
|
*
|
|
* Returns: a signed 32-bit integer from the attribute.
|
|
**/
|
|
gint32
|
|
g_file_info_get_attribute_int32 (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), 0);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', 0);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_int32 (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_uint64:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets a unsigned 64-bit integer contained within the attribute. If the
|
|
* attribute does not contain an unsigned 64-bit integer, or is invalid,
|
|
* 0 will be returned.
|
|
*
|
|
* Returns: a unsigned 64-bit integer from the attribute.
|
|
**/
|
|
guint64
|
|
g_file_info_get_attribute_uint64 (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), 0);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', 0);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_uint64 (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_attribute_int64:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Gets a signed 64-bit integer contained within the attribute. If the
|
|
* attribute does not contain an signed 64-bit integer, or is invalid,
|
|
* 0 will be returned.
|
|
*
|
|
* Returns: a signed 64-bit integer from the attribute.
|
|
**/
|
|
gint64
|
|
g_file_info_get_attribute_int64 (GFileInfo *info,
|
|
const char *attribute)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), 0);
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', 0);
|
|
|
|
value = g_file_info_find_value_by_name (info, attribute);
|
|
return _g_file_attribute_value_get_int64 (value);
|
|
}
|
|
|
|
static GFileAttributeValue *
|
|
g_file_info_create_value (GFileInfo *info,
|
|
guint32 attr_id)
|
|
{
|
|
GFileAttribute *attrs;
|
|
int i;
|
|
|
|
if (info->mask != NO_ATTRIBUTE_MASK &&
|
|
!_g_file_attribute_matcher_matches_id (info->mask, attr_id))
|
|
return NULL;
|
|
|
|
i = g_file_info_find_place (info, attr_id);
|
|
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
if (i < info->attributes->len &&
|
|
attrs[i].attribute == attr_id)
|
|
return &attrs[i].value;
|
|
else
|
|
{
|
|
GFileAttribute attr = { 0 };
|
|
attr.attribute = attr_id;
|
|
g_array_insert_val (info->attributes, i, attr);
|
|
|
|
attrs = (GFileAttribute *)info->attributes->data;
|
|
return &attrs[i].value;
|
|
}
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
GFileAttributeType type,
|
|
gpointer value_p)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
|
|
if (value)
|
|
_g_file_attribute_value_set_from_pointer (value, type, value_p, TRUE);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @type: a #GFileAttributeType
|
|
* @value_p: (not nullable): pointer to the value
|
|
*
|
|
* Sets the @attribute to contain the given value, if possible. To unset the
|
|
* attribute, use %G_ATTRIBUTE_TYPE_INVALID for @type.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute (GFileInfo *info,
|
|
const char *attribute,
|
|
GFileAttributeType type,
|
|
gpointer value_p)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
|
|
_g_file_info_set_attribute_by_id (info, lookup_attribute (attribute), type, value_p);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_object_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
GObject *attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_object (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_object:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @attr_value: a #GObject.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_object (GFileInfo *info,
|
|
const char *attribute,
|
|
GObject *attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
g_return_if_fail (G_IS_OBJECT (attr_value));
|
|
|
|
_g_file_info_set_attribute_object_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_stringv_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
char **attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_stringv (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_stringv:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key
|
|
* @attr_value: (array) (element-type utf8): a %NULL terminated array of UTF-8 strings.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
*
|
|
* Sinze: 2.22
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_stringv (GFileInfo *info,
|
|
const char *attribute,
|
|
char **attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
g_return_if_fail (attr_value != NULL);
|
|
|
|
_g_file_info_set_attribute_stringv_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_string_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
const char *attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_string (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_string:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @attr_value: a UTF-8 string.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_string (GFileInfo *info,
|
|
const char *attribute,
|
|
const char *attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
g_return_if_fail (attr_value != NULL);
|
|
|
|
_g_file_info_set_attribute_string_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_byte_string_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
const char *attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_byte_string (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_byte_string:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @attr_value: a byte string.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_byte_string (GFileInfo *info,
|
|
const char *attribute,
|
|
const char *attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
g_return_if_fail (attr_value != NULL);
|
|
|
|
_g_file_info_set_attribute_byte_string_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_boolean_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
gboolean attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_boolean (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_boolean:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @attr_value: a boolean value.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_boolean (GFileInfo *info,
|
|
const char *attribute,
|
|
gboolean attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
|
|
_g_file_info_set_attribute_boolean_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_uint32_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
guint32 attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_uint32 (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_uint32:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @attr_value: an unsigned 32-bit integer.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_uint32 (GFileInfo *info,
|
|
const char *attribute,
|
|
guint32 attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
|
|
_g_file_info_set_attribute_uint32_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_int32_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
gint32 attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_int32 (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_int32:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @attr_value: a signed 32-bit integer
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_int32 (GFileInfo *info,
|
|
const char *attribute,
|
|
gint32 attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
|
|
_g_file_info_set_attribute_int32_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_uint64_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
guint64 attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_uint64 (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_uint64:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: a file attribute key.
|
|
* @attr_value: an unsigned 64-bit integer.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_uint64 (GFileInfo *info,
|
|
const char *attribute,
|
|
guint64 attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
|
|
_g_file_info_set_attribute_uint64_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
void
|
|
_g_file_info_set_attribute_int64_by_id (GFileInfo *info,
|
|
guint32 attribute,
|
|
gint64 attr_value)
|
|
{
|
|
GFileAttributeValue *value;
|
|
|
|
value = g_file_info_create_value (info, attribute);
|
|
if (value)
|
|
_g_file_attribute_value_set_int64 (value, attr_value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_attribute_int64:
|
|
* @info: a #GFileInfo.
|
|
* @attribute: attribute name to set.
|
|
* @attr_value: int64 value to set attribute to.
|
|
*
|
|
* Sets the @attribute to contain the given @attr_value,
|
|
* if possible.
|
|
*
|
|
**/
|
|
void
|
|
g_file_info_set_attribute_int64 (GFileInfo *info,
|
|
const char *attribute,
|
|
gint64 attr_value)
|
|
{
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (attribute != NULL && *attribute != '\0');
|
|
|
|
_g_file_info_set_attribute_int64_by_id (info,
|
|
lookup_attribute (attribute),
|
|
attr_value);
|
|
}
|
|
|
|
/* Helper getters */
|
|
/**
|
|
* g_file_info_get_deletion_date:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Returns the #GDateTime representing the deletion date of the file, as
|
|
* available in G_FILE_ATTRIBUTE_TRASH_DELETION_DATE. If the
|
|
* G_FILE_ATTRIBUTE_TRASH_DELETION_DATE attribute is unset, %NULL is returned.
|
|
*
|
|
* Returns: a #GDateTime, or %NULL.
|
|
*
|
|
* Since: 2.36
|
|
**/
|
|
GDateTime *
|
|
g_file_info_get_deletion_date (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
const char *date_str;
|
|
GTimeVal tv;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_TRASH_DELETION_DATE);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
date_str = _g_file_attribute_value_get_string (value);
|
|
if (!date_str)
|
|
return NULL;
|
|
|
|
if (g_time_val_from_iso8601 (date_str, &tv) == FALSE)
|
|
return NULL;
|
|
|
|
return g_date_time_new_from_timeval_local (&tv);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_file_type:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets a file's type (whether it is a regular file, symlink, etc).
|
|
* This is different from the file's content type, see g_file_info_get_content_type().
|
|
*
|
|
* Returns: a #GFileType for the given file.
|
|
**/
|
|
GFileType
|
|
g_file_info_get_file_type (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), G_FILE_TYPE_UNKNOWN);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_TYPE);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return (GFileType)_g_file_attribute_value_get_uint32 (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_is_hidden:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Checks if a file is hidden.
|
|
*
|
|
* Returns: %TRUE if the file is a hidden file, %FALSE otherwise.
|
|
**/
|
|
gboolean
|
|
g_file_info_get_is_hidden (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return (GFileType)_g_file_attribute_value_get_boolean (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_is_backup:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Checks if a file is a backup file.
|
|
*
|
|
* Returns: %TRUE if file is a backup file, %FALSE otherwise.
|
|
**/
|
|
gboolean
|
|
g_file_info_get_is_backup (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return (GFileType)_g_file_attribute_value_get_boolean (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_is_symlink:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Checks if a file is a symlink.
|
|
*
|
|
* Returns: %TRUE if the given @info is a symlink.
|
|
**/
|
|
gboolean
|
|
g_file_info_get_is_symlink (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return (GFileType)_g_file_attribute_value_get_boolean (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_name:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the name for a file.
|
|
*
|
|
* Returns: (type filename): a string containing the file name.
|
|
**/
|
|
const char *
|
|
g_file_info_get_name (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_NAME);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return _g_file_attribute_value_get_byte_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_display_name:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets a display name for a file.
|
|
*
|
|
* Returns: a string containing the display name.
|
|
**/
|
|
const char *
|
|
g_file_info_get_display_name (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return _g_file_attribute_value_get_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_edit_name:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the edit name for a file.
|
|
*
|
|
* Returns: a string containing the edit name.
|
|
**/
|
|
const char *
|
|
g_file_info_get_edit_name (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return _g_file_attribute_value_get_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_icon:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the icon for a file.
|
|
*
|
|
* Returns: (transfer none): #GIcon for the given @info.
|
|
**/
|
|
GIcon *
|
|
g_file_info_get_icon (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
GObject *obj;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_ICON);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
obj = _g_file_attribute_value_get_object (value);
|
|
if (G_IS_ICON (obj))
|
|
return G_ICON (obj);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_symbolic_icon:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the symbolic icon for a file.
|
|
*
|
|
* Returns: (transfer none): #GIcon for the given @info.
|
|
*
|
|
* Since: 2.34
|
|
**/
|
|
GIcon *
|
|
g_file_info_get_symbolic_icon (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
GObject *obj;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
obj = _g_file_attribute_value_get_object (value);
|
|
if (G_IS_ICON (obj))
|
|
return G_ICON (obj);
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_content_type:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the file's content type.
|
|
*
|
|
* Returns: a string containing the file's content type.
|
|
**/
|
|
const char *
|
|
g_file_info_get_content_type (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return _g_file_attribute_value_get_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_size:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the file's size.
|
|
*
|
|
* Returns: a #goffset containing the file's size.
|
|
**/
|
|
goffset
|
|
g_file_info_get_size (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), (goffset) 0);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SIZE);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return (goffset) _g_file_attribute_value_get_uint64 (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_modification_time:
|
|
* @info: a #GFileInfo.
|
|
* @result: (out caller-allocates): a #GTimeVal.
|
|
*
|
|
* Gets the modification time of the current @info and sets it
|
|
* in @result.
|
|
**/
|
|
void
|
|
g_file_info_get_modification_time (GFileInfo *info,
|
|
GTimeVal *result)
|
|
{
|
|
static guint32 attr_mtime = 0, attr_mtime_usec;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (result != NULL);
|
|
|
|
if (attr_mtime == 0)
|
|
{
|
|
attr_mtime = lookup_attribute (G_FILE_ATTRIBUTE_TIME_MODIFIED);
|
|
attr_mtime_usec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC);
|
|
}
|
|
|
|
value = g_file_info_find_value (info, attr_mtime);
|
|
result->tv_sec = _g_file_attribute_value_get_uint64 (value);
|
|
value = g_file_info_find_value (info, attr_mtime_usec);
|
|
result->tv_usec = _g_file_attribute_value_get_uint32 (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_symlink_target:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the symlink target for a given #GFileInfo.
|
|
*
|
|
* Returns: a string containing the symlink target.
|
|
**/
|
|
const char *
|
|
g_file_info_get_symlink_target (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return _g_file_attribute_value_get_byte_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_etag:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the [entity tag][gfile-etag] for a given
|
|
* #GFileInfo. See %G_FILE_ATTRIBUTE_ETAG_VALUE.
|
|
*
|
|
* Returns: a string containing the value of the "etag:value" attribute.
|
|
**/
|
|
const char *
|
|
g_file_info_get_etag (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_ETAG_VALUE);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return _g_file_attribute_value_get_string (value);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_get_sort_order:
|
|
* @info: a #GFileInfo.
|
|
*
|
|
* Gets the value of the sort_order attribute from the #GFileInfo.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
|
|
*
|
|
* Returns: a #gint32 containing the value of the "standard::sort_order" attribute.
|
|
**/
|
|
gint32
|
|
g_file_info_get_sort_order (GFileInfo *info)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_val_if_fail (G_IS_FILE_INFO (info), 0);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER);
|
|
|
|
value = g_file_info_find_value (info, attr);
|
|
return _g_file_attribute_value_get_int32 (value);
|
|
}
|
|
|
|
/* Helper setters: */
|
|
/**
|
|
* g_file_info_set_file_type:
|
|
* @info: a #GFileInfo.
|
|
* @type: a #GFileType.
|
|
*
|
|
* Sets the file type in a #GFileInfo to @type.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_TYPE.
|
|
**/
|
|
void
|
|
g_file_info_set_file_type (GFileInfo *info,
|
|
GFileType type)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_TYPE);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_uint32 (value, type);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_is_hidden:
|
|
* @info: a #GFileInfo.
|
|
* @is_hidden: a #gboolean.
|
|
*
|
|
* Sets the "is_hidden" attribute in a #GFileInfo according to @is_hidden.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN.
|
|
**/
|
|
void
|
|
g_file_info_set_is_hidden (GFileInfo *info,
|
|
gboolean is_hidden)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_boolean (value, is_hidden);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_is_symlink:
|
|
* @info: a #GFileInfo.
|
|
* @is_symlink: a #gboolean.
|
|
*
|
|
* Sets the "is_symlink" attribute in a #GFileInfo according to @is_symlink.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK.
|
|
**/
|
|
void
|
|
g_file_info_set_is_symlink (GFileInfo *info,
|
|
gboolean is_symlink)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_boolean (value, is_symlink);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_name:
|
|
* @info: a #GFileInfo.
|
|
* @name: (type filename): a string containing a name.
|
|
*
|
|
* Sets the name attribute for the current #GFileInfo.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_NAME.
|
|
**/
|
|
void
|
|
g_file_info_set_name (GFileInfo *info,
|
|
const char *name)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (name != NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_NAME);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_byte_string (value, name);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_display_name:
|
|
* @info: a #GFileInfo.
|
|
* @display_name: a string containing a display name.
|
|
*
|
|
* Sets the display name for the current #GFileInfo.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME.
|
|
**/
|
|
void
|
|
g_file_info_set_display_name (GFileInfo *info,
|
|
const char *display_name)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (display_name != NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_string (value, display_name);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_edit_name:
|
|
* @info: a #GFileInfo.
|
|
* @edit_name: a string containing an edit name.
|
|
*
|
|
* Sets the edit name for the current file.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME.
|
|
**/
|
|
void
|
|
g_file_info_set_edit_name (GFileInfo *info,
|
|
const char *edit_name)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (edit_name != NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_string (value, edit_name);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_icon:
|
|
* @info: a #GFileInfo.
|
|
* @icon: a #GIcon.
|
|
*
|
|
* Sets the icon for a given #GFileInfo.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_ICON.
|
|
**/
|
|
void
|
|
g_file_info_set_icon (GFileInfo *info,
|
|
GIcon *icon)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (G_IS_ICON (icon));
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_ICON);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_object (value, G_OBJECT (icon));
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_symbolic_icon:
|
|
* @info: a #GFileInfo.
|
|
* @icon: a #GIcon.
|
|
*
|
|
* Sets the symbolic icon for a given #GFileInfo.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON.
|
|
*
|
|
* Since: 2.34
|
|
**/
|
|
void
|
|
g_file_info_set_symbolic_icon (GFileInfo *info,
|
|
GIcon *icon)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (G_IS_ICON (icon));
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_object (value, G_OBJECT (icon));
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_content_type:
|
|
* @info: a #GFileInfo.
|
|
* @content_type: a content type. See [GContentType][gio-GContentType]
|
|
*
|
|
* Sets the content type attribute for a given #GFileInfo.
|
|
* See %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE.
|
|
**/
|
|
void
|
|
g_file_info_set_content_type (GFileInfo *info,
|
|
const char *content_type)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (content_type != NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_string (value, content_type);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_size:
|
|
* @info: a #GFileInfo.
|
|
* @size: a #goffset containing the file's size.
|
|
*
|
|
* Sets the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute in the file info
|
|
* to the given size.
|
|
**/
|
|
void
|
|
g_file_info_set_size (GFileInfo *info,
|
|
goffset size)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SIZE);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_uint64 (value, size);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_modification_time:
|
|
* @info: a #GFileInfo.
|
|
* @mtime: a #GTimeVal.
|
|
*
|
|
* Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED attribute in the file
|
|
* info to the given time value.
|
|
**/
|
|
void
|
|
g_file_info_set_modification_time (GFileInfo *info,
|
|
GTimeVal *mtime)
|
|
{
|
|
static guint32 attr_mtime = 0, attr_mtime_usec;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (mtime != NULL);
|
|
|
|
if (attr_mtime == 0)
|
|
{
|
|
attr_mtime = lookup_attribute (G_FILE_ATTRIBUTE_TIME_MODIFIED);
|
|
attr_mtime_usec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC);
|
|
}
|
|
|
|
value = g_file_info_create_value (info, attr_mtime);
|
|
if (value)
|
|
_g_file_attribute_value_set_uint64 (value, mtime->tv_sec);
|
|
value = g_file_info_create_value (info, attr_mtime_usec);
|
|
if (value)
|
|
_g_file_attribute_value_set_uint32 (value, mtime->tv_usec);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_symlink_target:
|
|
* @info: a #GFileInfo.
|
|
* @symlink_target: a static string containing a path to a symlink target.
|
|
*
|
|
* Sets the %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET attribute in the file info
|
|
* to the given symlink target.
|
|
**/
|
|
void
|
|
g_file_info_set_symlink_target (GFileInfo *info,
|
|
const char *symlink_target)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
g_return_if_fail (symlink_target != NULL);
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_byte_string (value, symlink_target);
|
|
}
|
|
|
|
/**
|
|
* g_file_info_set_sort_order:
|
|
* @info: a #GFileInfo.
|
|
* @sort_order: a sort order integer.
|
|
*
|
|
* Sets the sort order attribute in the file info structure. See
|
|
* %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
|
|
**/
|
|
void
|
|
g_file_info_set_sort_order (GFileInfo *info,
|
|
gint32 sort_order)
|
|
{
|
|
static guint32 attr = 0;
|
|
GFileAttributeValue *value;
|
|
|
|
g_return_if_fail (G_IS_FILE_INFO (info));
|
|
|
|
if (attr == 0)
|
|
attr = lookup_attribute (G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER);
|
|
|
|
value = g_file_info_create_value (info, attr);
|
|
if (value)
|
|
_g_file_attribute_value_set_int32 (value, sort_order);
|
|
}
|
|
|
|
|
|
typedef struct {
|
|
guint32 id;
|
|
guint32 mask;
|
|
} SubMatcher;
|
|
|
|
struct _GFileAttributeMatcher {
|
|
gboolean all;
|
|
gint ref;
|
|
|
|
GArray *sub_matchers;
|
|
|
|
/* Interator */
|
|
guint32 iterator_ns;
|
|
gint iterator_pos;
|
|
};
|
|
|
|
G_DEFINE_BOXED_TYPE (GFileAttributeMatcher, g_file_attribute_matcher,
|
|
g_file_attribute_matcher_ref,
|
|
g_file_attribute_matcher_unref)
|
|
|
|
static gint
|
|
compare_sub_matchers (gconstpointer a,
|
|
gconstpointer b)
|
|
{
|
|
const SubMatcher *suba = a;
|
|
const SubMatcher *subb = b;
|
|
int diff;
|
|
|
|
diff = suba->id - subb->id;
|
|
|
|
if (diff)
|
|
return diff;
|
|
|
|
return suba->mask - subb->mask;
|
|
}
|
|
|
|
static gboolean
|
|
sub_matcher_matches (SubMatcher *matcher,
|
|
SubMatcher *submatcher)
|
|
{
|
|
if ((matcher->mask & submatcher->mask) != matcher->mask)
|
|
return FALSE;
|
|
|
|
return matcher->id == (submatcher->id & matcher->mask);
|
|
}
|
|
|
|
/* Call this function after modifying a matcher.
|
|
* It will ensure all the invariants other functions rely on.
|
|
*/
|
|
static GFileAttributeMatcher *
|
|
matcher_optimize (GFileAttributeMatcher *matcher)
|
|
{
|
|
SubMatcher *submatcher, *compare;
|
|
guint i, j;
|
|
|
|
/* remove sub_matchers if we match everything anyway */
|
|
if (matcher->all)
|
|
{
|
|
if (matcher->sub_matchers)
|
|
{
|
|
g_array_free (matcher->sub_matchers, TRUE);
|
|
matcher->sub_matchers = NULL;
|
|
}
|
|
return matcher;
|
|
}
|
|
|
|
if (matcher->sub_matchers->len == 0)
|
|
{
|
|
g_file_attribute_matcher_unref (matcher);
|
|
return NULL;
|
|
}
|
|
|
|
/* sort sub_matchers by id (and then mask), so we can bsearch
|
|
* and compare matchers in O(N) instead of O(N²) */
|
|
g_array_sort (matcher->sub_matchers, compare_sub_matchers);
|
|
|
|
/* remove duplicates and specific matches when we match the whole namespace */
|
|
j = 0;
|
|
compare = &g_array_index (matcher->sub_matchers, SubMatcher, j);
|
|
|
|
for (i = 1; i < matcher->sub_matchers->len; i++)
|
|
{
|
|
submatcher = &g_array_index (matcher->sub_matchers, SubMatcher, i);
|
|
if (sub_matcher_matches (compare, submatcher))
|
|
continue;
|
|
|
|
j++;
|
|
compare++;
|
|
|
|
if (j < i)
|
|
*compare = *submatcher;
|
|
}
|
|
|
|
g_array_set_size (matcher->sub_matchers, j + 1);
|
|
|
|
return matcher;
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_new:
|
|
* @attributes: an attribute string to match.
|
|
*
|
|
* Creates a new file attribute matcher, which matches attributes
|
|
* against a given string. #GFileAttributeMatchers are reference
|
|
* counted structures, and are created with a reference count of 1. If
|
|
* the number of references falls to 0, the #GFileAttributeMatcher is
|
|
* automatically destroyed.
|
|
*
|
|
* The @attribute string should be formatted with specific keys separated
|
|
* from namespaces with a double colon. Several "namespace::key" strings may be
|
|
* concatenated with a single comma (e.g. "standard::type,standard::is-hidden").
|
|
* The wildcard "*" may be used to match all keys and namespaces, or
|
|
* "namespace::*" will match all keys in a given namespace.
|
|
*
|
|
* ## Examples of file attribute matcher strings and results
|
|
*
|
|
* - `"*"`: matches all attributes.
|
|
* - `"standard::is-hidden"`: matches only the key is-hidden in the
|
|
* standard namespace.
|
|
* - `"standard::type,unix::*"`: matches the type key in the standard
|
|
* namespace and all keys in the unix namespace.
|
|
*
|
|
* Returns: a #GFileAttributeMatcher
|
|
*/
|
|
GFileAttributeMatcher *
|
|
g_file_attribute_matcher_new (const char *attributes)
|
|
{
|
|
char **split;
|
|
char *colon;
|
|
int i;
|
|
GFileAttributeMatcher *matcher;
|
|
|
|
if (attributes == NULL || *attributes == '\0')
|
|
return NULL;
|
|
|
|
matcher = g_malloc0 (sizeof (GFileAttributeMatcher));
|
|
matcher->ref = 1;
|
|
matcher->sub_matchers = g_array_new (FALSE, FALSE, sizeof (SubMatcher));
|
|
|
|
split = g_strsplit (attributes, ",", -1);
|
|
|
|
for (i = 0; split[i] != NULL; i++)
|
|
{
|
|
if (strcmp (split[i], "*") == 0)
|
|
matcher->all = TRUE;
|
|
else
|
|
{
|
|
SubMatcher s;
|
|
|
|
colon = strstr (split[i], "::");
|
|
if (colon != NULL &&
|
|
!(colon[2] == 0 ||
|
|
(colon[2] == '*' &&
|
|
colon[3] == 0)))
|
|
{
|
|
s.id = lookup_attribute (split[i]);
|
|
s.mask = 0xffffffff;
|
|
}
|
|
else
|
|
{
|
|
if (colon)
|
|
*colon = 0;
|
|
|
|
s.id = lookup_namespace (split[i]) << NS_POS;
|
|
s.mask = NS_MASK << NS_POS;
|
|
}
|
|
|
|
g_array_append_val (matcher->sub_matchers, s);
|
|
}
|
|
}
|
|
|
|
g_strfreev (split);
|
|
|
|
matcher = matcher_optimize (matcher);
|
|
|
|
return matcher;
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_subtract:
|
|
* @matcher: Matcher to subtract from
|
|
* @subtract: The matcher to subtract
|
|
*
|
|
* Subtracts all attributes of @subtract from @matcher and returns
|
|
* a matcher that supports those attributes.
|
|
*
|
|
* Note that currently it is not possible to remove a single
|
|
* attribute when the @matcher matches the whole namespace - or remove
|
|
* a namespace or attribute when the matcher matches everything. This
|
|
* is a limitation of the current implementation, but may be fixed
|
|
* in the future.
|
|
*
|
|
* Returns: A file attribute matcher matching all attributes of
|
|
* @matcher that are not matched by @subtract
|
|
**/
|
|
GFileAttributeMatcher *
|
|
g_file_attribute_matcher_subtract (GFileAttributeMatcher *matcher,
|
|
GFileAttributeMatcher *subtract)
|
|
{
|
|
GFileAttributeMatcher *result;
|
|
guint mi, si;
|
|
SubMatcher *msub, *ssub;
|
|
|
|
if (matcher == NULL)
|
|
return NULL;
|
|
if (subtract == NULL)
|
|
return g_file_attribute_matcher_ref (matcher);
|
|
if (subtract->all)
|
|
return NULL;
|
|
if (matcher->all)
|
|
return g_file_attribute_matcher_ref (matcher);
|
|
|
|
result = g_malloc0 (sizeof (GFileAttributeMatcher));
|
|
result->ref = 1;
|
|
result->sub_matchers = g_array_new (FALSE, FALSE, sizeof (SubMatcher));
|
|
|
|
si = 0;
|
|
g_assert (subtract->sub_matchers->len > 0);
|
|
ssub = &g_array_index (subtract->sub_matchers, SubMatcher, si);
|
|
|
|
for (mi = 0; mi < matcher->sub_matchers->len; mi++)
|
|
{
|
|
msub = &g_array_index (matcher->sub_matchers, SubMatcher, mi);
|
|
|
|
retry:
|
|
if (sub_matcher_matches (ssub, msub))
|
|
continue;
|
|
|
|
si++;
|
|
if (si >= subtract->sub_matchers->len)
|
|
break;
|
|
|
|
ssub = &g_array_index (subtract->sub_matchers, SubMatcher, si);
|
|
if (ssub->id <= msub->id)
|
|
goto retry;
|
|
|
|
g_array_append_val (result->sub_matchers, *msub);
|
|
}
|
|
|
|
if (mi < matcher->sub_matchers->len)
|
|
g_array_append_vals (result->sub_matchers,
|
|
&g_array_index (matcher->sub_matchers, SubMatcher, mi),
|
|
matcher->sub_matchers->len - mi);
|
|
|
|
result = matcher_optimize (result);
|
|
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_ref:
|
|
* @matcher: a #GFileAttributeMatcher.
|
|
*
|
|
* References a file attribute matcher.
|
|
*
|
|
* Returns: a #GFileAttributeMatcher.
|
|
**/
|
|
GFileAttributeMatcher *
|
|
g_file_attribute_matcher_ref (GFileAttributeMatcher *matcher)
|
|
{
|
|
if (matcher)
|
|
{
|
|
g_return_val_if_fail (matcher->ref > 0, NULL);
|
|
g_atomic_int_inc (&matcher->ref);
|
|
}
|
|
return matcher;
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_unref:
|
|
* @matcher: a #GFileAttributeMatcher.
|
|
*
|
|
* Unreferences @matcher. If the reference count falls below 1,
|
|
* the @matcher is automatically freed.
|
|
*
|
|
**/
|
|
void
|
|
g_file_attribute_matcher_unref (GFileAttributeMatcher *matcher)
|
|
{
|
|
if (matcher)
|
|
{
|
|
g_return_if_fail (matcher->ref > 0);
|
|
|
|
if (g_atomic_int_dec_and_test (&matcher->ref))
|
|
{
|
|
if (matcher->sub_matchers)
|
|
g_array_free (matcher->sub_matchers, TRUE);
|
|
|
|
g_free (matcher);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_matches_only:
|
|
* @matcher: a #GFileAttributeMatcher.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Checks if a attribute matcher only matches a given attribute. Always
|
|
* returns %FALSE if "*" was used when creating the matcher.
|
|
*
|
|
* Returns: %TRUE if the matcher only matches @attribute. %FALSE otherwise.
|
|
**/
|
|
gboolean
|
|
g_file_attribute_matcher_matches_only (GFileAttributeMatcher *matcher,
|
|
const char *attribute)
|
|
{
|
|
SubMatcher *sub_matcher;
|
|
guint32 id;
|
|
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
|
|
|
|
if (matcher == NULL ||
|
|
matcher->all)
|
|
return FALSE;
|
|
|
|
if (matcher->sub_matchers->len != 1)
|
|
return FALSE;
|
|
|
|
id = lookup_attribute (attribute);
|
|
|
|
sub_matcher = &g_array_index (matcher->sub_matchers, SubMatcher, 0);
|
|
|
|
return sub_matcher->id == id &&
|
|
sub_matcher->mask == 0xffffffff;
|
|
}
|
|
|
|
static gboolean
|
|
matcher_matches_id (GFileAttributeMatcher *matcher,
|
|
guint32 id)
|
|
{
|
|
SubMatcher *sub_matchers;
|
|
int i;
|
|
|
|
if (matcher->sub_matchers)
|
|
{
|
|
sub_matchers = (SubMatcher *)matcher->sub_matchers->data;
|
|
for (i = 0; i < matcher->sub_matchers->len; i++)
|
|
{
|
|
if (sub_matchers[i].id == (id & sub_matchers[i].mask))
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
gboolean
|
|
_g_file_attribute_matcher_matches_id (GFileAttributeMatcher *matcher,
|
|
guint32 id)
|
|
{
|
|
/* We return a NULL matcher for an empty match string, so handle this */
|
|
if (matcher == NULL)
|
|
return FALSE;
|
|
|
|
if (matcher->all)
|
|
return TRUE;
|
|
|
|
return matcher_matches_id (matcher, id);
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_matches:
|
|
* @matcher: a #GFileAttributeMatcher.
|
|
* @attribute: a file attribute key.
|
|
*
|
|
* Checks if an attribute will be matched by an attribute matcher. If
|
|
* the matcher was created with the "*" matching string, this function
|
|
* will always return %TRUE.
|
|
*
|
|
* Returns: %TRUE if @attribute matches @matcher. %FALSE otherwise.
|
|
**/
|
|
gboolean
|
|
g_file_attribute_matcher_matches (GFileAttributeMatcher *matcher,
|
|
const char *attribute)
|
|
{
|
|
g_return_val_if_fail (attribute != NULL && *attribute != '\0', FALSE);
|
|
|
|
/* We return a NULL matcher for an empty match string, so handle this */
|
|
if (matcher == NULL)
|
|
return FALSE;
|
|
|
|
if (matcher->all)
|
|
return TRUE;
|
|
|
|
return matcher_matches_id (matcher, lookup_attribute (attribute));
|
|
}
|
|
|
|
/* return TRUE -> all */
|
|
/**
|
|
* g_file_attribute_matcher_enumerate_namespace:
|
|
* @matcher: a #GFileAttributeMatcher.
|
|
* @ns: a string containing a file attribute namespace.
|
|
*
|
|
* Checks if the matcher will match all of the keys in a given namespace.
|
|
* This will always return %TRUE if a wildcard character is in use (e.g. if
|
|
* matcher was created with "standard::*" and @ns is "standard", or if matcher was created
|
|
* using "*" and namespace is anything.)
|
|
*
|
|
* TODO: this is awkwardly worded.
|
|
*
|
|
* Returns: %TRUE if the matcher matches all of the entries
|
|
* in the given @ns, %FALSE otherwise.
|
|
**/
|
|
gboolean
|
|
g_file_attribute_matcher_enumerate_namespace (GFileAttributeMatcher *matcher,
|
|
const char *ns)
|
|
{
|
|
SubMatcher *sub_matchers;
|
|
int ns_id;
|
|
int i;
|
|
|
|
g_return_val_if_fail (ns != NULL && *ns != '\0', FALSE);
|
|
|
|
/* We return a NULL matcher for an empty match string, so handle this */
|
|
if (matcher == NULL)
|
|
return FALSE;
|
|
|
|
if (matcher->all)
|
|
return TRUE;
|
|
|
|
ns_id = lookup_namespace (ns) << NS_POS;
|
|
|
|
if (matcher->sub_matchers)
|
|
{
|
|
sub_matchers = (SubMatcher *)matcher->sub_matchers->data;
|
|
for (i = 0; i < matcher->sub_matchers->len; i++)
|
|
{
|
|
if (sub_matchers[i].id == ns_id)
|
|
return TRUE;
|
|
}
|
|
}
|
|
|
|
matcher->iterator_ns = ns_id;
|
|
matcher->iterator_pos = 0;
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_enumerate_next:
|
|
* @matcher: a #GFileAttributeMatcher.
|
|
*
|
|
* Gets the next matched attribute from a #GFileAttributeMatcher.
|
|
*
|
|
* Returns: a string containing the next attribute or %NULL if
|
|
* no more attribute exist.
|
|
**/
|
|
const char *
|
|
g_file_attribute_matcher_enumerate_next (GFileAttributeMatcher *matcher)
|
|
{
|
|
int i;
|
|
SubMatcher *sub_matcher;
|
|
|
|
/* We return a NULL matcher for an empty match string, so handle this */
|
|
if (matcher == NULL)
|
|
return NULL;
|
|
|
|
while (1)
|
|
{
|
|
i = matcher->iterator_pos++;
|
|
|
|
if (matcher->sub_matchers == NULL)
|
|
return NULL;
|
|
|
|
if (i < matcher->sub_matchers->len)
|
|
sub_matcher = &g_array_index (matcher->sub_matchers, SubMatcher, i);
|
|
else
|
|
return NULL;
|
|
|
|
if (sub_matcher->mask == 0xffffffff &&
|
|
(sub_matcher->id & (NS_MASK << NS_POS)) == matcher->iterator_ns)
|
|
return get_attribute_for_id (sub_matcher->id);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* g_file_attribute_matcher_to_string:
|
|
* @matcher: (nullable): a #GFileAttributeMatcher.
|
|
*
|
|
* Prints what the matcher is matching against. The format will be
|
|
* equal to the format passed to g_file_attribute_matcher_new().
|
|
* The output however, might not be identical, as the matcher may
|
|
* decide to use a different order or omit needless parts.
|
|
*
|
|
* Returns: a string describing the attributes the matcher matches
|
|
* against or %NULL if @matcher was %NULL.
|
|
*
|
|
* Since: 2.32
|
|
**/
|
|
char *
|
|
g_file_attribute_matcher_to_string (GFileAttributeMatcher *matcher)
|
|
{
|
|
GString *string;
|
|
guint i;
|
|
|
|
if (matcher == NULL)
|
|
return NULL;
|
|
|
|
if (matcher->all)
|
|
return g_strdup ("*");
|
|
|
|
string = g_string_new ("");
|
|
for (i = 0; i < matcher->sub_matchers->len; i++)
|
|
{
|
|
SubMatcher *submatcher = &g_array_index (matcher->sub_matchers, SubMatcher, i);
|
|
|
|
if (i > 0)
|
|
g_string_append_c (string, ',');
|
|
|
|
g_string_append (string, get_attribute_for_id (submatcher->id));
|
|
}
|
|
|
|
return g_string_free (string, FALSE);
|
|
}
|