| /* GIO - GLib Input, Output and Streaming Library | |
| * | |
| * Copyright (C) 2006-2007 Red Hat, Inc. | |
| * | |
| * SPDX-License-Identifier: LGPL-2.1-or-later | |
| * | |
| * 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> | |
| */ | |
| /** | |
| * GFileInfo: | |
| * | |
| * Stores information about a file system object referenced by a [iface@Gio.File]. | |
| * | |
| * 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 the [file attributes](file-attributes.html) document for more | |
| * information on how GIO handles file attributes. | |
| * | |
| * To obtain a `GFileInfo` for a [iface@Gio.File], use | |
| * [method@Gio.File.query_info] (or its async variant). To obtain a `GFileInfo` | |
| * for a file input or output stream, use [method@Gio.FileInputStream.query_info] | |
| * or [method@Gio.FileOutputStream.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 [method@Gio.File.set_attributes_from_info] | |
| * or [method@Gio.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 [method@Gio.FileInfo.set_size]. | |
| * You may call [method@Gio.File.query_settable_attributes] and | |
| * [method@Gio.File.query_writable_namespaces] to discover the settable attributes | |
| * of a particular file at runtime. | |
| * | |
| * The direct accessors, such as [method@Gio.FileInfo.get_name], are slightly more | |
| * optimized than the generic attribute accessors, such as | |
| * [method@Gio.FileInfo.get_attribute_byte_string].This optimization will matter | |
| * only if calling the API in a tight loop. | |
| * | |
| * It is an error to call these accessors without specifying their required file | |
| * attributes when creating the `GFileInfo`. Use | |
| * [method@Gio.FileInfo.has_attribute] or [method@Gio.FileInfo.list_attributes] | |
| * to check what attributes are specified for a `GFileInfo`. | |
| * | |
| * [struct@Gio.FileAttributeMatcher] 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 ***global_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); | |
| global_attributes = g_realloc (global_attributes, (ns_info->id + 1) * sizeof (char **)); | |
| global_attributes[ns_info->id] = g_new (char *, 1); | |
| global_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; | |
| global_attributes[ns_info->id] = g_realloc (global_attributes[ns_info->id], (id + 1) * sizeof (char *)); | |
| global_attributes[ns_info->id][id] = g_strdup (attribute); | |
| attr_id = MAKE_ATTR_ID (ns_info->id, id); | |
| g_hash_table_insert (attribute_hash, global_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 G_GNUC_UNUSED /* when compiling with G_DISABLE_ASSERT */; \ | |
| _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 (TIME_MODIFIED_NSEC); | |
| REGISTER_ATTRIBUTE (TIME_ACCESS_NSEC); | |
| REGISTER_ATTRIBUTE (TIME_CREATED_NSEC); | |
| REGISTER_ATTRIBUTE (TIME_CHANGED_NSEC); | |
| 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 (DOS_IS_MOUNTPOINT); | |
| REGISTER_ATTRIBUTE (DOS_REPARSE_POINT_TAG); | |
| 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 (THUMBNAIL_PATH_NORMAL); | |
| REGISTER_ATTRIBUTE (THUMBNAILING_FAILED_NORMAL); | |
| REGISTER_ATTRIBUTE (THUMBNAIL_IS_VALID_NORMAL); | |
| REGISTER_ATTRIBUTE (THUMBNAIL_PATH_LARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAILING_FAILED_LARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAIL_IS_VALID_LARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAIL_PATH_XLARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAILING_FAILED_XLARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAIL_IS_VALID_XLARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAIL_PATH_XXLARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAILING_FAILED_XXLARGE); | |
| REGISTER_ATTRIBUTE (THUMBNAIL_IS_VALID_XXLARGE); | |
| 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 = global_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; | |
| guint 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; | |
| guint 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; | |
| guint 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; | |
| guint 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; | |
| guint 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 @info 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 @info 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; | |
| guint 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; | |
| guint 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; | |
| } | |
| static void | |
| g_file_info_remove_value (GFileInfo *info, | |
| guint32 attr_id) | |
| { | |
| GFileAttribute *attrs; | |
| guint i; | |
| if (info->mask != NO_ATTRIBUTE_MASK && | |
| !_g_file_attribute_matcher_matches_id (info->mask, attr_id)) | |
| return; | |
| 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_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; | |
| g_return_if_fail (G_IS_FILE_INFO (info)); | |
| g_return_if_fail (attribute != NULL && *attribute != '\0'); | |
| attr_id = lookup_attribute (attribute); | |
| g_file_info_remove_value (info, attr_id); | |
| } | |
| /** | |
| * 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: %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; | |
| 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); | |
| 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 an attribute, formatted as a string. | |
| * This escapes things as needed to make the string valid | |
| * UTF-8. | |
| * | |
| * Returns: (nullable): a UTF-8 string associated with the given @attribute, or | |
| * %NULL if the attribute wasn’t set. | |
| * 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) (nullable): 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: (nullable): 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: (nullable): 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_file_path: | |
| * @info: a #GFileInfo. | |
| * @attribute: a file attribute key. | |
| * | |
| * Gets the value of a byte string attribute as a file path. | |
| * | |
| * If the attribute does not contain a byte string, `NULL` will be returned. | |
| * | |
| * This function is meant to be used by language bindings that have specific | |
| * handling for Unix paths. | |
| * | |
| * Returns: (type filename) (nullable): the contents of the @attribute value as | |
| * a file path, or %NULL otherwise. | |
| * | |
| * Since: 2.78 | |
| **/ | |
| const char * | |
| g_file_info_get_attribute_file_path (GFileInfo *info, | |
| const char *attribute) | |
| { | |
| return g_file_info_get_attribute_byte_string (info, attribute); | |
| } | |
| /** | |
| * 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) (nullable): 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 a 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; | |
| guint 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_FILE_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 zero-terminated=1) (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); | |
| } | |
| /** | |
| * g_file_info_set_attribute_file_path: | |
| * @info: a #GFileInfo. | |
| * @attribute: a file attribute key. | |
| * @attr_value: (type filename): a file path. | |
| * | |
| * Sets the @attribute to contain the given @attr_value, | |
| * if possible. | |
| * | |
| * This function is meant to be used by language bindings that have specific | |
| * handling for Unix paths. | |
| * | |
| * Since: 2.78 | |
| **/ | |
| void | |
| g_file_info_set_attribute_file_path (GFileInfo *info, | |
| const char *attribute, | |
| const char *attr_value) | |
| { | |
| g_file_info_set_attribute_byte_string (info, 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 */ | |
| #define get_required_attribute(value_ptr, info, attribute_name, error_value) \ | |
| G_STMT_START { \ | |
| static guint32 attr = 0; \ | |
| \ | |
| if (attr == 0) \ | |
| attr = lookup_attribute (attribute_name); \ | |
| \ | |
| *value_ptr = g_file_info_find_value (info, attr); \ | |
| if (G_UNLIKELY (*value_ptr == NULL)) \ | |
| { \ | |
| g_critical ("GFileInfo created without " attribute_name); \ | |
| g_return_val_if_reached (error_value); \ | |
| } \ | |
| } G_STMT_END | |
| /** | |
| * 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: (nullable): 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; | |
| GTimeZone *local_tz = NULL; | |
| GDateTime *dt = NULL; | |
| 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; | |
| local_tz = g_time_zone_new_local (); | |
| dt = g_date_time_new_from_iso8601 (date_str, local_tz); | |
| g_time_zone_unref (local_tz); | |
| return g_steal_pointer (&dt); | |
| } | |
| /** | |
| * 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(). | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_TYPE. | |
| * | |
| * Returns: a #GFileType for the given file. | |
| **/ | |
| GFileType | |
| g_file_info_get_file_type (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), G_FILE_TYPE_UNKNOWN); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_TYPE, G_FILE_TYPE_UNKNOWN); | |
| return (GFileType)_g_file_attribute_value_get_uint32 (value); | |
| } | |
| /** | |
| * g_file_info_get_is_hidden: | |
| * @info: a #GFileInfo. | |
| * | |
| * Checks if a file is hidden. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN. | |
| * | |
| * Returns: %TRUE if the file is a hidden file, %FALSE otherwise. | |
| **/ | |
| gboolean | |
| g_file_info_get_is_hidden (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN, FALSE); | |
| return _g_file_attribute_value_get_boolean (value); | |
| } | |
| /** | |
| * g_file_info_get_is_backup: | |
| * @info: a #GFileInfo. | |
| * | |
| * Checks if a file is a backup file. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP. | |
| * | |
| * Returns: %TRUE if file is a backup file, %FALSE otherwise. | |
| **/ | |
| gboolean | |
| g_file_info_get_is_backup (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP, FALSE); | |
| return _g_file_attribute_value_get_boolean (value); | |
| } | |
| /** | |
| * g_file_info_get_is_symlink: | |
| * @info: a #GFileInfo. | |
| * | |
| * Checks if a file is a symlink. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK. | |
| * | |
| * Returns: %TRUE if the given @info is a symlink. | |
| **/ | |
| gboolean | |
| g_file_info_get_is_symlink (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), FALSE); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK, FALSE); | |
| return _g_file_attribute_value_get_boolean (value); | |
| } | |
| /** | |
| * g_file_info_get_name: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the name for a file. This is guaranteed to always be set. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_NAME. | |
| * | |
| * Returns: (type filename) (not nullable): a string containing the file name. | |
| **/ | |
| const char * | |
| g_file_info_get_name (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_NAME, NULL); | |
| 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. This is guaranteed to always be set. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME. | |
| * | |
| * Returns: (not nullable): a string containing the display name. | |
| **/ | |
| const char * | |
| g_file_info_get_display_name (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME, NULL); | |
| return _g_file_attribute_value_get_string (value); | |
| } | |
| /** | |
| * g_file_info_get_edit_name: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the edit name for a file. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME. | |
| * | |
| * Returns: a string containing the edit name. | |
| **/ | |
| const char * | |
| g_file_info_get_edit_name (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME, NULL); | |
| return _g_file_attribute_value_get_string (value); | |
| } | |
| /** | |
| * g_file_info_get_icon: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the icon for a file. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_ICON. | |
| * | |
| * Returns: (nullable) (transfer none): #GIcon for the given @info. | |
| **/ | |
| GIcon * | |
| g_file_info_get_icon (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| GObject *obj; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_ICON, NULL); | |
| 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. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON. | |
| * | |
| * Returns: (nullable) (transfer none): #GIcon for the given @info. | |
| * | |
| * Since: 2.34 | |
| **/ | |
| GIcon * | |
| g_file_info_get_symbolic_icon (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| GObject *obj; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON, NULL); | |
| 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. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE. | |
| * | |
| * Returns: (nullable): a string containing the file's content type, | |
| * or %NULL if unknown. | |
| **/ | |
| const char * | |
| g_file_info_get_content_type (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE, NULL); | |
| return _g_file_attribute_value_get_string (value); | |
| } | |
| /** | |
| * g_file_info_get_size: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the file's size (in bytes). The size is retrieved through the value of | |
| * the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute and is converted | |
| * from #guint64 to #goffset before returning the result. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_SIZE. | |
| * | |
| * Returns: a #goffset containing the file's size (in bytes). | |
| **/ | |
| goffset | |
| g_file_info_get_size (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), (goffset) 0); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_SIZE, (goffset) 0); | |
| 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. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_TIME_MODIFIED. If %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC is | |
| * provided it will be used too. | |
| * | |
| * Deprecated: 2.62: Use g_file_info_get_modification_date_time() instead, as | |
| * #GTimeVal is deprecated due to the year 2038 problem. | |
| **/ | |
| G_GNUC_BEGIN_IGNORE_DEPRECATIONS | |
| 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); | |
| if (G_UNLIKELY (value == NULL)) | |
| { | |
| g_critical ("GFileInfo created without " G_FILE_ATTRIBUTE_TIME_MODIFIED); | |
| result->tv_sec = result->tv_usec = 0; | |
| g_return_if_reached (); | |
| } | |
| 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_GNUC_END_IGNORE_DEPRECATIONS | |
| /** | |
| * g_file_info_get_modification_date_time: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the modification time of the current @info and returns it as a | |
| * #GDateTime. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_TIME_MODIFIED. If %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC is | |
| * provided, the resulting #GDateTime will additionally have microsecond | |
| * precision. | |
| * | |
| * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC must | |
| * be queried separately using g_file_info_get_attribute_uint32(). | |
| * | |
| * Returns: (transfer full) (nullable): modification time, or %NULL if unknown | |
| * Since: 2.62 | |
| */ | |
| GDateTime * | |
| g_file_info_get_modification_date_time (GFileInfo *info) | |
| { | |
| static guint32 attr_mtime = 0, attr_mtime_usec; | |
| GFileAttributeValue *value, *value_usec; | |
| GDateTime *dt = NULL, *dt2 = NULL; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), 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); | |
| if (value == NULL) | |
| return NULL; | |
| dt = g_date_time_new_from_unix_utc (_g_file_attribute_value_get_uint64 (value)); | |
| value_usec = g_file_info_find_value (info, attr_mtime_usec); | |
| if (value_usec == NULL) | |
| return g_steal_pointer (&dt); | |
| dt2 = g_date_time_add (dt, _g_file_attribute_value_get_uint32 (value_usec)); | |
| g_date_time_unref (dt); | |
| return g_steal_pointer (&dt2); | |
| } | |
| /** | |
| * g_file_info_get_access_date_time: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the access time of the current @info and returns it as a | |
| * #GDateTime. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_TIME_ACCESS. If %G_FILE_ATTRIBUTE_TIME_ACCESS_USEC is | |
| * provided, the resulting #GDateTime will additionally have microsecond | |
| * precision. | |
| * | |
| * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_ACCESS_NSEC must | |
| * be queried separately using g_file_info_get_attribute_uint32(). | |
| * | |
| * Returns: (transfer full) (nullable): access time, or %NULL if unknown | |
| * Since: 2.70 | |
| */ | |
| GDateTime * | |
| g_file_info_get_access_date_time (GFileInfo *info) | |
| { | |
| static guint32 attr_atime = 0, attr_atime_usec; | |
| GFileAttributeValue *value, *value_usec; | |
| GDateTime *dt = NULL, *dt2 = NULL; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| if (attr_atime == 0) | |
| { | |
| attr_atime = lookup_attribute (G_FILE_ATTRIBUTE_TIME_ACCESS); | |
| attr_atime_usec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_ACCESS_USEC); | |
| } | |
| value = g_file_info_find_value (info, attr_atime); | |
| if (value == NULL) | |
| return NULL; | |
| dt = g_date_time_new_from_unix_utc (_g_file_attribute_value_get_uint64 (value)); | |
| value_usec = g_file_info_find_value (info, attr_atime_usec); | |
| if (value_usec == NULL) | |
| return g_steal_pointer (&dt); | |
| dt2 = g_date_time_add (dt, _g_file_attribute_value_get_uint32 (value_usec)); | |
| g_date_time_unref (dt); | |
| return g_steal_pointer (&dt2); | |
| } | |
| /** | |
| * g_file_info_get_creation_date_time: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the creation time of the current @info and returns it as a | |
| * #GDateTime. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_TIME_CREATED. If %G_FILE_ATTRIBUTE_TIME_CREATED_USEC is | |
| * provided, the resulting #GDateTime will additionally have microsecond | |
| * precision. | |
| * | |
| * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_CREATED_NSEC must | |
| * be queried separately using g_file_info_get_attribute_uint32(). | |
| * | |
| * Returns: (transfer full) (nullable): creation time, or %NULL if unknown | |
| * Since: 2.70 | |
| */ | |
| GDateTime * | |
| g_file_info_get_creation_date_time (GFileInfo *info) | |
| { | |
| static guint32 attr_ctime = 0, attr_ctime_usec; | |
| GFileAttributeValue *value, *value_usec; | |
| GDateTime *dt = NULL, *dt2 = NULL; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| if (attr_ctime == 0) | |
| { | |
| attr_ctime = lookup_attribute (G_FILE_ATTRIBUTE_TIME_CREATED); | |
| attr_ctime_usec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_CREATED_USEC); | |
| } | |
| value = g_file_info_find_value (info, attr_ctime); | |
| if (value == NULL) | |
| return NULL; | |
| dt = g_date_time_new_from_unix_utc (_g_file_attribute_value_get_uint64 (value)); | |
| value_usec = g_file_info_find_value (info, attr_ctime_usec); | |
| if (value_usec == NULL) | |
| return g_steal_pointer (&dt); | |
| dt2 = g_date_time_add (dt, _g_file_attribute_value_get_uint32 (value_usec)); | |
| g_date_time_unref (dt); | |
| return g_steal_pointer (&dt2); | |
| } | |
| /** | |
| * g_file_info_get_symlink_target: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the symlink target for a given #GFileInfo. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET. | |
| * | |
| * Returns: (type filename) (nullable): a string containing the symlink target. | |
| **/ | |
| const char * | |
| g_file_info_get_symlink_target (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET, NULL); | |
| return _g_file_attribute_value_get_byte_string (value); | |
| } | |
| /** | |
| * g_file_info_get_etag: | |
| * @info: a #GFileInfo. | |
| * | |
| * Gets the [entity tag](iface.File.html#entity-tags) for a given | |
| * #GFileInfo. See %G_FILE_ATTRIBUTE_ETAG_VALUE. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %G_FILE_ATTRIBUTE_ETAG_VALUE. | |
| * | |
| * Returns: (nullable): a string containing the value of the "etag:value" attribute. | |
| **/ | |
| const char * | |
| g_file_info_get_etag (GFileInfo *info) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), NULL); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_ETAG_VALUE, NULL); | |
| 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. | |
| * | |
| * It is an error to call this if the #GFileInfo does not contain | |
| * %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) | |
| { | |
| GFileAttributeValue *value; | |
| g_return_val_if_fail (G_IS_FILE_INFO (info), 0); | |
| get_required_attribute (&value, info, G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER, 0); | |
| 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 and | |
| * %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the | |
| * given time value. | |
| * | |
| * %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC will be cleared. | |
| * | |
| * Deprecated: 2.62: Use g_file_info_set_modification_date_time() instead, as | |
| * #GTimeVal is deprecated due to the year 2038 problem. | |
| **/ | |
| G_GNUC_BEGIN_IGNORE_DEPRECATIONS | |
| void | |
| g_file_info_set_modification_time (GFileInfo *info, | |
| GTimeVal *mtime) | |
| { | |
| static guint32 attr_mtime = 0, attr_mtime_usec = 0, attr_mtime_nsec = 0; | |
| 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); | |
| attr_mtime_nsec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC); | |
| } | |
| 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); | |
| /* nsecs can’t be known from a #GTimeVal, so remove them */ | |
| g_file_info_remove_value (info, attr_mtime_nsec); | |
| } | |
| G_GNUC_END_IGNORE_DEPRECATIONS | |
| /** | |
| * g_file_info_set_modification_date_time: | |
| * @info: a #GFileInfo. | |
| * @mtime: (not nullable): a #GDateTime. | |
| * | |
| * Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED and | |
| * %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the | |
| * given date/time value. | |
| * | |
| * %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC will be cleared. | |
| * | |
| * Since: 2.62 | |
| */ | |
| void | |
| g_file_info_set_modification_date_time (GFileInfo *info, | |
| GDateTime *mtime) | |
| { | |
| static guint32 attr_mtime = 0, attr_mtime_usec = 0, attr_mtime_nsec = 0; | |
| 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); | |
| attr_mtime_nsec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC); | |
| } | |
| value = g_file_info_create_value (info, attr_mtime); | |
| if (value) | |
| _g_file_attribute_value_set_uint64 (value, g_date_time_to_unix (mtime)); | |
| value = g_file_info_create_value (info, attr_mtime_usec); | |
| if (value) | |
| _g_file_attribute_value_set_uint32 (value, g_date_time_get_microsecond (mtime)); | |
| /* nsecs can’t be known from a #GDateTime, so remove them */ | |
| g_file_info_remove_value (info, attr_mtime_nsec); | |
| } | |
| /** | |
| * g_file_info_set_access_date_time: | |
| * @info: a #GFileInfo. | |
| * @atime: (not nullable): a #GDateTime. | |
| * | |
| * Sets the %G_FILE_ATTRIBUTE_TIME_ACCESS and | |
| * %G_FILE_ATTRIBUTE_TIME_ACCESS_USEC attributes in the file info to the | |
| * given date/time value. | |
| * | |
| * %G_FILE_ATTRIBUTE_TIME_ACCESS_NSEC will be cleared. | |
| * | |
| * Since: 2.70 | |
| */ | |
| void | |
| g_file_info_set_access_date_time (GFileInfo *info, | |
| GDateTime *atime) | |
| { | |
| static guint32 attr_atime = 0, attr_atime_usec = 0, attr_atime_nsec = 0; | |
| GFileAttributeValue *value; | |
| g_return_if_fail (G_IS_FILE_INFO (info)); | |
| g_return_if_fail (atime != NULL); | |
| if (attr_atime == 0) | |
| { | |
| attr_atime = lookup_attribute (G_FILE_ATTRIBUTE_TIME_ACCESS); | |
| attr_atime_usec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_ACCESS_USEC); | |
| attr_atime_nsec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_ACCESS_NSEC); | |
| } | |
| value = g_file_info_create_value (info, attr_atime); | |
| if (value) | |
| _g_file_attribute_value_set_uint64 (value, g_date_time_to_unix (atime)); | |
| value = g_file_info_create_value (info, attr_atime_usec); | |
| if (value) | |
| _g_file_attribute_value_set_uint32 (value, g_date_time_get_microsecond (atime)); | |
| /* nsecs can’t be known from a #GDateTime, so remove them */ | |
| g_file_info_remove_value (info, attr_atime_nsec); | |
| } | |
| /** | |
| * g_file_info_set_creation_date_time: | |
| * @info: a #GFileInfo. | |
| * @creation_time: (not nullable): a #GDateTime. | |
| * | |
| * Sets the %G_FILE_ATTRIBUTE_TIME_CREATED and | |
| * %G_FILE_ATTRIBUTE_TIME_CREATED_USEC attributes in the file info to the | |
| * given date/time value. | |
| * | |
| * %G_FILE_ATTRIBUTE_TIME_CREATED_NSEC will be cleared. | |
| * | |
| * Since: 2.70 | |
| */ | |
| void | |
| g_file_info_set_creation_date_time (GFileInfo *info, | |
| GDateTime *creation_time) | |
| { | |
| static guint32 attr_ctime = 0, attr_ctime_usec = 0, attr_ctime_nsec = 0; | |
| GFileAttributeValue *value; | |
| g_return_if_fail (G_IS_FILE_INFO (info)); | |
| g_return_if_fail (creation_time != NULL); | |
| if (attr_ctime == 0) | |
| { | |
| attr_ctime = lookup_attribute (G_FILE_ATTRIBUTE_TIME_CREATED); | |
| attr_ctime_usec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_CREATED_USEC); | |
| attr_ctime_nsec = lookup_attribute (G_FILE_ATTRIBUTE_TIME_CREATED_NSEC); | |
| } | |
| value = g_file_info_create_value (info, attr_ctime); | |
| if (value) | |
| _g_file_attribute_value_set_uint64 (value, g_date_time_to_unix (creation_time)); | |
| value = g_file_info_create_value (info, attr_ctime_usec); | |
| if (value) | |
| _g_file_attribute_value_set_uint32 (value, g_date_time_get_microsecond (creation_time)); | |
| /* nsecs can’t be known from a #GDateTime, so remove them */ | |
| g_file_info_remove_value (info, attr_ctime_nsec); | |
| } | |
| /** | |
| * g_file_info_set_symlink_target: | |
| * @info: a #GFileInfo. | |
| * @symlink_target: (type filename): 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; | |
| /* Iterator */ | |
| 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 @attributes 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: (nullable): Matcher to subtract from | |
| * @subtract: (nullable): 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: (nullable): 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 an 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; | |
| guint 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; | |
| guint ns_id; | |
| guint 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: (nullable): a string containing the next attribute or, %NULL if | |
| * no more attribute exist. | |
| **/ | |
| const char * | |
| g_file_attribute_matcher_enumerate_next (GFileAttributeMatcher *matcher) | |
| { | |
| guint 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); | |
| } |